JDK源码中，都有哪些常见的设计模式?

Posted 2021-04-21 小张的学习笔记

1、结构性模式：

1.1、适配器模式

常用于把一个接口转化成另一个接口

 
   
   
 

  
    
    
  
 java.util.Arrays#asList()
  
    
    
  
 javax.swing.JTable(TableModel)
  
    
    
  
 java.io.InputStreamReader(InputStream)
  
    
    
  
 java.io.OutputStreamWriter(OutputStream)
  
    
    
  
 javax.xml.bind.annotation.adapters.XmlAdapter#marshal()
  
    
    
  
 javax.xml.bind.annotation.adapters.XmlAdapter#unmarshal()
 
   
   
 

在我们业务代码中经常有新旧接口适配需求，可以采用该模式。

1.2、桥接模式

这个模式将抽象和抽象操作的实现进行了解耦，这样使得抽象和实现可以独立地变化。

 
   
   
 

  
    
    
  
 AWT (It provides an abstraction layer which maps onto the native OS the windowing support.)
  
    
    
  
 JDBC
 
   
   
 

这个模式，其实我们每天都在用到，但是你可能却浑然不知。只要你用到面向接口编程，其实都是在用桥接模式。

1.3、组合模式

让客户端看起来在处理单个对象和对象的组合是平等的，换句话说，某个类型的方法同时也接受自身类型作为参数

 
   
   
 

  
    
    
  
 javax.swing.JComponent#add(Component)
  
    
    
  
 java.awt.Container#add(Component)
  
    
    
  
 java.util.Map#putAll(Map)
  
    
    
  
 java.util.List#addAll(Collection)
  
    
    
  
 java.util.Set#addAll(Collection)
 
   
   
 

组合模式常用于递归操作的优化上，比如每个公司都有个boss系统，都会有什么菜单的功能。比如一级菜单下有二级菜单，二级菜单又有三级菜单。删除一级菜单的时候需要不断删除子菜单，那么这个设计模式你可以试试。总之，凡是有级联操作的，你都可以尝试这个设计模式。

1.4、装饰者模式

动态给一个对象附加额外的功能，这也是子类的一种替代方法。可以看到，在创建一个类型的时候，同时也传入同一类型的对象，这在JDK里随处可见。

 
   
   
 

  
    
    
  
 java.io.BufferedInputStream(InputStream)
  
    
    
  
 java.io.DataInputStream(InputStream)
  
    
    
  
 java.io.BufferedOutputStream(OutputStream)
  
    
    
  
 java.util.zip.ZipOutputStream(OutputStream)
  
    
    
  
 java.util.Collections#checkedList|Map|Set|SortedSet|SortedMap
 
   
   
 

这个模式使用很广泛，我们常用的AOP,既有动态代理，也有装饰着的味道

1.5、门面模式

为一组组件，接口，抽象或者子系统提供简化的接口

 
   
   
 

  
    
    
  
 java.lang.Class
  
    
    
  
 javax.faces.webapp.FacesServlet
 
   
   
 

我们使用的SLFJ日志就是门面日志，比如Dubbo,向外提供的服务就尽量采用门面模式，然后服务在调用各种service做聚合。

1.6、享元模式

使用缓存来减少对小对象的访问时间

 
   
   
 

  
    
    
  
 java.lang.Integer#valueOf(int)
  
    
    
  
 java.lang.Boolean#valueOf(boolean)
  
    
    
  
 java.lang.Byte#valueOf(byte)
  
    
    
  
 java.lang.Character#valueOf(char)
 
   
   
 

只要用到了缓存，基本都是在使用享元模式。使用map缓存几个对象，基本上都运用了享元模式的思想

1.7、代理模式

代理模式用于比较简单的对象代替创建负载或者耗时的对象

 
   
   
 

  
    
    
  
 java.lang.reflect.Proxy
  
    
    
  
 RMI
 
   
   
 

代理模式用的很广泛，基本上 开源框架都在使用

2、创建模式：

2.1、抽象工厂模式

抽象工厂模式提供了一个协议来生成一系列的相关或者独立的对象，而不是指定具体对象的类型。它使得应用程序能够和使用框架的具体实现进行解耦。在JDK和许多开源框架，比如Spring中随处可见。任何用于创建对象但返回接口或者抽象类的，就是抽象工厂模式了。

 
   
   
 

  
    
    
  
 java.util.Calendar#getInstance()
  
    
    
  
 java.util.Arrays#asList()
  
    
    
  
 java.util.ResourceBundle#getBundle()
  
    
    
  
 java.sql.DriverManager#getConnection()
  
    
    
  
 java.sql.Connection#createStatement()
  
    
    
  
 java.sql.Statement#executeQuery()
  
    
    
  
 java.text.NumberFormat#getInstance()
  
    
    
  
 javax.xml.transform.TransformerFactory#newInstance()
 
   
   
 

该模式可以与策略模式结合使用

2.2、建造者模式

用于通过定义一个类来简化复杂对象的创建，该类的目的是构建另一个类的实例。构建器模式还允许实现Fluent接口。

 
   
   
 

  
    
    
  
 java.lang.StringBuilder#append()
  
    
    
  
 java.lang.StringBuffer#append()
  
    
    
  
 java.sql.PreparedStatement
  
    
    
  
 javax.swing.GroupLayout.Group#addComponent()
 
   
   
 

这个在我们业务代码中使用的场景太广泛了，例如订单系统大部分项目都有，订单对象就是一个复杂对象，我们可以采用建造者模式

2.3、工厂方法

就是一个返回具体对象的方法。

 
   
   
 

  
    
    
  
 java.lang.Proxy#newProxyInstance()
  
    
    
  
 java.lang.Object#toString()
  
    
    
  
 java.lang.Class#newInstance()
  
    
    
  
 java.lang.reflect.Array#newInstance()
  
    
    
  
 java .lang.reflect.Constructor#newInstance()
  
    
    
  
 java.lang.Boolean#valueOf(String)
  
    
    
  
 java.lang.Class#forName()
 
   
   
 

2.4、原型模式

使类的实例能够生成自身的拷贝。如果创建一个对象的实例非常复杂且耗时时，就可以使用这种模式，而不用重新创建一个新的实例，你可以拷贝一个对象并直接修改它

 
   
   
 

  
    
    
  
 java.lang.Object#clone()
  
    
    
  
 java.lang.Cloneable
 
   
   
 

例如我们的业务代码，经常要各种DTD、BO、VO转化，其实就可以参考原型设计模式

2.5、单例模式

用来确保类只有一个实例。另一个方法就是使用枚举。

 
   
   
 

  
    
    
  
 java.lang.Runtime#getRuntime()
  
    
    
  
 java.awt.Toolkit#getDefaultToolkit()
  
    
    
  
 java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment()
  
    
    
  
 java.awt.Desktop#getDesktop()
 
   
   
 

Spring的bean默认的就是单利级别。

3、行为模式

3.1、责任链

通过把请求从一个对象传递到链条中下一个对象的方式来解除对象之间的耦合，直到请求被处理完毕。链中的对象是同一接口或者抽象类的不同实现。

 
   
   
 

  
    
    
  
 java.util.logging.Logger#log()
  
    
    
  
 javax.servlet.Filter#doFilter()
 
   
   
 

凡是带有Filter关键词的，基本都在用这个设计模式。在业务代码使用的场景实在是太多了，用到拦截器的地方基本都在用这个设计模式。

3.2、命令模式

将命令包装在对象中、以便可以将其存储，传递到方法中，并像任何其他对象

 
   
   
 

  
    
    
  
 java.lang.Runnable
  
    
    
  
 javax.swing.Action
 
   
   
 

命令模式使用的频率比较高，和策略模式比较像

3.3、解释器模式

此模式通常描述为该语言定义语法并使用该语法来解释改格式的语句

 
   
   
 

  
    
    
  
 java.util.Pattern
  
    
    
  
 java.text.Normalizer
  
    
    
  
 java.text.Format
 
   
   
 

3.4、迭代器模式

提供一个一致的方法来顺序访问集合中的对象，这个方法与底层的集合的具体实现无关。

 
   
   
 

  
    
    
  
 java.util.Iterator
  
    
    
  
 java.util.Enumeration
 
   
   
 

3.5、中介者模式

通过使用一个中间对象来进行消息分发，以及减少类之间的直接依赖。

 
   
   
 

  
    
    
  
 java.util.Timer
  
    
    
  
 java.util.concurrent.Executor#execute()
  
    
    
  
 java.util.concurrent.ExecutorService#submit()
  
    
    
  
 java.lang.reflect.Method#invoke()
 
   
   
 

此模式使用的场景很多，例如MQ，其实就是用中介者模式

3.6、备忘录模式

生成对象的一个快照，以便可以恢复原始状态而不用暴露自身的内容。比如Date对象通过自身内部的一个long值来实现备忘录模式。

 
   
   
 

  
    
    
  
 java.util.Date
  
    
    
  
 java.io.Serializable
 
   
   
 

3.7、空对象模式

这个模式通过一个无意义的对象来代替没有对象这个状态。它使得你不用额外对空对象进行处理

 
   
   
 

  
    
    
  
 java.util.Collections#emptyList()
  
    
    
  
 java.util.Collections#emptyMap()
  
    
    
  
 java.util.Collections#emptySet()
 
   
   
 

这个业务代码用得不多，但是JDK中的这几个方法我们倒是挺常用的。

3.8、观察者模式

用于为组件提供一种灵活的感兴趣的接受者广播消息的方法

 
   
   
 

  
    
    
  
 java.util.EventListener
  
    
    
  
 javax.servlet.http.HttpSessionBindingListener
  
    
    
  
 javax.servlet.http.HttpSessionAttributeListener
  
    
    
  
 javax.faces.event.PhaseListener
 
   
   
 

业务代码一般是基于Zookeeper来做观察者的。基本上用到ZK的地方都是用观察者模式，比如分布式锁，比如服务发现等

3.9、状态模式

通过改变对象内部的状态，使得你可以在运行时动态改变一个对象的行为。

 
   
   
 

  
    
    
  
 java.util.Iterator
  
    
    
  
 javax.faces.lifecycle.LifeCycle#execute()
 
   
   
 

比如常见的订单状态或者各种xx状态。都可以用得上

3.10、策略模式

使用这个模式将一组算法封装成一系列对象。通过调用这些对象可以灵活的改变程序的功能

 
   
   
 

  
    
    
  
 java.util.Comparator#compare()
  
    
    
  
 javax.servlet.http.HttpServlet
  
    
    
  
 javax.servlet.Filter#doFilter()
 
   
   
 

此模式常用于优化大量if-else

3.11、模板方法模式

让子类可以重写方法的一部分，而不是整个重写，你可以控制子类需要重写那些操作。

 
   
   
 

  
    
    
  
 java.util.Collections#sort()
  
    
    
  
 java.io.InputStream#skip()
  
    
    
  
 java.io.InputStream#read()
  
    
    
  
 java.util.AbstractList#indexOf()
 
   
   
 

这个模式也是非常高频的模式，业务代码中经常遇到很多相同的部分，我们可以做成一个抽象类，子类来实现差异化

3.12、访问者模式

提供一个方便的可维护的方法来操作一组对象。它使得你在不改变操作的对象前提下，可以修改或者扩展对象的行为。

 
   
   
 

  
    
    
  
 javax.lang.model.element.Element
  
    
    
  
 javax.lang.model.element.ElementVisitor
  
    
    
  
 javax.lang.model.type.TypeMirror
  
    
    
  
 javax.lang.model.type.TypeVisitor