Java 常见设计模式使用教程之一

大纲

• Java 常见设计模式使用教程之一
• Java 常见设计模式使用教程之二

前言

本文将介绍 Java 常用设计模式的使用，包括工厂模式、策略模式、模板方法模式、单例模式。

设计模式

设计模式的分类

• 创建型模式：提供一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象，这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。
• 结构型模式：关注对象之间的组合和关系，用于解决如何构建灵活且可复用的类和对象结构。
• 行为型模式：关注对象之间的通信和交互，用于解决对象之间的责任分配和算法的封装。

设计模式的六大原则

• 开放封闭原则（Open Close Principle）

  • 原则思想：尽量通过扩展软件实体来解决需求变化，而不是通过修改已有的代码来完成变化。
  • 描述：一个软件产品在生命周期内，都会发生变化，既然变化是一个既定的事实，我们就应该在设计的时候尽量适应这些变化，以提高项目的稳定性和灵活性。
  • 优点：单一原则告诉我们，每个类都有自己负责的职责，里氏替换原则不能破坏继承关系的体系。

• 里氏代换原则（Liskov Substitution Principle）

  • 原则思想：使用的基类可以在任何地方使用继承的子类，完美地替换基类。
  • 描述：子类可以扩展父类的功能，但不能改变父类原有的功能。子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法，子类中可以增加自己特有的方法。
  • 优点：增加程序的健壮性，即使增加了子类，原有的子类还可以继续运行，互不影响。

• 依赖倒转原则（Dependence Inversion Principle）

  • 依赖倒置原则的核心思想是面向接口编程。
  • 依赖倒转原则要求我们在程序代码中传递参数时或在关联关系中，尽量引用层次高的抽象层类。
  • 这个是开放封闭原则的基础，具体内容是：对接口编程，依赖于抽象而不依赖于具体。

• 接口隔离原则（Interface Segregation Principle）

  • 使用多个隔离的接口，要比使用单个接口好。本质还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。
  • 例如：支付类的接口和订单类的接口，需要把这俩个类别的接口变成两个隔离的接口。

• 迪米特法则（Demeter Principle）

  • 原则思想：又叫 “最少知道原则” 原则，一个对象应当对其他对象有尽可能少的了解，简称类间解耦。
  • 描述：一个类尽量减少自己对其他对象的依赖，原则是高内聚与低耦合，只有使各个模块之间的耦合尽量的低，才能提高代码的复用率。
  • 优点：高内聚，低耦合。

• 单一职责原则（Principle of Single Responsibility）

  • 原则思想：一个方法、一个类只负责一件事情。
  • 描述：单一职责原则很简单，一个方法、一个类只负责一个职责，各个职责的程序改动，不影响其它程序。这是常识，几乎所有程序员都会遵循这个原则。
  • 优点：降低类和类直接的耦合，提高代码可读性，增加代码的可维护性和可拓展性，降低可变性的风险。

单例模式

单例模式的概述

单例设计模式，即某个类在整个系统中只能有一个实例，对象可被获取和使用的设计模式。值得一提的是，JVM 运行环境的 Runtime 类就使用了单例模式。

• 单例模式的特点

  • 构造方法私有化，限制某个类只能有一个实例
  • 必须自行创建这个实例，即含有一个该类的静态变量来保存唯一的实例
  • 必须自行向整个系统提供这个实例，对外提供获取实例对象的方式一般是：直接通过静态变量暴露或者使用静态 Get 方法来获取

• 单例模式的优点

  • 在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就防止其它对象对自己的实例化，确保所有的对象都访问一个实例。
  • 单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
  • 由于在系统内存中只存在一个对象，因此可以节约系统资源。相对于频繁创建和销毁对象，单例模式无疑可以提高系统的性能。
  • 单例模式提供了对唯一实例的受控访问。
  • 避免对共享资源的多重占用。

• 单例模式的缺点

  • 不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。
  • 由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
  • 单例类的职责过重，在一定程度上违背了 “单一职责原则”。
  • 滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

单例模式的应用场景

• 单例模式的使用场景

  • 网站的计数器，一般也是采用单例模式实现，否则难以同步。
  • 应用程序的日志应用，一般都是单例模式实现，只有一个实例去操作才好，否则日志内容不好追加显示。
  • 多线程的线程池的设计一般也是采用单例模式，因为线程池要方便对池中的线程进行控制。
  • Windows 的任务管理器就是很典型的单例模式，它不能同时运行两个。
  • windows 的回收站也是典型的单例应用。在整个系统运行过程中，回收站只维护一个实例。

• 单例模式的使用注意事项

  • 使用单例模式时，不能用反射模式创建单例，否则会实例化一个新的对象。
  • 使用懒汉式单例模式时，需要注意线程安全问题。
  • 饿汉式单例模式和懒汉式单例模式的构造方法都是私有的，因此是不能被继承的，但有些单例模式可以被继承（如登记式模式）。

• 单例模式的几种常见实现方式

  • 饿汉式（在类初始化时，直接创建对象，不存在线程安全的问题）

    • 直接实例化（简洁直观）
    • 枚举（最简洁）
    • 静态代码块（适合复杂的实例化）

  • 懒汉式（延迟创建对象，可能存在线程安全的问题）

    • 判断非空则直接实例化（非线程安全，适用于单线程）
    • DCL - 双端检锁（线程安全，适用于多线程）
    • 静态内部类形式（线程安全，适用于多线程）

• 如何选择单例的创建方式

  • 如果需要延迟加载单例，可以使用静态内部类形式来创建单例，不存在线程安全的问题。
  • 如果不需要延迟加载单例，可以使用枚举（最简洁）来创建单例，不存在线程安全的问题。枚举本身就是单例，由 JVM 从根本上提供保障，可以避免通过反射和反序列化的漏洞。

单例模式的使用案例

• 饿汉式：类初始化时，会立即加载该对象，天生线程安全，调用效率高。
• 懒汉式：类初始化时，不会初始化该对象，等真正需要使用的时候才会创建该对象，具备懒加载功能。

饿汉式单例模式

• 饿汉式的第一种实现方式：直接实例化（简洁直观）

public class HungrySingleton {

	public static final HungrySingleton INSTANCE = new HungrySingleton();

	private HungrySingleton() {

	}

}

• 饿汉式的第二种实现方式：枚举（最简洁）

// 枚举类在类加载时就会被加载
public enum HungrySingleton {

    INSTANCE;

    public void doSomething() {
        // 单例的业务逻辑
    }

}

public class SingletonTest {

    public static void main(String[] args) {
        Singleton singleton = Singleton.INSTANCE;
        singleton.doSomething();
    }

}

• 饿汉式的第三种实现方式：静态代码块（适合复杂的实例化）

public class HungrySingleton {

	public static final HungrySingleton INSTANCE;

	static {
            // do anything
            INSTANCE = new HungrySingleton();
	}

	private HungrySingleton() {

	}

}

懒汉式单例模式

• 懒汉式的第一种实现方式：判断非空则直接实例化（非线程安全，适用于单线程）

public class LazySingleton01 {

	private static LazySingleton01 instance;

	private LazySingleton01() {

	}

	public static LazySingleton01 getInstance() {
		if (instance == null) {
			instance = new LazySingleton01();
		}
		return instance;
	}

}

• 懒汉式的第二种实现方式：DCL - 双端检锁（线程安全，适用于多线程）
  • (1) DCL（双端检锁）机制不一定是线程安全的，因为有指令重排的存在，加入 volatile 关键字可以禁止指令重排。
  • (2) 原因是在多线程环境下，某一个线程执行到第一个检测，读取到的 instance 不为 null 时，instance 实例可能没有完成初始化。
  • (3) 指令重排只会保证串行语义的执行一致性（单线程），但并不会关心多线程间的语义一致性。所以当一个线程访问 instance 不为 null 时，由于 instance 实例未必已初始化完成，也就造成了线程安全问题。

public class LazySingleton02 {

	private static volatile LazySingleton02 instance;

	private LazySingleton02() {

	}

	public static LazySingleton02 getInstance() {
		if (instance == null) {
			synchronized (LazySingleton02.class) {
				if (instance == null) {
					instance = new LazySingleton02();
				}
			}
		}
		return instance;
	}

}

• 懒汉式的第三种实现方式：静态内部类形式（线程安全，适用于多线程）
  • （1）静态内部类不会自动随着外部类的加载和初始化而初始化，它是单独去加载和初始化的。
  • （2）因为是在静态内部类加载和初始化时，才创建单例对象，因此是线程安全的。

public class LazySingleton03 {

	private LazySingleton03() {

	}

	public static LazySingleton03 getInstance() {
		return Singleton.instance;
	}

	private static class Singleton {
		private static final LazySingleton03 instance = new LazySingleton03();
	}
	
}

防止反射漏洞攻击

使用 Java 反射可以跳过单例模式的限制直接创建对象，为了避免单例对象的唯一性被破坏，可以参考以下代码来解决：

public class Singleton {

    private static boolean flag = false;

    private Singleton() {
        if (flag == false) {
            flag = !flag;
        } else {
            throw new RuntimeException("单例模式被侵犯！");
        }
    }

}

工厂模式

工厂模式的概述

工厂模式提供了一种创建对象的最佳方式。在工厂模式中，开发者在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象，从而实现了创建者和调用者分离。

• 工厂模式的优点

  • 工厂模式是最常用的实例化对象模式，可以用工厂方法代替 new 运算操作符。
  • 利用工厂模式可以降低程序的耦合性，为后期的维护修改提供了很大的便利。
  • 将选择实现类、创建对象统一管理和控制，从而将调用者跟实现类解耦。

• Spring IOC 容器

  • 看过 Spring 源码就知道，在 Spring IOC 容器创建 Bean 的过程是使用了工厂模式。
  • 在 Spring 中，无论是通过 XML 配置还是通过配置类还是注解进行创建 Bean，大部分都是通过简单工厂来创建的。
  • 当容器拿到了 BeanName 和 Class 类型后，会动态地通过反射来创建具体的某个对象，最后将创建的对象放到 Map 中。

• 为什么 Spring IOC 容器要使用工厂模式创建 Bean

  • 在实际开发中，如果 A 对象调用 B 对象，B 对象调用 C 对象，C 对象调用 D 对象，这样代码的耦合性就会变高（耦合大致分为类与类之间的依赖，方法与方法之间的依赖）。
  • 在很久以前使用三层架构编程时，都是控制层调用业务层，业务层调用数据访问层，而且都是直接 new 对象，代码的耦合性大大提升，代码重复量也很高，对象满天飞。
  • 为了避免这种情况，Spring 使用了工厂模式，写一个工厂，由工厂负责创建 Bean，以后如果需要使用对象就直接管工厂要就可以，剩下的事情就不用管了。Spring IOC 容器的工厂中有个静态的 Map，是为了让工厂符合单例设计模式，即每个对象只生产一次，生产出对象后就存入到 Map 中，保证了实例不会重复创建，从而提高程序效率。

工厂模式的分类

工厂模式分为简单工厂模式、工厂方法模式、抽象工厂模式。

• 简单工厂模式：用来生产同一等级结构的任意产品（不支持拓展增加产品）。
• 工厂方法模式：用来生产同一等级结构的固定产品（支持拓展增加产品）。
• 抽象工厂模式：用来生产不同产品族的全部产品（不支持拓展增加产品，但支持增加产品族）。

工厂模式的使用案例

简单工厂模式

简单工厂模式相当于是一个工厂中有各种产品，创建在一个类中，客户无需知道具体产品的名称，只需要知道产品类所对应的参数即可。但是，工厂的职责过重，而且当类型过多时不利于系统的扩展维护。

• 创建工厂

public interface Car {

	public void run();

}

• 创建工厂的产品（宝马）

public class Bmw implements Car {

	public void run() {
		System.out.println("我是宝马汽车...");
	}

}

• 创建工厂的产品（奥迪）

public class AoDi implements Car {

	public void run() {
		System.out.println("我是奥迪汽车..");
	}

}

• 创建核心工厂类，由它决定具体创建哪个产品

public class CarFactory {

	 public static Car createCar(String name) {
		if ("".equals(name)) {
             return null;
		}
		if(name.equals("奥迪")){
			return new AoDi();
		}
		if(name.equals("宝马")){
			return new Bmw();
		}
		return null;
	}

}

• 演示工厂类的使用

public class FactoryDemo {

	public static void main(String[] args) {
		Car bmw = CarFactory.createCar("宝马");
		Car aodi = CarFactory.createCar("奥迪");
		bmw.run();
		aodi.run();
	}

}

简单工厂模式的优缺点

• 优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
• 缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反 GRASPR 的高内聚的责任分配原则。

工厂方法模式

工厂方法模式（ Factory Method）又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去完成。该核心工厂类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

• 创建工厂

public interface Car {

	public void run();

}

• 创建工厂的产品（宝马）

public class Bmw implements Car {

	public void run() {
		System.out.println("我是宝马汽车...");
	}

}

• 创建工厂的产品（奥迪）

public class AoDi implements Car {

	public void run() {
		System.out.println("我是奥迪汽车..");
	}

}

• 创建工厂方法调用接口（这是工厂子类必须实现的接口）

public interface CarFactory {

	Car createCar();

}

• 创建工厂方法调用接口的实例（宝马）

public class BmwFactory implements CarFactory {

	public Car createCar() {
		return new Bmw();
	}

}

• 创建工厂方法调用接口的实例（奥迪）

public class AoDiFactory implements CarFactory {

	public Car createCar() {
		return new AoDi();
	}
}

• 演示工厂类的使用

public class FactoryDemo {

	public static void main(String[] args) {
		Car bmw = new BmwFactory().createCar();
		Car aodi = new AoDiFactory().createCar();
		bmw.run();
		aodi.run();
	}

}

抽象工厂模式

抽象工厂，简单来说就是工厂的工厂，抽象工厂可以创建具体工厂，由具体工厂来生产具体产品。

• 创建第一个子工厂与实现类

public interface Car {
    void run();
}

public class CarA implements Car{

    public void run() {
        System.out.println("宝马");
    }

}

public class CarB implements Car{

    public void run() {
        System.out.println("奥迪");
    }

}

• 创建第二个子工厂与实现类

public interface Engine {

    void run();

}

public class EngineA implements Engine {

    public void run() {
        System.out.println("转的快!");
    }

}

public class EngineB implements Engine {

    public void run() {
        System.out.println("转的慢!");
    }

}

• 创建一个总工厂与实现类（由总工厂的实现类决定调用哪个工厂的哪个实例）

public interface TotalFactory {

    // 创建汽车
    Car createCar();

    // 创建发动机
    Engine createEngine();

}

public class TotalFactoryReally implements TotalFactory {

    public Engine createEngine() {
        return new EngineA();
    }

    public Car createCar() {
        return new CarA();
    }

}

• 演示工厂类的使用

public class FactoryDemo {

    public static void main(String[] args) {
        TotalFactory totalFactory = new TotalFactoryReally();

        Car car = totalFactory.createCar();
        car.run();

        Engine engine = totalFactory.createEngine();
        engine.run();
    }

}

策略模式

策略模式的概述

• 策略模式的介绍

  • 定义了一系列的算法、逻辑、相同意义的操作，并将每一个算法、逻辑操作封装起来，而且使它们还可以相互替换。策略模式在 Java 中用的非常广泛。
  • 策略模式可以简化多个 if ... else 所带来的复杂性和维护难度。

• 策略模式的优点

  • 算法、逻辑可以自由切换。
  • 可以避免使用多重条件判断。
  • 扩展性非常良好。

• 策略模式的缺点

  • 策略类会增多。
  • 所有策略类都需要对外暴露。

• 策略模式的应用场景

  • 策略模式的用意是针对一组算法或逻辑，将每一个算法或逻辑封装到具有共同接口的独立的类中，从而使得它们之间可以相互替换。
  • 例如：要做一个不同会员打折力度不同的三种策略，初级会员、中级会员、高级会员策略（涉及三种不同打折力度的计算）。
  • 例如：要一个支付模块，分别需要接入微信支付、支付宝支付、银联支付等。

策略模式的使用案例

这里将模拟支付模块需要接入微信支付、支付宝支付、银联支付。

• 定义抽象的公共方法

public abstract class PayStrategy {

    // 支付逻辑方法
    abstract void algorithmInterface();

}

• 定义微信支付的实现类

public class PayStrategyA extends PayStrategy {

    void algorithmInterface() {
        System.out.println("微信支付");
    }

}

• 定义支付宝支付的实现类

public class PayStrategyB extends PayStrategy {

    void algorithmInterface() {
        System.out.println("支付宝支付");
    }

}

• 定义银联支付的实现类

public class PayStrategyC extends PayStrategy {

    void algorithmInterface() {
        System.out.println("银联支付");
    }

}

• 定义维护支付策略的上下文

public class Context {

	PayStrategy strategy;

	public Context(PayStrategy strategy) {
		this.strategy = strategy;
	}

	public void algorithmInterface() {
		strategy.algorithmInterface();
	}

}

• 运行测试的代码

public class StrategyTest {

    public static void main(String[] args) {
        Context context;

        //使用支付逻辑A
        context = new Context(new PayStrategyA());
        context.algorithmInterface();

        //使用支付逻辑B
        context = new Context(new PayStrategyB());
        context.algorithmInterface();

        //使用支付逻辑C
        context = new Context(new PayStrategyC());
        context.algorithmInterface();
    }

}

模板方法模式

模板方法模式的概述

• 模板方法模式的介绍

  • 模板方法模式：定义一个操作中的算法骨架（父类），而将一些步骤延迟到子类中。 模板方法使得子类可以不改变一个算法的结构来重定义该算法的

• 模板方法的应用场景

  • 在实现一些操作时，整体步骤很固定，但就是其中一小部分需要改变，这时候可以使用模板方法模式，将容易变的部分抽象出来，供子类实现。
  • 其实很多框架中都有用到了模板方法模式，比如 Spring 提供的 JDBCTemplate 与 RedisTemplate、Junit 单元测试、Servlet 中关于 doGet/doPost 方法的调用等。

模板方法模式的使用案例

这里将模拟去餐厅吃饭，餐厅给客户提供了一个模板就是：看菜单、点菜、吃饭、付款、离开。这里的 “点菜” 和 “付款” 步骤是不确定的，由子类来完成的，其他的步骤则是一个模板。

• 定义一个模板，让子类来实现模板中的点菜和付款步骤

public abstract class RestaurantTemplate {

    // 1.看菜单
    public void menu() {
        System.out.println("看菜单");
    }

    // 2.点菜
    abstract void spotMenu();

    // 3.吃饭
    public void havingDinner() { System.out.println("吃饭"); }

    // 4.付款
    abstract void payment();

    // 5.离开
    public void leave() { System.out.println("离开"); }

    // 模板通用结构
    public void process(){
        menu();
        spotMenu();
        havingDinner();
        payment();
        leave();
    }

}

• 具体的模板方法子类一

public class RestaurantGinsengImpl extends RestaurantTemplate {

    void spotMenu() {
        System.out.println("人参");
    }

    void payment() {
        System.out.println("支付200元");
    }

}

• 具体的模板方法子类二

public class RestaurantLobsterImpl  extends RestaurantTemplate  {

    void spotMenu() {
        System.out.println("龙虾");
    }

    void payment() {
        System.out.println("支付500元");
    }
	
}

• 运行测试的代码

public class Templatetest {

    public static void main(String[] args) {
        // 调用第一个模板实例
        RestaurantTemplate restaurantTemplate = new RestaurantGinsengImpl();
        restaurantTemplate.process();
    }

}

参考资料

• 菜鸟教程 - 设计模式
• 最全的设计模式详解
• 谈谈 Spring 用到了哪些设计模式