工廠方法模式——軟件設計模式
例子：女媧造人
- 涉及到3個對象：女媧、八卦爐、三種不同膚色的人（白人、黑人、黃種人）
- 女媧可以用場景類Client來表示
- 八卦爐類似一個工廠，負責制造生產產品（即人類）
- 三種不同膚色的人，都是同一接口下的不同實現類
類圖
女媧造人類圖
- AbstractHumanFactory是一個抽象類，定義了一個八卦爐具有的整體功能
- HumanFactory是實現類，完成具體的任務——創造人類
- Human接口是人類的總稱，三個實現類分別為三類人種
- NvWa（女媧）是一個Client場景類，負責模擬這個場景，并執行相關的任務
- 定義每個人種都有兩種方法：getColor()、talk()
人類總稱
public interface Human {
public void getColor();
public void talk();
}
人類接口的三個實現類
public class BlackHuman implements Human {
public void getColor(){
System.out.println("皮膚的顏色是black");
}
public void talk(){
System.out.println("黑人說話");
}
}
public class WhiteHuman implements Human {
public void getColor(){
System.out.println("皮膚的顏色是white");
}
public void talk(){
System.out.println("白人說話");
}
}
public class YellowHuman implements Human {
public void getColor(){
System.out.println("皮膚的顏色是yellow");
}
public void talk(){
System.out.println("黃種人說話");
}
}
抽象人類創建工廠
/**
* 作為一個生產的管理者，只要知道生產什么就可以了，而不需要食物的具體信息。
* 八卦爐生產人類的方法輸入參數類型應該是Human接口的實現類
*/
public abstract class AbstractHumanFactory{
//使用了泛型Generic，通過定義泛型對createHuman的輸入參數產生兩種限制
//1. 必須是Class類型
//2. 必須是Human的實現類
public abstract <T extends Human> T createHuman(Class<T> c);
}
人類創建工廠
public class HumanFactory extends AbstractHumanFactory {
public <T extends Human> T createHuman(Class<T> c){
Human human = null;
try {
human = (Human)Class.forName(c.getName()).newInstance();
}catch (Exception e) {
System.out.println("人種生成錯誤");
}
return (T)human;
}
}
場景類Client：NvWa
public class NvWa{
public static void main(String[] args) {
AbstractHumanFactory abstractHumanFactory = new HumanFactory();
System.out.println("生產白人");
Human whiteHuman = abstractHumanFactory.createHuman(WhiteHuman.class);
whiteHuman.getColor();
whiteHuman.talk();
System.out.println("生產黑人");
Human blackHuman = abstractHumanFactory.createHuman(BlackHuman.class);
blackHuman.getColor();
blackHuman.talk();
System.out.println("生產黃種人");
Human yelloHuman = abstractHumanFactory.createHuman(YellowHuman.class);
yelloHuman.getColor();
yelloHuman.talk();
}
}
工廠方法模式的定義
Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
定義一個用于創建對象的接口，讓子類決定實例化哪一個類。工廠方法使一個類的實例化延遲到其子類
工廠方法模式
- 在工廠方法模型中，抽象產品類Product負責定義產品的共性，實現對事物最抽象的定義
- Creator為抽象創建類，也就是抽象工廠
- ConcreteCreator具體如何創建產品類
抽象產品類
public abstract class Product{
//產品類的公共方法
public void method1(){
//doSomething
}
//抽象方法
public abstract void method2();
}
具體產品類
public class ConcreteProduct1 extends Product {
public void method2(){
//doSomething
}
}
public class ConcreteProduct2 extends Product {
public void method2(){
//doSomething
}
}
抽象工廠類
/**
* 抽象工廠類負責定義產品對象的產生
*/
public abstract class Creator{
/**
* 創建一個產品對象，其輸入參數類型可以自行設置
* 通常為String、Enum、Class等，也可以為空
*/
public abstract <T extends Product> T createProduct(Class<T> c);
}
具體工廠類
public class ConcreteCreator extends Creator {
public <T extends Product> T createProduct(Class<T>c ){
Product product = null;
try {
product = (Product)Class.forName(c.getNmae()).newInstance();
}catch (Exception e) {
//異常處理
}
return (T)product;
}
}
場景類Client
public class Client{
public static void main(String[] args) {
Creator creator = new ConcreteCreator();
Product product = creator.createProduct(ConcreteProduct1.class);
/**
* 繼續業務邏輯
*/
}
}
工廠方法模式的優缺點
工廠方法模式的優點
- 良好的封裝性
- 代碼結構清晰
- 擴展性非常優秀
- 屏蔽產品類，產品類的實現如何變化，調用者都不需要關心，只關心產品的接口，只要接口不變，系統中的上層模塊就不會發生變化
- 工廠方法模式是典型的解耦框架
- 高層模塊值只需要知道產品的抽象類，其他的實現類都不需要關系，符合迪米特法則，不需要的就不去了解
- 符合依賴倒置原則，只依賴產片類的抽象
- 符合里氏替換原則，可以用產品子類替代產品父類
工廠方法模式的使用場景
- 工廠方法模式是new一個對象的替代品，但是需要慎重地考慮是否增加一個工廠類進行管理，增加代碼的復雜度
- 需要靈活的，可擴展的框架時，可以考慮采用工廠方法模式
1.工廠方法模式的擴展——縮小為簡單工廠模式
- 一個模塊僅需要一個工廠類，沒必要生產出來，使用靜態的方法就可以
- 類圖變得簡單，模式是工廠方法模式的弱化
簡單工廠模式
變化
- 去掉了AbstractHumanFactory
- 同時把createHuman方法設置為static靜態類型，簡化了類的創建過程
源碼變化僅HumanFactory和NvWa
人類創建工廠: HumanFactory
public class HumanFactory {
public static <T extends Human> T createHuman(Class<T> c){
Human human = null;
try {
human = (Human)Class.forName(c.getName()).newInstance();
}catch (Exception e) {
System.out.println("人種生成錯誤");
}
return (T)human;
}
}
場景類Client：NvWa
- 直接HumanFactory的靜態方法
public class NvWa{
public static void main(String[] args) {
// AbstractHumanFactory abstractHumanFactory = new HumanFactory();
System.out.println("生產白人");
Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);
whiteHuman.getColor();
whiteHuman.talk();
System.out.println("生產黑人");
Human blackHuman = HumanFactory.createHuman(BlackHuman.class);
blackHuman.getColor();
blackHuman.talk();
System.out.println("生產黃種人");
Human yelloHuman = HumanFactory.createHuman(YellowHuman.class);
yelloHuman.getColor();
yelloHuman.talk();
}
}
2.升級為多工廠模式
多個工廠類的類圖
多工廠模式的抽象工廠類
- 抽象方法不在需要傳遞相關參數了，每個具體的工廠都已經非常明確自己的職責：創建自己負責的產片類對象
public abstract class AbstractHumanFactory{
public abstract Human createHuman();
}
各色人種的創建工廠
public abstract class BlackHumanFactory extends AbstractHumanFactory{
public Human createHuman(){
return new BlackHuman();
}
}
public abstract class WhiteHumanFactory extends AbstractHumanFactory{
public Human createHuman(){
return new WhiteHuman();
}
}
public abstract class YellowHumanFactory extends AbstractHumanFactory{
public Human createHuman(){
return new YellowHuman();
}
}
場景類Client
public class NvWa{
public static void main(String[] args) {
// AbstractHumanFactory abstractHumanFactory = new HumanFactory();
System.out.println("生產白人");
Human whiteHuman = (new WhiteHumanFactory()).createHuman();
whiteHuman.getColor();
whiteHuman.talk();
System.out.println("生產黑人");
Human blackHuman = (new BlackHumanFactory()).createHuman();
blackHuman.getColor();
blackHuman.talk();
System.out.println("生產黃種人");
Human yelloHuman = (new YellowHumanFactory()).createHuman();
yelloHuman.getColor();
yelloHuman.talk();
}
}
3.替代單例模式
工廠方法模式替代單例模式類圖
工廠類
public class SingletonFactory{
private static Singleton singleton;
static{
try {
Class cl = Class.forName(Singleton.class.getName());
//獲得無參構造
Constructor constructor = cl.getDeclaredConstructor();
//設置無參構造是可訪問的
constructor.setAccessible(true);
//產生一個實例對象
singleton = (Singleton)constructor.newInstance();
}catch (Exception e) {
//異常處理
}
}
public static Singleton getSingleton(){
return singleton;
}
}
單例類
public class Singleton{
//不允許通過new產生一個對象
private Singleton(){
}
public void doSomething(){
//doSomething
}
}
4.延遲初始化lazy initialization
延遲初始化的通用類圖
ProductFactory負責產品類對象的創建工作，并通過prMap變量產生一個緩存，對需要再次被重用的對象保留
抽象產品類
public abstract class Product{
//產品類的公共方法
public void method1(){
//doSomething
}
//抽象方法
public abstract void method2();
}
具體產品類
public class ConcreteProduct1 extends Product {
public void method2(){
//doSomething
}
}
public class ConcreteProduct2 extends Product {
public void method2(){
//doSomething
}
}
產品工廠
public class ProductFactory {
private static final Map<String, Product> prMap = new HashMap();
public static synchronized Product createProduct(String type) throws Exception{
Product product = null;
//如果Map中已有這個對象
if(prMap.containsKey(type)){
product = prMap.get(type);
}else{
if(type.equals("ConcreteProduct1")){
product = new ConcreteProduct1();
}else{
product = new ConcreteProduct2();
}
prMap.put(type, product);
}
return product;
}
}
