java 按照条件动态添加注解 java代码动态注入

转载

mob64ca14017c37 2024-03-12 10:40:40

文章标签 java 按照条件动态添加注解 java c/c++ 数据结构与算法初始化 文章分类 Java 后端开发

一直以来反射都是只闻其声，却无法将之使用，近日尽心下来学习下，发现了很多精妙之处。

Java动态装载和反射技术

一、类的动态装载

1.Java代码编译和执行的整个过程包含了以下三个重要的机制：

　　● Java源码编译机制：得到Class字节码
　　● 类加载机制：包括类的装载，连接，初始化三个阶段
　　● 类执行机制

2.类加载机制分为装载，连接，初始化三个阶段

（1）装载阶段：类装载器(ClassLoader) 把编译形成的class文件载入内存，创建类相关的java.lang.Class对象，这个Class对象封装了我们要使用的类的类型信息。

ClassLoader分四层，分别为Bootstrap ClassLoader，Extension ClassLoader，System ClassLoader，他们不是类继承的父子关系，是逻辑上的上下级关系。

Bootstrap ClassLoader是启动类加载器，它是用C++编写的，从%jre%/lib目录中加载类，或者运行时用-Xbootclasspath指定目录来加载。

Extension ClassLoader是扩展类加载器，从%jre%/lib/ext目录加载类，或者运行时用-Djava.ext.dirs制定目录来加载。

App ClassLoader，系统类加载器，它会从系统环境变量配置的classpath来查找路径，环境变量里的.表示当前目录，是通过运行时-classpath或-Djava.class.path指定的目录来加载类。

ClassLoader使用了双亲委托模式进行类加载。下图是ClassLoader的加载类流程图，以加载一个类的过程类示例说明整个ClassLoader的过程。

（2）连接阶段：又可以分为三个子步骤：验证、准备和解析。（纯抄，暂时也不去理解了）

验证就是要确保java类型数据格式的正确性，并适于JVM使用。

准备阶段，JVM为静态变量分配内存空间，并设置默认值，注意，这里是设置默认值，比如说int型的变量会被赋予默认值0 。在这个阶段，JVM可能还会为一些数据结构分配内存，目的是提高运行程序的性能，比如说方法表。

解析过程就是在类型的常量池中寻找类、接口、字段和方法的符号引用，把这些符号引用替换成直接引用。这个阶段可以被推迟到初始化之后，当程序运行的过程中真正使用某个符号引用的时候再去解析它

（3）初始化阶段：

类会在首次被“主动使用”时执行初始化，为类（静态）变量赋予正确的初始值。在Java代码中，一个正确的初始值是通过类变量初始化语句或者静态初始化块给出的。而我们这里所说的主动使用包括：

a. 创建类的实例

b. 调用类的静态方法

c. 使用类的非常量静态字段

d. 调用Java API中的某些反射方法

e. 初始化某个类的子类

f. 含有main()方法的类启动时

初始化一个类包括两个步骤：

1、如果类存在直接父类的话，且直接父类还没有被初始化，则先初始化其直接父类

2、如果类存在一个初始化方法，就执行此方法

注：初始化接口并不需要初始化它的父接口。

问题

我们加载一个类的时候，很多时候可以使用Class.forname，也可以使用ClassLoader.loadClass，这两者有什么区别呢？

Class.forname的两个重载方法

1 public static Class<?> forName(String name, boolean initialize,
2 ClassLoader loader)
3 throws ClassNotFoundException
4 
5 
6 public static Class<?> forName(String className) 
7 throws ClassNotFoundException

ClassLoader.loadClass的两个重载方法

1 protected synchronized Class<?> loadClass(String name, boolean resolve)
2     throws ClassNotFoundException
3 
4 public Class<?> loadClass(String name) throws ClassNotFoundException

二者的区别（结论）：

1.Class.forName返回的Class对象可以决定是否初始化，默认会初始化。而ClassLoader.loadClass返回的类型绝对不会初始化，最多只会做连接操作。
2.Class.forName可以决定由哪个classLoader来请求这个类型，默认使用当前类的ClassLoader。而ClassLoader.loadClass是用确定的当前classLoader去请求。

二、反射

我们知道利用类加载机制可以动态加载Class，这样我们就可以通过class.forName或者ClassLoader.loadClass获得任何一个Class的Class<?>对象。

利用这个Class<?>对象，我们可以将这个Class反射出来。

下面的例子，使用getSystemClassLoader，Load出String的Class<?>，在DumpClassInfo类中，把String类中的inferface,superClass,filed,method等都获取出来。

1         ClassLoader loader =  ClassLoader.getSystemClassLoader();
2 
3         Class<?> cls = loader.loadClass("java.lang.String");
4         
5         DumpClassInfo.dump(cls, System.out);

1 package com.sgpro._01_classloader;
  2 
  3 import java.io.IOException;
  4 import java.io.OutputStream;
  5 import java.lang.annotation.Annotation;
  6 import java.lang.reflect.Constructor;
  7 import java.lang.reflect.Field; 8 import java.lang.reflect.Method; 9 import java.lang.reflect.Modifier; 10 11 public class DumpClassInfo { 12 13 private static String dumppAnnotation(Annotation[] ann) { 14 StringBuffer ans = new StringBuffer(); 15 if (ann != null) { 16 for (Annotation a : ann) { 17 if (ans.length() != 0) { 18 ans.append(","); 19  } 20  ans.append(a.toString()); 21  } 22  } 23 return ans.length() == 0? "" : "/**\r\n" + ans.toString() + "*/\r\n"; 24  } 25 26 public static void dump(Class<?> cls, OutputStream os) { 27 28 StringBuffer iStr = new StringBuffer(); //interface 29 StringBuffer fStr = new StringBuffer(); //Field 30 StringBuffer cStr = new StringBuffer(); //Constructor 31 StringBuffer mStr = new StringBuffer(); //Method 32 33 StringBuffer paramTypes = new StringBuffer(); //param 34 StringBuffer exceptionTypes = new StringBuffer(); //exception 35 36 /** 37 * 所有声明的属性 38 */ 39 for (Field f : cls.getDeclaredFields()) { 40  fStr.append( 41 String.format("%s\t%s %s %s;\r\n", 42 dumppAnnotation(f.getDeclaredAnnotations())//注释 43 , Modifier.toString(f.getModifiers()) //修饰符 public private protected 44 , f.getType().getSimpleName() //类型 integer String 等 45 // , f.getGenericType() == null? "" : "<" + f.getGenericType() + ">" 46 , f.getName())); //字段名 47  } 48 49 /** 50 * 所有的构造方法 51 */ 52 for (Constructor<?> c : cls.getConstructors()) { 53 paramTypes.setLength(0); 54 exceptionTypes.setLength(0); 55 56 for (Class<?> p: c.getParameterTypes()) { 57 if (paramTypes.length() != 0) { 58 paramTypes.append(", "); 59  } 60  paramTypes.append(p.getSimpleName()); 61  } 62 63 for (Class<?> e: c.getExceptionTypes()) { 64 if (exceptionTypes.length() != 0) { 65 exceptionTypes.append(", "); 66  } 67  exceptionTypes.append(e.getSimpleName()); 68  } 69 70  cStr.append( 71 String.format("%s\t%s %s (%s ) %s %s \r\n" 72  , dumppAnnotation(c.getDeclaredAnnotations()) 73  , Modifier.toString(c.getModifiers()) 74  , c.getDeclaringClass().getSimpleName() 75  , paramTypes 76 , exceptionTypes.length() > 0? "throws" : "" 77  , exceptionTypes)); 78 79  } 80 81 /** 82 * 所有声明的方法 83 */ 84 for (Method m : cls.getDeclaredMethods()) { 85 paramTypes.setLength(0); 86 exceptionTypes.setLength(0); 87 88 for (Class<?> c: m.getParameterTypes()) { 89 if (paramTypes.length() != 0) { 90 paramTypes.append(", "); 91  } 92  paramTypes.append(c.getSimpleName()); 93  } 94 95 for (Class<?> c: m.getExceptionTypes()) { 96 if (exceptionTypes.length() != 0) { 97 exceptionTypes.append(", "); 98  } 99  exceptionTypes.append(c.getSimpleName()); 100  } 101 102  mStr.append( 103 String.format("%s,\t%s %s %s (%s ) %s %s \r\n" 104  , dumppAnnotation(m.getDeclaredAnnotations()) 105  , Modifier.toString(m.getModifiers()) 106  , m.getReturnType().getSimpleName() 107  , m.getName() 108  , paramTypes 109 , exceptionTypes.length() > 0? "throws" : "" 110  , exceptionTypes)); 111 112  } 113 114 /** 115 * interface获取 116 */ 117 for (Class<?> intf : cls.getInterfaces()) { 118 if (iStr.length() != 0 ) { 119 iStr.append(", "); 120  } 121  iStr.append(intf.getSimpleName()); 122  } 123 124 125 /** 126 * superClass 127 */ 128 Class<?> supcls = cls.getSuperclass(); 129 130 131 String dc = String.format("%s %s %s %s %s {\r\n%s\r\n%s\r\n%s\r\n}\r\n" 132  , dumppAnnotation(cls.getDeclaredAnnotations()) 133  , Modifier.toString(cls.getModifiers()) 134  , cls.getSimpleName() 135 , supcls == Object.class? "" : "extends " + supcls.getSimpleName() 136 , iStr.length() == 0? "" : " implements " + iStr.toString() 137 , fStr.length() == 0? "" : fStr.toString() 138  , cStr.toString() 139 , mStr.length() == 0? "" : mStr.toString() 140  ); 141 142 try { 143  os.write(dc.getBytes()); 144 } catch (IOException e) { 145 // TODO Auto-generated catch block 146  e.printStackTrace(); 147  } 148 } 149 150 } 151

从以上例子可以得知，利用发射技术，我们可以没有看到源码，仅有Class的情况下，获取所有此Class的信息。

上面我们是使用的getSystemClassLoader，下面我们使用一个自定义的InternetClassLoader，此ClassLoader实现利用http从网上去加载一个Class

1 package com.sgpro._01_classloader;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.ByteArrayOutputStream;
 5 import java.io.IOException;
 6 import java.net.HttpURLConnection;
 7 import java.net.URL; 8 9 public class InternetClassLoader extends ClassLoader { 10 11 public String getDomain() { 12 return domain; 13  } 14 15 public void setDomain(String domain) { 16 this.domain = domain; 17  } 18 public InternetClassLoader(String domain) { 19 super(); 20 this.domain = domain; 21  } 22 private String domain = "http://192.168.30.170/JavaClassPool/"; 23 public InternetClassLoader() { 24 // TODO Auto-generated constructor stub 25  } 26 27 public InternetClassLoader(ClassLoader parent) { 28 super(parent); 29 // TODO Auto-generated constructor stub 30  } 31 32 public byte [] downloadClass(String name) { 33 byte [] data = null ; 34 35 if (name == null ) { 36 throw new IllegalArgumentException("参数有误！类名为空"); 37  } 38 39 try { 40 BufferedInputStream bis = null; 41 HttpURLConnection httpUrl = null; 42 URL url = null; 43 byte[] buf = new byte[4096]; 44 45 // 建立链接 46 47 String[] packagePath = name.split("\\."); 48 String clsName = packagePath.length > 0? packagePath[packagePath.length - 1] : name; 49 50 url = new URL(domain + clsName + ".class"); 51 httpUrl = (HttpURLConnection) url.openConnection(); 52 httpUrl.setRequestProperty("Accept", "*/*"); 53 // 连接指定的资源 54  httpUrl.connect(); 55 // 获取网络输入流 56 bis = new BufferedInputStream(httpUrl.getInputStream()); 57 ByteArrayOutputStream bos = new ByteArrayOutputStream(); 58 59 int size = 0; 60 while ((size = bis.read(buf)) != -1) { 61 bos.write(buf, 0, size); 62  } 63 64  bos.close(); 65  bis.close(); 66  httpUrl.disconnect(); 67 68 return bos.toByteArray(); 69 } catch (IOException e) { 70  e.printStackTrace(); 71  } 72 73 return data; 74  } 75  @Override 76 protected Class<?> findClass(String name) throws ClassNotFoundException { 77 Class<?> ret = null; 78 byte[] data = downloadClass(name); 79 80 try { 81 if (data == null) { 82 throw new Exception("字节码无法获取"); 83  } 84 ret = defineClass(name, data, 0, data.length); 85 } catch (Exception ex) { 86 System.err.println("找不到类" + name + "详细：" + ex.getMessage()); 87 throw new ClassNotFoundException("无法加载远程类", ex); 88  } 89 90 return ret; 91  } 92 93 }

1         loader =   new InternetClassLoader();
2         cls = loader.loadClass("_05_Generic.Country");
3 
4         DumpClassInfo.dump(cls, System.out);

我们可以看到，自定义一个ClassLoader需要继承ClassLoader类以及实现findClass的方法。InternetClassLoader中的findClass放，我们按照提供的类名去http服务器中请求获得.class文件，再通过defineClass方法()最终获得Class<?>类。

然后，我们可以使用得到Class<？>类，进行实例化，并执行对象的方法

1         o = cls.newInstance();
2 
3         o.getClass().getMethod("setName", String.class).invoke(o, "中国");
4         o.getClass().getMethod("getName").invoke(o);
5         
6         System.out.println(o.toString());

三、反射的应用

四、内省机制和javabean

参考资料：

sgpro的java学习例子

http://daizuan.iteye.com/blog/1097105 Class.forName与ClassLoader

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。