通过 Spring Event 方式优雅的抽象策略模式解决 if else 问题

- 日理万妓 2022-12-10 03:58 73阅读 0赞

策略模式是设计模式中非常常用的一种设计模式。它对修改关闭，对扩展开放。而且通过策略模式还可以减少项目中一系列的 `if else` 代码块。常见的策略模式也很多种写法。比如：定义一个接口，接口有不同的实现，然后定义一个工厂，把这个接口的实现以对应不同的 Key 保存到这个工厂里面，然后通过传入不同的 key 从定义好的 Map 中获取到对应接口的实例，如果需要新添加策略就直接添加新的实现就可以了。

## 1、基于工厂的策略模式 ##

下面我们就举一个简单的小例子

### 1.1 接口定义 ###

首先定义一个接口，这个接口只有一个方法那就是打招呼。然后不同的国家都有不同的打招呼方式。

public interface Hello { 
    
    	void sayHello();
    	
    }

### 1.2 不同的实现 ###

定义了两个国家的实现方式，一个是美国的打招呼方式就是 `hello`，另一个是中国的打招呼方式是：`你好`。

// 美国人说 Hello
    @Service("america")
    public class America implements Hello { 
    
        @Override
        public void sayHello() { 
            System.out.println("hello");
        }
    }
    
    // 中国人说 Hello
    @Service("chinese")
    public class Chinese implements Hello { 
        @Override
        public void sayHello() { 
            System.out.println("你好!");
        }
    }

### 1.3 对象工厂 ###

定义一个获取打招呼的工厂类，根据传递进来不同的国家，获取到相应的打招呼方式。如果没有获取到对应的打招呼方式就报：`not support country code`。

public interface HelloFactory { 
    
        Hello getHello(String country);
    
    }
    
    @Service("helloFactory")
    public class DefaultHelloFactory implements HelloFactory { 
    
        @Resource
        private Map<String, Hello> hellos;
    
        @Override
        public Hello getHello(String country) { 
            Hello hello = hellos.get(country);
            Assert.notNull(hello, "not support country code");
            return hello;
        }
    
    }

### 1.4 测试类 ###

下面我们编写一个测试类，用于测试当我们传入 `america`，打招呼就是 `hello`。

> Test.java

@ComponentScan
    @Configuration
    public class Test {
    
        public static void main(String[] args) {
            ApplicationContext context = new AnnotationConfigApplicationContext(Test.class);
            HelloFactory helloFactory = context.getBean(HelloFactory.class);
            Hello hello = helloFactory.getHello("america");
            hello.sayHello();
        }
    
    }

运行结果如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI0MTA3MzM_size_16_color_FFFFFF_t_70_pic_center]  
可以看到运行结果是符合我们预期的。

## 2、思考 ##

在上面的代码当中我们可以通过传入不同的 code 获取到我们想要的实现，这本身就是策略模式的实现。但是存在一个问题，就是我们不同的策略就需要创建一个 Factory 与它的属性 Map 来保存这个策略。那么可不可以所有的策略都保存在一个 Map 当中呢？还有如果自动的把这些实现注入到 Map 当中呢？

所以我们就有两个点需要优化：

*  `统一管理`：把各个不同的策略的所有实现的保存在一个统一的 Map 当中
 *  `自动注册`：如何自动的把所有不同的策略都注册到这个 Map 当中

**统一管理**：需要所有的工厂都需要实现自己的不同的工厂那么就抽象出一个定义路由的泛型接口，然后需要实现策略的接口都需要实现这个定义路由的泛型接口。这样接口的路由 Key 就是统一的对象了。

> 路由接口

public interface SimpleRegisterService<RouteKey> {
    
    	/**
    	 * 返回用于路由服务的对象
    	 */
    	RouteKey getRouteKey();
    
    }

**自动注册**：所有接口都需要实现一个工厂，可以抽象一个策略工厂出来把不同接口的策略都注册到这个接口当中。可以使用 Spring 的 Event 来做这一件事，当 Spring 容器初始化完成之后会发布 `ContextRefreshedEvent` 事件，这个抽象工厂可以监听这个事件并且在具体的工厂中定义需要操作的接口，然后把这个接口的实现类都添加到这个抽象类的 Map 当中，这样就完成了接口的自动注册。

> 策略自动注册抽象

public abstract class AbstractSimpleRegisterServiceFactory<RouteKey, Service extends SimpleRegisterService<RouteKey>>
    		implements ApplicationListener<ContextRefreshedEvent> {
    
    	protected Map<RouteKey, Service> serviceMap = new HashMap<>();
    
    	/**
    	 * 返回服务
    	 * @param routeKey 路由对象
    	 * @return 如果无匹配服务返回null
    	 */
    	public Service getService(RouteKey routeKey) {
    		return serviceMap.get(routeKey);
    	}
    
    	@Override
    	public void onApplicationEvent(ContextRefreshedEvent event) {
    		Map<String, Service> services = event.getApplicationContext().getBeansOfType(getServiceClazz());
    		if (services == null || services.size() == 0) {
    			return;
    		}
    		beforeRegisterAll();
    		for (Map.Entry<String, Service> entry : services.entrySet()) {
    			registerService(entry.getKey(), entry.getValue());
    		}
    		afterRegisterAll();
    	}
    
    	/**
    	 * 默认注册服务实现，Map管理服务，key是路由对象，value是服务
    	 * @param beanName bean名称
    	 * @param service 服务实例
    	 */
    	protected void registerService(String beanName, Service service) {
    		RouteKey routeKey = service.getRouteKey();
    		if (routeKey == null) {
    			throw new RuntimeException(String.format("注册服务路由对象不可为空:%s", service.getClass()));
    		}
    		if (!serviceMap.containsKey(routeKey)) {
    			serviceMap.put(routeKey, service);
    		} else {
    			throw new RuntimeException(String.format("注册服务路由对象重复: %s, %s, %s, %s", routeKey,
    					serviceMap.get(routeKey).getClass(), service.getClass(), getFactoryName()));
    		}
    	}
    
    	/**
    	 * 在所有注册之前
    	 */
    	protected void beforeRegisterAll() {
    
    	}
    
    	/**
    	 * 在所有注册之后
    	 */
    	protected void afterRegisterAll() {
    
    	}
    
    	/**
    	 * 返回服务工厂名称
    	 *
    	 * @return
    	 */
    	protected abstract String getFactoryName();
    
    	/**
    	 * 返回自动发现服务的接口类型
    	 *
    	 * @return
    	 */
    	protected abstract Class<Service> getServiceClazz();
    	
    }

基于上面的两个类我们就可以完成策略的统一管理以及自动注册。

## 3、优化 ##

下面我们就来改造上面的打招呼接口。

### 3.1 实现注册接口 ###

需要实现策略的接口实现注册接口，统一各个实例的路由键对象。

public interface Hello extends SimpleRegisterService<String>{
    
        void sayHello();
    
    }

### 3.2 接口不同的实现 ###

各个实现都定义好它的路由键，接口工厂通过路由键获取到相应实例。

@Service("chinese")
    public class Chinese implements Hello { 
        @Override
        public void sayHello() { 
            System.out.println("你好!");
        }
    
        @Override
        public String getRouteKey() { 
            return "chinese";
        }
    }
    
    @Service("america")
    public class America implements Hello { 
    
        @Override
        public void sayHello() { 
            System.out.println("hello");
        }
    
        @Override
        public String getRouteKey() { 
            return "america";
        }
    }

### 3.3 接口工厂 ###

具体接口工厂定义需要检测的策略路由接口

@Service
    public class HelloFactory extends AbstractSimpleRegisterServiceFactory<String, Hello> { 
    
        @Override
        protected String getFactoryName() { 
            return "hello 工厂";
        }
    
        @Override
        protected Class<Hello> getServiceClazz() { 
            return Hello.class;
        }
    }

### 3.4 测试类 ###

下面我们编写测试类，把打招呼国家换成中国，看是否打招呼是 `你好！`.

@ComponentScan
    @Configuration
    public class Test { 
    
        public static void main(String[] args) { 
            ApplicationContext context = new AnnotationConfigApplicationContext(Test.class);
            HelloFactory helloFactory = context.getBean(HelloFactory.class);
            Hello hello = helloFactory.getService("chinese");
            hello.sayHello();
        }
    
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI0MTA3MzM_size_16_color_FFFFFF_t_70_pic_center 1]  
上面就是通过 Spring Event 优化后的策略模式。

当然，如果需要添加其它接口具体多个实例需要使用策略直接添加一个具体的获取接口的工厂定义好需要检测的具体接口就好了。而且这个路由键的支持范围也特别广，只要是对象就行了。比之前 String 的扩展性更加好。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI0MTA3MzM_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/80f6ad6dbb9a4b2bbda430dd348caf29.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI0MTA3MzM_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/f7462041f9614490a09f09963b01a868.png