import  java.lang.*;
 import  java.lang.reflect.*;
 import  java.util.Hashtable;
 import  java.sql.*;
 import  java.io.*;
 import  org.postgresql.largeobject.*;
 import  org.postgresql.util.*;
 import  org.postgresql.ds.*;
 import  java.net.*;
 import  javax.naming.*;
 import  javax.sql.*;
 import  java.util.*;

/**
 *
 * @author yr
 */
 public   class  sqlClassLoader  extends  ClassLoader{
    
    /** Creates a new instance of sqlClassLoader */
     Hashtable cache =  new  Hashtable();
 
   private  ClassLoader parent =  null ;
   private   Boolean  initialized = false; 
   static   private  Connection conn =  null ;
   private  InitialContext ic =  null ; 
   private  PGPoolingDataSource source =  null ;
   private   Boolean  setcon = false;
 
   public  sqlClassLoader(ClassLoader parent){
   
     super (parent);
     this .parent = parent;
    Properties envl =  new  Properties();
     try {
        
      envl.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory");
      envl.setProperty( Context.PROVIDER_URL,"file:" +  new  File(".").getAbsolutePath());     
      ic =  new  InitialContext(envl);
       new  org.postgresql.ds.common.PGObjectFactory();
      ic.list("Data");
      
    } catch  (NamingException e) {
             
    }
   
 }
 
  /**
   * Обращение к базе данных
   * @param name
   * @return */
     private   byte [] loadClassData(String name) {
   
     if  (conn ==  null )
         return   null ;
     try  {
       byte  result[] =  null ;
      conn.setAutoCommit(false);
      LargeObjectManager lobj = ((org.postgresql.PGConnection)conn).getLargeObjectAPI();
      PreparedStatement stmt =
 	 conn.prepareStatement("SELECT object_data FROM client_object WHERE object_name = ?");
         
      stmt.setString( 1 , name);
  
       try {
      ResultSet rs = stmt.executeQuery();
      
       if  (rs.next()){
         int  oid =  0 ;        
        oid = rs.getInt( 1 );
        LargeObject obj = lobj.open(oid, LargeObjectManager.READ);       
        result =  new   byte [obj.size()];
        obj.read(result,  0 , obj.size());        
        obj.close();
        
      }   
      rs.close();
      } catch  (PSQLException e){
         return   null ;
      }
      stmt.close();
      
       return  result;
    }  catch  (SQLException e) {
      e.printStackTrace();
   }
   return   null ;

}

  /**
   * Получить класс из базы данных
   * @param name
   * @return * @throws ClassNotFoundException
   */
   public   Class  loadClass(String name)  throws  ClassNotFoundException  {
      
       return   this .findClass(name);
       
    
  }
   public   synchronized   Class  findClass(String name)  throws  ClassNotFoundException {
     // Получить класс из кэша
   System.out.println(name);
   Object dd =  null ;
    Boolean  s = false;  
    Class  c; 
    try  {           
      dd =  ic.lookup("Data");
       if  (conn !=  null ) {
        s = true;      
      }    
    } catch  (NamingException e) {      
    }
    if  (!s){
   
     c = ( Class ) cache.get(name);
       
      if  (c !=  null ){
          return  c;
     } 
   } 
 
   if  (conn ==  null  || s){
     try  {           
      setcon = true;

      dd =  ic.lookup("Data");  
      ic.unbind("Data");
      cache.clear();
      DataSource source = (DataSource) dd;
      conn = source.getConnection();

    } catch  (NamingException e) {      
    } catch  (SQLException e){   
    }          
  }
  
      byte [] data = loadClassData(name);
       
      if  (data ==  null ) {      
         Class  clazz =  null ;
         try  {    
            String pathName =  name.replace( '.', File.separatorChar ) + ".class";
            pathName =   new  File(".").getAbsolutePath().replace("\\.", "\\build\\classes\\") + pathName;         
            File fl =  new  File(pathName);             
            FileInputStream inFile =  new  FileInputStream( fl );         
             byte [] classBytes =  new   byte [ inFile.available()];
            inFile.read( classBytes );
           
            c = defineClass( name, classBytes,  0 , classBytes.length );
            cache.put(name, c);        
        }  catch  ( java.io.IOException ioEx ) {        
            c =  Class .forName(name);
            cache.put(name, c);         
        }
      
         return  c;
    
       
     }  else  {
      // Класс обнаружен       
      c = defineClass(name, data,  0 , data.length);    
      cache.put(name, c);
       return  c;
    }
  
 
  }
   
  
      static  {
 
          conn =  null ;
          
     }
}

  try {
         Method lc = ClassLoader.getSystemClassLoader().getClass().getMethod("loadClass", pr);  
         lc.invoke(ClassLoader.getSystemClassLoader(), "Wellcome");
         Method ri = ClassLoader.getSystemClassLoader().getClass().getMethod("reInit",  null );  
         ri.invoke(ClassLoader.getSystemClassLoader());        
          Wellcome a =  new  Wellcome();
          a.Wellcome_run();       
      
       } catch (NoSuchMethodException e){
          e.printStackTrace();   
       } catch (IllegalAccessException e){
          e.printStackTrace(); 
       } catch (InvocationTargetException e){
          e.printStackTrace(); 
       } 

ClassLoader cl = ClassLoader.getSystemClassLoader();
Object dd = cl.loadClass("uakievhrm.StartWindow").newInstance();
StartWindow a = (StartWindow)dd;