设计模式之---代理模式

前言

    Java的23种设计模式比较抽象，学习的时候最好结合现实的例子去理解。本篇博客只讲一下代理模式。代理模式在Spring框架中的AOP中有使用到。

目录

• 代理模式是什么
• 为什么要用到代理模式
• jdk动态代理
• cglib动态代理
• 自定义代理

正文

    1、代理模式是什么？

        代理模式可以在现实世界中找到好多例子，比如：租房人和中介，买票人和黄牛等。顾名思义，就是自己做不来或者不想做的事，找一个人替你做，这就是代理。同样，在代码中也是一样的。

    2、为什么要用到代理模式？实现代理模式的条件又是什么呢？

        刚才上面已经提到，因为自己做不来或者不想做，省事图方便，所以要用到代理。

        实现代理模式需要满足的条件：

            1、首先得有两个对象，被代理对象和执行者。

            2、被代理对象不会做，或者不想做，要找代理。

            3、执行者要拿到被代理对象的个人资料。（在代码中体现就是，拿到被代理对象的引用。试想一下，租房    的时候中介如果不知道你要租什么样的房子，怎么给你推荐合适的房源信息呢？）

-------------------------------------------------------------------------------------------------------------------------

    那么，在Java中又是如何用到代理模式的呢？代理模式主要分三种：jdk动态代理、cglib动态代理、自定义代理

  jdk动态代理

    （1）首先定义一个Person接口，要通过媒婆相亲，定义一个方法

public interface Person {
    void findLove();
}

    （2）然后Eason实现Person接口，实现findLove()方法

public class Eason implements Person {

    @Override
    public void findLove() {
        System.out.println("肤白");
        System.out.println("貌美");
        System.out.println("大长腿");
    }
}

    （3）最后写一个Meipo类，给Eason找对象

public class MeiPo implements InvocationHandler{
    
    //被代理对象的引用作为一个对象保存下来
    Person target;
    
    //获取被代理人的全部个人资料
    public Object getInstance(Person target) {
        this.target = target;
        Class clazz = target.getClass();
        System.out.println("被代理对象是：" + clazz);
        return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("我是媒婆：开始进行海选...");
        System.out.println("------------");
        
        method.invoke(this.target, args);
        System.out.println("------------");
        System.out.println("如果合适的话，就准备结婚");
        return null;
    }
    
}

    （4）可以测试一下

public class TestFindLove {
    public static void main(String[] args) {
        Person person = (Person)new MeiPo().getInstance(new Eason());
        person.findLove();
    }
}

        至此，一个jdk动态代理就完成了。

cglib动态代理

    以上jdk的动态代理有没有发现很方便？因为jdk已经给我们提供了这样的API。但是，有一个问题，想用jdk动态代理，使用动态代理的对象必须实现接口，如果想要代理没有实现接口的对象怎么办呢？就用cglib动态代理。

    （1）首先，写一个Eason类

public class Eason {
    public void findLove(){
        System.out.println("肤白貌美大长腿");
    }
}

    （2）然后，写一个Meipo类，需要shixianMethodInterceptor接口

public class CGlibMeipo implements MethodInterceptor{
    
    public Object getInstance(Class clazz) {
        Enhancer enhancer = new Enhancer();
        
        //告诉cglib，生成的子类需要继承哪个类
        enhancer.setSuperclass(clazz);
        //设置回调
        enhancer.setCallback(this);
        //创建
        return enhancer.create();
    }
    
    @Override
    public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy proxy) throws Throwable {
        System.out.println("我是GP媒婆：" + "开始进行海选...");
        System.out.println("------------");
        
        proxy.invokeSuper(arg0, arg2);
        System.out.println("------------");
        System.out.println("如果合适的话，就准备结婚");
        return null;
    }

}

    （3）最后，测试一下

public class TestCglibProxy {
    public static void main(String[] args) {
        
        Eason eason = (Eason)new CGlibMeipo().getInstance(Eason.class);
        eason.findLove();
    }
}

自定义代理

    自定义的代理，顾名思义，就是自己定义代理的实现方式。

    （1）首先，自己定义一个classLoader，继承自jdk的ClassLoader

//代码生成、编译，重新动态load到jvm中
public class CustomClassLoader extends ClassLoader{
    private File baseDir;
    
    public CustomClassLoader() {
        String basePath = CustomClassLoader.class.getResource("").getPath();
        this.baseDir = new File(basePath);
    }
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String className = CustomClassLoader.class.getPackage().getName() + "." + name;
        if(baseDir != null) {
            File classFile = new File(baseDir,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();
                } finally {
                    if (in != null) {
                        try {
                            in.close();
                        } catch(IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    
                    if (out != null) {
                        try {
                            out.close();
                        } catch(IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    classFile.delete();
                }
            }
        }
        return null;
    }
}

    （2）然后，自己定义一个InvocationHandler

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

    （3） 然后，写一个Meipo类，继承自己的CustomInvocationHandler

public class CustomMeipo implements CustomInvocationHandler{

    Person target;
    
    public Object getInstance(Person target) {
        this.target = target;
        Class clazz = target.getClass();
        System.out.println("被代理对象是" + clazz);
        return CustomProxy.newProxyInstance(new CustomClassLoader(), clazz.getInterfaces(), this);
    } 
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("我是媒婆：得给你找个异性才行");
        System.out.println("开始进行海选...");
        System.out.println("------------");
        method.invoke(this.target, args);
        System.out.println("------------");
        System.out.println("如果合适的话，就准备办事");
        return null;
    }

}

    （4）最后，完成自己的代理类

//生成代理对象的代码
public class CustomProxy {
    private static String ln = "\r\n";
    
    public static Object newProxyInstance(CustomClassLoader classLoader,Class<?>[] interfaces,CustomInvocationHandler h) {
        try {
            //1、生成源代码
            String proxySrc = generateSrc(interfaces[0]);
            //2、将生成的源代码输出到磁盘，保存为.java文件
            String filePath = CustomProxy.class.getResource("").getPath();
            File f = new File(filePath + "$Proxy0.java");
            FileWriter fw  = new FileWriter(f);
            fw.write(proxySrc);
            fw.flush();
            fw.close();
            //3、编译源代码，并且生成.class文件
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null);
            Iterable iterable = manager.getJavaFileObjects(f);
            CompilationTask task = compiler.getTask(null, manager, null, null, null, iterable);
            task.call();
            manager.close();
            //4、将class文件中的内容，动态加载到jvm中来
            Class proxyClass = classLoader.findClass("$Proxy0");
            Constructor c = proxyClass.getConstructor(CustomInvocationHandler.class);
            f.delete();
            
            //5、返回被代理后的代理对象
            return c.newInstance(h);
        } catch(Exception e) {
            e.printStackTrace();
        }
        
        return null;       
    }
    
    private static String generateSrc(Class<?> interfaces){
        StringBuffer src = new StringBuffer();
        src.append("package proxy.custom;" + ln);
        src.append("import java.lang.reflect.Method;" + ln);
        src.append("public class $Proxy0 implements " + interfaces.getName() + "{" +ln);
        src.append("CustomInvacationHandler h;" + ln);
        src.append("public $Proxy0(CustomInvacationHandler h) {" + ln);
        src.append("this.h = h;" + ln);
        src.append("}" + ln);
        
        for (Method m : interfaces.getMethods()) {
            src.append("public " + m.getReturnType().getName() + " " + m.getName() + "(){" + ln);
            src.append("try{" + ln);
            src.append("Method m = " + interfaces.getName() + ".class.getMethod(\"" + m.getName() + "\",new Class[]{});" + ln);
            src.append("this.h.invoke(this,m,null);" + ln);
            src.append("}catch(Throwable e){e.printStackTrace();}" + ln);
            src.append("}" + ln);
        }
        src.append("}");
        return src.toString();
    }
}

    （5）完成之后，测试一下

public class TestFindLove {
    public static void main(String[] args) {
        Person person = (Person)new CustomMeipo().getInstance(new Eason());
        person.findLove();
    }
}

---------------------------------------------------------------------------------------------------------------------------------

以上，3种代理模式全部介绍完毕，如有错误之处，请及时更正，谢谢。