黑马程序员——高新技术--代理-CSDN博客

本文链接：https://blog.csdn.net/u012126525/article/details/49225879

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

代理：

生活中的代理
武汉人从武汉的代理商手中买联想电脑和直接跑到北京传智播客旁边来找联想总部买电脑，你觉得最终的主体业务目标有什么区别吗？基本上一样吧，都解决了核心问题，但是，一点区别都没有吗？从代理商那里买真的一点好处都没有吗？

程序中的代理
要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，你准备如何做？
编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。

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

AOP：

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

                      安全       事务         日志
StudentService  ------|----------|------------|-------------
CourseService   ------|----------|------------|-------------
MiscService     ------|----------|------------|-------------

用具体的程序代码描述交叉业务：

method1         method2          method3
{                      {                       {
------------------------------------------------------切面
....                    ....                     ......
------------------------------------------------------切面
}                       }                       }

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

------------------------------------------------------切面
func1     func2    func3
{             {                {
....            ....              ......
}             }                }
------------------------------------------------------切面

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

注意：
安全，事务，日志等功能要贯穿到好多个模块中，所以，它们就是交叉业务。

重要原则：不要把供货商暴露给你的客户。

动态代理技术

要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！

JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。

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

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

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

在调用目标方法之前
在调用目标方法之后
在调用目标方法前后
在处理目标方法异常的catch块中

例子：

Class proxy{
     void sayHello(){
          ……….
          try{
               target.sayHello();
          }catch(Exception e){
               ………..
          }
          ………….
     }
}

创建动态类及查看其方法列表信息

创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。
编码列出动态类中的所有构造方法和参数签名。
编码列出动态类中的所有方法和参数签名。

import java.lang.reflect.*;
import java.util.*;

public class ProxyTest {

    public static void main(String[] args) {

        //*通过指定一个类加载器跟一个接口获得一个Class对象*/
        Class clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class );
        System. out.println(clazzProxy.getName());

        System. out.println("--------begin constructors list-------");

        //*打印该class的各个构造函数及其参数列表*/
        Constructor[] constructors = clazzProxy.getConstructors();
        for(Constructor constructor : constructors){
              String name = constructor.getName();
              StringBuilder sBuilder = new StringBuilder(name);
              sBuilder.append( "(");
              Class[] clazzParams = constructor.getParameterTypes();
              for(Class clazzParam : clazzParams){
                  sBuilder.append(clazzParam.getName()).append( ",");
              }
              if(clazzParams != null && clazzParams.length != 0){
                  sBuilder.deleteCharAt(sBuilder.length() - 1);
              }
              sBuilder.append( ")");
              System. out.println(sBuilder);
        }

        //*打印该class的各个方法及其参数列表*/
        System. out.println("--------begin methods list-------" );
        Method[] methods = clazzProxy.getMethods();
        for(Method method : methods){
            String name = method.getName();
            StringBuilder sBuilder = new StringBuilder(name);
            sBuilder.append( "(");
            Class[] clazzParams = method.getParameterTypes();
            for(Class clazzParam : clazzParams){
                sBuilder.append(clazzParam.getName()).append( ",");
            }
            if(clazzParams != null && clazzParams.length != 0){
                sBuilder.deleteCharAt(sBuilder.length() - 1);
            }
            sBuilder.append( ")");
            System. out.println(sBuilder);
        }
    }
}

创建动态类的实例对象及调用其方法：

创建动态类的实例对象。

用反射获得构造方法。
编写一个最简单的InvocationHandler类。
调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去。
将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。

总结思考：
让jvm创建动态类及其实例对象，需要给它提供哪些信息?
答：三个方面：

生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
产生的类字节码必须有个一个关联的类加载器对象；
生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。

import java.lang.reflect.*;
import java.util.*;

public class ProxyTest {

    public static void main(String[] args) throws Exception {
        Class clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class );

        System. out.println("--------begin create instance object-------");

        //获取构造函数对象，传入的参数为InvocationHandler.class，这是个接口
        Constructor constructor = clazzProxy.getConstructor(InvocationHandler.class) ;

        //要使用该构造函数对象得到实例对象需要传入参数类的实例对象，这时要创建类实现该接口，再创建对象。也可以使用匿名对象
        Collection proxy1 = (Collection)constructor.newInstance(new InvocationHandler(){
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                return null ;
            }
        });

        System. out.println(proxy);
        //结果：null
        proxy.clear();
        //执行没有返回值的方法，不会报告异常
        proxy.size();
        //执行有返回值的方法，会报告异常
    }
}

用Proxy.newInstance方法可以直接一步就创建出代理对象。

import java.lang.reflect.*;
import java.util.*;

public class ProxyTest {

    public static void main(String[] args) throws Exception {

        //传入三个参数：类加载器，接口，实现InvocationHandler接口的对象
        Collection proxy = (Collection)Proxy.newProxyInstance(

            //类加载器
            Collection. class.getClassLoader(),

            //接口数组
            new Class[]{Collection.class},

            //实现InvocationHandler接口的对象
            new InvocationHandler() {
                ArrayList target = new ArrayList();

                //代理对象的方法
                public Object invoke(Object proxy, Method method, Object[] args)
                        throws Throwable {
                    long beginTime = System.currentTimeMillis();
                    Object retVal = method.invoke(target,args);
                    long endTime = System.currentTimeMillis();
                    System. out.println(method.getName() + " running out of " + (endTime - beginTime));
                    return retVal;
                }
            }
        );

        proxy.add("zxx");
        proxy.add("lhm");
        proxy.add("bxd");
        System. out.println(proxy.size());
        //结果：3
    }
}

注意：
如果作为target的ArrayList对象放置在invoke方法内部定义，那么每次调用代理的某个方法，都会调用invoke方法，这样作为target的ArrayList对象每次都会被创建，这样就导致最后调用proxy.size()的时候，结果为0。

InvocationHandler对象的运行原理：
动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。

构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？
答：接受的对象会通过构造函数赋值给某个成员变量。

$Proxy0 implements Collection
{
     InvocationHandler handler;
     public $Proxy0(InvocationHandler handler)
     {
          this.handler = handler;
     }
}
实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？图解说明如下：

这里写图片描述

像上面的add()、size()方法执行的时候就会把这三个参数传递到invoke()方法中去，委托InvocationHandler对象执行，然后接收invoke()方法的返回值作为add()，size()方法的返回值。

总结分析动态代理类的设计原理与结构：
这里写图片描述

                        动态代理的工作原理图

调用代理方法时，代理方法会把参数传给InvocationHandler对象，InvocationHandler对象根据log配置信息决定调用哪个方法，再把得到的值返回给代理方法。

注意：
源对象的类必须自己定义时就实现接口，从该类的祖辈类上继承的接口是无效的。

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

将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？

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

import java.lang.reflect.*;
import java.util.*;

//定义接口
public interface Advice {

       //在调用目标方法前的功能代码
       void beforeAdvice(Method method);

       //在调用目标方法后的功能代码
       void afterAdvice(Method method);
}

//定义类实现接口
public class MyAdvice implements Advice {

       private long beginTime = 0;

       public void afterAdvice(Method method) {
             long endTime = System.currentTimeMillis();

             //打印代码执行时间
             System. out .println(method.getName() + " running out of " + (endTime - beginTime));
      }

       public void beforeAdvice(Method method) {
             beginTime = System.currentTimeMillis();
      }

}

//代理规则
public class ProxyTest {

    public static void main(String[] args) throws Exception {

       //target被内部类调用，要声明final
       final ArrayList target = new ArrayList ();

       //通过getProxy方法获取代理对象
       Collection collection = (Collection) getProxy(target,new MyAdvice());
       collection.add("zxx" );
       //结果：add running out of 0
    }

    //通用的获取代理方法，传入两个对象（以获取类加载器和接口的对象）和（调用增强功能的对象）。
    public static Object getProxy(final ArrayList target,final Advice advice) {
        Object proxy = Proxy.newProxyInstance(

            //通过target获取类加载器和接口类
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),


            new InvocationHandler() {
                public Object invoke(Object proxy, Method method, Object[] args)
                       throws Throwable {
                //运行代码前功能
                advice.beforeAdvice(method);

                //计算返回值
                Object retVal = method.invoke(target ,args);

                //运行代码后功能
                advice.afterAdvice(method);

                return retVal;
                }
            }
        );
        return proxy;
    }
}

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

工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该类实例对象的getProxy方法返回的对象。

BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：
- #xxx=java.util.ArrayList //非特殊类，创建出xxx对应的ArrayList类实例对象并返回
- xxx=cn.itcast.ProxyFactoryBean //特殊类，返回代理类的实例对象
- xxx.target=java.util.ArrayList //用来获取类加载器和接口的对象
- xxx.advice=cn.itcast.MyAdvice //实现增强功能的对象

ProxyFacotryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？
- 目标
- 通知

编写客户端应用：
- 编写实现Advice接口的类和在配置文件中进行配置
- 调用BeanFactory获取对象

import java.lang.reflect.*;
import java.io.*;
import java.util.*;

import com.itheima.day3.Advice;

//定义特殊Bean
public class ProxyFactoryBean {
    private Advice advice ;
    private Object target ;

    public Advice getAdvice() {
        return advice ;
    }

    public void setAdvice(Advice advice) {
        this .advice = advice;
    }

    public Object getTarget() {
        return target ;
    }

    public void setTarget(Object target) {
        this .target = target;
    }

    public Object getProxy(){
        Object proxy = Proxy. newProxyInstance(
            target .getClass().getClassLoader(),
            target .getClass().getInterfaces(),
            new InvocationHandler() {
                public Object invoke(Object proxy, Method method, Object[] args)
                         throws Throwable {
                    advice .beforeAdvice(method);
                    Object retVal = method.invoke( target ,args);
                    advice .afterAdvice(method);
                    return retVal;
                }
            }
        );
        return proxy;
    };
}

//工厂类BeanFactory，负责创建目标类或代理类的实例对象
public class BeanFactory {

    Properties props = new Properties();

    //通过构造函数接收配置文件的流
    public BeanFactory(InputStream ips){
          try {

                //从流中加载配置文件
                props.load(ips);
         } catch (IOException e) {
               e.printStackTrace();
         }
    }

    public Object getBean(String name) {

        //从配置文件中获取类名
        String className = props.getProperty(name);
        Object bean = null;
        try {

            //通过类名获取Class对象
            Class clazz = Class.forName(className);

            //通过空参数构造函数获取对象
            bean = clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }

        //如果是特殊的Bean，就获取代理
        if(bean instanceof ProxyFactoryBean){
            ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;
            Object proxy = null;
            try {

                //通过配置文件中的类名获取advice跟target对象
                Advice advice = (Advice) Class.forName(
                             props.getProperty(name + ".advice")).newInstance();
                Object target = Class. forName(
                             props.getProperty(name + ".target")).newInstance();

                //把advice跟target设置到类的代理方法中去
                proxyFactoryBean.setAdvice(advice);
                proxyFactoryBean.setTarget(target);

                //通过类对象的getProxy方法获取代理对象
                proxy = proxyFactoryBean.getProxy();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return proxy;
        }
        return bean;
    }
}

//主体功能
public class AopFrameworkTest {

    public static void main(String[] args) throws Exception{

        //配置文件加载进流
        InputStream ips = AopFrameworkTest.class .getResourceAsStream("config.properties");

        //把流作为参数创建BeanFactory对象并调用getBean功能
        Object bean = new BeanFactory(ips).getBean("xxx" );
        System. out.println(bean.getClass().getName());
    }
}