一、写在前面 之前有介绍过状态模式，但是不是特别直接。后来写了一篇 Spring StateMachine 介绍，有几位同学联系我说想要源码。但是其实我觉得如果不是逻辑特别复杂的话，我不是特别推荐使用状态机。因为我们完全可以通过状态模式来实现，而且更加灵活和简单。
二、状态模式 状态模式的定义此处不在赘述，有兴趣的同学可以看下之前的文章。
首先，我们来定义几个名词。
状态（state）
这个比较好理解，状态模式嘛，就是管理状态的变更，所以首先我们要定义状态。 事件（event）
所谓事件，就是指状态变化的原因。例如，订单在经过支付事件之后，由 “待支付” 状态变为了 “待发货” 状态。 上下文（context）
负责状态以及状态的变更。 三、示例 为了跟 spring 的 state-machine 对比，我们依然使用简单订单状态的例子。
3.1 状态（state） /** * 订单状态 */ public interface OrderState { /** * 处理订单事件 * @param orderStateContext 上下文 * @param orderEvent 事件 */ default void handle(OrderStateContext orderStateContext, OrderEvent orderEvent){ System.out.println("can not handle this event " + orderEvent); } } /** * 订单待支付状态 * * @author sunbufu */ public class WaitPayState implements OrderState { @Override public void handle(OrderStateContext orderStateContext, OrderEvent orderEvent) { if (OrderEvent....
一、定义 单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。 详情可以参考之前的博客 [单例模式]({{ site.url }}/2018/06/06/design-patterns-01/#3单例模式singleton){:target="_blank"}。
二、实现 2.1 基本实现 单例模式可以笼统的分为 饿汉式 和 懒汉式。
// 饿汉式 public class Singleton { /** 私有的构造方法 */ private Singleton() { } /** 私有的静态的对象 */ private static Singleton singleton = new Singleton(); /** 公共的静态的获取对象的方法 */ public static Singleton getInstance(){ return singleton; } } // 懒汉式 public class Singleton { /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */ private static Singleton instance = null; /* 私有构造方法，防止被实例化 */ private Singleton() { } /* 静态工程方法，创建实例 */ public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */ public Object readResolve() { return instance; } } 饿汉式 会在类加载时直接创建对象。懒汉式 有点类似懒加载的感觉，在第一次使用的时候创建对象，但是这样也带来一个问题，如何保证线程安全。 上面的 懒汉式 其实是有问题的，多线程同时调用的时候会创建多个实例，所以用的比较多的是 double check 的实现方式。...
设计模式（Design Patterns） ——可复用面向对象软件的基础
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。
一、设计模式的分类 总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 剩余还有两类：并发型模式和线程池模式。 二、设计模式的六大原则 1、开闭原则（Open Close Principle） 开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则（Liskov Substitution Principle） 里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科
3、依赖倒转原则（Dependence Inversion Principle） 这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。
4、接口隔离原则（Interface Segregation Principle） 这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
5、迪米特法则（最少知道原则）（Demeter Principle） 为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
6、合成复用原则（Composite Reuse Principle） 原则是尽量使用合成/聚合的方式，而不是使用继承。
三、Java的23种设计模式 从这一块开始，我们详细介绍Java中23种设计模式的概念，应用场景等情况，并结合他们的特点及设计模式的原则进行分析。
1、工厂方法模式（Factory Method） 工厂方法模式分为三种：
1.1 普通工厂模式 就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。首先看下关系图： 举例如下：（我们举一个发送邮件和短信的例子）
创建二者的共同接口： public interface Sender { public void Send(); } 创建产品的实现类 public class MailSender implements Sender { @Override public void Send() { System....
我们接着讨论设计模式，上篇文章我讲完了5种创建型模式，这章开始，我将讲下7种结构型模式：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源，我们看下面的图： 6、适配器模式（Adapter） 适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。
6.1 类的适配器模式 核心思想就是：有一个Source类，拥有一个方法，待适配，目标接口时Targetable，通过Adapter类，将Source的功能扩展到Targetable里。
public class Source { public void method1() { System.out.println("this is original method!"); } } public interface Targetable { /* 与原类中的方法相同 */ public void method1(); /* 新类的方法 */ public void method2(); } public class Adapter extends Source implements Targetable { @Override public void method2() { System.out.println("this is the targetable method!"); } } Adapter类继承Source类，实现Targetable接口，下面是测试类：
public class AdapterTest { public static void main(String[] args) { Targetable target = new Adapter(); target....
先来张图，看看这11中模式的关系： 第一类：通过父类与子类的关系进行实现。 第二类：两个类之间。 第三类：类的状态。 第四类：通过中间类 13、策略模式（strategy） 策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数，关系图如下： 图中ICalculator提供统一的方法， AbstractCalculator是辅助类，提供辅助方法，接下来，依次实现下每个类： 首先统一接口：
public interface ICalculator { public int calculate(String exp); } 辅助类：
public abstract class AbstractCalculator { public int[] split(String exp,String opt){ String array[] = exp.split(opt); int arrayInt[] = new int[2]; arrayInt[0] = Integer.parseInt(array[0]); arrayInt[1] = Integer.parseInt(array[1]); return arrayInt; } } 三个实现类：
public class Plus extends AbstractCalculator implements ICalculator { @Override public int calculate(String exp) { int arrayInt[] = split(exp,"\\+"); return arrayInt[0]+arrayInt[1]; } } public class Minus extends AbstractCalculator implements ICalculator { @Override public int calculate(String exp) { int arrayInt[] = split(exp,"-"); return arrayInt[0]-arrayInt[1]; } } public class Multiply extends AbstractCalculator implements ICalculator { @Override public int calculate(String exp) { int arrayInt[] = split(exp,"\\*"); return arrayInt[0]*arrayInt[1]; } } 简单的测试类：...