反射离不开Class.forName(),我们先从Class.forName说起。
上一篇我们说要得到一个类的实例有4个方法：new，反射，克隆，反序列化。
反射可以跟new一个对象有相同的效果。例如
public class Company { private String a; private String b; @Override public String toString() { return "Company{" + "a='" + a + '\'' + ", b='" + b + '\'' + '}'; } public Company() { this.a = "A"; this.b = "B"; } }
public class CompanyInstance { private static Company company = new Company(); public static void main(String[] args) { System.out.println(company); } }
运行结果
Company{a='A', b='B'}
又可以写成如下
public class CompanyInstance { public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException { System.out.println(Class.forName("com.guanjian.Company").newInstance()); } }
运行结果
Company{a='A', b='B'}
虽然效果一样，但他们的过程并不一样。 首先，newInstance( )是一个方法，而new是一个关键字；其次，Class下的newInstance()的使用有局限，因为它生成对象只能调用无参的构造函数，而使用 new关键字生成对象没有这个限制。
newInstance()的时候是使用的上篇说的类装载机制的，它会走完全部过程。具体可以看 浅析类装载 ，而new一个实例的时候，走的流程不太一样，它会先在JVM内部先去寻找该类的Class实例，然后依照该Class实例的定义，依葫芦画瓢，把该类的实例给生成出来。但如果找不到该类的Class实例，则会走上篇说的装载流程。 其中JDK的Class实例一般是在jvm启动时用启动类加载器完成加载，用户的Class实例则是在用到的时候再加载。
Class.forName()被重载为有一个参数和三个参数的，我们来看一下其源码
@CallerSensitive public static Class<?> forName(String className) throws ClassNotFoundException { Class<?> caller = Reflection.getCallerClass(); return forName0(className, true, ClassLoader.getClassLoader(caller), caller); }
@CallerSensitive public static Class<?> forName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException { Class<?> caller = null; SecurityManager sm = System.getSecurityManager(); if (sm != null) { // Reflective call to get caller class is only needed if a security manager // is present. Avoid the overhead of making this call otherwise. caller = Reflection.getCallerClass(); if (sun.misc.VM.isSystemDomainLoader(loader)) { ClassLoader ccl = ClassLoader.getClassLoader(caller); if (!sun.misc.VM.isSystemDomainLoader(ccl)) { sm.checkPermission( SecurityConstants.GET_CLASSLOADER_PERMISSION); } } } return forName0(name, initialize, loader, caller); }
其中Reflection.getCallerClass()源码如下
@CallerSensitive public static native Class<?> getCallerClass();
这是一个跟C语言交互的，用户无权限调用的方法，只能被 bootstrap class loader 和 extension class loader 调用的，这两个加载类后面再说。意思是返回调用者的Class实例。
private static native Class<?> forName0(String name, boolean initialize, ClassLoader loader, Class<?> caller) throws ClassNotFoundException;
它的第二个参数boolean initialize表示是否要初始化该类，单参Class.forName()默认true是要初始化的，三参的Class.forName()由你自己选择。一旦初始化，就会触发目标对象的 static块代码执行，static参数也也会被再次初始化。当然如果你使用了三个参数的Class.forName(),并调用了newInstance()以后，是肯定会初始化的。
public class CompanyInstance { public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException { System.out.println(Class.forName("com.guanjian.Company",false,Thread.currentThread().getContextClassLoader()).newInstance()); } }
运行结果
Company{a='A', b='B'}
现在我们重点要说的是它的ClassLoader，这个才是真正装载类的核心组件。所有的Class都是由ClassLoader进行加载的，ClassLoader负责通过各种方式将Class信息的二进制字节码数据流读入系统，然后交给JVM虚拟机进行连接、初始化等操作。ClassLoader是一个抽象类，我们来看一下它的部分源码。
public abstract class ClassLoader { private static native void registerNatives(); static { registerNatives(); } // The parent class loader for delegation // Note: VM hardcoded the offset of this field, thus all new fields // must be added *after* it. private final ClassLoader parent;
我们来看一下它部分对外公开的public方法。
public Class<?> loadClass(String name) throws ClassNotFoundException { return loadClass(name, false); }
static ClassLoader getClassLoader(Class<?> caller) { // This can be null if the VM is requesting it if (caller == null) { return null; } // Circumvent security check since this is package-private return caller.getClassLoader0(); }
public loadClass方法的作用为给定一个类名，加载一个类，返回代表这个类的Class实例，如果找不到类，则返回ClassNotFoundException异常。它调用了protected loadClass方法。源码如下（加了注释）
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { //对这个名称产生一个锁对象，并进行加锁处理 synchronized (getClassLoadingLock(name)) { // First, check if the class has already been loaded //findLoadedClass的底层也是C语言交互实现的，应该是在JVM内存中查找该类的Class实例 Class<?> c = findLoadedClass(name); //如果在JVM内存中找不到该类的Class实例 if (c == null) { long t0 = System.nanoTime(); try {//parent为该加载器的双亲，具体会在后面介绍，如果双亲对象不为null，使用双亲加载 if (parent != null) { c = parent.loadClass(name, false); } else { //如果找不到双亲，启用最高权限的BootstrapClassLoader加载，BootstrapClassLoader在Java中没有对象，是用C语言实现的 c = findBootstrapClassOrNull(name); } } catch (ClassNotFoundException e) { // ClassNotFoundException thrown if class not found // from the non-null parent class loader } //如果找不到最高权限的加载器 if (c == null) { // If still not found, then invoke findClass in order // to find the class. long t1 = System.nanoTime(); //直接抛出异常 c = findClass(name); // this is the defining class loader; record the stats sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0); sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1); sun.misc.PerfCounter.getFindClasses().increment(); } } //如果在JVM内存中找到该类的Class实例，当前加载器自己处理 if (resolve) { resolveClass(c); } return c; } }
加锁处理片段代码
private final ConcurrentHashMap<String, Object> parallelLockMap;
protected Object getClassLoadingLock(String className) { //加载器对象赋给一个锁对象 Object lock = this; //如果该hashmap不为空 if (parallelLockMap != null) { //产生一把新锁 Object newLock = new Object(); //如果该hashmap中存在className的key,则返回key的value，如果不存在，则将className和newLock作为key,value放入hashmap中，返回null lock = parallelLockMap.putIfAbsent(className, newLock); if (lock == null) { lock = newLock; } } return lock; }
查找最高权限加载器源码
private Class<?> findBootstrapClassOrNull(String name) { if (!checkName(name)) return null; return findBootstrapClass(name); } // return null if not found private native Class<?> findBootstrapClass(String name);
findClass源码
protected Class<?> findClass(String name) throws ClassNotFoundException { throw new ClassNotFoundException(name); }
resolveClass源码
protected final void resolveClass(Class<?> c) { resolveClass0(c); } private native void resolveClass0(Class<?> c);
ClassLoader的分类
在标准的Java程序中，Java虚拟机会创建3类ClassLoader为整个应用程序服务。它们分别是：BootStrap ClassLoader（启动类加载器），Extension ClassLoader（扩展类加载器），App ClassLoader（应用类加载器，也称为系统类加载器）。此外，每一个应用程序还可以拥有自定义的ClassLoader,扩展Java虚拟机获取Class数据的能力。其中，应用类加载器的双亲为扩展类加载器，扩展类加载器的双亲为启动类加载器。当系统需要使用一个类时，在判断类是否已经被加载时，会先从当前底层类加载器进行判断。当系统需要加载一个类时，会从顶层类开始加载，依次向下尝试，直到成功。
这里根类加载器即为启动类加载器。通过代码验证
public class PrintClassLoaderTree { public static void main(String[] args) { ClassLoader cl = PrintClassLoaderTree.class.getClassLoader(); while (cl != null) { System.out.println(cl); cl = cl.getParent(); } System.out.println(String.class.getClassLoader()); } }
运行结果
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@4554617c
null
由此可知，PrintClassLoaderTree用户类加载于AppClassLoader中，而AppClassLoader的双亲为ExtClassLoader.而从ExtClassLoader无法再取得启动类加载器，因为这是一个纯C实现。因此，任何加载在启动类加载器中的类时无法获得其ClassLoader实例的，比如String属于Java核心类，因此会被启动类加载器加载，所以最后一条打印为null.
因为后面还有一些双亲委托的东西，这个不是我的重点，就不重点写了。重点是结合我之前的一篇文章，做一个解析，见 @Compenent,@Autowired,@PostConstruct自实现
程序主入口
public class Test { public static void main(String[] args) { Manager.scanAndImp("com.guanjian.test"); Test2 test2 = (Test2)Manager.getBean(Test2.class); test2.show(); } }
Manager.scanAndImp("com.guanjian.test")代码如下
public static void scanAndImp(String basePackage) { ClassHelper.setClassSet(basePackage); BeanHelper.setBeanMap(); IocHelper.ioc(); }
/** * 定义类集合(用于存放所加载的类) * @param basePackage */ private static Set<Class<?>> CLASS_SET; /** * 扫描所有的包，获取类集合放入CLASS_SET * @param basePackage */ public static void setClassSet(String basePackage) { CLASS_SET = ClassUtil.getClassSet(basePackage); }
很明显，第一步是扫描包，获取所有的Class实例，我们根据前面的介绍知道，要装载类，就必须要有一个类装载器，而这个类装载器就是
/** * 获取类加载器 * @return */ public static ClassLoader getClassLoader() { return Thread.currentThread().getContextClassLoader(); }
因为要装载的类都是我们自己写的类，而不是系统类，所以此时在JVM内存中是肯定没有它们的Class实例的，而装载它们的肯定也就是应用类装载器。
/** * 获取制定包名下的所有类 * @param packageName * @return */ public static Set<Class<?>> getClassSet(String packageName) { ...
代码就不详细分析了，只要知道这里使用了加载器装载了这些类，并产生了Class实例，但并未初始化。其中调用了方法
private static void doAddClass(Set<Class<?>> classSet,String className) { Class<?> cls = loadClass(className,false); classSet.add(cls); }
/** * 加载类 * @param className * @param isInitialized * @return */ public static Class<?> loadClass(String className,boolean isInitialized) { Class<?> cls; try { cls = Class.forName(className,isInitialized,getClassLoader()); } catch (ClassNotFoundException e) { LOGGER.error("load class failure",e); throw new RuntimeException(e); } return cls; }
即为我们之前说的Class.forName()的三参形式。这些所有的Class实例被放入了一个HashSet集合中，即为private static Set<Class<?>> CLASS_SET;
这样第一条语句ClassHelper.setClassSet(basePackage);就分析完了。
--------------------------------------------------------------------------------------------------
然后是第二条语句BeanHelper.setBeanMap();
/** * 获取所有Class实例跟类本身实例的映射关系 */ public static void setBeanMap() { Set<Class<?>> beanClassSet = ClassHelper.getBeanClassSet(); for (Class<?> beanClass:beanClassSet) { Object obj = ReflectionUtil.newInstance(beanClass); BEAN_MAP.put(beanClass,obj); } }
/** * 定义Bean映射(用于存放Bean类与Bean实例的映射关系) */ private static final Map<Class<?>,Object> BEAN_MAP = new HashMap<Class<?>, Object>();
/** * 获取应用包名下所有Bean类 * @return */ public static Set<Class<?>> getBeanClassSet() { Set<Class<?>> beanClassSet = new HashSet<Class<?>>(); beanClassSet.addAll(getComponentClassSet()); return beanClassSet; }
/** * 获取应用包名下所有Comonent类 * @return */ public static Set<Class<?>> getComponentClassSet() { Set<Class<?>> classSet = new HashSet<Class<?>>(); for (Class<?> cls:CLASS_SET) { //这个Class实例是否带有@Component标签 if (cls.isAnnotationPresent(Component.class)) { classSet.add(cls); } } return classSet; }
/** * 创建实例 * @param cls * @return */ public static Object newInstance(Class<?> cls) { Object instance; try { instance = cls.newInstance(); } catch (Exception e) { LOGGER.error("new instance failure",e); throw new RuntimeException(e); } return instance; }
这里是被@Component标签识别加载的称为bean，我们之前的确获取了所有的类，并且加载了，但并没有初始化。但有一些可能并没有打上@Component标签的就不能称为bean.我们需要对有@Component标签的进行初始化。把bean类跟带有@Component的类分离，是为了方便扩展，以后有其他的标签的可以方便修改。
BeanHelper.setBeanMap();的意思就是把所有的bean都给初始化了，并建立了一个Class实例跟bean类本身的实例的映射关系的HashMap.其中cls.isAnnotationPresent(Component.class)就是检测Class实例是否被我们自定义的标签@Component标记，这是一个比较重点的地方吧。
--------------------------------------------------------------------------------------------------------
然后是第三条语句IocHelper.ioc();
public static void ioc(){ //获取所有的Bean类与Bean实例之间的映射关系 Map<Class<?>,Object> beanMap = BeanHelper.getBeanMap(); if (CollectionUtil.isNotEmpty(beanMap)) { //遍历Bean Map for (Map.Entry<Class<?>,Object> beanEntry:beanMap.entrySet()) { //从BeanMap中获取Bean类与Bean实例 Class<?> beanClass = beanEntry.getKey(); Object beanInstance = beanEntry.getValue(); //获取Bean类定义的所有成员变量 Field[] beanFields = beanClass.getDeclaredFields(); if (ArrayUtil.isNotEmpty(beanFields)) { //遍历Bean Field for (Field beanField:beanFields) { //判断当前Bean Field是否带有Autowired注解 if (beanField.isAnnotationPresent(Autowired.class)) { //获取当前Bean Field的Class实例 Class<?> beanFieldClass = beanField.getType(); //通过该Class实例在HashMap中获取对应的Bean Field类本身的实例，此时并没有设置到Field中 //且注意beanFieldInstance是beanInstance某个属性的实例，他们不是同一个实例 Object beanFieldInstance = beanMap.get(beanFieldClass); if (beanFieldInstance != null) { //通过反射初始化BeanField的值，把在HashMap中找到的Bean类实例设置给beanInstance //的beanField ReflectionUtil.setField(beanInstance,beanField,beanFieldInstance); } } } } Method[] beanMethods = beanClass.getMethods(); if (ArrayUtil.isNotEmpty(beanMethods)) { //遍历method for (Method method:beanMethods) { //判断当前注解是否有PostConstruct注解 if (method.isAnnotationPresent(PostConstruct.class)) { try { //执行该方法 method.invoke(beanInstance,null); } catch (Exception e) { e.printStackTrace(); } } } } } } }
/** * 获取Class实例和Bean类本身实例的映射 * @return */ public static Map<Class<?>,Object> getBeanMap() { return BEAN_MAP; }
/** * 设置成员变量值 * @param obj * @param field * @param value */ public static void setField(Object obj, Field field,Object value) { try { //如果field在类中为private，则必须setAccessible(true)才可以在反射中正常访问 field.setAccessible(true); //obj为要注入的Bean类的实例，value为该Bean类的field字段的要注入的值 field.set(obj,value); } catch (IllegalAccessException e) { LOGGER.error("set field failure",e); throw new RuntimeException(e); } }
这里主要是为了实现IOC依赖注入（@Autowired标签）以及@PostConstruct标签方法的自动运行。其中Class<?> beanFieldClass = beanField.getType();用来获取类的属性的Class实例，比较重要，再去HashMap中查找该Class实例对应的Bean类本身的实例，这里Class实例跟类本身的实例一定要分清楚。然后ReflectionUtil.setField(beanInstance,beanField,beanFieldInstance);把找到的实例设置给要设置的Bean类的field属性，完成初始化。同样method.invoke(beanInstance,null);也是调用beanInstance自身的方法。
总体思路就是在Class实例中查找各种属性，方法以及类自定义标签、属性自定义标签，方法自定义标签，再结合类本身的实例，通过Class实例的Field,method进行属性赋值，方法运行，这些又都必须在反射（Class实例）中调用类本身的实例。
具体谈一下反射在抽象工厂模式下的应用。
抽象工厂模式下有3个概念，抽象工厂，抽象零件，抽象产品。它是一个以抽象对抽象的处理，无需具体的实现类参与。
具体例子可以参考 设计模式整理
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
