摘自《轻量级JavaEE企业应用开发》
【模式】是一条由三个部分组装成的通用规则：它表示了一个特定环境、一类问题和一个解决方案之间的关系
【设计模式】是对于特定环境下，经常出现的的某类软件开发问题的一种相对成熟的设计方案
单例模式
如果一个类始终只能创建一个实例，则称这个类为单例类，这种模式就被称为单例模式。
Spring推荐奖所有业务逻辑组件、DAO组件、数据源组件等配置为单例的行为方式，因为这些组件不需要保存任何用户状态，是所有客户端都可以通用的组件
代码实现
package com.singleton;
/**
* 单例模式Demo
* 《轻量级JavaEE企业应用实战》 P727
* 如果一个类始终只能创建一个实例，则这个类称为单例类，这种模式称为单例模式
* Spring推荐奖所有业务逻辑组件、DAO组件、数据源组件等配置成单例的行为方式
* @author Slience
*
*/
class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
//如果instance等于null，证明还没有创建过Singleton实例，为其创建Singleton实例
//如果instance不等于null，说明已经创建过Singleton实例，
//直接将这个Singleton返回即可，不必在new一个Singleton
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
public class SingletonTest {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
}
}
单例模式主要有两个优势
- 减少创建Java实例所带来的系统开销。
- 便于系统跟踪单个Java实例的生命周期、实例状态等。
简单工厂模式
A实例调用B实例的方法，则称A依赖于B
当A实例需要调用B实例的时候，有两种方式可以实现：
- 一种是使用new 关键字创建一个B实例，这种方式的缺点在于如果日后需求有变需要用C实例替代B实例，那么A实例中硬编码耦合B实例就需要修改，如果有很多实例都用new B()的方式去调用B实例的方法，那么需要修改的地方将会很多。
- A实例只需要调用B对象的方法，并不关心B对象的实现创建过程，所以我们可以让B类实现了一个IB借口，A类只需要和IB接口耦合，A类不直接使用new关键字来创建B实例，而是重新定义一个IBFactory类，由该类来负责创建IB实例，A类只需要调用IBFactory工厂方法来得到IB实例。
使用后一种设计，可以让A类和B类解除耦合，只需要和IB结构和IBFactory耦合，这样当新需求来时C类可以去实现IB接口然后再IBFactory中修改创建IB实例的代码，就可以实现新需求了，A类中不需要对代码进行修改。
这种将多个类对象交给工厂类来生成的设计方式被称为【简单工厂模式】
代码实现
假设程序用有一个Computer对象需要依赖一个输出设备，可以让Computer对象依赖一个Output（接口）属性，再用Printer（实现输出类）对象去实现Output接口，Computer从OutputFactory工厂类生成Printer从而让Computer和Printer分离开来，日后如果有更好的实现输出类BetterPrinter，那么直接修改OutputFactory代码即可。
Computer类
package com.simplefactory;
/**
* 《轻量级JavaEE企业应用实战 p728
* Computer类可以通过Output接口打印内容，让打印机类实现Output接口
* Computer使用OutputFactory来获取合适的打印机从而让打印机类和电脑类解耦
*
* 使用简单工厂模式的优势是：让对象的调用者和对象的创建过程分离，当对象调用者需要对象时，
* 直接向工厂请求即可；从而避免了对象的调用者与对象的实现类以硬编码方式耦合，
* 以提高系统的可维护性、可拓展性。
* 工厂模式也有一个小小的缺陷：当产品修改是，工厂类也要做相应的修改
* @author Slience
*
*/
public class Computer {
private Output out;
public Computer(Output out) {
this.out = out;
}
//定义一个模拟获取字符串输入的方法
public void keyIn(String msg) {
out.getDate(msg);
}
//定义一个模拟打印的方法
public void print() {
out.out();
}
public static void main(String[] args) {
OutputFactory factory = new OutputFactory();
//通过工厂类获取output对象
//Computer和factory硬编码而不和output实现类耦合，这样修改到另一个实现类的时候
//只需要修改factory中的getOutput方法即可
Computer computer = new Computer(factory.getOutput());
computer.keyIn("Hello World");
computer.keyIn("Slience");
computer.print();
}
}
Output输出接口
package com.simplefactory;
public interface Output {
//默认的打印队列大小
final static int MAX_CACHE_LINE = 1;
void getDate(String msg);
void out();
}
之后用Printer去实现Output
package com.simplefactory;
public class Printer implements Output {
private String[] printData = new String[MAX_CACHE_LINE];
//用以记录当前需要打印的作业数
private int dataNum = 0;
@Override
public void getDate(String msg) {
// TODO Auto-generated method stub
if(dataNum >= MAX_CACHE_LINE) {
System.out.println("输出队列已满，添加失败");
} else {
printData[dataNum++] = msg;
}
}
@Override
public void out() {
// TODO Auto-generated method stub
while(dataNum > 0) {
System.out.println("打印机打印:" + printData[0]);
//将原数组第二个到--dataNum个元素前移一位
System.arraycopy(printData, 1, printData, 0, --dataNum);
}
}
}
创建Output对象都通过OutputFactory工厂类去创建
package com.simplefactory;
public class OutputFactory {
public Output getOutput() {
return new Printer();
//换了新的打印机之后就可以打印两行了
//return new BetterPrinter();
}
}
当我们运行起Computer的时候会输出
输出队列已满，添加失败
打印机打印:Hello World
如果此时来了一个更好地Output实现类——BetterPrinter，他能够打印原大小两倍的数据量
package com.simplefactory;
public class BetterPrinter implements Output {
private String[] printData = new String[MAX_CACHE_LINE * 2];
//用以记录当前需要打印的作业数
private int dataNum = 0;
@Override
public void getDate(String msg) {
// TODO Auto-generated method stub
if(dataNum >= MAX_CACHE_LINE * 2) {
System.out.println("输出队列已满，添加失败");
} else {
printData[dataNum++] = msg;
}
}
@Override
public void out() {
// TODO Auto-generated method stub
while(dataNum > 0) {
System.out.println("打印机打印:" + printData[0]);
//将原数组第二个到--dataNum个元素前移一位
System.arraycopy(printData, 1, printData, 0, --dataNum);
}
}
}
我们想要给Computer换上新的Output的话，只需要在OutputFactory中修改为return new BetterPrinter()即可，Computer不需要做任何的改变。但是这样还是有一个小小的缺点，那就是当产品修改时，工厂类也要做相应的修改。
在Spring中可以通过配置XML来实现工厂类的修改
工厂模式
和简单工厂模式很像，只不过新增了一个OutputFactory接口和BetterPrinterFactory和PrinterFactory工厂类，这样做的好处在于不同的工厂生产不同的对象，工厂实现类不需要对逻辑进行判断，逻辑判断可以在OutputFactoryFactory类中进行，OutputFactoryFactory类是用来根据需要生成不同的实现了OutputFactory接口的工厂类的类。
代码实现
Output接口不变，新增OutputFactory接口
package com.factory;
public interface OutputFactory {
Output getOutput();
}
还有其实现类OutputFactoryFactory
package com.factory;
public class OutputFactoryFactory {
public static OutputFactory getOutputFactory(String type) {
//不考虑大小写
if(type.equalsIgnoreCase("better")) {
return new BetterPrinterFactory();
} else {
return new PrinterFactory();
}
}
}
之后创建BetterPrinterFactory和PrinterFactory工厂实现类，PrintFactory和BetterPrinterFactory只是两者返回的对象不同。
package com.factory;
public class BetterPrinterFactory implements OutputFactory {
@Override
public Output getOutput() {
// TODO Auto-generated method stub
return new BetterPrinter();
//如果是PrinterFactory返回的就是
//return new Printer();
}
}
在Computer中通过对OutputFactoryFactory传入不同的参数来获取不同的Factory类，再通过不同的工厂类来创建不同的对象
package com.factory;
/**
* 《轻量级JavaEE企业应用实战 p737
*
*
*
* @author Slience
*
*/
public class Computer {
private Output out;
public Computer(Output out) {
this.out = out;
}
//定义一个模拟获取字符串输入的方法
public void keyIn(String msg) {
out.getDate(msg);
}
//定义一个模拟打印的方法
public void print() {
out.out();
}
public static void main(String[] args) {
//工厂的工厂
OutputFactory factory = OutputFactoryFactory.getOutputFactory("better");
//通过工厂类获取output对象
//Computer和factory硬编码而不和output实现类耦合，这样修改到另一个实现类的时候
//只需要修改factory中的getOutput方法即可
Computer computer = new Computer(factory.getOutput());
computer.keyIn("Hello World");
computer.keyIn("Slience");
computer.print();
}
}
