代理模式

语雀链接:https://www.yuque.com/nlwrno/xfkcgp/vcw1u4

什么是代理

代理名词

代理对象:增强后的对象
目标对象:被增强的对象
他们不是绝对的,是根据情况变化的

静态代理

继承

// 目标对象
public class IndexDaoImpl {
    public void query(){
        System.out.println("select db...");
    }
}
//代理对象,代理打印日志

public class IndexDaoLogImpl extends IndexDaoImpl {
    @Override
    public void query() {
        System.out.println("console log...");
        super.query();
    }
}

// 代理验证
public class IndexDaoPowerImpl extends IndexDaoImpl {
    @Override
    public void query() {
        System.out.println("power...");
        super.query();
    }
}
/*

*   模拟查询加日志
*   1、加在查询方法处,但有可能IndexDao是引入class文件,不能直接添加
*   2、加在调用方法处,但调用可能调用很多次,代码侵入性/冗余度太高
*   3、静态代理
*        继承:代理对象继承目标对象
*        聚合:
*   4、动态代理
* */
* 
// 继承方式
public class Test {
    public static void main(String[] args) {
        IndexDaoLogImpl log = new IndexDaoLogImpl();
        log.query();
        //IndexDaoImpl indexDao = new IndexDaoImpl();
        //indexDao.query();
    }
}

聚合

public interface IndexDao {
    public void query();
}

// 目标对象
public class IndexDaoImpl implements IndexDao {
    public void query(){
        System.out.println("select db...");
    }
}
// 代理对象
public class IndexDaoLogImpl implements IndexDao {
    private IndexDao dao;

    public IndexDaoLogImpl(IndexDao dao){
        this.dao = dao;
    }
    public void query() {
        System.out.println("console log...");
        dao.query();
    }
}
// 代理对象
public class IndexDaoPowerImpl implements IndexDao {

   private IndexDao dao;

   public IndexDaoPowerImpl(IndexDao dao){
        this.dao = dao;
    }
    @Override
    public void query() {
        System.out.println("power...");
        dao.query();
    }
}
public class Test {
    public static void main(String[] args) {
        IndexDao dao = new IndexDaoImpl();
        IndexDao dao1 = new IndexDaoLogImpl(dao);
        dao1.query();
    }
}

这时候就会出现一个问题,是继承好还是聚合好,为什么?
在这里插入图片描述
在这里插入图片描述
从两幅图种可以观察到,如果我们的代理需要增加,比如,我们即需要log代理,又需要power代理,这个时候,继承和聚合是怎么实现的呢?

**继承:**我们不能修改原先的代理,如果又修改了,我们只需要power代理时,则又要改动,所以只能增加一个新的代理。可以说是链式代理。
在这里插入图片描述
**聚合:**只需要将log代理传入到log代理中即可
在这里插入图片描述
那如果这时候来了个变态需求,需要log代理和power代理顺序也又要求,继承/类又要增加,这时候就要疯了。这时候还会出现类爆炸,一直增加类。相对来说,聚合就好很多,但如果要求又很多代理,依然会产生类爆炸,只是相对继承来说好一点。

总结:如果在不确定的情况下,尽量不去使用静态代理。因为一旦写代码就会产生类,一直产生类就会发生类爆炸。所谓不确定,就是不知道后续要不要进行扩展,就像需求中所说的,log代理之后有没有可能会出来power不确定。所以这种情况最好不要使用静态代理,从而引出了动态代理。

手动实现代理

那我们知道了上面的缺点,我们自己实现代理的话会如何去做呢?

  1. 生成java文件
  2. 编译Java文件,生成.class
  3. 通过.class创建Proxy代理对象
    在这里插入图片描述

Proxy生成

/**
 * @Description TODO
 * @ClassName ProxyUtil.java
 * @Author yangkai
 * @CreateTime 2020年03月19日 14:09:00
 * @Version 1.0
 * @History
 **/

package com.proxy.util;

import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;

public class ProxyUtil {
    /*
    *  content ----> string
    *  .java   io
    *  .class
    *   new
    *   return
    * */
    public static Object newInstance(Class clazz, MineInvocationHandler h) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        Object proxy = null;
       // Class<?> clazz = clz.getInterfaces()[0];
        Method[] methods = clazz.getDeclaredMethods();
        String line = "\r\n";
        String tab = "\t";
        String infName = clazz.getSimpleName();
        String content = "";
        String packageContent = "package com.google;"+line;
        String importContent = "import "+clazz.getName()+";"+line
                             + "import com.proxy.util.MineInvocationHandler;"+line
                             + "import java.lang.reflect.Method;"+line;

        String clazzFirstLineContent = "public class $Proxy implements "+infName+"{"+line;
        String fileContent = tab+"private MineInvocationHandler h;"+line;
        String constructContent  = tab+"public $Proxy(MineInvocationHandler h){"+line
                                    +tab + tab + "this.h = h;"+line
                                    +tab + tab +"}"+line;
        String methodContent = "";
        for (Method method : methods) {
            String returnTypeName = method.getReturnType().getName();
            String methodName = method.getName();
            Object args[] = method.getParameterTypes();
            String argsContents ="";
            String paramsContents = "";
            String argNames="";
            for (int i=0;i<args.length;i++) {
                String argName = ((Class) args[0]).getName();
                argNames = argName+".class,";
                argsContents += argName+" p"+i+",";
                paramsContents+="p"+i+",";
            }

            if(argsContents.length()>0){
                argNames = ","+argNames.substring(0,argNames.length()-1);
                argsContents = argsContents.substring(0,argsContents.length()-1);
                paramsContents = ",new Object[]{"+paramsContents.substring(0,paramsContents.length()-1)+"}";
            }else{
                paramsContents=",null";
            }

            methodContent += tab+"public "+returnTypeName+" "+methodName +"("+argsContents+"){"+line
                            +tab+tab+"try{"+line
                            +tab+tab+tab + "Method method = Class.forName(\""+clazz.getName()+"\").getDeclaredMethod(\""+methodName+"\""+argNames+");"+line;
            if ("void".equals(returnTypeName)){
                methodContent+=tab+tab+tab +"h.invoke(new $Proxy(h),method"+paramsContents+");"+line
                            +tab+tab+"}catch ( Throwable e){"+line
                            +tab+tab+tab+"e.printStackTrace();"+line
                            +tab+tab+"}"+line
                            +tab+"}"+line;
            }else{
                methodContent+=tab+tab+tab +"return ("+returnTypeName+")h.invoke(new $Proxy(h),method"+paramsContents+");"+line
                            +tab+tab+"}catch ( Throwable e){"+line
                            +tab+tab+tab+"e.printStackTrace();"+line
                            +tab+tab+"}"+line
                            +tab+tab+"return null;"+line
                            +tab+"}"+line;
            }

        }
        content=packageContent+importContent+clazzFirstLineContent+fileContent+constructContent+methodContent+"}";

         File file = new File("G:/com/google");
         if(!file.exists()){
            file.mkdirs();
         }
        file = new File("G:/com/google/$Proxy.java");
        FileWriter fileWriter = new FileWriter(file);
        fileWriter.write(content);
        fileWriter.flush();
        fileWriter.close();
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager standardFileManager = compiler.getStandardFileManager(null,null,null);
        Iterable utils = standardFileManager.getJavaFileObjects(file);
        JavaCompiler.CompilationTask task = compiler.getTask(null, standardFileManager, null, null, null,utils);
        task.call(); // 这里仅使用jre会抛异常,使用jdk
        standardFileManager.close();
       // compiler.run(null,null,null,"G:/com/google/$Proxy.java");

        URL[] urls = new URL[]{new URL("file:G:\\\\")};
        URLClassLoader urlClassLoader = new URLClassLoader(urls);
        Class claz = urlClassLoader.loadClass("com.google.$Proxy");
        Constructor constructor = claz.getConstructor(MineInvocationHandler.class);
        proxy = constructor.newInstance(h);

        return proxy;
    }
}

InvocationHandler

/**
 * @Description TODO
 * @ClassName InvocatetionHandler.java
 * @Author yangkai
 * @CreateTime 2020年03月20日 15:03:00
 * @Version 1.0
 * @History
 **/

package com.proxy.util;

import java.lang.reflect.Method;

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

测试动态代理

/**
 * @Description TODO
 * @ClassName IndexDao.java
 * @Author yangkai
 * @CreateTime 2020年03月19日 11:50:00
 * @Version 1.0
 * @History
 **/

package com.proxy.proxy1;

public interface IndexDao {
    public void query();

    public String selectStr();

    public String queryName(String name);
}
/**
 * @Description TODO
 * @ClassName IndexDao.java
 * @Author yangkai
 * @CreateTime 2020年03月19日 11:28:00
 * @Version 1.0
 * @History
 **/

package com.proxy.dao;

import com.proxy.proxy1.IndexDao;

public class IndexDaoImpl implements IndexDao {

    public void query(){
        System.out.println("select db...");
    }


    public String selectStr() {
        System.out.println("IndexDaoImpl selectStr");
        return "IndexDaoImpl";
    }

    @Override
    public String queryName(String name) {
        return name;
    }
}
/**
 * @Description TODO
 * @ClassName TestInvokeHandle.java
 * @Author yangkai
 * @CreateTime 2020年03月20日 15:05:00
 * @Version 1.0
 * @History
 **/

package com.proxy.util;

import java.lang.reflect.Method;

public class TestInvokeHandle implements MineInvocationHandler {
    Object target;

    public TestInvokeHandle(Object target){
        this.target= target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理");
        return method.invoke(target,args);
    }
}
public class Test {
    public static void main(String[] args) throws Exception {
        IndexDao proxy = (IndexDao) ProxyUtil.newInstance(IndexDao.class,new TestInvokeHandle(new IndexDaoImpl()));
        proxy.query();
        proxy.selectStr();
        String s = proxy.queryName("测试....");
        System.out.println(s);
    }
}

在这里插入图片描述

JDK动态代理

流程图

在这里插入图片描述

测试JDK动态代理

public interface IndexDao {
    public void query();

    public String selectStr();

    public String queryName(String name);
}
/**
 * @Description TODO
 * @ClassName IndexDao.java
 * @Author yangkai
 * @CreateTime 2020年03月19日 11:28:00
 * @Version 1.0
 * @History
 **/

package com.proxy.dao;

import com.proxy.proxy1.IndexDao;

public class IndexDaoImpl implements IndexDao {

    public void query(){
        System.out.println("select db...");
    }


    public String selectStr() {
        System.out.println("IndexDaoImpl selectStr");
        return "IndexDaoImpl";
    }

    @Override
    public String queryName(String name) {
        return name;
    }
}
/**
 * @Description TODO
 * @ClassName MyInvoketionHandle.java
 * @Author yangkai
 * @CreateTime 2020年03月20日 14:37:00
 * @Version 1.0
 * @History
 **/

package com.proxy.util;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvoketionHandle implements InvocationHandler {
    Object target;

    public MyInvoketionHandle(Object target){
        this.target = target;
    }
    /**
     *
     * @param proxy 代理对象
     * @param method 目标对象的方法
     * @param args 目标方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy invoke...");
        return method.invoke(target,args);
    }

}
/**
 * @Description TODO
 * @ClassName Test.java
 * @Author yangkai
 * @CreateTime 2020年03月19日 11:29:00
 * @Version 1.0
 * @History
 **/

package com.proxy.test;
//开闭原则
// 单一职责

import com.proxy.dao.IndexDaoImpl;
import com.proxy.proxy.IndexDaoLogImpl;
import com.proxy.proxy1.IndexDao;
import com.proxy.util.MyInvoketionHandle;
import com.proxy.util.ProxyUtil;
import com.proxy.util.TestInvokeHandle;

import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/*
*   模拟查询加日志
*   1、加在查询方法处,但有可能IndexDao是引入class文件,不能直接添加
*   2、加在调用方法处,但调用可能调用很多次,代码侵入性/冗余度太高
*   3、静态代理
*        继承:代理对象继承目标对象
*        聚合:
*   4、动态代理
* */
public class Test {
    public static void main(String[] args) throws Exception {
        IndexDao proxy1 = (IndexDao)Proxy.newProxyInstance(Test.class.getClassLoader(),
                new Class[]{IndexDao.class}, new MyInvoketionHandle(new IndexDaoImpl()));
        proxy1.query();
        proxy1.selectStr();
        String s = proxy1.queryName("测试....");
        System.out.println(s);
    }

}

/*
 *  代理对象  增强后的对象
 *  目标对象  被代理的对象
 * */

在这里插入图片描述

源码解析

后续增加…

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值