java类加载，反射，动态代理入门理解

1、java的类加载机制，参考文档

http://blog.csdn.net/gjanyanlig/article/details/6818655

JVM的类加载是通过ClassLoader及其子类来完成的，类的层次关系和加载顺序可以由下图来描述：

1）Bootstrap ClassLoader

负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class，由C++实现，不是ClassLoader子类

2）Extension ClassLoader

负责加载java平台中扩展功能的一些jar包，包括$JAVA_HOME中jre/lib/*.jar或-Djava.ext.dirs指定目录下的jar包

3）App ClassLoader

负责记载classpath中指定的jar包及目录中class

4）Custom ClassLoader

属于应用程序根据自身需要自定义的ClassLoader，如tomcat、jboss都会根据j2ee规范自行实现ClassLoader

加载过程中会先检查类是否被已加载，检查顺序是自底向上，从Custom ClassLoader到BootStrap ClassLoader逐层检查，只要某个classloader已加载就视为已加载此类，保证此类只所有ClassLoader加载一次。而加载的顺序是自顶向下，也就是由上层来逐层尝试加载此类。

2、反射

       JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
      要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。

下面我们通过一个小案例来了解下class对象的一些特性

/*
 * 反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。
 * 
 * Person p = new Person();
 * p.使用
 * 
 * 要想这样使用，首先你必须得到class文件对象，其实也就是得到Class类的对象。
 * Class类：
 * 		成员变量	Field
 * 		构造方法	Constructor
 * 		成员方法	Method
 * 
 * 获取class文件对象的方式：
 * A:Object类的getClass()方法
 * B:数据类型的静态属性class
 * C:Class类中的静态方法
 * 		public static Class forName(String className)
 * 
 * 一般我们到底使用谁呢?
 * 		A:自己玩	任选一种，第二种比较方便
 * 		B:开发	第三种
 * 			为什么呢?因为第三种是一个字符串，而不是一个具体的类名。这样我们就可以把这样的字符串配置到配置文件中。
 */
public class ReflectDemo {
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		// 方式1
		Person p = new Person();
		Class c = p.getClass();

		Person p2 = new Person();
		Class c2 = p2.getClass();

		System.out.println(p == p2);// false
		System.out.println(c == c2);// true

		// 方式2
		Class c3 = Person.class;
		// int.class;
		// String.class;
		System.out.println(c == c3);

		// 方式3
		// ClassNotFoundException
		Class c4 = Class.forName("cn.itcast_01.Person");
		Person person=(Person) c2.newInstance();
		System.out.println(c == c4);
	}
}

输出结果false
true
true
true

我们可以这么吧，获取class对象的方式有三种方式，且class对象是单例模式。

（2）下面介绍下class对象的主要方法：

Class c = Class.forName("cn.itcast_01.Person");

Constructor con = c.getConstructor(String.class, int.class,String.class);// 返回的是构造方法对象（可以带有参数，有重载方法）

Person obj = (Person) con.newInstance();//创建该类的对象（可以带有参数，有重载方法）

getConstructors() //返回一个集合，所有构造方法

输出结果

public cn.itcast_01.Person()
Person [name=null, age=0, address=null]

反射可以创建私有构造方法的对象

/*
 * 需求：通过反射获取私有构造方法并使用
 * private Person(String name){}
 * 
 * Person p = new Person("风清扬");
 * System.out.println(p);
 */
public class ReflectDemo3 {
	public static void main(String[] args) throws Exception {
		// 获取字节码文件对象
		Class c = Class.forName("cn.itcast_01.Person");

		// 获取私有构造方法对象
		// NoSuchMethodException：每个这个方法异常
		// 原因是一开始我们使用的方法只能获取公共的，下面这种方式就可以了。
		Constructor con = c.getDeclaredConstructor(String.class);

		// 用该私有构造方法创建对象
		// IllegalAccessException:非法的访问异常。
		// 暴力访问
		con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。
		Object obj = con.newInstance("风清扬");

		System.out.println(obj);
	}
}

（3）、获取字段对象，并进行赋值

// 获取单个的成员变量
		// 获取address并对其赋值
		Field addressField = c.getField("address");
		// public void set(Object obj,Object value)
		// 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
		addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
		System.out.println(obj);

（4）通过方法名，得到方法Method，并调用该方法（这种模式下，可以调用私有方法）

public class ReflectDemo {
	public static void main(String[] args) throws Exception {
		// 获取字节码文件对象
		Class c = Class.forName("cn.itcast_01.Person");

		// 获取所有的方法
		// Method[] methods = c.getMethods(); // 获取自己的包括父亲的公共方法
		// Method[] methods = c.getDeclaredMethods(); // 获取自己的所有的方法
		// for (Method method : methods) {
		// System.out.println(method);
		// }

		Constructor con = c.getConstructor();
		Object obj = con.newInstance();
		

		/*
		 * Person p = new Person(); p.show();
		 */

		// 获取单个方法并使用
		// public void show()
		// public Method getMethod(String name,Class<?>... parameterTypes)
		// 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
		Method m1 = c.getMethod("show");
		// obj.m1(); // 错误
		// public Object invoke(Object obj,Object... args)
		// 返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
		m1.invoke(obj); // 调用obj对象的m1方法

		System.out.println("----------");
		// public void method(String s)
		Method m2 = c.getMethod("method", String.class);
		m2.invoke(obj, "hello");
		System.out.println("----------");

		// public String getString(String s, int i)
		Method m3 = c.getMethod("getString", String.class, int.class);
		Object objString = m3.invoke(obj, "hello", 100);
		System.out.println(objString);
		// String s = (String)m3.invoke(obj, "hello",100);
		// System.out.println(s);
		System.out.println("----------");

		// private void function()
		Method m4 = c.getDeclaredMethod("function");
		m4.setAccessible(true);
		m4.invoke(obj);
	}
}

总结：上面我们说了如果通过反射获取对象，获取字段，获取方法、如果如何给字段赋值，如何调用方法，并且

我们发现获取方法，字段都是重构的，并且可以一次获取所有方法和字段。具体方法可以参考api

下面我们接触动态代理，我们会发现动态代理中通过反射调用目标方法

案例

/**
 * 拦截器
 *    1、目标类导入进来
 *    2、事务导入进来
 *    3、invoke完成
 *        1、开启事务
 *        2、调用目标对象的方法
 *        3、事务的提交
 * @author zd
 *
 */
public class MyInterceptor implements InvocationHandler{
	private Object target;//目标类
	private Transaction transaction;
	
	
	public MyInterceptor(Object target, Transaction transaction) {
		super();
		this.target = target;
		this.transaction = transaction;
	}
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		String methodName = method.getName();
		if("savePerson".equals(methodName)||"updatePerson".equals(methodName)
				||"deletePerson".equals(methodName)){
			this.transaction.beginTransaction();//开启事务
			method.invoke(target);//调用目标方法
			this.transaction.commit();//事务的提交
		}else{
			method.invoke(target);
		}
		return null;
	}
}

public class JDKProxyTest {
	@Test
	public void testJDKProxy(){
		/**
		 * 1、创建一个目标对象
		 * 2、创建一个事务
		 * 3、创建一个拦截器
		 * 4、动态产生一个代理对象
		 */
		Object target = new PersonDaoImpl();
		Transaction transaction = new Transaction();
		MyInterceptor interceptor = new MyInterceptor(target, transaction);
		/**
		 * 1、目标类的类加载器
		 * 2、目标类实现的所有的接口
		 * 3、拦截器
		 */
		PersonDao personDao = (PersonDao)Proxy.newProxyInstance(target.getClass().getClassLoader(), 
				target.getClass().getInterfaces(), interceptor);
		//personDao.savePerson();
		personDao.updatePerson();
	}
}

这里有个注意事项，我们发现代理类，必须实现接口，那么解决方法可以通过cglib解决，这里不介绍了，也是个代理方法

而且这里我们必须联系到注解

首先我们谈下如何定义注解，请阅读如下文章

http://blog.csdn.net/u012316953/article/details/52749496

那么我们如何读取类上，方法上 等的注解呢？
毫无疑问也是通过class对象，那么我介绍下class对象的一些关于注解的方法，具体参考api

isAnnotation()
          如果此 Class 对象表示一个注释类型则返回 true。

getAnnotation(Class<A> annotationClass)
          如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。

getAnnotations()
          返回此元素上存在的所有注释。

 字段Field 关于注解的方法

getAnnotation(Class<T> annotationClass)
          如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。

方法Method关于注解的方法

getAnnotation(Class<T> annotationClass)
          如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。

getDeclaredAnnotations()
          返回直接存在于此元素上的所有注释。

构造函数construct上的注解方法

getAnnotation(Class<T> annotationClass) 
          如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。

getDeclaredAnnotations() 
          返回直接存在于此元素上的所有注释。