Java代理简述

Java资料站

共 32839字,需浏览 66分钟

 ·

2021-05-02 07:00

点击上方蓝色字体,选择“标星公众号”

优质文章,第一时间送达

  作者 |  码猿手

来源 |  urlify.cn/qQBvMf

 1.什么是代理?

  对类或对象(目标对象)进行增强功能,最终形成一个新的代理对象,(Spring Framework中)当应用调用该对象(目标对象)的方法时,实际调用的是代理对象增强后的方法,比如对功能方法login实现日志记录,可以通过代理实现;

  PS:

目标对象--被增强的对象;

代理对象--增强后的对象;

  2.为什么需要代理?

  一些类里面的方法有相同的代码或类中有相同的功能,可以将这些相同抽取出来形成一个公共的方法或功能,但Java有两个重要的原则:

单一职责(对类来说的,即一个类应该只负责一项职责)和开闭原则(开放扩展,修改关闭),如果每个类的每个功能都调用了公共功能,就破坏了单一职责,如下图;

如果这个类是别人已经写好的,你动了这个代码,同时也破坏了开闭原则(同时改动代码很麻烦,里面可能涉及其他很多的调用,可能带出无数的bug,改代码比新开发功能还难/(ㄒoㄒ)/~~);

  由于有上面的问题存在,使用代理来实现是最好的解决办法;

  3.Java实现代理有哪些?

  (1)静态代理:通过对目标方法进行继承或聚合(接口)实现;

(会产生类爆炸,因此在不确定的情况下,尽量不要使用静态代理,避免产生类爆炸)   1)继承:代理对象继承目标对象,重写需要增强的方法;

//业务类(目标对象)
public class UserServiceImpl {
    public void query(){
        System.out.println("业务操作查询数据库....");
    }
}
//日志功能类
public class Log {
    public static void info(){
        System.out.println("日志功能");
    }
}
//继承实现代理(代理对象)
public class UserServiceLogImpl extends UserServiceImpl {
    public void query(){
        Log.info();
        super.query();
    }
}

    从上面代码可以看出,每种增强方法会产生一个代理类,如果现在增强方法有日志和权限,单个方法增强那需要两个代理类(日志代理类和权限代理类),如果代理类要同时拥有日志和权限功能,那又会产生一个代理类,同时由于顺序的不同,可能会产生多个类,比如先日志后权限是一个代理类,先权限后日志又是另外一个代理类。

    由此可以看出代理使用继承的缺陷:

产生的代理类过多(产生类爆炸),非常复杂,维护难;

    2)聚合:

代理对象和目标对象都实现同一接口,使用装饰者模式,提供一个代理类构造方法(代理对象当中要包含目标对象),参数是接口,重写目标方法;

//接口
public interface UserDao {
    void query();
}
//接口实现类:目标对象
public class UserDaoImpl implements  UserDao {
    @Override
    public void query() {
        System.out.println("query......");
    }
}
//日志功能类
public class Log {
    public static void info(){
        System.out.println("日志功能");
    }
}
//聚合实现代理:同样实现接口,使用装饰者模式;(代理对象)
public class UserDaoLogProxy implements UserDao {
    UserDao userDao;
    public UserDaoLogProxy(UserDao userDao){//代理对象包含目标对象
        this.userDao = userDao;
    }
    @Override
    public void query() {
        Log.info();
        userDao.query();
    }
}
//测试
public static void main(String[] args) {
    UserDaoImpl target = new UserDaoImpl();
    UserDaoLogProxy proxy = new UserDaoLogProxy(target);
    proxy.query();
}


    聚合由于利用了面向接口编程的特性,产生的代理类相对继承要少一点(虽然也是会产生类爆炸,假设有多个Dao,每个Dao产生一个代理类,所以还是会产生类爆炸),如下案例:

//时间记录功能
public class Timer {
    public static void timer(){
        System.out.println("时间记录功能");
    }
}
//代理类:时间功能+业务
public class UserDaoTimerProxy implements UserDao {

    UserDao userDao;
    public UserDaoTimerProxy(UserDao userDao){
        this.userDao = userDao;
    }
    @Override
    public void query() {
        Timer.timer();
        userDao.query();
    }
}
//测试
public static void main(String[] args) {
    //timer+query
    UserDao target = new UserDaoTimerProxy(new UserDaoImpl());
    //log+timer+query
    UserDao proxy = new UserDaoLogProxy(target);
    proxy.query();
}
public static void main(String[] args) {
    //log+query
    UserDao target = new UserDaoLogProxy(new UserDaoImpl());
    //timer+log+query
    UserDao proxy = new UserDaoTimerProxy(target);
    proxy.query();
}

  PS:

    装饰和代理的区别:

代理不需要指定目标对象,可以对任何对象进行代理;

装饰需要指定目标对象,所以需要构造方法参数或set方法指定目标对象;

    几个io的Buffer流(BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter)就是使用了装饰模式的静态代理;

public class BufferedReader extends Reader {
    private Reader in;
    ........
    public BufferedReader(Reader in, int sz) {
        super(in);
        if (sz <= 0)
            throw new IllegalArgumentException("Buffer size <= 0");
        this.in = in;
        cb = new char[sz];
        nextChar = nChars = 0;
    }

    public BufferedReader(Reader in) {
        this(in, defaultCharBufferSize);
    }
}

  (2)动态代理:Java有JDK动态代理和CGLIB代理;

(Spring Framework通过Spring AOP实现代理,底层还是使用JDK代理和CGLIB代理来实现)    

模拟动态代理:不需要手动创建类文件(因为一旦手动创建类文件,会产生类爆炸),通过接口反射生成一个类文件,然后调用第三方的编译技术,动态编译这个产生的类文件成class文件,然后利用URLclassLoader把这个动态编译的类加载到jvm中,然后通过反射把这个类实例化。

(通过字符串产生一个对象实现代理);

    PS:

Java文件 -> class文件 -> byte字节(JVM)-> class对象(类对象)-> new(对象);

    所以步骤如下:

      1)代码实现一个内容(完整的Java文件内容,包含包名、变量、构造方法、增强后的方法等),使其通过IO产生一个Java文件;

      2)通过第三方编译技术产生一个class文件;

      3)加载class文件利用反射实例化一个代理对象出来;

public class ProxyUtil {
    /**
     *  content --->string
     *     |
     *     |生成
     *     v
     *  .java   <-----通过io产生
     *  .class  <-----Java文件编程产生
     *
     *  .new    <-----class文件反射产生实例对象
     * @return
     */
    public static Object newInstance(Object target){
        Object proxy=null;
        //根据对象获取接口
        Class targetInf =target.getClass().getInterfaces()[0];
        //获取接口的所有方法
        //getMethods(),该方法是获取本类以及父类或者父接口中所有的公共方法(public修饰符修饰的)
        //getDeclaredMethods(),该方法是获取本类中的所有方法,包括私有的(private、protected、默认以及public)的方法
        Method[] declaredMethods = targetInf.getDeclaredMethods();
        String line="\n";
        String tab ="\t";
        //接口名称
        String targetInfName = targetInf.getSimpleName();
        String content ="";
        //包位置
        String packageContent = "package com;"+line;
        //接口
        String importContent = "import "+targetInf.getName()+";"+line;
        String clazzFirstLineContent = "public class $Proxy implements "+targetInfName+"{"+line;
        //属性
        String filedContent  =tab+"private "+targetInfName+" target;"+line;
        //构造方法
        String constructorContent =tab+"public $Proxy ("+targetInfName+" target){" +line
                +tab+tab+"this.target =target;"
                +line+tab+"}"+line;
        //方法
        String methodContent = "";
        for(Method method:declaredMethods){
            //返回值
            String returnTypeName = method.getReturnType().getSimpleName();
            //方法名
            String methodName = method.getName();
            // Sting.class String.class 参数类型
            Class<?>[] parameterTypes = method.getParameterTypes();
            String argsContent = "";
            String paramsContent="";
            int flag = 0;
            for(Class args :parameterTypes){
                //String,参数类型
                String simpleName = args.getSimpleName();
                //String p0,Sting p1,
                argsContent+=simpleName+" p"+flag+",";
                paramsContent+="p"+flag+",";
                flag++;
            }
            if (argsContent.length()>0){
                argsContent=argsContent.substring(0,argsContent.lastIndexOf(",")-1);
                paramsContent=paramsContent.substring(0,paramsContent.lastIndexOf(",")-1);
            }
            methodContent+=tab+"public "+returnTypeName+" "+methodName+"("+argsContent+") {"+line
                    //增强方法先写死
                    +tab+tab+"System.out.println(\"log\");"+line;
            if(returnTypeName.equals("void")){
                methodContent+=tab+tab+"target."+methodName+"("+paramsContent+");"+line
                        +tab+"}"+line;
            }else{
                methodContent+=tab+tab+"return target."+methodName+"("+paramsContent+");"+line
                        +tab+"}"+line;
            }
        }
        content+=packageContent+importContent+clazzFirstLineContent+filedContent
                +constructorContent+methodContent+"}";
        //生成Java文件
        File file = new File("D:\\com\\$Proxy.java");
        try{
            if(!file.exists()){
                file.createNewFile();
            }
            //创建
            FileWriter wr = new FileWriter(file);
            wr.write(content);
            wr.flush();
            wr.close();
            //编译Java文件
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

            StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
            Iterable units = fileMgr.getJavaFileObjects(file);

            JavaCompiler.CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
            t.call();
            fileMgr.close();
            //new --> 反射
            URL[] urls = new URL[]{new URL("file:D:\\\\")};
            //加载外部文件
            URLClassLoader classLoader = new URLClassLoader(urls);
            Class<?> proxyClass = classLoader.loadClass("com.$Proxy");
            Constructor constructor = proxyClass.getConstructor(targetInf);
            //构造方法创建实例
            proxy = constructor.newInstance(target);
            //clazz.newInstance();//根据默认构造方法创建对象
            //Class.forName()
        }catch (Exception e){
            e.printStackTrace();
        }
        return proxy;
    }
}

  自定义代理的缺点:

生成Java文件;

动态编译文件;

需要一个URLClassLoader;

涉及到了IO操作,软件的最终性能体现到了IO操作,即IO操作影响到软件的性能;

案例:

  1)接口:

public interface UserDao {
     void query();
     void query(String name);
     String getName(String id);
}

 2)实现类:

public class UserService implements UserDao {
    @Override
    public void query() {
        System.out.println("query");
    }

    @Override
    public void query(String name) {
        System.out.println(name);
    }

    @Override
    public String getName(String id) {
        System.out.println("id:"+id);
        return "李四";
    }
}

  3)测试:

public static void main(String[] args) {
    UserDao dao = (UserDao) ProxyUtil.newInstance(new UserService());
    dao.query();
    dao.query("张三");
}
--------结果--------
log
query
log
张三

package com;
import com.hrh.dynamicProxy.dao.UserDao;
public class $Proxy implements UserDao{//自定义动态代理生成的文件
    private UserDao target;
    public $Proxy (UserDao target){
        this.target =target;
    }
    public String getName(String p) {
        System.out.println("log");
        return target.getName(p);
    }
    public void query(String p) {
        System.out.println("log");
        target.query(p);
    }
    public void query() {
        System.out.println("log");
        target.query();
    }
}

  JDK动态代理:

基于反射实现,通过接口反射得到字节码,然后将字节码转成class,通过一个native(JVM实现)方法来执行;

  案例实现:

实现 InvocationHandler 接口重写 invoke 方法,其中包含一个对象变量和提供一个包含对象的构造方法;

public class MyInvocationHandler implements InvocationHandler {
    Object target;//目标对象
    public MyInvocationHandler(Object target){
        this.target=target;
    }
    /**
     * @param proxy 代理对象
     * @param method 目标对象的目标方法
     * @param args    目标方法的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("log");
        return method.invoke(target,args);
    }
}
public class MyInvocationHandlerTest {
    public static void main(String[] args) {
        //参数: 当前类的classLoader(保证MyInvocationHandlerTest当前类可用)
        //         接口数组:通过接口反射得到接口里面的方法,对接口里面的所有方法都进行代理
        //         实现的InvocationHandler:参数是目标对象
        UserDao jdkproxy = (UserDao) Proxy.newProxyInstance(MyInvocationHandlerTest.class.getClassLoader(),
                new Class[]{UserDao.class},new MyInvocationHandler(new UserService()));
        jdkproxy.query("query");
        //-----结果------
        //log
        //query
    }
}

  下面查看底层JDK生成的代理类class:

byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy18", new Class[]{UserDao.class});

        try {
            FileOutputStream fileOutputStream = new FileOutputStream("xxx本地路径\\$Proxy18.class");
            fileOutputStream.write(bytes);
            fileOutputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

  或在代码的最前面添加下面代码:

System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "xxx本地路径");

代理类class反编译后的内容:

下面的内容验证了JDK动态代理为什么基于聚合(接口)来的,而不能基于继承来的?

因为JDK动态代理底层已经继承了Proxy,而Java是单继承,不支持多继承,所以以接口来实现;

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

import com.hrh.dao.UserDao;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy18 extends Proxy implements UserDao {
    private static Method m1;
    private static Method m4;
    private static Method m5;
    private static Method m2;
    private static Method m0;
    private static Method m3;

    public $Proxy18(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 query(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 void query() throws  {
        try {
            super.h.invoke(this, m5, (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 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);
        }
    }

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

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m4 = Class.forName("com.hrh.dao.UserDao").getMethod("query", Class.forName("java.lang.String"));
            m5 = Class.forName("com.hrh.dao.UserDao").getMethod("query");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m3 = Class.forName("com.hrh.dao.UserDao").getMethod("getName", Class.forName("java.lang.String"));
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

  CGLIB代理:

借助asm(一个操作字节码的框架)实现代理操作;

CGLIB基于继承来的(前文有CGLIB代理类class的反编译可以看出);

public class UserService {
    public void query(){
        System.out.println("query");
    }

    public static void main(String[] args) {
        // 通过CGLIB动态代理获取代理对象的过程
        Enhancer enhancer = new Enhancer();
        // 设置enhancer对象的父类
        enhancer.setSuperclass(UserService.class);
        // 设置enhancer的回调对象
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                System.out.println("before method run...");
                Object result = proxy.invokeSuper(obj, args);
                System.out.println("after method run...");
                return result;
            }
        });
        //创建代理对象
        UserService bean = (UserService) enhancer.create();
        bean.query();
    }
}//-----------结果------before method run...queryafter method run...

  PS:如果只是对项目中一个类进行代理,可以使用静态代理,如果是多个则使用动态代理;





粉丝福利:Java从入门到入土学习路线图

👇👇👇

👆长按上方微信二维码 2 秒


感谢点赞支持下哈 

浏览 20
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报