Java开源框架中的设计模式以及应用场景

前言

设计模式是软件设计中常见问题的典型解决方案，你可以通过对其进行定制来解决代码中的特定设计问题。

关于设计模式，网上有很多讲解。但大部分都是Demo示例，看完有可能还是不知道怎么用。

本文笔者将从设计模式入手，看一看在优秀的Java框架/中间件产品中，不同的设计模式应用场景在哪里。

一、单例模式

单例模式是Java中最简单的设计模式之一，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式虽然很简单，但它的花样一点都不少，我们一一来看。

1、饿汉式

饿汉式，顾名思义，就是我很饿，迫不及待。不管有没有人用，我先创建了再说。

比如在Dubbo中的这段代码，创建一个配置管理器。

public class ConfigManager {
private static final ConfigManager configManager = new ConfigManager(); 
private ConfigManager() {}
public static ConfigManager getInstance() {
    return configManager;
}
} 

又或者在RocketMQ中，创建一个MQ客户端实例的时候。

public class MQClientManager {

private static MQClientManager instance = new MQClientManager();
private MQClientManager() {}
public static MQClientManager getInstance() {
    return instance;
}
} 

 

2、懒汉式

懒汉式是对应饿汉式而言的。它旨在第一次调用才初始化，避免内存浪费。但为了线程安全和性能，一般都会使用双重检查锁的方式来创建。

我们来看Seata框架中，通过这种方式来创建一个配置类。

public class ConfigurationFactory{

private static volatile Configuration CONFIG_INSTANCE = null;
public static Configuration getInstance() {
    if (CONFIG_INSTANCE == null) {
        synchronized (Configuration.class) {
            if (CONFIG_INSTANCE == null) {
                CONFIG_INSTANCE = buildConfiguration();
            }
        }
    }
    return CONFIG_INSTANCE;
}
} 

 

3、静态内部类

可以看到，通过双重检查锁的方式来创建单例对象，还是比较复杂的。又是加锁，又是判断两次，还需要加volatile修饰的。

使用静态内部类的方式，可以达到双重检查锁相同的功效，但实现上简单了。

在Seata框架中，创建RM事件处理程序器的时候，就使用了静态内部类的方式来创建单例对象。

public class DefaultRMHandler extends AbstractRMHandler{

protected DefaultRMHandler() {
    initRMHandlers();
}
private static class SingletonHolder {
    private static AbstractRMHandler INSTANCE = new DefaultRMHandler();
}
public static AbstractRMHandler get() {
    return DefaultRMHandler.SingletonHolder.INSTANCE;
}
} 

还有可以通过枚举的方式来创建单例对象，但这种方式并没有被广泛采用，至少笔者在常见的开源框架中没见过，所以就不再列举。

有人说，饿汉式的单例模式不好，不能做到延迟加载，浪费内存。但笔者认为似乎过于吹毛求疵，事实上很多开源框架中，用的最多的就是这种方式。

如果明确希望实现懒加载效果时，可以考虑用静态内部类的方式；如果还有其他特殊的需求，比如创建对象的过程比较繁琐，可以用双重检查锁的方式。

二、工厂模式

工厂模式是Java中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

简单来说，在工厂模式中，就是代替new实例化具体类的一种模式。

1、简单工厂

简单工厂，的确比较简单，它的作用就是把对象的创建放到一个工厂类中，通过参数来创建不同的对象。

在分布式事务框架Seata中，如果发生异常，则需要进行二阶段回滚。

它的过程是，通过事务id找到undoLog记录，然后解析里面的数据生成SQL，将一阶段执行的SQL给撤销掉。

问题是SQL的种类包含了比如INSERT、UPDATE、DELETE，所以它们反解析的过程也不一样，就需要不同的执行器去解析。

在Seata中，有一个抽象的撤销执行器，可以生成一条SQL。

public abstract class AbstractUndoExecutor{
//生成撤销SQL
protected abstract String buildUndoSQL();
} 

然后有一个获取撤销执行器的工厂，根据SQL的类型，创建不同类型的执行器并返回。

public class UndoExecutorFactory {

public static AbstractUndoExecutor getUndoExecutor(String dbType, SQLUndoLog sqlUndoLog) {
    switch (sqlUndoLog.getSqlType()) {
        case INSERT:
            return new MySQLUndoInsertExecutor(sqlUndoLog);
        case UPDATE:
            return new MySQLUndoUpdateExecutor(sqlUndoLog);
        case DELETE:
            return new MySQLUndoDeleteExecutor(sqlUndoLog);
        default:
            throw new ShouldNeverHappenException();
    }
}
} 

使用的时候，直接通过工厂类获取执行器。

AbstractUndoExecutor undoExecutor = UndoExecutorFactory.getUndoExecutor(dataSourceProxy.getDbType(),sqlUndoLog);
undoExecutor.executeOn(conn);

简单工厂模式的优点，想必各位都能领会，我们不再赘述。但它还有个小小的缺点：

一旦有了新的实现类，就需要修改工厂实现，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。

2、工厂方法

工厂方法模式解决了上面那个问题。它可以创建一个工厂接口和多个工厂实现类，这样如果增加新的功能，只需要添加新的工厂类就可以，不需要修改之前的代码。

另外，工厂方法模式还可以和模板方法模式结合一起，将他们共同的基础逻辑抽取到父类中，其它的交给子类去实现。

在Dubbo中，有一个关于缓存的设计完美的体现了工厂方法模式+模板方法模式。

首先，有一个缓存的接口，它提供了设置缓存和获取缓存两个方法。

public interface Cache {
void put(Object key, Object value);
Object get(Object key);
} 

然后呢，还有一个缓存工厂，它返回一个缓存的实现。

public interface CacheFactory {
Cache getCache(URL url, Invocation invocation);
} 

由于结合了模板方法模式，所以Dubbo又搞了个抽象的缓存工厂类，它实现了缓存工厂的接口。

public abstract class AbstractCacheFactory implements CacheFactory {

//具体的缓存实现类
private final ConcurrentMap<String, Cache> caches = new ConcurrentHashMap<String, Cache>();

@Override
public Cache getCache(URL url, Invocation invocation) {
    url = url.addParameter(Constants.METHOD_KEY, invocation.getMethodName());
    String key = url.toFullString();
    Cache cache = caches.get(key);
    if (cache == null) {
        //创建缓存实现类，交给子类实现
        caches.put(key, createCache(url));
        cache = caches.get(key);
    }
    return cache;
}
//抽象方法，交给子类实现
protected abstract Cache createCache(URL url);
} 

在这里，公共的逻辑就是通过getCahce()创建缓存实现类，那具体创建什么样的缓存实现类，就由子类去决定。

所以，每个子类都是一个个具体的缓存工厂类，比如包括：

ExpiringCacheFactory、JCacheFactory、LruCacheFactory、ThreadLocalCacheFactory。
这些工厂类，只有一个方法，就是创建具体的缓存实现类。
public class ThreadLocalCacheFactory extends AbstractCacheFactory {
@Override
protected Cache createCache(URL url) {
    return new ThreadLocalCache(url);
}
} 

这里的ThreadLocalCache就是具体的缓存实现类，比如它是通过ThreadLocal来实现缓存功能。

public class ThreadLocalCache implements Cache {

private final ThreadLocal<Map<Object, Object>> store;

public ThreadLocalCache(URL url) {
    this.store = new ThreadLocal<Map<Object, Object>>() {
        @Override
        protected Map<Object, Object> initialValue() {
            return new HashMap<Object, Object>();
        }
    };
}
@Override
public void put(Object key, Object value) {
    store.get().put(key, value);
}
@Override
public Object get(Object key) {
    return store.get().get(key);
}
} 

那在客户端使用的时候，还是通过工厂来获取缓存对象。

public static void main(String[] args) {
URL url = URL.valueOf("http://localhost:8080/cache=jacache&.cache.write.expire=1");
Invocation invocation = new RpcInvocation();
CacheFactory cacheFactory = new ThreadLocalCacheFactory();
Cache cache = cacheFactory.getCache(url, invocation);
cache.put("java","java");
System.out.println(cache.get("java"));
} 

这样做的好处有两点。

第一，如果增加新的缓存实现，只要添加一个新的缓存工厂类就可以，别的都无需改动。

第二，通过模板方法模式，封装不变部分，扩展可变部分。提取公共代码，便于维护。

另外，在Dubbo中，注册中心的获取也是通过工厂方法来实现的。

3、抽象工厂

抽象工厂模式，它能创建一系列相关的对象，而无需指定其具体类。

工厂方法模式和抽象工厂模式，它们之间最大的区别在于：

• 工厂方法模式只有一个抽象产品类，具体工厂类只能创建一个具体产品类的实例；
• 抽象工厂模式有多个抽象产品类，具体工厂类可以创建多个具体产品类的实例。

我们拿上面缓存的例子来继续往下说。

如果我们现在有一个数据访问程序，需要同时操作缓存和数据库，那就需要多个抽象产品和多个具体产品实现。

缓存相关的产品类都已经有了，我们接着来创建数据库相关的产品实现。

首先，有一个数据库接口，它是抽象产品类。

public interface DataBase {
void insert(Object tableName, Object record);
Object select(Object tableName);
} 

然后，我们创建两个具体产品类MysqlDataBase和OracleDataBase。

public class MysqlDataBase implements DataBase{
Map<Object,Object> mysqlDb = new HashMap<>();
@Override
public void insert(Object tableName, Object record) {
    mysqlDb.put(tableName,record);
}
@Override
public Object select(Object tableName) {
    return mysqlDb.get(tableName);
}
}

public class OracleDataBase implements DataBase {
Map<Object,Object> oracleDb = new HashMap<>();
@Override
public void insert(Object tableName, Object record) {
    oracleDb.put(tableName,record)