这篇博文，我们主要以类图和代码的形式来对照学习一下静态代理和动态代理。重点解析各自的优缺点。
定义代理模式（Proxy Pattern）是对象的结构型模式，代理模式给某一个对象提供了一个代理对象，并由代理对象控制对原对象的引用。
代理模式不会改变原来的接口和行为，仅仅是转由代理干某件事，代理能够控制原来的目标，比如：代理商，代理商仅仅会买东西，但并不会改变行为。不会制造东西。
让我们通过以下的代码好好理解一下这句话。
分类静态代理和动态代理
静态代理静态代理类图
代码演示样例
接口
package com.liang.pattern;
public interface UserManager {
public void addUser(String userId,String userName);
public void delUser(String userId);
public void modifyUser(String userId,String userName);
public String findUser(String userId);
}
目标对象
package com.liang.pattern;
public class UserManagerImpl implements UserManager {
public void addUser(String userId, String userName) {
try{
System.out.println("UserManagerImpl.addUser() userId-->>" + userId);
}catch(Exception e){
e.printStackTrace();
throw new RuntimeException();
}
}
public void delUser(String userId) {
System.out.println("UserManagerImpl.delUser() userId-->>" + userId);
}
public String findUser(String userId) {
System.out.println("UserManagerImpl.findUser() userId-->>" + userId);
return "于亮";
}
public void modifyUser(String userId, String userName) {
System.out.println("UserManagerImpl.modifyUser() userId-->>" + userId);
}
}
代理类，我们使用代理对象做一些日志记录，我们将简略的打印信息到控制台。
package com.liang.pattern;
public class UserManagerImplProxy implements UserManager {
private UserManager userManager;
public UserManagerImplProxy(UserManager userManager){
this.userManager = userManager;
}
public void addUser(String userId, String userName) {
//记录日志等操作或打印输入參数
System.out.println("start-->>addUser() userId-->>" + userId);
try{
userManager.addUser(userId, userName);
//运行成功。打印成功信息
System.out.println("success-->>addUser()");
}catch(Exception e){
e.printStackTrace();
//失败时。打印失败信息
System.out.println("error-->>addUser()");
//throw new RuntimeException();
}
}
public void delUser(String userId) {
//同上，略
userManager.delUser(userId);
}
public String findUser(String userId) {
//同上。略
userManager.findUser(userId);
return null;
}
public void modifyUser(String userId, String userName) {
//同上。略
userManager.modifyUser(userId, userName);
}
}
client调用
package com.liang.pattern;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());
userManager.addUser("001","于亮");
}
} 输出结果，此方法运行成功
start-->>addUser() userId-->>001 UserManagerImpl.addUser() userId-->>001 success-->>addUser()
从类图我们能够看出。client本来能够直接和目标对象打交道，代理中间加了一个间接层。他们实现的功能是一样的，也没有改变參数。相信大家对上面的类图和代码非常熟悉。跟我们平时看别人的博文一样。没有不论什么差别。以下我们看一下静态代理的优缺点。
优缺点
长处：
1、直观感受，静态代理是实实在在的存在的，我们自己写的。
2、在编译期增加，提前就指定好了谁调用谁，效率高。
缺点：
相同，它的长处也成了它致命的缺点。
1、静态代理非常麻烦。须要大量的代理类
当我们有多个目标对象须要代理时，我就须要建立多个代理类。改变原有的代码，改的多了就非常有可能出问题，必须要又一次測试。
2、反复的代码会出如今各个角落里，违背了一个原则：反复不是好味道
我们应该杜绝一次次的反复。
3、在编译期增加，系统的灵活性差
我们能够看到代理类的每一个方法中，都有记录日志，运行成功或失败的代码，每一个方法都反复了一遍，假设我们须要改动的话，并没有比不用静态代理时降低改动的地方。仅仅是不用改动目标类。动态代理非常好的为我们攻克了这个问题。以下我们看一下动态代理。
动态代理动态代理类图
代码演示样例
代理类（不明确，就看看凝视吧）
package com.liang.pattern;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 採用JDK动态代理必须实现InvocationHandler接口。採用Proxy类创建对应的代理类
* @author liang
*
*/
public class ProxyHandler implements InvocationHandler {
private Object targetObject;
/**
* 目标的初始化方法。依据目标生成代理类
* @param targetObject
* @return
*/
public Object newProxyInstance(Object targetObject){
this.targetObject = targetObject;
//第一个參数，目标的装载器
//第二个參数，目标接口，为每一个接口生成代理
//第三个參数，调用实现了InvocationHandler的对象。当你一调用代理，代理就会调用InvocationHandler的invoke方法
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
}
/**
* 反射，这样你能够在不知道详细的类的情况下，依据配置的參数去调用一个类的方法。在灵活编程的时候很实用。
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//记录日志等操作或打印输入參数
System.out.println("start-->>" + method.getName());
for(int i=0;i<args.length;i++){
//打印调用目标方法的參数
System.out.println(args[i]);
}
Object ret = null;
try{
//调用目标方法
ret = method.invoke(targetObject, args);
//运行成功。打印成功信息
System.out.println("success-->>" + method.getName());
}catch(Exception e){
e.printStackTrace();
//失败时，打印失败信息
System.out.println("error-->>" + method.getName());
throw e;
}
return ret;
}
}
client调用
package com.liang.pattern;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
ProxyHandler proxyHandler = new ProxyHandler();
UserManager userManager = (UserManager)proxyHandler.newProxyInstance(new UserManagerImpl());
String name = userManager.findUser("0001");
System.out.println("client.main-->>" + name);
}
}
输出结果，执行成功
start-->>findUser 0001 UserManagerImpl.findUser() userId-->>0001 success-->>findUser client.main-->>于亮
接口和目标类，同上，我就不再浪费大家的带宽了。
优缺点
长处：
1、一个动态代理类更加简单了，能够解决创建多个静态代理的麻烦，避免不断的反复多余的代码
2、调用目标代码时，会在方法“执行时”动态的增加，决定你是什么类型，才调谁，灵活
缺点：
1、系统灵活了。可是相比而言，效率减少了，比静态代理慢一点
2、动态代理比静态代理在代码的可读性上差了一点，不太easy理解
3、JDK动态代理仅仅能对实现了接口的类进行代理
总结静态代理VS动态代理，打成了平手，各自有各的独特之处，均不可取代，在项目中究竟使用哪种代理，没有最好。仅仅有更合适。