背景

虽然Java 的设计模式有20多种，但是我们基本上都是用spring体系开发的，所以只推荐一下这5种设计模式，基本上能解决大部分问题。

常用的5种设计模式

一、单例模式

定义： 这个类的实例在这个项目中只能有一个。

代码：

// 全局本地缓存
public class Cache {
	private static final Cache<CacheKey, Object> cache = new Cache<>();	
	public static Cache<CacheKey, Object> getInstance(){
		return cache;
	}
}
// 全局的线程池，提供给多个场景复用
public class ExecutorServiceManager {

    private final static LinkedBlockingQueue<Runnable> WORK_QUEUE = new LinkedBlockingQueue<>(1000);

    private final static RejectedExecutionHandler HANDLER = new ThreadPoolExecutor.CallerRunsPolicy();

    private static ThreadPoolExecutor executorService = new ThreadPoolExecutor(
            20, 100, 0, TimeUnit.SECONDS, WORK_QUEUE, HANDLER
    );

 	public static ThreadPoolExecutor getThreadPoolInstance(){
		return executorService;
	}
	
	// 关闭线程池
    public static void shutdown() {
        if (executorService != null && !executorService.isShutdown()) {
            executorService.shutdown();
        }
    }

    // 强制关闭线程池
    public static void shutdownNow() {
        if (executorService != null && !executorService.isShutdown()) {
            executorService.shutdownNow();
        }
    }
}

二、工厂模式

定义：推荐两种，分别是简单工厂模式、抽象工厂模式。

代码：

// 简单工厂模式
@Component
public class OrderFactory {

    @Autowired
    private List<Order> orderList;

    public Order createOrderBean(BizTypeEnum type) throws Exception {
        return orderList.stream().filter(x -> x.symbol() == type).findFirst().orElseThrow(() -> new Exception("参数有误"));
    }
}

// 抽象工厂模式
public abstract class AbstractFactory<E extends Enum<E>, S extends BeanInterface<E>> {

    protected List<S> ss;

    public AbstractFactory(List<S> ss) {
        this.ss = ss;
    }

    /**
     * 创建bean
     *
     * @param en 枚举
     * @return 符合条件的bean
     */
    public Optional<S> createBean(E en) {
        return ss.stream().filter(x -> x.symbol().equals(en)).findFirst();
    }

}

public interface BeanInterface<E extends Enum<E>> {

    /**
     * 具体实例的标识
     *
     * @return
     */
    E symbol();

}

三、适配器模式

这个模式，简单说就是想使用别的类的功能。细分为三种，类的适配器模式、对象的适配器模式、接口的适配器模式，但是类的适配器模式不推荐（基于继承），所以下面就介绍下，对象的适配器模式和接口的适配器模式。
对象的适配器模式：就是通过组合的方式拥有某个对象的能力；
接口的适配器模式：就是抽象的形式，空实现，给子类足够的选择。

对象的适配器模式代码：

@Data
public final class RecoveryUserModelAdapter  {

    private UserModel userModel;

    public List<String> getCompany() {
        return userModel.getCompany();
    }

    public String getAccount(){
        return userModel.getAccount();
    }

    public String getName(){
        return userModel.getName();
    }

    public RecoveryUserModelAdapter(UserModel userModel) {
        this.userModel = userModel;
    }

    /**
     * 角色key
     */
    private Set<String> roleKeys;

    public boolean hasSuperRole() {
        return roleKeys != null
                && (roleKeys.contains(RecoveryConstants.SUPER_ROLE)
                || roleKeys.contains(RecoveryConstants.MANAGE_ROLE)
                || roleKeys.contains(RecoveryConstants.ADMIN));
    }

    public boolean hasManageRole() {
        return roleKeys != null
                && (roleKeys.contains(RecoveryConstants.MANAGE_ROLE)
                || roleKeys.contains(RecoveryConstants.ADMIN));
    }

}

接口的适配器模式代码：

public interface Order {

    public Object create(Object params);
    
    public void check(Object params);

    public BizTypeEnum symbol();
}

public abstract class AbstractOrder implements Order {
	
	
    @Override
    public Object create(Object params) {
	
        return null;
    }

    @Override
    public void check(Object params) {

    }
}

四、模版方法模式

定义：一个方法定义好执行步骤，每个步骤子类可以按照自己的需要实现对应的方法。

代码：

public abstract class AbstractOrder implements Order {

    @Override
    public Object create(Object params) {

        // 1.校验参数
        checkParam(params);

        // 2.价格确认
        priceConfirm(params);

        // 3.构建数据
        buildOrderData(params);

        // 4.下单
        uniOrder(params);

        // 5.入库
        saveData(params);

        return null;
    }

    protected abstract void saveData(Object params);

    protected abstract void uniOrder(Object params);

    protected abstract void buildOrderData(Object params);

    protected abstract void priceConfirm(Object params);

    protected abstract void checkParam(Object params);

    protected void check(Object params) {
    }
}

五、策略模式

定义：一个方法多种实现，根据需要选择对应的实现，可以配合上面的几种模式使用

代码：

@Component
public class AppOrderStrategy implements Order{
    @Override
    public Object create(Object params) {
        return null;
    }

    @Override
    public BizTypeEnum symbol() {
        return BizTypeEnum.APP;
    }
}
@Component
public class MiniAppOrderStrategy implements Order{
    @Override
    public Object create(Object params) {
        return null;
    }

    @Override
    public BizTypeEnum symbol() {
        return BizTypeEnum.MINI_APP;
    }
}
@Component
public class H5OrderStrategy implements Order{

    @Override
    public Object create(Object params) {
        return null;
    }

    @Override
    public BizTypeEnum symbol() {
        return BizTypeEnum.H5;
    }
}