请求类型分发处理机制
本文将从实际业务出发，展示一种业务请求分发处理实现机制。
当某一个项目需要各种各样的功能，比如有搜索，sug，热点推荐，Es搜索这些功能时，这些功能对应不同的请求类型，不同的请求类型需要对应不同的处理方法，需要不同的拦截过滤器。本实现机制易于扩展，可以很方便的增加具体的处理类也就是一个个具体的功能，过滤器也可通过注解很方便的添加在各个具体的功能上。
首先来具体介绍下几个主要的接口以及类：
1.ApiRequestType：enum类型，定义多种请求类型
2.ApiDispatcher: 请求分发类
3.ApiHandler: 请求处理接口，定义方法handle(),getInterceptors()
4.AbstractApiHandler: 实现ApiHandler接口以及InitializingBean接口，服务启动自动扫描时添加拦截器
5.SearchDataHandler: 具体handler类，继承抽象类AbstractApiHandler，实现doHandle方法；注解方式标识该类需要的拦截器
6.ApiInteceptor: 拦截器接口，定义前置与后置处理方法
下面写上具体代码进行展示：
1.ApiRequestType : Enum类型，定义了请求类型，定义每一个请求对应的具体处理类handler ，当然也可以对每一个枚举定义一些额外的定制化项，比如返回项数据类型，以及缓存时机等，根据业务需求来。
public enum ApiRequestType {
/**
* 热点推荐
*/
HOT_RECOMMAND("hotspot", HotDataHandler.class, HotRecommandItem.class, H_1),
/**
* 根据关键字搜索
*/
SEARCH_BY_QUERY("search_by_query", SearchDataHandler.class, null, M_10);
/**
* 请求类型
*/
private String type;
/**
* 对应的处理器
*/
private Class<? extends ApiHandler> handlerClass;
/**
* 返回项数据类型
*/
private Class<? extends BaseObj> itemClass;
...
}
2.ApiDispatcher:请求分发类，获取请求requestType对应的请求处理器，SpringContextUtil是自定义工具类，通过ApplicationContext来获取bean
@Slf4j
@Service
public class ApiDispatcher {
/**
* API Dispatcher
*/
public Object dispatch(ApiRequestType requestType, Long ucid, Object request, Converter converter) throws Exception{
return toHandle(requestType, getApiHandler(requestType), ucid, request, converter);
}
/**
* 获取处理器
*/
public ApiHandler getApiHandler(ApiRequestType requestType) {
Class<? extends ApiHandler> handlerClass = requestType.getHandlerClass();
if (handlerClass == null) {
// no handler class
}
//获取bean
ApiHandler apiHandler = SpringContextUtil.getBean(handlerClass);
if (apiHandler == null) {
// no handler bean
}
return apiHandler;
}
/**
* 业务处理
*/
public Object toHandle(ApiRequestType requestType, ApiHandler apiHandler , Long ucid, Object request, Converter converter) {
if (ucid == null) {
return null;
}
EhrUserDTO user = getUser(ucid);
if (user == null) {
return null;
}
//处理
Object response = apiHandler.handle(new ApiRequest(requestType, user, request));
if (converter != null) {
response = converter.convertFrom(response);
}
return response;
}
}
3.ApiHandler:抽象类实现的接口
public interface ApiHandler {
/**
* api handle
*/
ApiResponse handle(ApiRequest request);
/**
* get all interceptors of the handler
* @return
*/
List<ApiInterceptor> getInterceptors();
}
4.AbstractApiHandler:实现ApiHandler的两个方法；实现InitializingBean的afterPropertiesSet方法，服务启动时，具体handler类实例化时添加拦截器；进行具体handler类的doHandle方法前后进行拦截器的前后置方法；
@Slf4j
public abstract class AbstractApiHandler implements ApiHandler,InitializingBean {
private List<ApiInterceptor> interceptors;
@Override
public ApiResponse handle(ApiRequest request) {
try {
LOGGER.info("{} handle request={}", this.getClass().getSimpleName(), request);
// pre handle
if (!CollectionUtils.isEmpty(interceptors)) {
for (ApiInterceptor interceptor : interceptors) {
ApiResponse response = interceptor.preHandle(request, null);
if (response != null) {
return response;
}
}
}
// handle
ApiResponse response = doHandle(request);
// post handle
if (!CollectionUtils.isEmpty(interceptors)) {
for (ApiInterceptor interceptor : interceptors) {
response = interceptor.postHandle(request, response, null);
}
}
return response;
} catch (Exception e) {
LOGGER.info("{} handle request={} error", this.getClass().getSimpleName(), request, e);
}
return null;
}
protected abstract ApiResponse doHandle(ApiRequest request);
/**
* 添加拦截器
* 两种方式：
* 1. Handler上加注解（@ApiInterceptors）,服务启动时自动扫描；
* 2. 代码中手动添加；
* @param interceptor
*/
private void addInterceptor(ApiInterceptor interceptor) {
if (interceptors == null) {
interceptors = new ArrayList<>();
}
interceptors.add(interceptor);
}
@Override
public List<ApiInterceptor> getInterceptors() {
return interceptors;
}
@Override
public void afterPropertiesSet() throws Exception {
// 根据注解服务启动时自动添加拦截器，给各个具体非抽象类添加
ApiInterceptors apiInterceptors = this.getClass().getAnnotation(ApiInterceptors.class);
if (apiInterceptors != null && apiInterceptors.interceptorClasses().length > 0) {
for (Class clazz : apiInterceptors.interceptorClasses()) {
addInterceptor((ApiInterceptor) clazz.newInstance());
}
}
}
}
5.SearchDataHandler具体处理类：注解标记该类需要添加的拦截器，可动态添加，且可实现拦截器前后置方法与核心方法解耦；实现AbstractApiHandler抽象类的doHandle方法，实现具体业务逻辑
@Slf4j
@Service
@ApiInterceptors(interceptorClasses = {RequestAuthInterceptor.class, DataAuthInterceptor.class, CacheInterceptor.class,
PostInterceptor.class, DataFormatInterceptor.class})
public class SearchDataHandler extends AbstractApiHandler {
@Override
protected ApiResponse doHandle(ApiRequest request) {
ApiResponse response = new ApiResponse(request.getRequestType());
SearchResponse resp = null;
// 根据关键字搜索
resp = searchService.searchByQuery(...);
response.setData(resp);
return response;
}
}
ApiInterceptors: 定义拦截器注解
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ApiInterceptors {
Class[] interceptorClasses() default {};
}
6.ApiInterceptor:拦截器接口
public interface ApiInterceptor {
/**
* 前置处理
*/
ApiResponse preHandle(ApiRequest request, Object handler);
/**
* 后置处理
*/
ApiResponse postHandle(ApiRequest request, ApiResponse response, Object handler);
}
public class DataAuthInterceptor implements ApiInterceptor{
@Override
public ApiResponse preHandle(ApiRequest request, Object handler) {
//前置处理
return response;
}
@Override
public ApiResponse postHandle(ApiRequest request, ApiResponse response, Object handler) {
//后置处理
return response;
}
}
总结：
本实现机制实现业务请求分发处理，具有易扩展、易维护、低耦合的特点
