Java策略模式实例
Java策略模式实例
- 一、前言
- 二、需求
- 三、代码结构图
- 总体UML如下：
- 具体流程
- 四、小结
一、前言
最近写代码发现，业务逻辑很多的时候，总会有很多的if ... else。会导致有时候丢失某些逻辑。
有的时候也会用到switch case 来区分不同的类型下执行不同的方法。但是往往这个时候会显得一个方法的代码很长，而且如果需求有变动，有增加，还要改switch代码逻辑，不利于扩展。
这个时候使用策略模式，可以很好的解决问题。
二、需求
现在有个需求，有个获取运单相关位置的需求，根据不同的操作节点，返回不同的处理数据，比如，操作节点为始发地，则返回始发地的相关经纬度信息，如果操作点为车辆位置，则返回车辆实时位置信息，如果操作点为目的的，则返回目的地的经纬度信息。
最简单的思路就是通过switch来判断或者if else 来判断不同的业务节点，返回不同的数据，如果要加操作节点的话，还要改原来的代码，继续添加新的逻辑，这个时候如果使用策略模式，就可以不用改动原来的代码，只需要新加一个Handler就行了。
三、代码结构图
总体UML如下：
具体流程
在serviceImpl中通过调HandlerContext来获取抽象类AbstractHandler 的实例，。而项目启动的时候，会扫描指定目录下带有我们自定义注解的类。并把类上的注解的值和类的实例作为k-v存到handlerContext中。
HandlerProcessor ，项目启动扫描handler入口。
HandlerProcessor：
类中指明了扫描 com.XXX.handle.biz路径下的，带有HandlerType的注解的类。
/**
* @description: 处理器核心逻辑
* @author: huangxinhe
* @create: 2020/03/21 23:05
*/
@Component
@SuppressWarnings("unchecked")
public class HandlerProcessor implements BeanFactoryPostProcessor {
private static final String HANDLER_PACKAGE = "com.XXXXX.handle.biz";
/**
* @description 扫描@handlerType，初始化HandlerContext,将其注册到spring容器
* @see HandlerType
* @see HandlerContext
**/
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
Map<String,Class> handlerMap = Maps.newHashMapWithExpectedSize(4);
ClassScaner.scan(HANDLER_PACKAGE,HandlerType.class).forEach(clazz->{
//获取注解中的类型值
String type = clazz.getAnnotation(HandlerType.class).value();
//将注解中的值作为key，对应的类作为value，保存到Map中
handlerMap.put(type,clazz);
});
//初始化HandlerContext，将其注册到spring容器中
HandlerContext context = new HandlerContext(handlerMap);
beanFactory.registerSingleton(HandlerContext.class.getName(),context);
}
}
HandlerType自定义注解
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface HandlerType {
String value();
}
ClassScanner
根据包路径和注解扫描类
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternUtils;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.util.StringUtils;
import org.springframework.util.SystemPropertyUtils;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
public class ClassScaner implements ResourceLoaderAware {
private final List<TypeFilter> includeFilters = new LinkedList<TypeFilter>();
private final List<TypeFilter> excludeFilters = new LinkedList<TypeFilter>();
private ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver);
@SafeVarargs
public static Set<Class<?>> scan(String[] basePackages, Class<? extends Annotation>... annotations) {
ClassScaner cs = new ClassScaner();
if (ArrayUtils.isNotEmpty(annotations)) {
for (Class anno : annotations) {
cs.addIncludeFilter(new AnnotationTypeFilter(anno));
}
}
Set<Class<?>> classes = new HashSet<>();
for (String s : basePackages) {
classes.addAll(cs.doScan(s));
}
return classes;
}
@SafeVarargs
public static Set<Class<?>> scan(String basePackages, Class<? extends Annotation>... annotations) {
return ClassScaner.scan(StringUtils.tokenizeToStringArray(basePackages, ",; \t\n"), annotations);
}
public final ResourceLoader getResourceLoader() {
return this.resourcePatternResolver;
}
@Override
public void setResourceLoader(ResourceLoader resourceLoader) {
this.resourcePatternResolver = ResourcePatternUtils
.getResourcePatternResolver(resourceLoader);
this.metadataReaderFactory = new CachingMetadataReaderFactory(
resourceLoader);
}
public void addIncludeFilter(TypeFilter includeFilter) {
this.includeFilters.add(includeFilter);
}
public void addExcludeFilter(TypeFilter excludeFilter) {
this.excludeFilters.add(0, excludeFilter);
}
public void resetFilters(boolean useDefaultFilters) {
this.includeFilters.clear();
this.excludeFilters.clear();
}
public Set<Class<?>> doScan(String basePackage) {
Set<Class<?>> classes = new HashSet<>();
try {
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+ org.springframework.util.ClassUtils
.convertClassNameToResourcePath(SystemPropertyUtils
.resolvePlaceholders(basePackage))
+ "/**/*.class";
Resource[] resources = this.resourcePatternResolver
.getResources(packageSearchPath);
for (int i = 0; i < resources.length; i++) {
Resource resource = resources[i];
if (resource.isReadable()) {
MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
if ((includeFilters.size() == 0 && excludeFilters.size() == 0) || matches(metadataReader)) {
try {
classes.add(Class.forName(metadataReader
.getClassMetadata().getClassName()));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
} catch (IOException ex) {
throw new BeanDefinitionStoreException(
"I/O failure during classpath scanning", ex);
}
return classes;
}
protected boolean matches(MetadataReader metadataReader) throws IOException {
for (TypeFilter tf : this.excludeFilters) {
if (tf.match(metadataReader, this.metadataReaderFactory)) {
return false;
}
}
for (TypeFilter tf : this.includeFilters) {
if (tf.match(metadataReader, this.metadataReaderFactory)) {
return true;
}
}
return false;
}
}
HandlerContext
根据类型实例化抽象类
import java.util.Map;
/**
* @description:
* @author: huangxinhe
* @create: 2020/03/21 23:34
*/
@SuppressWarnings("unchecked")
public class HandlerContext {
private Map<String, Class> handlerMap;
public HandlerContext(Map<String, Class> handlerMap) {
this.handlerMap = handlerMap;
}
public AbstractHandler getInstance(String type) {
Class clazz = handlerMap.get(type);
if (clazz == null) {
throw new IllegalArgumentException("not found handler for type: " + type);
}
return (AbstractHandler) BeanTool.getBean(clazz);
}
}
BeanTool
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Component
public class BeanTool implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext context) throws BeansException {
if (applicationContext == null) {
applicationContext = context;
}
}
public static Object getBean(String name) {
return applicationContext.getBean(name);
}
public static <T> T getBean(Class<T> clazz) {
return applicationContext.getBean(clazz);
}
}
抽象方法类
AbstractHandler
import java.util.List;
/**
* @description: 抽象处理器
* @author: huangxinhe
* @create: 2020/03/21 23:02
*/
public abstract class AbstractHandler {
abstract public List<TransportApartPointDto> handle(LogisticsTrackCondition condition);
}
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* @description: 始发地处理器
* @author: huangxinhe
* @create: 2020/03/21 22:54
*/
@Slf4j
@Component
@HandlerType("1")
public class SendLocationHandler extends AbstractHandler{
@Resource
private LogisticsDataDao logisticsDataDao;
@Override
public List<TransportApartPointDto> handle(LogisticsTrackCondition condition){
log.info("SendLocationHandler handle params:[{}]", JSONObject.toJSONString(condition));
//处理始发地物流轨迹
return null;
}
log.info("SendLocationHandler handle transportApartPointDtoList:[{}]", JSONObject.toJSONString(transportApartPointDtoList));
return transportApartPointDtoList;
}
}
/**
* @program cmem-parent-pom
* @description: 车辆所在地处理器
* @author: huangxinhe
* @create: 2020/03/21 22:54
*/
@Slf4j
@Component
@HandlerType("2")
public class VehicleLocationHandler extends AbstractHandler {
/**
* dao 接口
*/
@Resource
private LogisticsDataDao logisticsDataDao;
/**
* 地图服务
*/
@Resource
private EGisWrapperService eGisWrapperService;
/**
* 获取车辆实时位置
*/
@Resource
private TransportTmsService transportTmsService;
@Resource
private CacheClient cacheClient;
/**
* 获取车辆实时位置
*
* @param condition
* @return
*/
@Override
public List<TransportApartPointDto> handle(LogisticsTrackCondition condition) {
log.info("VehicleLocationHandler handle params:[{}]", JSONObject.toJSONString(condition));
//处理车辆所在点物流轨迹
List<TransportApartPointDto> transportApartPointDtoList = new ArrayList<>();
return transportApartPointDtoList;
}
}
//目的地
/**
* @description: 目的地地处理器
* @author: huangxinhe
* @create: 2020/03/21 22:54
*/
@Slf4j
@Component
@HandlerType("3")
public class ReceiveLocationHandler extends AbstractHandler{
@Resource
private LogisticsDataDao logisticsDataDao;
@Override
public List<TransportApartPointDto> handle(LogisticsTrackCondition condition){
//处理目的地物流轨迹
return null;
}
}
四、小结
策略模式的作用：就是把具体的算法实现从业务逻辑中剥离出来，成为一系列独立算法类，使得它们可以相互替换。
在我们可以通过继续写心的业务逻辑类，来拓展我们的代码，这个是非常方便的，基本serviceImpl的类中是不用修改的。可以增加新的东西，不用修改旧的东西，这个正好是设计模式里面的开闭原则。