java：责任链设计模式配合Spring@Order注解使用场景
1 前言
java的责任链模式，经典使用的场景为SpringMVC的doDispatch下，针对请求的过滤链式行为。实际开发场景中，可配合Spring的@Order注解，定义1个有顺序的链式Components列表，根据Components列表的顺序依次处理，如果中途存在处理失败的Component，则终止（或过滤，依赖实际场景即可）整个处理过程，实际使用方式见如下。
2 使用
链式调用的client接口：
public interface IHandleChain {
boolean handleChain();
}
链式调用的client抽象类：
package com.xiaoxu.handleChain;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import javax.annotation.PostConstruct;
import java.util.List;
/**
* @author xiaoxu
* @date 2023-01-09
* java_demo2:com.xiaoxu.handleChain.AbstractHandleChain
*/
public abstract class AbstractHandleChain implements IHandleChain{
@Autowired
List<IHandle> handlers;
IHandle handler;
@PostConstruct
public void postHandlers(){
if(CollectionUtils.isEmpty(handlers)){
throw new RuntimeException("handlers should not be null or empty.");
}
System.out.println("开始执行postHandlers...");
IHandle currentHandler;
IHandle nextHandler;
for (int i = 0; i < handlers.size(); i++) {
if(i == 0){
handler = handlers.get(0);
}else{
currentHandler = handlers.get(i-1);
nextHandler = handlers.get(i);
currentHandler.setNextIHandle(nextHandler);
}
}
System.out.println("handleChain:"+handler);
}
protected boolean handle(){
if(null == this.handler){
throw new RuntimeException("handler should not be null.");
}
return this.handler.handle();
}
}
上述抽象类获取的链式client处理对象：
链式调用Client：
package com.xiaoxu.handleChain;
import org.springframework.stereotype.Component;
/**
* @author xiaoxu
* @date 2023-01-09
* java_demo2:com.xiaoxu.handleChain.HandleChainClient
*/
@Component
public class HandleChainClient extends AbstractHandleChain{
@Override
public boolean handleChain() {
boolean res;
if(res = this.handle()){
System.out.println("全部业务处理成功!");
}else{
System.out.println("事务中途处理失败!!!");
}
return res;
}
}
IHandle接口：
public interface IHandle {
void setNextIHandle(IHandle iHandle);
IHandle getNextIHandle();
boolean doHandle();
boolean handle();
}
IHandle抽象类：
package com.xiaoxu.handleChain;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
/**
* @author xiaoxu
* @date 2023-01-10
* java_demo2:com.xiaoxu.handleChain.AbstractIHandle
*/
public abstract class AbstractIHandle implements IHandle{
IHandle nextIHandle;
@Override
public void setNextIHandle(IHandle iHandle) {
this.nextIHandle = iHandle;
}
@Override
public IHandle getNextIHandle() {
return this.nextIHandle;
}
@Override
public boolean handle() {
boolean res = this.doHandle();
if(res){
if(null != getNextIHandle()){
return getNextIHandle().handle();
}
return true;
}
return false;
}
@Override
public String toString(){
return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
}
}
IHandle的具体处理实现类：
链式处理step1：前置检查
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
* @author xiaoxu
* @date 2023-01-09
* java_demo2:com.xiaoxu.handleChain.PreHandle
*/
@Component
@Order(value = 1)
public class PreHandle extends AbstractIHandle{
@Override
public boolean doHandle() {
System.out.println("前置检查...");
return true;
}
}
链式处理step2：安全检查
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
* @author xiaoxu
* @date 2023-01-09
* java_demo2:com.xiaoxu.handleChain.CheckSecurityHandle
*/
@Component
@Order(value = 2)
public class CheckSecurityHandle extends AbstractIHandle{
@Override
public boolean doHandle() {
System.out.println("安全检查...");
return true;
}
}
链式处理step3：业务处理
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
* @author xiaoxu
* @date 2023-01-09
* java_demo2:com.xiaoxu.handleChain.ServiceHandle
*/
@Component
@Order(value = 3)
public class ServiceHandle extends AbstractIHandle{
@Override
public boolean doHandle() {
System.out.println("业务处理...");
return true;
}
}
链式处理step4：后置处理
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
* @author xiaoxu
* @date 2023-01-09
* java_demo2:com.xiaoxu.handleChain.PostHandle
*/
@Component
@Order(value = 4)
public class PostHandle extends AbstractIHandle{
@Override
public boolean doHandle() {
System.out.println("后置处理...");
return true;
}
}
编写单测执行：
import com.xiaoxu.MainApplication;
import com.xiaoxu.handleChain.HandleChainClient;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
/**
* @author xiaoxu
* @date 2023-01-09
* java_demo2:PACKAGE_NAME.TestHandle
*/
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MainApplication.class)
public class TestHandle {
@Autowired
HandleChainClient client;
@Test
public void test_01(){
boolean b = client.handleChain();
System.out.println("结果为:" + b);
}
}
执行结果如下，可见达到了链式处理的效果：
若将业务处理的返回改为false后再次执行：
结果如下所示：
