【学习设计模式+手写】jdk动态代理与cglib动态代理（代理设计模式）

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

提一下静态代理

接口

/**
 * 接口
 * @author Jay
 * @date 2020/7/10 11:38
 * @Description:
 */
public interface BookService{
    void buyBook();
}

2.委托类

/**
 * @author Jay
 * @date 2020/7/10 11:37
 * @Description:
 */
/**
 * 实现类
 * @date 2020/7/10 11:11
 */
public class BookServiceImpl implements BookService{

    @Override
    public void buyBook() {
        System.out.println("买书");
    }
}

3.代理类

/**代理类
 * @author Jay
 * @date 2020/7/10 11:39
 * @Description:
 */

public class BookServiceProxy implements BookService{

    private BookService bookService;

    public BookServiceProxy(BookService bookService){
        this.bookService=bookService;
    }

    @Override
    public void buyBook() {
        prepareMoneyForBuyBook();
        bookService.buyBook();
        readBookAfterBuy();
    }

    private void prepareMoneyForBuyBook(){
        System.out.println("为买本准备好钱...");
    }

    private void readBookAfterBuy(){
        System.out.println("终于可以看自己喜欢的书了...");
    }
}

4.测试类

/**
 * @author Jay
 * @date 2020/7/10 11:30
 * @Description:
 */
public class StaticProxyTest {
    public static void main(String[] args) {
        BookServiceProxy bookServiceProxy=new BookServiceProxy(new BookServiceImpl());
        bookServiceProxy.buyBook();
    }
}

静态代理类优缺点

优点：
业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理的共有优点。
缺点：
1）代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

动态代理

JDK动态代理中包含一个类和一个接口：
InvocationHandler接口：
public interface InvocationHandler {
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
参数说明：
Object proxy：指被代理的对象。
Method method：要调用的方法
Object[] args：方法调用时所需要的参数

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。

Proxy类：
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
参数说明：
ClassLoader loader：类加载器
Class<?>[] interfaces：得到全部的接口
InvocationHandler h：得到InvocationHandler接口的子类实例

例子代码：

1.接口

/**
 * 接口
 * @author Jay
 * @date 2020/7/10 11:56
 * @Description:
 */
public interface BookFacade {
    void addBook();
}

2.委托类

 * @author Jay
 * @date 2020/7/10 11:57
 * @Description:
 */
public class BookFacadeImpl implements BookFacade {
    @Override
    public void addBook() {
        System.out.println("增加图书");
    }
}

3.代理类

/**
 * @author Jay
 * @date 2020/7/10 11:58
 * @Description:
 */
public class BookFacadeProxy implements InvocationHandler {
    private Object target;
    public Object bind(Object target){
        this.target=target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      Object result=null;
        System.out.println("事务开始");
        result=method.invoke(target,args);
        System.out.println("事务结束");
        return result;
    }
}

4.测试类

/**
 * @author Jay
 * @date 2020/7/10 14:08
 * @Description:
 */
public class TestProxy {
    public static void main(String[] args) {
        BookFacadeProxy bookProxy=new BookFacadeProxy();
        BookFacade bookFacade = (BookFacade) bookProxy.bind(new BookFacadeImpl());
        bookFacade.addBook();

    }
}

其实代理类可以直接省略

/**
 * @author Jay
 * @date 2020/7/10 14:08
 * @Description:
 */
/**
 * <p>@author  Jay</p>
 * <p>@date  2020/8/5 9:46</p>
 * <p>@Description:</p>
 */
public class testProxy {
    public static void main(String[] args) {
        BookService bookService= (BookService) Proxy.newProxyInstance(BookService.class.getClassLoader(), BookService.class.getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("开始代理");
                method.invoke(new BookServiceImpl(),args);
                System.out.println("结束代理");
                return null;
            }
        });

      bookService.buyBook();

    }
    }

可以看到JDK动态代理实际上是在静态代理上的增强，但是
JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。

cglib动态代理

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

直接上代码例子：

1.委托类

/**
 * @author Jay
 * @date 2020/7/10 14:25
 * @Description:
 */
public class BookFcadeImplcglib {
    public void addBook(){
        System.out.println("增加图书");
    };

}

2.代理类

/**
 * @author Jay
 * @date 2020/7/10 14:29
 * @Description:
 */
public class BookFacadeCglib implements MethodInterceptor{

    private Object target;

    public Object getInstance(Object target){
        this.target=target;
        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("事务开始");
        methodProxy.invokeSuper(o,objects);
        System.out.println("事务结束");
        return null;
    }
}

3.测试类

/**
 * @author Jay
 * @date 2020/7/10 16:08
 * @Description:
 */
public class TestCglib {
    public static void main(String[] args) {
        BookFacadeCglib cglib=new BookFacadeCglib();
        BookFcadeImplcglib Impl= (BookFcadeImplcglib) cglib.getInstance(new BookFcadeImplcglib());
        Impl.addBook();
    }
}

cglib也一样，代理类可简写

/**
 * @author Jay
 * @date 2020/7/10 16:48
 * @Description:
 */
public class Testmain {
    public static void main(String[] args) {
        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass( BookFcadeImplcglib.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

                System.out.println("开始执行");
                methodProxy.invokeSuper(o,objects);
                System.out.println("结束");
                return null;
            }
        });
        BookFcadeImplcglib Impl= (BookFcadeImplcglib) enhancer.create();
        Impl.addBook();

    }
}

可以看到的是cglib的动态代理已经丢弃了接口，类之间的关系使用反射进行构建，起到了很大程度的解耦合，代码也更轻巧，也是因此spring的AOP底层就是cglib。
这章主要是手写系列，原理部分留到以后总结