责任链模式是将请求的处理对象像一条链条组合起来，形成对象链。这样做的好处就是请求并不需要知道处理对象是哪一个，实现了请求和处理对象的解耦。
首先先看使用责任链经典的三个地方
1.servlet中的Filter
public class PassThroughFilterChain implements FilterChain {
private Filter filter;
private FilterChain nextFilterChain;
private Servlet servlet;
public PassThroughFilterChain(Filter filter, FilterChain nextFilterChain) {
Assert.notNull(filter, "Filter must not be null");
Assert.notNull(nextFilterChain, "'FilterChain must not be null");
this.filter = filter;
this.nextFilterChain = nextFilterChain;
}
public PassThroughFilterChain(Servlet servlet) {
Assert.notNull(servlet, "Servlet must not be null");
this.servlet = servlet;
}
public void doFilter(ServletRequest request, ServletResponse response) throws ServletException, IOException {
if (this.filter != null) {
this.filter.doFilter(request, response, this.nextFilterChain);
}
else {
this.servlet.service(request, response);
}
}
}
FilterChain执行第一个filter时，执行filter.doFilter方法时会把下一个filter通过参数传递形式传入。如何维护filter链式关系，可以通过一个集合或者数组。比如说ApplicationFilterChain就维护了一个List<FilterConfig>数组，每次调用可以外部控制条用或者通过参数传递形式。
2.dubbo中的Filter(ProtocolFilterWrapper)
private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
Invoker<T> last = invoker;
List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);
if (filters.size() > 0) {
for (int i = filters.size() - 1; i >= 0; i --) {
final Filter filter = filters.get(i);
final Invoker<T> next = last;
last = new Invoker<T>() {
public Class<T> getInterface() {
return invoker.getInterface();
}
public URL getUrl() {
return invoker.getUrl();
}
public boolean isAvailable() {
return invoker.isAvailable();
}
public Result invoke(Invocation invocation) throws RpcException {
return filter.invoke(next, invocation);
}
public void destroy() {
invoker.destroy();
}
@Override
public String toString() {
return invoker.toString();
}
};
}
}
return last;
}
原理就是新建一个invoker包装Filter，Filter.invoke方法会传入前一个invoker，循环调用就会形成一个调用链条。新建的invoker担任的角色就是包装filter，并且设置包装filter后置处理器。实际初始invoker就是执行终点。
3.mybatis中的interceptor
public class Plugin implements InvocationHandler {
private Object target;
private Interceptor interceptor;
private Map<Class<?>, Set<Method>> signatureMap;
private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) {
this.target = target;
this.interceptor = interceptor;
this.signatureMap = signatureMap;
}
public static Object wrap(Object target, Interceptor interceptor) {
Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
Class<?> type = target.getClass();
Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
if (interfaces.length > 0) {
return Proxy.newProxyInstance(
type.getClassLoader(),
interfaces,
new Plugin(target, interceptor, signatureMap));
}
return target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
Set<Method> methods = signatureMap.get(method.getDeclaringClass());
if (methods != null && methods.contains(method)) {
return interceptor.intercept(new Invocation(target, method, args));
}
return method.invoke(target, args);
} catch (Exception e) {
throw ExceptionUtil.unwrapThrowable(e);
}
}
private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
if (interceptsAnnotation == null) { // issue #251
throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());
}
Signature[] sigs = interceptsAnnotation.value();
Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>();
for (Signature sig : sigs) {
Set<Method> methods = signatureMap.get(sig.type());
if (methods == null) {
methods = new HashSet<Method>();
signatureMap.put(sig.type(), methods);
}
try {
Method method = sig.type().getMethod(sig.method(), sig.args());
methods.add(method);
} catch (NoSuchMethodException e) {
throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
}
}
return signatureMap;
}
}
mybatis通过动态代理来实现责任链模式。Mybatis支持对Executor、StatementHandler、PameterHandler和ResultSetHandler 接口进行拦截，也就是说会对这4种对象进行代理。mybatis会生成被拦截接口对象的动态代理类，动态代理类相当于是被拦截对象和拦截器的包装类，动态代理类有个target属性保存被拦截对象，执行时先执行拦截器方法，执行成功调用被拦截对象。动态代理类还可以被拦截再次生成新的动态代理类，每次生成新的都会保存上一个动态代理类，从而实现链式调用。
mybatis的分页就是通过拦截器的形式实现的。
@Intercepts({ @Signature(method = "prepare", type = StatementHandler.class, args = { Connection.class }) })
public class PageInterceptor implements Interceptor {
private static final Logger logger = LoggerFactory.getLogger(PageInterceptor.class);
@Override
public Object plugin(Object target) {
if (target instanceof StatementHandler) {
return Plugin.wrap(target, this);
} else {
return target;
}
}
@Override
public Object intercept(Invocation invocation) throws Throwable {
RoutingStatementHandler handler = (RoutingStatementHandler) invocation.getTarget();
StatementHandler delegate = (StatementHandler) ReflectUtils.getFieldValue(handler, "delegate");
handlePage(invocation, delegate, delegate.getBoundSql());
return invocation.proceed();
}
private void handlePage(Invocation invocation, StatementHandler delegate, BoundSql boundSql) throws SQLException {
Page page = getPage(boundSql.getParameterObject());
if (page == null) {
return;
}
MappedStatement ms = (MappedStatement) ReflectUtils.getFieldValue(delegate, "mappedStatement");
if (page.isCount()) {
count(page, boundSql, ms, (Connection) invocation.getArgs()[0]);
}
handleOrder(boundSql, page.getOrderRules());
String pageSql = new StringBuilder(boundSql.getSql()).append(" limit ").append(page.getStartIndex()).append(",").append(page.getPageSize()).toString();
ReflectUtils.setFieldValue(boundSql, "sql", pageSql);
}
private void handleOrder(BoundSql boundSql, List<OrderRule> orderRules) throws SQLException {
if (CollectionUtils.isEmpty(orderRules)) {
return;
}
StringBuilder orderBuilder = new StringBuilder();
for (OrderRule orderRule : orderRules) {
if (orderBuilder.length() > 0) {
orderBuilder.append(", ");
}
orderBuilder.append(orderRule.getProperty()).append(" ").append(orderRule.getType());
}
ReflectUtils.setFieldValue(boundSql, "sql", new StringBuilder(boundSql.getSql()).append(" order by ").append(orderBuilder).toString());
}
protected void count(Page page, BoundSql boundSql, MappedStatement mappedStatement, Connection connection) throws SQLException {
String countSql = "select count(0) from (" + boundSql.getSql() + ") as temp_count_alias";
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
BoundSql countBoundSql = new BoundSql(mappedStatement.getConfiguration(), countSql, parameterMappings, boundSql.getParameterObject());
ReflectUtils.setFieldValue(countBoundSql, "metaParameters", ReflectUtils.getFieldValue(boundSql, "metaParameters"));
ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, boundSql.getParameterObject(), countBoundSql);
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt = connection.prepareStatement(countSql);
parameterHandler.setParameters(pstmt);
rs = pstmt.executeQuery();
if (rs.next()) {
int totalCount = rs.getInt(1);
page.setTotal(totalCount);
}
} finally {
if (rs != null) {
try {
rs.close();
} catch (Exception e) {
logger.error("close resultSet error", e);
}
}
if (pstmt != null) {
try {
pstmt.close();
} catch (Exception e) {
logger.error("close PreparedStatement error", e);
}
}
}
}
@SuppressWarnings("rawtypes")
private Page getPage(Object paramArgs) {
if (paramArgs == null) {
return null;
}
if (paramArgs instanceof Page) {
return (Page) paramArgs;
}
if (paramArgs instanceof Map) {
for (Object obj : ((Map) paramArgs).values()) {
if (obj instanceof Page) {
return (Page) obj;
}
}
}
return null;
}
}
拦截器比较重要的两个方法plugin、intercept。
plugin是对哪些情况进行拦截，拦截时会生成被拦截对象的动态代理类，intercept是实际拦截执行的操作，这个方法会最终调用invocation.proceed执行操作。
构成链式调用的关键是Plugin interceptor.intercept(new Invocation(target, method, args)); 动态代理类会将被代理对象传入拦截器方法，实际调用就是被拦截对象，当多次包装时，被代理对象仍然是个代理类，就构成了链式调用。
从上面三个例子可以看出来，实现责任链模式关键在于两个角色抽象处理类和具体处理类，类图如下
1.抽象处理类:主要包含指向下一个处理类的成员变量和一个处理请求的方法handleRequest。handleRequest思想就是如果当前满足条件就处理，否则让下一个处理类nextHandler去处理。
2.具体处理类:具体处理类主要是对具体的处理逻辑和处理要满足条件的具体实现。
下面以一个审批金额例子来简单说明这个模式的应用
员工审批金额不能超过500，领导审批金额不能超过1000，经理审批金额不能超过10000。
抽象员工处理类
public abstract class AbstrackClerk {
private AbstrackClerk next;
public AbstrackClerk getNext() {
return next;
}
public void setNext(AbstrackClerk next) {
this.next = next;
}
public abstract int getLimit();
public abstract void approve();
public final void approveRequest(BorrowRequest request) {
if (getLimit() < request.getRequestMoney()) {
if (next != null) {
next.approveRequest(request);
} else {
throw new IllegalStateException("金额过大");
}
} else {
this.approve();
}
}
}
职员处理类
public class Clerk extends AbstrackClerk {
@Override
public int getLimit() {
return 500;
}
@Override
public void approve() {
System.out.println("clerk approve");
}
}
领导具体处理类
public class Leader extends AbstrackClerk {
@Override
public int getLimit() {
return 1000;
}
@Override
public void approve() {
System.out.println("leader approve");
}
}
经理具体处理类
public class Leader extends AbstrackClerk {
@Override
public int getLimit() {
return 1000;
}
@Override
public void approve() {
System.out.println("leader approve");
}
}
Client类 设置具体处理类的后继关系
public class Client {
public static void main(String[] args) {
AbstrackClerk clerk = new Clerk();
AbstrackClerk leader = new Leader();
AbstrackClerk manager = new Manager();
List<AbstrackClerk> clerks = Arrays.asList(clerk, leader, manager);
for (int i = 0; i < clerks.size() - 1; i++) {
clerks.get(i).setNext(clerks.get(i + 1));
}
clerk.approveRequest(new BorrowRequest(5000));
}
}
目前自己还没有动手实现责任链场景，等以后遇到这边继续更新
