设计模式——代理模式

代理模式

什么是代理模式？

首先说什么是代理。记得有这么个神评论“请说出一个最像日本人名字的中文职位”，神评论：房屋中介。

代理的作用就类似房屋中介。试想一个业主想要出售自己的房屋，但是业主本身并不是干这行的，对这行的规矩和行情并不了解，因此他将房屋在出售过程中的行使权交给中介，由中介代替他去完成挂牌、引流、洽谈和成交等过程。房屋中介是业主的代理。反过来，中介并没有拥有房屋的所有权，因此对于房屋在出售过程中的签字，证件证明等过程仍需要业主出面提供，所以代理必须要调用被代理（业主）提供的方法。

代理起到的作用就是保护和增强功能的作用，代理拥有部分被代理对象不持有的逻辑，通过代理的逻辑，被代理的对象原有的行为能够得到一定的增强。

静态代理

如下游戏玩家自己有账号，但是自己没时间玩，因此花钱请了代练来帮助自己练级。代练可以通过游戏外挂对号主的账号进行加强，因为代练持有了号主的账号，因此可以对账号进行前后的增强。

public interface Game {
    void login(String username,String password);

    void play();

    void levelUp();
}

玩家正常的玩法：

public class GamePlayer implements Game {
    @Override
    public void login(String username, String password) {
        System.out.printf("登录成功！用户名：%s,密码：%s\n",username,password);
    }

    @Override
    public void play() {
        System.out.println("用户正在刷野");
    }

    @Override
    public void levelUp() {
        System.out.println("用户已升级");
    }
}

代练（代理）的玩法：

public class GamePlayerProxy implements Game {
    private Game game;

    public GamePlayerProxy(Game game) {
        this.game = game;
    }

    @Override
    public void login(String username, String password) {
        System.out.println("代理获取用户登录账号和密码");
        game.login(username,password);
    }

    @Override
    public void play() {
        System.out.println("代理开启自动刷图外挂");
        game.play();
    }

    @Override
    public void levelUp() {
        game.levelUp();
        System.out.println("代理通过邮件转出升级奖励");
    }
}

代理必须持有玩家的引用，才能在其正常的逻辑前后进行增强处理。

public class Test {
    public static void main(String[] args) {
        System.out.println("================玩家自己玩游戏===================");
        GamePlayer gamePlayer = new GamePlayer();
        gamePlayer.login("root","123456");
        gamePlayer.play();
        gamePlayer.levelUp();
        System.out.println("===================代练后===================");
        GamePlayerProxy proxy = new GamePlayerProxy(new GamePlayer());
        proxy.login("root","123456");
        proxy.play();
        proxy.levelUp();
    }
}

================玩家自己玩游戏===================
登录成功！用户名：root,密码：123456
用户正在刷野
用户已升级
===================代练后===================
代理获取用户登录账号和密码
登录成功！用户名：root,密码：123456
代理开启自动刷图外挂
用户正在刷野
用户已升级
代理通过邮件转出升级奖励

不同的调用方式可以看出使用了代理后，用户的刷野效率得到了很高的提升，用户足不出户就能够快速升级。

这是一种静态代理的实现，缺点是代理类的逻辑是写死的，如果用户想要切换账号，则必须要通知代练进行修改，因此不是很灵活。既然有静态代理，name必定也会有动态代理。

动态代理

动态代理中逻辑并不是写死的，而是根据被代理类的逻辑动态生成的，能适应不同的逻辑变化。

JDK动态代理

JDK中自带了一种动态代理的实现。只需实现InvocationHandler接口即可实现动态代理。

public interface Game {
    void login(String username,String password);

    void play();

    void levelUp();
}


public class GamePlayer implements Game {
    @Override
    public void login(String username, String password) {
        System.out.printf("登录成功！用户名：%s,密码：%s\n",username,password);
    }

    @Override
    public void play() {
        System.out.println("用户正在刷野");
    }

    @Override
    public void levelUp() {
        System.out.println("用户已升级");
    }
}

使用代理

其中：
Proxy.newProxyInstance(
this.getClass().getClassLoader(),
this.game.getClass().getInterfaces(),
this)
方法中，参数依次为
类加载器，被代理的接口，实现了InvocationHandler接口的类实例。

public class JDKGamePlayerProxy implements InvocationHandler {
    // 必须持有被代理类的引用
    private Game game;

    public Object getInstance(Game game){
        if(this.game == null){
            synchronized(JDKGamePlayerProxy.class){
                if(this.game == null){
                    this.game = game;
                }
            }
        }
        return Proxy.newProxyInstance(
                this.getClass().getClassLoader(),
                this.game.getClass().getInterfaces(),
                this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object reslt = null;
        if("login".equals(method.getName())){
            System.out.println("代练开始为玩家练号");
            reslt = method.invoke(game,args);
        }
        if("play".equals(method.getName())){
            System.out.println("外挂已打开，即将开始全屏自动刷怪");
            reslt = method.invoke(game,args);
        }
        if("levelUp".equals(method.getName())){
            reslt = method.invoke(game,args);
            System.out.println("代理通过邮件转出升级奖励");
        }
        return reslt;
    }
}

在重写的invoke方法中可以获取被代理的方法，因此可以在方法的调用前后进行相应的处理。方法的调用采用反射机制。

============用户自己练级============
登录成功！用户名：root,密码：123456
用户正在刷野
用户已升级
===========用户请了代练============
代练开始为玩家练号
登录成功！用户名：root,密码：123456
外挂已打开，即将开始全屏自动刷怪
用户正在刷野
用户已升级
代理通过邮件转出升级奖励

当我想着写博客的时候，当然不是写API，但是如果没有API的使用反而显得有点空洞。那么JDK动态代理是怎么实现的呢？

JDK动态代理的实现原理

在上述的测试类代码行，我们打下一个断点（如下图），通过debug看看这个instance到底是什么：

断点显示instance是一个 $Proxy0 ，这个类直接去全局搜索当然是搜不到的。上边说道动态代理会动态生成类，那么这个类是否就是动态生成的那个类呢？到这里似乎线索断了，如果我能弄出这个类，那么想要解决上述的疑问也就不在话下了。

只要敢想，方法总会有的。通过下方的方法就能把这个类给保存下来：

JDKGamePlayerProxy proxy = new JDKGamePlayerProxy();
Game instance = (Game) proxy.getInstance(new GamePlayer());
byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Game.class});
FileOutputStream os = new FileOutputStream("./$Proxy0.class");

代码执行完成后，在src目录下就会生成这个类：

源码的代码会影响页面浏览体验，因此开启一个传送门

在静态代码块中：

m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m5 = Class.forName("proxy.dynamicproxy.Game").getMethod("levelUp");
m4 = Class.forName("proxy.dynamicproxy.Game").getMethod("play");
m3 = Class.forName("proxy.dynamicproxy.Game").getMethod("login", Class.forName("java.lang.String"), Class.forName("java.lang.String"));
m0 = Class.forName("java.lang.Object").getMethod("hashCode");

通过反射将被代理类的方法创建了实例，并保存起来。而public final class $Proxy0 extends Proxy implements Game可知这个$Proxy0继承了Proxy，被缓存的方法在调用的时候通过super.h.invoke(this, m5, (Object[])args);来调用。super.h 指的就是Proxy#h

public class Proxy implements java.io.Serializable {
	protected InvocationHandler h;
}

这个h在此处被赋值：

protected Proxy(InvocationHandler h) {
	Objects.requireNonNull(h);
	this.h = h;
}

这是一个构造方法，构造方法在调用Proxy.newInstance的时候会被调用，也就是说将 Proxy.newProxyInstance(
this.getClass().getClassLoader(),
this.game.getClass().getInterfaces(),
this)中的最后一个this赋值。因此调用super.h.invoke会转回调用JDKGamePlayerProxy#invoke，所以最后既获取了被代理的对象的方法，又能实现方法的调用。拿到这个方法后，想要在方法上前后进行操作那还是不是轻而易举吗？

既然JDK中通过动态生成class文件，用类加载器加载到JVM中来实现动态运行，基于这样的思路，我们是否也可以实现自己的动态加载呢？
当然可以，主要思路是：

• 找到类路径
• 编写动态类的代码
• 将代码编译称为.class文件
• 将class文件加载到JVM中

限于篇幅和阅读耐力，仅贴出部分核心代码，有兴趣的话本人会考虑将全部源代码放到传送门(如果链接到百度则说明源码未贴出）

public static Object newProxyInstance(BufferClassLoader classloader,
                                      Class<?>[] interfaces,
                                      BufferInvocationHandler handler){
    // 生成代理类的源码
    String srcCode = generaterSrcCode(interfaces);
    // 获取当前类的路径
    String path = BufferInvocationHandler.class.getResource("").getPath();
    File file = new File(path+"$Proxy0.class");
        try{
            FileWriter fileWriter = new FileWriter(file);
            fileWriter.write(srcCode);
            fileWriter.flush();
            fileWriter.close();
            // 执行文件的编译
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null);
            Iterable<? extends JavaFileObject> javaFile = manager.getJavaFileObjects(file);
            JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, null, null, null);
            task.call();
            manager.close();
            Class<?> aClass = classloader.findClass("$Proxy0.class");
            Constructor<?> constructor = aClass.getConstructor(BufferInvocationHandler.class);
            
            ......
            
            return constructor.newInstance(handler);
        }catch(Exception e){
            e.printStackTrace();
        }
     return null;
}

Cglib动态代理

与JDK动态代理不同的是，Cglib动态代理既能代理接口，也能代理类（JDK动态创建的类已经继承了Proxy，因为不能多继承，因此无法代理类，而且因为代理接口需要调用接口的方法，因此还要求接口要有实现类），用法上稍微比JDK动态代理复杂，但是整体上更加灵活。两种动态的代理有不同的使用场景，并无好坏之分。

public class Customer {
    public void printSomething(){
        System.out.println("我是普通的那个需要玩家");
    }
}

public class CglibProxy implements MethodInterceptor {
    public Object getInstance(Class<?> clazz) {
        Enhancer enhancer = new Enhancer();
        enhancer.setCallback(this);
        enhancer.setSuperclass(clazz);
        return enhancer.create();
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        Object reslt = null;
        System.out.println("前置增强");
        reslt = methodProxy.invokeSuper(o,objects);
        System.out.println("后置增强");
        return reslt;
    }
}

其中reslt = methodProxy.invokeSuper(o,objects)表示调用父类的方法，而enhancer.setSuperclass(clazz)刚好设置了父类是谁，因此最后也就是调用被代理的类的方法。

public static void main(String[] args) {
    CglibProxy cglibProxy = new CglibProxy();
    Customer customer = (Customer) cglibProxy.getInstance(Customer.class);
    customer.printSomething();
}

前置增强
我是普通的那个需要玩家
后置增强

Cglib代理接口的时候，如果需要调用方法，但是接口没有实现类的话，方法的调用就会有问题。那么为什么mybatis的DAO层不用写实现类也可以调用方法呢？mybatis也是用的动态代理实现的，会生成类来实现接口，关于这个实现类的方法体怎么写，在这里算是题外话。mybatis虽然不需要写DAO层的实现类，但是要求写Mapper.xml文件，而xml文件的namespace绑定了DAO的路径，sql的标枪id也与方法名一一对应，而sql语句也可以从标签中获取到，接下来不就是JDBC的操作了吗？

烟鬼正传，在还没了解cglib动态生成的类之前，一切都是不可信的，眼见为实，我们采用如下方法将cglib生成的动态代理类的代码保存到本地。

System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"D://cglib_proxy_classes")

需要注意这方法必须放在代理类产生之前，否则无效如：

System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"D://cglib_proxy_classes");
CglibProxy cglibProxy = new CglibProxy();
Customer customer = (Customer) cglibProxy.getInstance(Customer.class);
customer.printSomething();

代码运行结束后看到提示CGLIB debugging enabled, writing to 'D://cglib_proxy_classes表示生成成功。限于篇幅将代码放到额外的篇幅中，此处设立传送门。可以看到一共生成了三个类，分别是

• Customer$$EnhancerByCGLIB$$1be8ba4$$FastClassByCGLIB$$fdb70e35.class
• Customer$$EnhancerByCGLIB$$1be8ba4.class
• Customer$$FastClassByCGLIB$$bd784a6a.class
  其中继承实现关系如下：
• extends Customer implements Factory
• extends FastClass
• extends FastClass
  也就是说cglib都是用继承的方式去生成类，因此cglib可以代理类。
  主要方法如图：
  
  
  
  通过FastClass机制，将方法进行缓存（包含集成Object的方法和自定义的方法），调用的时候直接通过索引去获取，不用再通过反射去调用，因此调用的效率会比JDK动态代理的高。

---

总结：

Cglib和JDK动态代理的异同

JDK动态代理采用实现的方式去生成新的类，继承已经自己使用了（extends Proxy）,由于java允许多实现，只允许单继承，所以JDK动态代理只能代理接口，而且要求接口要有实现类，否则方法无法调用。

Cglib采用继承的方式去生成类，覆盖父类的方法。

---

Cglib和JDK动态代理都是生成字节码，从而组装成新的类。

---

JDK动态代理对于用户而言，依赖性更强，因为要求类必须实现一个接口,但是调用也更加复杂。
Cglib对目标类没有任何要求。

---

Cglib效率更高，生成的类复杂耗时，但是会将方法缓存起来，下次调用就会很快，性能也更高，底层没有用到反射。
JDK生成的类的逻辑较为简单，执行效率低，每次都要反射（method.invoke()），调用效率低。

---

Cglib中有一个坑，就是被代理类中的final方法会被忽略。

---

代理模式的优缺点

优点：

• 代理模式能将代理对象与真是被调用的目标对象分离，一定程度上降低了系统的耦合程度，易于扩展。
• 代理模式可以起到保护目标对象的作用。
• 代理模式可以增强目标的职责。

缺点：

• 代理模式会造成系统设计中类的数量增加。
• 在客户端和目标对象之间增加了一个代理对象，请求处理速度变慢。
• 增加系统的复杂度。

拓展

Spring中的代理选择原则

• 当Bean有实现接口时，Spring会用JDK的动态代理。
• 当Bean没有实现接口时，Spring选择Cglib。
• Spring可以通过配置强制使用Cglib，只需在Spring的配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true">。