黑马程序员________Java动态代理类的学习和个人理解

------- android培训、java培训、期待与您交流！ ----------

        要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异理、日志、计算方法的运行时间、事务管理就需要用到代理。交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。

        代理类可以分为两种。 

静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 

动态代理：在程序运行时，运用反射机制动态创建而成。 

假设有一个Person类他继承了print接口，而我们需要他在提供打印功能的同时能显示打印一共用了多少秒。我们先用静态代理来做。

package com.itheima.gaoxin;

import java.util.List;

import java.util.ArrayList;

public class ProxyDemo {

public static void main(String[] args) {

Print p=new PrintProxy(new Person());//面向接口创建Print接口的代理类

p.printCount();

}

}

interface Print{

void printCount();

}

class Person implements Print{//人对象实现print接口

public void printCount(){

for(int x=0;x<1000;x++){

System.out.println(x);

}

}

}

class PrintProxy implements Print{

private Print p;

public PrintProxy(Print p){//构造函数接收一个实现print接口的对象

this.p=p;

}

public void printCount(){

long start=System.currentTimeMillis();//实现被代理对象功能的前提下，增加了获取运行时间的功能

p.printCount();

long end=System.currentTimeMillis();

System.out.println("共耗时"+(end-start)+"毫秒");

}

}

        但是这样每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作动态代理类。

        

        JDK动态代理中包含一个类和一个接口： 

        InvocationHandler接口： 

public interface InvocationHandler { 

public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 

} 

其中 Object proxy：指被代理的对象。 

Method method：要调用的方法 

Object[] args：方法调用时所需要的参数 

可以将InvocationHandler接口的子类想象成一个代理的最终操作类

。 

Proxy类： 

Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类。

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, 

InvocationHandler h)   throws IllegalArgumentException 

其中  ClassLoader loader：类加载器 

Class<?>[] interfaces：得到全部的接口 

InvocationHandler h：得到InvocationHandler接口的子类实例 

我们可以用一个方法来获得一个任意对象的代理类。以下代码是根据老师的思路写出

package com.itheima.gaoxin;


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;




public class ProxyDemo {


public static void main(String[] args) {


//Print p=new PrintProxy(new Person());
//p.printCount();


Person person=new Person();
Print personProxy=(Print)getProxy(person);//调用方法，并将要代理的对象传入，代理对象是面向接口的
personProxy.printCount();


}

public static Object getProxy(final Object target){//因为被代理对象要被InvocationHandler内部类访问，所以要用final修饰
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), 
new InvocationHandler() {

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
long start=System.currentTimeMillis();//

Object reVal=method.invoke(target, args);

long end=System.currentTimeMillis();
System.out.println("共耗时"+(end-start)+"毫秒");
return reVal;

}

});

}

}


interface Print{
void printCount();
}


class Person implements Print{//人对象实现print接口
public void printCount(){
for(int x=0;x<1000;x++){
System.out.println(x);
}
}

public void ssyHello(){
System.out.println("hello");
}

}

但是把一个功能放在主函数内毕竟不方便，于是课后自己就想把他封装到一个类里，而这个类本省实现InvocationHandler接口，里面的获得代理类方法直接调用自身。

package com.itheima.gaoxin;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

public class ProxyDemo {

public static void main(String[] args) {

//Print p=new PrintProxy(new Person());//面向接口创建Print接口的代理类

//p.printCount();

Person person=new Person();

TimeProxy tp=new TimeProxy();

Print personProxy=(Print)tp.getProxy(person);//代理对象是面向接口的

personProxy.printCount();

}

}

class TimeProxy implements InvocationHandler{

private Object target;//要被代理的对象

public Object getProxy(Object target){//传入要被代理的对象

this.target=target;

return Proxy.newProxyInstance(target.getClass().getClassLoader(),//返回代理对象

target.getClass().getInterfaces(),

this);//这里本类就是一个InvocationHandler接口的实现类

}

@Override

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

// TODO Auto-generated method stub

long start=System.currentTimeMillis();

Object reVal=method.invoke(target, args);

long end=System.currentTimeMillis();

System.out.println("共耗时"+(end-start)+"毫秒");

return reVal;

}

}

interface Print{

void printCount();

}

class Person implements Print{

public void printCount(){

for(int x=0;x<1000;x++){

System.out.println(x);

}

}

public void ssyHello(){

System.out.println("hello");

}

}

学习完代理类总感觉他跟装饰类十分相似，搞不清他们到底是区别在哪里。于是上网查资料，终于弄明白。

装饰类是新增某个功能，多出来很多自定义的方法，而调用其中某一项已有功能的时候，仍然是原类的方法。客户端用的是面向具体类编程，而且端已知该类不是本类。

代理类是控制接口中方法的功能，方法还是原来的方法，但是运行他们中的每一个方法都会去执行自定义的代理代码，从而达到了控制的作用，比如在执行原方法代码前，加一个判断语句，如果不满足则return null。客户端是面向接口编程，而且不知道该类是不是本类。