今天是：
带着程序的旅程，每一行代码都是你前进的一步，每个错误都是你成长的机会，最终，你将抵达你的目的地。
title

设计模式-工厂模式（Factory）

定义

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种统一的接口来创建对象，但将具体对象的创建延迟到子类或具体工厂类中。工厂模式通过封装对象的创建过程，使客户端代码与具体对象的实例化过程分离，从而实现了松耦合和更好的代码可维护性。

意图

  • 松耦合（Loose Coupling）： 工厂模式通过将对象的创建过程封装在工厂中，降低了客户端代码与具体对象的耦合程度。客户端不需要知道如何实例化具体对象，只需要与工厂接口交互，这使得代码更加灵活和易于维护。

  • 可扩展性（Scalability）： 工厂模式使得在不修改现有客户端代码的情况下可以添加新的产品或具体工厂类。这样，系统可以轻松地支持新的产品类型或变种。

  • 代码复用： 工厂模式促使客户端代码重用，因为客户端通过抽象工厂接口与产品交互，可以在不修改客户端的情况下更换具体工厂类，以创建不同类型的产品。

  • 封装对象创建过程： 工厂模式将对象创建的复杂性和细节封装在具体工厂中，使客户端代码更简洁和清晰。

  • 适用于多种产品族： 抽象工厂模式引入了一层抽象工厂，可以创建一组相关的产品对象。这对于创建多种不同产品族的对象非常有用。

种类

  • 简单工厂 ： 使用一个工厂对象用来生产同一等级结构中的任意产品。（不支持拓展增加产品）
  • 工厂方法 ： 使用多个工厂对象用来生产同一等级结构中对应的固定产品。（支持拓展增加产品）
  • 抽象工厂 ： 使用多个工厂对象用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）

参与者

  • 抽象工厂（Abstract Factory）： 定义了创建产品对象的接口，通常包含一个或多个抽象的工厂方法。这是工厂模式的核心，客户端将通过这个接口来请求产品的创建。

  • 具体工厂（Concrete Factory）： 实现了抽象工厂接口，负责实际创建具体产品对象。每个具体工厂通常对应创建一类产品。

  • 抽象产品（Abstract Product）： 定义了产品对象的通用接口，通常包括产品对象的属性和方法的声明。

  • 具体产品（Concrete Product）： 实现了抽象产品接口，表示被创建的具体对象。

  • 客户端（Client）： 负责使用工厂来创建产品对象，而不需要直接实例化具体产品。客户端通过抽象工厂接口与产品进行交互，从而实现了松耦合。

举例

简单工厂

生产宝马汽车的工厂，这个工厂会生产520和525类型的宝马车

工厂的createBMW方法用于生产不同的宝马车

public  class FactoryBMW {
		public BWM createBMW(String name){
			if(name.equals("BWM520LI")){
				return new BWM520Li(name);
			}if(name.equals("BWM525LI")){
				return new BWM525Li(name);
			}else{
				return null;
			}
		};
		public static void main(String[] args) {
			FactoryBMW fb =new FactoryBMW();
			BWM  bwm525 =fb.createBMW("BWM525LI");
			BWM  bwm520 = fb.createBMW("BWM520LI");
			System.out.println(bwm520.getName());
			System.out.println(bwm525.getName());
		}
}
优点：

  1. 简单性： 简单工厂模式是一种简单的模式，易于理解和实现。它将对象的创建逻辑封装在一个工厂类中，客户端只需通过工厂类来创建对象，而不需要关心对象的具体创建细节。

  2. 封装： 简单工厂模式有助于将对象创建的复杂性封装起来，使客户端代码保持简洁和清晰。客户端不需要了解对象的创建方式或构造函数。

  3. 松耦合： 简单工厂模式降低了客户端与具体对象的耦合。客户端只需与工厂类交互，而不需要直接与具体对象类交互，这使得客户端代码更容易维护和扩展。

  4. 中心化控制： 简单工厂模式允许将对象的创建逻辑集中在一个位置，有助于统一管理和维护对象的创建过程。

缺点：

  1. 不适用于复杂对象结构： 简单工厂模式适用于创建较简单的对象，当对象的创建过程较为复杂且多样化时，简单工厂模式可能变得笨拙和难以维护。

  2. 违反开放封闭原则： 当需要添加新的产品类型时，通常需要修改工厂类的代码，这违反了开放封闭原则。这意味着维护现有的工厂类可能需要对代码进行修改，可能会导致不稳定的代码。

  3. 难以扩展工厂： 如果需要在简单工厂模式中添加新的产品类型，通常需要修改工厂类，这可能导致工厂类变得庞大和难以维护。这也可能影响其他客户端代码。

工厂方法

不同的型号使用不同的工厂创建

public class FactoryBWM520LI implements FactoryBWM {

	@Override
	public BWM createBWM() {
		
		return new BWM520Li("BWM520LI");
	}

}
public class FactoryBWM525LI implements FactoryBWM {


	@Override
	public BWM createBWM() {
		// TODO Auto-generated method stub
		return new BWM525Li("BWM525LI");
	}

}
	public static void main(String[] args) {
		FactoryBWM520LI bwm520li =new FactoryBWM520LI();
		System.out.println(bwm520li.createBWM().getName());
		FactoryBWM525LI bwm525li = new FactoryBWM525LI();
		System.out.println(bwm525li.createBWM().getName());
	}
优点：

  1. 松耦合（Loose Coupling）： 工厂方法模式将具体产品的创建延迟到具体工厂类中，客户端与具体产品之间的耦合度更低，客户端只需与抽象工厂接口交互，无需直接依赖于具体产品类。

  2. 可扩展性： 工厂方法模式支持添加新的产品类型，只需创建新的具体工厂类和具体产品类，而不需要修改现有代码。这遵循开放封闭原则，使系统更易于扩展。

  3. 隐藏细节： 工厂方法模式将对象的创建过程封装在工厂类中，客户端代码无需关心对象的具体创建细节，这提高了代码的清晰度和可维护性。

  4. 多态性： 工厂方法模式允许客户端以统一的方式创建产品，从而支持多态性。客户端可以根据需要选择不同的具体工厂来创建对象，实现了多态性的特性。

  5. 适应不同需求： 工厂方法模式适用于各种不同的需求和情况，可以创建多种不同类型的产品。

缺点：

  1. 类爆炸： 如果有多个产品等级结构和多个具体工厂类，可能会导致类的数量急剧增加，这被称为类爆炸问题。管理大量的工厂和产品类可能会变得复杂。

  2. 增加复杂度： 工厂方法模式引入了更多的接口和抽象类，使系统的结构变得更加复杂。这可能增加一些开发和维护的成本。

  3. 不适用于简单情况： 对于一些简单的对象创建需求，工厂方法模式可能过于繁琐，不如简单工厂模式来得直接。

抽象工厂

520和525工厂可以别生产对应的 发动机和空调

BWM520LIFactory 

public class BWM520LIFactory implements BWMFactory {


	@Override
	public Engine createEngine() {
		// TODO Auto-generated method stub
		return new BWM520LIEngine();
	}


	@Override
	public AriCondition createAriCondition() {
		return new AirBWM520LI();
	}

}

BWM525LIFactory  

public class BWM525LIFactory implements BWMFactory {


	@Override
	public Engine createEngine() {
		// TODO Auto-generated method stub
		return new BWM525LIEngine();
	}


	@Override
	public AriCondition createAriCondition() {
		// TODO Auto-generated method stub
		return new AirBWM525LI();
	}

}
优点：

  1. 松耦合： 抽象工厂模式通过将对象的创建逻辑封装在抽象工厂中，降低了客户端代码与具体对象的耦合。客户端只需与抽象工厂接口交互，无需直接依赖于具体产品类。

  2. 可扩展性： 抽象工厂模式支持添加新的产品族，只需创建新的具体工厂类和具体产品类，而不需要修改现有代码。这遵循开放封闭原则，使系统更易于扩展。

  3. 隐藏细节： 抽象工厂模式将对象的创建过程封装在抽象工厂类中，客户端代码无需关心对象的具体创建细节，这提高了代码的清晰度和可维护性。

  4. 多态性： 抽象工厂模式允许客户端以统一的方式创建产品，从而支持多态性。客户端可以根据需要选择不同的具体工厂来创建对象，实现了多态性的特性。

  5. 一致性： 抽象工厂模式确保了一组相关的产品对象能够协同工作，因为它们由同一工厂创建，这有助于确保产品之间的一致性。

缺点：

  1. 类爆炸： 如果有多个产品族和多个具体工厂类，可能会导致类的数量急剧增加，这被称为类爆炸问题。管理大量的工厂和产品类可能会变得复杂。

  2. 增加复杂度： 抽象工厂模式引入了更多的接口和抽象类，使系统的结构变得更加复杂。这可能增加一些开发和维护的成本。

  3. 不适用于简单情况： 对于一些简单的对象创建需求，抽象工厂模式可能过于繁琐，不如简单工厂模式或工厂方法模式来得直接。

Spring中的工厂模式

BeanFactory的继承关系

Spring BeanFactory

 

BeanFactory 接口在 Spring Framework 中通常用作工厂方法模式的实现。它定义了一组方法，用于创建和管理 Bean 实例。每个具体的 Bean 工厂（如 DefaultListableBeanFactory）都实现了这个接口，负责创建特定类型的 Bean 实例。因此，BeanFactory 接口是工厂方法模式的实现，它将对象的创建委托给具体的工厂类，每个工厂类负责创建特定类型的对象（Bean）。这种模式使得代码更具弹性和可维护性，因为可以根据需要添加或更改工厂类来创建不同类型的 Bean。因此BeanFactory 接口更符合工厂方法模式的概念，它定义了一组方法用于创建和管理 Bean 实例

 分享到：

专栏

每日推荐

类型标签

    更多>>

    外部链接

    百度一下

    今日头条

    必应搜索

    Google

    CSDN

    CNN

    网站访问总量