사용자 정의 클래스 로 더 를 통 해 동적 컴 파일 과 동적 구현 인터페이스

두 가지 동적 로드 방법
1.       java. lang. Class. forName (fullClassName) 을 사용 합 니 다.
2.       사용자 정의 클래스 로 더 를 사용 합 니 다.
자바 류 로 딩 을 사용자 정의 로 불 러 오 는 방법 을 보 여 줍 니 다.
 
기본적으로 사용 하 는 클래스 로 더 를 통 해 클래스 를 불 러 옵 니 다. 일반적으로 다음 과 같은 방법 을 사용 합 니 다.
 

  
  
  
  
  1. Class obj = aLoader.loadClass(customFullClassName, true); 

 
loadclass 방법의 실현 을 보십시오.
 

  
  
  
  
  1. protected synchronized Class<?> loadClass(String name, boolean resolve) 
  2.     throws ClassNotFoundException 
  3.     { 
  4.     Class c = findLoadedClass(name); 
  5.     …………… 
  6. ……… 

이것 은 부모 위임 체 제 를 이용 한 실현 이다. 가장 중요 한 것 은 find Loaded Class 방법 이 고 다른 것 은 아버 지 를 찾 는 것 이다.
그래서 사용자 정의 확장 을 하려 면 이 방법 부터 시작 해 야 합 니 다.
findLoadClass 의 기본 값 은 다음 과 같 습 니 다.
여기 서 우 리 는 가장 흥미 로 운 방법 을 보 았 다. define Class
protected final Class defineClass(String name, byte[] b, int off, int len);
이 방법 은 바이트 데 이 터 를 Class 로 변환 하고 초기 화 합 니 다.
물론 바 꿀 수 없다 면 이상: ClassFormatterror.
 
그래서 우 리 는 파일 시스템 에서 임의의 합 법 적 인 파일 을 자 유 롭 게 불 러 올 생각 을 하 게 되 었 다.
클래스 계승 ClassLoader - 파일 시스템 의 *. class 파일 을 byte [] 방식 으로 전송 - defineClass 처리 에 맡 깁 니 다. 이러한 방법 은 자바 의 부모 위임 을 파괴 한 것 같 습 니 다.
그래서 클래스 정 의 는 다음 과 같다.
 

  
  
  
  
  1. /** 
  2.  *  . 
  3.  * @author nileader 
  4.  */ 
  5. public class CustomClassLoader extends ClassLoader { 
  6.  
  7.     public static final String classPath = System.getProperty("user.dir") + "\\bin\\"
  8.  
  9.     /** 
  10.      *  , Java  
  11.      * @param classFullName 
  12.      * @return 
  13.      */ 
  14.     protected Class customLoadClass(String classFullName){ 
  15.         String filePath = classFullName2FileName(classFullName, classPath); 
  16.         byte[] data = loadClassFromFS(filePath ); 
  17.         // defineClass . 
  18.         return defineClass(classFullName, data, 0, data.length); 
  19.     } 
  20.  
  21.     /** 
  22.      *  , byte[]. 
  23.      * @param name     
  24.      * @return     
  25.      */ 
  26.     private byte[] loadClassFromFS(String filePath) { 
  27.         FileInputStream fis = null
  28.         byte[] byteSource = null
  29.         try { 
  30.             fis = new FileInputStream(new File(filePath ) ); 
  31.             ByteArrayOutputStream tempSource = new ByteArrayOutputStream(); 
  32.             int readChar= 0
  33.             while ((readChar = fis.read()) != -1) { 
  34.                 tempSource.write(readChar ); 
  35.             } 
  36.             byteSource = tempSource.toByteArray(); 
  37.         } catch (IOException e) { 
  38.             //IO  
  39.         } 
  40.         return byteSource; 
  41.     } 
  42.      
  43.     /** 
  44.      *  classpath . 
  45.      * @param classFullName       
  46.      * @param classPath           
  47.      * @return 
  48.      */ 
  49.     public String classFullName2FileName(String classFullName, String classPath){ 
  50.         classFullName = classFullName.replaceAll("[.]""\\\\" ); 
  51.         return classPath  + classFullName + ".class"
  52.     } 

 
이제 수 정 된 클래스 로 더 를 사용 하여 클래스 로 딩 할 수 있 습 니 다.

  
  
  
  
  1. CustomClassLoader customClassLoader = new CustomClassLoader(); 
  2.  
  3. Class obj = customClassLoader.customLoadClass("com.test.DemoInterface" ); 

불 러 온 후에 Class, Field, Method 의 일부 방법 으로 인터페이스의 '실현' 을 할 수 있 습 니 다.
방법 이 많다.
여기 서 이른바 '실현' 이란 프로그램 운영 과정 에서 의 수요 에 따라 구체 적 인 방법 으로 쓰 는 것 이다. 예 를 들 어:
동적 컴 파일
동적 컴 파일 과정 은:
임시 *. 자바 파일 을 만 들 고 com. sun. tools. javac. Main 을 사용 하여 명령 행 의 자바 파일 컴 파일 을 모 의 합 니 다.
 
 
 

  
  
  
  
  1. /** 
  2.      *  Java . 
  3.      *  
  4.      * @param sourceCode 
  5.      *             Java  
  6.      * @throws Exception 
  7.      */ 
  8.     public static boolean compile(String sourceCode, String className) { 
  9.         File file = null
  10.         //  *.java . 
  11.         try { 
  12.             file = File.createTempFile("JavaRuntime"".java"new File( 
  13.                     targetPath)); 
  14.         } catch (IOException e) { 
  15.             //  IO  
  16.         } 
  17.         String fileName = null
  18.         if (null != file) { 
  19.             //   
  20.             fileName = file.getName(); 
  21.             file.deleteOnExit(); 
  22.         } 
  23.  
  24.         //  java . 
  25.         PrintWriter out = null
  26.         try { 
  27.             out = new PrintWriter(new FileOutputStream(file)); 
  28.         } catch (FileNotFoundException e) { 
  29.             //   FileNotFoundException  . 
  30.         } 
  31.         if (null != out) { 
  32.             out.write(sourceCode); 
  33.             out.flush(); 
  34.             out.close(); 
  35.         } 
  36.  
  37.         /**   */ 
  38.         if (fileName != null) { 
  39.             Main.compile(new String[] { "-d"
  40.                     System.getProperty("user.dir") + "\\bin\\"
  41.                     targetPath + fileName }); 
  42.         } 
  43.  
  44.         return true
  45.  
  46.     } 

생 성 된 후에 같은 방식 으로 클래스 의 로드 를 실현 할 수 있 습 니 다. 다음 과 같은 방식 으로 진행 할 수 있 습 니 다.

  
  
  
  
  1. Class c1 = customClassLoader.customLoadClass(implementsFullName); 
  2.         Constructor con = c1.getDeclaredConstructor(); 
  3.         con.setAccessible(true ); 
  4.         Object o = con.newInstance(); 
  5.         //  bean  
  6.         Method method = c1.getMethod("print"); 
  7.         method.setAccessible(true); 
  8.         method.invoke(o); 

좋은 웹페이지 즐겨찾기