java基础
11 分钟 读完 (大约 1704 个字)

JDK动态代理的底层实现

JavaEE的开发中，许多框架用到了动态代理机制，例如Spring的AOP编程。Java中的动态代理一般就两种：1. JDK自带 ； 2. cglib库，本文主要介绍第一种。


什么是代理

真实对象的访问控制交由代理类实现，代理类成为外部对象与委托类的中间桥梁。

通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。

基于此，代理类可以做一些不影响真实对象功能的附加功能，例如内容校验、日志记录等。


静态代理

代理类的生成必须人为手动编写，无法自动生成，在程序运行前代理类的.class文件就已经存在。

例如：UserServiceImpl与StaticProxy都实现了接口IUserService

1
2
3
4
IUserService userService = new UserServiceImpl();
        StaticProxy proxy = new StaticProxy(userService);
        proxy.sayHello("andy");
        proxy.sayBye("andy");

动态代理-原理简介

动态代理是动态的生成代理类，已JDK动态代理为例，实现代理需要两个关键对象：代理类、调用处理器InvocationHandler。大致流程如下：

  • 编写InvocationHandler调用处理器
  • 被代理类实现接口
  • 生成代理类
  • 实现代理调用

示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class DynamicProxyHandler implements InvocationHandler {

    private IUserService target;

    public DynamicProxyHandler(IUserService target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        System.out.println("++++++before " + method.getName() + "++++++");
        result = method.invoke(target, args);
        System.out.println("++++++after " + method.getName() + "++++++");
        return result;
    }

    public Object getProxy(){
        /*
         * Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
         * 方法的第一个参数的作用就是 获取当前类的类加载器,作用是用来生成类的
         * 第二个参数是获取真实对象的所有接口    获取所有接口的目的是用来生成代理的,因为代理要实现所有的接口
         * 第三个参数是 调用处理器  这里传入调用处理器，是因为生成代理实例需要 调用处理器    为什么需要调用处理器，因为生成的代理不能直接调用真实对象的方法,
         * 而是通过调用处理器来调用真实对象的方法，具体就是通过上面定义的DynamicProxyHandler重写父类InvocationHandler的invoke方法
         */
        return  Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this );
    }

}
1
2
3
4
5
6
7
public static void testDynamicProxy() {
   DynamicProxyHandler handler = new DynamicProxyHandler(new UserServiceImpl());
   IUserService userService = (IUserService) handler.getProxy();
   userService.sayHello("jeck");
   userService.sayBye("jeck");

}

动态代理-底层代码分析

动态代理的核心是代理类如何生成？大体上如下流程：

  • 生成代理类字节码
  • 类加载器加载字节码
  • 生成代理类class
  • 实力化代理类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h) throws IllegalArgumentException {
    Objects.requireNonNull(h);

    final Class<?>[] intfs = interfaces.clone();
   //生成代理Class对象
    Class<?> cl = getProxyClass0(loader, intfs);

    try {
       //代理对象的构造方法
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        //实例化代理对象
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {

    }
}

getProxyClass0用于生成class对象，其首先去缓存WeakCache<ClassLoader, Class[], Class>取值，如果取不到则生成。核心代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
       Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
        for (Class<?> intf : interfaces) {
            Class<?> interfaceClass = null;
            try {
                interfaceClass = Class.forName(intf.getName(), false, loader);
            } catch (ClassNotFoundException e) {
            }
            if (interfaceClass != intf) {
                throw new IllegalArgumentException(
                    intf + " is not visible from class loader");
            }
            /*
             * Verify that the Class object actually represents an
             * interface.
             */
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }
            /*
             * Verify that this interface is not a duplicate.
             */
            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
        }

        String proxyPkg = null;     // package to define proxy class in
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

        /*
         * Record the package of a non-public proxy interface so that the
         * proxy class will be defined in the same package.  Verify that
         * all non-public proxy interfaces are in the same package.
         */
        for (Class<?> intf : interfaces) {
            int flags = intf.getModifiers();
            if (!Modifier.isPublic(flags)) {
                accessFlags = Modifier.FINAL;
                String name = intf.getName();
                int n = name.lastIndexOf('.');
                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                if (proxyPkg == null) {
                    proxyPkg = pkg;
                } else if (!pkg.equals(proxyPkg)) {
                    throw new IllegalArgumentException(
                        "non-public interfaces from different packages");
                }
            }
        }

        if (proxyPkg == null) {
            // if no non-public proxy interfaces, use com.sun.proxy package
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }

        /*
         * Choose a name for the proxy class to generate.
         */
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num;

        /*
         * Generate the specified proxy class.
         */
         //生成代理对象字节码
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        try {
            //返回代理Class对象
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            /*
             * A ClassFormatError here means that (barring bugs in the
             * proxy class generation code) there was some other
             * invalid aspect of the arguments supplied to the proxy
             * class creation (such as virtual machine limitations
             * exceeded).
             */
            throw new IllegalArgumentException(e.toString());
        }
    }
}

InvocationHandler的invoke方法如何被代理类使用？我们把代理类解析如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy11 extends Proxy implements IUserService {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m4;
    private static Method m0;

    //构造方法中传入处理对象
    public $Proxy11(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    //实现了相同的接口，通过处理对象的invoke方法调用
    public final void sayHello(String var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    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 void sayBye(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 int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m3 = Class.forName("com.github.sources.proxy.service.IUserService").getMethod("sayHello", new Class[]{Class.forName("java.lang.String")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m4 = Class.forName("com.github.sources.proxy.service.IUserService").getMethod("sayBye", new Class[]{Class.forName("java.lang.String")});
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

由以上可以得知，在实力化代理类时传递invocationHandler对象cons.newInstance(new Object[]{h});，在代理类构造方法中接收对象。


总结

  • JDK代理需要依赖代理类、调用处理器
  • 代理类的生成是核心：生成字节码、生成class对象、实力化代理类


版权声明：本文为博主原创文章，欢迎转载，转载请注明作者、原文超链接，感谢各位看官!!!

本文出自：monkeyGeek

座右铭：生于忧患，死于安乐

欢迎志同道合的朋友一起交流、探讨！

monkeyGeek
#

喜欢这篇文章？打赏一下作者吧

java的垃圾回收器
java偏向锁/轻量级锁/自旋锁/重量级锁

评论

关注我

分类

标签云

BASE理论 CAP理论 RPA RPA组件库 Saga Spring UiPath XA规范 activiti annotation注解 apollo blog docker eureka experienceShare feign git github hexo janusGraph java语法基础 java集合 jvm key mq mysql php基础 php语言 rabbitmq ribbon springboot ssh 事务 分布式 分布式一致性 多线程 并发容器 成长 所感 数据一致性 标准与规范 理财 算法 系统装机 网络协议 职业发展 读后感 锁 面试

最新文章

归档

标签

BASE理论 1
CAP理论 1
RPA 8
RPA组件库 1
Saga 1
Spring 5
UiPath 6
XA规范 1
activiti 8
annotation注解 5
apollo 1
blog 1
docker 1
eureka 1
experienceShare 1
feign 1
git 5
github 3
hexo 10
janusGraph 3
java语法基础 1
java集合 11
jvm 10
key 1
mq 5
mysql 1
php基础 1
php语言 1
rabbitmq 5
ribbon 1
springboot 2
ssh 1
事务 6
分布式 6
分布式一致性 3
多线程 6
并发容器 4
成长 1
所感 11
数据一致性 6
标准与规范 1
理财 2
算法 7
系统装机 1
网络协议 3
职业发展 10
读后感 9
锁 8
面试 91

最新文章

归档

标签

BASE理论 1
CAP理论 1
RPA 8
RPA组件库 1
Saga 1
Spring 5
UiPath 6
XA规范 1
activiti 8
annotation注解 5
apollo 1
blog 1
docker 1
eureka 1
experienceShare 1
feign 1
git 5
github 3
hexo 10
janusGraph 3
java语法基础 1
java集合 11
jvm 10
key 1
mq 5
mysql 1
php基础 1
php语言 1
rabbitmq 5
ribbon 1
springboot 2
ssh 1
事务 6
分布式 6
分布式一致性 3
多线程 6
并发容器 4
成长 1
所感 11
数据一致性 6
标准与规范 1
理财 2
算法 7
系统装机 1
网络协议 3
职业发展 10
读后感 9
锁 8
面试 91
Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×