摘自《轻量级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();
}
}
网友评论