GoF之工厂模式
Spring
- GoF之工厂模式
-
- 工厂模式的三种形态
- 简单工厂模式
-
- 简单工厂模式优缺点
- 工厂方法模式
-
- 工厂方法模式的优缺点
GoF之工厂模式
● 设计模式：一种可以被重复利用的解决方案。
GoF有23种设计模式，还有其它的设计模式，比如：JavaEE的设计模式（DAO模式、MVC模式等）
● 工厂模式是解决对象创建问题的，所以工厂模式属于创建型设计模式。
工厂模式的三种形态
工厂模式通常有三种形态：
● 第一种：简单工厂模式，不属于23种设计模式之一
● 第二种：工厂方法模式
● 第三种：抽象工厂模式
简单工厂模式
Spring中的BeanFactory就使用了简单工厂模式。
简单工厂模式的角色包括三个：
● 抽象产品角色
● 具体产品角色
● 工厂类角色
例：简单工厂模式
抽象产品角色：
package com.w.spring6.factory;
public abstract class Weapon {
/**
* 所有的武器都有攻击行为
*/
public abstract void attack();
}
具体产品角色：
Tank.java
package com.w.spring6.factory;
public class Tank extends Weapon{
@Override
public void attack() {
System.out.println("坦克开炮！");
}
}
Fighter.java
package com.w.spring6.factory;
public class Fighter extends Weapon{
@Override
public void attack() {
System.out.println("战斗机投下原子弹！");
}
}
Dagger.java
package com.w.spring6.factory;
public class Dagger extends Weapon{
@Override
public void attack() {
System.out.println("刀他！");
}
}
工厂类角色：
WeaponFactory.java
package com.w.spring6.factory;
public class WeaponFactory {
/**
* 根据不同的武器类型生产武器
* @param weaponType 武器类型
* @return 武器对象
*/
public static Weapon get(String weaponType){
if (weaponType == null || weaponType.trim().length() == 0) {
return null;
}
Weapon weapon = null;
if ("TANK".equals(weaponType)) {
weapon = new Tank();
} else if ("FIGHTER".equals(weaponType)) {
weapon = new Fighter();
} else if ("DAGGER".equals(weaponType)) {
weapon = new Dagger();
} else {
throw new RuntimeException("不支持该武器！");
}
return weapon;
}
}
客户端程序：
Client.java
package com.w.spring6.factory;
public class Client {
public static void main(String[] args) {
Weapon weapon1 = WeaponFactory.get("TANK");
weapon1.attack();
Weapon weapon2 = WeaponFactory.get("FIGHTER");
weapon2.attack();
Weapon weapon3 = WeaponFactory.get("DAGGER");
weapon3.attack();
}
}
运行结果：
简单工厂模式优缺点
优点：
- 客户端程序不需要关心对象的创建细节，需要哪个对象时，只需要向工厂索要即可，初步实现了责任的分离。客户端只负责“消费”，工厂负责“生产”。生产和消费分离。
缺点：
- 工厂类集中了所有产品的创造逻辑，形成一个无所不知的全能类，有人把它叫做上帝类。显然工厂类非常关键，不能出问题，一旦出问题，整个系统瘫痪。
- 不符合OCP开闭原则，在进行系统扩展时，需要修改工厂类。
工厂方法模式
工厂方法模式既保留了简单工厂模式的优点，同时又解决了简单工厂模式的缺点。
工厂方法模式的角色包括：
抽象工厂角色
具体工厂角色
抽象产品角色
具体产品角色
例：工厂方法模式
抽象产品角色：
Weapon.java
package com.w.spring6.factorymethod;
public abstract class Weapon {
/**
* 所有的武器都有攻击行为
*/
public abstract void attack();
}
具体产品角色:
Gun.java
package com.w.spring6.factorymethod;
public class Gun extends Weapon{
@Override
public void attack() {
System.out.println("开枪射击！");
}
}
Fighter.java
package com.w.spring6.factorymethod;
public class Fighter extends Weapon{
@Override
public void attack() {
System.out.println("战斗机发射核弹！");
}
}
抽象工厂角色:
package com.w.spring6.factorymethod;
public interface WeaponFactory {
Weapon get();
}
具体工厂角色:
GunFactory.java
package com.w.spring6.factorymethod;
public class GunFactory implements WeaponFactory{
@Override
public Weapon get() {
return new Gun();
}
}
FighterFactory.java
package com.w.spring6.factorymethod;
public class FighterFactory implements WeaponFactory{
@Override
public Weapon get() {
return new Fighter();
}
}
客户端程序：
Client.java
package com.w.spring6.factorymethod;
public class Client {
public static void main(String[] args) {
WeaponFactory factory = new GunFactory();
Weapon weapon = factory.get();
weapon.attack();
WeaponFactory factory1 = new FighterFactory();
Weapon weapon1 = factory1.get();
weapon1.attack();
}
}
运行结果：
如果想扩展一个新的产品，只要新增一个产品类，再新增一个该产品对应的工厂即可，例如新增：匕首
增加：具体产品角色
Dagger.java
package com.w.spring6.factorymethod;
public class Dagger extends Weapon{
@Override
public void attack() {
System.out.println("刀他！");
}
}
增加：具体工厂角色
DaggerFactory.java
public class DaggerFactory implements WeaponFactory{
@Override
public Weapon get() {
return new Dagger();
}
}
客户端程序：
WeaponFactory factory2 = new DaggerFactory();
Weapon weapon2 = factory2.get();
weapon2.attack();
运行结果：
我们可以看到在进行功能扩展的时候，不需要修改之前的源代码，显然工厂方法模式符合OCP原则。
工厂方法模式的优缺点
优点：
- 一个调用者想创建一个对象，只要知道其名称就可以了。
- 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
- 屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：
- 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。