1. 日志工厂

一个软件，不管是本地开发调试，还是线上生产运行，日志的收集都是非常重要的。如何设计一个灵活的日志系统呢？

将日志的功能抽象出来，封装成接口：

public interface Logger {

    // 调试信息
    void debug(String message);

    // 错误信息
    void error(String message);
}

每个日志记录器都应该有自己的名称，不然你怎么知道是谁输出的日志呢？

public abstract class AbstractLogger implements Logger {
    protected String name;// 日志记录器名称

    public AbstractLogger(String name) {
        this.name = name;
    }
}

本地开发调试，只需要将日志输出到控制台就好了，无需持久化存储。

public class ConsoleLogger extends AbstractLogger {

    public ConsoleLogger(String name) {
        super(name);
    }

    @Override
    public void debug(String message) {
        System.out.println(name + " -- " + message);
    }

    @Override
    public void error(String message) {
        System.err.println(name + " -- " + message);
    }
}

线上环境，没人会盯着日志去看，所以需要将日志写入磁盘文件，后面排查错误时你就知道它的重要性了。

public class FileLogger extends AbstractLogger{
    private File debugLogFile = new File(System.getProperty("user.dir"), "logs/debug.log");
    private File errorLogFile = new File(System.getProperty("user.dir"), "logs/error.log");

    public FileLogger(String name) {
        super(name);
    }

    @Override
    public void debug(String message) {
        FileUtil.appendUtf8String(name + " -- " + message, debugLogFile);
    }

    @Override
    public void error(String message) {
        FileUtil.appendUtf8String(name + " -- " + message, errorLogFile);
    }
}

日志的两种实现都有了，分别是控制台输出和写入磁盘文件。
那么，如何生成Logger实例呢？手动new吗？
你怎么知道我需要哪种实现？万一后面又增加了新的需求，需要将日志写入ElasticSearch作离线分析呢？你又要怎么做？

客户端只依赖日志接口，具体Logger实例的创建交给工厂吧。

定义日志工厂接口：

public interface LoggerFactory {

    // 获取日志记录器
    Logger getLogger(String name);
}

专门生产控制台日志的工厂：

public class ConsoleLoggerFactory implements LoggerFactory {

    @Override
    public Logger getLogger(String name) {
        return new ConsoleLogger(name);
    }
}

专门生产文件日志的工厂：

public class FileLoggerFactory implements LoggerFactory{

    @Override
    public Logger getLogger(String name) {
        return new FileLogger(name);
    }
}

客户端调用：

public class Client {
    public static void main(String[] args) {
        LoggerFactory factory = new FileLoggerFactory();
        Logger logger = factory.getLogger(Client.class.getName());
        logger.error("哈哈");
    }
}

后面如果加了新的日志实现，只需要再扩展一个工厂类就好了。
这就是工厂方法模式。

2. 工厂方法模式的定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

在这里插入图片描述

<center><b><font color=red>工厂方法模式通用类图</font></b></center>

Product：产品的抽象类或接口，负责定义产品的特征和共性。
ConcreteProduct：具体的产品类。
Creator：产品的创建类，工厂接口。
ConcreteCreator：具体的创建类，工厂实现。

3. 工厂方法模式的优点

工厂方法模式，封装了对象创建的过程，对外屏蔽了复杂对象的创建细节，而且降低了类间的耦合。客户端只依赖产品的抽象，无需知道产品实现，让产品工厂来完成对象的创建。

客户端使用简单，无需知道复杂对象的创建过程。
工厂可以控制对象的创建数量，避免内存溢出，还可以复用对象，避免频繁创建和销毁。
工厂可以提前创建好一批对象，以便快速响应客户端。
降低耦合，客户端只依赖产品抽象，符合依赖倒置原则。
客户端不关心具体实现类，只关心工厂，符合迪米特法则。
扩展的产品子类可随时替换父类，符合里氏替换原则。

工厂方法模式是new关键字的替代品，它提供了创建对象的一种绝佳的方式，任何需要创建对象的地方都可以考虑使用该模式。缺点是需要增加工厂类，代码复杂度会提高，需要结合实际情况考虑。

4. 工厂方法模式的扩展

4.1 降级为简单工厂

如果一个模块很简单，只需要一个工厂类，就可以降级为简单工厂，使用静态方法来创建对象。

public class SimpleFactory {
    /**
     * 优点:实现简单
     * 缺点:增加一个产品类型就要修改工厂,不符合开闭原则、static无法定义层级结构
     * @param type
     * @return
     */
    public static Product create(ProductType type) {
        switch (type){
            case A:
                return new ProductA();
            case B:
                return new ProductB();
            default:
                return null;
        }
    }
}

4.2 替代单例模式

单例模式本身既要负责业务逻辑，又要保证单例，不符合单一职责原则，可以使用工厂模式来替代单例模式，由工厂类来保证单例，而不是单例类本身。

class Singleton{
    private Singleton(){}
}

class SingletonFactory{
    private static Singleton INSTANCE;

    static {
        try {
            Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
            constructor.setAccessible(true);
            INSTANCE = constructor.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

4.3 对象复用

对于可以复用的对象，工厂类可以将实例缓存起来，避免频繁的创建和销毁。这在很大程度上可以降低系统的性能开销，减轻GC的压力。

class ProductFactory {
    private static final Map<ProductType, Product> CACHE = new ConcurrentHashMap<>();

    public static Product getProduct(ProductType productType) {
        if (!CACHE.containsKey(productType)) {
            synchronized (ProductFactory.class) {
                if (!CACHE.containsKey(productType)) { // recheck
                    switch (productType) {
                        case A:
                            CACHE.put(productType, new ProductA());
                            break;
                        case B:
                            CACHE.put(productType, new ProductB());
                            break;
                    }
                }
            }
        }
        return CACHE.get(productType);
    }
}

5. 总结

工厂方法模式在项目中使用的非常频繁，很多开源框架都能看到它的影子，它提供了对象创建的一种绝佳方式，凡是需要创建对象的地方，都可以考虑使用工厂方法模式。

工厂方法模式-日志工厂