代理模式

代理模式介绍

       代理模式中有代理角色和被代理角色（目标对象）。由被代理角色，来做关键事情。代理角色通常来说会持有被代理角色的对象引用（以便于代理角色完成工作之前，或者之后能找到被代理对象 ） 

        应用场景:为其他对象提供一种代理以控制对这个对象的访问。从结构上来看和 Decorator 模式类似， 但 Proxy 是控制，更像是一种对功能的限制，而 Decorator 是增加职责。Spring 的 Proxy 模式在 AOP 中有体现，比如 JdkDynamicAopProxy 和Cglib2AopProxy。事务代理，非侵入式日志监听，拦截器。

     代理目的：拿到目标类的引用并且能够调用目标类的业务方法。

     代理分为静态代理和动态代理（jdk与cglib）

静态代理和动态代理的区别：

        静态代理在代理之前所有的东西都是已知的。（类似于人工操作）

       动态代理，再代理之前所有的东西都是未知的。（自动，智能化）

静态代理

//被代理对象，即目标对象
public class Son {
    public void findLove(){
        System.out.println("找对象，肤白，貌美，大长腿");
    }
}

//代理对象
public class Father {
    private Son son;

    public Father(Son son) {
        this.son = son;
    }

    //目标对象的引用拿到
    public void  findLove(){
        System.out.println("根据你的要求物色");
        this.son.findLove();
        System.out.println("双方父母是不是同意");
    }
}

//测试类
public class StaticProxyTest  {
    public static void main(String[] args) {
        //只能帮son找对象,不能帮其他类找对象
        Father father = new Father(new Son());
        father.findLove();
    }
}

动态代理

   1、基于jdk动态代理

//目标类实现的接口
public interface Person {

    void findLove();

    void zufangzi();

    void buy();

    void findJob();

    //...... 其他方法
}

//被代理类，目标类
public class XieMu implements Person {

    public void findLove(){
        System.out.println("高富帅");
        System.out.println("180cm");
        System.out.println("六块腹肌");
    }

    @Override
    public void zufangzi() {
        System.out.println("租房子");
    }

    @Override
    public void buy() {
        System.out.println("买东西");

    }

    @Override
    public void findJob() {
        System.out.println("月薪20k~50K");
        System.out.println("找工作");

    }
}


//被代理类（即目标类）必须强制实现接口才能转化，否者在 proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),InvocationHandler) 生成代理对象时会报错。
//java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to proxy.dynamic.jdk.XieMu
//        at proxy.dynamic.jdk.JDKProxyTest.main(JDKProxyTest.java:11)

// 找对象代理类
// 调用代理类的方法，从而掉到了目标类的方法
public class JDKMeipo implements InvocationHandler {

    //被代理的对象，把引用给保存下来
    private Person target;

    public Object getInstance(Person target)throws Exception{
        this.target = target;

        Class<?> clazz = target.getClass();

        //用来生成一个新的对象(字节码重组来实现) 参数this 表示invocationHandler
       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("如果合适的话，就准备办事");
        return null;
    }
}

// 工作代理类
// 调用代理类的方法，从而调到了目标类的方法
public class JDK58 implements InvocationHandler {

    //被代理的对象，把引用给保存下来
    private Person target;

    public Object getInstance(Person target)throws Exception{
        this.target = target;

        Class<?> clazz = target.getClass();

        //用来生成一个新的对象(字节码重组来实现)  参数this 表示InvocationHandler
       return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(" 我是58 ：我要给你找工作，现在拿到你的简历");
        System.out.println("开始投递");
        //调用目标类的方法
        method.invoke(this.target,args);
        System.out.println("安排 面试");
        return null;
    }
}

//test 测试类
public class JDKProxyTest {
    public static void main(String[] args) {
        try {
            Person obj = (Person)new JDK58().getInstance(new XieMu());
            System.out.println(obj.getClass());
            obj.findJob();
            System.out.println(obj);

             //原理：
            //1、拿到被代理对象的引用，并且获取到它的所有接口，反射获取
            //2、JDK Proxy类重新生成一个新的类$Proxy0,同时新的类实现被代理类所有实现的接口
            //3、动态的生成java代码， 把新加的业务逻辑方法，由一定的逻辑代码去调用
            //4、编译新生成的java代码.class
            //5、再重新加载到JVM 中运行
            //以上这个过程就叫字节码重组


           

            //将动态代理生成的class文件打印出来,通过反编译工具可以查看源代码，
            byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Person.class});
            FileOutputStream os = new FileOutputStream("/Users/xxx/$Proxy0.class");
            os.write(bytes);
            os.flush();
            os.close();
            //JDK 中有个规范，只要是$开头的一般都是自动生成的，如$Proxy0:0表示编号，是第几个自动生成的类

        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

2、基于cglib实现的动态代理

//目标类
public class ZhangSan {

    public void findLove(){
        System.out.println("肤白、貌美、大象腿");
    }
}

//代理类
public class CglibMeiPo implements MethodInterceptor {
    public Object getInstance(Class<?> clazz)throws Exception{

        Enhancer enhancer = new Enhancer();
        //要把哪个类设置为即将生成新类的父类
        // cglib 的继承实现是 因为他有一个enhancer.setSupperClass
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("我是媒婆：我要给你找对象，现在拿到你的需求");
        System.out.println("开始物色");
        //业务的增强
        methodProxy.invokeSuper(o, objects);
        System.out.println("如果合适的话，就准备办事");
        return null;
    }
}

//测试类
public class CgLibTest {
    public static void main(String[] args) {

        try {
            ZhangSan obj = (ZhangSan)new CglibMeiPo().getInstance(ZhangSan.class);
            obj.findLove();
            System.out.println("---------------------");
            System.out.println(obj.getClass());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3、自行实现动态代理

 

//类加载器
public class GPClassLoader extends  ClassLoader{

    private File classPathFile;

    public GPClassLoader(){
        String classPath = GPClassLoader.class.getResource("").getPath();
        this.classPathFile = new File(classPath);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String className = GPClassLoader.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();
                } finally {
                    if (null != in) {
                        try {
                            in.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    if (null != out) {
                        try {
                            out.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }

            }
        }
        return null;
    }
}

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

//proxy 类
public class GPProxy {

    public static final String ln = "\r\n";

    public static  Object newProxyInstance(GPClassLoader classLoader,Class<?>[] interfaces, GPInvocationHandler h){
        try {
            //1、动态生成源代码.java
            String src = generateSrc(interfaces);
            //2、java文件输出到磁盘
            String filePath = GPProxy.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 complier = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manage = complier.getStandardFileManager(null,null,null);
            Iterable<? extends JavaFileObject> iterable = manage.getJavaFileObjects(f);
            JavaCompiler.CompilationTask task = complier.getTask(null, manage, null, null, null, iterable);
            task.call();
            manage.close();

            //4、把编译生成的.class 文件加载到JVM 中来
            Class<?> proxyClass = classLoader.findClass("$Proxy0");
            Constructor c =proxyClass.getConstructor(GPInvocationHandler.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("package proxy.dynamic.custom;" + ln);
        sb.append("import proxy.static1.Person;" + ln);
        sb.append("import java.lang.reflect.Method;" + ln);
        sb.append("public class $Proxy0 implements" + " " + interfaces[0].getName() + "{" +ln);

        sb.append("GPInvocationHandler h;" + ln);
        //构造方法
        sb.append("public $Proxy0(GPInvocationHandler h) {" + ln);
        sb.append("this.h = h;");
        sb.append("}" + ln);

        //循环获取接口中的方法
        for (Method m : interfaces[0].getMethods()) {
            sb.append("public" + " " + m.getReturnType().getName() + " " + m.getName() + "(){" + ln);
                sb.append("try{" + ln);
                    sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod(\"" + m.getName() + "\",new Class[]{});" + ln);
                    sb.append("this.h.invoke(this,m,null);"+ln);
                sb.append("}catch(Throwable e){" + ln);
                sb.append("e.printStackTrace();" + ln);
                sb.append("}");
            sb.append("}");
        }

        sb.append("}" + ln);

        return sb.toString();
    }
}

//代理类
public class CustomMeiPo implements GPInvocationHandler{
    //被代理的对象，把引用给保存下来
    private Person target;

    public Object getInstance(Person target)throws Exception{
        this.target = target;

        Class<?> clazz = target.getClass();

        //用来生成一个新的对象(字节码重组来实现)
        return GPProxy.newProxyInstance(new GPClassLoader(),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("如果合适的话，就准备办事");
        return null;
    }
}

//测试类
public class CustomProxyTest {
    public static void main(String[] args) {
        try {
            Person obj = (Person)new CustomMeiPo().getInstance(new XieMu());
            System.out.println(obj.getClass());
            obj.findLove();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}