Java三种代理模式：静态代理、动态代理和cglib代理

最新推荐文章于 2022-05-17 11:31:01 发布

Arthur-Ji

最新推荐文章于 2022-05-17 11:31:01 发布

阅读量192

点赞数

分类专栏： Java

原文链接：https://segmentfault.com/a/1190000011291179

版权

Java 专栏收录该内容

115 篇文章 2 订阅

订阅专栏

一、代理模式介绍

代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强原对象的功能和简化访问方式。

代理模式UML类图

代理模式UML类图

举个例子，我们生活中经常到火车站去买车票，但是人一多的话，就会非常拥挤，于是就有了代售点，我们能从代售点买车票了。这其中就是代理模式的体现，代售点代理了火车站对象，提供购买车票的方法。

二、静态代理

这种代理方式需要代理对象和目标对象实现一样的接口。

优点：可以在不修改目标对象的前提下扩展目标对象的功能。

缺点：

冗余。由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
不易维护。一旦接口增加方法，目标对象与代理对象都要进行修改。

举例：保存用户功能的静态代理实现

接口类： IUserDao

public interface IUserDao {
public void save();
}" title="" data-original-title=“复制”>

package com.proxy;

public interface IUserDao {
public void save();
}

目标对象：UserDao

public class UserDao implements IUserDao{

@Override
public void save() {
    System.out.println(&quot;保存数据&quot;);
}

}" title="" data-original-title=“复制”>

package com.proxy;

public class UserDao implements IUserDao{

<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">save</span><span class="hljs-params">()</span> </span>{
    System.out.println(<span class="hljs-string">"保存数据"</span>);
}

}

静态代理对象：UserDapProxy 需要实现IUserDao接口！

public class UserDaoProxy implements IUserDao{

private IUserDao target;
public UserDaoProxy(IUserDao target) {
    this.target = target;
}

@Override
public void save() {
    System.out.println(&quot;开启事务&quot;);//扩展了额外功能
    target.save();
    System.out.println(&quot;提交事务&quot;);
}

}
" title="" data-original-title=“复制”>

package com.proxy;

public class UserDaoProxy implements IUserDao{

<span class="hljs-keyword">private</span> IUserDao target;
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">UserDaoProxy</span><span class="hljs-params">(IUserDao target)</span> </span>{
    <span class="hljs-keyword">this</span>.target = target;
}

<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">save</span><span class="hljs-params">()</span> </span>{
    System.out.println(<span class="hljs-string">"开启事务"</span>);<span class="hljs-comment">//扩展了额外功能</span>
    target.save();
    System.out.println(<span class="hljs-string">"提交事务"</span>);
}

}

测试类：TestProxy

import org.junit.Test;

public class StaticUserProxy {
@Test
public void testStaticProxy(){
//目标对象
IUserDao target = new UserDao();
//代理对象
UserDaoProxy proxy = new UserDaoProxy(target);
proxy.save();
}
}" title="" data-original-title=“复制”>

package com.proxy;

import org.junit.Test;

public class StaticUserProxy {
@Test
public void testStaticProxy(){
//目标对象
IUserDao target = new UserDao();
//代理对象
UserDaoProxy proxy = new UserDaoProxy(target);
proxy.save();
}
}

输出结果

开启事务
保存数据
提交事务

三、动态代理

动态代理利用了JDK API，动态地在内存中构建代理对象，从而实现对目标对象的代理功能。动态代理又被称为JDK代理或接口代理。

静态代理与动态代理的区别主要在：

静态代理在编译时就已经实现，编译完成后代理类是一个实际的class文件
动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中

特点：
动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理。

JDK中生成代理对象主要涉及的类有

java.lang.reflect Proxy，主要方法为

Class<?>[] interfaces, //目标对象实现的接口的类型
InvocationHandler h //事件处理器
)
//返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。" title="" data-original-title=“复制”>

static Object    newProxyInstance(ClassLoader loader,  //指定当前目标对象使用类加载器

Class<?>[] interfaces, //目标对象实现的接口的类型
InvocationHandler h //事件处理器
)
//返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

java.lang.reflect InvocationHandler，主要方法为

 Object    invoke(Object proxy, Method method, Object[] args) 
// 在代理实例上处理方法调用并返回结果。

举例：保存用户功能的动态代理实现

接口类： IUserDao

public interface IUserDao {
public void save();
}" title="" data-original-title=“复制”>

package com.proxy;

public interface IUserDao {
public void save();
}

目标对象：UserDao

public class UserDao implements IUserDao{

@Override
public void save() {
    System.out.println(&quot;保存数据&quot;);
}

}" title="" data-original-title=“复制”>

package com.proxy;

public class UserDao implements IUserDao{

<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">save</span><span class="hljs-params">()</span> </span>{
    System.out.println(<span class="hljs-string">"保存数据"</span>);
}

}

动态代理对象：UserProxyFactory

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

public class ProxyFactory {

private Object target;// 维护一个目标对象

public ProxyFactory(Object target) {
    this.target = target;
}

// 为目标对象生成代理对象
public Object getProxyInstance() {
    return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
            new InvocationHandler() {

                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println(&quot;开启事务&quot;);

                    // 执行目标对象方法
                    Object returnValue = method.invoke(target, args);

                    System.out.println(&quot;提交事务&quot;);
                    return null;
                }
            });
}

}" title="" data-original-title=“复制”>

package com.proxy;

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

public class ProxyFactory {

<span class="hljs-keyword">private</span> Object target;<span class="hljs-comment">// 维护一个目标对象</span>

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">ProxyFactory</span><span class="hljs-params">(Object target)</span> </span>{
    <span class="hljs-keyword">this</span>.target = target;
}

<span class="hljs-comment">// 为目标对象生成代理对象</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> Object <span class="hljs-title">getProxyInstance</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
            <span class="hljs-keyword">new</span> InvocationHandler() {

                <span class="hljs-meta">@Override</span>
                <span class="hljs-function"><span class="hljs-keyword">public</span> Object <span class="hljs-title">invoke</span><span class="hljs-params">(Object proxy, Method method, Object[] args)</span> <span class="hljs-keyword">throws</span> Throwable </span>{
                    System.out.println(<span class="hljs-string">"开启事务"</span>);

                    <span class="hljs-comment">// 执行目标对象方法</span>
                    Object returnValue = method.invoke(target, args);

                    System.out.println(<span class="hljs-string">"提交事务"</span>);
                    <span class="hljs-keyword">return</span> <span class="hljs-keyword">null</span>;
                }
            });
}

}

测试类：TestProxy

import org.junit.Test;

public class TestProxy {

@Test
public void testDynamicProxy (){
    IUserDao target = new UserDao();
    System.out.println(target.getClass());  //输出目标对象信息
    IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
    System.out.println(proxy.getClass());  //输出代理对象信息
    proxy.save();  //执行代理方法
}

}" title="" data-original-title=“复制”>

package com.proxy;

import org.junit.Test;

public class TestProxy {

<span class="hljs-meta">@Test</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">testDynamicProxy</span> <span class="hljs-params">()</span></span>{
    IUserDao target = <span class="hljs-keyword">new</span> UserDao();
    System.out.println(target.getClass());  <span class="hljs-comment">//输出目标对象信息</span>
    IUserDao proxy = (IUserDao) <span class="hljs-keyword">new</span> ProxyFactory(target).getProxyInstance();
    System.out.println(proxy.getClass());  <span class="hljs-comment">//输出代理对象信息</span>
    proxy.save();  <span class="hljs-comment">//执行代理方法</span>
}

}

输出结果

class com.proxy.UserDao
class com.sun.proxy.$Proxy4
开启事务
保存数据
提交事务

四、cglib代理

cglib is a powerful, high performance and quality Code Generation Library. It can extend JAVA classes and implement interfaces at runtime.

cglib (Code Generation Library )是一个第三方代码生成类库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

cglib特点

JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。
如果想代理没有实现接口的类，就可以使用CGLIB实现。
CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。
它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。
不鼓励直接使用ASM，因为它需要你对JVM内部结构包括class文件的格式和指令集都很熟悉。

cglib与动态代理最大的区别就是

使用动态代理的对象必须实现一个或多个接口
使用cglib代理的对象则无需实现接口，达到代理类无侵入。

使用cglib需要引入cglib的jar包，如果你已经有spring-core的jar包，则无需引入，因为spring中包含了cglib。

cglib的Maven坐标

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.5</version>
</dependency>

举例：保存用户功能的动态代理实现

目标对象：UserDao

public class UserDao{

public void save() {
    System.out.println(&quot;保存数据&quot;);
}

}" title="" data-original-title=“复制”>

package com.cglib;

public class UserDao{

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">save</span><span class="hljs-params">()</span> </span>{
    System.out.println(<span class="hljs-string">"保存数据"</span>);
}

}

代理对象：ProxyFactory

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class ProxyFactory implements MethodInterceptor{

private Object target;//维护一个目标对象
public ProxyFactory(Object target) {
    this.target = target;
}

//为目标对象生成代理对象
public Object getProxyInstance() {
    //工具类
    Enhancer en = new Enhancer();
    //设置父类
    en.setSuperclass(target.getClass());
    //设置回调函数
    en.setCallback(this);
    //创建子类对象代理
    return en.create();
}

@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
    System.out.println(&quot;开启事务&quot;);
    // 执行目标对象的方法
    Object returnValue = method.invoke(target, args);
    System.out.println(&quot;关闭事务&quot;);
    return null;
}

}" title="" data-original-title=“复制”>

package com.cglib;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class ProxyFactory implements MethodInterceptor{

<span class="hljs-keyword">private</span> Object target;<span class="hljs-comment">//维护一个目标对象</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">ProxyFactory</span><span class="hljs-params">(Object target)</span> </span>{
    <span class="hljs-keyword">this</span>.target = target;
}

<span class="hljs-comment">//为目标对象生成代理对象</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> Object <span class="hljs-title">getProxyInstance</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-comment">//工具类</span>
    Enhancer en = <span class="hljs-keyword">new</span> Enhancer();
    <span class="hljs-comment">//设置父类</span>
    en.setSuperclass(target.getClass());
    <span class="hljs-comment">//设置回调函数</span>
    en.setCallback(<span class="hljs-keyword">this</span>);
    <span class="hljs-comment">//创建子类对象代理</span>
    <span class="hljs-keyword">return</span> en.create();
}

<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> Object <span class="hljs-title">intercept</span><span class="hljs-params">(Object obj, Method method, Object[] args, MethodProxy proxy)</span> <span class="hljs-keyword">throws</span> Throwable </span>{
    System.out.println(<span class="hljs-string">"开启事务"</span>);
    <span class="hljs-comment">// 执行目标对象的方法</span>
    Object returnValue = method.invoke(target, args);
    System.out.println(<span class="hljs-string">"关闭事务"</span>);
    <span class="hljs-keyword">return</span> <span class="hljs-keyword">null</span>;
}

}

测试类：TestProxy

import org.junit.Test;

public class TestProxy {

@Test
public void testCglibProxy(){
    //目标对象
    UserDao target = new UserDao();
    System.out.println(target.getClass());
    //代理对象
    UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance();
    System.out.println(proxy.getClass());
    //执行代理对象方法
    proxy.save();
}

}
" title="" data-original-title=“复制”>

package com.cglib;

import org.junit.Test;

public class TestProxy {

<span class="hljs-meta">@Test</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">testCglibProxy</span><span class="hljs-params">()</span></span>{
    <span class="hljs-comment">//目标对象</span>
    UserDao target = <span class="hljs-keyword">new</span> UserDao();
    System.out.println(target.getClass());
    <span class="hljs-comment">//代理对象</span>
    UserDao proxy = (UserDao) <span class="hljs-keyword">new</span> ProxyFactory(target).getProxyInstance();
    System.out.println(proxy.getClass());
    <span class="hljs-comment">//执行代理对象方法</span>
    proxy.save();
}

}

输出结果

class com.cglib.UserDao
class com.cglib.UserDao$$EnhancerByCGLIB$$552188b6
开启事务
保存数据
关闭事务

五、总结

静态代理实现较简单，只要代理对象对目标对象进行包装，即可实现增强功能，但静态代理只能为一个目标对象服务，如果目标对象过多，则会产生很多代理类。
JDK动态代理需要目标对象实现业务接口，代理类只需实现InvocationHandler接口。
动态代理生成的类为 lass com.sun.proxy.\$Proxy4，cglib代理生成的类为class com.cglib.UserDao\$\$EnhancerByCGLIB\$\$552188b6。
静态代理在编译时产生class字节码文件，可以直接使用，效率高。
动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。
cglib代理无需实现接口，通过生成类字节码实现代理，比反射稍快，不存在性能问题，但cglib会继承目标对象，需要重写方法，所以目标对象不能为final类。

六、相关资料

代理模式相关知识

UML相关知识

Arthur-Ji

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java三种代理模式：静态代理、动态代理和cglib代理

一、代理模式介绍代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强原对象的功能和简化访问方式。代理模式UML类图举个例子，我们生活中经常到火车站去买车票，但是人一多的话，就会非常拥挤，于是就有了代售点，我们能从代售点买车票了。这其中就是代理模式的体现，代售点代理了火车站对象，提供购买车票的方法。二、静态代理这种代理方.
复制链接

扫一扫

专栏目录