设计模式笔记——GoF设计模式汇总
目录
· 总述
· 记忆
· 效果
· 面向对象设计原则
· 创建型模式
· 效果
· 分类
· 代码（饿汉式）
· 代码（懒汉式）
· 代码（枚举单例）
· 应用场景
· 工厂模式
· 效果
· 分类
· 代码（简单工厂）
· 代码（工厂方法）
· 代码（抽象工厂）
· 应用场景
· 效果
· 代码
· 应用场景
· 效果
· 核心角色
· 代码（浅克隆）
· 应用场景
· 结构型模式
· 效果
· 核心角色
· 分类
· 代码（使用继承）
· 代码（使用关联）
· 应用场景
· 效果
· 核心角色
· 分类
· 代码（静态代理）
· 代码（动态代理）
· 应用场景
· 效果
· 代码
· 应用场景
· 效果
· 核心角色
· 代码
· 代码（杀毒举例）
· 应用场景
· 效果
· 核心角色
· 代码
· 应用场景
· 效果
· 代码
· 应用场景
· 效果
· 核心角色
· 代码
· 应用场景
· 行为型模式
· 责任链模式（Chain of Resposibility）
· 效果
· 核心角色
· 代码
· 应用场景
· 效果
· 核心角色
· 代码
· 应用场景
· 效果
· 代码
· 应用场景
· 效果
· 核心角色
· 代码
· 应用场景
· 效果
· 应用场景
· 效果
· 应用场景
· 效果
· 代码
· 应用场景
· 效果
· 代码
· 应用场景
· 效果
· 核心角色
· 代码
· 应用场景
· 效果
· 代码
· 应用场景
· 效果
· 核心角色
· 代码
· 应用场景
总述
记忆
1. 创建型：sbfp；
2. 结构型：abcdffp；
3. 行为型：iimmccsstov。
效果
1. 所有面向对象设计原则和设计模式都是为了降低代码耦合度，提高扩展性、复用，手段是“分工”。
2. 类似社会分工，现代社会比原始社会发展得大，也是因为分工。
面向对象设计原则
|
首字母 |
代指 |
解释 |
|
S |
单一功能原则（Single Responsibility Principle） |
对象应该仅具有一种单一功能。 |
|
O |
开闭原则（Open/Closed Principle） |
软件体应该是对于扩展开放的，但是对于修改封闭的。 |
|
L |
里氏替换原则（Liskov Substitution Principle） |
程序中的对象应该是可以在不改变程序正确性的前提下被它的子类所替换的。 |
|
I |
接口隔离原则（Interface Segregation Principle） |
多个特定客户端接口要好于一个宽泛用途的接口。 |
|
D |
依赖反转原则（Dependency Inversion Principle） |
一个方法应该遵从“依赖于抽象而不是一个实例”。 |
创建型模式
单例模式（Singleton）
效果
1. 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
2. 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。
分类
1. 常见实现方式。
a) 饿汉式：线程安全，调用效率高，不能延时加载。
b) 懒汉式：线程安全，调用效率不高，可延时加载。
2. 其他实现方式。
a) 双重检测锁式：由于JVM底层内部模型原因，偶尔出问题，不建议使用。
b) 静态内部类式：线程安全，调用效率高，可延时加载。
c) 枚举单例：线程安全，调用效率高，不能延时加载。
3. 选择方法。
a) 单例对象占用资源少，不需要延时加载：枚举式好于饿汉式；
b) 单例对象占用资源多，需要延时加载：静态内部类好于懒汉式。
代码（饿汉式）
1. Singleton.java
public class Singleton {
// 类初始化时立即创建对象
private static final Singleton instance = new Singleton();
// 私有化构造器
private Singleton() {
if (instance != null) {
throw new RuntimeException();
}
}
public static Singleton getInstance() {
return instance;
}
}
2. Client.java
public class Client {
public static void main(String[] args) {
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2);
}
}
代码（懒汉式）
1. Singleton.java
public class Singleton {
private static Singleton instance;
// 私有化构造器
private Singleton() {
}
// 同步方法
public static synchronized Singleton getInstance() {
if (instance == null) {
// 延时加载
instance = new Singleton();
}
return instance;
}
}
2. Client.java
public class Client {
public static void main(String[] args) {
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2);
}
}
代码（双重检测锁式）
1. Singleton.java
public class Singleton {
private static volatile Singleton instance;
// 私有化构造器
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
// 第一次创建时同步
synchronized (Singleton.class) {
if (instance == null) {
// 延时加载
instance = new Singleton();
}
}
}
return instance;
}
}
2. Client.java
public class Client {
public static void main(String[] args) {
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2);
}
}
代码（静态内部类式）
1. Singleton.java
public class Singleton {
// 初始化外部类时不会立即初始化内部类
private static class SingletonInstance {
private static final Singleton instance = new Singleton();
}
// 私有化构造器
private Singleton() {
}
public static Singleton getInstance() {
return SingletonInstance.instance;
}
}
2. Client.java
public class Client {
public static void main(String[] args) {
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2);
}
}
代码（枚举单例）
1. Singleton.java
public enum Singleton {
// 枚举本身就是单例
INSTANCE;
// 添加需要的方法
public void method() {
}
}
2. Client.java
public class Client {
public static void main(String[] args) {
Singleton singleton1 = Singleton.INSTANCE;
Singleton singleton2 = Singleton.INSTANCE;
System.out.println(singleton1 == singleton2);
}
}
代码（使用反射的破解与防御）
1. Singleton.java
public class Singleton {
// 类初始化时立即创建对象
private static final Singleton instance = new Singleton();
// 私有化构造器
private Singleton() {
// 防御：再次创建时抛出异常
if (instance != null) {
throw new RuntimeException();
}
}
public static Singleton getInstance() {
return instance;
}
}
2. Client.java
import java.lang.reflect.Constructor;
public class Client {
public static void main(String[] args) throws Exception {
Singleton singleton1 = Singleton.getInstance();
Class<Singleton> clazz = Singleton.class;
Constructor<Singleton> constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true);
Singleton singleton2 = constructor.newInstance();
System.out.println(singleton1 == singleton2);
}
}
代码（使用序列化的破解与防御）
1. Singleton.java
import java.io.Serializable;
public class Singleton implements Serializable {
private static final long serialVersionUID = -3230831923851678463L;
// 类初始化时立即创建对象
private static final Singleton instance = new Singleton();
// 私有化构造器
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
// 防御：反序列化时，直接返回该方法的返回值
private Object readResolve() {
return instance;
}
}
2. Client.java
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream; public class Client { public static void main(String[] args) throws Exception {
Singleton singleton1 = Singleton.getInstance(); File tempFile = new File("D:/test");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(tempFile));
oos.writeObject(singleton1);
oos.close();
ObjectInputStream ios = new ObjectInputStream(new FileInputStream(tempFile));
Singleton singleton2 = (Singleton) ios.readObject();
ios.close();
System.out.println(singleton1 == singleton2); } }
应用场景
1. Windows的Task Manager（任务管理器）。
2. Windows的Recycle Bin（回收站）。
3. 项目中，读取配置文件的类，一般只有一个对象，没必要每次创建。
4. 数据库连接池。
5. Application是单例的典型应用（Servlet编程）。
6. Spring中，每个Bean默认是单例的。
7. 每个Servlet是单例。
8. Spring MVC中，控制器对象是单例的。
工厂模式
效果
1. 实例化对象，用工厂方法代替new。实现了创建者和调用者的分离。
2. 将选择实现类、创建对象统一管理和控制，从而将调用者跟我们的实现类解耦。
分类
1. 简单工厂模式：用来产生同一等级结构中的任意产品。对于增加新的产品，需要修改已有代码。
2. 工厂方法模式：用来产生同一等级结构中的固定产品。支持增加任意产品。
3. 抽象工厂模式：用来生产不同产品族的全部产品。对于增加新的产品，无能为力；支持增加产品族。
4. 简单工厂模式效果：
a) 又称静态工厂模式。
b) 工厂类一般使用静态方法，通过接收的参数来返回不同的对象实例。
c) 对于增加新产品只能修改代码（违反OCP）。
d) 有两种实现方式（见代码）。
5. 工厂方法模式效果：
a) 避免简单工厂的缺点，但不完全满足OCP。
b) 简单工厂模式VS.工厂方法模式：
i. 结构复杂度：显然简单工厂模式占优，简单工厂模式只要一个工厂，而工厂方法模式的工厂类随着产品类个数增加而增加。
ii. 代码复杂度：代码复杂度与结构复杂度相反，简单工厂模式的工厂类随着产品增加需要增加更多方法（代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简单。
iii. 客户端编程难度：工厂方法模式虽然满足了OCP，但客户端编码中需要对工厂实例化，而简单工厂模式的工厂类是一个静态类。
iv. 管理上的难度：工厂方法模式需要维护的工厂类过多，而简单工厂模式只有一个。
c) 设计理论建议使用工厂方法模式，但实际中一般都用简单工厂模式。
6. 抽象工厂模式效果：
a) 用来生产不同产品族的全部产品。对于增加新的产品，无能为力；支持增加产品族。
b) 抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象时一种非常好的解决方式。
代码（简单工厂）
1. Car.java
public interface Car {
void run();
}
2. Audi.java
public class Audi implements Car {
@Override
public void run() {
System.out.println("奥迪在跑！");
}
}
3. Byd.java
public class Byd implements Car {
@Override
public void run() {
System.out.println("比亚迪在跑！");
}
}
4. CarFactory.java
// 一个方法实现
public class CarFactory1 { public static Car createCar(String type) {
if ("Audi".equals(type)) {
return new Audi();
}
if ("Byd".equals(type)) {
return new Byd();
}
return null;
} }
5. CarFactory2.java
// 多个方法实现
public class CarFactory2 { public static Car createAudi() {
return new Audi();
} public static Car createByd() {
return new Byd();
} }
6. Client.java
public class Client {
public static void main(String[] args) {
Car car1 = CarFactory1.createCar("Audi");
Car car2 = CarFactory1.createCar("Byd");
car1.run();
car2.run();
}
}
代码（工厂方法）
1. Car.java
public interface Car {
void run();
}
2. CarFactory.java
public interface CarFactory {
Car createCar();
}
3. Audi.java
public class Audi implements Car {
@Override
public void run() {
System.out.println("奥迪在跑！");
}
}
4. AudiFactory.java
public class AudiFactory implements CarFactory {
@Override
public Car createCar() {
return new Audi();
}
}
5. Byd.java
public class Byd implements Car {
@Override
public void run() {
System.out.println("比亚迪在跑！");
}
}
6. BydFactory.java
public class BydFactory implements CarFactory {
@Override
public Car createCar() {
return new Byd();
}
}
7. Client.java
public class Client {
public static void main(String[] args) {
Car car1 = new AudiFactory().createCar();
Car car2 = new BydFactory().createCar();
car1.run();
car2.run();
}
}
代码（抽象工厂）
1. Engine.java
public interface Engine {
void start();
void speedUp();
}
class LuxuryEngine implements Engine {
@Override
public void start() {
System.out.println("快速启动！");
}
@Override
public void speedUp() {
System.out.println("快速加速！");
}
}
class LowEngine implements Engine {
@Override
public void start() {
System.out.println("慢速启动！");
}
@Override
public void speedUp() {
System.out.println("慢速加速！");
}
}
2. Seat.java
public interface Seat {
void massage();
}
class LuxurySeat implements Seat {
@Override
public void massage() {
System.out.println("按摩！");
}
}
class LowSeat implements Seat {
@Override
public void massage() {
System.out.println("不能按摩！");
}
}
3. Tire.java
public interface Tire {
void revolve();
}
class LuxuryTire implements Tire {
@Override
public void revolve() {
System.out.println("旋转不磨损！");
}
}
class LowTire implements Tire {
@Override
public void revolve() {
System.out.println("旋转磨损快！");
}
}
4. CarFactory.java
public interface CarFactory {
Engine createEngine();
Seat createSeat();
Tire createTire();
}
class LuxuryCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LuxuryEngine();
}
@Override
public Seat createSeat() {
return new LuxurySeat();
}
@Override
public Tire createTire() {
return new LuxuryTire();
}
}
class LowCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LowEngine();
}
@Override
public Seat createSeat() {
return new LowSeat();
}
@Override
public Tire createTire() {
return new LowTire();
}
}
5. Client.java
public class Client {
public static void main(String[] args) {
CarFactory carFactory = new LuxuryCarFactory();
Engine engine = carFactory.createEngine();
engine.start();
engine.speedUp();
}
}
应用场景
1. JDK中Calendar.getInstance()方法。
2. JDBC中Connection对象的获取。
3. Hibernate中SessionFactory创建Session。
4. Spring中IoC容器创建管理Bean对象。
5. 反射中Class对象的newInstance()方法。
构建者模式（Builder）
效果
1. 构建一个复杂的产品（如神舟飞船、iPhone）时，需要解决“如何装配子组件”的问题。
2. 分离了对象子组件的单独构建（Builder）和装配（Director），从而构造出复杂对象。
3. 由于实现了构建和装配的解耦。不同的构建器、相同的装配，或者相同的构建器、不同的装配，都可以创建不同的对象。
4. 建造者模式一般与工厂模式搭配，由工厂模式创建子组件，再有建造者模式装配。
代码
1. Airship.java
public class Airship {
private Engine engine;
private OrbitalModule orbitalModule;
private EscapeTower escapeTower;
public void launch() {
System.out.println(engine.getName() + "点火！");
System.out.println(orbitalModule.getName() + "发射！");
}
public Engine getEngine() {
return engine;
}
public void setEngine(Engine engine) {
this.engine = engine;
}
public OrbitalModule getOrbitalModule() {
return orbitalModule;
}
public void setOrbitalModule(OrbitalModule orbitalModule) {
this.orbitalModule = orbitalModule;
}
public EscapeTower getEscapeTower() {
return escapeTower;
}
public void setEscapeTower(EscapeTower escapeTower) {
this.escapeTower = escapeTower;
}
}
class Engine {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class OrbitalModule {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class EscapeTower {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
2. AirshipBuilder.java
public interface AirshipBuilder {
Engine buildEngine();
OrbitalModule buildOrbitalModule();
EscapeTower buildEscapeTower();
}
3. AirshipDirector.java
public interface AirshipDirector {
Airship directAirship();
}
4. SzAirshipBuilder.java
public class SzAirshipBuilder implements AirshipBuilder {
@Override
public Engine buildEngine() {
// 也可使用工厂模式创建
Engine engine = new Engine();
engine.setName("神舟发动机");
return engine;
}
@Override
public OrbitalModule buildOrbitalModule() {
// 也可使用工厂模式创建
OrbitalModule orbitalModule = new OrbitalModule();
orbitalModule.setName("神舟轨道舱");
return orbitalModule;
}
@Override
public EscapeTower buildEscapeTower() {
// 也可使用工厂模式创建
EscapeTower escapeTower = new EscapeTower();
escapeTower.setName("神舟逃逸塔");
return escapeTower;
}
}
5. SzAirshipDirector.java
public class SzAirshipDirector implements AirshipDirector {
private AirshipBuilder airshipBuilder;
public SzAirshipDirector(AirshipBuilder airshipBuilder) {
this.airshipBuilder = airshipBuilder;
}
@Override
public Airship directAirship() {
Engine engine = airshipBuilder.buildEngine();
OrbitalModule orbitalModule = airshipBuilder.buildOrbitalModule();
EscapeTower escapeTower = airshipBuilder.buildEscapeTower();
Airship airship = new Airship();
airship.setEngine(engine);
airship.setOrbitalModule(orbitalModule);
airship.setEscapeTower(escapeTower);
return airship;
}
}
6. Client.java
public class Client {
public static void main(String[] args) {
AirshipDirector airshipDirector = new SzAirshipDirector(new SzAirshipBuilder());
Airship airship = airshipDirector.directAirship();
airship.launch();
}
}
应用场景
1. StringBuilder.append()方法。
2. SQL中的PareparedStatement。
原型模式（Prototype）
效果
1. 通过new创建对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
2. 就是Java中的克隆技术，以某个对象为原型，复制出新的对象。
3. 优势：效率高，避免重新执行构建过程。
4. 克隆类似于new，但不同于new。new创建新的对象属性采用默认值。克隆出的对象属性完全与原型对象相同，并且克隆出的新对象改变不会影响原型对象，然后再修改克隆对象的值。
核心角色
1. Clonable接口的clone()方法。
2. 实现原型模式最困难的是内存复制操作，所幸Java提供了clone()方法。
代码（浅克隆）
1. Sheep.java
import java.util.Date;
public class Sheep implements Cloneable {
private String name;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
2. Client.java
import java.util.Date;
public class Client {
public static void main(String[] args) throws Exception {
Sheep sheep1 = new Sheep();
sheep1.setName("少利");
sheep1.setBirthday(new Date());
Sheep sheep2 = (Sheep) sheep1.clone();
sheep2.setName("多利");
System.out.println(sheep2.getName());
System.out.println(sheep2.getBirthday());
// 浅克隆
System.out.println(sheep1.getBirthday() == sheep2.getBirthday());
}
}
代码（基于JDK的深克隆）
1. Sheep.java
import java.util.Date;
public class Sheep implements Cloneable {
private String name;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
Sheep sheep = (Sheep) super.clone();
sheep.setBirthday((Date) birthday.clone());
return sheep;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
2. Client.java
import java.util.Date;
public class Client {
public static void main(String[] args) throws Exception {
Sheep sheep1 = new Sheep();
sheep1.setName("少利");
sheep1.setBirthday(new Date());
Sheep sheep2 = (Sheep) sheep1.clone();
sheep2.setName("多利");
System.out.println(sheep2.getName());
System.out.println(sheep2.getBirthday());
// 深克隆
System.out.println(sheep1.getBirthday() == sheep2.getBirthday());
}
}
代码（基于序列化的深克隆）
1. Sheep.java
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Date; public class Sheep implements Cloneable, Serializable { private static final long serialVersionUID = 2155997264135266066L; private String name; private Date birthday; @Override
protected Object clone() throws CloneNotSupportedException {
Sheep sheep = null;
ByteArrayOutputStream baos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bais = null;
ObjectInputStream ois = null;
try {
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(this);
byte[] bytes = baos.toByteArray();
bais = new ByteArrayInputStream(bytes);
ois = new ObjectInputStream(bais);
sheep = (Sheep) ois.readObject(); } catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
return sheep;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public Date getBirthday() {
return birthday;
} public void setBirthday(Date birthday) {
this.birthday = birthday;
} }
2. Client.java
import java.util.Date;
public class Client {
public static void main(String[] args) throws Exception {
Sheep sheep1 = new Sheep();
sheep1.setName("少利");
sheep1.setBirthday(new Date());
Sheep sheep2 = (Sheep) sheep1.clone();
sheep2.setName("多利");
System.out.println(sheep2.getName());
System.out.println(sheep2.getBirthday());
// 深克隆
System.out.println(sheep1.getBirthday() == sheep2.getBirthday());
}
}
应用场景
1. 原型模式很少单独使用，一般与工厂模式一起出现。通过clone()方法创建对象后由工厂模式返回。
2. Spring的Bean创建有单例模式和原型模式两种方式。
结构型模式
适配器模式（Adapter）
效果
将一个类的接口转换成客户希望的另一个接口，使原本由于接口不兼容而不能一起工作的那些类可以在一起工作。
核心角色
1. 目标接口（Target）：客户所期望的接口（接口、抽象类或具体类）。
2. 适配的类（Adaptee）。
3. 适配器（Adapter）：通过包装适配的类，把原接口转换成目标接口。
分类
1. 使用继承实现：Adapter继承Adaptee。
2. 使用关联实现：Adapter持有Adaptee的引用，Adapter可以继承其他类，更灵活。
代码（使用继承）
1. Target.java
public interface Target {
void handleRequest();
}
2. Adaptee.java
public class Adaptee {
public void request() {
System.out.println("处理请求！");
}
}
3. Adapter.java
public class Adapter extends Adaptee implements Target {
@Override
public void handleRequest() {
request();
}
}
4. Client.java
public class Client {
public void execute(Target target) {
target.handleRequest();
}
public static void main(String[] args) {
Target target = new Adapter();
new Client().execute(target);
}
}
代码（使用关联）
1. Target.java
public interface Target {
void handleRequest();
}
2. Adaptee.java
public class Adaptee {
public void request() {
System.out.println("处理请求！");
}
}
3. Adapter.java
public class Adapter implements Target {
// 使用关联更灵活，这样适配器可以继承其他类
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public void handleRequest() {
adaptee.request();
}
}
4. Client.java
public class Client {
public void execute(Target target) {
target.handleRequest();
}
public static void main(String[] args) {
Target target = new Adapter();
new Client().execute(target);
}
}
应用场景
1. 做旧系统改造和升级。
2. java.io.InputStreamReader(InputStream)。
3. java.io.OutputStreamWriter(OutputStream)。
代理模式（Proxy）
效果
1. 通过代理，控制对对象的访问。
2. 可以详细控制访问某个（某类）对象的方法，在调用方法前做前置处理，调用方法后做后置处理（即APO的微观实现）。
3. AOP（Aspect Oriented Programming，面向切面编程）的核心实现机制。
核心角色
1. 抽象角色：定义代理角色和真实角色的公共对外方法。
2. 真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。
3. 代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己操作。
分类
1. 静态代理（静态定义代理类）。
2. 动态代理（动态定义代理类）：
a) JDK自带的动态代理（java.lang.reflect.Proxy动态生成代理类和对象，java.lang.reflect.InvocationHandler通过invoke()方法实现访问真实角色）；
b) javaassist字节码操作库实现；
c) CGLIB；
d) ASM（底层使用指令，可维护性较差）。
代码（静态代理）
1. Star.java
public interface Star {
void confer();
void signContract();
void bookTicket();
void sing();
void collectMoney();
}
2. RealStar.java
public class RealStar implements Star {
@Override
public void confer() {
System.out.println("RealStar.confer()");
}
@Override
public void signContract() {
System.out.println("RealStar.signContract()");
}
@Override
public void bookTicket() {
System.out.println("RealStar.bookTicket()");
}
@Override
public void sing() {
System.out.println("RealStar.sing()");
}
@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}
}
3. ProxyStar.java
public class ProxyStar implements Star {
private Star realStar;
public ProxyStar(Star realStar) {
this.realStar = realStar;
}
@Override
public void confer() {
System.out.println("ProxyStar.confer()");
}
@Override
public void signContract() {
System.out.println("ProxyStar.signContract()");
}
@Override
public void bookTicket() {
System.out.println("ProxyStar.bookTicket()");
}
@Override
public void sing() {
realStar.sing();
}
@Override
public void collectMoney() {
System.out.println("ProxyStar.collectMoney()");
}
}
4. Client.java
public class Client {
public static void main(String[] args) {
RealStar realStar = new RealStar();
ProxyStar proxyStar = new ProxyStar(realStar);
proxyStar.confer();
proxyStar.signContract();
proxyStar.bookTicket();
proxyStar.sing();
proxyStar.collectMoney();
}
}
代码（动态代理）
1. Star.java
public interface Star {
void confer();
void signContract();
void bookTicket();
void sing();
void collectMoney();
}
2. RealStar.java
public class RealStar implements Star {
@Override
public void confer() {
System.out.println("RealStar.confer()");
}
@Override
public void signContract() {
System.out.println("RealStar.signContract()");
}
@Override
public void bookTicket() {
System.out.println("RealStar.bookTicket()");
}
@Override
public void sing() {
System.out.println("RealStar.sing()");
}
@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}
}
3. StarHandler.java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method; public class StarHandler implements InvocationHandler { private Star realStar; public StarHandler(Star realStar) {
this.realStar = realStar;
} @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
switch (method.getName()) {
case "confer":
System.out.println("ProxyStar.confer()");
break;
case "signContract":
System.out.println("ProxyStar.signContract()");
break;
case "bookTicket":
System.out.println("ProxyStar.bookTicket()");
break;
case "sing":
method.invoke(realStar, args);
break;
case "collectMoney":
System.out.println("ProxyStar.collectMoney()");
break;
} return null;
} }
4. Client.java
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
Star realStar = new RealStar();
StarHandler handler = new StarHandler(realStar);
Star proxyStar = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[] { Star.class }, handler);
proxyStar.confer();
proxyStar.signContract();
proxyStar.bookTicket();
proxyStar.sing();
proxyStar.collectMoney();
}
}
应用场景
1. 安全代理：屏蔽对真实角色的直接访问。
2. 远程代理：通过代理类处理远程方法调用（RMI）。
3. 延迟代理：先加载轻量级代理对象，真正需要时再加载真实对象。
桥接模式（Bridge）
效果
1. 处理多层继承结构、处理多维变化的场景，将各个维度设计成独立的继承结构，使各个维度可以独立的扩展在抽象层建立关联。
2. 以商场系统中的电脑分类为例，多层继承不利于扩展性（类个数膨胀问题）：
a) 如果要增加一个新的电脑类型智能手机，则要增加各个品牌下面的类。
b) 如果要增加一个新的品牌，也要增加各种电脑类型的类。
3. 违反单一职责原则：比如一个联想笔记本，有两个引起这个类变化的原因。
4. 桥接模式将电脑拆分为类型和品牌两个维度。
代码
1. Computer.java
public abstract class Computer {
protected Brand brand;
public Computer(Brand brand) {
this.brand = brand;
}
public abstract void run();
}
class Desktop extends Computer {
public Desktop(Brand brand) {
super(brand);
}
@Override
public void run() {
System.out.println(brand.getName() + "台式机运行！");
}
}
class Laptop extends Computer {
public Laptop(Brand brand) {
super(brand);
}
@Override
public void run() {
System.out.println(brand.getName() + "笔记本运行！");
}
}
2. Brand.java
public interface Brand {
String getName();
}
class Lenovo implements Brand {
@Override
public String getName() {
return "联想";
}
}
class Dell implements Brand {
@Override
public String getName() {
return "戴尔";
}
}
3. Client.java
public class Client {
public static void main(String[] args) {
Brand brand = new Lenovo();
Computer computer = new Laptop(brand);
computer.run();
}
}
应用场景
1. JDBC驱动程序。
2. 银行日志管理。
a) 格式分类：操作日志、交易日志、异常日志。
b) 距离分类：本地记录日志、异地记录日志。
3. 人力资源系统的奖金计算模块。
a) 奖金分类：个人奖金、团体奖金、激励奖金。
b) 部门分类：人事部门、销售部门、研发部门。
4. OA系统的消息处理。
a) 业务类型：普通消息、加急消息、特急消息。
b) 发送消息方式：系统内消息、手机短信、邮件。
组合模式（Composite）
效果
1. 把部分和整理的关系用树形结构表示，从而使客户端可以使用统一方式处理部分对象和整体对象。
2. 组合模式为处理树形结构提供了完美的解决方案，描述了如何将容器和叶子进行递归组合，使得用户在使用时可以一致性的对待容器和叶子。
核心角色
1. 抽象构件角色（Component）：定义了叶子和容器构件的共同点。
2. 叶子构件角色（Leaf）：无子节点。
3. 容器构件角色（Composite）：有容器特征，可以包含子节点。
代码
Component.java
import java.util.List;
public interface Component {
void operation();
}
interface Leaf extends Component {
}
interface Composite extends Component {
void add(Component child);
void remove(Component child);
List<Component> getChildren();
}
代码（杀毒举例）
1. AbstractFile.java
import java.util.ArrayList;
import java.util.List; public interface AbstractFile { void killVirus(); } class File implements AbstractFile { private String name; public File(String name) {
this.name = name;
} @Override
public void killVirus() {
System.out.println(name + " 文件杀毒！");
} } class Folder implements AbstractFile { private String name;
private List<AbstractFile> children = new ArrayList<>(); public Folder(String name) {
this.name = name;
} public void add(AbstractFile child) {
children.add(child);
} public void remove(AbstractFile child) {
children.remove(child);
} @Override
public void killVirus() {
for (AbstractFile child : children) {
child.killVirus();
}
System.out.println(name + " 文件夹杀毒！");
} }
2. Client.java
public class Client {
public static void main(String[] args) {
Folder myDocument = new Folder("我的文档");
myDocument.add(new File("Client.java"));
myDocument.add(new File("index.php"));
myDocument.add(new File("老师.avi"));
Folder book = new Folder("图书");
book.add(new File("设计模式.pdf"));
book.add(new File("Hadoop权威指南.pdf"));
myDocument.add(book);
myDocument.killVirus();
}
}
应用场景
1. 操作系统的资源管理器。
2. GUI的容器层次图。
3. XML文件解析。
4. OA系统的组织结构处理。
5. JUnit单元测试框架：Test接口（抽象）、TestCase（叶子）、TestUnit（容器）。
装饰器模式（Decorator）
效果
1. 又称包装器模式（Wrapper）。
2. 动态的为一个对象增加新的功能。
3. 装饰器模式是一种用于代替继承的技术，无须通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。
4. 装饰器模式降低系统的耦合度，可以动态的增加或删除对象的职责，并使得需要装饰的具体构件类和具体装饰类可以独立变化，以便增加新的具体构件类和具体装饰类。
核心角色
1. 抽象构件角色（Component）：具体构件角色和装饰角色有相同的接口，客户端能够以与具体构件角色相同的方式同装饰角色交互。
2. 具体构件角色（ConcreteComponent）。
3. 装饰角色（Decorator）：持有一个抽象构件角色引用，接收所有客户端请求，并把这些请求转发给具体装饰角色。
4. 具体装饰角色（ConcreteDecorator）：给构件增加新功能。
代码
1. ICar.java
public interface ICar {
void move();
}
// 具体构建角色
class Car implements ICar {
@Override
public void move() {
System.out.println("陆地上跑！");
}
}
// 装饰器角色
abstract class SuperCar implements ICar {
private ICar car;
public SuperCar(ICar car) {
this.car = car;
}
public abstract void move();
}
class FlyCar extends SuperCar {
public FlyCar(ICar car) {
super(car);
}
@Override
public void move() {
super.move();
fly();
}
public void fly() {
System.out.println("天上飞！");
}
}
class WaterCar extends SuperCar {
public WaterCar(ICar car) {
super(car);
}
@Override
public void move() {
super.move();
swim();
}
public void swim() {
System.out.println("水上游！");
}
}
class AICar extends SuperCar {
public AICar(ICar car) {
super(car);
}
@Override
public void move() {
super.move();
autoMove();
}
public void autoMove() {
System.out.println("自动跑！");
}
}
2. Client.java
public class Client {
public static void main(String[] args) {
Car car = new Car();
car.move();
// 陆地上跑 + 天上飞
FlyCar flyCar = new FlyCar(car);
flyCar.move();
// 陆地上跑 + 水上游
WaterCar waterCar = new WaterCar(car);
waterCar.move();
// 陆地上跑 + 自动跑
AICar aiCar = new AICar(car);
aiCar.move();
// 陆地上跑 + 天上飞 + 水上游
WaterCar flyWaterCar = new WaterCar(flyCar);
flyWaterCar.move();
// 陆地上跑 + 天上飞 + 水上游 + 自动跑
AICar aiFlyWaterCar = new AICar(flyWaterCar);
aiFlyWaterCar.move();
}
}
应用场景
1. IO的InputStream、OutputStream、Reader、Writer的设计。
2. Servlet API的request对象的默认实现类HttpServletRequestWrapper。
外观模式（Facade）
效果
1. 为子系统提供统一的入口。封装子系统的复杂性，便于客户端调用。
2. 迪米特法则：一个软件实体应当尽可能少地与其他实体发生相互作用。
代码
1. Tea.java
public interface Tea {
String getName();
void drink();
}
2. WaitressFacade.java
public class WaitressFacade {
public Tea makeTea(String teaName) {
Water water = new Water("农夫山泉", 100.0);
Tea tea = null;
switch (teaName) {
case "西湖龙井":
tea = new XiHuLongJing();
break;
case "碧螺春":
tea = new BiLuoChun();
break;
case "铁观音":
tea = new TieGuanYin();
break;
default:
return null;
}
TeaSet teaSet = new TeaSet();
teaSet.cleanTeaSet(water);
teaSet.addTea(tea);
teaSet.cleanTea(water);
teaSet.makeTea(water);
return tea;
}
}
class Water {
private String name;
private Double temperature;
public Water(String name, Double temperature) {
this.name = name;
this.temperature = temperature;
}
public String getName() {
return name;
}
public Double getTemperature() {
return temperature;
}
}
class TeaSet {
private Tea tea;
public void cleanTeaSet(Water water) {
System.out.println("使用" + water.getTemperature() + "°的" + water.getName() + "烫洗茶具！");
}
public void addTea(Tea tea) {
System.out.println("投入" + tea.getName() + "！");
this.tea = tea;
}
public void cleanTea(Water water) {
System.out.println("使用" + water.getTemperature() + "°的" + water.getName() + "洗茶！");
}
public Tea makeTea(Water water) {
System.out.println("使用" + water.getTemperature() + "°的" + water.getName() + "泡茶！");
return tea;
}
}
class XiHuLongJing implements Tea {
@Override
public String getName() {
return "西湖龙井";
}
@Override
public void drink() {
System.out.println("品" + getName() + "！");
}
}
class BiLuoChun implements Tea {
@Override
public String getName() {
return "洞庭碧螺春";
}
@Override
public void drink() {
System.out.println("品" + getName() + "！");
}
}
class TieGuanYin implements Tea {
@Override
public String getName() {
return "安溪铁观音";
}
@Override
public void drink() {
System.out.println("品" + getName() + "！");
}
}
3. Client.java
public class Client {
public static void main(String[] args) {
WaitressFacade waitressFacade = new WaitressFacade();
Tea tea = waitressFacade.makeTea("铁观音");
tea.drink();
}
}
应用场景
1. 频率很高，处处用到。
2. JDBC封装后的DbUtils类。
3. Hibernate提供的工具类。
4. Spring JDBC工具类等。
享元模式（FlyWeight）
效果
1. 享元模式以共享的方式高效地支持大量细粒度对象的重用。
a) 内存属于稀缺资源，不要随便浪费。如果有很多个完全相同或相似的对象，我们可以通过享元模式节省内存。
b) 用时间换取空间。
2. 享元对象能做到共享的关键是区分了内部状态和外部状态。
a) 内部状态：可以共享，不会随环境变化而变化。
b) 外部状态：不可以共享，会随环境变化而变化。
核心角色
1. 享元工厂类（FlyWeightFactory）：创建并管理享元对象，享元池一般设计成键值对。
2. 抽象享元类（FlyWeight）：通常是一个接口或抽象类，声明公共方法向外界提供对象的内部状态、设置外部状态。
3. 具体享元类（ConcreteFlyWeight）：为内部状态提供成员变量进行存储。
4. 非共享享元类（UnsharedConcreteFlyWeight）：不能被共享的子类可以设计为非共享享元类。
代码
1. ChessFlyWeight.java
// 抽象享元类
public interface ChessFlyWeight { String getColor(); void display(Position position); }
2. Position.java
// 非共享享元类
public class Position { private int x; private int y; public Position(int x, int y) {
this.x = x;
this.y = y;
} public int getX() {
return x;
} public int getY() {
return y;
} }
3. ConcreteChess.java
// 具体享元类
public class ConcreteChess implements ChessFlyWeight { private String color; public ConcreteChess(String color) {
this.color = color;
} @Override
public String getColor() {
return color;
} @Override
public void display(Position position) {
System.out.println("显示：颜色" + color + "，位置(" + position.getX() + "," + position.getY() + ")！");
} }
4. ChessFactory.java
import java.util.HashMap;
import java.util.Map; // 享元工厂类
public class ChessFactory { private static Map<String, ChessFlyWeight> chesses = new HashMap<>(); public static ChessFlyWeight getChess(String color) {
ChessFlyWeight chess = chesses.get(color);
if (chess != null) {
return chess;
}
chess = new ConcreteChess(color);
chesses.put(color, chess);
return chess;
} }
5. Client.java
public class Client {
public static void main(String[] args) {
ChessFlyWeight chess1 = ChessFactory.getChess("黑");
ChessFlyWeight chess2 = ChessFactory.getChess("黑");
System.out.println(chess1 == chess2);
chess1.display(new Position(10, 20));
chess1.display(new Position(20, 10));
}
}
应用场景
1. 享元模式由于共享的特性，可以应用与任何“池”，比如线程池、数据库连接池。
2. String类的设计。
行为型模式
责任链模式（Chain of Resposibility）
效果
1. 将能够处理同一类请求的对象连成一条链，所提交的请求沿着链传递，链上的对象逐个判断是否有能力处理该请求，如果能则处理，否则传递给链上的下一个对象。
2. 请假条审批过程：天数小于3天，主任审批；大于等于3天，小于10天，经理审批；大于等于10天，小于30天，总经理审批；大于等于30天，拒绝。
核心角色
1. 责任链既可以通过LinkedList实现，也可以通过ArrayList实现。
2. 可事先定义好责任链存储到配置文件或数据库。
代码
1. LeaveRequest.java
public class LeaveRequest {
private String name;
private int leaveDays;
private String reason;
public LeaveRequest(String name, int leaveDays, String reason) {
this.name = name;
this.leaveDays = leaveDays;
this.reason = reason;
}
public String getName() {
return name;
}
public int getLeaveDays() {
return leaveDays;
}
public String getReason() {
return reason;
}
}
2. Leave.java
public abstract class Leader {
protected String name;
protected Leader nextLeader;
public Leader(String name) {
this.name = name;
}
public void setNextLeader(Leader nextLeader) {
this.nextLeader = nextLeader;
}
public abstract void handleRequest(LeaveRequest leaveRequest);
}
class Director extends Leader {
public Director(String name) {
super(name);
}
@Override
public void handleRequest(LeaveRequest leaveRequest) {
if (leaveRequest.getLeaveDays() < 3) {
System.out.println("主任" + name + "审批通过！");
} else if (nextLeader != null) {
nextLeader.handleRequest(leaveRequest);
}
}
}
class Manager extends Leader {
public Manager(String name) {
super(name);
}
@Override
public void handleRequest(LeaveRequest leaveRequest) {
if (leaveRequest.getLeaveDays() < 10) {
System.out.println("经理" + name + "审批通过！");
} else if (nextLeader != null) {
nextLeader.handleRequest(leaveRequest);
}
}
}
class GeneralManager extends Leader {
public GeneralManager(String name) {
super(name);
}
@Override
public void handleRequest(LeaveRequest leaveRequest) {
if (leaveRequest.getLeaveDays() < 30) {
System.out.println("总经理" + name + "审批通过！");
} else {
System.out.println("不通过！");
}
}
}
3. Client.java
public class Client {
public static void main(String[] args) {
Leader director = new Director("张三");
Leader manager = new Manager("李四");
Leader generalManager = new GeneralManager("王五");
director.setNextLeader(manager);
manager.setNextLeader(generalManager);
LeaveRequest leaveRequest = new LeaveRequest("Tom", 5, "回英国老家。");
director.handleRequest(leaveRequest);
}
}
应用场景
1. Java的异常捕获，try可对应多个catch，当第一个catch不匹配，则自动跳到第二个catch。
2. JavaScript的事件冒泡和捕获机制。
3. Servlet开发中，过滤器的链式处理。
迭代器模式（Iterator）
效果
1. 又称游标模式（Cursor）。
2. 提供一种可以遍历聚合对象的方式。
核心角色
1. 聚合对象（Aggregate）：存储数据。
2. 迭代器（Iterator）：遍历数据的算法，比如正序、倒序、随机等。
代码
1. Iterator.java
public interface Iterator {
boolean hasNext();
Object next();
}
2. Aggregate.java
public interface Aggregate {
void add(Object element);
void remove(Object element);
Iterator iterator();
}
3. ConcreteAggregate.java
import java.util.ArrayList;
import java.util.List; public class ConcreteAggregate implements Aggregate { private List<Object> list = new ArrayList<>(); @Override
public void add(Object element) {
list.add(element);
} @Override
public void remove(Object element) {
list.remove(element);
} @Override
public Iterator iterator() {
return new ConcreteAggregateIterator();
} // 定义成内部类，可直接访问外部类的属性
private class ConcreteAggregateIterator implements Iterator { private int cursor = -1; @Override
public boolean hasNext() {
return cursor < list.size() - 1;
} @Override
public Object next() {
cursor++;
return list.get(cursor);
} } }
4. Client.java
public class Client {
public static void main(String[] args) {
Aggregate aggregate = new ConcreteAggregate();
aggregate.add("A");
aggregate.add("B");
aggregate.add("C");
aggregate.add("D");
aggregate.add("E");
Iterator iterator = aggregate.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
应用场景
JDK内置的迭代器。
中介者模式（Mediator）
效果
1. 如果一个系统中对象之间的联系呈现为网状结构，对象之间存在大量多对多关系，将导致关系及其复杂，这些对象称为“同事对象”。
2. 引入一个中介者对象，使各同事对象只跟中介者对象打交道，将复杂的网状结构解耦成星状结构。
3. 解耦多个同事对象之间的交互关系。每个对象都持有中介者对象的引用，只跟中介者对象打交道。我们通过中介者对象统一管理这些交互关系。
代码
1. 公司有总经理，各个部门有事情都通报给总经理，总经理再通知各个相关部门。总经理起到中介、协调作用。
2. Colleague.java
public interface Colleague {
void selfAction();
void outAction();
}
3. Mediator.java
public interface Mediator {
void register(String name, Colleague colleague);
void command(String name);
}
4. DevelopmentDepartment.java
public class DevelopmentDepartment implements Colleague {
private Mediator mediator;
public DevelopmentDepartment(Mediator mediator) {
this.mediator = mediator;
mediator.register("研发部", this);
}
@Override
public void selfAction() {
System.out.println("专心研发！");
}
@Override
public void outAction() {
System.out.println("研发部向总经理汇报：需要资金支持！");
mediator.command("财务部");
}
}
5. MarcketDepartment.java
public class MarcketDepartment implements Colleague {
private Mediator mediator;
public MarcketDepartment(Mediator mediator) {
this.mediator = mediator;
mediator.register("市场部", this);
}
@Override
public void selfAction() {
System.out.println("专心接项目");
}
@Override
public void outAction() {
System.out.println("市场部向总经理汇报：需要资金支持！");
}
}
6. FinacialDepartment.java
public class FinacialDepartment implements Colleague {
private Mediator mediator;
public FinacialDepartment(Mediator mediator) {
this.mediator = mediator;
mediator.register("财务部", this);
}
@Override
public void selfAction() {
System.out.println("专心数钱！");
}
@Override
public void outAction() {
System.out.println("财务部向总经理汇报：钱太多，花不完！");
mediator.command("市场部");
}
}
7. GeneralManager.java
import java.util.HashMap;
import java.util.Map; public class GeneralManager implements Mediator { private Map<String, Colleague> colleagues = new HashMap<>(); @Override
public void register(String name, Colleague colleague) {
colleagues.put(name, colleague);
} @Override
public void command(String name) {
colleagues.get(name).outAction();
} }
8. Client.java
public class Client {
public static void main(String[] args) {
Mediator generalManager = new GeneralManager();
Colleague developmentDepartment = new DevelopmentDepartment(generalManager);
Colleague marcketDepartment = new MarcketDepartment(generalManager);
Colleague finacialDepartment = new FinacialDepartment(generalManager);
developmentDepartment.selfAction();
developmentDepartment.outAction();
}
}
应用场景
1. MVC模式的C是中介者对象，M和V都和他打交道。
2. GUI中，多个组件之间交互，可以引入一个中介者对象（整体窗口对象或DOM对象）。
3. java.lang.reflect.Method#invoke()。
命令模式（Command）
效果
1. 又称“动作模式（Action）、事务模式（Transaction）。
2. 将一个请求封装成一个对象，从而使我们可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。
核心角色
1. 抽象命令类（Command）。
2. 具体命令类（ConcreteCommand）。
3. 调用者/请求者（Invoker）：请求的发送者，通过命令对象来执行请求。调用者并不需要在设计时确定接收者，而是在运行时，调用命令对象的execute()，间接调用接
收者的相关操作。
4. 接收者（Receiver）：执行与请求相关的操作，具体实现对请求的业务处理。
代码
1. Command.java
public interface Command {
// 实际中可设计多个方法
void execute();
}
2. ConcreteCommand.java
public class ConcreteCommand implements Command {
private Receiver receiver;
public ConcreteCommand(Receiver receiver) {
this.receiver = receiver;
}
@Override
public void execute() {
// 可在执行前后做其他操作，比如记录日志
receiver.action();
}
}
3. Invoker.java
public class Invoker {
// 也可以是多条命令，类似数据库事务中的多条命令
private Command command;
public Invoker(Command command) {
this.command = command;
}
public void call() {
command.execute();
}
}
4. Receiver.java
public class Receiver {
public void action() {
System.out.println("Receiver.action()");
}
}
5. Client.java
public class Client {
public static void main(String[] args) {
Command command = new ConcreteCommand(new Receiver());
Invoker invoker = new Invoker(command);
invoker.call();
}
}
应用场景
数据库事务机制的底层实现。
解释器模式（Interpreter）
效果
1. 不常用的设计模式。
2. 用于描述如何构成一个简单的语言解释器，主要用于使用面向对象语言开发的编译器和解释器设计。
3. 尽量不要使用解释器模式，后期维护非常麻烦。在项目中，可以使用JRuby、Groovy、Java的JavaScript引擎来代替解释器，弥补Java语言不足。
应用场景
1. EL表达式的处理。
2. 正则表达式解释器。
3. SQL语法解释器。
4. 数学表达式解析器，如工具包Math Expression String Parser、Expression4J。
访问者模式（Visitor）
效果
1. 不常用的设计模式。
2. 对于存储在一个集合中的对象，他们可能具有不同的类型（即使有一个公共的接口），对于该集合中的对象，可以接收一类称为访问者的对象来访问，不同的访问者其访问方式也有所不同。
3. 表示一个作用于某对象结构中各元素的操作，使我们可以不在改变元素类的前提下定义作用于这些元素的新操作。
应用场景
1. XML文档解析器设计。
2. 编译器的设计。
3. 复杂集合对象的处理。
策略模式（Strategy）
效果
1. 策略模式对应于解决某一个问题的一个算法族，允许客户端从该算法族中任选一个算法解决问题，同时可以方便更换算法或添加新的算法。
2. 本质：分离算法，选择实现。
代码
1. 某个市场人员接到单后的报销策略（CRM系统的常见问题）。报价策略很复杂：
a) 普通客户小批量报价；
b) 普通客户大批量报价；
c) 老客户小批量报价；
d) 老客户大批量报价。
2. Strategy.java
public interface Strategy {
double getPrice(double standardPrice);
}
3. Context.java
// 负责与具体的策略类交互，将客户端与算法分离
public class Context { private Strategy strategy; public Context(Strategy strategy) {
this.strategy = strategy;
} public void printPrice(double standardPrice) {
System.out.println(strategy.getPrice(standardPrice));
} }
4. NewCustomerFewStrategy.java
public class NewCustomerFewStrategy implements Strategy {
@Override
public double getPrice(double standardPrice) {
System.out.println("不打折！");
return standardPrice;
}
}
5. NewCustomerManyStrategy.java
public class NewCustomerManyStrategy implements Strategy {
@Override
public double getPrice(double standardPrice) {
System.out.println("打九折！");
return standardPrice * 0.9;
}
}
6. OldCustomerFewStrategy.java
public class OldCustomerFewStrategy implements Strategy {
@Override
public double getPrice(double standardPrice) {
System.out.println("打八五折！");
return standardPrice * 0.85;
}
}
7. OldCustomerManyStrategy.java
public class OldCustomerManyStrategy implements Strategy {
@Override
public double getPrice(double standardPrice) {
System.out.println("打八折！");
return standardPrice * 0.8;
}
}
8. Client.java
public class Client {
public static void main(String[] args) {
Strategy strategy = new OldCustomerManyStrategy(); // 可通过配置生成
Context context = new Context(strategy);
context.printPrice(998);
}
}
应用场景
1. Java的GUI编程，布局管理。
2. Spring框架的Resource接口，资源访问策略。
3. javax.servlet.http.HttpServlet#service()。
模板方法模式（Template Method）
效果
1. 常用的模式。
2. 模板方法定义一个操作的算法框架，将某些步骤延迟到子类中实现。这样，新的子类可以在不改变算法结构的前提下，重新定义该算法的某些特定步骤。
代码
1. BankTemplateMethod.java
public abstract class BankTemplateMethod {
protected void takeNumber() {
System.out.println("取号！");
}
protected void waitInLine() {
System.out.println("排队！");
}
// 钩子方法/回调方法：办理具体业务
protected abstract void transaction();
protected void evaluate() {
System.out.println("评分！");
}
// 模板方法
public final void process() {
takeNumber();
waitInLine();
transaction();
evaluate();
}
}
2. DrawMoney.java
public class DrawMoney extends BankTemplateMethod {
@Override
protected void transaction() {
System.out.println("取款！");
}
}
3. Client.java
public class Client {
public static void main(String[] args) {
BankTemplateMethod drawMoney = new DrawMoney();
drawMoney.process();
// 匿名内部类实现
new BankTemplateMethod() {
@Override
protected void transaction() {
System.out.println("存款！");
}
}.process();;
}
}
应用场景
1. 各框架、类库都有模板方法。
2. 数据库访问的封装。
3. JUnit单元测试。
4. Servlet的doGet()和doPost()方法调用。
5. Spring的JDBCTemplate、HibernateTemplate。
状态模式（State）
效果
1. 用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题。
2. 酒店系统中，房间的状态变化。
核心角色
1. 上下文类（Context）：环境类中维护一个State对象，定义了当前的状态。
2. 抽象状态类（State）。
3. 具体状态类（ConcreteState）：每一个类封装了一个状态对应的行为。
代码
1. State.java
public interface State {
void handle();
}
2. RoomContext.java
public class RoomContext {
private State state;
public State getState() {
return state;
}
public void setState(State state) {
this.state = state;
state.handle();
}
}
3. FreeState.java
public class FreeState implements State {
@Override
public void handle() {
System.out.println("退出房间！");
}
}
4. BookedState.java
public class BookedState implements State {
@Override
public void handle() {
System.out.println("预定房间！");
}
}
5. CheckedInState.java
public class CheckedInState implements State {
@Override
public void handle() {
System.out.println("入住房间！");
}
}
6. Client.java
public class Client {
public static void main(String[] args) {
RoomContext context = new RoomContext();
context.setState(new FreeState());
context.setState(new BookedState());
context.setState(new CheckedInState());
}
}
应用场景
1. 银行系统的账号状态管理。
2. OA系统的公文状态管理。
3. 酒店系统的房间状态管理。
4. 线程对象各状态之间的切换。
观察者模式（Observer）
效果
1. 观察者模式用于1:N的消息通知。
2. 当目标对象（Subject或Observable）的状态变化（消息发布）时，他及时告知一系列观察者对象（Observer），令他们做出相应（消息订阅）。
3. 通知观察者的方式：
a) 推：每次都会把消息以广播方式发送给所有观察者，所有观察者只能被动接收。
b) 拉：观察者只要知道有变化即可，什么时候获取消息、获取什么内容，都由观察者自主决定。
代码
1. Subject.java
import java.util.ArrayList;
import java.util.List; public abstract class Subject { private List<Observer> observers = new ArrayList<>(); public void subscribe(Observer observer) {
observers.add(observer);
} public void unsubscribe(Observer observer) {
observers.remove(observer);
} public void notifyAllObservers() {
for (Observer observer : observers) {
observer.update(this);
}
} }
2. ConcreteSubject.java
public class ConcreteSubject extends Subject {
private int state;
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
notifyAllObservers();
}
}
3. Observer.java
public interface Observer {
void update(Subject subject);
}
4. ConcreteObserver.java
public class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
@Override
public void update(Subject subject) {
System.out.println(name + "收到消息：state=" + ((ConcreteSubject) subject).getState());
}
}
5. Client.java
public class Client {
public static void main(String[] args) {
ConcreteSubject subject = new ConcreteSubject();
Observer observer1 = new ConcreteObserver("张三");
Observer observer2 = new ConcreteObserver("李四");
Observer observer3 = new ConcreteObserver("王五");
subject.subscribe(observer1);
subject.subscribe(observer2);
subject.subscribe(observer3);
subject.setState(1);
subject.setState(2);
}
}
代码（基于JDK）
1. ConcreteSubject.java
import java.util.Observable;
public class ConcreteSubject extends Observable {
private int state;
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
// 目标对象已变化
setChanged();
// 通知观察者
notifyObservers(state);
}
}
2. ConcreteObserver.java
import java.util.Observable;
import java.util.Observer; public class ConcreteObserver implements Observer { private String name; public ConcreteObserver(String name) {
this.name = name;
} @Override
public void update(Observable observable, Object arg) {
ConcreteSubject subject = (ConcreteSubject) observable;
System.out.println(name + "收到消息：" + arg);
System.out.println(name + "获取最新状态：" + subject.getState());
} }
3. Client.java
import java.util.Observer;
public class Client {
public static void main(String[] args) {
ConcreteSubject subject = new ConcreteSubject();
Observer observer1 = new ConcreteObserver("张三");
Observer observer2 = new ConcreteObserver("李四");
Observer observer3 = new ConcreteObserver("王五");
subject.addObserver(observer1);
subject.addObserver(observer2);
subject.addObserver(observer3);
subject.setState(1);
subject.setState(2);
}
}
应用场景
1. 聊天室，服务器转发给所有客户端。
2. 网络游戏多人联机对战，服务器将客户端的状态进行分发。
3. 邮件订阅。
4. Servlet编程，监听器的实现。
5. Android，广播机制。
6. 京东商城，群发某商品打折信息。
备忘录模式（Memento）
效果
保存某个对象内部状态的拷贝，以后可以将该对象恢复到原先状态。
核心角色
1. 源发器类（Originator）：负责创建一个备忘录类，用以记录当前内部状态，并可使用备忘录恢复内部状态。
2. 备忘录类（Memento）：负责存储源发器类的内部状态，并可防止源发器类以外的其他对象访问备忘录类。
3. 负责人类（CareTaker）：负责保存好备忘录，备忘点较多时，可用List或Stack存储。也可以持久化。
代码
1. Employee.java
// 源发器类
public class Employee { private String name; private int age; private double salary; public Employee(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
} // 备忘
public EmployeeMemento memento() {
return new EmployeeMemento(this);
} // 恢复
public void recover(EmployeeMemento employeeMemento) {
this.name = employeeMemento.getName();
this.age = employeeMemento.getAge();
this.salary = employeeMemento.getSalary();
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} public double getSalary() {
return salary;
} public void setSalary(double salary) {
this.salary = salary;
} @Override
public String toString() {
return "name=" + name + ",age=" + age + ",salary=" + salary;
} }
2. EmployeeMemento.java
public class EmployeeMemento {
private String name;
private int age;
private double salary;
public EmployeeMemento(Employee employee) {
this.name = employee.getName();
this.age = employee.getAge();
this.salary = employee.getSalary();
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public double getSalary() {
return salary;
}
}
3. EmployeeCareTaker.java
import java.util.ArrayList;
import java.util.List; public class EmployeeCareTaker { private List<EmployeeMemento> mementoes = new ArrayList<>(); public void addMemento(EmployeeMemento mementoe) {
mementoes.add(mementoe);
} public EmployeeMemento getMemento(int index) {
return mementoes.get(index);
} public EmployeeMemento getLastMemento() {
return getMemento(mementoes.size() - 1);
} }
4. Client.java
public class Client {
public static void main(String[] args) {
EmployeeCareTaker careTaker = new EmployeeCareTaker();
Employee employee = new Employee("张三", 18, 1000);
System.out.println(employee);
careTaker.addMemento(employee.memento());
employee.setAge(20);
employee.setSalary(3000);
System.out.println(employee);
careTaker.addMemento(employee.memento());
employee.setAge(21);
System.out.println(employee);
employee.recover(careTaker.getLastMemento());
System.out.println(employee);
}
}
应用场景
1. 棋类游戏的悔棋。
2. 编辑软件的撤销操作。
3. 数据库的事务回滚操作。
4. Photoshop的历史版本记录。
作者：netoxi
出处：http://www.cnblogs.com/netoxi
本文版权归作者和博客园共有，欢迎转载，未经同意须保留此段声明，且在文章页面明显位置给出原文连接。欢迎指正与交流。
设计模式笔记——GoF设计模式汇总的更多相关文章
- [设计模式] .NET设计模式笔记 - 了解设计模式
今天在TerryLee的cnblog(http://terrylee.cnblogs.com)里看到了与设计模式相关的整套文章,初学设计模式看完每篇文章后做些笔记和摘抄. ●什么是设计模式,什么是架构 ...
- 【设计模式】GoF设计模式学习总结
什么是设计模式 为解决某一类普遍存在的问题而提供的一种解决方案: 分类及定义 创建型模式(5) 1.原型模式:通过复制一个已存在对象来生成一个新对象,被复制的对象称为原型:详情... 2.单例模式:一 ...
- 【设计模式】GOF设计模式趣解（23种设计模式）
创建型模式 1.FACTORY—追MM少不了请吃饭了,麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西,虽然口味有所不同,但不管你带MM去麦当劳或肯德基,只管向服务员说 ...
- python 学习 设计模式（goF设计模式）
一 单例模式 用来创建单个实例 #/usr/bin/env python3 # -*- coding:utf-8 -*- # Author: ZSHAOX class Foo: instance = ...
- grasp设计模式笔记回顾
根据讲师所讲做了一下笔记以便自己能方便学习: ------------------------------------------grasp设计模式: grasp(general responsibi ...
- <大话设计模式>笔记
读完了<大话设计模式>这本书,收获很多,对程序设计有了很多新的理解.将每章模式的大概要点做了些笔记以备查阅,一些设计模式书读完也对其了解得不是很透彻,需要以后在实践中来不断地加深理解吧.读 ...
- GOF设计模式特烦恼
这段时间,学习状态比较一般,空闲时基本都在打游戏,和研究如何打好游戏,终于通过戏命师烬制霸LOL,玩笑了.为了和"学习"之间的友谊小船不翻,决定对以往学习过的GOF设计模式做一个简 ...
- 在GoF设计模式
在GoF设计模式中,结构型模式有: 1.适配器模式 Adapter 适配器模式是将一个类的接口转换成客户希望的另外一个接口.适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作. ...
- Asp.net设计模式笔记之一：理解设计模式
GOF设计模式著作中的23种设计模式可以分成三组:创建型(Creational),结构型(Structural),行为型(Behavioral).下面来做详细的剖析. 创建型 创建型模式处理对象构造和 ...
随机推荐
- jquery里的attr()方法和prop()方法的区别
在jq的高版本里出现了prop()方法,那么attr()和prop()的区别在哪呢?这两者分别在什么情况用呢? 对于HTML元素本身就带有的固有属性,在处理时,使用prop方法. 对于HTML元素我们 ...
- Array和ArrayList的区别与联系
博主今天去了一个java的实习面试,发现有好多java最基础的数据结构对于博主来说反而感到陌生,在面试官问一些常见的例如HashMap这样的数据结构,博主能回答的头头是道,但是在问到Array和Arr ...
- Kafka 源代码分析之FileMessageSet
这里主要分析FileMessageSet类 这个类主要是管理log消息的内存对象和文件对象的类.源代码文件在log目录下.这个类被LogSegment类代理调用用来管理分片. 下面是完整代码.代码比较 ...
- 【Android Developers Training】 26. 在SQL数据库中保存数据
注:本文翻译自Google官方的Android Developers Training文档,译者技术一般,由于喜爱安卓而产生了翻译的念头,纯属个人兴趣爱好. 原文链接:http://developer ...
- [图形学] 计算机图形学 with OpenGL开篇
<计算机图形学>(第四版)正在学习中,学习目的是为了在Unity中使用shader实现不同的渲染效果. 希望在这里能把学习过程中学到的知识和遇到的问题记录下来. 工作环境是:Xcode 8 ...
- NodeJS中的http模块
利用http模块,nodejs可以开发服务器, 极大简化服务器的创建: var http = require("http"); //创建服务器 var server = http. ...
- springmvc(四) springmvc的数据校验的实现
so easy~ --WH 一.什么是数据校验? 这个比较好理解,就是用来验证客户输入的数据是否合法,比如客户登录时,用户名不能为空,或者不能超出指定长度等要求,这就叫做数据校验. 数据校验分为客户端 ...
- js验证身份证号码
function IdentityCodeValid(code) { var city={11:"北京",12:"天津",13:"河北",1 ...
- PHPOffice/PHPExcel生成省市区三级联动的excel表格
最近公司需要用到一个省市区三级联动的excel表格,但是数据都在数据库,又太多,人工不好制作,就让我这个phper来帮忙啦. 主要用到的是excel的定义名称,数据验证.其中数据验证的列表只能是一列或 ...
- 深入理解Java内部类
内部类就是定义在一个类中的另外一个类,是一种从属关系.在没有实际了解内部类之前,我始终困惑,为什么要在一个类中定义另外一个类,这不是增加代码结构复杂度么?现在才大致能知道这种设计的优势是大于 ...