代理设计模式

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
RealSubject 是原对象（本文把原对象称为"委托对象"），Proxy 是代理对象。
Subject 是委托对象和代理对象都共同实现的接口。
Request() 是委托对象和代理对象共同拥有的方法

public class ProxyDemo {
    public static void main(String args[]){
        RealSubject subject = new RealSubject();
        Proxy p = new Proxy(subject);
        p.request();
    }
}

interface Subject{
    void request();
}

class RealSubject implements Subject{
    public void request(){
        System.out.println("request");
    }
}

class Proxy implements Subject{
    private Subject subject;
    public Proxy(Subject subject){
        this.subject = subject;
    }
    public void request(){
        System.out.println("PreProcess");
        subject.request();
        System.out.println("PostProcess");
    }
}

---

1. 定义一个委托类和公共接口。
2. 自己定义一个类（调用处理器类，即实现 InvocationHandler 接口），这个类的目的是指定运行时将生成的代理类需要完成的具体任务（包括Preprocess和Postprocess），即代理类调用任何方法都会经过这个调用处理器类（在本文最后一节对此进行解释）。
3. 生成代理对象（当然也会生成代理类），需要为他指定(1)委托对象(2)实现的一系列接口(3)调用处理器类的实例。因此可以看出一个代理对象对应一个委托对象，对应一个调用处理器实例。

Java 实现动态代理主要涉及以下几个类：
java.lang.reflect.Proxy: 这是生成代理类的主类，通过 Proxy 类生成的代理类都继承了 Proxy 类，即 DynamicProxyClass extends Proxy。
java.lang.reflect.InvocationHandler: 这里称他为"调用处理器"，他是一个接口，我们动态生成的代理类需要完成的具体内容需要自己定义一个类，而这个类必须实现 InvocationHandler 接口。

Proxy 类主要方法为：

//创建代理对象

static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler handler)
{
    //1. 根据类加载器和接口创建代理类
    Class clazz = Proxy.getProxyClass(loader, interfaces); 
    //2. 获得代理类的带参数的构造函数
    Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });
    //3. 创建代理对象，并制定调用处理器实例为参数传入
    Interface Proxy = (Interface)constructor.newInstance(new Object[] {handler});
}

具体过程：

public class DynamicProxyDemo01 {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();    //1.创建委托对象
        ProxyHandler handler = new ProxyHandler(realSubject);   //2.创建调用处理器对象
        Subject proxySubject = (Subject)Proxy.newProxyInstance(RealSubject.class.getClassLoader(),
                                                        RealSubject.class.getInterfaces(), handler);    //3.动态生成代理对象
        proxySubject.request(); //4.通过代理对象调用方法
    }
}

/**
 * 接口
 */
interface Subject{
    void request();
}

/**
 * 委托类
 */
class RealSubject implements Subject{
    public void request(){
        System.out.println("====RealSubject Request====");
    }
}
/**
 * 代理类的调用处理器
 */
class ProxyHandler implements InvocationHandler{
    private Subject subject;
    public ProxyHandler(Subject subject){
        this.subject = subject;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("====before====");//定义预处理的工作，当然你也可以根据 method 的不同进行不同的预处理工作
        Object result = method.invoke(subject, args);
        System.out.println("====after====");
        return result;
    }
}

---

cglib动态代理：

public class TransctionHandle implements InvocationHandler{

    // 增强
    private TransactionManagear tx;
    private Object  object;

    public TransctionHandle(TransactionManagear tx,Object object){
        this.tx = tx;
        this.object = object;
    }
    
    /**
     * proxy:代理对象
     * method：目标对象中正在执行的方法
     * args：参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        tx.begin();
        Object invoke = method.invoke(object, args); //调用目标方法
        tx.commit();
        return invoke;
    }

}

public void testDynamicProxy() {
        
        // 1.增强
        TransactionManagear tx = new TransactionManagear();
        
        // 2.目标对象
        UserServiceImpl userService = new UserServiceImpl();
        
        // 3.实例化拦截器
        TransactionManagerInterceptor tmi = new TransactionManagerInterceptor(tx);
        
        
        // 4.创建代理类
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(userService.getClass()); // 设置目标对象
        enhancer.setCallback(tmi);
        
        // 5.得到代理对象
        UserServiceImpl  userServiceProxy = (UserServiceImpl)enhancer.create();
        
        // 6.调用目标方法
        userServiceProxy.add();
        System.out.println("==========================");
        userServiceProxy.fidnById(10);
    }

静态代理和jdk动态代理对比：

1. 静态代理
   1)必须要有接口
   2)代理类和目标对象都要实现该接口
   3)由代理对象调用目标对象
   4)可以实现AOP的思想，但是每个目标对象都要创建一个代理，代理类过多。

2. jdk实现动态代理
   1)如何实现
   a)定义handle
   1)要写一个handle实现InvocationHandler
   2)在这个handle里面传入
   a)目标对象
   b)增强
   c)创建代理对象
   1)目标对象的类加载器
   2)目标对象的接口
   3)自定义的handle
   2)动态代理解决了静态代理遗留的问题(代理类过多)，但是它也存在缺点，必须要有接口

3. 基于cglib实现的动态代理
   1)定义一个方法的拦截器
   a)要实现MethodInterceptor接口
   2)通过Enhancer创建代理对象
   a)要设置父类的calss
   b)要设置拦截器
   3)底层实现
   1)给目标对象创建一个子类，所以在设置的时候enhancer.setSuperclass(userService.getClass())
   2)复写父类中的方法
   3)给子类的方法加了一个拦截器
   3)我们看到的代理对象其实就是子类
   4)缺点是给目标对象中的所有方法都加了增加

转载于:https://www.cnblogs.com/jwlxtf/p/8037241.html