代理模式----静态代理、动态代理 、CGLIB代理

代理模式：

提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。
简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强原对象的功能和简化访问方式。

---

1、静态代理

• 使用静态代理的目的：

在不改变原来的类的前提下，对这个类的一些功能实现增强效果

• 静态代码的优点：

可以在不更改 目标对象的情况下实现功能的增加

• 静态代理的缺点：

1、代码冗余， 静态代理要求 被代理对象和代理对象 实现同一个接口，这样会形成很多的类
2、不易维护，增加新的方法，目标对象和 代理对象都要对代码进行更改

IOrderService 是目标类和代理类都要实现的接口

	
	public interface IOrderService {
	    int createOrder(Order order);
	}

OrderService 目标类（功能要增强的对象）

/**
 * @author : GONG ZHI QIANG
 * @data : 2019-08-31 , 19:37
 * @user : SnaChat
 * @project: DesignPattern
 * @description :
 */
public class OrderDao
{
    public int insert(Order order){
        System.out.println("            原来的功能----创建订单成功");
        return 1;
    }
}

OrderServiceStaticProxy 静态代理类（增强的功能实现）

/**
 * @author : GONG ZHI QIANG
 * @data : 2019-08-31 , 19:47
 * @user : SnaChat
 * @project: DesignPattern
 * @description :
 */
public class OrderServiceStaticProxy implements IOrderService {

    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd", Locale.getDefault(Locale.Category.FORMAT));
    
    //这里是目标对象。 在Spring中使用的是自动注入
    private OrderService orderService; 

    public OrderServiceStticProxy(OrderService orderService) {
        this.orderService = orderService;
    }
    /**
     * 这个方法中实现对代理类的增强
     */
    @Override
    public int createOrder(Order order) {
        before();
        System.out.println("            原来的功能----代理方法执行中，原来的功能，加入代理之后是不影响的");
        orderService.createOrder(order);  //注意：这里是重点，这里使用的是 目标对象调用原来的方法，实现功能
        after();
        return 0;
    }
    private void before() {
        System.out.println("\n代理方法开始，在这里我们对 被代理的对象的功能进行增强 -- before()");
    }

    private void after() {
        System.out.println("代理方法结束，在这里我们对 被代理的对象的功能进行增强 -- after()");
    }
}

---

2 、动态代理：

1、动态代理和静态代理实现的思路相似，但是动态代理的功能更加强大，动态代理的适应性更强，动态代理又被称为JDK代理或接口代 理。
2、动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理。

静态代理与动态代理的区别：

静态代理在编译时就已经实现，编译完成后代理类是一个实际的class文件
动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中

核心的方法：

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

ClassLoader :指定当前的目标对象的类加载器（类加载器 + .class文件确定对象）
Class<?>[ ] :目标对象实现的接口的类型
InvocationHandler : 事件处理器
Object ：返回一个指定接口的代理类的实例（注意这里是代理类的对象），该接口可以将方法调用指派到指定的调用处理程序。

2、Object invoke(Object proxy, Method method, Object[] args)

		在代理实例上处理方法调用并返回结果。

目标类实现的接口

public interface Person {
    public  void findLove();
}

代理类 实现 InvocationHandler接口

/**
 * @author : Snachat
 * @data : 2019-08-18 , 15:50
 * @user : SnaChat
 * @project: DesignPattern
 */
public class JDKMeipo implements InvocationHandler {

    private Object target;

    public Object getInstance(Object target) {

        this.target = target;

        Class<?> clazz = target.getClass();

        return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }
    
    /**
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        this.before();
        Object object = method.invoke(this.target, args);
        this.after();
        return object;
    }

    public void before() {
        System.out.println("调用方法：" + Thread.currentThread().getStackTrace()[1].getMethodName() + "  , 在这里实现类方法的增强");

    }

    public void after() {
        System.out.println("调用方法：" + Thread.currentThread().getStackTrace()[1].getMethodName() + "  , 在这里实现类方法的增强");

    }
}

测试结果：

 public static void main(String[] args) {
        /**
         * 这里使用反射的方式，创建目标对象（被代理的对象）
         */
        Person person = (Person) new JDKMeipo().getInstance(new Customer());

        person.findLove();
    }