深入浅出java静态代理和动态代理

首先介绍一下，什么是代理：

代理模式，是常用的设计模式。特征是，代理类与委托类有相同的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类。以及事后处理消息。

代理类和委托类，存在着关联关系。代理类的对象本身并不真正实现服务，知识通过调用委托类的对象的相关方法。

代理类可以分为两种：静态代理和动态代理。

静态代理：

代理类是由程序员创建，或由工具生成的代码 编译成的。在程序运行前，代理类的 *.class文件已经存在了。直接就可以运行 。

动态代理：

动态代理的代理类。没有直接由源代码生成。动态代理类的对象是在程序运行时由Java反射机制动态生成，不需要手工编写源代码。从而提高了软件的可扩展性。JAVA反射机制可以生成任意类型的动态代理类。

静态代理的实现：

接口：

1. package test.static.pattern;
3. public interface UserManager {
5. public void addUser(String userId,String userName);
7. public void delUser(String userId);
9. public String findUser(String userId);
11. public void modifyUser(String userId,String userNameString);
12. }

实现类：

1. package test.static.pattern;
3. public class UserManagerImpl implements UserManager {
5. @Override
6. public void addUser(String userId, String userName) {
7. System.out.println("UserManagerImpl.addUser() userId-->>" + userId);
8. }
10. @Override
11. public void delUser(String userId) {
12. System.out.println("UserManagerImpl.delUser() userId-->>" + userId);
13. }
15. @Override
16. public String findUser(String userId) {
17. System.out.println("UserManagerImpl.findUser() userId-->>" + userId);
18. return null;
19. }
21. @Override
22. public void modifyUser(String userId, String userNameString) {
23. System.out.println("UserManagerImpl.modifyUser() userId-->>" + userId);
24. }
26. }

静态代理类：（只持有对象的引用）

1. package test.static.pattern;
3. public class UserManagerImplProxy implements UserManager {
5. private UserManager userManager;
7. public UserManagerImplProxy (UserManager userManager){
8. this.userManager=userManager;
9. }
11. @Override
12. public void addUser(String userId, String userName) {
13. userManager.addUser(userId, userName);
14. }
16. @Override
17. public void delUser(String userId) {
18. userManager.delUser(userId);
19. }
21. @Override
22. public String findUser(String userId) {
24. return userManager.findUser(userId);
25. }
27. @Override
28. public void modifyUser(String userId, String userNameString) {
29. userManager.modifyUser(userId, userNameString);
30. }
32. }

客户端：

1. package test.static.pattern;
3. public class Client {
4. /**
5. * @param args
6. */
7. public static void main(String[] args) {
8. //正常思路：客户端直接实例化出 子类的对象
9. UserManager userManager=new UserManagerImpl();
10. //静态代理：客户端实例化代理，通过代理取 子类的引用
11. UserManager userManager=new UserManagerImplProxy(new UserManagerImpl());
12. userManager.addUser("0001", "张三");
13. }
14. }

执行结果：

静态代理，因为代理类持有对象的引用，所以可以对其进行控制。

现象1：对于各个功能模块来说，都要建立对应的代理类。造成大量的代理类

现象2：但是如果对各个实现相同的控制，则需要重复写大量的代码。

为了避免重复代码出现多次，我们接着看什么是动态代理。

动态代理的实现：

接口：

1. package test.dynamic.pattern;
3. public interface UserManager {
5. public void addUser(String userId,String userName);
7. public void delUser(String userId);
9. public String findUser(String userId);
11. public void modifyUser(String userId,String userNameString);
12. }

实现类：

• package test.dynamic.pattern;
• public class UserManagerImpl implements UserManager {
• @Override
• public void addUser(String userId, String userName) {
• System.out.println("UserManagerImpl.addUser() userId-->>" + userId);
• }
• @Override
• public void delUser(String userId) {
• System.out.println("UserManagerImpl.delUser() userId-->>" + userId);
• }
• @Override
• public String findUser(String userId) {
• System.out.println("UserManagerImpl.findUser() userId-->>" + userId);
• return null;
• }
• @Override
• public void modifyUser(String userId, String userNameString) {
• System.out.println("UserManagerImpl.modifyUser() userId-->>" + userId);
• }
• }

动态代理生成类：

1. package test.dynamic.pattern;
3. import java.lang.reflect.InvocationHandler;
4. import java.lang.reflect.Method;
5. import java.lang.reflect.Proxy;
7. import org.omg.CORBA.SystemException;
8. import org.omg.CORBA.portable.InputStream;
9. import org.omg.CORBA.portable.InvokeHandler;
10. import org.omg.CORBA.portable.OutputStream;
11. import org.omg.CORBA.portable.ResponseHandler;
13. public class LogHandler implements InvocationHandler {
15. /**
16. * 调用引用对象类的方法抽象
17. */
18. @Override
19. public Object invoke(Object proxy, Method method, Object[] args)
20. throws Throwable {
22. Object ret=null;
23. try {
24. //调用目标方法
25. ret=method.invoke(targetObject, args);
26. } catch (Exception e) {
27. throw e;
28. }
29. return ret;
30. }
32. //目标实现的引用
33. private Object targetObject;
35. /**
36. * 代理类生成方法
37. * @param targetObject
38. * @return
39. */
40. public Object newProxyInstance(Object targetObject){
41. this.targetObject=targetObject;
42. return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
43. }
44. }

客户端：

• package test.dynamic.pattern;
• public class Client {
• /**
• * @param args
• */
• public static void main(String[] args) {
• //动态代理
• LogHandler logHandler=new LogHandler();
• UserManager userManager=(UserManager)logHandler.newProxyInstance(new UserManagerImpl());
• //userManager.addUser("0001", "张三");
• userManager.delUser("111");
• }
• }

执行结果：

动态代理类，在程序中没有体现。只有在程序运行的时候采用创建相应的代理类。这样就可以少写大量的代理类。