Java动态代理

Java动态代理

标签： Java动态代理代理

2013-09-06 09:59 719人阅读 评论(0) 收藏 举报

分类：

Java（14）

版权声明：本文为博主原创文章，未经博主允许不得转载。

提到Java动态代理，必须首先说一下Java静态代理，也就是通常所说的代理模式：

[java] view plain copy

1. package com.sean;  
2.   
3. public class User {  
4.     public Integer id;  
5.     public String name;  
6.       
7.     public Integer getId() {  
8.         return id;  
9.     }  
10.       
11.     public void setId(Integer id) {  
12.         this.id = id;  
13.     }  
14.       
15.     public String getName() {  
16.         return name;  
17.     }  
18.       
19.     public void setName(String name) {  
20.         this.name = name;  
21.     }  
22. }  

[java] view plain copy

1. package com.sean;  
2.   
3. public interface UserDAO {  
4.     public boolean add(User user);  
5.       
6.     public boolean delete(Integer id);  
7.       
8.     public boolean modify(User user);  
9.       
10.     public Object query(Integer id);  
11. }  

[java] view plain copy

1. package com.sean;  
2.   
3. public class UserDAOImpl implements UserDAO {  
4.     @Override  
5.     public boolean add(User user) {  
6.         System.out.println("Add a new user");  
7.         return true;  
8.     }  
9.   
10.     @Override  
11.     public boolean delete(Integer id) {  
12.         System.out.println("Delete a new user");  
13.         return true;  
14.     }  
15.   
16.     @Override  
17.     public boolean modify(User user) {  
18.         System.out.println("Modify a new user");  
19.         return true;  
20.     }  
21.   
22.     @Override  
23.     public Object query(Integer id) {  
24.         System.out.println("Query a new user");  
25.         return new User();  
26.     }  
27. }  

UserDAOImpl类的代理类

[java] view plain copy

1. package com.sean;  
2.   
3. public class UserDAOProxy implements UserDAO {  
4.     private UserDAO userDAO;  
5.       
6.     public UserDAOProxy(UserDAO userDAO){  
7.         this.userDAO = userDAO;  
8.     }  
9.   
10.     @Override  
11.     public boolean add(User user) {  
12.         this.beginTransaction();  
13.         boolean result = userDAO.add(user);  
14.         this.endTransaction();  
15.         return result;  
16.     }  
17.   
18.     @Override  
19.     public boolean delete(Integer id) {  
20.         this.beginTransaction();  
21.         boolean result = userDAO.delete(id);  
22.         this.endTransaction();  
23.         return result;  
24.     }  
25.   
26.     @Override  
27.     public boolean modify(User user) {  
28.         this.beginTransaction();  
29.         boolean result = userDAO.modify(user);  
30.         this.endTransaction();  
31.         return result;  
32.     }  
33.   
34.     @Override  
35.     public Object query(Integer id) {  
36.         this.beginTransaction();  
37.         Object obj = userDAO.query(id);  
38.         this.endTransaction();  
39.         return obj;  
40.     }  
41.       
42.     private void beginTransaction(){  
43.         System.out.println("Begin transaction");  
44.     }  
45.       
46.     private void endTransaction(){  
47.         System.out.println("End transaction");  
48.     }  
49. }  

从上面的代码中我们可以发现静态代理一个很明显的问题就是重复代码太多，不利于维护

当然如果想要使用动态代理，目标类必须是一个接口实现类，由于UserDAOImpl是一个接口实现类，满足使用Java动态代理的条件，我们可以使用Java动态代理避免出现太多重复性代码的问题

对于非接口实现类，CGlib可以作为动态代理一个很好的补充

看到这里是不是想到了spring AOP的应用场景？没错，Spring AOP也是使用Java动态代理实现的（针对非接口实现类，Spring AOP使用CGlib实现）

[java] view plain copy

1. package com.sean;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6.   
7. public class TransactionHandler implements InvocationHandler {  
8.     private UserDAO userDAO;  
9.       
10.     @Override  
11.     public Object invoke(Object proxy, Method method, Object[] args)  
12.             throws Throwable {  
13.         this.beginTransaction();  
14.         Object obj =  method.invoke(userDAO, args);  
15.         this.endTransaction();  
16.         return obj;  
17.     }  
18.       
19.     public UserDAO createProxy(UserDAO userDAO){  
20.         this.userDAO = userDAO;  
21.         return (UserDAO)Proxy.newProxyInstance(userDAO.getClass().getClassLoader(),   
22.                 userDAO.getClass().getInterfaces(), this);  
23.     }  
24.       
25.     private void beginTransaction(){  
26.         System.out.println("Begin transaction");  
27.     }  
28.       
29.     private void endTransaction(){  
30.         System.out.println("End transaction");  
31.     }  
32. }  

[java] view plain copy

1. package com.sean;  
2.   
3. public class Test {  
4.     public static void main(String[] args) {  
5.         UserDAO userDAO = new UserDAOImpl();  
6.         TransactionHandler th = new TransactionHandler();  
7.         UserDAO userDAOProxy = th.createProxy(userDAO);  
8.         userDAOProxy.add(new User());  
9.     }  
10. }  

UserDAO的代理类及其实例是在运行期间由Proxy的newProxyInstance动态生成的，所以被称为动态代理

从代码中可以看到，动态代理不但快捷方便而且对原代码没有任何侵入性