GOF23种设计模式在Java中的应用（part 1）

最新推荐文章于 2024-05-13 14:12:48 发布

xiaomifeng1010

最新推荐文章于 2024-05-13 14:12:48 发布

阅读量1.1k

点赞数 1

分类专栏：设计模式和设计原则文章标签： Java基础设计模式 GOF23种设计模式 Java设计模式

本文链接：https://blog.csdn.net/u011174699/article/details/87561148

版权

设计模式和设计原则专栏收录该内容

4 篇文章 0 订阅

订阅专栏

第二部分：GOF23种设计模式在Java中的应用（part 2）

一、GOF来源及简介

1.1 GOF23种设计模式简介

《Design Patterns: Elements of Reusable Object-Oriented Software》（即后述《设计模式》一书），由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 合著（Addison-Wesley出版社，1995）。这几位作者常被称为"四人组（Gang of Four），在《设计模式》这本书的最大部分是一个目录，该目录列举并描述了 23 种设计模式，非常经典。

1.2 GOF23种设计模式分类：

创建型模式：

单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。

结构型模式：

适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

行为型模式：

模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

二、GOF23种设计模式详细内容

2.1 单例模式

2.1 .1单例模式定义

定义：确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

一个类只能产生一个对象，该怎么实现呢？对象产生是通过new关键字完成的（也有其他方法，如对象复制，反射等），那么如何控制呢？在创建对象，调用对应构造函数，那么把构造函数的权限设置为private私有访问权限就可以禁止外部创建对象。

2.1.2 单例模式的优点：

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决（在JavaEE中采用单例模式时需要注意JVM垃圾回收机制）。

单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

2.1.3 单例模式的缺点：

单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。单例模式为什么不能增加接口呢？因为接口对单例模式没有任何意义的，它要求“自行实例化”，并且提供单一的实例、接口或抽象类是不可能被实例化的。淡然了，在特殊情况下，单例模式可以实现接口、被继承等，需要在系统开发中根据环境判断。

单例模式对测试时不利的。在并行开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能使用mock的方式虚拟一个对象。

单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是单例取决于环境，单例模式把

“要单例”和业务逻辑融合在一个类中。

2.1.4 单例模式的使用场景

在一个系统中，要求一个类有且只有一个对象，如果出现多个对象，就会出现“不良反应”，可以采用单利模式，具体场景如下：

要求生成唯一序列号的环境。

在整个项目中需要一个共享访问点或者共享数据，例如一个web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保线程是安全的。

创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源。

需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（当然，也可以直接声明为static的方式）。

2.1.5 单例模式使用注意事项

首先，在高并发情况下，请注意单例模式的线程同步问题。单例模式有几种不同的实现方式，例如下面的情况是需要考虑线程同步：

public class Singleton{

    private static Singleton singleton= null;

    //限制产生多个对象

    private Singleton(){

    }

    //通过该方法获得实例对象

    public static Singleton getInstance(){

        if(singleton==null){

            singleton=new Singleton();

            }

            return singleton;

    }

}

该单例模式在低并发的情况下尚不会出现问题，若系统压力增大，并发量增加时则可能在内存中出现多个实例，破坏了最初的预期。为什么会出现这种情况呢？如一个线程A执行到singleton=new Singleton().但是还没有获得对象（对象初始化时需要时间的），第二个线程B也在执行，执行到（singleton==null）判断，那么线程B判断条件也是为真，于是继续运行下去，线程A获得了一个对象，线程B也获得了另一个对象，在内存中出现了两个不同的对象！

解决线程不安全的方法有很多，可以在getInstance方法前加上synchronized关键字，

其次要考虑对象复制的情况，在java中，对象默认是不可以被复制的，若实现了Cloneable接口，并实现了clone方法，则可以直接通过对象法制方式创建一个新对象，对象复制是不用调用类的构造函数，因此即使是私有的构造函数，对象仍然可以被复制。在一般情况下，类复制的情况不需要考虑，很少会出现一个单例类会主动要求被复制的情况，解决该问题的最好方法就是单例类不要事先Cloneable接口。

2.1.6 常见的五种单例模式实现方式：

– 主要：
• 饿汉式（线程安全，调用效率高。但是，不能延时加载。）
• 懒汉式（线程安全，调用效率不高。但是，可以延时加载。）
– 其他：
• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
• 静态内部类式(线程安全，调用效率高。但是，可以延时加载)
• 枚举单例(线程安全，调用效率高，不能延时加载)

2.1.6.1 饿汉式实现（单例对象立即加载）

public class SingletonDemo02 {
private static /*final*/ SingletonDemo02 s = new SingletonDemo02();
private SingletonDemo02(){} //私有化构造器
public static /*synchronized*/ SingletonDemo02 getInstance(){
return s;
}
}

public class Client {
public static void main(String[] args) {
SingletonDemo02 s = SingletonDemo02.getInstance();
SingletonDemo02 s2 = SingletonDemo02.getInstance();
System.out.println(s==s2); //结果为true
}
}

饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问
题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字。
• 问题：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！

2.1.6.2 懒汉式实现（单例对象延迟加载）

public class SingletonDemo01 {
private static SingletonDemo01 s;
private SingletonDemo01(){} //私有化构造器
public static synchronized SingletonDemo01 getInstance(){
if(s==null){
s = new SingletonDemo01();
}
return s;
}
}

要点：
– lazy load! 延迟加载，懒加载！真正用的时候才加载！
• 问题：
– 资源利用率高了。但是，每次调用getInstance()方法都要同步，并发
效率较低。

2.1.6.3 双重检测锁实现

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

这个模式将同步内容下方到if内部，提高了执行的效率不必每次获取对象时都进行同步，只有第一次才同步创建了以后就没必要了。

问题：
• 由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题。不建议使用。

2.1.6.4 静态内部类实现方式(也是一种懒加载方式)

public class SingletonDemo04 {
private static class SingletonClassInstance {
private static final SingletonDemo04 instance = new SingletonDemo04();
}
public static SingletonDemo04 getInstance() {
return SingletonClassInstance.instance;
}
private SingletonDemo04() {
}
}

要点：
– 外部类没有static属性，则不会像饿汉式那样立即加载对象。
– 只有真正调用getInstance(),才会加载静态内部类。加载类时是线程安全的。 instance是static final
类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性.
– 兼备了并发高效调用和延迟加载的优势！

问题：
– 反射可以破解上面几种(不包含枚举式)实现方式！（可以在构造方法中手动
抛出异常控制）
– 反序列化可以破解上面几种((不包含枚举式))实现方式！
• 可以通过定义readResolve()防止获得不同对象。
– 反序列化时，如果对象所在类定义了readResolve()，（实际是一种回调），
定义返回哪个对象。

public class SingletonDemo01 implements Serializable {
private static SingletonDemo01 s;
private SingletonDemo01() throws Exception{
if(s!=null){
throw new Exception("只能创建一个对象");
//通过手动抛出异常，避免通过反射创建多个单例对象！
}
} //私有化构造器
public static synchronized SingletonDemo01 getInstance() throws Exception{
if(s==null){
s = new SingletonDemo01();
}r
eturn s;
}
//反序列化时，如果对象所在类定义了readResolve()，（实际是一种回调），定义返回哪个对象。
private Object readResolve() throws ObjectStreamException {
return s;
}
}

2.1.6.5 使用枚举实现单例模式

public enum SingletonDemo05 {
/**
* 定义一个枚举的元素，它就代表了Singleton的一个实例。
*/
INSTANCE;
/**
* 单例可以有自己的操作
*/
public void singletonOperation(){
//功能处理
}
}

public static void main(String[] args) {
SingletonDemo05 sd = SingletonDemo05.INSTANCE;
SingletonDemo05 sd2 = SingletonDemo05.INSTANCE;
System.out.println(sd==sd2);
}

优点：
– 实现简单
– 枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！
• 缺点：
– 无延迟加载

常见的五种单例模式在多线程环境下的效率测试

– 大家只要关注相对值即可。在不同的环境下不同的程序测得值完全不一样
• CountDownLatch
– 同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一
个或多个线程一直等待。
• countDown() 当前线程调此方法，则计数减一(建议放在 finally里执行)
• await()，调用此方法会一直阻塞当前线程，直到计时器的值为0

常见的五种单例模式实现方式
– 主要：
• 饿汉式（线程安全，调用效率高。但是，不能延时加载。）
• 懒汉式（线程安全，调用效率不高。但是，可以延时加载。）
– 其他：
• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
• 静态内部类式(线程安全，调用效率高。但是，可以延时加载)
• 枚举式(线程安全，调用效率高，不能延时加载。并且可以天然的防止反射和反序列
化漏洞！)
• 如何选用?
– 单例对象占用资源少，不需要延时加载：
• 枚举式好于饿汉式
– 单例对象占用资源大，需要延时加载：
• 静态内部类式好于懒汉式

2.2 工厂模式

– 实现了创建者和调用者的分离。

核心本质：
– 实例化对象，用工厂方法代替new操作。
– 将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实
现类解耦。
– 详细分类：
• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

– 简单工厂模式
• 用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
– 工厂方法模式
• 用来生产同一等级结构中的固定产品。（支持增加任意产品）
– 抽象工厂模式
• 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

2.2.1 工厂方法模式定义：

工厂方法模式使用的频率非常高，在日常开发中总能看到它的身影。

定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

2.2.2 面向对象设计的基本原则

OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭。
DIP（依赖倒转原则，Dependence Inversion Principle）：要针对接口编程，不要针对实现编程。
LoD（迪米特法则，Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信。

2.2.3.1简单工厂模式的使用

package cn.xiaomifeng1010.simplefactory;

public interface Car {
	void run();
}

package cn.xiaomifeng1010.simplefactory;

public class Audi implements Car {

	@Override
	public void run() {
		System.out.println("Audi is running");
	}

}

package cn.xiaomifeng1010.simplefactory;

public class Byd implements Car {

	@Override
	public void run() {
		System.out.println("Byd is running,too！");
	}

}

不使用简单工厂模式时

public class Client01 { //调用者
public static void main(String[] args) {
Car c1 = new Audi();
Car c2 = new Byd();
c1.run();
c2.run();
}
}

使用简单工厂模式：

要点：
– 简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，
通过接收的参数的不同来返回不同的对象实例。
– 对于增加新产品无能为力！不修改代码的话，是无法扩展的。

package cn.xiaomifeng1010.factory.simplefactory;
//第一种方式：
public class CarFactory01 {
	
	public static  Car createCar(String type){
		if("奥迪".equals(type)){
			return new Audi();
		}else if("比亚迪".equals(type)){
			return new Byd();
		}else{
			return null;
		}
	}
	
}

package cn.xiaomifeng1010.factory.simplefactory;

/**
 * 简单工厂类
 * @author xiaomifeng1010
 *
 */
public class CarFactory2 {
	
	public static  Car createAudi(){
		return new Audi();
	}
	public static  Car createByd(){
		return new Byd();
	}
	
}

简单工厂模式下调用

package cn.xiaomifeng1010factory.simplefactory;

/**
 * 简单工厂情况下
 * @author xiaomifeng1010
 *
 */
public class Client02 {   //调用者
	
	public static void main(String[] args) {
		Car c1 =CarFactory.createCar("奥迪");
		Car c2 = CarFactory.createCar("比亚迪");
		
		c1.run();
		c2.run();
		
	}
}

类之间关系图：

2.2.3.2工厂方法模式的使用

工厂方法模式要点：
– 为了避免简单工厂模式的缺点，不完全满足OCP。
– 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目
或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

每种汽车创建工厂类

package cn.xiaomifeng1010.factory.factorymethod;

public class AudiFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Audi();
	}

}

package cn.xiaomifeng1010.factory.factorymethod;

public class BydFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Byd();
	}

}

客户端调用

package cn.xiaomifeng1010.factory.factorymethod;


public class Client {
	public static void main(String[] args) {
		Car c1 = new AudiFactory().createCar();
		Car c2 = new BydFactory().createCar();
		
		c1.run();
		c2.run();
	}
}

简单工厂模式和工厂方法模式PK:
– 结构复杂度
从这个角度比较，显然简单工厂模式要占优。简单工厂模式只需一个工厂类，而工厂方法模式的工厂类随着产品类个
数增加而增加，这无疑会使类的个数越来越多，从而增加了结构的复杂程度。
– 代码复杂度
代码复杂度和结构复杂度是一对矛盾，既然简单工厂模式在结构方面相对简洁，那么它在代码方面肯定是比工厂方法
模式复杂的了。简单工厂模式的工厂类随着产品类的增加需要增加很多方法（或代码），而工厂方法模式每个具体工
厂类只完成单一任务，代码简洁。
– 客户端编程难度
工厂方法模式虽然在工厂类结构中引入了接口从而满足了OCP，但是在客户端编码中需要对工厂类进行实例化。而简
单工厂模式的工厂类是个静态类，在客户端无需实例化，这无疑是个吸引人的优点。
– 管理上的难度
这是个关键的问题。
我们先谈扩展。众所周知，工厂方法模式完全满足OCP，即它有非常良好的扩展性。那是否就说明了简单工厂模式就
没有扩展性呢？答案是否定的。简单工厂模式同样具备良好的扩展性——扩展的时候仅需要修改少量的代码（修改工
厂类的代码）就可以满足扩展性的要求了。尽管这没有完全满足OCP，但我们不需要太拘泥于设计理论，要知道，
sun提供的java官方工具包中也有想到多没有满足OCP的例子啊。
然后我们从维护性的角度分析下。假如某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。当同时
需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦（对号入座已经是个问题了）。反而简单工厂没有这些
麻烦，当多个产品类需要修改是，简单工厂模式仍然仅仅需要修改唯一的工厂类（无论怎样都能改到满足要求吧？大
不了把这个类重写）。
• 根据设计理论建议：工厂方法模式。但实际上，我们一般都用简单工厂模式。

2.2.3.3 抽象工厂模式

用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
– 抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

抽象工厂模式的优点：

封装性，每个产品的实现类不是高层模块要关心的，他要关心的是什么？是接口，是抽象，它不关心对象是如何创建出来的，这由谁负责呢？工厂类，只要知道工厂类是谁，我就能创建出一个需要的对象，省时省力，优秀设计就应该如此。

产品族内的约束为非公开状态，例如生产男女比例的问题上，猜想女娲娘娘肯定有自己的打算，不能让女盛男衰，否则女性的有点不就体现不出来了吗？那么在抽象工厂模式，就应该有这样一个约束：没生产一个女性，就同时生产1.2个男性，这样的生产过程对调用工厂类的高层模块来说是透明的，它不需要知道这个约束，我就是要一个黄色女性产品就可以了，具体产品族内的约束是在工厂内实现的。

抽象工厂模式的缺点：

抽象工厂模式的最大缺点就是产品族的扩展非常困难，为什么这样说呢？我们一通用代码为例，如果要增加一个产品C，也就是说产品家族由原来的两个增加到3个，程序的改动非常大。

package cn.xiaomifeng1010.factory.abstractFactory;

public interface CarFactory {
	Engine createEngine();
	Seat createSeat();
	Tyre createTyre();
}

package cn.xiaomifeng1010.factory.abstractFactory;

public interface Engine {
	void run();
	void start();
}


class LuxuryEngine implements Engine{

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

	@Override
	public void start() {
		System.out.println("启动快!可以自动启停！");
	}
	
}

class LowEngine implements Engine{
	
	@Override
	public void run() {
		System.out.println("转的慢！");
	}
	
	@Override
	public void start() {
		System.out.println("启动慢!");
	}
	
}

package cn.xiaomifeng1010.factory.abstractFactory;

public class LowCarFactory implements CarFactory {

	@Override
	public Engine createEngine() {
		return new LowEngine();
	}

	@Override
	public Seat createSeat() {
		return new LowSeat();
	}

	@Override
	public Tyre createTyre() {
		return new LowTyre();
	}


}

package cn.xiaomifeng1010.factory.abstractFactory;

public class LuxuryCarFactory implements CarFactory {

	@Override
	public Engine createEngine() {
		return new LuxuryEngine();
	}

	@Override
	public Seat createSeat() {
		return new LuxurySeat();
	}

	@Override
	public Tyre createTyre() {
		return new LuxuryTyre();
	}


}

package cn.xiaomifeng1010.factory.abstractFactory;

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("不能按摩！");
	}
	
}

package cn.xiaomifeng1010.factory.abstractFactory;

public interface Tyre {
	void revolve();
}

class LuxuryTyre implements Tyre {

	@Override
	public void revolve() {
		System.out.println("旋转不磨损！");
	}
	
}

class LowTyre implements Tyre {

	@Override
	public void revolve() {
		System.out.println("旋转磨损快！");
	}
	
}

package cn.xiaomifeng1010.factory.abstractFactory;

public class Client {

	public static void main(String[] args) {
		CarFactory  factory = new LuxuryCarFactory();
		Engine e = factory.createEngine();
		e.run();
		e.start();
		
		
	}
}

2.2.4工厂模式要点：
– 简单工厂模式(静态工厂模式)
• 虽然某种程度不符合设计原则，但实际使用最多。
– 工厂方法模式
• 不修改已有类的前提下，通过增加新的工厂类实现扩展。
– 抽象工厂模式
• 不可以增加产品，可以增加产品族！
• 应用场景
– JDK中Calendar的getInstance方法
– JDBC中Connection对象的获取
– Hibernate中SessionFactory创建Session
– spring中IOC容器创建管理bean对象
– XML解析时的DocumentBuilderFactory创建解析器对象
– 反射中Class对象的newInstance()

2.3 创建者模式

2.3.1 建造者模式的定义及简介：

建造者模式也叫作生成器模式，定义：将一个复杂对象的构建与他的表示分离，使得同样的构建过程可以创建不同的表示。

场景：
– 我们要建造一个复杂的产品。比如：神州飞船,Iphone。这个复杂的产品的创建。有这样
一个问题需要处理：
• 装配这些子组件是不是有个步骤问题?
– 实际开发中，我们所需要的对象构建时，也非常复杂，有很多步骤需要处理时。
• 建造模式的本质：
– 分离了对象子组件的单独构造(由Builder来负责)和装配(由Director负责)。从而可以构
造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况下使用。
– 由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；
相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配
算法的解耦，实现了更好的复用。

2.3.2 建造者模式实例：

package cn.xiaomifeng1010.builder;

/**
 * 宇宙飞船
 * @author 
 *
 */
public class AirShip {
	
	private OrbitalModule orbitalModule;  //轨道舱
	private Engine engine; //发动机
	private EscapeTower escapeTower;  //逃逸塔
	
	
	public void launch(){
		System.out.println("发射！");
	}
	
	
	
	public OrbitalModule getOrbitalModule() {
		return orbitalModule;
	}
	public void setOrbitalModule(OrbitalModule orbitalModule) {
		this.orbitalModule = orbitalModule;
	}
	public Engine getEngine() {
		return engine;
	}
	public void setEngine(Engine engine) {
		this.engine = engine;
	}
	public EscapeTower getEscapeTower() {
		return escapeTower;
	}
	public void setEscapeTower(EscapeTower escapeTower) {
		this.escapeTower = escapeTower;
	}
	
	
	
}

class OrbitalModule{
	private String name;

	public OrbitalModule(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
}

class Engine {
	private String name;

package cn.xiaomifeng1010.builder;


public interface AirShipBuilder {
	Engine builderEngine();
	OrbitalModule builderOrbitalModule();
	EscapeTower  builderEscapeTower();
}

package cn.xiaomifeng1010.builder;

public interface AirShipDirector {
	
	/**
	 * 组装飞船对象
	 * @return
	 */
	AirShip   directAirShip();
	
}

package cn.xiaomifeng1010.builder;


public class SxtAirShipBuilder implements AirShipBuilder {
	//StringBuilder, 以后学习XML解析中，JDOM库中的类：DomBuilder,SaxBuilder
	@Override
	public Engine builderEngine() {
		System.out.println("构建发动机！");
		return new Engine("发动机！");
	}

	@Override
	public EscapeTower builderEscapeTower() {
		
		System.out.println("构建逃逸塔");
		return new EscapeTower("逃逸塔");
	}

	@Override
	public OrbitalModule builderOrbitalModule() {
		System.out.println("构建轨道舱");
		return new OrbitalModule("轨道舱");
	}	
	
}

package cn.xiaomifeng1010.builder;

public class SxtAirshipDirector implements AirShipDirector {

	private AirShipBuilder builder;

	public SxtAirshipDirector(AirShipBuilder builder) {
		this.builder = builder;
	}


	@Override
	public AirShip directAirShip() {
		Engine e = builder.builderEngine();
		OrbitalModule o = builder.builderOrbitalModule();
		EscapeTower et = builder.builderEscapeTower();
		
		//装配成飞船对象
		AirShip ship = new AirShip();
		ship.setEngine(e);
		ship.setEscapeTower(et);
		ship.setOrbitalModule(o);
		
		return ship;
	}

}

package cn.xiaomifeng1010.builder;

public class Client {
	public static void main(String[] args) {
		
		AirShipDirector director = new SxtAirshipDirector(new SxtAirShipBuilder());

		AirShip ship = director.directAirShip();
		
		System.out.println(ship.getEngine().getName());
		
		ship.launch();
		
	}
}

类关系图：

2.3.3 开发中应用场景：
– StringBuilder类的append方法
– SQL中的PreparedStatement
– JDOM中，DomBuilder、SAXBuilder

2.4 原型模式

2.4.1 原型模式的定义

原型模式（Prototype Pattern）的简单程度仅次于单例模式和迭代器模式。由于简单，使用非常广泛。

定义：

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

原型模式：
– 通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
– 就是java中的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具备原型对象的特点
– 优势有：效率高(直接克隆，避免了重新执行构造过程步骤) 。
– 克隆类似于new，但是不同于new。new创建新的对象属性采用的是默认值。克隆出的
对象的属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后，
再修改克隆对象的值。
• 原型模式实现：
– Cloneable接口和clone方法
– Prototype模式中实现起来最困难的地方就是内存复制操作，所幸在Java中提供了
clone()方法替我们做了绝大部分事情。
• 注意用词：克隆和拷贝一回事！
短时间大量创建对象时，原型模式和普通new方式效率测试
• 开发中的应用场景
– 原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone的方法创建一个对象，然后由工厂方法提供给调用者。
• spring中bean的创建实际就是两种：单例模式和原型模式。（当然，原型模式需要和工厂模式搭配起来）

原型模式的优点：

性能优良。原型模式是在内存二进制流的拷贝，要比直接new一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。

逃避构造函数的约束。这既是它的有点也是缺点，直接在内存中拷贝，构造函数是不会执行的。有点就是减少了约束，缺点也是减少了约束，需要大家在实际应用是考虑。

原型模式使用场景：

资源优化场景：

类初始化需要消耗非常多的资源，这个资源包括数据、硬件资源等。

性能和安全要求的场景

通过new产生一个对象需要非常繁琐的数据准备或者访问权限，则可以使用原型模式。

一个对象多个修改者的场景：

一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。

在实际项目中，原型模式很少单独出现，一般是和工厂模式一起出现，通过clone方法创建一个对象，然后由工厂模式提供给调用者。原型模式已经与java融为一体，大家可以随手拿来使用。

2.4.2 原型模式的应用实例：

多利羊实例：

package cn.xiaomifeng1010.prototype;

import java.io.Serializable;
import java.util.Date;


public class Sheep implements Cloneable,Serializable {   //1997,英国的克隆羊，多利！
	private String sname;
	private Date birthday;
	
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object obj = super.clone();  //直接调用object对象的clone()方法！
		return obj;
	}


	public String getSname() {
		return sname;
	}


	public void setSname(String sname) {
		this.sname = sname;
	}


	public Date getBirthday() {
		return birthday;
	}


	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}


	public Sheep(String sname, Date birthday) {
		super();
		this.sname = sname;
		this.birthday = birthday;
	}
	
	public Sheep() {
	}
	
}

package cn.xiaomifeng1010.prototype;

import java.util.Date;


//测试深复制
public class Sheep2 implements Cloneable {   //1997,英国的克隆羊，多利！
	private String sname;
	private Date birthday;
	
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object obj = super.clone();  //直接调用object对象的clone()方法！
		
		
		//添加如下代码实现深复制(deep Clone)
		Sheep2 s = (Sheep2) obj;
		s.birthday = (Date) this.birthday.clone();  //把属性也进行克隆！
		
		return obj;
	}


	public String getSname() {
		return sname;
	}


	public void setSname(String sname) {
		this.sname = sname;
	}


	public Date getBirthday() {
		return birthday;
	}


	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}


	public Sheep2(String sname, Date birthday) {
		super();
		this.sname = sname;
		this.birthday = birthday;
	}
	
	public Sheep2() {
	}
	
}

浅克隆（复制）测试：

package cn.xiaomifeng1010.prototype;

import java.util.Date;

/**
 * 测试原型模式(浅克隆)
 * @author 
 */
public class Client {
	public static void main(String[] args) throws Exception {
		Date date = new Date(12312321331L);
		Sheep s1 = new Sheep("少利",date);
		System.out.println(s1);
		System.out.println(s1.getSname());
		System.out.println(s1.getBirthday());
		
		date.setTime(23432432423L);
		
		System.out.println(s1.getBirthday());
		
		Sheep s2 = (Sheep) s1.clone();
		s2.setSname("多利");
		System.out.println(s2);
		System.out.println(s2.getSname());
		System.out.println(s2.getBirthday());
		
		
	}
}

原型模式（深复制）

package cn.xiaomifeng1010.prototype;

import java.util.Date;

/**
 * 原型模式(深复制)
 * @author 
 *
 */
public class Client2 {
	public static void main(String[] args) throws CloneNotSupportedException {
		Date date = new Date(12312321331L);
		Sheep2 s1 = new Sheep2("少利",date);
		Sheep2 s2 = (Sheep2) s1.clone();   //实现深复制。s2对象的birthday是一个新对象！
		
		
		System.out.println(s1);
		System.out.println(s1.getSname());
		System.out.println(s1.getBirthday());
		
		date.setTime(23432432423L);
		
		System.out.println(s1.getBirthday());
		
		
		s2.setSname("多利");
		System.out.println(s2);
		System.out.println(s2.getSname());
		System.out.println(s2.getBirthday());
		
		
		
	}
}

package cn.xiaomifeng1010.prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

/**
 * 原型模式(深复制,使用序列化和反序列化的方式实现深复制)
 * @author
 *
 */
public class Client3 {
	public static void main(String[] args) throws CloneNotSupportedException, Exception {
		Date date = new Date(12312321331L);
		Sheep s1 = new Sheep("少利",date);
		System.out.println(s1);
		System.out.println(s1.getSname());
		System.out.println(s1.getBirthday());

		
//		使用序列化和反序列化实现深复制
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		ObjectOutputStream    oos = new ObjectOutputStream(bos);
		oos.writeObject(s1);
		byte[] bytes = bos.toByteArray();
		
		ByteArrayInputStream  bis = new ByteArrayInputStream(bytes);
		ObjectInputStream	  ois = new ObjectInputStream(bis);
		
		Sheep s2 = (Sheep) ois.readObject();   //克隆好的对象！
		
		System.out.println("修改原型对象的属性值");  
		date.setTime(23432432423L);
		
		System.out.println(s1.getBirthday());
		
		s2.setSname("多利");
		System.out.println(s2);
		System.out.println(s2.getSname());
		System.out.println(s2.getBirthday());
		
		
	}
}

package cn.xiaomifeng1010.prototype;

/**
 * 测试普通new方式创建对象和clone方式创建对象的效率差异！
 * 如果需要短时间创建大量对象，并且new的过程比较耗时。则可以考虑使用原型模式！
 * @author 
 *
 */
public class Client4 {
	
	public static void testNew(int size){
		long start = System.currentTimeMillis();
		for(int i=0;i<size;i++){
			Laptop t = new Laptop();
		}
		long end = System.currentTimeMillis();
		System.out.println("new的方式创建耗时："+(end-start));
	}
	
	public static void testClone(int size) throws CloneNotSupportedException{
		long start = System.currentTimeMillis();
		Laptop t = new Laptop();
		for(int i=0;i<size;i++){
			Laptop temp = (Laptop) t.clone();
		}
		long end = System.currentTimeMillis();
		System.out.println("clone的方式创建耗时："+(end-start));
	}
	
	
	public static void main(String[] args) throws Exception {	
		testNew(1000);
		testClone(1000);
	}
}


class Laptop implements Cloneable {  //笔记本电脑
	public Laptop() {
		try {
			Thread.sleep(10);  //模拟创建对象耗时的过程!
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object obj = super.clone();  //直接调用object对象的clone()方法！
		return obj;
	}
	
}

浅克隆存在的问题
– 被复制的对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都
仍然指向原来的对象。
• 深克隆如何实现?
– 深克隆把引用的变量指向复制过的新对象，而不是原有的被引用的对象。
– 深克隆：让已实现Clonable接口的类中的属性也实现Clonable接口
– 基本数据类型和String能够自动实现深度克隆（值的复制）

//利用序列化和反序列化技术实现深克隆！
Date date = new Date(12312321331L);
Sheep s1 = new Sheep("少利",date);
System.out.println(s1);
System.out.println(s1.getSname());
System.out.println(s1.getBirthday());
//使用序列化和反序列化实现深复制
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(s1);
byte[] bytes = bos.toByteArray();
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bis);
Sheep s2 = (Sheep) ois.readObject(); //克隆好的对象！
System.out.println("修改原型对象的属性值");
date.setTime(23432432423L);
System.out.println(s1.getBirthday());

2.5 创建型模式小结：

创建型模式：都是用来帮助我们创建对象的！
– 单例模式
• 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
– 工厂模式
• 简单工厂模式
– 用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
• 工厂方法模式
– 用来生产同一等级结构中的固定产品。（支持增加任意产品）
• 抽象工厂模式
– 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
– 建造者模式
• 分离了对象子组件的单独构造(由Builder来负责)和装配(由Director负责)。从而可
以构造出复杂的对象。
– 原型模式
• 通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式

本文是GOF23中设计模式的第一部分，即介绍了第一种类型创建型设计模式，第二部分会继续分别介绍结构性模式和行为型模式。

本文部分内容引用了《设计模式之禅第二版》作者：秦小波

第二部分内容：GOF23种设计模式在Java中的应用（part 2）

xiaomifeng1010

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
GOF23种设计模式在Java中的应用（part 1）

第二部分：GOF23种设计模式在Java中的应用（part 2）一、GOF来源及简介1.1 GOF23种设计模式简介《Design Patterns: Elements of Reusable Object-Oriented Software》（即后述《设计模式》一书），由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides...
复制链接

扫一扫

专栏目录