代理模式

代理模式是指，为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户类和目标对象之间起到中介的作用。

换句话说，使用代理对象，是为了在不修改目标对象的基础上，增强主业务逻辑。 客户类真正的想要访问的对象是目标对象，但客户类真正可以访问的对象是代理对象。客户类对目标对象的访问是通过访问代理对象来实现的。当然，代理类与目标类要实现同一个接口。

对于代理模式，需要注意以下几点： 　　
　　（1）代理类和目标类要实现同一个接口，即业务接口。 

　　（2）客户类对目标类的调用均是通过代理类完成的。

　　（3）代理类的执行既执行了对目标类的增强业务逻辑，又调用了目标类的主业务逻辑。

根据代理关系建立的时间不同，可以将代理分为两类：静态代理与动态代理。

静态代理：

　　静态代理是指，代理类在程序运行前就已经定义好，其与目标类的关系在程序运行前就已经确立。

package com.tongji.csis.qjj;

//业务接口
public interface ISomeService {
    String doSome();
    String doSecond();
}

package com.tongji.csis.qjj;

//目标类,主要实现了业务接口的主业务逻辑，这些方法称为目标方法
public class SomeServiceImpl implements ISomeService {

    @Override
    public String doSome() {
        System.out.println("执行doSome()");
        return "I Love you";
    }

    @Override
    public String doSecond() {
        System.out.println("执行doSecond()");
        return "China";
    }
    
}

package com.tongji.csis.qjj;

//静态代理类
//要求静态代理类与目标类实现相同的业务接口
public class SomeServiceProxy implements ISomeService {
    //声明业务接口对象
    private ISomeService target;
    
    public SomeServiceProxy() {
        super();
    }
    //业务接口对象作为构造器参数，用于接收目标对象
    public SomeServiceProxy(ISomeService target) {
        super();
        this.target = target;
    }

    @Override
    public String doSome() {
        return target.doSome();
    }
    //代理方法，实现对目标方法的功能增强
    @Override
    public String doSecond() {
        return target.doSecond().toUpperCase();
    }
    
}

package com.tongji.csis.qjj;

public class MyTest {

    public static void main(String[] args) {
        //定义目标对象
        ISomeService target = new SomeServiceImpl();
        //定义目标对象的代理对象
        ISomeService serviceProxy = new SomeServiceProxy(target);
        String result1 = serviceProxy.doSome();
        String result2 = serviceProxy.doSecond();
        System.out.println(result1 + "," + result2);
    }
    
}

JDK动态代理：

　　动态代理是指，程序在整个运行过程中根本就不存在目标类的代理类，目标对象的代理对象只是由代理生成工具（如代理工厂类）在程序运行时由JVM根据反射等机制动态生成的。代理对象与目标对象的代理关系在程序运行时才确立。
　　对比静态代理，静态代理是指在程序运行前就已经定义好了目标类的代理类。代理类与目标类的代理关系在程序运行之前就确立了。

　　动态代理的实现方式常用的有两种：使用JDK的Proxy，与通过CGLIB生成代理。 通过JDK的java.lang.reflect.Proxy类实现动态代理，会使用其静态方法newProxyInstance()，依据目标对象、业务接口及业务增强逻辑三者，自动生成一个动态代理对象。

　　JDK动态代理代码中的业务接口代码和目标类代码和上面相同；

package com.tongji.csis.qjj;

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

//主业务增强逻辑类
public class MyExtension implements InvocationHandler {

    private Object target;
    
    public MyExtension(Object target) {
        super();
        this.target = target;
    }

    //增强方法，proxy:代理对象；method:目标方法；args:目标方法的参数列表
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String result = (String) method.invoke(target,args);
        if ("doSecond".equals(method.getName())) {
            result = result.toUpperCase();
        }
        return result;
    }

}

package com.tongji.csis.qjj;

import java.lang.reflect.Proxy;

public class MyTest {

    public static void main(String[] args) {
        
        //定义目标对象
        ISomeService target = new SomeServiceImpl();
        //定义目标对象的代理对象
        ISomeService serviceProxy = (ISomeService) Proxy.newProxyInstance(
                                        target.getClass().getClassLoader(),  //获取目标对象的类加载器
                                        target.getClass().getInterfaces(),   //获取目标对象的所有接口
                                        new MyExtension(target));            //增强业务逻辑
        
        String result1 = serviceProxy.doSome();
        String result2 = serviceProxy.doSecond();
        System.out.println(result1 + "," + result2);
    }

}

　　　　JDK的动态代理，底层是通过“工厂+反射机制”，动态创建静态代理中的代理类。

　　

　　CGLIB动态代理：

　　　　使用JDK的Proxy实现代理，要求目标类与代理类实现相同的接口。若目标类不存在接口，则无法使用该方式实现。 
　　　　但对于无接口的类，要为其创建动态代理，就要使用CGLIB来实现。CGLIB代理的生成原理是生成目标类的子类，而子类是增强过的，这个子类对象就是代理对象。所以，使用CGLIB生成动态代理，要求目标类必须能够被继承，即不能是final的类。

　　　　CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM(Java字节码操控框架)，来转换字节码并生成新的类。CGLIB是通过对字节码进行增强来生成代理的。

　　　　CGIB动态代理代码中没有业务接口代码；

package com.tongji.csis.qjj;

//目标类
public class SomeService {

    public String doSome() {
        System.out.println("执行doSome()");
        return "I Love you";
    }

    public String doSecond() {
        System.out.println("执行doSecond()");
        return "China";
    }
    
}

package com.tongji.csis.qjj;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

//CGLIB代理类的生成工厂
public class CglibProxyFactory implements MethodInterceptor {
    
    private SomeService target;
    
    public CglibProxyFactory() {
        super();
    }
    
    public CglibProxyFactory(SomeService target) {
        super();
        this.target = target;
    }

    //用于创建Cglib代理对象
    public SomeService myProxyCreator() {
        //增强器:指定父类，既要增强的目标类,并指定回调接口对象
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(SomeService.class);
        enhancer.setCallback(this);
        return (SomeService) enhancer.create();
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args,
            MethodProxy methodProxy) throws Throwable {
        String result = (String) method.invoke(target,args);
        if ("doSecond".equals(method.getName())) {
            result = result.toUpperCase();
        }
        return result;
    }
}

package com.tongji.csis.qjj;

public class MyTest {

    public static void main(String[] args) {
        //定义目标对象
        SomeService target = new SomeService();
        //定义目标对象的代理对象
        SomeService serviceProxy = new CglibProxyFactory(target).myProxyCreator();
        String result1 = serviceProxy.doSome();
        String result2 = serviceProxy.doSecond();
        System.out.println(result1 + "," + result2);
    }

}