Java设计模式-代理模式笔记

0 什么是代理模式

理解方式1

两个子类共同实现一个接口，其中一个子类负责真实业务实现，另一个子类完成辅助真实业务主题的操作。

例如买电脑这个业务。首先，我们要定义一个业务接口，要定义我们要干什么事，具体是谁来干还不知道，所以要是一个接口。你自己是买电脑的真实客户，但是在买电脑之前和买电脑之后还要干一些事情，但是前后干的这些事和你真实的业务（买电脑）是没有关系的，前和后干的那些事只是辅助操作，所以有一个专门的类来帮你干这些辅助操作，你是买电脑的人，但你不想去排队、取钱、装软件，你想让别人去帮你干这些事，所以才有了代理类。

代理类就是帮你实现真实业务之前和之后的操作。

理解方式2

代理模式提供了间接对目标对象进行访问的方式，即通过代理对象访问目标对象。这样做的好处是：可以在目标对象实现的功能上,增加额外的功能补充,即扩展目标对象的功能，而不是去修改源代码

这就符合了设计模式的开闭原则，即在对既有代码不改动的情况下进行功能的扩展

开闭原则：对于扩展是开放的，但是对于修改是封闭的

1 静态代理

1.1 代码实现

// 接口
public interface IStar {
        void sing();
    }

// 真实对象
class LDHStar implements IStar {
    @Override
    public void sing() {
        System.out.println("刘德华唱歌");
    }
}

// 代理类
//需要有真实对象的控制权 (引用)
class ProxyManger implements IStar {
    // 真实对象的引用
    private IStar star;
    
	//构造函数
    public ProxyManger(IStar star) {
        this.star = star;
    }
    
    @Override
    public void sing() {
	　　　System.out.println("唱歌前准备");
	　　　star.sing();
	   　System.out.println("善后工作");
   　}
}

//使用类
class Test{
public static void main(String[] args) {
            // 创建明星对象
            IStar ldh = new LDHStar();
            ProxyManger proxy = new ProxyManger(ldh);//刘德华的经纪人
            proxy.sing();
        }
}

1.2 方法解读

1. 定义一个“所有明星”的接口Istar
2. 定义一个“具体明星”，继承明星接口并覆写方法
3. 定义代理类，代理覆写的sing方法=具体明星的sing方法+前后其他工作。它也继承“所有明星”接口（因为代理也要覆写总的sing方法）
4. 使用类首先创建一个具体明星，再创建一个经纪人且传入要代理的明星（创建某个具体明星的经纪人），最后调用经纪人覆写的sing方法（包含前后+被代理明星的sing）

1.3 优缺点

优点：可以做到在不修改目标对象的功能前提下,对目标功能扩展.
缺点：因为代理对象需要与目标对象实现一样的接口（sing）,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.

2 动态代理

在java.lang.reflect.Proxy包里就有代理类，因此实现代理只需要调用newProxyInstance方法即可。

2.1 具体实现

//目标类接口
Public interface IDog{
    void run();
}

//目标类
class GunDog implements IDog{

    @Override
    public void run() {
        System.out.println("猎狗在跑");
    }
}

class DogUtils{
    public static void method1() {
        System.out.println("增强方式一");
    }
    
    public static void method2() {
        System.out.println("增强方式二");
    }
}

//代理工厂类

//为下面需要handle做准备
class MyInvocationHandle implements InvocationHandler{
    private Object target;
    public void setTarget(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) 
    throws Throwable {
            DogUtils.method1();
            method.invoke(target, args);
            DogUtils.method2();
            return null;
    }
}
    //生产代理对象proxy的工厂
 class MyProxyFactory{
    public static Object getProxy(Object target) {
	//先准备好handle       
	MyInvocationHandle handle = new MyInvocationHandle();
    handle.setTarget(target);
	
	//根据newProxyInstance的要求设置好proxy，并返回，这个就是后面需要的代理对象
    Object proxy = Proxy.newProxyInstance(
    target.getClass().getClassLoader(),
    target.getClass().getInterfaces(), 
    handle);
    
    return proxy;
    }
 }

//使用类
public class ProxyDemo {
    public static void main(String[] args) {
      IDog dog = new GunDog();
      IDog proxy =(IDog) MyProxyFactory.getProxy(dog);
      proxy.run();
    }

}

运行结果：

2.2 方法解读

1. 定义抽象目标类接口和具体目标类，与上个方法一样。
2. 定义代理对象需要实现的增强功能
3. 建立代理工厂类，该类的目标在于生产一个proxy并返回。而创造proxy需要调用newProxyInstance函数。

newProxyInstance需要的参数如下：

ClassLoader loader：指定当前目标对象使用类加载器,获取加载器的方法是固定的

Class<?>[ ] interfaces：目标对象实现的接口的类型,使用泛型方式确认类型

InvocationHandler h：事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入

前两个都可以通过函数获得，而最后一个需要在生产proxy之前准备好一个handle。
而准备handle的过程=定义一个handle类和构造函数–>在工厂里面调用构造函数并传入目标对象

4. 使用类：先创建好目标对象，再创建代理对象（调用产生代理对象的代理工厂类的构造函数先造出工厂，再用工厂里的创造代理对象函数），最后具体执行

2.3 注意

代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理

3 Cglib代理

3.1什么是Cglib

之前的目标对象都是实现一个接口的目标对象（即，都是从一个抽象类继承下来的具体类）,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就必须使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理。

Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。代理类去继承目标类，然后重写其中目标类的方法，这样也可以保证代理类拥有目标类的同名方法

注意事项：
1.代理的类不能为final,否则报错
2.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

3.2 具体实现

1.需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.
或者是：

2.引入功能包后,就可以在内存中动态构建子类

//目标类
package com.wyq.day527;
public class Dog{
    final public void run(String name) {
    //目标对象方法为final，不会被拦截
        System.out.println("狗"+name+"----run");
    }
    
    public void eat() {
        System.out.println("狗----eat");
    }
}

//方法拦截器
package com.wyq.day527;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class MyMethodInterceptor implements MethodInterceptor{
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("这里是对目标类进行增强！！！");
        //注意这里的方法调用，不是用反射哦！！！
		//invoke super表示调用父类的方法
        Object object = proxy.invokeSuper(obj, args);
        return object;
    }  
}

//使用类
package com.wyq.day527;

import net.sf.cglib.core.DebuggingClassWriter;
import net.sf.cglib.proxy.Enhancer;

public class CgLibProxy {
    public static void main(String[] args) {
                
        //创建Enhancer对象，类似于JDK动态代理的Proxy类，下一步就是设置几个参数
        Enhancer enhancer = new Enhancer();
        //设置目标类的字节码文件
        enhancer.setSuperclass(Dog.class);
        //设置回调函数
        enhancer.setCallback(new MyMethodInterceptor());
        
        //这里的create方法就是正式创建代理类
        Dog proxyDog = (Dog)enhancer.create();

        //调用代理类的eat方法
        proxyDog.eat();       
    }
}

3.3 解读

1. 使用类里面首先创建并设置enhancer对象，再调用enhancer对象的create方法创建出代理类
2. 调用代理类eat的方法。此时会进入到方法拦截器的intercept（）方法，在这个方法中会调用proxy.invokeSuper(obj, args)方法
3. invokeSuper中，通过FastClass机制调用目标类的方法

4 参考资料

https://blog.csdn.net/huaijiu123/article/details/86507148
https://www.cnblogs.com/cenyu/p/6289209.html
https://www.cnblogs.com/wyq1995/p/10945034.html