设计模式之-代理模式

代理模式,今天我们就来说说代理模式,简单点来说就是相当于明星的经纪人一样,一般没有执行访问明星的,
都是通过访问其经纪人,再进行明星的访问的.

关于增强,java 的侵入性,最小的单位是一个方法,可以在方法执行前进行增强,也可以在方法执行后进行增强,最好不要直接进行方法中代码的
修改,这样就实现了功能的增强.

关于代理模式有多种实现的方式,有通过继承来实现代理的,一个具体的类继承原来类,对其中需要增强的方法进行增强,还有通过动态代理的
方式,只是在进行方法的调用的时候,进行动态的生成对象进行方法的增强.

首先我们来说类的继承来实现功能的增强:

**产品服务类
 * @author zhangke
 *
 */
public class ProductService {
    
    //保存方法
    public void save(){
        System.out.println("product 的save方法");
    }
    //查找方法,返回查找个数
    public int find(){
        System.out.println("这个事product的find方法/////");
        return 22;
    }
}


/**通过继承来进行代理的实现,耦合性过高
 * @author zhangke
 */
public class ProductServiceProxy extends ProductService {

    @Override
    public void save() {
        System.out.println("~~~在这个拦截的方法执行前执行");
        //还是调用原来的方法执行
        super.save();
        System.out.println("在这个拦截的方法执行后执行~~~");
    }

    @Override
    public int find() {
        System.out.println("~~~在这个拦截的方法执行前执行");
        //执行以前的方法,返回的结果加100了
        int find = super.find();
        System.out.println("在这个拦截的方法执行后执行~~~");
        return find+100;
    }
}

这种方式耦合性较强,但是很容易理解.


下面我们来说JDK自带的动态代理的方法:
面向接口的代理方式:

/**客户服务接口的类
 * @author zhangke
 *
 */
public interface ICustomerService {
    void save();
    int find();
}

//实现类
public class CustomerService  implements ICustomerService{
    @Override
    public void save() {
        System.out.println("service的方法保存了");
    }

    @Override
    public int find() {
        System.out.println("service的find的方法保存了");
        return 11;
    }
}


/**JDK的动态代理
 * @author zhangke
 *
 */
public class JDKProxyFactory {
    private Object target;
    //使用构造函数传递对象进来
    public JDKProxyFactory(Object target) {
        super();
        this.target = target;
    }

    //方案1
/*    public Object getProxyObject(){
    return    Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if("save".equals(method.getName())){
                    System.out.println("~~~在这个拦截的方法执行前执行");
                }
                Object invoke = method.invoke(target, args);
                System.out.println("在这个拦截的方法执行后执行~~~");
                return invoke;
            }
        });
    }*/
    
    
    //方案2
    public Object getProxyObject(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new myInvokeHandler());
    }
    
    private class myInvokeHandler implements   InvocationHandler{
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if("save".equals(method.getName())){
                System.out.println("~~~在这个拦截的方法执行前执行");
            }
            Object invoke = method.invoke(target, args);
            System.out.println("在这个拦截的方法执行后执行~~~");
            return invoke;
        }
    }
    
    
    //方案3
    //这个类自己实现InvocationHandler接口,重写方法
/*    public Object getProxyObject(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }*/
    

/*    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if("save".equals(method.getName())){
            System.out.println("~~~在这个拦截的方法执行前执行");
        }
        Object invoke = method.invoke(target, args);
        System.out.println("在这个拦截的方法执行后执行~~~");
        return invoke;
    }*/
}


最后一个就是Spring 的Cglib代理方法,cglib是通过继承的方法进行代理.

/**Spring的Cglib 的继承的代理
 * @author zhangke
 *
 */
public class CglibProxyFactory  implements MethodInterceptor{
    //传递对象过来进行代理
    private Object target;
    //使用构造函数传递对象进来
    public CglibProxyFactory(Object target) {
        super();
        this.target = target;
    }
    
    /**得到代理的对象
     * @return
     */
    public Object getProxyObject(){
        //1.代理对象生成器
        Enhancer enhancer = new Enhancer();
        //2.在增强器上设置两个属性
        //设置要生成代理对象的目标对象：生成的目标对象类型的子类型
        enhancer.setSuperclass(target.getClass());
        //设置回调方法
        enhancer.setCallback(this);
        //返回对象
        return enhancer.create();
    }
    
    //这个就是回调的方法,需要实现MethodInterceptor这个接口的
    @Override
    public Object intercept(Object proxy, Method method, Object[] arg2, MethodProxy methodProxy) throws Throwable {
        if("save".equals(method.getName())){
            System.out.println("~~~在这个拦截的方法执行前执行");
        }
        Object invoke = method.invoke(target, arg2);
        System.out.println("在这个拦截的方法执行后执行~~~");
        return invoke;
    }
}

相比较而言,同时生成10000个代理对象,使用JDK的接口代理方式效率会比cglib的效率高.所以我也是推荐面向接口编程.


测试方法:
public class ProxyTest {
//JDK的代理
    @Test
    public void test(){
        ICustomerService target = new CustomerService();
        JDKProxyFactory jdkProxyFactory = new JDKProxyFactory(target);
         ICustomerService  proxy= (ICustomerService) jdkProxyFactory.getProxyObject();
         proxy.save();
         proxy.find();
    }

//cglib的代理方式    
    @Test
    public void test2(){
        ProductService target = new ProductService();
        CglibProxyFactory factory = new CglibProxyFactory(target);
        ProductService  proxyObject=(ProductService) factory.getProxyObject();
        proxyObject.save();
        proxyObject.find();
    }
}