代理模式

它在不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能.

应用场景

  1. 业务系统的非功能性需求开发, 比如：监控、统计、鉴权、限流、事务、幂等、日志。
  2. 代理模式在 RPC、缓存中的应用
  • RPC 框架也可以看作一种代理模式，GoF 的《设计模式》一书中把它称作远程代理。通过远程代理，将网络通信、数据编解码等细节隐藏起来。
  • 基于 Spring 框架来开发，可以在 AOP 切面中完成接口缓存的功能。

java动态代理示例代码

  2. public class MetricsCollectorProxy {
  3.   private MetricsCollector metricsCollector;
  5.   public MetricsCollectorProxy() {
  6.     this.metricsCollector = new MetricsCollector();
  7.   }
  9.   public Object createProxy(Object proxiedObject) {
  10.     Class<?>[] interfaces = proxiedObject.getClass().getInterfaces();
  11.     DynamicProxyHandler handler = new DynamicProxyHandler(proxiedObject);
  12.     return Proxy.newProxyInstance(proxiedObject.getClass().getClassLoader(), interfaces, handler);
  13.   }
  15.   private class DynamicProxyHandler implements InvocationHandler {
  16.     private Object proxiedObject;
  18.     public DynamicProxyHandler(Object proxiedObject) {
  19.       this.proxiedObject = proxiedObject;
  20.     }
  22.     @Override
  23.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  24.       long startTimestamp = System.currentTimeMillis();
  25.       Object result = method.invoke(proxiedObject, args);
  26.       long endTimeStamp = System.currentTimeMillis();
  27.       long responseTime = endTimeStamp - startTimestamp;
  28.       String apiName = proxiedObject.getClass().getName() + ":" + method.getName();
  29.       RequestInfo requestInfo = new RequestInfo(apiName, responseTime, startTimestamp);
  30.       metricsCollector.recordRequest(requestInfo);
  31.       return result;
  32.     }
  33.   }
  34. }
  36. //MetricsCollectorProxy使用举例
  37. MetricsCollectorProxy proxy = new MetricsCollectorProxy();
  38. IUserController userController = (IUserController) proxy.createProxy(new UserController());

其余参考javaGuide吧, 感觉这个模式除了spring AOP以外, 在实际场景中的应用有限

桥接模式

  • 将抽象和实现解耦，让它们可以独立变化.
  • 一个类存在两个（或多个）独立变化的维度，我们通过组合的方式，让这两个（或多个）维度可以独立进行扩展。

应用示例

  2. public enum NotificationEmergencyLevel {
  3.   SEVERE, URGENCY, NORMAL, TRIVIAL
  4. }
  6. public class Notification {
  7.   private List<String> emailAddresses;
  8.   private List<String> telephones;
  9.   private List<String> wechatIds;
  11.   public Notification() {}
  13.   public void setEmailAddress(List<String> emailAddress) {
  14.     this.emailAddresses = emailAddress;
  15.   }
  17.   public void setTelephones(List<String> telephones) {
  18.     this.telephones = telephones;
  19.   }
  21.   public void setWechatIds(List<String> wechatIds) {
  22.     this.wechatIds = wechatIds;
  23.   }
  25.   public void notify(NotificationEmergencyLevel level, String message) {
  26.     if (level.equals(NotificationEmergencyLevel.SEVERE)) {
  27.       //...自动语音电话
  28.     } else if (level.equals(NotificationEmergencyLevel.URGENCY)) {
  29.       //...发微信
  30.     } else if (level.equals(NotificationEmergencyLevel.NORMAL)) {
  31.       //...发邮件
  32.     } else if (level.equals(NotificationEmergencyLevel.TRIVIAL)) {
  33.       //...发邮件
  34.     }
  35.   }
  36. }
  38. //在API监控告警的例子中，我们如下方式来使用Notification类：
  39. public class ErrorAlertHandler extends AlertHandler {
  40.   public ErrorAlertHandler(AlertRule rule, Notification notification){
  41.     super(rule, notification);
  42.   }
  45.   @Override
  46.   public void check(ApiStatInfo apiStatInfo) {
  47.     if (apiStatInfo.getErrorCount() > rule.getMatchedRule(apiStatInfo.getApi()).getMaxErrorCount()) {
  48.       notification.notify(NotificationEmergencyLevel.SEVERE, "...");
  49.     }
  50.   }
  51. }

使用桥接模式优化后:

  2. public interface MsgSender {
  3.   void send(String message);
  4. }
  6. public class TelephoneMsgSender implements MsgSender {
  7.   private List<String> telephones;
  9.   public TelephoneMsgSender(List<String> telephones) {
  10.     this.telephones = telephones;
  11.   }
  13.   @Override
  14.   public void send(String message) {
  15.     //...
  16.   }
  18. }
  20. public class EmailMsgSender implements MsgSender {
  21.   // 与TelephoneMsgSender代码结构类似，所以省略...
  22. }
  24. public class WechatMsgSender implements MsgSender {
  25.   // 与TelephoneMsgSender代码结构类似，所以省略...
  26. }
  28. public abstract class Notification {
  29.   protected MsgSender msgSender;
  31.   public Notification(MsgSender msgSender) {
  32.     this.msgSender = msgSender;
  33.   }
  35.   public abstract void notify(String message);
  36. }
  38. public class SevereNotification extends Notification {
  39.   public SevereNotification(MsgSender msgSender) {
  40.     super(msgSender);
  41.   }
  43.   @Override
  44.   public void notify(String message) {
  45.     msgSender.send(message);
  46.   }
  47. }
  49. public class UrgencyNotification extends Notification {
  50.   // 与SevereNotification代码结构类似，所以省略...
  51. }
  52. public class NormalNotification extends Notification {
  53.   // 与SevereNotification代码结构类似，所以省略...
  54. }
  55. public class TrivialNotification extends Notification {
  56.   // 与SevereNotification代码结构类似，所以省略...
  57. }

装饰器模式

这部分代码示例参考java的IO
装饰器模式主要解决继承关系过于复杂的问题，通过组合来替代继承。它主要的作用是给原始类添加增强功能。

装饰器模式还有一个特点，那就是可以对原始类嵌套使用多个装饰器。为了满足这个应用场景，在设计的时候，装饰器类需要跟原始类继承相同的抽象类或者接口。

  1. InputStream in = new FileInputStream("/user/wangzheng/test.txt");
  2. InputStream bin = new BufferedInputStream(in);
  3. DataInputStream din = new DataInputStream(bin);
  4. int data = din.readInt();

装饰器模式与代理模式的区别

你是一个优秀的歌手，只会唱歌这一件事，不擅长找演唱机会，谈价钱，搭台，这些事情你可以找一个经纪人帮你搞定，经纪人帮你做好这些事情你就可以安稳的唱歌了，让经纪人做你不关心的事情这叫代理模式。

你老爱记错歌词，歌迷和媒体经常吐槽你没有认真对待演唱会，于是你想了一个办法，买个高端耳机，边唱边提醒你歌词，让你摆脱了忘歌词的诟病，高端耳机让你唱歌能力增强，提高了基础能力这叫装饰者模式。

Decorator关注为对象动态的添加功能, Proxy关注对象的信息隐藏及访问控制. Decorator体现多态性, Proxy体现封装性.

代理模式中，代理类附加的是跟原始类无关的功能，而在装饰器模式中，装饰器类附加的是跟原始类相关的增强功能。

适配器模式

将不兼容的接口转换为可兼容的接口，让原本由于接口不兼容而不能一起工作的类可以一起工作.

分为类适配器和对象适配器, 比如A类方法和B接口方法不适配;

  • 创建类适配器Adapter extends A implements B, 再重写B中方法
  • 创建对象适配器Adapter implements B , 组合A对象, 使用A对象方法来实现B中方法 ```java

// 类适配器: 基于继承 public interface ITarget { void f1(); void f2(); void fc(); }

public class Adaptee { public void fa() { //… } public void fb() { //… } public void fc() { //… } }

public class Adaptor extends Adaptee implements ITarget { public void f1() { super.fa(); }

public void f2() { //…重新实现f2()… }

// 这里fc()不需要实现，直接继承自Adaptee，这是跟对象适配器最大的不同点 }

// 对象适配器：基于组合 public interface ITarget { void f1(); void f2(); void fc(); }

public class Adaptee { public void fa() { //… } public void fb() { //… } public void fc() { //… } }

public class Adaptor implements ITarget { private Adaptee adaptee;

public Adaptor(Adaptee adaptee) { this.adaptee = adaptee; }

public void f1() { adaptee.fa(); //委托给Adaptee }

public void f2() { //…重新实现f2()… }

public void fc() { adaptee.fc(); } }

  2. 应用场景:
  4. 1. 封装有缺陷的接口设计
  5. 1. 统一多个类的接口设计
  6. 1. 替换依赖的外部系统
  7. 1. 兼容老版本接口
  8. 1. 适配不同格式的数据
  10. 适配器模式在 Java 日志中的应用<br />Slf4j 的出现晚于 JUL、JCL、log4j 等日志框架, 所以，它不仅仅提供了统一的接口定义，还提供了针对不同日志框架的适配器。对不同日志框架的接口进行二次封装，适配成统一的 Slf4j 接口定义。
  11. ```java
  13. // slf4j统一的接口定义
  14. package org.slf4j;
  15. public interface Logger {
  16.   public boolean isTraceEnabled();
  17.   public void trace(String msg);
  18.   public void trace(String format, Object arg);
  19.   public void trace(String format, Object arg1, Object arg2);
  20.   public void trace(String format, Object[] argArray);
  21.   public void trace(String msg, Throwable t);
  23.   public boolean isDebugEnabled();
  24.   public void debug(String msg);
  25.   public void debug(String format, Object arg);
  26.   public void debug(String format, Object arg1, Object arg2)
  27.   public void debug(String format, Object[] argArray)
  28.   public void debug(String msg, Throwable t);
  30.   //...省略info、warn、error等一堆接口
  31. }
  33. // log4j日志框架的适配器
  34. // Log4jLoggerAdapter实现了LocationAwareLogger接口，
  35. // 其中LocationAwareLogger继承自Logger接口，
  36. // 也就相当于Log4jLoggerAdapter实现了Logger接口。
  37. package org.slf4j.impl;
  38. public final class Log4jLoggerAdapter extends MarkerIgnoringBase
  39.   implements LocationAwareLogger, Serializable {
  40.   final transient org.apache.log4j.Logger logger; // log4j
  42.   public boolean isDebugEnabled() {
  43.     return logger.isDebugEnabled();
  44.   }
  46.   public void debug(String msg) {
  47.     logger.log(FQCN, Level.DEBUG, msg, null);
  48.   }
  50.   public void debug(String format, Object arg) {
  51.     if (logger.isDebugEnabled()) {
  52.       FormattingTuple ft = MessageFormatter.format(format, arg);
  53.       logger.log(FQCN, Level.DEBUG, ft.getMessage(), ft.getThrowable());
  54.     }
  55.   }
  57.   public void debug(String format, Object arg1, Object arg2) {
  58.     if (logger.isDebugEnabled()) {
  59.       FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
  60.       logger.log(FQCN, Level.DEBUG, ft.getMessage(), ft.getThrowable());
  61.     }
  62.   }
  64.   public void debug(String format, Object[] argArray) {
  65.     if (logger.isDebugEnabled()) {
  66.       FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
  67.       logger.log(FQCN, Level.DEBUG, ft.getMessage(), ft.getThrowable());
  68.     }
  69.   }
  71.   public void debug(String msg, Throwable t) {
  72.     logger.log(FQCN, Level.DEBUG, msg, t);
  73.   }
  74.   //...省略一堆接口的实现...
  75. }

门面模式

门面模式为子系统提供一组统一的接口，定义一组高层接口让子系统更易用。

应用场景

  1. 解决易用性问题

门面模式可以用来封装系统的底层实现，隐藏系统的复杂性，提供一组更加简单易用、更高层的接口

  1. 解决性能问题

通过将多个接口调用替换为一个门面接口调用，减少网络通信成本，提高 App 客户端的响应速度。

  1. 解决分布式事务问题

组合模式

将一组对象组织（Compose）成树形结构，以表示一种“部分 - 整体”的层次结构。组合让客户端（在很多设计模式书籍中，“客户端”代指代码的使用者。）可以统一单个对象和组合对象的处理逻辑。

组合模式的设计思路，与其说是一种设计模式，倒不如说是对业务场景的一种数据结构和算法的抽象。其中，数据可以表示成树这种数据结构，业务需求可以通过在树上的递归遍历算法来实现。

其实就是这种数据结构, 可以通过递归遍历还实现一些统计等操作

  1. class TreeNode{
  2.     private List<TreeNode> subNodes;
  3. }

享元模式

所谓“享元”，顾名思义就是被共享的单元。享元模式的意图是复用对象，节省内存，前提是享元对象是不可变对象。

具体来讲，当一个系统中存在大量重复对象的时候，如果这些重复的对象是不可变对象，我们就可以利用享元模式将对象设计成享元，在内存中只保留一份实例，供多处代码引用。这样可以减少内存中对象的数量，起到节省内存的目的。实际上，不仅仅相同对象可以设计成享元，对于相似对象，我们也可以将这些对象中相同的部分（字段）提取出来，设计成享元，让这些大量相似对象引用这些享元。

比如棋盘中的棋子的文字内容以及格式都是一样的, 因此可以利用享元模式做成共享的不可变对象. 一般会利用工厂方法存储这些共享对象.

享元模式 VS 单例、缓存、对象池
应用单例模式是为了保证对象全局唯一。应用享元模式是为了实现对象复用，节省内存。且享元是共享使用. 缓存是为了提高访问效率，而非复用。池化技术中的“复用”理解为“重复使用”，主要是为了节省时间。

  • 享元模式在包装类中的使用

Byte, Short, Integer, Long的缓存池

拿Integer的代码举例
i1==i2为true, 因为当我们通过自动装箱，也就是调用 valueOf() 来创建 Integer 对象的时候，如果要创建的 Integer 对象的值在 -128 到 127 之间，会从 IntegerCache 类中直接返回

  1. Integer i1 = 56;
  2. Integer i2 = 56;
  3. Integer i3 = 129;
  4. Integer i4 = 129;
  5. System.out.println(i1 == i2);
  6. System.out.println(i3 == i4);
  1. public static Integer valueOf(int i) {
  2.     if (i >= IntegerCache.low && i <= IntegerCache.high)
  3.         return IntegerCache.cache[i + (-IntegerCache.low)];
  4.     return new Integer(i);
  5. }
  • 享元模式在String中的应用

字符串常量池, 这里就不多说了