正文
一、职责链模式
介绍
顾名思义，职责链模式是为请求创建一个接收者对象的链，对请求的发送者和接收者进行解耦。
举个例子，比如说，公司请假，根据请假时长不同，递交到公司领导的级别也不一样，这种层级递交的关系就是一种链式结构
实现
创建抽象类AbstractArticleHandler，创建两种类型的文章处理类，都扩展了AbstractArticleHandler，每个文章处理类都有自己的逻辑，通过文章类型判断，如果是则执行相应文章处理类，否则把消息传给下一个文章处理类
步骤1
创建抽象的文章处理类
public abstract class AbstractArticleHandler { /** * 下一个处理者 */ private AbstractArticleHandler abstractArticleHandler; /** * 获取articleType * @return */ protected abstract ArticleTypeEnum getArticleTypeEnum(); /** * 拉取文章 * @param uris 链接数组 * @return */ protected abstract void articlePull(String[] uris); public final void handlerArticle(final List<String> links,final String articleType) { if (this.getArticleTypeEnum().getValue().equals(articleType)) { this.articlePull(links.toArray(new String[links.size()])); } else { if (this.abstractArticleHandler != null) { this.abstractArticleHandler.handlerArticle(links, articleType); } } } public void setNext(AbstractArticleHandler abstractArticleHandler) { this.abstractArticleHandler = abstractArticleHandler; } } enum ArticleTypeEnum { CSDN("csdn"), BKY("bky"); private final String value; ArticleTypeEnum(String value) { this.value = value; } public String getValue() { return value; } }
步骤2
创建扩展文章处理类
public class CsdnArticleHandler extends AbstractArticleHandler{ @Override protected ArticleTypeEnum getArticleTypeEnum() { return ArticleTypeEnum.CSDN; } @Autowired private PipelineObserver pipelineObserver; @Override protected void articlePull(String[] uris) { } }
public class BkyArticleHandler extends AbstractArticleHandler{ @Override protected ArticleTypeEnum getArticleTypeEnum() { return ArticleTypeEnum.BKY; } @Override protected void articlePull(String[] uris) { } }
步骤3
添加文章处理器，形成链式调用
public class ArticleService { public static void main(String[] args) { AbstractArticleHandler a1 = new CsdnArticleHandler(); AbstractArticleHandler a2 = new BkyArticleHandler(); a1.setNext(a2); a1.handlerArticle("链接地址","csdn"); } }
二、装饰器模式
介绍
装饰器模式允许向一个现有的对象添加新的功能，同时又不修改其结构
举个例子，比如说，手机有没有贴膜，都是是可以使用，手机贴上膜，不影响手机的使用
实现
创建ProcessStrategy接口和实现了ProcessStrategy接口的实体类，然后创建一个实现ProcessStrategy接口的抽象装饰类ProcessHandler，并把processStrategy对象作为它的实例变量，IteratorProcess实现ProcessHandler实体类，ArticleHandler类使用ProcessHandler来装饰ProcessStrategy
步骤1
创建接口
/** * @author Kou Shenhai * @version 1.0 * @date 2021/4/24 0024 下午 3:44 */ public interface ProcessStrategy { /** * 爬虫具体执行方法 * @param page */ void process(Page page); }
步骤2
创建实现接口的实现类
/** * * @author Kou Shenhai * @version 1.0 * @date 2021/4/24 0024 下午 4:05 */ public class BkyArticleProcess implements ProcessStrategy{ @Override public void process(Page page) { } }
/** * * @author Kou Shenhai * @version 1.0 * @date 2021/4/24 0024 下午 4:05 */ public class CsdnArticleProcess implements ProcessStrategy{ @Override public void process(Page page) { } }
步骤3
创建实现ProcessStrategy接口的抽象装饰类
/** * 装饰类 ，伪实现类 * @author Kou Shenhai * @version 1.0 * @date 2021/4/24 0024 下午 4:01 */ public abstract class ProcessHandler implements ProcessStrategy{ protected volatile ProcessStrategy processStrategy; public ProcessHandler(ProcessStrategy processStrategy) { this.processStrategy = processStrategy; } @Override public void process(Page page) { processStrategy.process(page); } }
步骤4
扩展ProcessHandler类的实体装饰类
/** * 装饰者，用来装饰csdn文章 * @author Kou Shenhai * @version 1.0 * @date 2021/4/24 0024 下午 4:15 */ public class IteratorProcess extends ProcessHandler{ public IteratorProcess(ProcessStrategy processStrategy) { super(processStrategy); } }
步骤5
使用IteratorProcess来装饰ProcessStrategy对象
public class ArticleHandler{ public static void main(String[] args) { //装饰 IteratorProcess process = new IteratorProcess(new BkyArticleProcess()); } }
三、观察者模式
介绍
当对象存在一对多关系时，则使用观察者模式。
举个例子，比如说一个对象的数据发生变更，则会自动通知依赖它的对象
注：jdk有对观察者模式的支持类
实现（采用jdk自带的观察者模式并进行扩展）
观察者模式使用三个类，ArticleObserver、Observer和Observable（由具体的类来实现）。Observable对象带有绑定观察者到ArticleObserver对象和从Client对象解绑观察者的方法。我们创建Observable类、Observer接口和实现Observer类的实体类
步骤1
创建Observable类
/** * 参考java.util.Observable * 让具体的实现类实现相关逻辑，^秒啊^ * @author Kou Shenhai */ public interface Observable { /** * 加入观察者 * @param o */ void addObserver(Observer o); /** * 通知观察者 * @param arg */ void notifyObservers(Object arg); /** * 解绑观察者 * @param o */ void deleteObserver(Observer o); }
步骤2
实现Observable类
public class ArticlePipeline implements Observable{ private Vector<Observer> obs; public ArticlePipeline() { obs = new Vector<>(1); } @Override public void process(ResultItems resultItems, Task task) { notifyObservers(resultItems.getAll()); } @Override public synchronized void addObserver(Observer o) { if (o == null) { throw new NullPointerException(); } if (!obs.contains(o)) { obs.addElement(o); } } @Override public synchronized void notifyObservers(Object arg) { Object[] arrLocal; synchronized (this) { arrLocal = obs.toArray(); } for (int i = arrLocal.length - 1; i >= 0; i--) { ((Observer)arrLocal[i]).update(this, arg); } } @Override public synchronized void deleteObserver(Observer o) { obs.removeElement(o); } }
步骤3
创建 Observer 类
/** * 参考{@link java.util.Observer}设计 * @author Kou Shenhai */ public interface Observer { /** * 信息变更 * @param o * @param data */ void update(Observable o, Object data); }
步骤4
创建实体观察类
public class PipelineObserver implements Observer { @Override public void update(Observable o, Object data) { } }
步骤5
使用Observable和实体观察者对象
public class ArticleHandler{ public static void main(String[] args) { Observer o = new PipelineObserver(); Observable ob = new ArticlePipeline(); ob.addObserver(o); } }
