正文

[z]Java代理(jdk静态代理、动态代理和cglib动态代理)

IP云
IP云V管理员/6 阅读
11/28
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

一、代理是Java常用的设计模式，代理类通过调用被代理类的相关方法，并对相关方法进行增强。加入一些非业务性代码，比如事务、日志、报警发邮件等操作。

二、jdk静态代理

1、业务接口

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* 业务接口
* @author pc
*
*/
public interface UserService {
// 增加一个用户
public void addUser();
// 编辑账户
public void editUser();
}

2、业务实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
* 业务实现类
* @author pc
*
*/
public class UserServiceImpl implements UserService {
public void addUser() {
System.out.println( "增加一个用户。。。" );
}
public void editUser() {
System.out.println( "编辑一个用户。。。" );
}
}

3、代理类

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
/**
* 代理类
*
* @author pc
*
*/
public class UserServiceProxy implements UserService {
private UserServiceImpl userImpl;
public UserServiceProxy(UserServiceImpl countImpl) {
this .userImpl = countImpl;
}
public void addUser() {
System.out.println( "代理类方法，进行了增强。。。" );
System.out.println( "事务开始。。。" );
// 调用委托类的方法;
userImpl.addUser();
System.out.println( "处理结束。。。" );
}
public void editUser() {
System.out.println( "代理类方法，进行了增强。。。" );
System.out.println( "事务开始。。。" );
// 调用委托类的方法;
userImpl.editUser();
System.out.println( "事务结束。。。" );
}
}

4、测试类

1
2
3
4
5
6
7
public static void main(String[] args) {
UserServiceImpl userImpl = new UserServiceImpl();
UserServiceProxy proxy = new UserServiceProxy(userImpl);
proxy.addUser();
System.out.println( "----------分割线----------" );
proxy.editUser();
}

5、结果

1
2
3
4
5
6
7
8
9
代理类方法，进行了增强。。。
事务开始。。。
增加一个用户。。。
处理结束。。。
----------分割线----------
代理类方法，进行了增强。。。
事务开始。。。
编辑一个用户。。。
事务结束。。。

三、jdk动态代理

1、业务接口

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* 业务接口
* @author pc
*
*/
public interface UserService {
// 增加一个用户
public void addUser();
// 编辑账户
public void editUser();
}

2、业务接口实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
* 业务接口实现类
* @author pc
*
*/
public class UserServiceImpl implements UserService {
public void addUser() {
System.out.println( "增加一个用户。。。" );
}
public void editUser() {
System.out.println( "编辑一个用户。。。" );
}
}

3、代理类

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
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
*
* @author pc
*
*/
public class ServiceInvocationHandler implements InvocationHandler {
// 目标对象
private Object target;
public ServiceInvocationHandler(Object target) {
super ();
this .target = target;
}
/**
* 创建代理实例
* @return
* @throws Throwable
*/
public Object getProxy() throws Throwable {
return Proxy.newProxyInstance(Thread.currentThread()
.getContextClassLoader(), this .target.getClass()
.getInterfaces(), this );
// 这样写只返回了目标对象，没有生成代理对象。
// return target;
}
/**
* 实现InvocationHandler接口方法
* 执行目标对象的方法，并进行增强
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null ;
System.out.println( "代理类方法，进行了增强。。。" );
System.out.println( "事务开始。。。" );
// 执行目标方法对象
result = method.invoke(target, args);
System.out.println( "事务结束。。。" );
return result;
}
}

4、测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Test {
/**
* jdk动态代理会生成一个动态代理类，生成相应的字节码，然后通过ClassLoader加载字节码。
* 该实例继承了Proxy类，并实现了业务接口，在实现的方法里通过反射调用了InvocationHandler接口实现类
* 的invoke()回调方法。
* @param args
* @throws Throwable
*/
public static void main(String[] args) throws Throwable {
UserService userService = new UserServiceImpl();
ServiceInvocationHandler handler = new ServiceInvocationHandler(userService);
// 根据目标生成代理对象
UserService proxy = (UserService) handler.getProxy();
proxy.addUser();
//      proxy.editUser();
}
}

5、测试结果

1
2
3
4
代理类方法，进行了增强。。。
事务开始。。。
增加一个用户。。。
事务结束。。。

四、cglib动态代理

需要引入cglib的jar包，

在pom.xml加入依赖：

1
2
3
4
5
6
<!-- https: //mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version> 2.2 . 2 </version>
</dependency>

1、业务类，没有实现接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
* 业务类
* 没有实现接口
* 如果类是final的，则没法生成代理对象，报错。
* 如果方法是final的，代理无效
* @author pc
*
*/
public class UserServiceImpl {
public void addUser() {
System.out.println( "增加一个用户。。。" );
}
public void editUser() {
System.out.println( "编辑一个用户。。。" );
}
}

2、代理类

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
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
* 使用Cglib动态代理
* @author pc
*
*/
public class UserServiceCglib implements MethodInterceptor{
private Object target;
/**
* 创建代理实例
* @param target
* @return
*/
public Object getInstance(Object target){
this .target = target;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass( this .target.getClass());
// 设置回调方法
enhancer.setCallback( this );
// 创建代理对象
return enhancer.create();
}
/**
* 实现MethodInterceptor接口要重写的方法。
* 回调方法
*/
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println( "事务开始。。。" );
Object result = proxy.invokeSuper(obj, args);
System.out.println( "事务结束。。。" );
return result;
}
}

3、测试类

1
2
3
4
5
6
7
8
9
public class TestCglib {
public static void main(String[] args) {
UserServiceCglib cglib = new UserServiceCglib();
UserServiceImpl bookFacadeImpl = (UserServiceImpl)cglib.getInstance( new UserServiceImpl());
bookFacadeImpl.addUser();
//      bookFacadeImpl.editUser();
}
}

4、结果：

1
2
3
事务开始。。。
增加一个用户。。。
事务结束。。。

5、如果业务实现类被定义成final类，就会报以下错误

1
2
3
4
5
6
7
8
Exception in thread "main" java.lang.IllegalArgumentException: Cannot subclass final class class cn.xx.xx.cgilb.UserServiceImpl
at net.sf.cglib.proxy.Enhancer.generateClass(Enhancer.java: 446 )
at net.sf.cglib.core.DefaultGeneratorStrategy.generate(DefaultGeneratorStrategy.java: 25 )
at net.sf.cglib.core.AbstractClassGenerator.create(AbstractClassGenerator.java: 216 )
at net.sf.cglib.proxy.Enhancer.createHelper(Enhancer.java: 377 )
at net.sf.cglib.proxy.Enhancer.create(Enhancer.java: 285 )
at cn.pconline.proxy.cgilb.UserServiceCglib.getInstance(UserServiceCglib.java: 30 )
at cn.pconline.proxy.cgilb.TestCglib.main(TestCglib.java: 7 )

五、总结

1、原理

jdk静态代理实现比较简单，一般是直接代理对象直接包装了被代理对象。

jdk动态代理是接口代理，被代理类A需要实现业务接口，业务代理类B需要实现InvocationHandler接口。

jdk动态代理会根据被代理对象生成一个继承了Proxy类，并实现了该业务接口的jdk代理类，该类的字节码会被传进去的ClassLoader加载，创建了jdk代理对象实例，

jdk代理对象实例在创建时，业务代理对象实例会被赋值给Proxy类，jdk代理对象实例也就有了业务代理对象实例，同时jdk代理对象实例通过反射根据被代理类的业务方法创建了相应的Method对象m（可能有多个）。当jdk代理对象实例调用业务方法，如proxy.addUser();这个会先把对应的m对象作为参数传给invoke()方法（就是invoke方法的第二个参数），调用了jdk代理对象实例的invoke()回调方法，在invoke方法里面再通过反射来调用被代理对象的因为方法，即result = method.invoke(target, args);。

cglib动态代理是继承代理，通过ASM字节码框架修改字节码生成新的子类，重写并增强方法的功能。

2、优缺点

jdk静态代理类只能为一个被代理类服务，如果需要代理的类比较多，那么会产生过多的代理类。jdk静态代理在编译时产生class文件，运行时无需产生，可直接使用，效率好。

jdk动态代理必须实现接口，通过反射来动态代理方法，消耗系统性能。但是无需产生过多的代理类，避免了重复代码的产生，系统更加灵活。

cglib动态代理无需实现接口，通过生成子类字节码来实现，比反射快一点，没有性能问题。但是由于cglib会继承被代理类，需要重写被代理方法，所以被代理类不能是final类，被代理方法不能是final。

因此，cglib的应用更加广泛一点。

参考：http://blog.csdn.net/fighterandknight/article/details/51200470

http://blog.csdn.net/jiankunking/article/details/52143504

相关阅读

目录[+]