本文深入探讨了工厂模式，包括简单工厂、工厂方法和抽象工厂模式。通过实例展示了如何在Java中实现这些模式，以创建油漆产品及其附属产品，强调了解耦和扩展性的重要性。工厂模式在创建对象时隐藏了具体实现细节，提高了代码的灵活性和可维护性。
工厂模式(复习笔记 2021.6.11)
前言:
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
**意图：**定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
**主要解决：**主要解决接口选择的问题。
**何时使用：**我们明确地计划不同条件下创建不同实例时。
**如何解决：**让其子类实现工厂接口，返回的也是一个抽象的产品。
**关键代码：**创建过程在其子类执行。
应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。
优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。
**缺点：**每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。
**注意事项：**作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。
工厂模式分为3种:
1: 简单工厂模式 (根据方法参数, 生产出不同的实例)
2: 方法工厂模式 (简单工厂的升级版, 为每一种实例构建不同的工厂, 对应工厂只负责生产对应实例)
3: 抽象工厂模式 (一个工厂, 不单单只能生产一种实例)
前提条件:
我们开了一家油漆工厂, 店内在售卖一种品牌油漆。
油漆(涂料) 是一个接口, 里面指定了涂料的保质期、品牌、颜色
public interface Coating {
LocalDateTime shelfLife();
String brand();
String color();
}
假设根据用户需要的清单, 获取不同颜色的油漆, 普通的面向实现方式:
@Test
public void applicationTest() throws Exception {
Coating coating = null;
String color = "green";
if ("red".equals(color)){
coating = new RedCoating();
}else if ("green".equals(color)){
coating = new GreenCoating();
}
System.out.println("油漆品牌:"+coating.brand());
System.out.println("油漆保质期:"+coating.shelfLife());
System.out.println("油漆颜色:"+coating.color());
}
//-----------
油漆品牌:嘉宝莉
油漆保质期:2021-06-12T00:00
油漆颜色:绿色
简单工厂:
下面利用简单工厂进行解耦, 不在由我们进行手动创建(new), 改为被动的从工厂获取实例对象
1.1 定义一个简单工厂
/**
* @Author: ZhiHao
* @Date: 2021/6/8 16:47
* @Description: 简单工厂
* @Versions 1.0
**/
public class SimpleFactory {
private String color;
public SimpleFactory(String color) {
this.color = color;
}
/**
* 判断逻辑从业务方, 移到了工厂
*
* @return com.zhihao.interfaces.Coating
* @author: ZhiHao
* @date: 2021/6/8
*/
public Coating createCoating() {
Coating coating = null;
if ("red".equals(color)) {
coating = new RedCoating("嘉宝莉");
} else if ("green".equals(color)) {
coating = new GreenCoating("嘉宝莉");
}
return coating;
}
}
1.2 业务方
改为被动的获取实例对象
@Test
public void applicationTest() throws Exception {
String color = "red";
SimpleFactory simpleFactory = new SimpleFactory(color);
Coating coating = simpleFactory.createEntity();
System.out.println("油漆品牌:"+coating.brand());
System.out.println("油漆保质期:"+coating.shelfLife());
System.out.println("油漆颜色:"+coating.color());
}
//
油漆品牌:嘉宝莉
油漆保质期:2021-06-08T18:48:11.226
油漆颜色:红色
这就是最简单的工厂模式, 根据参数生产实例对象。
后面我们的工厂想扩展做大做强, 开分厂, 不单单只想生产一种嘉宝莉油漆了, 想扩展生产多2种不同品牌的油漆(三棵树, 嘉实多)。
如果这个时候用户想买5桶嘉宝莉与5桶三棵树, 还使用到简单工厂的话, 则需要增加一个创建涂料的参数了, 需要生产什么品牌与什么颜色的油漆了, 下面使用工厂方法进行职责划分更为清晰的模式进行解决!
工厂方法
工厂方法, 是简单工厂的一种升级, 使职责划分更为清晰, 什么工厂生产什么实例对象。 耦合更低
这种情况就需要抽象一个大家都遵守的工厂规则(类似规章制度, 只能生产油漆), 然后允许分厂做决定生产那个牌子。
1.1 定义一个抽象基类工厂
/**
* @Author: ZhiHao
* @Date: 2021/6/9 17:02
* @Description: 需要大家都遵守规则的基础(总厂)
* @Versions 1.0
**/
public abstract class BaseFactory {
/**
* 生产油漆
*
* @return com.zhihao.interfaces.Coating
* @author: ZhiHao
* @date: 2021/6/9
*/
public abstract Coating createCoating();
}
1.2 定义一个专门生产嘉宝莉工厂
/**
* @Author: ZhiHao
* @Date: 2021/6/9 17:09
* @Description: 嘉宝莉工厂
* @Versions 1.0
**/
public class CarpolyFactory extends BaseFactory {
private String color;
public CarpolyFactory() {
}
public CarpolyFactory(String color) {
this.color = color;
}
@Override
public Coating createCoating() {
Coating coating = null;
if ("red".equals(color)) {
coating = new RedCoating("嘉宝莉");
} else if ("green".equals(color)) {
coating = new GreenCoating("嘉宝莉");
}
return coating;
}
}
1.3 定义一个专门生产三棵树工厂
/**
* @Author: ZhiHao
* @Date: 2021/6/9 17:09
* @Description: 三棵树工厂
* @Versions 1.0
**/
public class ThreeTreesFactory extends BaseFactory {
private String color;
public ThreeTreesFactory() {
}
public ThreeTreesFactory(String color) {
this.color = color;
}
@Override
public Coating createCoating() {
Coating coating = null;
if ("red".equals(color)) {
coating = new RedCoating("三棵树");
} else if ("green".equals(color)) {
coating = new GreenCoating("三棵树");
}
return coating;
}
}
1.4 业务方
用户想买5桶嘉宝莉与5桶三棵树的绿色油漆
@Test
public void applicationTest() throws Exception {
String color = "red";
// 先创建出2个工厂
BaseFactory carpolyFactory = new CarpolyFactory(color);
BaseFactory treesFactory = new ThreeTreesFactory(color);
// 生产不同品牌
Coating carpolyCoating = carpolyFactory.createCoating();
Coating treesCoating = treesFactory.createCoating();
System.out.println("油漆品牌:"+carpolyCoating.brand());
System.out.println("油漆保质期:"+carpolyCoating.shelfLife());
System.out.println("油漆颜色:"+carpolyCoating.color());
System.out.println("油漆品牌:"+treesCoating.brand());
System.out.println("油漆保质期:"+treesCoating.shelfLife());
System.out.println("油漆颜色:"+treesCoating.color());
}
//------------
油漆品牌:嘉宝莉
油漆保质期:2021-06-09T17:37:20.998
油漆颜色:红色
油漆品牌:三棵树
油漆保质期:2021-06-09T17:37:20.998
油漆颜色:红色
正式定义:
工厂方法模式定义了一个创建对象的接口, 但由子类决定要实例化的类是哪一个, 工厂方法让类把实例化推迟到子类。
如同在正式定义中所说的, 常常听到其他开发人员说: 工厂方法让子类决定要实例化的类是哪一个。希望不要理解错误, 所谓的“决定”, 并不是指模式允许子类本身在运行时做决定, 而是指在编写创建者类时, 不需要知道实际创建的产品是哪一个。选择了使用哪个子类,自然就决定了实际创建的产品是什么。
后面我们的工厂想进行扩展业务, 不仅仅出售生产油漆了, 想进行根据不同油漆捆绑销售油漆刷子、腻子、手套、等等相关产品。
抽象工厂
不仅仅可以生产一种产品, 可以生产一组产品, 允许客户创建对象的家族, 而无需指定他们的具体类
1.1 定义一个抽象基工厂接口
/**
* @Author: ZhiHao
* @Date: 2021/6/11 18:47
* @Description: 抽象工厂接口
* @Versions 1.0
**/
public interface class AbstractBaseFactory {
/**
* 获取刷子附属产品
*
* @param name
* @return com.zhihao.entity.AffiliatedProduct
* @author: ZhiHao
* @date: 2021/6/11
*/
AffiliatedProduct getBrush(String name);
/**
* 获取手套附属产品
*
* @param name
* @return com.zhihao.entity.AffiliatedProduct
* @author: ZhiHao
* @date: 2021/6/11
*/
AffiliatedProduct getGlove(String name);
}
//----------AffiliatedProduct接口, Brush、Glove都实现了该接口-------
public interface AffiliatedProduct {String affiliatedProductName();}
1.2 定义一个专门生产嘉宝莉附属产品工厂
/**
* @Author: ZhiHao
* @Date: 2021/6/11 19:05
* @Description: 嘉宝莉附属产品工厂
* @Versions 1.0
**/
public class CarpolyAffiliatedFactory implements AbstractBaseFactory {
@Override
public Brush getBrush(String name) {
return new Brush("嘉宝莉"+name);
}
@Override
public Glove getGlove(String name) {
return new Glove("嘉宝莉"+name);
}
}
1.3 定义一个专门生产三棵树附属产品工厂
/**
* @Author: ZhiHao
* @Date: 2021/6/11 19:05
* @Description: 三棵树附属产品工厂
* @Versions 1.0
**/
public class ThreeTreesAffiliatedFactory implements AbstractBaseFactory {
@Override
public Brush getBrush(String name) {
return new Brush("三棵树"+name);
}
@Override
public Glove getGlove(String name) {
return new Glove("三棵树"+name);
}
}
1.4 改造Coating 油漆接口与其实现实体
public interface Coating {
LocalDateTime shelfLife();
String brand();
String color();
// 增加设置与返回附属产品
AffiliatedProduct[] getAffiliatedProducts();
AffiliatedProduct[] setAffiliatedProducts(AffiliatedProduct[] affiliatedProducts);
}
// 修改其2个油漆实体, 增加成员参数, 以下都是增加的参数, 其他参数省略不写
public class RedCoating implements Coating{
private AffiliatedProduct[] affiliatedProducts;
@Override
public AffiliatedProduct[] getAffiliatedProducts() {
return affiliatedProducts;
}
@Override
public AffiliatedProduct[] setAffiliatedProducts(AffiliatedProduct[] affiliatedProducts) {
return this.affiliatedProducts = affiliatedProducts;
}
}
// GreenCoating 实体也和RedCoating 一模一样
1.5 改造工厂方法中createCoating方法
public class ThreeTreesFactory extends BaseFactory {
private String color;
private AbstractBaseFactory baseFactory;
public ThreeTreesFactory(String color) {
this.color = color;
this.baseFactory = new ThreeTreesAffiliatedFactory();
}
@Override
public Coating createCoating() {
Coating coating = null;
if ("red".equals(color)) {
coating = new RedCoating("三棵树");
coating.setAffiliatedProducts(new AffiliatedProduct[]{baseFactory.getBrush("红色油漆捆绑销售刷子")
,baseFactory.getGlove("红色油漆捆绑销售手套")});
} else if ("green".equals(color)) {
coating = new GreenCoating("三棵树");
coating.setAffiliatedProducts(new AffiliatedProduct[]{baseFactory.getBrush("绿色油漆捆绑销售刷子")
,baseFactory.getGlove("绿色油漆捆绑销售手套")});
}
return coating;
}
}
// 嘉宝莉工厂代码也是几乎一模一样
1.6 业务方
@Test
public void applicationTest() throws Exception {
String color = "red";
// 先创建出2个工厂
BaseFactory carpolyFactory = new CarpolyFactory(color);
BaseFactory treesFactory = new ThreeTreesFactory(color);
// 生产不同品牌
Coating carpolyCoating = carpolyFactory.createCoating();
Coating treesCoating = treesFactory.createCoating();
System.out.println("油漆品牌:"+carpolyCoating.brand());
System.out.println("油漆保质期:"+carpolyCoating.shelfLife());
System.out.println("油漆颜色:"+carpolyCoating.color());
Arrays.stream(carpolyCoating.getAffiliatedProducts()).forEach((affiliatedProduct)->
System.out.println(affiliatedProduct.affiliatedProductName()));
System.out.println("-----------------------------");
System.out.println("油漆品牌:"+treesCoating.brand());
System.out.println("油漆保质期:"+treesCoating.shelfLife());
System.out.println("油漆颜色:"+treesCoating.color());
Arrays.stream(treesCoating.getAffiliatedProducts()).forEach((affiliatedProduct)->
System.out.println(affiliatedProduct.affiliatedProductName()));
}
// ----
油漆品牌:嘉宝莉
油漆保质期:2021-06-11T19:47:23.895
油漆颜色:红色
嘉宝莉红色油漆捆绑销售刷子
嘉宝莉红色油漆捆绑销售手套
-----------------------------
油漆品牌:三棵树
油漆保质期:2021-06-11T19:47:23.897
油漆颜色:红色
三棵树红色油漆捆绑销售刷子
三棵树红色油漆捆绑销售手套
从上面可以看出, 我们的工厂油漆并不关心也并不知道附属产品是那个品牌, 达到了解耦,
后续在有附属产品, 则只需要构建一个抽象工厂生产一组附属产品
定义:
抽象工厂模式提供一个接口, 用于创建相关或依赖对象的家族(一组), 而不需要明确指定具体类。
抽象工厂允许客户使用抽象接口来创建一组的相关产品, 而不需要知道(或关心) 实际产出的具体产品是什么, 这样一来客户就从具体的产品中被解耦
1
扫一扫
2106
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
