Spring中常用的23中设计模式

比眉伴天荒 2021-11-01 08:54 578阅读 0赞

1.spring 中常用的设计模式有23中

<table> 
 <tbody> 
  <tr> 
   <td style="text-align:left;">&nbsp;分类</td> 
   <td>&nbsp;设计模式</td> 
  </tr> 
  <tr> 
   <td>&nbsp;创建型</td> 
   <td> <pre>工厂方法模式（FactoryMethod）、抽象工厂模式（AbstractFactory）、<br>建造者模式（Builder）、原型模式（Prototype）、单例模式(Singleton)</pre> </td> 
  </tr> 
  <tr> 
   <td>&nbsp;结构型</td> 
   <td> <p>&nbsp;适配器模式(Adapter)、桥接模式（Bridge）、组合模式（Composite）、</p> <p>装饰器模式（Decorator）、门面模式（Facade）、享元模式（Flyweight）、代理模式（Proxy）</p> </td> 
  </tr> 
  <tr> 
   <td>&nbsp;行为型</td> 
   <td> <pre>解释器模式（Interpreter）、模板方法模式（TemplateMethod）、<br>责任链模式（ChainofResponsibility）、命令模式（Command）、<br>迭代器模式（Iterator）、调解者模式（Mediator）、备忘录模式（Memento）、<br>观察者模式（Observer）、状态模式（State）、策略模式（Strategy）、访问者模式（Visitor）</pre> </td> 
  </tr> 
 </tbody> 
</table>

通常来说，设计模式都是混合使用，不会独立应用。利用穷举法充分理解设计模式的应用场景。在平时的应用中，不是用设计模式去生搬硬套，而是根据具体业务问题需要时借鉴。
    2、设计模式在应用中遵循六大原则：
          a、开闭原则（OpenClosePrinciple）
         　　 开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现
         　　 一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的
         　　 效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
          b、里氏代换原则（LiskovSubstitutionPrinciple）
         　　 里氏代换原则(LiskovSubstitutionPrincipleLSP)
         　　 面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
          c、依赖倒转原则（DependenceInversionPrinciple）
         　　 这个是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。
          d、接口隔离原则（InterfaceSegregationPrinciple）
        　　  这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
          e、迪米特法则（最少知道原则）（DemeterPrinciple）
         　　 为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
          f、合成复用原则（CompositeReusePrinciple）
         　　 原则是尽量使用合成/聚合的方式，而不是使用继承。
    设计模式之间的关系图

![1429143-20190620150940638-815431803.png][]

1.1、简单工厂模式（Factory）

应用场景：又叫做静态工厂方法（StaticFactoryMethod）模式，但不属于23种设计模式之一。简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。

Spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得Bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。

<table style="width:550px;"> 
 <tbody> 
  <tr> 
   <td>归类</td> 
   <td>特点</td> 
   <td>穷举</td> 
  </tr> 
  <tr> 
   <td> <p>创建型模式</p> </td> 
   <td>是复杂工厂模式的思维模型</td> 
   <td>批量生产、标准化</td> 
  </tr> 
 </tbody> 
</table>

1.2、工厂方法模式（FactoryMethod）

应用场景：通常由应用程序直接使用new创建新的对象，为了将对象的创建和使用相分离，采用工厂模式,即应用程序将对象的创建及初始化职责交给工厂对象。

一般情况下,应用程序有自己的工厂对象来创建Bean.如果将应用程序自己的工厂对象交给Spring管理,那么Spring

管理的就不是普通的Bean,而是工厂Bean。

<table style="width:547px;"> 
 <tbody> 
  <tr> 
   <td>归类</td> 
   <td>特点</td> 
   <td>穷举</td> 
  </tr> 
  <tr> 
   <td> <p>创建型模式</p> </td> 
   <td>&nbsp;对于调用者来说，隐藏了复杂的逻辑处理过程，调用者只关心执行结果。 <p>对于工厂来说要对结果负责，保证生产出符合规范的产品。</p> </td> 
   <td>&nbsp;流水线生产</td> 
  </tr> 
 </tbody> 
</table>

1.3、单例模式（Singleton）

应用场景：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

Spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是因为Spring管理的是是任意的Java对象。Spring下默认的Bean均为单例。

<table style="width:628px;"> 
 <tbody> 
  <tr> 
   <td style="text-align:left;">归类</td> 
   <td>特点</td> 
   <td>穷举</td> 
  </tr> 
  <tr> 
   <td>创建型模式</td> 
   <td style="text-align:left;"> <p>保证从系统启动到系统终止，全过程只会产生一个实例。</p> <p>当我们在应用中遇到功能性冲突的时候，需要使用单例模式。</p> </td> 
   <td>配置文件、日历、<span>OC容器</span></td> 
  </tr> 
 </tbody> 
</table>

常用单例模式写法：饿汉式、懒汉式、注册式、序列化。

1.4、原型模式（Prototype）

应用场景：原型模式就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节。

所谓原型模式，就是Java中的克隆技术，以某个对象为原型。复制出新的对象。显然新的对象具备原型对象的特点，效率高（避免了重新执行构造过程步骤）。

<table> 
 <tbody> 
  <tr> 
   <td>归类</td> 
   <td>特点</td> 
   <td>穷举</td> 
  </tr> 
  <tr> 
   <td>创建型模式</td> 
   <td> <p><span>首先有一个原型。</span></p> <p>数据内容相同，但对象实例不同（完全两个个体）。</p> </td> 
   <td>孙悟空吹毫毛</td> 
  </tr> 
 </tbody> 
</table>

1.5、代理模式（Proxy）

应用场景：为其他对象提供一种代理以控制对这个对象的访问。从结构上来看和Decorator模式类似，但Proxy是控制，更像是一种对功能的限制，而Decorator是增加职责。

Spring的Proxy模式在AOP中有体现，比如JdkDynamicAopProxy和Cglib2AopProxy。

<table> 
 <tbody> 
  <tr> 
   <td>归类</td> 
   <td>特点</td> 
   <td>穷举</td> 
  </tr> 
  <tr> 
   <td>结构型模式</td> 
   <td> <p><span>执行者、被代理人</span>对于被代理人来说，这件事情是一定要做的，</p> <p>但是我自己又不想做或者没有时间做。对于代理人而言，</p> <p>需要获取到被代理的人个人资料，只是参与整个过程的某个或几个环节。</p> </td> 
   <td> <p>租房中介、售票黄牛、婚介、经纪人、</p> <p>快递、事务代理、非侵入式日志监听</p> </td> 
  </tr> 
 </tbody> 
</table>

1.6、策略模式（Strategy）

应用场景：定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独

立于使用它的客户而变化。

Spring中在实例化对象的时候用到Strategy模式，在SimpleInstantiationStrategy有使用。

<table> 
 <tbody> 
  <tr> 
   <td>归类</td> 
   <td>特点</td> 
   <td>穷举</td> 
  </tr> 
  <tr> 
   <td>行为型模式</td> 
   <td>最终执行结果是固定的。执行过程和执行逻辑不一样</td> 
   <td>旅游出行方式</td> 
  </tr> 
 </tbody> 
</table>

1.7、模板方法模式（TemplateMethod）

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。TemplateMethod使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

TemplateMethod模式一般是需要继承的。这里想要探讨另一种对TemplateMethod的理解。Spring中的JdbcTemplate，在用这个类时并不想去继承这个类，因为这个类的方法太多，但是我们还是想用到JdbcTemplate

已有的稳定的、公用的数据库连接，那么我们怎么办呢？我们可以把变化的东西抽出来作为一个参数传入JdbcTemplate的方法中。但是变化的东西是一段代码，而且这段代码会用到JdbcTemplate中的变量。怎么办？那我们就用回调对象吧。在这个回调对象中定义一个操纵JdbcTemplate中变量的方法，我们去实现这个方法，就把变化的东西集中到这里了。然后我们再传入这个回调对象到JdbcTemplate，从而完成了调用。这就是TemplateMethod不需要继承的另一种实现方式。

<table> 
 <tbody> 
  <tr> 
   <td>归类</td> 
   <td>特点</td> 
   <td>穷举</td> 
  </tr> 
  <tr> 
   <td>行为型模式</td> 
   <td> <p><span>执行流程固定，但中间有些步骤有细微差别（运行时才确定）。</span></p> <p>可实现批量生产。</p> </td> 
   <td>SpringORM数据模型</td> 
  </tr> 
 </tbody> 
</table>

1.8、委派模式（Delegate）

应用场景：不属于23种设计模式之一，是面向对象设计模式中常用的一种模式。这种模式的原理为类B和类A是两个互相没有任何关系的类，B具有和A一模一样的方法和属性；并且调用B中的方法，属性就是调用A中同名的方法和属性。B好像就是一个受A授权委托的中介。第三方的代码不需要知道A的存在，也不需要和A发生直接的联系，通过B就可以直接使用A的功能，这样既能够使用到A的各种功能，又能够很好的将A保护起来了，一举两得。

<table> 
 <tbody> 
  <tr> 
   <td>归类</td> 
   <td>特点</td> 
   <td>穷举</td> 
  </tr> 
  <tr> 
   <td>行为型模式</td> 
   <td> <p><span>要和代理模式区分开来。</span></p> <p>持有被委托人的引用。</p> <p>不关心过程，只关心结果。</p> </td> 
   <td>经理派发工作任务、<span>Dispatcher</span></td> 
  </tr> 
 </tbody> 
</table>

1.9、适配器模式（Adapter）

SpringAOP模块对BeforeAdvice、AfterAdvice、ThrowsAdvice三种通知类型的支持实际上是借助适配器模式来实现的，这样的好处是使得框架允许用户向框架中加入自己想要支持的任何一种通知类型，上述三种通知类型是SpringAOP模块定义的，它们是AOP联盟定义的Advice的子类型。

<table> 
 <tbody> 
  <tr> 
   <td>归类</td> 
   <td>特点</td> 
   <td>穷举</td> 
  </tr> 
  <tr> 
   <td>结构型模式</td> 
   <td> <p><span>注重兼容、转换。</span></p> <p>适配者与被适配这之间没有层级关系，也没有必然联系。</p> <p>满足<span>has-a的关系。</span></p> </td> 
   <td>编码解码、一拖三充电头、<span>HDMI转<span>VGA、<span>Type-C转<span>USB</span></span></span></span></td> 
  </tr> 
 </tbody> 
</table>

1.10、装饰器模式（Decorator）

应用场景：在我们的项目中遇到这样一个问题：我们的项目需要连接多个数据库，而且不同的客户在每

次访问中根据需要会去访问不同的数据库。我们以往在Spring和Hibernate框架中总是配置一个数据源，因而SessionFactory的DataSource属性总是指向这个数据源并且恒定不变，所有DAO在使用SessionFactory的时候都是通过这个数据源访问数据库。但是现在，由于项目的需要，我们的DAO在访问SessionFactory的时候都不得不在多个数据源中不断切换，问题就出现了：如何让SessionFactory在执行数据持久化的时候，根据客户的需求能够动态切换不同的数据源？我们能不能在Spring的框架下通过少量修改得到解决？是否有什么设计模式可以利用呢？

首先想到在Spring的ApplicationContext中配置所有的DataSource。这些DataSource可能是各种不同类型的，比如不同的数据库：Oracle、SQLServer、MySQL等，也可能是不同的数据源：比如Apache提供的org.apache.commons.dbcp.BasicDataSource、Spring提供的org.springframework.jndi.JndiObjectFactoryBean等。然后SessionFactory根据客户的每次请求，将DataSource属性设置成不同的数据源，以到达切换数据源的目的。

Spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。

<table> 
 <tbody> 
  <tr> 
   <td>归类</td> 
   <td>特点</td> 
   <td>穷举</td> 
  </tr> 
  <tr> 
   <td>结构型模式</td> 
   <td> <p><span><span>1、注重覆盖、扩展。</span></span></p> <p><span>2、装饰器和被装饰器都实现同一个接口，</span></p> <p><span>主要目的是为了扩展之后依旧保留<span>OOP关系（同宗同源）。</span></span></p> <p><span>3、满足<span>is-a的关系。</span></span></p> </td> 
   <td>IO流包装、数据源包装、简历包装</td> 
  </tr> 
 </tbody> 
</table>

1.11、观察者模式（Observer）

应用场景：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象

都得到通知并被自动更新。

Spring中Observer模式常用的地方是Listener的实现。如ApplicationListener。

<table> 
 <tbody> 
  <tr> 
   <td>归类</td> 
   <td>特点</td> 
   <td>穷举</td> 
  </tr> 
  <tr> 
   <td>行为型模式</td> 
   <td> <p><span>一般由两个角色组成：发布者和订阅者（观察者）。</span></p> <p>观察者通常有一个回调，也可以没有。</p> </td> 
   <td>监听器、日志收集、短信通知、邮件通知</td> 
  </tr> 
 </tbody> 
</table>

1.12、各设计模式对比及编程思想总结

<table> 
 <tbody> 
  <tr> 
   <td>设计模式</td> 
   <td>一句话归纳</td> 
  </tr> 
  <tr> 
   <td>工厂模式（<span>Factory）</span></td> 
   <td>只对结果负责，不要三无产品。</td> 
  </tr> 
  <tr> 
   <td>单例模式（<span>Singleton）</span></td> 
   <td>保证独一无二。</td> 
  </tr> 
  <tr> 
   <td>适配器模式（<span>Adapter）</span></td> 
   <td>需要一个转换头（兼容）。</td> 
  </tr> 
  <tr> 
   <td>装饰器模式（<span>Decorator）</span></td> 
   <td>需要包装，但不改变本质<span>(同宗同源<span>)。</span></span></td> 
  </tr> 
  <tr> 
   <td>代理模式（<span>Proxy）</span></td> 
   <td>办事要求人，所以找代理。</td> 
  </tr> 
  <tr> 
   <td>观察者模式（<span>Observer）</span></td> 
   <td>完成时通知我。</td> 
  </tr> 
  <tr> 
   <td>策略模式（<span>Strategy）</span></td> 
   <td>我行我素，达到目的就行。</td> 
  </tr> 
  <tr> 
   <td>模板模式（<span>Template）</span></td> 
   <td>流程标准化，原料自己加。</td> 
  </tr> 
  <tr> 
   <td>委派模式（<span>Delegate）</span></td> 
   <td>干活是你的（普通员工），功劳是我的（项目经理）。</td> 
  </tr> 
  <tr> 
   <td>原型模式（<span>Prototype）</span></td> 
   <td>拔一根猴毛，吹出千万个。</td> 
  </tr> 
 </tbody> 
</table>

编程思想总结

<table> 
 <tbody> 
  <tr> 
   <td>Spring思想</td> 
   <td>应用场景（特点）</td> 
   <td>一句话归纳</td> 
  </tr> 
  <tr> 
   <td>AOP</td> 
   <td> <p><span>AspectOrientedProgramming(<span>面向切面编程)</span></span></p> <p>找出多个类中有一定规律的代码，开发时拆开，运行时再合并。</p> <p>面向切面编程，即面向规则编程。</p> </td> 
   <td>解耦，专人做专事。</td> 
  </tr> 
  <tr> 
   <td>OOP</td> 
   <td> <p><span>ObjectOrientedProgramming<span>（面向对象编程）</span></span></p> <p>归纳总结生活中一切事物。</p> </td> 
   <td>封装、继承、多态。</td> 
  </tr> 
  <tr> 
   <td>BOP</td> 
   <td> <p><span>BeanOrientedProgramming<span>（面向Bean<span>编程）</span></span></span></p> <p>面向<span>Bean（普通的<span>java类）设计程序。</span></span></p> </td> 
   <td>一切从<span>Bean开始。</span></td> 
  </tr> 
  <tr> 
   <td>IOC</td> 
   <td> <p><span><span>InversionofControl（控制反转）</span></span></p> <p>将<span>new对象的动作交给<span>Spring管理，并由<span>Spring保存已创建的对象（<span>IOC容器）。</span></span></span></span></p> </td> 
   <td><span><span>转交控制权（即控制权反转）。</span></span></td> 
  </tr> 
  <tr> 
   <td>DI/DL</td> 
   <td> <p><span>DependencyInjection<span>（依赖注入）或者DependencyLookup<span>（依赖查找）</span></span></span></p> <p>依赖注入、依赖查找，<span>Spring不仅保存自己创建的对象，而且保存对象与对象之间的关系。</span></p> <p>注入即赋值，主要三种方式构造方法、<span>set方法、直接赋值。</span></p> </td> 
   <td>先理清关系再赋值。</td> 
  </tr> 
 </tbody> 
</table>

转载于:https://www.cnblogs.com/klyjb/p/11059326.html

[1429143-20190620150940638-815431803.png]: /images/20211101/44dd755146fc42149c5134328cbfc4db.png