设计模式 - 代理模式

设计模式 - 代理模式

场景

小张接到一个需要，需要对用户的增删改查每次操作都进行行安全检查，防止不安全的操作破坏用户的敏感信息。

小张之前听说过面向切面编程（aop），而这个需求很贴合面向切面编程，首先肯定不能在用户管理类（userManagerImpl）里增加代码，这会破坏和并且增加了用户管理类的复杂度。

可以这样理解切面，我们的每个操作线程都是一个水管，我们之前写代码都是在一个水管里写代码横向的，但是实际会有很多操作和很多线程，如果要做一件事，我们需要往每个水管代码，但是这很不可取，我们可以纵向写代码，对很多的水管的一个面写代码。

代理模式

我们来看一下代理模式的概念：

代理模式：为另一个对象提供一个替身或占位符以控制对这个对象的访问。

我们现在有一个UserManager接口有四个方法分别对应增删改查，我们需要对这四个方法的访问进行安全控制。

UserManager接口：

package xuelongjiang.designpartten.proxy;

/**
 *
 * 只是示例，所以很多方法没有参数，
 * 如果是业务开发，请根据实际业务确定方法参数
 *
 * @Author xuelongjiang
 */
public interface UserManager {

    public void addUsr();

    public void updateUser();

    public void insert();

    public  void delete();

}

UserManager的实现类UserManagerImpl：

package xuelongjiang.designpartten.proxy;

import xuelongjiang.designpartten.proxy.UserManager;

import java.io.Serializable;

/**
 * @Author xuelongjiang
 */
public class UserManagerImpl implements UserManager {

    @Override
    public void addUsr() {
        System.out.println("---add user ---");
    }

    @Override
    public void updateUser() {
        System.out.println("---update user -----");
    }

    @Override
    public void insert() {
        System.out.println("----insert user -----");
    }

    @Override
    public void delete() {
        System.out.println("---- delete user -------");
    }
}

静态代理

如果不想破坏UserManagerImpl的内部实现，又想对四个方法进行权限控制，那么有一种方式，我们可以创建一个类，用来代理UserManagerImple

类图：

UserManagerImpleProxy代理类:

package xuelongjiang.designpartten.proxy.staticProxy;

import xuelongjiang.designpartten.proxy.UserManager;

/**
 * @Author xuelongjiang
 */
public class UserManagerImplePorxy implements UserManager {


    private UserManager userManager;

    public UserManagerImplePorxy(UserManager userManager) {
        this.userManager = userManager;
    }

    public void checkSecurity(){
        System.out.println("----checkSecurity ---");
    }

    @Override
    public void addUsr() {
        checkSecurity();
        userManager.addUsr();
    }

    @Override
    public void updateUser() {
        checkSecurity();
        userManager.updateUser();

    }

    @Override
    public void insert() {
        checkSecurity();
        userManager.insert();
    }

    @Override
    public void delete() {
        checkSecurity();
        userManager.delete();
    }
}

测试类：

package xuelongjiang.designpartten.proxy.staticProxy;

import xuelongjiang.designpartten.proxy.UserManager;
import xuelongjiang.designpartten.proxy.UserManagerImpl;

/**
 * @Author xuelongjiang
 */
public class ClientTest {

    public static void main(String[] args) {

        UserManager userManager = new UserManagerImplePorxy(new UserManagerImpl());

        userManager.addUsr();
        userManager.insert();
        userManager.updateUser();
        userManager.delete();
    }

}

上面这种方式叫做静态代理，原理很简单，我们创建一个类实现 Usermanager接口，重写四个方法，增加安全检查。回想一下上面的切面和水管图，如果使用静态代理那么如果每一个水管是一个类，那么我们需要创建同等数量的代理类，这样的工作量，作为程序员我们是希望尽量避免的。

动态代理

如果一个切面，只想写一个类呢？该怎么做呢？我们可以使用动态代理。

动态代理有两种方式：Java jdk提供的方式和spring cglib提供的的方式。
两者的区别是：

• jdk:代理的目标对象必须有接口，且创建的代理对象也是需要转化成接口的类型区执行方法，达到增强目标对象的行为的目的。
• cglib：主要解决没有接口类的代理实现。

jdk

类图：

动态代理类：

• 实现InvocationHandler接口
• 代理类新增一个方法使用proxy类实例化一个代理类

package xuelongjiang.designpartten.proxy.dynamicProxy;

import java.io.Serializable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 *
 * 动态代理
 *
 * @Author xuelongjiang
 */
public class SecurityHanlder implements InvocationHandler {

    private Object  targetObject;

    public SecurityHanlder() {

    }

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

    private void checkSecurity(){
        System.out.println("----checkSecurity---");
    }


       @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        checkSecurity();
        Object ret = null;

        try {
            //调用被代理目标对象的真实方法
            ret = method.invoke(this.targetObject,args);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        return ret;
    }
}

测试类：

package xuelongjiang.designpartten.proxy.dynamicProxy;

import sun.misc.ProxyGenerator;
import xuelongjiang.designpartten.proxy.UserManager;
import xuelongjiang.designpartten.proxy.UserManagerImpl;

import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Modifier;

/**
 * @Author xuelongjiang
 */
public class ClientTest {

    public static void main(String[] args)throws  Exception {

        SecurityHanlder securityHanlder = new SecurityHanlder();

        //jdk代理对象必须是有接口，且代理返回接口，取消注释，运行失败
        //使用cglib，对象不必有接口
        //UserManagerImpl userManager = (UserManagerImpl) securityHanlder.newProxy(new UserManagerImpl());


        UserManager userManager = (UserManager) securityHanlder.newProxy(new UserManagerImpl());

        //输出生成的代理类
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                "xuelongjiang.designpartten.proxy.dynamicProxy.$proxy0.class", new Class[]{UserManager.class}, Modifier.FINAL);
        // 输出文件到本地
        FileOutputStream out = new FileOutputStream(new File("/Users/xuelongjiang/Documents/$Proxy0.class"));
        out.write(proxyClassFile);
        out.flush();
        out.close();

        out.close();
        //outputStream.close();
        //objectOutputStream.close();



        userManager.delete();

    }

}

测试类中有一段代码是输出生成的代理类，我们会在后面展开。

cglib

cglib是spring提供的动态代理方法，我在spring中调试代码经常会看见生成的代理类。

类图：

代理类：

实现MethodInterceptor接口，重写intercept 方法

 package xuelongjiang.designpartten.proxy.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @Author xuelongjiang
 */
public class CglibProxy implements MethodInterceptor {


    private Object targetObject;

    public Object newProxy(Object targetObject){

        //创建代理对象
        this.targetObject = targetObject;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.targetObject.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    private void checkSecurity(){
        System.out.println("---checkSecurity---");
    }



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

       checkSecurity();
       Object ret = null;

        try {
            method.invoke(this.targetObject,objects);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        return ret;
    }
}

测试类：

package xuelongjiang.designpartten.proxy.cglib;

import sun.misc.ProxyGenerator;
import xuelongjiang.designpartten.proxy.UserManager;
import xuelongjiang.designpartten.proxy.UserManagerImpl;

import java.io.File;
import java.io.FileOutputStream;
import java.lang.reflect.Modifier;

/**
 * @Author xuelongjiang
 */
public class ClientTest {

    public static void main(String[] args) throws  Exception {

        //cglib可以代理不实现接口的类
        CglibProxy cglibProxy = new CglibProxy();
        UserManagerImpl userManager = (UserManagerImpl) cglibProxy.newProxy(new UserManagerImpl());
        userManager.addUsr();


    }

}

JDK代理的原理

我们的代理类代码主要两部分：

• 使用proxy创建代理对象
• 代理调用的方法

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

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 

invoke是我们的真正执行的方法，使用反射出要执行的方法并且执行我们的功能代码。

还记得我们在jdk动态代理的测试代码中有一段输出代理的代码吗？

jdk代理的思路是：生成代理类，并且代理类会为被代理类中的每个方法生成代理方法，之后调用生成的代理类。

我们反编译了生成的字节码：

我们可以看到，每个方法的执行变成了：
h就是实现InvocationHandler接口的类。

super.h.invoke(this, m4, (Object[])null);

并且：

final class class extends Proxy implements UserManager {}

代理的类继承自proxy，所以jdk动态代理只能代理实现某个接口的类
（Java的单继承性）。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package xuelongjiang.designpartten.proxy.dynamicProxy.$proxy0;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import xuelongjiang.designpartten.proxy.UserManager;

final class class extends Proxy implements UserManager {
    private static Method m1;
    private static Method m4;
    private static Method m2;
    private static Method m3;
    private static Method m6;
    private static Method m0;
    private static Method m5;

    public class(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void insert() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void delete() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void addUsr() throws  {
        try {
            super.h.invoke(this, m6, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void updateUser() throws  {
        try {
            super.h.invoke(this, m5, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m4 = Class.forName("xuelongjiang.designpartten.proxy.UserManager").getMethod("insert");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("xuelongjiang.designpartten.proxy.UserManager").getMethod("delete");
            m6 = Class.forName("xuelongjiang.designpartten.proxy.UserManager").getMethod("addUsr");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m5 = Class.forName("xuelongjiang.designpartten.proxy.UserManager").getMethod("updateUser");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

一些问题

jdk代理测试代码中输出代理，我们是怎么知道类的全限定名的？

进入proxy类，我们可以看到：

private static final String proxyClassNamePrefix = "$Proxy";

 private static final AtomicLong nextUniqueNumber = new AtomicLong();

   long num = nextUniqueNumber.getAndIncrement();

我们得知生成的代理类名。