黑马程序员—Java提高3（注解，类加载器，代理）

----------------------   JavaEE+Android、Java培训、期待与您交流！ ----------------------

注解

注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则没有某种标记。以后，java编译器、开发工具和其他应用程序就可以用反射来了解自己的类及各种元素上有无何种标记，有什么标记，就会做出相应的处理。标记可以加在包、类、字段、方法、方法参数，以及局部变量上等等。在java.lang包中提供了最基本的annotation，即注解。

格式：@注解类名()。如果有属性，则在括号中加上属性名（可省略）和属性值。

java中三种最基本的注解：

1、@SuppressWarning(”deprecation”) 压制警告

SupressWarning是告知编译器或开发工具等提示指定的编译器警告；

”deprecation”是告知具体的信息即方法已过时。

2、@Deprecated 提示成员等已经过时，不再推荐使用。

源代码标记@Deprecated是在JDK1.5中作为内置的annotation引入的，用于表明类(class)、方法(method)、字段(field)已经不再推荐使用，并且在以后的JDK版本中可能将其删除，编译器在默认情况下检测到有此标记的时候会提示警告信息。

例如：假定之前的某个类升级了，其中的某个方法已经过时了，不能够将过时的方法删除，因为可能会影响到调用此类的这个方法的某些程序，这是就可以通过在方法上加这个注解。

3、@Override 提示覆盖（父类方法）

加上此注解，，可对自己类中的方法判断是否是要覆盖的父类的方法，典型的例子即在集合中覆盖equals(Object obj)方法，其中的参数类型必须是Object，才能被覆盖，若不是，加上此注解就会提示警告。

注解类

1、定义格式：@interface 名称{statement}

2、元注解（注解的注解）

一个注解有其生命周期（Retetion）和存放的位置（Taget），这就可以通过元注解说明。

1）Retetion：用于说明注解保留在哪个时期，加载定义的注解之上。

一个注解的声明周期包含：java源程序--(javac)-->class文件--(类加载器)-->内存中的字节码

第一、当再源程序上加了注解，javac将java源程序编译为class文件，可能会把源程序中的一些注解去掉，进行相应的处理操作，当我们拿到源程序的时候，就看不到这些注解了。

第二、假设javac把这些注解留在了源程序中（或者说留在了class文件中），当运行此class文件的时候，用类加载器将class文件调入内存中，此时有转换的过程，即把class文件中的注解是否保留下来也不一定。

注意：class文件中不是字节码，只有把class文件中的内部加载进内存，用类加载器加载处理后（进行完整的检查等处理），最终得到的二进制内容才是字节码。

Reteton（枚举类）取值：

Retetion.Policy.SOURSE：java源文件时期，如@Overried和@SuppressWarning

Retetion.Policy.CLASS： class文件时期（默认阶段）

Retetion.Policy.RUNTIME：运行时期，如@Deprecated

2）Taget：用于说明注解存放在哪些成分上，默认值是任何元素

其值可设置为枚举类ElementType类中的任何一个，包括：包、字段、方法、方法参数、构造器、类等值。取值为：

PACKAGE(包声明)

FIELD(字段声明)

ANNOTATION_TYPE(注释类型声明)

CONSIRUCTOR(构造器声明)

METHOD(方法声明)

PARAMETER(参数声明)

TYPE(类、接口（包含注释类型）或枚举声明)

LOCAL_VARIABLE(局部变量声明)

注意：其中代表类的值是TYPE。因为class、enum、interface和@interface等都是属于Type的。不可用CLASS表示。

3、通过反射查看其它类中的注释：

第一、注解类：@interfaceA{}

第二、应用了“注释类”的类：@Aclass B{}

第三、对“应用注释类的类”进行反射操作的类：class{...}，操作如下：

B.class.isAnnotionPresent(A.class); //判断是否存在此注解类

A a = B.class.getAnnotation(a.class); //存在的话则得到这个注释类的对象

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD})
public @interface ItcastAnnotation {}

@ItcastAnnotation()
public class AnnotionTest {
	@SuppressWarnings("deprecation")//表示压制警告的注解
	@ItcastAnnotation()
	public static void main(String[] args) {
		System.runFinalizersOnExit(true);
		//反射方式查看注解
		//检查类上是否有注解
		if(AnnotionTest.class.isAnnotationPresent(ItcastAnnotation.class)){
			//通过反射获取到注解
			ItcastAnnotation annotation = AnnotionTest.class.getAnnotation(ItcastAnnotation.class);
			System.out.println(annotation);
		}
	}
	

为注解增加基本属性

1、属性：

一个注解相当于一个胸牌，但仅通过胸牌还不足以区别带胸牌的两个人，这时就需要给胸牌增加一个属性来区分，如颜色等。

2、定义格式：同接口中的方法一样：String color();

定义缺省格式：Stringvalue() default ”ignal”;

3、应用：直接在注解的括号中添加自身的属性，如：

@ItcastAnnotation(color=”red”)

这个和上面的@SuppressWarnings("deprecation")是一样的，其中的"deprecation"就是属性值

1）当只有一个属性时，可直接传入属性值。如”red”

2）当含有其他属性值的时候，如果那个属性值是缺省的（default），也可以直接传入这个属性值。

为注解增加高级属性

1、可以为注解增加的高级属性的返回值类型有：

1）八种基本数据类型   2）String类型  3）Class类型

4）枚举类型   5）注解类型   6）前五种类型的数组

2、数组类型的属性：

定义：int[]arrayArr() default {1,2,3};     -->可不定义默认值

应用：@MyAnnotation(arrayArr={2,3,4})  --> 可重新赋值

注：若数组属性中只有一个元素（或重新赋值为一个元素），这时属性值部分可省略大括号。

3、枚举类型的属性：

假设定义了一个枚举类TraffLamp，它是EnumTest的内部类，其值是交通灯的三色。

定义：EnumTest.TrafficLamplamp();

应用：@MyAnnotation(lamp=EnumTestTrafficLamp.GREEN)

4、注解类型的属性：

假定有个注解类：MetaAnnotation，其中定义了一个属性：String value()

定义：MetaAnnotationannotation() default @MetaAnnotation(”xxx”);

应用：@MyAnnotation(annotation=@MetaAnnotation(”yyy”))  --> 可重新赋值

可认为上面的@MetaAnnotation是MyAnnotation类的一个实例对象，同样可以认为上面的@MetaAnnotation是MetaAnnotation类的一个实例对象，调用：

MetaAnnotation ma =MyAnnotation.annotation();

System.out.println(ma.value());

5、Class类型的属性：

定义：Class cls();

应用：@MyAnnotation(cls=ItcastAnnotion.class)

注：这里的.class必须是已定义的类，或是已有的字节码对象

7、基本数据类型的属性（以int为例）：

定义：int val()default 3;     -->可不定义默认值

应用：@MyAnnotation(val=7)  --> 可重新赋值

8、注解的详细语法可通过查看java语言规范了解即javaLanguage Specification

//自定义注解类
package cn.itcast.text2;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import cn.itcast.text1.EnumText;
//将定义的注解的生命周期设置在运行时期
@Retention(RetentionPolicy.RUNTIME)
//定义注解的放置位置
@Target({ElementType.TYPE,ElementType.METHOD})
//自定义注解
public @interface ItcastAnnotation {
	//定义属性
	String str();
	int val() default 1;
	int[] arr() default {2,3,4};
	Class cls() default AnnotionTest.class;
	EnumText.TrafficLamp lamp() default EnumText.TrafficLamp.YELLOW;
	MetaAnnotation annotation() default @MetaAnnotation("sss");
}

//测试注解类，用反射查看其属性
package cn.itcast.text2;
import cn.itcast.text1.EnumText;
@ItcastAnnotation(annotation=@MetaAnnotation("anntation"),
				Lamp=EnumText.TrafficLamp.RED,
				arr=7,val=5,str="String",
				cls=ItcastAnnotation.class)
public class AnnotionTest {
	@SuppressWarnings("deprecation")//表示压制警告的注解
	@ItcastAnnotation(str = "yyy")//有缺省值可不用写缺省部分
	public static void main(String[] args) {
		//反射方式查看注解
		//检查类上是否有注解
		if(AnnotionTest.class.isAnnotationPresent(ItcastAnnotation.class)){
			//通过反射获取到注解
			ItcastAnnotation annotation = AnnotionTest.class.getAnnotation(ItcastAnnotation.class);
			//打印查看属性值
			System.out.println(annotation);
			System.out.println(annotation.str());
			System.out.println(annotation.val());
			System.out.println(annotation.arr().length);
			System.out.println(annotation.cls().getName());
			System.out.println(annotation.lamp().nextLamp());
			System.out.println(annotation.annotation().value());
		}
	}
}

//定义枚举类，交通灯
package cn.itcast.text1;
public class EnumText {
	public static void main(String[] args) {}
	//定义交通灯
	public enum TrafficLamp{
		//定义3个元素，即此类的子类，覆写抽象方法
		RED(30){
			@Override
			public TrafficLamp nextLamp() {return GREEN;}},
		GREEN(45){
			@Override
			public TrafficLamp nextLamp() {return YELLOW;}},
		YELLOW(5) {
			@Override
			public TrafficLamp nextLamp() {return RED;}};
		private int time;
		//构造方法
		private TrafficLamp(int time){this.time = time;}
		//抽象方法，转为下个灯
		public abstract TrafficLamp nextLamp();
	}
}

类加载器

简单说，类加载器就是加载类的工具。

当出现一个类，用到此类的时候，Java虚拟机首先将类字节码加载进内存，通常字节码的原始信息放在硬盘上的classpath指定的目录下。

类加载器作用：将.class文件中的内容加载进内存进行处理，处理完后的结果就是字节码。

默认类加载器：

1）Java虚拟机中可安装多个类加载器，系统默认的有三个主要的，每个类负责加载特定位置的类：BootStrap、ExtClassLoader、AppClassLoader

2）BootStrap--顶级类加载器：

类加载器本身也是Java类，因为它是Java类，本身也需要加载器加载，显然必须有第一个类加载器而不是java类的，这正是BootStrap。它是嵌套在Java虚拟机内核中的，已启动即出现在虚拟机中，是用c++写的一段二进制代码。所以不能通过java程序获取其名字，获得的只能是null。

Java虚拟机中的所有类加载器采用子父关系的树形结构进行组织，在实例化每个类加载器对象或默认采用系统类加载器作为其父级类加载器。

类加载器的委托机制

1、加载类的方式

当Java虚拟机要加载一个类时，到底要用哪个类加载器加载呢？

1）首先，当前线程的类加载器去加载线程中的第一个类。

2）若A引用类B（继承或者使用了B），Java虚拟机将使用加载类的类加载器来加载类B。

3）还可直接调用ClassLoader的LoaderClass()方法，来制定某个类加载器去加载某个类。

2、加载器的委托机制：每个类加载器加载类时，又先委托给上级类加载器。

每个ClassLoader本身只能分别加载特定位置和目录中的类，但他们可以委托其他类的加载器去加载，这就是类加载器的委托模式，类加载器一级级委托到BootStrap类加载器，当BootStrap在指定目录中没有找到要加载的类时，无法加载当前所要加载的类，就会一级级返回子孙类加载器，进行真正的加载，每级都会先到自己相应指定的目录中去找，有没有当前的类；直到退回到最初的类装载器的发起者时，如果它自身还未找到，未完成类的加载，那就报告ClassNoFoundException的异常。

简单说，就是先由发起者将类一级级委托为BootStrap，从父级开始找，找到了直接返回，没找到再返回给其子级找，直到发起者，再没找到就报异常。

3、委托机制的优点：可以集中管理，不会产生多字节码重复的现象。

面试题

可不可以自己写个类为：java.lang.System呢？

回答：第一、通常是不可以的，由于类加载器的委托机制，会先将System这个类一级级委托给最顶级的BootStrap，由于BootStrap在其指定的目录中加载的是rt.jar中的类，且其中有System这个类，那么就会直接加载自己目录中的，也就是Java已经定义好的System这个类，而不会加载自定义的这个System。

第二、但是还是有办法加载这个自定义的System类的，此时就不能交给上级加载了，需要用自定义的类加载器加载，这就需要有特殊的写法才能去加载这个自定义的System类的。

自定义类加载器

1、自定义的类加载器必须继承抽象类ClassLoader，要覆写其中的findClass(String name)方法，而不用覆写loadClass()方法。

2、覆写findClass(String name)方法的原因：

1）是要保留loadClass()方法中的流程，因为loadClass()中调用了findClass(String name)这个方法，此方法返回的就是去寻找父级的类加载器。

2）在loadClass()内部是会先委托给父级，当父级找到后就会调用findClass(String name)方法，而找不到时就会用子级的类加载器，再找不到就报异常了，所以只需要覆写findClass方法，那么就具有了实现用自定义的类加载器加载类的目的。

流程：

父级-->loadClass-->findClass-->得到Class文件后转化成字节码-->defind()。

3、编程步骤：

1）编写一个对文件内容进行简单加盟的程序

2）编写好了一个自己的类加载器，可实现对加密过来的类进行装载和解密。

3）编写一个程序，调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类，程序中除了可使用ClassLoader的load方法外，还能使用放置线程的上线文类加载器加载或系统类加载器，然后在使用forName得到字节码文件。

<span style="font-family:Arial;">package cn.itcast.text2;
import java.util.Date;

public class ClassLoaderAttachment extends Date {
	//对此类进行加密
		public String toString(){
			return "hello world";
		}
		public static void main(String [] args){
			
		}
}

//自定义类加载器
package cn.itcast.text2;

import java.io.*;
//继承抽象类ClassLoader
public class MyClassLoader  extends ClassLoader {
	public static void main(String[] args) throws Exception {
		//传入两个参数，源和目标
		String scrPath = args[0];
		String destDir = args[1];
		//将数据读取到输入流中，并写入到输出流中
		FileInputStream fis = new FileInputStream(scrPath);
		String destFileName = 
				scrPath.substring(scrPath.lastIndexOf('\\')+1);
		String destPath = destDir + "\\" + destFileName;
		FileOutputStream fos = new FileOutputStream(destPath);
		//加密数据
		cypher(fis,fos);
		fis.close();
		fos.close();
	}
	//定义加密数据的方法
	private static void cypher(InputStream ips,OutputStream ops)throws Exception{
		int b = 0;
		while((b=ips.read())!=-1){
			ops.write(b ^ 0xff);
		}
	}
	//定义全局变量
	private String classDir;
	@Override//覆写findClass方法，自定义类加载器
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		String classFileName = classDir + "\\" + name + ".class"; 
		try {
			//将要加载的文件读取到流中，并写入字节流中
			FileInputStream fis = new FileInputStream(classFileName);
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			cypher(fis,bos);
			fis.close();
			byte[] bytes = bos.toByteArray();
			return defineClass(bytes, 0, bytes.length);
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//如果没找到类，则用父级类加载器加载
		return super.findClass(name);
	}
	//构造函数
	public MyClassLoader(){}
	public MyClassLoader(String classDir){
		this.classDir = classDir;
	}
}
</span>

代理

生活中的代理：就是常说的代理商，从厂商将商品卖给消费者，消费者不用很麻烦的到厂商在购买了。

程序中的代理：要为已经存在的多个具有相同接口的目标类的各个方法增加一些系统功能，如异常处理、日志、计算方法的运行时间、事物管理等等。

代理类的优点：

如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类还是代理类。这样以后很容易切换，如果想要日志功能时，就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想换掉系统功能也很容易。

<span style="font-family:Arial;">import java.lang.reflect.*;
import java.util.*;
public class ProxyTest {
	public static void main(String[] args) throws Exception{
		//获取代理类Proxy的Class对象，传入的是类加载器和相应的字节码对象
		Class clazzProxy1 = Proxy.getProxyClass(
				Collection.class.getClassLoader(), Collection.class);
		System.out.println(clazzProxy1.getName());//$Proxy0
		
		System.out.println("---begin constructor list------");
		//获取代理类的构造方法，可能含有多个，得到数组
		Constructor[] constructors = clazzProxy1.getConstructors();
		//遍历数组，获取每个构造方法
		for(Constructor constructor : constructors){
			//先得到构造方法的名字，并装入字符串容器中
			String name = constructor.getName();
			StringBuilder sBul = new StringBuilder(name);
			sBul.append('(');
			//获取构造方法中的参数类型，并遍历
			Class[] clazzParams = constructor.getParameterTypes();
			for(Class clazzParam : clazzParams){
				sBul.append(clazzParam.getName()).append(',');
			}
			//将最后一个逗号去除
			if(clazzParams != null && clazzParams.length!=0)
				sBul.deleteCharAt(sBul.length()-1);
			sBul.append(')');
			System.out.println(sBul.toString());
		}
		
		System.out.println("---begin method list------");
		//获取代理类的方法，存入数组
		Method[] methods = clazzProxy1.getMethods();
		//遍历数组，获取每个方法
		for(Method method : methods){
			//先得到方法的名字，并装入字符串容器中
			String name = method.getName();
			StringBuilder sBul = new StringBuilder(name);
			sBul.append('(');
			//获取方法中的参数类型，并遍历
			Class[] clazzParams = method.getParameterTypes();
			for(Class clazzParam : clazzParams){
				sBul.append(clazzParam.getName()).append(',');
			}
			//将最后一个逗号去除
			if(clazzParams!=null && clazzParams.length!=0)
				sBul.deleteCharAt(sBul.length()-1);
			sBul.append(')');
			System.out.println(sBul.toString());
		}
}
</span>

AOP

AOP（Aspect Oriented Program）即面向方面的编程。

动态代理技术

一、概述：

1、要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，这时就不能采用静态代理方式，需用动态代理技术。

2、动态代理类：JVM可在运行时，动态生成类的字节码，这种动态（不是代理，只是拿出来作为代理类）生成的类往往被用作代理类，即动态代理类。

注：JVM生成的动态类必须实现一或多个接口，所以JVM生成的动态代理类只能用作具有相同接口的目标类代理。

3、CGLIB库可以动态生成一个类的子类，一个类的子类也可以作为该类的代理，所以，如果要为一个没有实现接口的类生成动态代理，那么可以使用CGLIB库。

4、代理类各个方法通常除了调用目标相应方法和对外返回目标返回的结果外，还可以再代理方法中的如下位置上加上系统功能代码：

1）在调用目标方法之前

2）在调用目标方法之后

3）在调用目标方法前后

4）在处理目标方法异常的catch块中。

二、分析JVM动态生成的类

1、创建动态类的实例对象：

1）用反射获得构造方法

2）编写一个最简单的InvocationHandler的类

3）调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去。

示例：

第一、打印创建的对象和调用对象的无返回值的方法和getClass方法，演示调用其他没有返回值的方法报告的异常

第二、将创建的动态类的实例对象的代理改写成为匿名内部类的形式编写。

<span style="font-family:Arial;">package cn.itcast.test3;
import java.lang.reflect.*;
import java.util.*;
public class ProxyTest {
	public static void main(String[] args) throws Exception{
//创建动态代理类的三种方式
		//方式一：通过接口的子类创建对象
		Collection proxy1 = (Collection)
				constructor.newInstance(new MyInvocationHandler());
		System.out.println(proxy1);//null
		System.out.println(proxy1.toString());//null
		proxy1.clear();//无异常
		//proxy1.size();//异常		
		//方式二：匿名内部类
		Collection proxy2 = (Collection)
				constructor.newInstance(new InvocationHandler(){
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						// TODO Auto-generated method stub
						return null;
					}
				});
		
		//方式三：
		//通过代理类的newProxyInstance方法直接创建对象
		Collection proxy3 = (Collection)Proxy.newProxyInstance(
			//定义代理类的类加载器
			Collection.class.getClassLoader(),
			//代理类要实现的接口列表
			new Class[]{Collection.class},
			//指派方法调用的调用处理程序
			new InvocationHandler() {
				//创建集合，制定一个目标
				ArrayList target = new ArrayList();
				public Object invoke(Object proxy, Method method, Object[] args)
						throws Throwable {
					//测试程序运行时间
					long beginTime = System.currentTimeMillis();
					//调用目标方法，将其从return抽出来，加入代理所需的代码
					Object retVal = method.invoke(target, args);
					long endTime = System.currentTimeMillis();
					//测试
					System.out.println(method.getName() + 
							" run time of " + 
							(endTime - beginTime));
					return retVal;
				}
			}
			);
		//通过代理类调用目标方法，每调用一个目标的方法就会执行代理类的方法
		//当调用一次add方法时，就会找一次InvocationHandler这个参数的invoke方法
		proxy3.add("sdfd");
		proxy3.add("shrt");
		proxy3.add("rtbv");
		System.out.println(proxy3.size());
		System.out.println(proxy3.getClass().getName());
	}
}
</span>

2、让JVM创建动态类需要提供的信息：

1）生成类中的哪些方法，通过让其实现哪些接口的方式进行告知。

2）产生的类字节码必须有一个关联的类加载器对象

3）生成的类中的方法的代码是怎么样的，也得由我们自己提供，把我们的代码写在一个约定好的子接口对象的方法中，把对象传给它，它调用我们的方法，即相当于插入了我们自己的代码。提供执行代码的对象就是InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的，在上面的InvocationHandler对象的invoke方法中，加一点代码就可以看到这些代码被调用运行了。

三、分析动态生成的类的内部代码

1、构造方法接受一个InvocationHandler对象，接受此对象的用处：

接受一个handler参数是为了记录它，以便在之后的程序中运用它。

2、实现Collection接口的动态类中的各个方法的代码的解析：

1）InvocationHandler接口中定义的invoke方法接受三个参数的含义：

第一、Client(客户端)程序调用objProxy.add(“avc”)方法时，涉及到了三个参数，分别为：objProxy对象，add方法，”avc”参数。代码如下：

class Proxy${

  add(Object obj){

      return handler.invoke(Object proxy, Method method, Object[] args);

   }

}

第二、其中的Objectproxy 即为objProxy对象，Method method对应add方法，Object[] args就是”avc”参数。在使用newProxyInstance的方式创建代理对象实现时，当前正在调用代理对象（Object proxy），调用当前对象的哪个方法（Method method），调用此对象方法时传入的参数（Object[] args）。

3、调用代理涉及到三个因素：代理对象，代理对象的哪个方法，以及此方法接受的参数。要执行目标对象，只需要将代理对象作为目标对象即可。

4、对于上面代码中的Object retVal = method.invoke(target,args)的分析：

目标对象target执行完返回一个值为retVal，接着将值作为结果return回去，则代理方法就会收到一个返回值。其中还可以定义一个过滤器，对参数args（即当前对象的方法传入的参数）进行过滤（修改）。

5、对于上面代码中的proxy3.add(“sdfd”)的分析：

1）代理对象调用add方法，传递了sdfd参数。

2）add方法内部会找到InvocationHandler中的invoke方法，将代理对象proxy传进去，把add方法传入，将“sdfd”参数传入代理对象中的handler参数，返回了一个结果，就是给了add方法，add方法继续向外返回给调用的对象proxy3，即最终结果。

其中的handler的invoke方法返回又来自于目标target返回值，从而将此返回值返给Object invoke()方法，即作为handler参数位置上的值返回给add方法。add方法作为最后的结果返回。

四、问题：

1、在上面的方式一的代码中，调用无返回值的方法返回的是null，而调用有返回值方法的时候会报NullPointException异常的原因：

在proxy1.size()方法中，size()会调用Object invoke()方法，而对其覆写时的返回值是null，而size()本身会返回int类型，两者返回的类型不相等，所以就会报错。

而对于proxy3.size()不报错，是因为size()返回值与代理对象中handler参数返回值是一致的，当前目标返回什么，代理就返回什么，所以不会报错。

注意：目标返回值和代理返回值必须是同一类型。

2、为何动态类的实例对象的getClass()方法返回了正确结果，而没调用invoke方法：

因为代理类从Object上继承了许多方法，其中只对三个方法（hashCode、equals和toString）进行开发，委托给handler去自行处理，对于它身上其他方法不会交给代理类去实现，所以对于getClass()方法，还是由Object本身实现的。即proxy3.getClass()，该是什么结果还是什么结果，并不会交给invoke方法处理。

五、总结分析动态代理类的统计原理和结构：

1、怎样将目标传进去：

1）直接在InvocationHandler实现类中创建目标类的实例对象，可看运行效果和加入日志代码，但是毫无意义。

2）为InvocationHandler实现类注入目标的实例对象，不能采用匿名内部类的形式了。

3）让匿名内部类的InvocationHandler实现类访问外面的方法中的目标类实例对象的final类型的引用变量。

2、动态代理的工作原理：

1）Client(客户端)调用代理，代理的构造方法接受一个InvocationHandler，client调用代理的各个方法，代理的各个方法请求转发给刚才通过构造方法传入的handler对象，又把各请求分发给目标的相应的方法。就是将handler封装起来，其中this引用了当前的放(发来什么请求就接受哪个方法)。

2）将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接受目标，同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。

在这里将InvocationHandler加入到Proxy的构造方法中，因此，在创建出来的对象，就会存有构造方法中InvocationHandler的一些功能和信息，因为我们把想要运行的代码封装在InvocationHandler对象，把它传入到构造函数中，那么就实现了代理对象每次调用目标方法（因为实现了同一接口）时，都会调用我们加入到InvocationHandler对象中的代码。这就保证了每次调用代理时，可以在目标上加入我们自己加入的功能。

3、把系统功能代理模块化，即切面代码也改为通过参数形式提供，怎么把要执行的系统功能代码以参数的形式提供：

1）把要执行的代码装到一个对象的某个方法中，然后把此对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外接提供的代码。

2）为bind方法增加一个Advice参数。

<span style="font-family:Arial;">//封装getProxy方法
package cn.itcast.test3;
import java.lang.reflect.*;
import java.util.*;
public class MyProxy {
	public static void main(String[] args)throws Exception {
		//创建目标对象，并进行操作测试
		final ArrayList target = new ArrayList();
		Collection proxy = (Collection)getProxy(target,new MyAdvice());
		proxy.add("sdf");
		proxy.add("wgcd");
		proxy.add("hgwe");
		System.out.println(proxy.size());
		
	}
	//作为一个通用的方法，就使用Object
	//传入一个目标，并传入一个接口，此接口作为通信的契约，才能调用额外的方法
	private static Object getProxy(final Object target,final Advice advice) {
		Object proxy = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),
				//这里的接口要和target实现相同的接口
				target.getClass().getInterfaces(),
				new InvocationHandler() {
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						//通过契约，使用其方法--before和after方法
						advice.beforeMethod(method);
						Object value = method.invoke(target, args);
						advice.afterMethod(method);
						return value;
					}
				}
				);
		return proxy;
	}
}
//创建实现Advice接口的子类
package cn.itcast.test3;
import java.lang.reflect.Method;
//实现Advice接口中方法的具体内容
public class MyAdvice implements Advice {

	long beginTime = 0;
	public void beforeMethod(Method method) {
		// TODO Auto-generated method stub
		System.out.println("从这里开始");
		beginTime = System.currentTimeMillis(); 
	}
	public void afterMethod(Method method) {
		// TODO Auto-generated method stub
		long endTime = System.currentTimeMillis();
		System.out.println("从这里结束");
		System.out.println(method.getName() + " run time of " + (endTime-beginTime));
	}
}
//创建接口Advice
import java.lang.reflect.Method;
/*接口中需要实现四个方法
 * 调用目标方法之前
 * 调用目标方法之后
 * 调用目标方法前后
 * 在处理目标方法异常的catch块中
 */
//这里只列出两个作为示例
public interface Advice {
	void beforeMethod(Method method);
	void afterMethod(Method method);
}
</span>

工厂类BeanFactory

1、工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。

2、getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则返回该类示例对象的getProxy方法返回的对象。

3、BeanFactory的构造方法接收代表配置文件的输入流对象的配置文件格式如下：

#xxx=java.util.ArrayList

xxx=cn.itcast.test3.aopframework.ProxyFactoryBean

xxx.advice=cn.itcast.test3.MyAdvice

xxx.target=java.util. ArrayList

注意：其中的#代表注释当前行。

4、ProxyFactoryBean充当封装成动态的工厂，需为工厂提供的配置参数信息包括：

目标（target）

通告（advice）

5、BeanFactory和ProxyFactoryBean：

1）BeanFactory是一个纯粹的bean工程，就是创建bean即相应的对象的工厂。

2）ProxyfactoryBean是BeanFactory中的一个特殊的Bean，是创建代理的工厂。

实现类似spring的可配置的AOP框架的思路

1、创建BeanFactory类：

1）构造方法：接受一个配置文件，通过Properties对象加载InputStream流对象获得。

2）创建getBean(String name)方法，接收Bean的名字，从上面加载后的对象获得。

3）通过其字节码对象创建实例对象bean。

4）判断bean是否是特殊的Bean即ProxyFactoryBean，如果是，就要创建代理类，并设置目标和通告，分别得到各自的实例对象，并返回代理类实例对象。如果不是在返回普通类的实例对象。

2、创建ProxyFactoryBean(接口)，此处用类做测试，其中有一个getProxy方法，用于获得代理类对象。

3、对配置文件进行配置，如上面配置一样。

4、作一个测试类：AopFrameworkTest进行测试。

<span style="font-family:Arial;">//创建BeanFactory类
package cn.itcast.test3.aopframework;
import java.io.*;
import java.util.Properties;
import cn.itcast.test3.Advice;
public class BeanFactory {
	Properties prop = new Properties();
	//创建对象时需要传入一个配置文件中的数据，所以需要在构造方法中接受一个参数
	public BeanFactory(InputStream ips) {
		try {
			//将配置文件加载进来
			prop.load(ips);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	//创建getBean方法，通过配置文件中的名字获取bean对象
	public Object getBean(String name){
		//从配置文件中读取类名
		String className = prop.getProperty(name);
		Object bean = null;
		try {
			//由类的字节码获取对象
			Class clazz = Class.forName(className);
			bean = clazz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		} 
		//判断bean是特殊的bean即ProxyFactoryBean还是普通的bean
		if(bean instanceof ProxyFactoryBean){
			Object proxy = null;
			try {
				//是ProxyFactoryBean的话，强转，并获取目标和通告
				ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;
				//获取advice和target
				Advice advice = (Advice)Class.forName(prop.getProperty(name + ".advice")).newInstance();
				Object target = Class.forName(prop.getProperty(name + ".target")).newInstance();
				//设置目标和通告
				proxyFactoryBean.setAdvice(advice);
				proxyFactoryBean.setTarget(target);
				//通过类ProxyFactoryBean（开发中是作为接口存在）中获得proxy对象
				proxy = proxyFactoryBean.getProxy();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} 
			//是ProxyFactoryBean的话，返回proxy对象
			return proxy;
		}
		//否则返回普通bean对象
		return bean;
	}
}

//创建ProxyFactoryBean类
package cn.itcast.test3.aopframework;
import java.lang.reflect.*;
import cn.itcast.test3.Advice;
public class ProxyFactoryBean {
	private Object target;
	private Advice advice;
	public Object getTarget() {
		return target;
	}
	public void setTarget(Object target) {
		this.target = target;
	}
	public Advice getAdvice() {
		return advice;
	}
	public void setAdvice(Advice advice) {
		this.advice = advice;
	}
	public Object getProxy() {
		Object proxy = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),
				//这里的接口要和target实现相同的接口
				target.getClass().getInterfaces(),
				new InvocationHandler() {
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						//通过契约，使用其方法--before和after方法
						advice.beforeMethod(method);
						Object value = method.invoke(target, args);
						advice.afterMethod(method);
						return value;
					}
				}
				);
		return proxy;
	}
}
//创建测试类AopFrameworkTest
package cn.itcast.test3.aopframework;
import java.io.InputStream;
public class AopFramewrorkTest {
	public static void main(String[] args)throws Exception {
		//读取配置文件的数据
		InputStream ips = 
				AopFramewrorkTest.class.getResourceAsStream("config.property");
		//获取bean对象
		Object bean = new BeanFactory(ips).getBean("xxx");
		System.out.println(bean.getClass().getName());
	}
}
</span>

----------------------   JavaEE+Android、Java培训、期待与您交流！ ----------------------

详细请查看： http://edu.csdn.net