代理模式
解决的问题：在直接访问对象时带来很大的开销。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。
代理模式就相当于Windows 里面的快捷方式，它并不实现什么功能，而只是在中间加以控制；而装饰器模式为了增强功能。
Java中的典型示例：静态代理：hibernate中的session.load()方法；动态代理：SpringAOP
代码实现：
1> 创建一个接口：Image.java
public interface Image {
void display();
}
2>创建两个接口的实现类
RealImage.java（假设该类实例化开销很大）
public class RealImage implements Image {
private String fileName;
public RealImage(String fileName){
this.fileName = fileName;
loadFromDisk(fileName); // 当实例化RealImage类的时候，会执行这个方法，打印输出语句
}
@Override
public void display() { // 重写父类的display方法
System.out.println("Displaying " + fileName);
}
private void loadFromDisk(String fileName){
System.out.println("Loading " + fileName);
}
}
ProxyImage.java（代理类）
public class ProxyImage implements Image{
private RealImage realImage;
private String fileName;
public ProxyImage(String fileName){ // 实例化时并不直接实例化RealImage，而是实例化这个类（这样就由类代理了RealImage的display方法）
this.fileName = fileName;
}
@Override
public void display() { // 当调用display方法时，实例化RealImage，然后再调用display方法
if(realImage == null){
realImage = new RealImage(fileName);
}
realImage.display();
}
}
3>当被请求时，使用 ProxyImage 来获取 RealImage 类的对象。
public class ProxyPatternDemo {
public static void main(String[] args) {
Image image = new ProxyImage("test_10mb.jpg"); // 实例化代理类
image.display(); 调用方法
}
}
静态代理与动态代理
静态代理：
静态代理就是我们上面写的内种方法，它的优缺点也很明显：
优点：
代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合）。
缺点：
1）代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。如上的代码是只为UserManager类的访问提供了代理，但是如果还要为其他类如Department类提供代理的话，就需要我们再次添加代理Department的代理类。
即静态代理类只能为特定的接口服务。如想要为多个接口服务则需要建立很多个代理类
动态代理：
根据如上的介绍，你会发现每个代理类只能为一个接口服务，这样程序开发中必然会产生许多的代理类
所以我们就会想办法可以通过一个代理类完成全部的代理功能，那么我们就需要用动态代理
在上面的示例中，一个代理只能代理一种类型，而且是在编译器就已经确定被代理的对象。而动态代理是在运行时，通过反射机制实现动态代理，并且能够代理各种类型的对象
在Java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持
剩下的猛击这里
装饰器模式
向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。
作用：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。
装饰器模式相当于孙悟空有 72 变，当他变成"庙宇"后，他的根本还是一只猴子，但是他又有了庙宇的功能。
优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。
缺点：多层装饰比较复杂。
实现步骤：
1、增强类与被增强的类要实现统一接口
2、在增强类中传入被增强的类
3、需要增强的方法重写 不需要增强的方法调用被增强对象的
示例：解决request.getParameter()方法获取的中文乱码问题
public class EncodingFilter implements Filter{
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
//被增强的对象
HttpServletRequest req = (HttpServletRequest) request;
//增强对象
EnhanceRequest enhanceRequest = new EnhanceRequest(req);
chain.doFilter(enhanceRequest, response);
}
}
class EnhanceRequest extends HttpServletRequestWrapper{ // 1>与要增强的类（HttpServletRequest类）继承/实现同一个类/接口
private HttpServletRequest request;
public EnhanceRequest(HttpServletRequest request) { // 2>传入要增强的类
super(request);
this.request = request;
}
//3>对要增强的方法（getParaameter）重写
@Override
public String getParameter(String name) {
String parameter = request.getParameter(name);//乱码
try {
parameter = new String(parameter.getBytes("iso8859-1"),"UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return parameter;
}
}
优点：
代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合），对于如上的客户端代码，newUserManagerImpl()可以应用工厂将它隐藏，如上只是举个例子而已。
缺点：
1）代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。如上的代码是只为UserManager类的访问提供了代理，但是如果还要为其他类如Department类提供代理的话，就需要我们再次添加代理Department的代理类。
举例说明：代理可以对实现类进行统一的管理，如在调用具体实现类之前，需要打印日志等信息，这样我们只需要添加一个代理类，在代理类中添加打印日志的功能，然后调用实现类，这样就避免了修改具体实现类。满足我们所说的开闭原则。但是如果想让每个实现类都添加打印日志的功能的话，就需要添加多个代理类，以及代理类中各个方法都需要添加打印日志功能（如上的代理方法中删除，修改，以及查询都需要添加上打印日志的功能）
即静态代理类只能为特定的接口(Service)服务。如想要为多个接口服务则需要建立很多个代理类。
引入动态代理：
根据如上的介绍，你会发现每个代理类只能为一个接口服务，这样程序开发中必然会产生许多的代理类
所以我们就会想办法可以通过一个代理类完成全部的代理功能，那么我们就需要用动态代理
在上面的示例中，一个代理只能代理一种类型，而且是在编译器就已经确定被代理的对象。而动态代理是在运行时，通过反射机制实现动态代理，并且能够代理各种类型的对象
在Java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持
java.lang.reflect.InvocationHandler接口的定义如下：
- //Object proxy:被代理的对象
- //Method method:要调用的方法
- //Object[] args:方法调用时所需要参数
- public interface InvocationHandler {
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
- }
java.lang.reflect.Proxy类的定义如下：
- //CLassLoader loader:类的加载器
- //Class<?> interfaces:得到全部的接口
- //InvocationHandler h:得到InvocationHandler接口的子类的实例
- public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
动态代理：
具体实现类
- public class UserManagerImpl implements UserManager {
- @Override
- public void addUser(String userId, String userName) {
- System.out.println("UserManagerImpl.addUser");
- }
- @Override
- public void delUser(String userId) {
- System.out.println("UserManagerImpl.delUser");
- }
- @Override
- public String findUser(String userId) {
- System.out.println("UserManagerImpl.findUser");
- return "张三";
- }
- @Override
- public void modifyUser(String userId, String userName) {
- System.out.println("UserManagerImpl.modifyUser");
- }
- }
动态创建代理对象的类
- //动态代理类只能代理接口（不支持抽象类），代理类都需要实现InvocationHandler类，实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类
- public class LogHandler implements InvocationHandler {
- // 目标对象
- private Object targetObject;
- //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。
- public Object newProxyInstance(Object targetObject){
- this.targetObject=targetObject;
- //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
- //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
- //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口
- //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法
- //根据传入的目标返回一个代理对象
- return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
- targetObject.getClass().getInterfaces(),this);
- }
- @Override
- //关联的这个实现类的方法被调用时将被执行
- /*InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/
- public Object invoke(Object proxy, Method method, Object[] args)
- throws Throwable {
- System.out.println("start-->>");
- for(int i=0;i<args.length;i++){
- System.out.println(args[i]);
- }
- Object ret=null;
- try{
- /*原对象方法调用前处理日志信息*/
- System.out.println("satrt-->>");
- //调用目标方法
- ret=method.invoke(targetObject, args);
- /*原对象方法调用后处理日志信息*/
- System.out.println("success-->>");
- }catch(Exception e){
- e.printStackTrace();
- System.out.println("error-->>");
- throw e;
- }
- return ret;
- }
- }
被代理对象targetObject通过参数传递进来，我们通过targetObject.getClass().getClassLoader()获取ClassLoader对象，然后通过targetObject.getClass().getInterfaces()获取它实现的所有接口，然后将targetObject包装到实现了InvocationHandler接口的LogHandler对象中。通过newProxyInstance函数我们就获得了一个动态代理对象。
客户端代码
- public class Client {
- public static void main(String[] args){
- LogHandler logHandler=new LogHandler();
- UserManager userManager=(UserManager)logHandler.newProxyInstance(new UserManagerImpl());
- //UserManager userManager=new UserManagerImpl();
- userManager.addUser("1111", "张三");
- }
- }
可以看到，我们可以通过LogHandler代理不同类型的对象，如果我们把对外的接口都通过动态代理来实现，那么所有的函数调用最终都会经过invoke函数的转发，因此我们就可以在这里做一些自己想做的操作，比如日志系统、事务、拦截器、权限控制等。这也就是AOP(面向切面编程)的基本原理。
插曲：
AOP（AspectOrientedProgramming）：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码---解耦。
针对如上的示例解释：
我们来看上面的UserManagerImplProxy类，它的两个方法System.out.println("start-->addUser()")和System.out.println("success-->addUser()")，这是做核心动作之前和之后的两个截取段，正是这两个截取段，却是我们AOP的基础，在OOP里，System.out.println("start-->addUser()")、核心动作、System.out.println("success-->addUser()")这个三个动作在多个类里始终在一起，但他们所要完成的逻辑却是不同的，如System.out.println("start-->addUser()")里做的可能是权限的判断，在所有类中它都是做权限判断，而在每个类里核心动作却各不相同，System.out.println("success-->addUser()")可能做的是日志，在所有类里它都做日志。正是因为在所有的类里，核心代码之前的操作和核心代码之后的操作都做的是同样的逻辑，因此我们需要将它们提取出来，单独分析，设计和编码，这就是我们的AOP思想。一句话说，AOP只是在对OOP的基础上进行进一步抽象，使我们的类的职责更加单一。
动态代理优点：
动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强
总结：
其实所谓代理，就是一个人或者一个机构代表另一个人或者另一个机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之前起到中介的作用。
代理对象就是把被代理对象包装一层，在其内部做一些额外的工作，比如用户需要上facebook,而普通网络无法直接访问，网络代理帮助用户先FQ，然后再访问facebook。这就是代理的作用了。
纵观静态代理与动态代理，它们都能实现相同的功能，而我们看从静态代理到动态代理的这个过程，我们会发现其实动态代理只是对类做了进一步抽象和封装，使其复用性和易用性得到进一步提升而这不仅仅符合了面向对象的设计理念，其中还有AOP的身影，这也提供给我们对类抽象的一种参考。关于动态代理与AOP的关系，个人觉得AOP是一种思想，而动态代理是一种AOP思想的实现！