因爲該模式有以下部分組成所以
所以首先來寫filter，但是在寫filter之前必須有pipe也就是管道，所以先來定義管道
pipe類
package ch03.pipesfilteres;
import java.util.ArrayDeque;
public class Pipe {
private ArrayDeque<Packet> packets = new ArrayDeque<Packet>();
public void write(Packet packet) {
packets.addFirst(packet);
//System.out.println(""+packet+" is written into pipe.");
}
public int size() {
return packets.size();
}
public Packet read() throws EmptyPipeException {
if (size() == 0) {
throw new EmptyPipeException();
}
Packet p = packets.getLast();
packets.pollLast();
return p;
}
}
寫完pipe之後，就可以寫filter類了
首先是一個抽象類
package ch03.pipesfilteres;
public abstract class Filter {
protected Pipe input;
protected Pipe output;
public Filter(Pipe in, Pipe out) {
input=in;
output=out;
}
public abstract void process();
}
他的實現：
package ch03.pipesfilteres;
public class FilterImpl extends Filter {
public FilterImpl(Pipe in,Pipe out) {
super(in,out);
}
public void customNotify() {
process();
}
@Override
public void process() {
while (input.size() > 0) {
try {
Packet packet=input.read();//
//packet.setContent("");
output.write(packet);
System.out.println("已經將"+packet+"寫入到了pipe2");
} catch (EmptyPipeException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
寫完這個之後就要把pipe放入數據source中，那麼source是如何實現的呢？可想而知，其接受pipe
package ch03.pipesfilteres;
public class DataSource extends Filter{
public DataSource(Pipe out) {
super(null,out);
}
@Override
public void process() {
for(int i=1;i<5;i++) {
System.out.println("DataSource: packet("+i+") is created.");
Packet p=new Packet(i);
p.setContent("第"+i+"已經寫入pipe");
System.out.println("第"+i+"已經寫入pipe");
output.write(p);
}
}
}
filter寫完之後就要開始完成sink的編寫了，也就是要將經過filer處理過的pipe輸入到終點
package ch03.pipesfilteres;
import java.util.ArrayDeque;
public class DataSink extends Filter{
private FilterImpl observer;
protected ArrayDeque<Packet> received = new ArrayDeque<Packet>();
public DataSink(Pipe in) {
super(in,null);
observer = null;
}
public int size() {
return received.size();
}
public Packet nextPacket() {
Packet p = received.getLast();
received.pollLast();
return p;
}
public void customNotify() {
try {
while(input.size() > 0) {
received.addFirst(input.read());
}
} catch (EmptyPipeException e) {
System.err.println(" empty pipe. ");
}
if(observer != null)
observer.customNotify();
}
public void setObserver(FilterImpl observer) {
this.observer = observer;
}
public FilterImpl getObserver() {
return observer;
}
@Override
public void process() {
try {
int i=0;
for(i=0;i<4;i++){
System.out.println(input.read()+"已經進入了數據池");
}
} catch (EmptyPipeException e) {
e.printStackTrace();
}
}
}
這些寫完之後就是其他一些類的編寫了
package ch03.pipesfilteres;
public class Packet {
//標號
private int pno = -1;
//標號對應的內容
private String content;
public Packet() {
}
public Packet(int no) {
pno = no;
}
public void setContent(String c) {
content=c;
}
public String toString() {
return "Packet(" + pno + "):"+content;
}
}
package ch03.pipesfilteres;
public class EmptyPipeException extends Exception {
}
package ch03.pipesfilteres;
public class NoOutputPipeException extends Exception {
}
最後就可以編寫一個測試類來測試了
package ch03.pipesfilteres;
public class TestPipes {
public static void main(String[] args) {
/** Instantiate our pattern blueprint classes. */
Pipe pipe1 = new Pipe();
Pipe pipe2= new Pipe();
DataSource source = new DataSource(pipe1);
source.process();
FilterImpl filter=new FilterImpl(pipe1,pipe2);
filter.process();
DataSink sink = new DataSink(pipe2);
sink.process();
}
}
得到以下的運行結果
DataSource: packet(1) is created.
第1已經寫入pipe
DataSource: packet(2) is created.
第2已經寫入pipe
DataSource: packet(3) is created.
第3已經寫入pipe
DataSource: packet(4) is created.
第4已經寫入pipe
已經將Packet(1):第1已經寫入pipe寫入到了pipe2
已經將Packet(2):第2已經寫入pipe寫入到了pipe2
已經將Packet(3):第3已經寫入pipe寫入到了pipe2
已經將Packet(4):第4已經寫入pipe寫入到了pipe2
Packet(1):第1已經寫入pipe已經進入了數據池
Packet(2):第2已經寫入pipe已經進入了數據池
Packet(3):第3已經寫入pipe已經進入了數據池
Packet(4):第4已經寫入pipe已經進入了數據池
目錄結構如下：
代碼在我的資源中，如果需要請下載