设计模式1：工厂模式

开始学习设计模式，这是小卷学习设计模式的第1篇文章，今天了解下工厂模式，以及框架中用到工厂模式的案例

1.概览

2.分类

设计模式分为三类：

• 创建型：在创建对象的同时隐藏创建逻辑，不使用new直接实例化对象，程序判断创建哪些对象时更灵活
• 结构型：通过类和接口间的继承、引用实现创建复杂结构的对象。
• 行为型：通过类之间不同通信方式实现不同行为。

工厂模式属于创建型设计模式，具体可以分为三类：

• 简单工厂模式，定义一个工厂类，根据传入参数动态创建不同类型的对象，缺点是新增产品需要修改工厂类逻辑，违背开闭原则
• 工厂方法模式，将对象的创建延迟到子类，每个产品对应一个工厂类，扩展更好
• 抽象工厂模式，用于创建产品族（多个相关联的系列对象），比如汽车工厂同时生产轮胎和引擎

3.简单工厂模式

简单⼯⼚模式指由⼀个⼯⼚对象来创建实例，客户端不需要关注创建逻

辑，只需提供传⼊⼯⼚的参数。

如：Spring的BeanFactory使用了简单工厂模式，根据传入一个唯一标识来获取Bean对象

下面是简单工厂模式的示例代码：

interface Car {
    void drive();
}

class Benz implements Car {
    @Override
    public void drive() {
        System.out.println("Benz.......");
    }
}

class Bmw implements Car {
    @Override
    public void drive() {
        System.out.println("Bmw......");
    }
}

class CarFactory {
    public Car createCar(String type) {
        if ("Benz".equals(type)) {
            return new Benz();
        }
        if ("Bmw".equals(type)) {
            return new Bmw();
        }
        throw new IllegalArgumentException("unknown type");
    }
}

public class SimpleFactory {
    public static void main(String[] args) {
        Car car = CarFactory.createCar("Bmw");
        car.drive(); //输出Bmw......
    }
}

4.工厂方法模式

定义一个抽象⼯⼚，其定义了产品的⽣产接⼝，但不负责具体的产

品，将⽣产任务交给不同的派⽣类⼯⼚

示例代码：

//工厂接口
interface CarFactory {
    Car createCar();
}
//每个产品对应一个工厂
class BenzFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Benz();
    }
}

class BmwFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Bmw();
    }
}

public class MethondFactory {
    public static void main(String[] args) {
        CarFactory carFactory = new BenzFactory();
        Car car = carFactory.createCar();
        car.drive(); //输出Benz.......
    }
}

5.抽象工厂模式

简单⼯⼚模式和⼯⼚⽅法模式不管⼯⼚怎么拆分抽象，都只是针对⼀类产

品，如果要⽣成另⼀种产品，就⽐较难办了！

抽象工厂模式通过在 AbstarctFactory 中增加创建产品的接⼝，并在具体⼦

工厂中实现新加产品的创建

//产品族接口（汽车 + 轮胎）
interface Car {
    void drive();
}

interface Tire {
    void wear();
}

//具体产品族，Benz族系列
class BenzCar implements Car {
    @Override
    public void drive() {
        System.out.println("Benz Car.......");
    }
}

class BenzTire implements Tire {
    @Override
    public void wear() {
        System.out.println("Benz Tire......");
    }
}
//抽象工厂接口
interface CarAbstractFactory {
    Car createCar();
    Tire createTire();
}
//具体工厂实现
class BenzFactory implements CarAbstractFactory {
    @Override
    public Car createCar() {
        return new BenzCar();
    }
    @Override
    public Tire createTire() {
        return new BenzTire();
    }
}
//使用
public class AbstractFactory {
    public static void main(String[] args) {
        CarAbstractFactory carAbstractFactory = new BenzFactory();
        Car car = carAbstractFactory.createCar();
        Tire tire = carAbstractFactory.createTire();
        car.drive(); //输出Benz Car.......
        tire.wear();
    }
}

6.具体框架案例

如SLF4J的LoggerFactory就使用了工厂模式 ，调用getLogger()方法来获取Logger实例

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Demo {
    private static final Logger logger = LoggerFactory.getLogger(Demo.class);
    
    public static void main(String[] args) {
        logger.info("Hello SLF4J");
    }
}