tomcat pipline设计模式

最新推荐文章于 2024-06-27 17:35:08 发布

_jerrytiger

最新推荐文章于 2024-06-27 17:35:08 发布

阅读量1.8k

点赞数 2

分类专栏： java

本文链接：https://blog.csdn.net/is_zhoufeng/article/details/49476587

版权

java 专栏收录该内容

86 篇文章 3 订阅

订阅专栏

最近在看tomcat源码，看到其中的Pipline设计模式，觉得很有趣，这里记录一下。

做过java web开发的应该都使用过Servlet和Filter。当想访问一个Servlet时会经过定义好的一系列Filter，然后再访问到Servlet 。这里就用到了Pipline管道设计模式。

Pipline的执行流程如下图

其中的Valve就是一个个阀门，Basic就是最后被执行的对象。可以理解成Valve是Filter，Basic是Servlet 。执行流程是控制权从第一个Valve一直流向最后一个Valve，最后流向Basic，然后从Basic开始再将控制权反向流到最前面的Valve。

在Valve中可以让流继续向下执行，也可以终止后面的执行。

下面通过代码来介绍这种模式。

首先定义一个Pipline接口。来代表这样一个管道，可以添加任意多的Valve，也可以设置一个Basic。（这里的Basic叫Target可能更合适一点）

package tomcat.p4;

import java.util.Map;

/**
 * 管道
 * @author zhoufeng
 *
 */
public interface Pipline{
	
	/**
	 * 这里的basic代表最后要执行的内容（在所有add的Valve执行后执行）
	 * @param basic
	 */
	void setBasic(Valve basic);
	
	/**
	 * 添加一个阀门
	 * @param valve
	 */
	void addValve(Valve valve);
	
	/**
	 * 执行
	 * 将会以此执行add的所有Valve然后执行basic
	 * @param params  携带的参数
	 */
	void invoke(Map<String, Object> params);
	
}

invoke方法就是开始执行这个管道的内容，执行流程就是上面讲的。方法定义了一个Map类型的参数。可以类比Servlet和Filter中的Request和Response参数。

接下来定义一个Valve接口。

该接口只有一个方法invoke，注意invoke中的参数，一个是Map类型，用于传递Pipline执行时传设置的参数，另外一个是PiplineContext，该参数描述了Pipline的上下文信息，在invoke方法中如果需要继续执行后面的Valve，可以使用PiplineContext的invokeNext方法。两个类的定义如下：

package tomcat.p4;

import java.util.Map;

/**
 * 阀门
 * @author zhoufeng
 *
 */
public interface Valve {

	/**
	 * 执行阀门里面的内容
	 * @param params  管道执行时携带过来的参数
	 * @param context 管道上下文
	 */
	void invoke(Map<String, Object> params , PiplineContext context);
	
}

package tomcat.p4;

import java.util.Map;

public interface PiplineContext {

	void invokeNext(Map<String, Object> params);
	
}

接下来实现一个简单的Piplie类。

package tomcat.p4.core;

import java.util.Map;

import tomcat.p4.Pipline;
import tomcat.p4.PiplineContext;
import tomcat.p4.Valve;

/**
 * 一个基本的pipline实现
 * @author zhoufeng
 */
public class SimplePipline implements Pipline{
	
	/**
	 * 阀门列表（相当于一系列的Filter）
	 */
	private Valve[] valves = new Valve[0];
	
	/**
	 * 最终要执行的内容
	 */
	private Valve basic ;

	
	@Override
	public void setBasic(Valve basic) {
		this.basic = basic ;
	}

	/**
	 * 添加一个阀
	 */
	@Override
	public void addValve(Valve valve) {
		Valve[] newValves = new Valve[valves.length + 1];
		System.arraycopy(valves, 0, newValves, 0, valves.length); 
		newValves[newValves.length - 1] = valve ;
		valves = newValves ;
	}

	/**
	 * 执行管道中的内容（注意这里使用内部类实例SimplePiplineContext实现）
	 */
	@Override
	public void invoke(Map<String, Object> params) {
		new SimplePiplineContext().invokeNext(params); 
	}
	
	/**
	 * 这里使用一个私有的内部类实现PiplineContext，用于线性的依次执行pipline中的valves，然后执行basic
	 * @author zhoufeng
	 *
	 */
	private class SimplePiplineContext implements PiplineContext{
		
		/**
		 * 记录当前正在执行到哪个valve
		 */
		private int step = 0 ;

		@Override
		public void invokeNext(Map<String, Object> params) {
			int curStep = step ;	
			step++;
			if(curStep < valves.length){
				valves[curStep].invoke(params , this); 
			}else if(curStep == valves.length){
				if(SimplePipline.this.basic != null){
					SimplePipline.this.basic.invoke(params, this); 
				}
			}else{
				throw new RuntimeException("no valve fond");
			}
		}
		
	}

	
}

里面的经典之处就是使用一个内部类SimplePiplineContext实现PiplineContext接口，从而可以通过该内部类操作宿主类SimplePipline实例的方法。

注意看SImplePipline的invoke方法，是实例化了一个内部类SimplePiplineContext对象，然后通过该对象一步一步调用自身的valves数组和basic对象。

接下来写几个类来测试一下。

首先实现一个HelloValve来当作Basic，将参数params都打印出来（可以理解为一个Servlet）

package tomcat.p4.test.valve;

import java.util.Map;
import java.util.Map.Entry;

import tomcat.p4.PiplineContext;
import tomcat.p4.Valve;

public class HelloValve implements Valve{

	@Override
	public void invoke(Map<String, Object> params, PiplineContext context) {
		System.out.println("--------------Hello Servlet ：--------------");
		if(params != null && params.size() > 0){
			for (Entry<String, Object> entry : params.entrySet()) {  
				System.out.printf("key:%s\tvalue:%s\n",entry.getKey() , entry.getValue());
			}
		} 
	}
	
}

然后实现一个BeforeValve，在basic前面打印一行内容。（可以理解为一个Filter）

package tomcat.p4.test.valve;

import java.util.Map;

import tomcat.p4.PiplineContext;
import tomcat.p4.Valve;

public class BeforeValve implements Valve{

	@Override
	public void invoke(Map<String, Object> params, PiplineContext context) {
		System.out.println("----------------BeforeValve-----------------");
		context.invokeNext(params); 
	}

	
}

再实现一个AfterValve，在basic后面打印一行内容。（可以理解为一个Filter）

package tomcat.p4.test.valve;

import java.util.Map;

import tomcat.p4.PiplineContext;
import tomcat.p4.Valve;

public class AfterValve implements Valve{

	@Override
	public void invoke(Map<String, Object> params, PiplineContext context) {
		context.invokeNext(params); 
		System.out.println("----------------AfterValve-----------------");
	}

}

再实现一个AroundValve，在basic的前后都打印一段内容。（可以理解为一个Filter）

package tomcat.p4.test.valve;

import java.util.Map;

import tomcat.p4.PiplineContext;
import tomcat.p4.Valve;

public class AroundValve implements Valve{

	@Override
	public void invoke(Map<String, Object> params, PiplineContext context) {
		System.out.println("----------------AroundValve before-----------------");
		
		context.invokeNext(params); 
		
		System.out.println("----------------AroundValve after-----------------");
	}

	
}

然后写个测试类来试试。

package tomcat.p4.test;

import java.util.HashMap;
import java.util.Map;

import tomcat.p4.Pipline;
import tomcat.p4.Valve;
import tomcat.p4.core.SimplePipline;
import tomcat.p4.test.valve.AfterValve;
import tomcat.p4.test.valve.AroundValve;
import tomcat.p4.test.valve.BeforeValve;
import tomcat.p4.test.valve.HelloValve;

public class Startup {

	public static void main(String[] args) {
		
		Pipline pipline = new SimplePipline();
		
		Valve helloValve = new HelloValve(); 
		
		Valve beforeValve = new BeforeValve();
		Valve afterValve = new AfterValve();
		Valve aroundValve = new AroundValve();
		
		pipline.setBasic(helloValve); 
		
		pipline.addValve(beforeValve);
		pipline.addValve(afterValve);
		pipline.addValve(aroundValve);
		
		Map<String, Object> params = new HashMap<String , Object>(); 
		params.put("a", 1);
		params.put("b", 2);
		params.put("c", 3);
		
		pipline.invoke(params);  
		
	}
	
}

执行结果

----------------BeforeValve-----------------
----------------AroundValve before-----------------
--------------Hello Servlet ：--------------
key:a	value:1
key:b	value:2
key:c	value:3
----------------AroundValve after-----------------
----------------AfterValve-----------------