参考的资料：

http://blog.csdn.net/jiuqiyuliang/article/details/38423811
http://www.360doc.com/content/14/0801/14/1073512_398598312.shtml
代理模式：由代理对象持有原对象。在代理对象中做的操作实际上都是由原对象来执行的。

1.代理模式可以动态在真实方法被调用前添加一些代码。
2.代理模式更加灵活，根据传入不同的真实对象，去执行不同的策略，达到同一个结果。

静态代理：

1.需要一个统一的接口，接口规定了要执行什么方法。

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);  
      
}  

2.原对象实现接口

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 UserManagerImpl2 implements UserManager {  
  ........  
}  

3.代理对象实现接口，并且持有原对象。

可以看到代理类中所有的方法，实际上都是执行的原函数的方法

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);         
    }  
  
}  

4.客户端的调用

   UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());  
   userManager.addUser("001","于亮"); 
   //同样我们可以传入UserManagerImpl2，实现依赖注入
   UserManager userManager = new UserManagerImplProxy(new UserManagerImpl2());  
   userManager.addUser("001","于亮"); 

**代理模式很灵活，但同时由于接口的关系，一种代理类，只能代理一组同样实现了该接口的真实类。这样可能造成代理类过多，爆炸。

动态代理

参考资料：http://blog.csdn.net/jiuqiyuliang/article/details/38423811

1、通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(...);
2、通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类
Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});
3、通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
4、通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入
Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));
为了简化对象创建过程，Proxy类中的newInstance方法封装了2~4，只需两步即可完成代理对象的创建。
生成的ProxySubject继承Proxy类实现Subject接口，实现的Subject的方法实际调用处理器的invoke方法，而invoke方法利用反射调(根据传入的对象，以及参数)调用被代理对象的的方法（Object result=method.invoke(proxied,args)）

Paste_Image.png

如果我们在操作真实对象之前不做任何操作，或者都做统一的处理（比如加日志。），那么不管任何真实类都可以用一个动态代理类来操作，避免了代理类的爆炸

Paste_Image.png

使用：

Paste_Image.png