结合电商项目谈设计模式

一、创建型（6种）

1.单例模式：创建一个仅能具有一个实例（仅能被实例化一次）的对象。

类框架：包括私有变量，私有构造方法和公共静态方法
实现方式：
（1）懒汉式-线程不安全：

    public class Singleton {private static Singleton uniqueInstance;private Singleton() {}public static Singleton getUniqueInstance() {if (uniqueInstance == null) {uniqueInstance = new Singleton();}return uniqueInstance;}}

（2）饿汉式-线程安全：直接实例化

 private static Singleton uniqueInstance = new Singleton();

（3）懒汉式-线程安全：只对公共静态方法加锁，即使对象已被实例化，获取实例时仍只能进入一个线程，存在线程堵塞，影响性能

    public class Singleton {private static Singleton uniqueInstance;private Singleton() {}public static synchronized Singleton getUniqueInstance() {if (uniqueInstance == null) {uniqueInstance = new Singleton();}return uniqueInstance;}}

（4）双重校验锁-线程安全：变量声明为volatile，对对象是否实例化进行判断，是，直接返回实例，否则进行加锁。

    public class Singleton {private volatile static Singleton uniqueInstance;//防止指令重排，创建多个实例。private Singleton() {}public static Singleton getUniqueInstance() {if (uniqueInstance == null) {synchronized (Singleton.class) {if (uniqueInstance == null) {//为了防止多个线程越过第一个null判断uniqueInstance = new Singleton();}}}return uniqueInstance;}}

应用场景：
统计网站的实时在线人数，首先创建一个在线人数列表userList,由单例模式实现，创建一个监听器在用户登录以后存入session和用户注销时候进行监听，以此来调用上述所写的list添加删除方法。
将线程池设计为单例模式，只实例化一个线程池，多个线程公用一个线程池，不会是每创一个线程就要创建一个线程池。https://blog.csdn.net/fengye454545/article/details/79536986

2.原型模式：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。

类框架：原型需要提供一个clone()方法，直接调用clone方法创建新对象。
实现方式：分为深克隆和浅克隆。
浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

    public class ConcretePrototype extends Prototype {private String filed;public ConcretePrototype(String filed) {this.filed = filed;}@OverridePrototype myClone() {return new ConcretePrototype(filed);}@Overridepublic String toString() {return filed;}}public class Client {public static void main(String[] args) {Prototype prototype = new ConcretePrototype("abc");Prototype clone = prototype.myClone();System.out.println(clone.toString());}}

适用于需要频繁创建对象的场景，利用原型模式会比直接创建对象更快，更简单。Java 自带的原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。
但是需要在原型类中加入一个clone()方法。clone 方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违背了开闭原则。当实现深克隆时，需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦。因此，深克隆、浅克隆需要运用得当。
Spring框架中bean的创建就用到了单例和原型两种模式。

3.简单工厂模式（静态工厂方法模式）：简单工厂模式有一个具体的工厂类，可以生成多个不同的产品，属于创建型设计模式。

结构包括：
（1）简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
（2）抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
（3）具体产品（ConcreteProduct）：是简单工厂模式的创建目标。
实现代码

public class Client {public static void main(String[] args) {}//抽象产品public interface Product {void show();}//具体产品：ProductAstatic class ConcreteProduct1 implements Product {public void show() {System.out.println("具体产品1显示...");}}//具体产品：ProductBstatic class ConcreteProduct2 implements Product {public void show() {System.out.println("具体产品2显示...");}}final class Const {static final int PRODUCT_A = 0;static final int PRODUCT_B = 1;static final int PRODUCT_C = 2;}static class SimpleFactory {public static Product makeProduct(int kind) {switch (kind) {case Const.PRODUCT_A:return new ConcreteProduct1();case Const.PRODUCT_B:return new ConcreteProduct2();}return null;}}
}

简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。
对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。

4.工厂方法模式：工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

结构：工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。
实现代码
优缺点：优点是对于新的产品，只需要增加一个新的工厂（流水线）和新产品类，不需要修改原有的代码。满足开闭准则。但是增加了系统的抽象性和复杂度。
适用于客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。

5.工厂方法模式：抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

结构：抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。具体而言，抽象工厂中实现了不同的产品种类，可以产生不同种类的商品，比如一边卖生产火腿肠，一边生产方便面。比如我们要增加一个老痰酸菜方便面的商品，由于我们的工厂可以生产方便面，所以只需要实现一个具体的老痰酸菜面工厂就行。但是如果我们想生产肥宅快乐水，那就费劲了，我们需要把抽象工厂都改一下，增加一条饮料的生产线，这就违反了开闭原则。而对比工厂方法，每个抽象工厂选择生产一个种类的商品，也就是只能生成饮料、方便面、火腿肠的一种，之后就可以进行一类商品比如可乐、雪碧、橙汁之类的具体产品的生产了。而简单工厂只能完成自定义的几种商品生产，一旦扩展就需要改变源代码。
适用场景：
（1）简单工厂：只生产特定商品，不扩展
（2）工厂方法：扩展统一种类的商品
（3）抽象工厂：生产多种类的商品。
比如在电商中，支付方式的选择上就可以应用工厂方法模式，支付可以选择银行付款、支付宝付款、微信付款，如果之后又有了其他的支付软件或者第三方金融机构，就可以进行扩展。

6.建造者（Builder）模式：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。

结构：由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成。
优缺点：优点就是系统解耦，缺点是使用场景收到限制。
适用场景：多个产品的属性很多，组件很多而且有一定的相似性，如果建造别墅和建造楼房都是建房子。

二、结构型

1.代理模式：顾名思义，就是在目标对象和访问对象之间增加一个代理对象，访问对象不能直接引用目标对象，而是引用代理对象。代理对象对目标对象进行引用，并可以进行功能的扩展。

结构：包括抽象主题类、真实主题类和代理类。代理类和真实主题类都作为抽象主题类的实现，不同的是，代理类中抽象方法的实现是通过引用真实主题类并加以扩展。
优缺点：优点就是实现了目标对象和访问对象的解耦，还可以扩展目标对象的功能。但是增加了代理类，增加了系统复杂度，请求处理速度也随之变慢。
根据代理的创建时期，代理模式分为静态代理和动态代理。静态：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。动态：在程序运行时，运用反射机制动态创建而成。Spring框架中的AOP原理就是利用动态代理模式实现的。

2.装饰器模式：注意与代理模式的异同，装饰器模式是在不改变现有对象结构的情况下，对现有对象功能进行扩展，属于对自身能力的提高。代理模式是通过加入代理类，让代理去处理一些与目标对象业务无关的事情。

结构：包括抽象构件、具体构件、抽象装饰、具体装饰。抽象装饰器是传入了具体构件对象，实现了抽象构件的方法。具体装饰器则是继承抽象装饰器并完成功能的扩展。

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()");}
}

4.适配器模式：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

结构：
目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。
适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。
适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。
实现方式有两种：类适配器模式：适配器类继承适配者类并实现目标接口，通过重写目标接口方法，调用适配者类的方法。对象适配器模式：适配者类实现目标接口，重写目标接口方法，将适配者对象传入。

package adapter;
//目标接口
interface Target
{public void request();
}
//适配者接口
class Adaptee
{public void specificRequest(){       System.out.println("适配者中的业务代码被调用！");}
}
//类适配器类
class ClassAdapter extends Adaptee implements Target
{public void request(){specificRequest();}
}
//客户端代码
public class ClassAdapterTest
{public static void main(String[] args){System.out.println("类适配器模式测试：");Target target = new ClassAdapter();target.request();}
}

package adapter;
//对象适配器类
class ObjectAdapter implements Target
{private Adaptee adaptee;public ObjectAdapter(Adaptee adaptee){this.adaptee=adaptee;}public void request(){adaptee.specificRequest();}
}
//客户端代码
public class ObjectAdapterTest
{public static void main(String[] args){System.out.println("对象适配器模式测试：");Adaptee adaptee = new Adaptee();Target target = new ObjectAdapter(adaptee);target.request();}
}

适用场景：比如在service和control层，control层通过注入srevice对象，并调用service方法并包装接口作为control层的返回值。

三、行为型模式

1.模板方法（Template Method）模式的定义如下：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。它是一种类行为型模式。

-结构：
1）抽象类/抽象模板（Abstract Class）
抽象模板类，负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。这些方法的定义如下。

① 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。

② 基本方法：是整个算法中的一个步骤，包含以下几种类型。
抽象方法：在抽象类中声明，由具体子类实现。
具体方法：在抽象类中已经实现，在具体子类中可以继承或重写它。
钩子方法：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。
2）具体子类/具体实现（Concrete Class）
具体实现类，实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的一个组成步骤。

-优缺点：优点在父类中提取了公共的部分代码，便于代码复用。部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。缺点：对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大。由于继承关系自身的缺点，如果父类添加新的抽象方法，则所有子类都要改一遍。

适用场景：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。比如在电商项目中对品牌、图片、商品种类进行增删改查时，可以利用模板方法，设计一个接口作为数据库表的操作service，之后根据不同的对象设计不同的实现类。