静态代理和动态代理

静态代理：

代码实现：

// 书籍接口
public interface Book {
    void saveBook();
}
// 接口实现类
public class BookService implements Book{
    @Override
    public void saveBook(){
        System.out.println("保存图书.........");
    }
}
// 代理类
public class BookServiceProxy implements Book{

    Book book;

    public BookServiceProxy(Book book) {
        this.book = book;
    }

    @Override
    public void saveBook() {
        System.out.println("before save.......");
        book.saveBook();
        System.out.println("after save.......");
    }

    public static void main(String[] args) {
        Book book = new BookService();
        BookServiceProxy bookServiceProxy = new BookServiceProxy(book);
        bookServiceProxy.saveBook();
    }
}
// 输出结果：
before save.......
保存图书.........
after save.......

对原生对象进行增强。
静态代理优点：
1、易于理解和实现
2、代理类和真实类的关系都是编译期决定的、和动态代理比起来减少了额外的开销。
静态代理缺点：
每一个类都需要单独创建一个代理类。

动态代理：

1、JDK的动态代理：

实现原理：
基于JDK内部的反射机制实现，在创建代理实现类时比CGLib要快，创建代理速度快。
代码实现：

/* Book类和BookService类和静态代理的一样 */
public class MyJDKProxy implements InvocationHandler {

    private Object targetObject;

    public Object getProxyInstance(Object targetObject){
        this.targetObject = targetObject;
        return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),
                this.targetObject.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("MyJDKProxy  before save.......");
        Object result = method.invoke(this.targetObject, args);
        System.out.println("MyJDKProxy  after save.......");
        return result;
    }

    public static void main(String[] args) {
        // 获取自己的代理类对象
        MyJDKProxy myJDKProxy = new MyJDKProxy();
        // 获取BookService的代理对象
        Book proxyInstance = (Book) myJDKProxy.getProxyInstance(new BookService());
        // 调用代理对象的方法
        proxyInstance.saveBook();
    }
}

2、CGLIB的动态代理：

实现原理：
CGLib动态代理是通过字节码技术底层生成一个继承代理类的类来实现，然后重写代理类的方法（如果被代理类被final关键字所修饰，那么会失败，如果代理类中方法被final修饰，该方法无法代理成功），但是运行速度比JDK动态代理要快。
代码实现：

public class MyCGLIBProxy implements MethodInterceptor {

    private Object targetObject;

    public Object getProxyInstance(Object targetObject){
        this.targetObject = targetObject;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetObject.getClass());
        // 回调方法的参数为代理类对象MyCGLIBProxy，最后增强目标类调用的是代理类对象MyCGLIBProxy中的intercept方法
        enhancer.setCallback(this);
        // 增强后的目标类
        Object proxyObject = enhancer.create();

        return proxyObject;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println("MyCGLIBProxy  before save.......");
        Object obj = method.invoke(targetObject, objects);
        System.out.println("MyCGLIBProxy  after  save.......");

        return obj;
    }

    public static void main(String[] args) {
        MyCGLIBProxy myCGLIBProxy = new MyCGLIBProxy();
        /* 获取代理对象 */
        Book proxyInstance = (Book) myCGLIBProxy.getProxyInstance(new BookService());
        proxyInstance.saveBook();
    }
}