目录
2、责任链模式（Chain of Responsibility）
7、观察者模式/发布订阅模式（Observer/Listener）
设计模式原则
- 开闭原则：对扩展开放、对修改关闭。
- 单一职责原则：一个类只做一件事。
- 依赖倒转原则：类似于ioc，采用接口编程。
- 迪米特原则：高内聚，低耦合。
- 接口隔离原则：应该使用多个接口，而不是用单一的总接口。
- 合成复用原则：尽量使用对象组合，而不是继承来达到复用目的。
- 里氏替换原则：子类可以扩展父类的功能，但不能改变原有的功能。
设计模式分类
一：创建型模式
- 提供创建对象的机制， 增加已有代码的灵活性和可复用性
1、单例模式（Singleton）
定义
- 指一个类只有一个实例，且该类能自行创建这个实例的一种模式。
- 单例类只有一个实例对象。
- 该单例对象必须由单例类自行创建。
- 单例类对外提供一个访问该单例的全局访问点。
结构
- 单例类：包含一个实例且能自行创建这个实例的类。
- 访问类：使用单例的类。
实现
- 懒汉式
public class LazySingleton {
// 保证 instance 在所有线程中同步
private static volatile LazySingleton instance = null;
// private 避免类在外部被实例化
private LazySingleton() {
}
public static synchronized LazySingleton getInstance() {
// getInstance 方法前加同步
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}- 饿汉式
public class HungrySingleton {
private static final HungrySingleton instance = new HungrySingleton();
private HungrySingleton() {
}
public static HungrySingleton getInstance() {
return instance;
}
}用例
- spring的bean单例模式
2、工厂模式（Factory）
定义：
- 把对象的创建功能交给工厂，达到解耦目的。
结构：
适用场景：
- 无法预知对象确切类别及依赖关系时，可使用。
- 希望复用现有对象来节省系统资源，而不是每次都创建对象。
实现：
用例：
3、抽象工厂模式（Abstract Factory）
定义
- 用于创建一系列相关的对象， 而无需指定其具体类。
结构：
适用场景：
- 如果代码需要与多个不同系列的相关产品交互，由于无法提前获取相关信息或未来扩展考虑，不希望代码基于产品的具体类来进行构建的情况下使用。
- 当有一个基于一组抽象方法的类，且其主要功能不明确时，可以使用。
实现：
用例：
- spring的BeanFactory。
- 任何用于创建对象但返回接口或抽象类的就是此模式。
搭配模式：
- 策略模式
4、生成器模式（Builder）
定义
- 定义一个类来简化复杂对象的创建（分步骤创建）。该类是为了构建另一个类的实例。
结构：
适用场景：
- 避免“重叠构造函数”的出现。
- 当希望用代码创建不同形式的产品时使用。
- 比如订单系统，订单对象就是一个复杂对象，我们可以build来做。
实现：
用例：
- SpringApplicationBuilder
- StringBuilder
5、原型模式（prototype）
定义
- 使你能够复制已有对象， 而又无需使代码依赖它们所属的类
结构
适用场景
- 创建一个对象的实例非常复杂且耗时时可以使用。
- 例如我们的DTO、BO、DO、VO转换时可以使用。
实现
用例
- spring的bean原型模式prototype（scope=prototype）
二：结构型模式
- 介绍如何将对象和类组装成较大的结构， 并同时保持结构的灵活和高效
1、代理模式（Proxy）
定义
- 由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。
结构
- 抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
- 真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
- 代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。
适用场景：
- 用于保护原对象。
- 用于增强原对象。
实现
package proxy;
public class ProxyTest {
public static void main(String[] args) {
Proxy proxy = new Proxy();
proxy.Request();
}
}
// 抽象主题
interface Subject {
void Request();
}
// 真实主题
class RealSubject implements Subject {
public void Request() {
System.out.println("访问真实主题方法...");
}
}
// 代理
class Proxy implements Subject {
private RealSubject realSubject;
public void Request() {
if (realSubject == null) {
realSubject = new RealSubject();
}
preRequest();
realSubject.Request();
postRequest();
}
public void preRequest() {
System.out.println("访问真实主题之前的预处理。");
}
public void postRequest() {
System.out.println("访问真实主题之后的后续处理。");
}
}用例：
- jdk的Proxy类
2、装饰器模式（Decorator/Wapper）
定义
- 指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。
结构
- 抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。
- 具体构件（ConcreteComponent）角色：实现抽象构件，通过装饰角色为其添加一些职责。
- 抽象装饰（Decorator）角色：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
- 具体装饰（ConcreteDecorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。
实现
package decorator;
public class DecoratorPattern {
public static void main(String[] args) {
Component p = new ConcreteComponent();
p.operation();
System.out.println("---------------------------------");
Component d = new ConcreteDecorator(p);
d.operation();
}
}
// 抽象构件角色
interface Component {
public void operation();
}
// 具体构件角色
class ConcreteComponent implements Component {
public ConcreteComponent() {
System.out.println("创建具体构件角色");
}
public void operation() {
System.out.println("调用具体构件角色的方法operation()");
}
}
// 抽象装饰角色
class Decorator implements Component {
private Component component;
public Decorator(Component component) {
this.component = component;
}
public void operation() {
component.operation();
}
}
// 具体装饰角色
class ConcreteDecorator extends Decorator {
public ConcreteDecorator(Component component) {
super(component);
}
public void operation() {
super.operation();
addedFunction();
}
public void addedFunction() {
System.out.println("为具体构件角色增加额外的功能addedFunction()");
}
}3、适配器模式（Adapter）
定义：
结构：
适用场景：
实现：
用例：
- springmvc的HandlerAdapter
- 例如xml转json，可以新增XmlJsonAdapter适配器类内进行转换
4、桥接模式（Bride）
定义：
结构：
适用场景：
实现：
用例：
5、组合模式（Composite）
定义：
结构：
适用场景：
实现：
用例：
6、外观/门面模式（Facade）
定义：
结构：
适用场景：
实现：
用例：
7、享元模式(Flyweight)
定义：
结构：
适用场景：
实现：
用例：
搭配模式：
三：行为模式
- 负责对象间的高效沟通和职责委派
1、策略模式（Strategy）
定义
- 该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。
结构
- 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
- 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。
- 环境（Context）类：持有一个策略类的引用，最终给客户端调用。
实现
public class StrategyPattern {
public static void main(String[] args) {
Context c = new Context();
Strategy s = new ConcreteStrategyA();
c.setStrategy(s);
c.strategyMethod();
System.out.println("-----------------");
s = new ConcreteStrategyB();
c.setStrategy(s);
c.strategyMethod();
}
}
// 抽象策略类
interface Strategy {
public void strategyMethod(); //策略方法
}
// 具体策略类A
class ConcreteStrategyA implements Strategy {
public void strategyMethod() {
System.out.println("具体策略A的策略方法被访问！");
}
}
// 具体策略类B
class ConcreteStrategyB implements Strategy {
public void strategyMethod() {
System.out.println("具体策略B的策略方法被访问！");
}
}
// 环境类
class Context {
private Strategy strategy;
public Strategy getStrategy() {
return strategy;
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void strategyMethod() {
strategy.strategyMethod();
}
}
4961
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
