Java动态代理的实现原理

概述

AOP用到了两种动态代理来实现织入功能:

  • jdk动态代理
  • cglib动态代理
  • 比较:
  • jdk动态代理是由java内部的反射机制来实现的,cglib动态代理底层则是借助asm来实现的。反射机制在生成类的过程中比较高效,而asm在生成类之后的相关执行过程中比较高效(可以通过将asm生成的类进行缓存,这样解决asm生成类过程低效问题)。
  • jdk动态代理的应用前提是目标类必须基于统一的接口。因此,jdk动态代理有一定的局限性,cglib这种第三方类库实现的动态代理应用更加广泛,且在效率上更有优势。

静态代理

  • 建一个接口,接口中定义相应(代理对象和目标对象都要实现)的 方法
public interface Subject{
void test();
}
  • 目标类(实现上述接口)
public class RealSubject implements Subject{
	@Override
	public void tset(){
	System.out.printin("target method");
	}
}
  • 代理类(实现上述接口)
public class Proxy implements Subject{
	private RealSubject realSubject;
	
	public Proxy(RealSubject realSubject){
	this.realSubject = realSubject;
	}


	@Override
	public void test(){
	System.out.printin("Before");
	try{
	realSubject.test();
	}catch(Exception e){
	System.out.println("ex:"+e.getmessage());
	throw e;
	}finally{
	System.out.println("After");
	}
}
}
  • 客户端调用
public class Client{
public static void main(String[] args){
//通过接口
Subject subject = new Proxy(new RealSubject());
subject.test();
}
}

动态代理

(静态代理缺点:不灵活,重复代码多)

基于接口代理(jdk)

  • 类:java.lang.reflect.Proxy(通过该类动态生成代理类)
  • 代理类实现接口:InvocationHandler
  • jdk代理只能基于接口动态代理(因为生成的proxy class中,继承了Proxy类,实现了需要代理的接口,而Java是单继承,多实现的处理方式)
  • 动态代理类
  • 实现接口的方法
  • 引用目标方法
  • 构造器注入目标方法
  • 通过反射调用目标方法
    public class JdkProxySubject implements InvocationHandler{

    
//引入要代理的真实对象
    private RealSubject realSubject;
    
    //用构造器注入目标方法,给我们要代理的真实对象赋初值
    public JdkProxySubject(RealSubject realSubject){
       this.realSubJect=realSubject;
    }
    //实现接口的方法
    @Override
    public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{
        System.out.println("before");
        Object result = null;
        try{
        //调用目标方法
        //利用反射构造目标对象
        //    当代理对象调用真实对象的方法时,其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
        result=method.invoke(realSubject,args);
        
        }catch(Exception e){
        System.out.println("ex:"+e.getMessage());
        throw e; 
        }finally{
            System.out.println("after");
        }
        return result;
    }
    }

  • 客户端调用(使用Proxy)
  public class Client{
  public static void main(String[] args){
    //使用Proxy构造对象
    //参数
    //java泛型需要转换一下
    /* 通过Proxy的newProxyInstance方法来创建我们的代理对象,我们来看看其三个参数
         * 第一个参数 getClassLoader() ,我们这里使用Client这个类的ClassLoader对象来加载我们的代理对象
         * 第二个参数表示我要代理的是该真实对象,这样我就能调用这组接口中的方法了
         * 第三个参数handler, 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
         * /
    Subject subject = (Subject) java.lang.reflect.Proxy.newProxyInstance(Client.class.getClassLoader(),new Class[]{Subject.class},new JdkProxySubject(new RralSubject()));
    //调用方法
    subject.test;
    }
    }
原理解析
过程
调用Proxy.newProxyInstance生成代理类的实现类:
  • 调用getProxyClass0寻找或生成指定代理类
    (从缓存中取,如果没有,就生成一个放在缓存中 : 通过ProxyClassFactory生成)
  • 缓存调用ProxyClassFactory生成代理类,proxy class的生成最终调用ProxyClassFactory的apply方法.
  • ProxyGenerator.generateProxyClass使用生成的代理类的名称,接口,访问标志生成proxyClassFile字节码
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                throw new IllegalArgumentException(e.toString());
            }

  • 生成字节码之后利用反射生成实例
    Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象,它并不是我们的InvocationHandler类型,也不是我们定义的那组接口的类型,而是在运行是动态生成的一个对象,并且命名方式都是这样的形式,以$开头,proxy为中,最后一个数字表示对象的标号。
InvocationHandler接口:

每一个动态代理类都必须要实现InvocationHandler这个接口,并且每个代理类的实例都关联到了一个handler,当我们通过代理对象调用一个方法的时候,这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法:

Object invoke(Object proxy, Method method, Object[] args) throws Throwable
我们看到这个方法一共接受三个参数,那么这三个参数分别代表什么呢?

-proxy:  指代我们所代理的那个真实对象
-method:  指代的是我们所要调用真实对象的某个方法的Method对象
-args:  指代的是调用真实对象某个方法时接受的参数

Proxy类
Proxy这个类的作用就是用来动态创建一个代理对象的类,它提供了许多的方法,但是我们用的最多的就是 newProxyInstance 这个方法:
这个方法的作用就是得到一个动态的代理对象,其接收三个参数,我们来看看这三个参数所代表的含义:
public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) throws IllegalArgumentException
  • loader:  一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载

  • interfaces:  一个Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口,如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口中的方法

  • h:  一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上

基于继承代理(cglib)

  • 代理类
 public class CglibMethodInterceptor implements MethodInterceptor{//主要的方法拦截类,它是Callback接口的子接口,需要用户实现

        @Override
        public Object intercept(Object obj,Method method,Object
        [] args,MethodProxy proxy )throws Throwable{
        System.out.println("before cgplib");
        Object result = null;
            try{
               //利用反射创建代理对象 
               result = proxy.invokeSuper(obj,args);
            }catch(Exception e){
            System.out.println("ex:"+e.getMessage());
                throw e;
            }finally{
                System.out.println("after cglib");
            }
            return result;
            }
        }
    
  • 调用类
 public class Client{
    public static void main(String[] args){
    // 主要的增强类
    Enhancer enhancer=new Enhancer;
    //  目标类 , 设置父类,被增强的类
    enhancer.setSuperclass(RealSubject.class);
    // 回调对象
    enhancer.setCallback(new CglibMethodInterceptor());
    //生成代理类对象,用cglibProxy来增强RealSubject
    Subject subject=enhancer.create();
    subject.test();
    }
}
原理解析

Cglib是一个优秀的动态代理框架,它的底层使用ASM在内存中动态的生成被代理类的子类,使用CGLIB即使代理类没有实现任何接口也可以实现动态代理功能。CGLIB具有简单易用,它的运行速度要远远快于JDK的Proxy动态代理:
CGLIB的核心类:

  • net.sf.cglib.proxy.Enhancer – 主要的增强类
  • net.sf.cglib.proxy.MethodInterceptor – 主要的方法拦截类,它是Callback接口的子接口,需要用户实现
  • net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method类的代理类,可以方便的实现对源对象方法的调用,如使用:
  • Object o = methodProxy.invokeSuper(proxy, args);//虽然第一个参数是被代理对象,也不会出现死循环的问题。

-net.sf.cglib.proxy.MethodInterceptor接口是最通用的回调(callback)类型,它经常被基于代理的AOP用来实现拦截(intercept)方法的调用。这个接口只定义了一个方法

public Object intercept(Object object, java.lang.reflect.Method method,
Object[] args, MethodProxy proxy) throws Throwable;
  • 第一个参数是代理对像,第二和第三个参数分别是拦截的方法和方法的参数。原来的方法可能通过使用java.lang.reflect.Method对象的一般反射调用,或者使用 net.sf.cglib.proxy.MethodProxy对象调用。net.sf.cglib.proxy.MethodProxy通常被首选使用,因为它更快。
Java字节码生成开源框架–ASM:

ASM 是一个 Java 字节码操控框架。它能够以二进制形式修改已有类或者动态生成类。ASM 可以直接产生二进制 class 文件,也可以在类被加载入 Java 虚拟机之前动态改变类行为。ASM 从类文件中读入信息后,能够改变类行为,分析类信息,甚至能够根据用户要求生成新类。
不过ASM在创建class字节码的过程中,操纵的级别是底层JVM的汇编指令级别,这要求ASM使用者要对class组织结构和JVM汇编指令有一定的了解。


文章目录

      • 概述
      • 静态代理
      • 动态代理
        • 基于接口代理(jdk)
          • 原理解析
        • 基于继承代理(cglib)
          • 原理解析
          • Java字节码生成开源框架--ASM:


喜欢的话可以点点关注,或者添加作者微信,欢迎随时来撩
Java动态代理的实现原理_第1张图片

你可能感兴趣的:(流水时代)