代理

代理

(1)代理的概念

1.生活中的代理：

我们从手机代理商那里买手机，而不是直接从厂商那里购买，这样使我们非常方便地就完成了买手机这一件事。

2.程序中的代理：

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

3.代理类的优点：

如果采用工厂模式和配置文件的方式进行管理，就不需要修改客户端程序，只需要在配置文件中配置使用目标类，或者代理类即可。这样，以后很容易切换。例如，想要日志功能时就配置代理类，否则就配置目标类。

4.一个简单的案例

目标类	代理类
class X{	Xproxy{
void sayHelloWorld(){	void sayHelloWorld(){
System.out.println("helloworld");	startTime;
}	X. sayHello();
}	endTime;}}

一般用接口来引用其子类，如：Collectioncoll = new ArrayList();

2.AOP  面向方面的编程

系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：

安全       事务         日志

StudentService  ------|----------|------------|-------------

CourseService   ------|----------|------------|-------------

MiscService       ------|----------|------------|-------------

安全、事物、日志等功能要贯穿到很多模块中去，所以它们都是交叉业务。

交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：

------------------------------------------------------切面

func1         func2            func3

{             {                { 

....            ....              ......

}             }                }

------------------------------------------------------切面

使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。

(2)动态代理技术

1.动态代理的引入

要为系统中的各种接口增加代理功能，那么就需要很多的代理类，全部采用静态代理的饭食，就需要写出成百上千个代理类，这样，就会非常地方麻烦，这时，我们 就会采用动态代理的我们就会采用动态代理的方式，那么什么是动态代理呢？

动态代理是JVM可以在运行期动态生成出类的字节码，这种动态生成的类被用做代理类的方式就是动态代理

注意：

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

2.动态代理的使用

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

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

1）在调用目标方法之前

2）在调用目标方法之后

3）在调用目标方法前后

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

3.分析JVM动态生成的类

让jvm创建动态类及其实例对象，需要给它提供哪些信息?

三个方面：

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

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

3、生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了

4.分析动态代理类的统计原理和结构：

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参数。
利用InvocationHandler接口创建代理类代码示例：

Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);//创建代理类  
Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);//获取代理类的构造方法  
  
  
  
class MyInvocationHandler1 implements InvocationHandler//内部类，实现InvocationHandler接口  
{              
    public Object invoke(Object proxy, Method method, Object[] args)      
        throws Throwable {                
            return null;      
        }                     
}   
            
//代理类通过反射调用方法，参数为内部类的实例对象  
Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHandler1());  
System.out.println(proxy1.toString());      
  
//运用匿名内部类  
Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler()  
{          
    public Object invoke(Object proxy, Method method, Object[] args)      
        throws Throwable {                    
            return null;      
    }                 
});      
  
//用Proxy的静态方法newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)     
  
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 startTime = System.currentTimeMillis();      
        Object retVal = method.invoke(target, args);      
        long endTime = System.currentTimeMillis();      
        System.out.println(method.getName()+"  running time:"+(endTime - startTime));      
        return retVal;                            
    }      
                  
});      

动态代理类框架： 
//事务接口  
public interface Advice {    
    void beforeMethod(Method method);//方法执行之前执行的方法  
    void afterMethod(Method method);//方法执行之后执行的方法  
}  
  
//实现事务接口  
public class MyAdvice implements Advice {    
    long startTime=0;    
    @Override    
    public void beforeMethod(Method method) { //覆盖父类方法  
        startTime = System.currentTimeMillis();    
    }    
    
    @Override    
    public void afterMethod(Method method) {    //覆盖父类方法  
        long endTime = System.currentTimeMillis();    
    System.out.println(method.getName()+"  running time:"+(endTime - startTime));    
    }      
}    
  
//创建代理框架  
public static Object getProxy(final Object target,final Advice advice) {//传入目标类与事务类  
    Object proxy3 =Proxy.newProxyInstance(    
        target.getClass().getClassLoader(),  //类加载器  
        target.getClass().getInterfaces(),//实现的接口  
        new InvocationHandler() {                   
        @Override    
        public Object invoke(Object proxy, Method method, Object[] args)    
            throws Throwable {    
        advice.beforeMethod(method);//执行事务类方法  
        Object retVal = method.invoke(target, args);//执行目标类的方法  
        advice.afterMethod(method);//执行事务类方法  
        return retVal;    
        }    
    });  
    return proxy3;    
}    

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

工厂类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进行测试。

//创建BeanFactory类     
package cn.itcast.test3.aopframework;    
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Properties;
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());    
    }    
}