工厂模式
在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严
重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。
如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，
直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦。
在本文章中会介绍三种工厂的使用
- 简单工厂模式（不属于GOF的23种经典设计模式）
- 工厂方法模式
- 抽象工厂模式
案例
在CoffeeStore类中，会根据客户提供的商品名称来判断coffee种类。目前咖啡店只有两种咖啡，如果咖啡店新增了几种coffee，就需要更改CoffeeStore类的代码，此处表现为新增几个if else判断语句。这就违反开闭原则（允许扩展，禁止修改）
简单工厂模式
简单工厂不是一种设计模式，反而比较像是一种编程习惯。
简单工厂包含如下角色：
- 抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。
- 具体产品 ：实现或者继承抽象产品的子类
- 具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。
类图
和案例的类图对比发现，简单工厂就是在CoffeeStore和Coffee之间多了一个工厂，之前制作咖啡的代码写在CoffeeStore中，现在写在了SimpleCoffeeFactory里面了（你可以理解为外包了）
SimpleCoffeeFactory简单工厂类代码
/**
* @author Watching
* * @date 2023/3/15
* * Describe:简单工厂制造咖啡
*/
public class CoffeeFactory {
public Coffee makeCoffee(String type){
Coffee coffee=null;
if("latte".equals(type)){
coffee = new LatteCoffee();
}else if("american".equals(type)){
coffee = new AmericanCoffee();
}else{
throw new RuntimeException("没有这种咖啡");
}
return coffee;
}
}
CoffeeStore类代码
public class CoffeeStore {
public Coffee orderCoffee(String type){
//使用简单工厂将制造咖啡的代码抽取出去，若是需要制造新咖啡，就不需要更改此处的代码了，但是工厂里的代码又耦合了
CoffeeFactory coffeeFactory = new CoffeeFactory();
Coffee coffee = coffeeFactory.makeCoffee(type);
coffee.addMilk();
coffee.addSugar();
return coffee;
}
}
可以看到，在CoffeeStore中没有条件判断语句了，我们将它们放进了工厂。即使新增咖啡种类，CoffeeStore也不用修改代码了。于是 CoffeeStore类和Coffee类就解耦了 但是！ 简单工厂又和Coffee类耦合了
优缺点
- 优点：
封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避
免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户
代码修改的可能性，更加容易扩展。 - 缺点：
增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。
静态工厂模式
就是将简单工厂模式中的方法设置为静态的，静态工厂模式也不是23中设计模式之中的
/**
* @author Watching
* * @date 2023/3/15
* * Describe:静态工厂制造咖啡
*/
public class CoffeeFactory {
//将方法设为静态的
public static Coffee makeCoffee(String type){
Coffee coffee=null;
if("latte".equals(type)){
coffee = new LatteCoffee();
}else if("american".equals(type)){
coffee = new AmericanCoffee();
}else{
throw new RuntimeException("没有这种咖啡");
}
return coffee;
}
}
工厂方法模式
将工厂也抽象为一个接口，实现接口创建不同的工厂类，不同的工厂类负责创建不痛的Coffe
-
抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂
方法来创建产品。 -
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
-
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
-
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
类图
抽象工厂接口代码
/**
* @author Watching
* * @date 2023/3/15
* * Describe:工厂接口，其它工厂类需要实现该接口并重写方法
*/
public interface CoffeeFactory {
public Coffee makeCoffee();
}
具体工厂代码之一
/**
* @author Watching
* * @date 2023/3/15
* * Describe:具体工厂
*/
public class LatteCoffeeFactory implements CoffeeFactory{
@Override
public Coffee makeCoffee() {
return new LatteCoffee();
}
}
抽象咖啡类
public abstract class Coffee {
public abstract String getName();
public void addMilk(){
System.out.println("add milk");
}
public void addSugar(){
System.out.println("add sugar");
}
}
具体咖啡类之一
/**
* @author Watching
* * @date 2023/3/15
* * Describe:具体咖啡类
*/
public class AmericanCoffee extends Coffee{
@Override
public String getName() {
return "美式咖啡";
}
}
咖啡店代码
/**
* @author Watching
* * @date 2023/3/15
* * Describe:咖啡店
*/
public class CoffeeStore {
//创建一个抽象工厂变量
private CoffeeFactory coffeeFactory;
public CoffeeStore() {
}
public CoffeeStore(CoffeeFactory coffeeFactory){
this.coffeeFactory = coffeeFactory;
}
//利用set方法将具体的咖啡工厂注入咖啡店的抽象工厂变量，使用多态
public void setCoffeeFactory(CoffeeFactory coffeeFactory) {
this.coffeeFactory = coffeeFactory;
}
//此时直接使用抽象工厂变量调用制作咖啡方法，由于多态，调用的将会是子类的方法
public Coffee orderCoffee(){
return coffeeFactory.makeCoffee();
}
}
使用工厂方法模式，我们发现如果此时增加新的咖啡种类，不需要更改咖啡店代码，也不需要更改咖啡工厂代码，只需要增加新的具体工厂类实现抽象工厂和具体咖啡类实现抽象Coffee类。满足了开闭原则
优缺点
优点
- 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
- 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；
缺点
- 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。产生”类爆炸“
抽象工厂模式
抽象工厂模式的主要角色如下：
- 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
- 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
- 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
- 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
类图
抽象工厂代码
/**
* @author Watching
* * @date 2023/3/15
* * Describe:抽象甜品工厂
*/
public interface DessertFactory {
Coffee createCoffee();
Dessert createDessert();
}
具体工厂代码
/**
* @author Watching
* * @date 2023/3/15
* * Describe:美式抽象工厂
* 生产美式咖啡和抹茶
*/
public class AmericanDessertFactory implements DessertFactory{
@Override
public Coffee createCoffee() {
return new AmericanCoffee();
}
@Override
public Dessert createDessert() {
return new Match();
}
}
/**
* @author Watching
* * @date 2023/3/15
* * Describe:意大利风味的甜品抽象工厂
* 生产拿铁和提拉米苏
*/
public class ItalyDessertFactory implements DessertFactory{
@Override
public Coffee createCoffee() {
return new LatteCoffee();
}
@Override
public Dessert createDessert() {
return new Tiramisu();
}
}
如果要加同一个产品族的话，只需要再加一个对应的工厂类即可，不需要修改其他的类。
优缺点
-
优点：
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。 -
缺点：
当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。
使用场景
-
当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
-
系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
-
系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。
简单工厂+配置文件实现咖啡店
首先将所有的甜品种类写在配置文件bean.properties中
配置文件中写的是咖啡名称=咖啡类的全类名
american=工厂模式.简单工厂加配置文件咖啡店.AmericanCoffee
latte=工厂模式.简单工厂加配置文件咖啡店.AmericanCoffee
除了简单工厂类，其余和上面的简单工厂实现咖啡店一致
简单工厂类代码
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Properties;
import java.util.Set;
/**
* @author Watching
* * @date 2023/3/15
* * Describe：静态工厂+配置文件 获取配置文件中的数据，通过反射创建对像
*/
public class CoffeeFactory {
//创建一个map集合存放生成的对象
private static HashMap<String,Coffee> map = new HashMap<>();
//静态代码块只会加载一次
//在静态代码块中获取配置文件中的数据，并通过反射机制创建对象
static{
Properties properties = new Properties();
ClassLoader classLoader = CoffeeFactory.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("工厂模式/简单工厂加配置文件咖啡店/bean.properties");
InputStreamReader isr = new InputStreamReader(is, StandardCharsets.UTF_8);//将InputStream字节流转换为字符流，方便读取中文
try {
properties.load(isr);
Set<Object> objects = properties.keySet();
for (Object object : objects) {
String key = (String) object;
String className = properties.getProperty(key);
Class<?> clazz = Class.forName(className);
Coffee coffee = (Coffee) clazz.newInstance();
map.put(key,coffee);
}
} catch (Exception e) {
e.printStackTrace();
}
}
//提供一个静态方法从map集合中获取目标对象并返回
public static Coffee createCoffee(String name){
return map.get(name);
}
}
静态成员变量用来存储创建的对象（键存储的是名称，值存储的是对应的对象），而读取配置文件以及
创建对象写在静态代码块中，目的就是只需要执行一次。
扫一扫
3573
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
