7.8-7.15

最新推荐文章于 2021-07-10 20:00:34 发布

劳资是学渣丶

最新推荐文章于 2021-07-10 20:00:34 发布

阅读量151

点赞数

本文链接：https://blog.csdn.net/weixin_41545613/article/details/95897370

版权

1 Template Method 模式

Template Method是带有模版功能的模式，组成模版的方法被定义在父类中，由于这些方法是抽象方法，所以只看父类的代码是无法知道这些方法最终会进行何种具体的处理的。

实现上述方法的是子类，但是不管子类具体如何实现，处理的流程都会按照父类所定义的进行

像这样在父类中定义处理流程的框架，在子类中实现具体处理的模式，称为Template Method模式.

1.1 示例程序

[外链图片转存失败(img-HyYBtVdQ-1563093798347)(http://note.youdao.com/yws/res/1737/04F3143D797C4F519A73CA1576CF4DE9)]

package designModel.TemplateModel;

public abstract class AbstractDisplay {
    public abstract void open();

    public abstract void print();

    public abstract void close();

    public final void display(){
        open();
        for(int i = 0; i < 5; i++){
            print();
        }
        close();
    }
}

package designModel.TemplateModel;

public class StringDisplay extends AbstractDisplay {

    private String string;

    private int width;

    public StringDisplay(String string) {
        this.string = string;
        this.width = string.getBytes().length;
    }

    @Override
    public void open() {
        printLine();
    }

    @Override
    public void print() {
        System.out.println("|" + string + "|");
    }

    @Override
    public void close() {
        printLine();
    }

    public void printLine(){
        System.out.print("+");
        for(int i = 0; i < width; i++){
            System.out.print("-");
        }
        System.out.println("+");
    }
}

package designModel.TemplateModel;

public class CharDisplay extends AbstractDisplay {

    private char ch;

    public CharDisplay(char ch) {
        this.ch = ch;
    }

    @Override
    public void open() {
        System.out.print("<<");
    }

    @Override
    public void print() {
        System.out.print(ch);
    }

    @Override
    public void close() {
        System.out.println(">>");
    }
}

package designModel.TemplateModel;

public class Main {
    public static void main(String[] args){
        AbstractDisplay d1 = new CharDisplay('H');
        AbstractDisplay d2 = new StringDisplay("Hello, World.");
        AbstractDisplay d3 = new StringDisplay("你好，世界");
        d1.display();
        d2.display();
        d3.display();
    }
}

输出如下结果:

<<HHHHH>>
+-------------+
|Hello, World.|
|Hello, World.|
|Hello, World.|
|Hello, World.|
|Hello, World.|
+-------------+
+---------------+
|你好，世界|
|你好，世界|
|你好，世界|
|你好，世界|
|你好，世界|
+---------------+

2 Factory Method 模式

2.1 示例程序

这段示例程序的作用是制作身份证，其中有5个类。Product和Factory类属于frameword包，这两个类组成了生成实例的框架。
IDCard类和IDCardFactory类负责实际的加工处理，她们属于idcard包
Main用于测试

2.1.1 Product类

frameword包中的Product类是用来表示产品的类，在该类中仅声明了use抽象方法。use方法的实现则被交给了Product类的子类.

package designModel.FactoryMethod.framework;

public abstract class Product {
    public abstract void use();
}

2.1.2 Factory类

createProduct的抽象方法和用于“注册产品”的registerProduct抽象方法。

在这个框架中，我们定义了工厂是用来“调用create方法生成Product实例”的，而create方法的实现是先调用createProduct生成产品，接着用registerProduct注册产品.

package designModel.FactoryMethod.framework;

public abstract class Factory {
    public final Product create(String owner){
        Product p = createProduct(owner);
        registerProduct(p);
        return p;
    }
    protected abstract Product createProduct(String owner);
    protected abstract void registerProduct(Product product);
}

2.1.3 IDCard类

package designModel.FactoryMethod.idcard;

import designModel.FactoryMethod.framework.Product;

public class IDCard extends Product {

    private String owner;

    public IDCard(String owner) {
        System.out.println("制作" + owner + "的ID卡");
        this.owner = owner;
    }

    @Override
    public void use() {
        System.out.println("使用" + owner + "的ID卡");
    }

    public String getOwner() {
        return owner;
    }
}

2.1.4 IDCardFactory类

package designModel.FactoryMethod.idcard;

import designModel.FactoryMethod.framework.Factory;
import designModel.FactoryMethod.framework.Product;

import java.util.ArrayList;
import java.util.List;

public class IDCardFactory extends Factory {

    private List owners = new ArrayList();

    @Override
    protected Product createProduct(String owner) {
        return new IDCard(owner);
    }

    @Override
    protected void registerProduct(Product product) {
        owners.add(((IDCard)product).getOwner());
    }

    public List getOwners() {
        return owners;
    }
}

2.1.5 Main类

package designModel.FactoryMethod;

import designModel.FactoryMethod.framework.Factory;
import designModel.FactoryMethod.framework.Product;
import designModel.FactoryMethod.idcard.IDCardFactory;

public class Main {
    public static void main(String[] args){
        Factory factory = new IDCardFactory();
        Product card1 = factory.create("小明");
        Product card2 = factory.create("小红");
        Product card3 = factory.create("小刚");
        card1.use();
        card2.use();
        card3.use();
    }
}

运行结果：

制作小明的ID卡
制作小红的ID卡
制作小刚的ID卡
使用小明的ID卡
使用小红的ID卡
使用小刚的ID卡

2.2 Factory Method登场角色

[外链图片转存失败(img-KyP1ouYq-1563093798348)(http://note.youdao.com/yws/res/1783/6CC513C023C94148BC790F43575EF053)]

Product（产品）

它定义了在Factory Method模式中生成的那些实例所持有的API，但具体的处理由子类ConcreateProduct角色决定
Creator（创建者）

负责生成Product角色的抽象类，但具体的处理则由子类ConcreteCreator角色决定。Creator角色对于实际负责生成实例的ConcreteCreator角色一无所知，它唯一知道的就是，只要调用Product角色和生成实例的方法，就可以生成Product的实例。在示例程序中，createProduct方法是用于生成实例的方法。不用new关键字来生成实例，而是调用生成实例的专用方法来生成实例，这样就可以防止父类与其他具体类耦合
ConcreteProduct(具体的产品)
ConcreteCreator(具体的加工者)

3 Abstract Facotry模式

抽象工厂的工作是将“抽象零件”组装成为“抽象的产品”，我们并不关心零件的具体实现，而是只关心接口，我们仅仅使用该接口将零件组装成为产品。

3.1 示例程序

<html>
<head>
    <title>LinkPage</title>
</head>
<body>
<h1>
    LinkPage
</h1>
<ul>
    <li>
        <ul>
            <li>
                <a href="http://www.people.com.cn">人民日报</a>
            </li>
            <li>
                <a href="http://www.gmw.cn">光明网</a>
            </li>
        </ul>
    </li>
    <ul>
        <li>
            Yahoo!
            <ul>
                <li><a href="http://www.yahoo.com/">Yahoo!</a></li>
                <li><a href="http://www.yahoo.co.jp/">Yahoo!Japan</a></li>
            </ul>
        </li>
        <li><a href="http://www.excite.com/">Excite</a></li>
        <li><a href="http://www.google.com/">Google</a></li>
    </ul>
</ul>
</body>
</html>

实例程序的功能是将导游层次关系的连接的集合制作成HTML文件，最后制作完成的HTML如上

在实例程序中，类被划分3个包

factory包：包含抽象工厂、零件、产品的包
listfactory包：包含具体工厂、零件、产品的包
Main的包

3.1.1 具体实现

抽象的零件：item类
Item类是Link和Tray类的父类，这样Link和Tray类就有可替换行了。
caption字段表示项目的标题
makeHTML方法交给子类实现

各个类:

package designModel.AbstractFactory.factory;

public abstract class Factory {
    public static Factory getFactory(String classname){
        Factory factory = null;
        try{
            factory = (Factory) Class.forName(classname).newInstance();
        }catch (ClassNotFoundException e){
            System.out.println("没有找到" + classname + " 类.");
        }catch (Exception e){
            e.printStackTrace();
        }
        return factory;
    }
    public abstract Link createLink(String caption, String url);
    public abstract Tray createTray(String caption);
    public abstract Page createPage(String title, String author);
}
/* -------------------------------------------------------- */
package designModel.AbstractFactory.factory;

public abstract class Item {
    protected String caption;

    public Item(String caption){
        this.caption = caption;
    }
    public abstract String makeHTML();
}
/* -------------------------------------------------------- */
package designModel.AbstractFactory.factory;

import java.io.PrintWriter;

public abstract class Link extends Item {
    protected String url;
    public Link(String caption, String url){
        super(caption);
        this.url = url;
    }
}
/* -------------------------------------------------------- */
package designModel.AbstractFactory.factory;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;

public abstract class Page {
    protected String title;
    protected String author;
    protected ArrayList content = new ArrayList();
    public Page(String title, String author){
        this.title = title;
        this.author = author;
    }

    public void add(Item item){
        content.add(item);
    }

    public void output(){
        try{
            String fileName = title + ".html";
            Writer writer = new FileWriter(fileName);
            writer.write(this.makeHTML());
            writer.close();
            System.out.println(fileName + "编写完成");
        }catch (IOException e ){
            e.printStackTrace();
        }
    }

    public abstract String makeHTML();
}
/* -------------------------------------------------------- */
package designModel.AbstractFactory.factory;

import java.util.ArrayList;

public abstract class Tray extends Item {
    protected ArrayList tray = new ArrayList();

    public Tray(String caption) {
        super(caption);
    }

    public void add(Item item) {
        tray.add(item);
    }
}
/* -------------------------------------------------------- */
package designModel.AbstractFactory.listfactory;

import designModel.AbstractFactory.factory.Factory;
import designModel.AbstractFactory.factory.Link;
import designModel.AbstractFactory.factory.Page;
import designModel.AbstractFactory.factory.Tray;

public class ListFactory extends Factory {
    @Override
    public Link createLink(String caption, String url) {
        return new ListLink(caption, url);
    }

    @Override
    public Tray createTray(String caption) {
        return new ListTray(caption);
    }

    @Override
    public Page createPage(String title, String author) {
        return new ListPage(title, author);
    }
}
/* -------------------------------------------------------- */
package designModel.AbstractFactory.listfactory;

import designModel.AbstractFactory.factory.Link;

public class ListLink extends Link {
    public ListLink(String caption, String url){
        super(caption, url);
    }
    @Override
    public String makeHTML() {
        return "<li><a href=\"" + url + "\">" + caption + "</a><li>\n";
    }
}
/* -------------------------------------------------------- */
package designModel.AbstractFactory.listfactory;

import designModel.AbstractFactory.factory.Item;
import designModel.AbstractFactory.factory.Page;

import java.util.Iterator;

public class ListPage extends Page {

    public ListPage(String title, String author){
        super(title, author);
    }

    @Override
    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<html><head><title>" + title + "</title></head>\n");
        buffer.append("<body>\n");
        buffer.append("<h1>" + title + "</h1>\n");
        buffer.append("<ul>\n");
        Iterator it = content.iterator();
        while(it.hasNext()){
            Item item = (Item)it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</ul>\n");
        buffer.append("<hr><address>" + author + "</address>");
        buffer.append("</body></html>\n");
        return buffer.toString();
    }
}
/* -------------------------------------------------------- */
package designModel.AbstractFactory.listfactory;

import designModel.AbstractFactory.factory.Item;
import designModel.AbstractFactory.factory.Tray;

import java.util.Iterator;

public class ListTray extends Tray {

    public ListTray(String caption){
        super(caption);
    }

    @Override
    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<li>\n");
        buffer.append(caption + "\n");
        buffer.append("<ul>\n");
        Iterator it = tray.iterator();
        while(it.hasNext()){
            Item item = (Item) it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("<ul>\n");
        buffer.append("<li>\n");
        return buffer.toString();
    }
}
/* -------------------------------------------------------- */

[外链图片转存失败(img-ePGUBawz-1563093798348)(https://note.youdao.com/src/FB8F70F1087B484B8AFDBE7319FD35A4)]

4、Builder模式

组装具有复杂结构的实例叫做Builder模式

4.1 实例程序

采用Builder模式编写“文档”，文档具有

含有一个标题
含有几条字符串
含有条目项目

package designModel.BuilderModel;

public abstract class Builder {
    public abstract void makeTitle(String title);
    public abstract void makeString(String str);
    public abstract void makeItems(String[] items);
    public abstract void close();
}
/* -------------------------------------------------------- */
package designModel.BuilderModel;

public class Directory {
    private Builder builder;

    public Directory(Builder builder) {
        this.builder = builder;
    }

    public void construct(){
        builder.makeTitle("Greeting");
        builder.makeString("从早上至下午");
        builder.makeItems(new String[]{
                "早上好.",
                "下午好."
        });
        builder.makeString("晚上");
        builder.makeItems(new String[] {
                "晚上好,",
                "晚安。",
                "再见."
        });
        builder.close();
    }
}
/* -------------------------------------------------------- */
package designModel.BuilderModel;

public class TestBuilder extends Builder {

    StringBuffer buffer = new StringBuffer();

    @Override
    public void makeTitle(String title) {
        buffer.append("===========================\n");
        buffer.append("[" + title +"]\n");
        buffer.append("\n");
    }

    @Override
    public void makeString(String str) {
        buffer.append("-" + str +"\n");
        buffer.append("\n");
    }

    @Override
    public void makeItems(String[] items) {
        for(String item:items){
            buffer.append("    ." + item + "\n");
        }
        buffer.append("\n");
    }

    @Override
    public void close() {
        buffer.append("===========================\n");
    }
    public String getResult(){
        return buffer.toString();
    }
}
/* -------------------------------------------------------- */

5 责任链模式

5.1 拦截器模式

首先定义一个拦截器接口：

package designModel.responseChain;

import java.lang.reflect.Method;

public interface Interceptor {
    public boolean before(Object proxy, Object target, Method method, Object[] args);
    public boolean around(Object proxy, Object target, Method method, Object[] args);
    public boolean after(Object proxy, Object target, Method method, Object[] args);
}

实现这个Inteceptor类:

package designModel.responseChain;

import java.lang.reflect.Method;

public class MyInterceptor implements Interceptor {
    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("反射方法前逻辑");
        return false;//不反射被代理对象原有方法
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("取代了被代理对象逻辑");
    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("反射方法后逻辑");
    }
}

package designModel.responseChain;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class InterceptorJdkProxy implements InvocationHandler {

    private Object target; //真实对象

    private String interceptorClass = null; //拦截器全限定名

    public InterceptorJdkProxy(Object target, String interceptorClass) {
        this.target = target;
        this.interceptorClass = interceptorClass;
    }

    public static Object bind(Object target, String interceptorClass){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),new InterceptorJdkProxy(target,interceptorClass));
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(interceptorClass == null){
            return method.invoke(target, args);
        }
        Object result = null;
        Interceptor interceptor = (Interceptor) Class.forName(interceptorClass).newInstance();
        if(interceptor.before(proxy, target,method,args)){
            result = method.invoke(proxy,args);
        }else{
            interceptor.around(proxy, target, method, args);
        }
        interceptor.after(proxy,target,method,args);
        return result;
    }
}

5.2 责任链模式

责任链模式就是运用多个拦截器，一个拦截器拦截另外一个代理对象，以此类推。

劳资是学渣丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
7.8-7.15

1 Template Method 模式Template Method是带有模版功能的模式，组成模版的方法被定义在父类中，由于这些方法是抽象方法，所以只看父类的代码是无法知道这些方法最终会进行何种具体的处理的。实现上述方法的是子类，但是不管子类具体如何实现，处理的流程都会按照父类所定义的进行像这样在父类中定义处理流程的框架，在子类中实现具体处理的模式，称为Template Method模式....
复制链接

扫一扫