什么是设计模式?
设计模式 (Design pattern)是一套被反复使用、多数人知晓、经过分类编目、代码设计经验的总结。
应用设计模式的好处？
设计模式是优秀的使用案例，实用设计模式可提高代码的重用性、让代码更容易被他人理解、保证代码可靠性。
工厂模式的概念
实例化对象，用工厂方法代替new操作。
工厂模式包括工厂方法模式和抽象工厂模式。
抽象工厂模式是工厂方法模式的扩展。
工厂模式的意图
定义一个接口来创建对象，但是让子类来决定哪些类需要被实例化。工厂方法把实例化的工作推迟到子类中去实现。
工厂模式的应用场景
有一组类似的对象需要创建。
在编码时不能预见需要创建哪种类的实例。
系统需要考虑扩展性，不应依赖于产品类实例如何被创建、组合和表达的细节。
项目中的现状
在软件系统中经常面临着"对象"的创建工作,由于需求的变化，这个对象可能随之也发生变化，但它却拥有比较稳定的接口。
为此，我们需要提供一种封装机制来隔离出这个易变对象的变化，从而保持系统中其他依赖该对象的对象不随着需求变化而变化。(低耦合）
基于项目现状将代码进行如下设计:
尽量松耦合，一个对象的依赖对象的变化与本身无关
具体产品与客户端剥离，责任分割。
工厂模式本质
工厂方法代替new操作;
工厂模式的好处
系统带来更大的可扩展性和尽量少的修改量。
工厂方法模式类图
Iporduct
/**
* 发型接口
* */
public interface HairInterface {
/**
* 实现发型
* */
public void draw();
}product1
/**
* 左偏分发型
* */
public class LeftHairImpl implements HairInterface{
/**
* 画了一个左偏分发型
* */
@Override
public void draw() {
System.out.println("画了一个左偏分发型");
}
}product2
/**
* 右偏分发型
* */
public class RightHairImpl implements HairInterface{
/**
* 画了个右偏分发型
* */
@Override
public void draw() {
System.out.println("画了个右偏分发型");
}
}客户端 Client
/**
* 模拟客户端实现
* */
public class HairTest {
public static void main(String[] args) {
HairInterface left = new LeftHairImpl();
left.draw();
HairInterface right = new RightHairImpl();
right.draw();
}
}假如存在N个product，难道要new N个product,答案当然是No!使用工厂，简化程序。
creator
/**
* 发型工厂
* */
public class HairFactory {
/**
* 根据类型创建对象
* */
public HairInterface getHairType(String type){
if("left".equals(type)){
return new LeftHairImpl();
}else if("right".equals(type)){
return new RightHairImpl();
}
return null;
}
}在客户端使用
HairFactory hairFactory = new HairFactory();
HairInterface left1 = hairFactory.getHairType("left");
left1.draw();但是，看上去代码并没有简化，我们该怎么做？根据类名使用类的反射机制创建对象。
creator
/**
* 根据类的名称创建对象
* 利用反射机制
* */
public HairInterface getHairTypeByClass( String className){
try {
HairInterface hairInerface = (HairInterface) Class.forName(className).newInstance();
return hairInerface;
} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}客户端
HairInterface left2 = hairFactory.getHairTypeByClass("com.dreamtale.designpattern.patter.factory.LeftHairImpl");
left2.draw();以上似乎方便了很多，但是参数看起来好冗余，试着将参数变短，该怎么做？
解决办法：使用属性文件，在同目录下创建type.properties文件,并添加以下内容;
left=com.dreamtale.designpattern.patter.factory.LeftHairImpl
right=com.dreamtale.designpattern.patter.factory.RightHairImpl接下来就该想办法读取这个文件了。
PropertiesReader
/**
* properties文件读取工具类
* */
public class PropertiesReader {
public Map<String,String> getProperties(){
Properties props = new Properties();
Map<String,String> map = new HashMap<String,String>();
try{
InputStream in = getClass().getResourceAsStream("type.properties");
props.load(in);
Enumeration<?> en = props.propertyNames();
while(en.hasMoreElements()){
String key = (String) en.nextElement();
String property = props.getProperty(key);
map.put(key, property);
}
}catch(Exception e){
}
return map;
}
}写好了该怎么读取，就该应用到代码中了。
creator
/**
* 根据类的key创建对象
* 利用反射机制
* */
public HairInterface getHairTypeByClassKey( String key){
try {
Map<String,String> map = new PropertiesReader().getProperties();
String value = map.get(key);
HairInterface hairInerface = (HairInterface) Class.forName(value).newInstance();
return hairInerface;
} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}客户端
HairInterface left3 = hairFactory.getHairTypeByClassKey("left");
left3.draw();抽象工厂模式类图
Client
public class PersonTest {
public static void main(String [] args){
PersonFactory factory = new MCFactory();
Gril gril = factory.getGril();
gril.drawWoman();
}
}AbstractProductA
/**
* 男孩
* */
public interface Boy {
void drawMan();
}AbstractProductB
/**
*女孩
*
*/
public interface Gril {
void drawWoman();
}Factory
/**
* 人物的实现接口
* */
public interface PersonFactory {
Boy getBoy();
Gril getGril();
}
ConcreateFactory1
/**
* 新年系列加工厂
* */
public class HNFactory implements PersonFactory{
@Override
public Boy getBoy() {
// TODO Auto-generated method stub
return new HNBoy();
}
@Override
public Gril getGril() {
// TODO Auto-generated method stub
return new HNGril();
}
}ConcreateFactory2
/**
* 圣诞系列加工厂
* */
public class MCFactory implements PersonFactory{
@Override
public Boy getBoy() {
// TODO Auto-generated method stub
return new MCBoy();
}
@Override
public Gril getGril() {
// TODO Auto-generated method stub
return new MCGril();
}
}ConcreateProductA1
/**
* 元旦系列的男孩
* */
public class HNBoy implements Boy {
@Override
public void drawMan() {
System.out.println("元旦系列的男孩");
}
} ConcreateProductA2
/**
* 圣诞系列的男孩
* */
public class MCBoy implements Boy {
@Override
public void drawMan() {
System.out.println("圣诞系列的男孩");
}
}ConcreateProductB1
/**
* 元旦系列的女孩
* */
public class HNGril implements Gril {
@Override
public void drawWoman() {
System.out.println("元旦系列的女孩");
}
}ConcreateProductB2
/**
* 圣诞系列的女孩
* */
public class MCGril implements Gril {
@Override
public void drawWoman() {
System.out.println("圣诞系列的女孩");
}
}常见应用
JDBC
一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。
Spring beanFactory
BeanFactory , 作为Spring基础的IoC容器,是Spring的一个Bean工厂。如果单从工厂模式的角度思考,它就是用来“生产Bean”,然后提供给客户端。
Bean的实例化过程如下
调用Bean的默认构造方法,或指定的构造方法,生成bean实例(暂称为instance1);
如果Bean的配置文件中注入了Bean属性值,则在instance1基础上进行属性注入形成instance2 ,这种注入是覆盖性的;
如果Bean实现了InitializingBean接口,则调用afterPropertiesSet()方法,来改变或操作instance2 ,得到instance3;
如果Bean的配置文件中指定了init-method="init"属性,则会调用指定的初始化方法,则在instance3的基础上调用初始化方法init(),将对象最终初始化为instance4 ;当然，这个初始化的名字是任意的;
工厂方法模式和抽象工厂模式对比
工厂模式是一种极端情况的抽象工厂模式,而抽象工厂模式可以看成是工厂模式的推广;
工厂模式用来创建一个产品的等级结构,而抽象工厂模式是用来创建多个产品的等级结构;
工厂模式只有一个抽象产品类,而抽象工厂模式有多个抽象产品类;
工厂模式的实现帮助我们
系统可以在不修改具体工厂角色的情况下引进新的产品;
客户端不必关心对象如果创建,明确了职责;
更好的理解面向对象的原则面向接口编程,而不要面向实现编程;
工厂模式适用与哪些场景
一个系统应当不依赖于产品类实例被创立,组成,和表示的细节。这对于所有形态的工厂模式都是重要的;
这个系统的产品有至少一个的产品族;
同属于同一个产品族的产品是设计成在一起使用的。这一约束必须得在系统的设计中体现出来。
不同的产品以一系列的接口的面貌出现,从而使系统不依赖于接口实现的细节