您好,登錄后才能下訂單哦!
這期內(nèi)容當(dāng)中小編將會給大家?guī)碛嘘P(guān)怎么在Java項目中實現(xiàn)一個責(zé)任鏈模式,文章內(nèi)容豐富且以專業(yè)的角度為大家分析和敘述,閱讀完這篇文章希望大家可以有所收獲。
1、概念相關(guān)
責(zé)任鏈模式為請求創(chuàng)建了一個接收者對象的鏈,每個接收者都包含對另一個接收者的引用。如果一個對象不能處理該請求,那么它會把相同的請求傳給下一個接收者,沿著這條鏈傳遞請求,直到有對象處理它為止。
客戶只需要將請求發(fā)送到職責(zé)鏈上即可,無須關(guān)心請求的處理細(xì)節(jié)和請求的傳遞,所以職責(zé)鏈將請求的發(fā)送者和請求的處理者解耦了。
1、有多個對象可以處理同一個請求,具體哪個對象處理該請求由運(yùn)行時刻自動確定。
2、在不明確指定接收者的情況下,向多個對象中的一個提交一個請求。
3、可動態(tài)指定一組對象處理請求。
注:代碼中g(shù)etter 和 setter都省略
定義一個請求
public class Request { private String name; private int days; }
定義一個返回結(jié)果
public class Result { private boolean agree; public Result(boolean agree) { this.agree = agree; } }
定義一個處理接口
public interface Handler { // 每個處理器持有鏈,能取到鏈上的請求或者傳遞請求 Result deal(Chain chain); interface Chain { // 獲取請求 Request request(); // 傳遞請求 Result proceed(Request request); } }
定義一個處理接口的鏈
public class HandlerChain implements Handler.Chain { // 持有鏈要處理的請求 private Request request; // 持有鏈上所有的處理器 private Queue<Handler> handlers; public HandlerChain(Request request) { this.request = request; } // 添加一個處理器 public HandlerChain addHandler(Handler handler) { if (handlers == null) { handlers = new LinkedList<>(); } handlers.add(handler); return this; } // 實現(xiàn)接口的方法- 獲取請求 public Request request() { return request; } // 實現(xiàn)接口的方法- 處理請求 public Result proceed(Request request) { // 取隊首的處理器開始請求。如果隊首的處理器處理了,直接返回結(jié)果 // 如果隊首的處理器選擇傳遞請求,又會進(jìn)這個proceed方法。取新的隊首處理 // 為什么是傳遞而不是直接遍歷隊列,如果result = null,繼續(xù);result != null,返回呢? 因為傳遞的方式,可以對request再次處理。A處理器可以做簡單處理,再傳遞給B。 Handler handler = handlers.poll(); return handler.deal(this); } }
定義三個處理者
public class AHandler implements Handler{ public Result deal(Chain chain) { Request request = chain.request(); // 只處理小于等于1的請求,大于1的請求被傳遞了 if (request.getDays() > 1) { // 這里可以對request做部分處理,再傳遞 return chain.proceed(request); } System.out.println("A處理了"); return new Result(true); } } public class BHandler implements Handler { public Result deal(Chain chain) { Request request = chain.request(); // 只處理小于等于2的請求,大于2的請求被傳遞了 if (request.getDays() > 2) { return chain.proceed(request); } System.out.println("B處理了"); return new Result(true); } } public class CHandler implements Handler { public Result deal(Chain chain) { Request request = chain.request(); // 只處理小于等于3的請求,大于3的請求被傳遞了 if (request.getDays() > 3) { return chain.proceed(request); } System.out.println("C處理了"); return new Result(true); } }
測試
public class Test { public static void main(String[] args) { // new 一個鏈,往鏈上添加處理器 Request request1 = new Request("hhy", 3); HandlerChain chains = new HandlerChain(request1).addHandler(new AHandler()).addHandler(new BHandler()).addHandler(new CHandler()); Result result1 = chains.proceed(request1); System.out.println("結(jié)果:" + result1.isAgree()); } }
結(jié)果
傳入3:
返回:
C處理了
結(jié)果:true傳入2:
返回:
B處理了
結(jié)果:true傳入1:
返回:
A處理了
結(jié)果:true
用過netty的同學(xué)看到下面這個代碼應(yīng)該很熟悉了,非常簡單netty客戶端,創(chuàng)建連接,設(shè)置編解碼器,發(fā)送請求。
public static void main(String[] args) { EventLoopGroup group = new NioEventLoopGroup(); NioSocketChannel channel = new NioSocketChannel(); Bootstrap bootstrap = new Bootstrap(); bootstrap.group(group).option(ChannelOption.TCP_NODELAY, true); InetSocketAddress address = new InetSocketAddress(InetAddress.getByName(httpRequest.host), httpRequest.port); group.register(channel); channel.connect(address).sync(); channel.pipeline().addLast("http-decoder", new HttpResponseDecoder()); channel.pipeline().addLast("http-encoder", new HttpRequestEncoder()); channel.pipeline().addLast("http-client", new HttpHandler(HttpClient.this)); channel.writeAndFlush(httpRequest); }
通過我們上面的例子,不難猜測到 channel.pipeline() 應(yīng)該就是一個鏈,持有了channel上所有的處理器。pipeline()方法返回一個ChannelPipeline接口,我們直接看它的實現(xiàn)類
public class DefaultChannelPipeline implements ChannelPipeline { final AbstractChannelHandlerContext head; final AbstractChannelHandlerContext tail; @Override public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) { final AbstractChannelHandlerContext newCtx; synchronized (this) { checkMultiplicity(handler); // 把handler封裝成AbstractChannelHandlerContext newCtx = newContext(group, filterName(name, handler), handler); // 調(diào)用了 addLast0方法 addLast0(newCtx); ... } callHandlerAdded0(newCtx); return this; } private void addLast0(AbstractChannelHandlerContext newCtx) { // 把新加入的處理器設(shè)置成尾部的前驅(qū),原尾部的前驅(qū)設(shè)置成新處理器的后繼 AbstractChannelHandlerContext prev = tail.prev; newCtx.prev = prev; newCtx.next = tail; prev.next = newCtx; tail.prev = newCtx; } }
通過addLast0, 我們看到DefaultChannelPipeline使用了鏈表的形式存儲了處理器。
繼續(xù)看這個類的其他方法
public class DefaultChannelPipeline implements ChannelPipeline { ... @Override public final Channel channel() { return channel; } @Override public final ChannelPipeline fireChannelActive() { AbstractChannelHandlerContext.invokeChannelActive(head); return this; } ... }
返回當(dāng)前的channel,處理channel上的事件。(就類似于我們上面的鏈里面有g(shù)etRequest(),proceed()方法 )
繼續(xù)跟蹤invokeChannelActive方法
abstract class AbstractChannelHandlerContext implements ChannelHandlerContext, ResourceLeakHint { static void invokeChannelActive(final AbstractChannelHandlerContext next) { EventExecutor executor = next.executor(); if (executor.inEventLoop()) { next.invokeChannelActive(); } else { executor.execute(new Runnable() { @Override public void run() { next.invokeChannelActive(); } }); } } // 調(diào)用了invokeChannelActive private void invokeChannelActive() { // 判斷是不是要處理 if (invokeHandler()) { try { // 處理 ((ChannelInboundHandler) handler()).channelActive(this); } catch (Throwable t) { invokeExceptionCaught(t); } } else { // 事件傳遞 fireChannelActive(); } } @Override public ChannelHandlerContext fireChannelActive() { // 執(zhí)行前需要先找到一個合適的處理器 invokeChannelActive invokeChannelActive(findContextInbound(MASK_CHANNEL_ACTIVE)); return this; } private AbstractChannelHandlerContext findContextInbound(int mask) { AbstractChannelHandlerContext ctx = this; EventExecutor currentExecutor = executor(); do { // 循環(huán),找到一個合適的處理器并返回 ctx = ctx.next; } while (skipContext(ctx, currentExecutor, mask, MASK_ONLY_INBOUND)); return ctx; } }
其實看到這,這個鏈已經(jīng)非常的明顯了。 pipline持有處理器,AbstractChannelHandlerContext做了一些封裝,使得鏈上的處理器能對事件進(jìn)行傳遞和處理。
最后再看下handler的實現(xiàn)類
public class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler { ...... @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { ctx.fireChannelActive(); } ...... }
以這個ChannelInboundHandlerAdapter為例,在channel收到激活事件通知的時候,它調(diào)用了ctx.fireChannelActive();方法傳遞了事件。ctx是ChannelHandlerContext類型,很熟悉,它是個接口,我們上面看到的AbstractChannelHandlerContext是它的實現(xiàn)類。就這樣,一個激活事件就在鏈上傳遞了起來。而鏈上的處理器就是我們最初始的測試方法里面addLast進(jìn)去的。
在netty中,事件在責(zé)任鏈中有序傳播,事件處理器可以處理自己關(guān)心的功能,可以攔截,也可以繼續(xù)傳播(向前或向后)事件。上層的業(yè)務(wù)只需要關(guān)心自己的邏輯。整個架構(gòu)層次分明。
OA系統(tǒng)的工作流 似乎也特別適合責(zé)任鏈模式,正如我們一開始的例子,不同人審批不同的時長的假期。
對于代碼里某些冗長的if else ,是不是也有改造成責(zé)任鏈的可能?
if (通過第一關(guān)) {
進(jìn)入第二關(guān)
if (通過第二關(guān)) {
進(jìn)入第三關(guān)
...
}
}
改成通過第一關(guān)后傳遞事件,反之結(jié)束。這期間還可以靈活的做跳躍,得到某個獎勵,直接跳到第三關(guān)。如果要添加第四關(guān),也比if else靈活的多。
上述就是小編為大家分享的怎么在Java項目中實現(xiàn)一個責(zé)任鏈模式了,如果剛好有類似的疑惑,不妨參照上述分析進(jìn)行理解。如果想知道更多相關(guān)知識,歡迎關(guān)注億速云行業(yè)資訊頻道。
免責(zé)聲明:本站發(fā)布的內(nèi)容(圖片、視頻和文字)以原創(chuàng)、轉(zhuǎn)載和分享為主,文章觀點不代表本網(wǎng)站立場,如果涉及侵權(quán)請聯(lián)系站長郵箱:is@yisu.com進(jìn)行舉報,并提供相關(guān)證據(jù),一經(jīng)查實,將立刻刪除涉嫌侵權(quán)內(nèi)容。