代理模式

 一、定义

代理模式（ProxyPattern）是指为其他对象提供一种代理，以控制对这个对象的访问，属于结构型模式。

在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

二、代理模式的应用场景

在生产环境中其实代码应用的非常广，例如有一组对象都实现同一个接口，实现同样的方法，但这组对象中有一部分对象需要有单独的方法，传统的笨办法是在每一个应用端都加上这个单独的方法，但是代码重用性低，耦合性高；当我们使用别人的代码的时候，可以通过代理，对方法增强，避免了修改别人的代码例如Spring AOP。还有例如

 

代理模式中的角色：

1、抽象主题角色（Subject）：声明了目标对象和代理对象的共同接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象。
2、具体主题角色（RealSubject)：也称为委托角色或者被代理角色。定义了代理对象所代表的目标对象。
3、代理主题角色（Proxy)：也叫委托类、代理类。代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后，执行某个操作，而不是单纯地将调用传递给目标对象。
 代理模式又分为静态代理和动态代理。静态代理是由程序猿创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。动态代理是在程序运行时，通过运用反射机制动态的创建而成。

三、代理模式案例

比如我们现在有一个登录注册类里面有 一个登录方法 一个注册方法。

public class Login {
    public void login(String userName){
        System.out.println("登录方法");
    }

    public void reist(String userName){
        System.out.println("注册方法");
    }

}

public class LoginTest {
    public static void main(String[] args) {
        Login login=new Login();
        login.reist("张三");
        login.login("张三");
    }
}

上面代码比较简单，现在如果有个场景，原来做这个功能现在要改，要增加一个日志功能，那么怎么实现呢，大部分程序员肯定是直接在login 和 regist方法中 直接再加两行打印不就行了吗，但是如果系统比较庞大里面逻辑比较复杂，那这样改多多少少会对系统稳定性有影响。

四、静态代理

那么现在该如何实现上面的功能呢，我们以登录注册方法添加时间日志为例，首先有经验的工程师在写代码的时候，就应该知道，我们要遵循基于接口而非实现的设计原则，所以我们应把login 和 regist 抽取出来，让Login类继承盖接口，如下所示：

public interface LoginInterface {
    public void login(String userName);

    public void reist(String userName);

}

public class Login implements LoginInterface {

    private static final String TAG = "Login";

    @Override
    public void login(String userName) {
        System.out.println("登录");
    }

    @Override
    public void reist(String userName) {
        System.out.println("注册");

    }
}

为Login 类 创建代理类 LoginProxy，让代理类 实现 和 原始类同样的接口，并调用原始类的方法 ，并在调用前 打印当前时间戳，代码如下所示：

public class LoginProxy implements LoginInterface{
    private static final String TAG = "Login";

    private LoginInterface loginInterface;

    public LoginProxy(LoginInterface loginInterface){
        this.loginInterface=loginInterface;
    }
    @Override
    public void login(String userName) {
        System.out.println("调用登录接口的日志方法");
        loginInterface.login(userName);
    }

    @Override
    public void reist(String userName) {
        System.out.println("调用注册接口的日志方法");
        loginInterface.reist(userName);
    }
}

public class LoginProxyTest {
    public static void main(String[] args) {
       Login login=new Login();
       LoginProxy loginProxy=new LoginProxy(login);
       loginProxy.reist("张三");
       loginProxy.login("张三");
    }
}

这样呢，我们就实现了不改变原始的情况下，为类方法添加日志的功能，但是呢，这种方法存在的问题

1、如果原来的代码没有实现接口怎么搞，对于这类型问题就只有一种解决方法那就是使用继承的方式去扩展，这种方式也称为对外部类的扩展

2、如果为每个类都添加代理类，会增加大量的文件，为解决这个问题就引出了另外一个东西，那就是动态代理

可能这个例子太浅，还不能太表达情况代理模式的应用业务场景，下面就拿另一个比较由贴切的精力场景，那就是分库分表时的数据库切换，如果自己做过数据源切换的朋友感受可能更加深切。

@Data
public class Datum {
    private Integer id;
    private String name;
}

public class DatumDao {
    public int insert(Datum datum) {
        System.out.println("创建数据库逻辑");
        return 0;
    }
}

public interface DatumService {
    int insert(Datum datum);
}

public class DatumServiceImpl implements DatumService{

    private  DatumDao datumDao;

    public  DatumServiceImpl(){
        datumDao=new DatumDao();
    }
    @Override
    public int insert(Datum datum) {
        System.out.println("逻辑代码");
        return datumDao.insert(datum);
    }
}

接下来使用静态代理

/**
 * 数据源切换
 */
public class DataSource {
    // 默认数据源
    public final static String DEFAULT_SOURCE = null;
    private final static ThreadLocal<String> local = new ThreadLocal<String>();
    private DataSource(){}

    /*** 清空数据源 */
    public static void clear() { local.remove(); }

    /*** 获取当前正在使用的数据源名字 */
    public static String get() { return local.get(); }

    /*** 还原当前切面的数据源 */
    public static void restore() { local.set(DEFAULT_SOURCE); }

    /*** 设置已知名字的数据源  */
    public static void set(String source) { local.set(source); }

    /*** 根据年份动态设置数据源 */
    public static void set(int year) { local.set("DB_" + year); }
}

创建切换数据源的代理

public class DataSourceProxy implements DatumService{

    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
    private DatumService datumService;

    public DataSourceProxy(DatumService datumService){
        this.datumService = datumService;
    }
    @Override
    public int insert(Datum datum) {
        before();
        String name = datum.getName();
        System.out.println( "静态代理处理流程");
        DataSource.set(name);
        datumService.insert(datum);
        after();
        return 0;
    }

    private void before(){ System.out.println("加的第一层代码"); }
    private void after(){ System.out.println("加的第二层代码"); }
}

测试

public class DataSourceProxyTest {
    public static void main(String[] args) {
        Datum datum = new Datum();
        datum.setName("张三");
        DatumService datumService = new DataSourceProxy(new DatumServiceImpl());
        datumService.insert(datum);
    }
}

五、动态代理

动态代理和静态对比基本思路是一致的，只不过动态代理功能更加强大，随着业务的扩展适应性更强。

1、JDK实现方式

public interface LoginInterface {
    public void login(String userName);

    public void reist(String userName);

}

public class Login implements LoginInterface {

    private static final String TAG = "Login";

    @Override
    public void login(String userName) {
        System.out.println("登录");
    }

    @Override
    public void reist(String userName) {
        System.out.println("注册");

    }
}

public class LoginProxy implements InvocationHandler {
    private static final String TAG = "Login";

    private LoginInterface loginInterface;
    private Object object;

    public LoginProxy() {

    }

    public Object getInstance(Object object){
         this.object=object;
         Class<?> clazz=object.getClass();
         return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }
    public LoginProxy(LoginInterface loginInterface){
        this.loginInterface=loginInterface;
    }

    public void login(String userName) {

        System.out.println("调用登录接口的日志方法");
        //loginInterface.login("张三");
    }


    public void reist(String userName) {
        System.out.println("调用注册接口的日志方法");
       // loginInterface.reist(userName);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        login("");
        Object obj = method.invoke(this.object,args);
        reist("张三");
        return object;
    }
}

public class LoginProxyTest {
    public static void main(String[] args) {
        LoginInterface loginInterface = (LoginInterface)new LoginProxy().getInstance(new Login());
        loginInterface.login("张三");
        loginInterface.reist("张三");
    }
}

3

2、CGLib实现方式

CGLib代理的目标不需要实现任何接口，它是通过动态继承目标对象实现的动态代理。

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

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        login("张三");
        Object obj = methodProxy.invokeSuper(o,objects);
        reist("张三");
        return obj;
    }

    public void login(String userName) {
        System.out.println("登录");
    }

    public void reist(String userName) {
        System.out.println("注册");

    }
}

public class Accomplish {
    public void accomplish(){
        System.out.println("完成所有");
    }
}

CGLib 代理的目标对象不需要实现任何接口，它是通过动态继承目标对象实现的动态代理。

public class CglibProxyTest {
    public static void main(String[] args) {

        try {
            Accomplish  accomplish = (Accomplish)new CglibProxy().getInstance(Accomplish.class);
            accomplish.accomplish();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

六、深入分析JDK动态代理

 断点发现这个生成的对像是一个代理对象，其实JDK动态生成代码类的原理 也很简单，也就是分成了五步；

1、获取被代理对象的引用，并且获取它的所有接口（反射获取）。

2、JDK Proxy类重新生成一个新的类，实现了被代理类所有接口的方法。

3、动态生成Java代码，把增强逻辑加入到新生成代码中。

4、编译生成新的Java代码的class文件。

5、加载并重新运行新的class，得到类就是全新类。

以上过程就叫字节码重组。JDK中有一个规范，在ClassPath下只要是$开头的.class文件，一般都是自动生成的。我们将内存中的对象字节码通过文件流输出到一个新的.class文件，然后利用反编译工具查看其源代码。

public class LoginProxyTest {
    public static void main(String[] args) {
        LoginInterface loginInterface = (LoginInterface)new LoginProxy().getInstance(new Login());
        loginInterface.login("张三");
        loginInterface.reist("张三");
        // 通过反编译工具可以查看源代码
        try {
            byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{LoginInterface.class});
            FileOutputStream os = new FileOutputStream("F://$Proxy0.class");
            os.write(bytes);
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行完成后到F盘找$Proxy0.class文件然后用idea打开

public final class $Proxy0 extends Proxy implements LoginInterface {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m4;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

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

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

    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 reist(String var1) throws  {
        try {
            super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (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"));
            m3 = Class.forName("com.ghy.demo3.jdkdynamic.LoginInterface").getMethod("login", Class.forName("java.lang.String"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m4 = Class.forName("com.ghy.demo3.jdkdynamic.LoginInterface").getMethod("reist", Class.forName("java.lang.String"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

仔细看发现，$Proxy0继承了Proxy类，同时还实现了LoginInterface 接口，而且重写了login()等方法。在静态块中用反射查找到了目标对象的所有方法，而且保存了所有方法的引用，重写的方法用反射调用目标对象的方法。上面的过程就是JDK帮我们自动生成的过程，下面就开始搞JDK的思路自己也来写一个类似的功能
先仿JDK来个InvocationHandler接口，直接把InvocationHandler里面内容抄过来

public interface LjxInvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
}

然后还有一个Proxy类也很重要，Proxy类中有个newProxyInstance方法也是在代码中有调用的，和上面一样，仿着源码抄一下

 

package com.ghy.demo3.jdkImitationis.proxy;

import com.ghy.demo3.jdkImitationis.invoking.LoginProxy;

import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class LjxProxy {
    public static final String ln = "
";

    public static Object newProxyInstance(LjxClassLoader loader,
                                          Class<?>[] interfaces,
                                          LoginProxy h)
            throws IllegalArgumentException
    {
        try {
            //1、动态生成源代码.java文件
            String src = generateSrc(interfaces);
            System.out.println(src);
            //2、Java文件输出磁盘
            String filePath = LjxProxy.class.getResource("").getPath();
            System.out.println(filePath);
            File f = new File(filePath + "$Proxy0.java");
            FileWriter fw = new FileWriter(f);
            fw.write(src);
            fw.flush();
            fw.close();
            //3、把生成的.java文件编译成.class文件
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null);
            Iterable iterable = manage.getJavaFileObjects(f);

            JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable);
            task.call();
            manage.close();
            //4、编译生成的.class文件加载到JVM中来
            Class proxyClass =  loader.findClass("$Proxy0");
            Constructor c = proxyClass.getConstructor(LjxInvocationHandler.class);
            f.delete();
            //5、返回字节码重组以后的新的代理对象
            return c.newInstance(h);
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

    private static String generateSrc(Class<?>[] interfaces) {
        StringBuffer sb = new StringBuffer();
        sb.append(LjxProxy.class.getPackage() + ";" + ln);
        //下面这一步就是导包的过程com.ghy.demo3.jdkImitationis.invoking.LoginInterface;
        sb.append("import " + interfaces[0].getName() + ";" + ln);
        //导入反射包
        sb.append("import java.lang.reflect.*;" + ln);
        sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
        sb.append("LjxInvocationHandler h;" + ln);
        sb.append("public $Proxy0(LjxInvocationHandler h) { " + ln);
        sb.append("this.h = h;");
        sb.append("}" + ln);
        for (Method m : interfaces[0].getMethods()){
            Class<?>[] params = m.getParameterTypes();
             //方法名字、参数名、参数值
            StringBuffer paramNames = new StringBuffer();
            StringBuffer paramValues = new StringBuffer();
            StringBuffer paramClasses = new StringBuffer();

            for (int i = 0; i < params.length; i++) {
                Class clazz = params[i];
                String type = clazz.getName();
                String paramName = toLowerFirstCase(clazz.getSimpleName());
                paramNames.append(type + " " +  paramName);
                paramValues.append(paramName);
                paramClasses.append(clazz.getName() + ".class");
                if(i > 0 && i < params.length-1){
                    paramNames.append(",");
                    paramClasses.append(",");
                    paramValues.append(",");
                }
            }
            sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "(" + paramNames.toString() + ") {" + ln);
            sb.append("try{" + ln);
            sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod("" + m.getName() + "",new Class[]{" + paramClasses.toString() + "});" + ln);
           //调用invoke
            sb.append((hasReturnValue(m.getReturnType()) ? "return " : "") + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})",m.getReturnType()) + ";" + ln);
            sb.append("}catch(Error _ex) { }");
            sb.append("catch(Throwable e){" + ln);
            sb.append("throw new UndeclaredThrowableException(e);" + ln);
            sb.append("}");
            sb.append(getReturnEmptyCode(m.getReturnType()));
            sb.append("}");
        }
        sb.append("}" + ln);
        return sb.toString();

}
    private static Map<Class,Class> mappings = new HashMap<Class, Class>();
    static {
        mappings.put(int.class,Integer.class);
    }
    private static String getReturnEmptyCode(Class<?> returnClass){
        if(mappings.containsKey(returnClass)){
            return "return 0;";
        }else if(returnClass == void.class){
            return "";
        }else {
            return "return null;";
        }
    }

    private static String getCaseCode(String code,Class<?> returnClass){
        if(mappings.containsKey(returnClass)){
            return "((" + mappings.get(returnClass).getName() +  ")" + code + ")." + returnClass.getSimpleName() + "Value()";
        }
        return code;
    }
    private static boolean hasReturnValue(Class<?> clazz){
        return clazz != void.class;
    }

    private static String toLowerFirstCase(String simpleName) {
        char [] chars = simpleName.toCharArray();
        chars[0] += 32;
        return String.valueOf(chars);
    }
    }

最后在还有一个类我们也调用过那就是ClassLoader，照着源码也抄一次

package com.ghy.demo3.jdkImitationis.proxy;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;

public class LjxClassLoader extends ClassLoader{
    private File classPathFile;
    public LjxClassLoader(){
        String classPath = LjxClassLoader.class.getResource("").getPath();
        this.classPathFile = new File(classPath);
    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String className = LjxClassLoader.class.getPackage().getName() + "." + name;
        if(classPathFile  != null){
            File classFile = new File(classPathFile,name.replaceAll("\.","/") + ".class");
            if(classFile.exists()){
                FileInputStream in = null;
                ByteArrayOutputStream out = null;
                try{
                    in = new FileInputStream(classFile);
                    out = new ByteArrayOutputStream();
                    byte [] buff = new byte[1024];
                    int len;
                    while ((len = in.read(buff)) != -1){
                        out.write(buff,0,len);
                    }
                    return defineClass(className,out.toByteArray(),0,out.size());
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

}

最后写上代理

public class Login implements LoginInterface {

    private static final String TAG = "Login";

    @Override
    public void login(String userName) {
        System.out.println("登录");
    }

    @Override
    public void reist(String userName) {
        System.out.println("注册");

    }
}

public interface LoginInterface {
    public void login(String userName);

    public void reist(String userName);

}

package com.ghy.demo3.jdkImitationis.invoking;

import com.ghy.demo3.jdkImitationis.proxy.LjxClassLoader;
import com.ghy.demo3.jdkImitationis.proxy.LjxInvocationHandler;
import com.ghy.demo3.jdkImitationis.proxy.LjxProxy;


import java.lang.reflect.Method;


public class LoginProxy implements LjxInvocationHandler {
    private static final String TAG = "Login";

    private LoginInterface loginInterface;
    private Object object;

    public LoginProxy() {

    }

    public Object getInstance(Object object){
         this.object=object;
         Class<?> clazz=object.getClass();
         return (Object) LjxProxy.newProxyInstance(new LjxClassLoader(),clazz.getInterfaces(),this);
    }
    public LoginProxy(LoginInterface loginInterface){
        this.loginInterface=loginInterface;
    }

    public void login(String userName) {

        System.out.println("调用登录接口的日志方法");
        //loginInterface.login("张三");
    }


    public void reist(String userName) {
        System.out.println("调用注册接口的日志方法");
       // loginInterface.reist(userName);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        login("");
        Object obj = method.invoke(this.object,args);
        reist("张三");
        return object;
    }
}

public class LoginProxyTest {
    public static void main(String[] args) {
        LoginInterface loginInterface = (LoginInterface)new LoginProxy().getInstance(new Login());
        loginInterface.login("张三");
        loginInterface.reist("张三");

    }
}

七、代理的总结

1.JDK 动态代理是实现了被代理对象的接口，CGLib 是继承了被代理对象。

2.JDK 和 CGLib 都是在运行期生成字节码，JDK 是直接写 Class 字节码，CGLib 使用 ASM框架写 Class 字节码，Cglib 代理实现更复杂，生成代理类比 JDK 效率低。

3.JDK 调用代理方法，是通过反射机制调用，CGLib 是通过 FastClass 机制直接调用方法，CGLib 执行效率更高。

4.静态代理只能通过手动完成代理操作，如果被代理类增加新的方法，代理类需要同步新增，违背开闭原则。

5.动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则。

 6.若动态代理要对目标类的增强逻辑扩展，结合策略模式，只需要新增策略类便可完成，无需修改代理类的代码。

7.代理模式能将代理对象与真实被调用的目标对象分离；一定程度上降低了系统的耦合度，扩展性好。

GIT源码：https://github.com/ljx958720/design_patterns.git