工厂模式
开发中，有时会需要根据不同的类型，创建同一接口的对应的不同实现类，再去执行方法。
工厂模式的理解，详情见： https://www.cnblogs.com/expiator/p/8245143.html
示例
以下会举一个例子，不同的反馈类型 type,创建不同的审批处理器对象，进行审批。
自定义注解
/**
* 审批的注解
*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Audit {
/**
* 类型
*
*/
String[] types();
/**
* 名称
*
*/
String name() default "";
}
基础接口
不同的类型type，会有不同的处理器去处理。
各个审批处理器的对象，需要实现 AuditHandler 接口。
/**
* 审批处理器接口
*/
public interface AuditHandler {
/**
* 审批
* @param id
* @param type
* @return
*/
void audit(Long id, String type);
}
实现接口的类1
/**
* 审批处理器。
* 通过注解指定处理哪些类型的提议
*
*/
@Audit( types = {"1"}, name = "审批处理器-类型1")
@Component
@Slf4j
public class FirstAuditHandler implements AuditHandler {
@Override
public void audit(Long id , String type) {
log.info("FirstAuditHandler audit.id:{}, type:{}", id, type);
}
}
实现接口的类2
/**
* 审批处理器。
* 通过注解指定处理哪些类型的提议
*
*/
@Audit( types = {"2"}, name = "审批处理器-类型2")
@Component
@Slf4j
public class SecondAuditHandler implements AuditHandler {
@Override
public void audit(Long id, String type) {
//忽略其他审批逻辑
log.info("SecondAuditHandler audit.id:{}, type:{}", id, type);
}
}
实现接口的类3
/**
* 审批处理器。
* 通过注解指定处理哪些类型的提议
*
*/
@Audit( types = {"3","4","5"}, name = "审批处理器-公共")
@Component
@Slf4j
public class CommonAuditHandler implements AuditHandler {
@Override
public void audit(Long id, String type) {
//忽略其他审批逻辑
log.info("CommonAuditHandler audit.id:{}, type:{}", id, type);
}
}
通过类型，获取对象
如果直接对比类型去获取对应的对象，在类型比较多的时候，会有大量的if else
通过map获取，可以减少if else判断。
/**
* 审批的初始化 map，以及获取实例
*/
public class AuditContext {
/**
* 自动审批处理器
*/
private static final Map<String, AuditHandler> AUTO_AUDIT_HANDLERS_MAP = new HashMap<>();
private AuditContext() {
}
/**
* 初始化 map
*
* @param types
* @param name
* @param auditHandler
*/
public static void initMap(String[] types, String name, AuditHandler auditHandler) {
for (String type : types) {
AUTO_AUDIT_HANDLERS_MAP.put(type, auditHandler);
}
}
/**
* 通过类型，获取实例。
* 如果直接对比类型，在类型比较多的时候，会有大量的if else
* 通过map获取，可以减少if else判断。
*
* @param type
* @return
*/
public static AuditHandler getInstance(String type) {
if (StringUtils.isBlank(type)) {
return null;
}
return AUTO_AUDIT_HANDLERS_MAP.get(type);
}
}
类型对应对象的Map初始化
/**
* 初始化审批的处理器及实例的Map
*
*/
@Component
@Slf4j
public class AuditInitService implements ApplicationContextAware, InitializingBean {
private ApplicationContext context;
@Override
public void afterPropertiesSet() {
init();
}
/**
* 设置上下文
* @param applicationContext
*/
@Override
public void setApplicationContext(ApplicationContext applicationContext) {
this.context = applicationContext;
}
/**
* 初始化审批的处理器及实例Map
*/
private void init() {
Map<String, Object> beans = context.getBeansWithAnnotation(Audit.class);
Type[] genericInterfaces;
Class<?> clazz;
Type rawType;
AuditHandler auditHandler;
Audit audit;
String[] types;
String name;
for (Object bean : beans.values()) {
//getGenericInterfaces()： 主要是 获取由此对象表示的类或接口直接实现的接口的Type。
genericInterfaces = bean.getClass().getGenericInterfaces();
for (Type genericInterface : genericInterfaces) {
if (Class.class.isAssignableFrom(genericInterface.getClass())) {
clazz = (Class<?>) genericInterface;
// isAssignableFrom() 用于检测一个类是否继承(或实现)于一个类/接口
if (AuditHandler.class.isAssignableFrom(clazz)) {
auditHandler = (AuditHandler) bean;
//获取AuditHandler实现类上面的@Audit注解
audit = auditHandler.getClass().getAnnotation(Audit.class);
types = audit.types();
name = audit.name();
//初始化审批的处理器及实例Map
AuditContext.initMap(types, name, auditHandler);
log.info(" Init auditHandler[{}] success! The types is {}...", name, Arrays.toString(types));
}
}
}
}
}
}
根据类型创建对象
初始化map的作用体现出来了，不用做太多的if else判断去获取对象类型。
/**
* 反馈提议
*/
@Service
public class SuggestionService {
/**
* 反馈提议后，进行审批
*/
public void suggest(Long id ,String type) {
//忽略其他的反馈逻辑
//...
//获取类型对应的审批处理器对象
//初始化map的作用体现出来了，不用做太多的if else判断去获取对象类型
AuditHandler auditHandler = AuditContext.getInstance(type);
if (auditHandler != null) {
//审批
auditHandler.audit(id, type);
}
}
}