设计模式专题之建造者&模版方法&适配器&外观模式

1. 建造者模式

1.1 什么是建造者模式

建造者模式：是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。
建造者模式通常包括下面几个角色：

1. Builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。
2. ConcreteBuilder：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。
3. Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
4. Product：要创建的复杂对象。

1.2 建造者应用场景

1. 去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。
2. JAVA 中的 StringBuilder 数组（单个字符）字整合在一起 字符串
   使用场景：
   (1)需要生成的对象具有复杂的内部结构。
   (2)需要生成的对象内部属性本身相互依赖。

与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

1.3 实际案例

这里以游戏开发中人物的构造过程为例。在游戏中创建一个形象时，需要对每个部位进行创建。简化而言，需要创建头部，身体和四肢。

建立一个人物对象Person

public class Person {
	private String head;
	private String body;
	private String foot;
//省略getter setter
}

Builder（给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建）

public interface PersonBuilder {

	void builderHead();

	void builderBody();

	void builderFoot();

	Person BuilderPersion(); //组装
}

ConcreteBuilder（实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例）

public class ManBuilder implements PersonBuilder {
	private Person person;

	public ManBuilder() {
		person = new Person();//创建一个Person实例,用于调用set方法
	}

	public void builderHead() {
		person.setHead("建造者头部分");
	}

	public void builderBody() {
		person.setBody("建造者身体部分");
	}

	public void builderFoot() {
		person.setFoot("建造者头四肢部分");
	}

	public Person BuilderPersion() {
		return person;
	}

}

Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序（和工厂设计模式最大的区别）创建

public class PersonDirector {

	public Person constructPerson(PersonBuilder pb) {
		pb.builderHead();
		pb.builderBody();
		pb.builderFoot();
		return pb.BuilderPersion();
	}

	public static void main(String[] args) {
		PersonDirector pb = new PersonDirector();
		Person person = pb.constructPerson(new ManBuilder());
		System.out.println(person.getHead());
		System.out.println(person.getBody());
		System.out.println(person.getFoot());
	}
}

2. 模板方法

2.1 什么是模板方法

模板方法模式：定义一个操作中的算法骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的
重复代码全部在父类里面，不同业务的，抽取给子类进行实现。抽取过程—抽象方法。

核心：处理某个流程的代码已经都具备，但是其中某个节点的代码暂时不能确定。因此，我们采用工厂方法模式，将这个节点的代码实现转移给子类完成。即：处理步骤在父类中定义好，具体的实现延迟到子类中定义。
说白了，就是将一些相同操作的代码，封装成一个算法的骨架。核心的部分留在子类中操作，在父类中只把那些骨架做好。

例如：

1. 去银行办业务，银行给我们提供了一个模板就是：先取号，排对，办理业务（核心部分我们子类完成），给客服人员评分，完毕。
   这里办理业务是属于子类来完成的，其他的取号，排队，评分则是一个模板。
2. 去餐厅吃饭，餐厅给提供的一套模板就是：先点餐，等待，吃饭（核心部分我们子类完成），买单这里吃饭是属于子类来完成的，其他的点餐，买单则是餐厅提供给我们客户的一个模板。
   

2.2 模板方法具体实现

这里使用银行办理业务为例
首先，定义一个模板。模板中把办理业务用作核心部分，让子类来实现。

//模板方法
public abstract class BankTemplateMethod {

	// 1.取号排队
	public void takeNumber() {
		System.out.println("取号排队。。");
	}

	// 2.每个子类不同的业务实现，由各自子类实现.
	abstract void transact();

	// 3.评价
	public void evaluate() {	
          System.out.println("反馈评价..");
	}
	
	public void process(){
		takeNumber();
		transact();
		evaluate();
	}
}

具体的模板方法的子类

public class DrawMoney extends BankTemplateMethod {
	@Override
	void transact() {
		System.out.println("我要取款");	
	}
}

客户端测试

public class Client {

	 public static void main(String[] args) {
		 BankTemplateMethod bankTemplate=new DrawMoney();
		 bankTemplate.process();
	}
	
}

匿名内部类方式

BankTemplateMethod bankTemplateMethod=new BankTemplateMethod() {
			
			@Override
			void transact() {
				System.out.println("我要存钱.");
				
			}
		};
		bankTemplateMethod.process();

2.3 什么时候使用模板方法

实现一些操作时，整体步骤很固定，但是呢。就是其中一小部分容易变，这时候可以使用模板方法模式，将容易变的部分抽象出来，比如上面代码中定义了抽象方法供子类实现。

开发中应用场景
其实，各个框架中，都有模板方法模式的影子。
数据库访问的封装、Junit单元测试、servlet中关于doGet/doPost方法的调用（继承抽象类HttpServlet，重写请求方法）
Hibernate中模板程序、spring中JDBCTemplate，HibernateTemplate等等

3. 适配模式

3.1 什么是适配器

在设计模式中，适配器模式（英语：adapter pattern）有时候也称包装样式或者包装(wrapper)。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类自己的接口包裹在一个已存在的类中。

3.2 适配器分类

适配器分为，类适配器、对象适配、接口适配方式
类适配器方式采用继承方式，对象适配方式使用构造函数传递

3.3 适配器案例

我们就拿日本电饭煲的例子进行说明，日本电饭煲电源接口标准是110V电压，而中国标准电压接口是220V，所以要想在中国用日本电饭煲，需要一个电源转换器。
代码模拟如下：

//日本110V 电源接口
public interface JP110VInterface {
	public void connect();
}

//110V电源接口实现
public class JP110VInterfaceImpl implements JP110VInterface {

	@Override
	public void connect() {
       System.out.println("日本110V,接通电源,开始工作..");
	}

}

我们再定义中国220V电源接口和实现。

public interface CN220VInterface {
	public void connect();
}

public class CN220VInterfaceImpl implements CN220VInterface {
	@Override
	public void connect() {
		 System.out.println("中国220V,接通电源,开始工作");
	}
}

定义一个电压适配器
要想在中国使用日本电饭煲，需要把电饭煲110v的电源接口适配成我们220V的电源接口，这就需要一个电源适配器：

public class ElectricCooker {

	private JP110VInterface jp110VInterface;//日本电饭煲
	ElectricCooker(JP110VInterface jp110VInterface){
		 this.jp110VInterface=jp110VInterface;
	}
	
	public void cook(){
		jp110VInterface.connect();
		System.out.println("开始做饭了..");
	}

}

定义一个电压适配器

public class PowerAdaptor implements JP110VInterface {
	private CN220VInterface cn220VInterface;

	public PowerAdaptor(CN220VInterface cn220VInterface) {
		this.cn220VInterface = cn220VInterface;
	}

	@Override
	public void connect() {
		cn220VInterface.connect();
	}

}

测试开始运行

public class AdaptorTest {

	public static void main(String[] args) {
		CN220VInterface cn220VInterface = new CN220VInterfaceImpl();
		PowerAdaptor powerAdaptor = new PowerAdaptor(cn220VInterface);
		// 电饭煲
		ElectricCooker cooker = new ElectricCooker(powerAdaptor);
		cooker.cook();//使用了适配器,在220V的环境可以工作了。
	}

}

3.4 适配器应用场景

我们根据上面的适配器的特点的介绍中，我们来分析下适配器模式的几类比较适用的使用场景：

1. 我们在使用第三方的类库，或者说第三方的API的时候，我们通过适配器转换来满足现有系统的使用需求。
2. 我们的旧系统与新系统进行集成的时候，我们发现旧系统的数据无法满足新系统的需求，那么这个时候，我们可能需要适配器，完成调用需求。
3. 我们在使用不同数据库之间进行数据同步。(我这里只是分析的是通过程序来说实现的时候的情况。还有其他的很多种方式[数据库同步])。

OutputStreamWriter：是Writer的子类，将输出的字符流变为字节流，即：将一个字符流的输出对象变为字节流的输出对象。
InputStreamReader：是Reader的子类，将输入的字节流变为字符流，即：将一个字节流的输入对象变为字符流的输入对象。
SpringMVC 适配器

4. 外观模式

4.1 什么是外观模式

外观模式（Facade Pattern）门面模式，隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。
这种模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。

外观模式例子
用户注册完之后，需要调用阿里短信接口、邮件接口、微信推送接口。

public interface EamilSmsService {
	  public void sendSms();	
}

public class EamilSmsServiceImpl implements   EamilSmsService{
	public void sendSms() {
		System.out.println("发送邮件消息");
		
	}
}

//微信消息推送
public interface WeiXinSmsService {
  public void sendSms();	
}

public class WeiXinSmsServiceImpl implements   EamilSmsService{

	@Override
	public void sendSms() {
		System.out.println("发送微信消息");
	}

}

//阿里短信消息
public interface AliSmsService {
	public void sendSms();
}

public class AliSmsServiceImpl implements AliSmsService {

	@Override
	public void sendSms() {
     System.out.println("支付宝发送消息...");
	}

}

门面类

public class Computer {
	AliSmsService aliSmsService;
	EamilSmsService eamilSmsService;
	WeiXinSmsService weiXinSmsService;

	public Computer() {
		aliSmsService = new AliSmsServiceImpl();
		eamilSmsService = new EamilSmsServiceImpl();
		weiXinSmsService = new WeiXinSmsServiceImpl();
	}

	public void sendMsg() {
		aliSmsService.sendSms();
		eamilSmsService.sendSms();
		weiXinSmsService.sendSms();
	}

}

public class Client {

	public static void main(String[] args) {
		// AliSmsService aliSmsService= new AliSmsServiceImpl();
		// EamilSmsService eamilSmsService= new EamilSmsServiceImpl();
		// WeiXinSmsService weiXinSmsService= new WeiXinSmsServiceImpl();
		// aliSmsService.sendSms();
		// eamilSmsService.sendSms();
		// weiXinSmsService.sendSms();
		new Computer().sendMsg();
	}
	
}