这正是命令格局的方式动机,Android 框架结构师之路 目录

情势动机
图片 1

格局动机
图片 2

Android 框架结构师之路 目录

在软件设计中,我们平时需求向少数对象发送请求,可是并不知道请求的接收者是何人,也不知道被呼吁的操作是哪些,大家只需在程序运转时钦点具体的央浼接收者即可,此时,能够动用命令情势来开始展览统一筹划,使得请求发送者与请求接收者消除相互之间的耦合,让对象之间的调用关系尤其灵敏。
命令形式能够对发送者和接收者完全解耦,发送者与接收者之间从未直接引用关系,发送请求的靶子只必要领会什么发送请求,而不要知道怎么办到请求。这正是命令方式的方式动机。

在软件设计中,大家日常需求向一些对象发送请求,可是并不知道请求的收信人是何人,也不理解被呼吁的操作是哪些,大家只需在程序运转时钦点具体的请求接收者即可,此时,可以选拔命令情势来进展统一筹划,使得请求发送者与请求接收者消除互相之间的耦合,让对象之间的调用关系进一步灵敏。
命令形式能够对发送者和接收者完全解耦,发送者与接收者之间从未平素引用关系,发送请求的靶子只必要精通什么样发送请求,而不用知道怎么样做到请求。那正是命令方式的格局动机。

一 、命令格局概念

形式定义
一声令下格局(Command
Pattern):将3个请求封装为1个对象,从而使大家可用不一样的请求对客户拓展参数化;对请求排队或者记录请求日志,以及支持可收回的操作。命令情势是一种对象行为型格局,其外号为动作(Action)格局或业务(Transaction)情势。
Command Pattern: Encapsulate a request as an object, thereby letting you
parameterize clients with different requests, queue or log requests, and
support undoable operations.
Frequency of use: medium high
UML图
图片 3

形式定义
命令格局(Command
Pattern):将三个呼吁封装为2个对象,从而使我们可用分歧的伸手对客户进行参数化;对请求排队只怕记录请求日志,以及支持可收回的操作。命令情势是一种对象行为型形式,其外号为动作(Action)形式或工作(Transaction)情势。
Command Pattern: Encapsulate a request as an object, thereby letting you
parameterize clients with different requests, queue or log requests, and
support undoable operations.
Frequency of use: medium high
UML图
图片 4

1.1 介绍

命令形式(Command
Pattern)是一种多少驱动的设计方式,它属于行为型格局。请求以命令的样式包裹在目的中,并传给调用对象。调用对象寻找能够拍卖该命令的适合的靶子,并把该命令传给相应的靶子,该对象执行命令。

情势协会
指令情势涵盖如下剧中人物:
Command: 抽象命令类
ConcreteCommand: 具体命令类
Invoker: 调用者
Receiver: 接收者
Client:客户类

方式组织
一声令下方式涵盖如下角色:
Command: 抽象命令类
ConcreteCommand: 具体命令类
Invoker: 调用者
Receiver: 接收者
Client:客户类

1.2 定义

将三个呼吁封装为一个对象,从而使你可用差别的伸手对客户进行参数化,对请求排队或记录请求日志。以及扶助可撤废的操作。

方式分析
指令方式的面目是对命令进行打包,将发出指令的权责和执行命令的权利分开开。
每贰个指令都以2个操作:请求的一方发出请求,必要履行多个操作;接收的一方接受请求,并进行操作。
一声令下格局允许请求的一方和接收的一方独立开来,使得请求的一方无需知道接收请求的一方的接口,更不要知道请求是怎么被接受,以及操作是或不是被实施、何时被实施,以及是怎么被实践的。

方式分析
指令方式的精神是对命令进行打包,将发生命令的义务和执行命令的责任分开开。
每三个指令都以一个操作:请求的一方发出请求,要求执行三个操作;接收的一方接受请求,并推行操作。
命令情势允许请求的一方和收取的一方独立开来,使得请求的一方不要知道接收请求的一方的接口,更无需知道请求是怎么被接到,以及操作是不是被实践、几时被实践,以及是怎么被执行的。

1.3 使用情状
  • 系统需求将呼吁调用者和请求接收者解耦,使得调用者和接收者不间接互动。
  • 系统供给在分化的时间钦定请求、将呼吁排队(如:线程池+工作行列)和实践请求。
  • 系统须求辅助命令的打消(Undo)操作和还原(Redo)操作。
  • 系统供给将一组操作结合在联合署名,即支持宏命令。

指令形式使请求笔者成为贰个目的,那几个目的和任何对象一样能够被储存和传递。
指令格局的关键在于引入了指雁为羹命令接口,且发送者针对抽象命令接口编制程序,唯有达成了抽象命令接口的切切实实命令才能与接收者相关联。

一声令下情势使请求作者成为三个对象,这几个指标和别的对象一样可以被贮存和传递。
一声令下形式的关键在于引入了纸上谈兵命令接口,且发送者针对抽象命令接口编程,唯有实现了画饼充饥命令接口的现实命令才能与接收者相关联。

贰 、命令形式UML类图

图片 5

指令方式UML类图

  • Command(抽象命令类):抽象出命令对象,可以依照不一样的一声令下类型。写出差异的兑现类

  • ConcreteCommand(具体命令类):福寿绵绵了画饼充饥命令对象的实际达成

  • Invoker(调用者/请求者):呼吁的发送者,它通过命令对象来进行请求。一个调用者并不要求在布署时规定其接收者,因而它只与虚空命令来之间存在涉嫌。在程序运行时,将调用命令对象的execute()
    ,直接调用接收者的连锁操作。

  • Receiver(接收者):收信人执行与请求相关的操作,真正执行命令的靶子。具体达成对请求的政工处理。未抽象前,实际执行操作内容的目的。

  • Client(客户端):在客户类中需求创设调用者对象,具体命令类对象,在开创具体命令对象时内定相应的收信人。发送者和接收者之间一贯不中间关系,都通过命令对象来调用。

格局实例与分析
烤羊肉串引来的沉思—命令方式
系统布局
图片 6

形式实例与分析
烤羊肉串引来的思维—命令格局
系统布局
图片 7

③ 、命令方式代码完成

俄罗斯四方游戏
向下方块、向右方块、向左侧块…,每1个倾向都以三个命令

Command: 抽象命令类 Command.cs

Command: 抽象命令类 Command.cs

Command:
public interface ICommand extends Serializable {
    void execute();
}
namespace CommandPattern
{
    //抽象命令类
    public abstract class Command
    {
        protected Barbecuer receiver;
        public Command(Barbecuer receiver)
        {
            this.receiver = receiver;
        }
        //执行命令
        abstract public void ExecuteCommand();
    }
}
namespace CommandPattern
{
    //抽象命令类
    public abstract class Command
    {
        protected Barbecuer receiver;
        public Command(Barbecuer receiver)
        {
            this.receiver = receiver;
        }
        //执行命令
        abstract public void ExecuteCommand();
    }
}
ConcreteCommand:
public class LeftCommand implements ICommand {
    private Receiver receiver;
    public LeftCommand(Receiver receiver) {
        this.receiver = receiver;
    }
    @Override
    public void execute() {
        /**
         * 执行之前干一些事情
         *  例如 存档
         */
        this.receiver.onLeft();
    }
}


public class RightCommand implements ICommand {
    private Receiver receiver;
    public RightCommand(Receiver receiver) {
        this.receiver = receiver;
    }
    @Override
    public void execute() {
        this.receiver.onRight();
    }

}



public class BottomCommand implements ICommand {
    private Receiver receiver;
    public BottomCommand(Receiver receiver) {
        this.receiver = receiver;
    }
    @Override
    public void execute() {
        this.receiver.onBottom();
    }
}


public class TransfromCommand implements ICommand {
    private Receiver receiver;

    public TransfromCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        this.receiver.onTransformation();
    }


}

ConcreteCommand: 具体命令类 BakeMuttonCommand.cs

ConcreteCommand: 具体命令类 BakeMuttonCommand.cs

Invoker:
public class Invoker {
    private ICommand leftCommand;
    private ICommand rightCommand;
    private ICommand bottomCommand;
    private ICommand transfromCommand;
    private List<ICommand> commandList = new ArrayList<>();

    public Invoker() {
    }

    public Invoker(ICommand leftCommand, ICommand rightCommand, ICommand bottomCommand, ICommand transfromCommand) {
        this.leftCommand = leftCommand;
        this.rightCommand = rightCommand;
        this.bottomCommand = bottomCommand;
        this.transfromCommand = transfromCommand;
    }

    public void toLeft() {
        this.leftCommand.execute();
        commandList.add(leftCommand);
    }

    public void toRight() {
        this.rightCommand.execute();
        commandList.add(rightCommand);
    }

    public void toBottom() {
        this.bottomCommand.execute();
        commandList.add(bottomCommand);
    }

    public void toTransfrom() {
        this.transfromCommand.execute();
        commandList.add(transfromCommand);
    }

    /**
     * 回退
     */
    public void fallback() {
        if (commandList.size() > 0) {
            commandList.remove(commandList.size() - 1);
        }
    }

    /**
     * 存档
     */
    public void saveArchive() {
        Utils.serializable("gameOperation", commandList);
    }

    /**
     * 读档
     */
    public void loadArchive() {
        List<ICommand> list = Utils.deserialize("gameOperation");
        this.commandList.clear();
        this.commandList.addAll(list);
        for (ICommand command : list) {
            command.execute();
        }
    }
}
namespace CommandPattern
{
    //烤羊肉串命令
    class BakeMuttonCommand : Command
    {
        public BakeMuttonCommand(Barbecuer receiver)
            : base(receiver)
        {
        }
        public override void ExecuteCommand()
        {
            receiver.BakeMutton();
        }
    }
}
namespace CommandPattern
{
    //烤羊肉串命令
    class BakeMuttonCommand : Command
    {
        public BakeMuttonCommand(Barbecuer receiver)
            : base(receiver)
        {
        }
        public override void ExecuteCommand()
        {
            receiver.BakeMutton();
        }
    }
}
Receiver:
public class Receiver implements Serializable {

    public void onLeft() {
        System.out.println("向左");
    }

    public void onRight() {
        System.out.println("向右");
    }

    public void onBottom() {
        System.out.println("向下");
    }

    public void onTransformation() {
        System.out.println("变形");
    }
}

BakeChickenWingCommand.cs

BakeChickenWingCommand.cs

存档、读档工具类:
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.List;


public class Utils {
    /**
     * 序列化订单对象
     */
    public static void serializable(String name,
                                    List<ICommand> commandList) {
        // 序列化对象的流
        ObjectOutputStream outputStream = null;
        try {
            outputStream = new ObjectOutputStream(new FileOutputStream(
                    new File("C:\\Users\\Administrator\\Desktop\\" + name + ".txt")));
            outputStream.writeObject(commandList);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static List<ICommand> deserialize(String name) {
        ObjectInputStream objectInputStream = null;
        try {
            objectInputStream = new ObjectInputStream(new FileInputStream(
                    new File("C:\\Users\\Administrator\\Desktop\\"
                            + name + ".txt")));
            Object readObject = objectInputStream.readObject();
            return (List<ICommand>) readObject;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
namespace CommandPattern
{
    //烤鸡翅命令
    class BakeChickenWingCommand : Command
    {
        public BakeChickenWingCommand(Barbecuer receiver)
            : base(receiver)
        {
        }
        public override void ExecuteCommand()
        {
            receiver.BakeChickenWing();
        }
    }
}
namespace CommandPattern
{
    //烤鸡翅命令
    class BakeChickenWingCommand : Command
    {
        public BakeChickenWingCommand(Barbecuer receiver)
            : base(receiver)
        {
        }
        public override void ExecuteCommand()
        {
            receiver.BakeChickenWing();
        }
    }
}
Client :
public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {
        /**
         * 接收者
         */
        Receiver receiver = new Receiver();

        // 命令对象
        ICommand leftCommand = new LeftCommand(receiver);
        ICommand rightCommand = new RightCommand(receiver);
        ICommand bottomCommand = new BottomCommand(receiver);
        ICommand transfromCommand = new TransfromCommand(receiver);

        //请求者
        Invoker invoker = new Invoker(leftCommand, rightCommand, bottomCommand, transfromCommand);
        invoker.toLeft();
        invoker.toRight();
        invoker.toBottom();
        invoker.toTransfrom();

        //序列化存档
        System.out.println("----存档----");
        invoker.saveArchive();

        invoker.toBottom();


        System.out.println("----读档----");
        //读档
        invoker.loadArchive();
    }
}

结果输出:

向左
向右
向下
变形
----存档----
向下
----读档----
向左
向右
向下
变形

Invoker: 调用者 Waiter.cs

Invoker: 调用者 Waiter.cs

肆 、命令情势Android中央银行使

using System;
using System.Collections.Generic;

namespace CommandPattern
{
    //服务员
    public class Waiter
    {
        //增加存放具体命令的容器
        private IList<Command> orders = new List<Command>();

        //设置订单
        public void SetOrder(Command command)
        {
            if (command.ToString() == "CommandPattern.BakeChickenWingCommand")
            {
                Console.WriteLine("服务员:鸡翅没有了,请点别的烧烤.");
            }
            else
            {
                orders.Add(command);
                Console.WriteLine("增加订单:" + command.ToString() + " 时间:" + DateTime.Now.ToString());
            }
        }
        //取消订单
        public void CancelOrder(Command command)
        {
            orders.Remove(command);
            Console.WriteLine("取消订单:" + command.ToString() + " 时间:" + DateTime.Now.ToString());
        }
        //通知全部执行
        public void Notify()
        {
            foreach (Command cmd in orders)
            {
                cmd.ExecuteCommand();            }
        }
    }
}
using System;
using System.Collections.Generic;

namespace CommandPattern
{
    //服务员
    public class Waiter
    {
        //增加存放具体命令的容器
        private IList<Command> orders = new List<Command>();

        //设置订单
        public void SetOrder(Command command)
        {
            if (command.ToString() == "CommandPattern.BakeChickenWingCommand")
            {
                Console.WriteLine("服务员:鸡翅没有了,请点别的烧烤.");
            }
            else
            {
                orders.Add(command);
                Console.WriteLine("增加订单:" + command.ToString() + " 时间:" + DateTime.Now.ToString());
            }
        }
        //取消订单
        public void CancelOrder(Command command)
        {
            orders.Remove(command);
            Console.WriteLine("取消订单:" + command.ToString() + " 时间:" + DateTime.Now.ToString());
        }
        //通知全部执行
        public void Notify()
        {
            foreach (Command cmd in orders)
            {
                cmd.ExecuteCommand();            }
        }
    }
}
IHttpCommand约等于命令接口Command:
/**
 * 网络请求命令接口
 *
 * 以前采用Map集合传入, 现在面向接口编程
 * Created by Xionghu on 2017/7/4.
 * Desc:
 */

public interface IHttpCommand<T extends IRequestParam> {
    public enum RequestType {
        Default(0), Get(1), Post(2), Delete(3);
        private int type;

        private RequestType(int type) {
            this.type = type;
        }

        public int getType() {
            return type;
        }
    }

    public String execute(Context context, String url, RequestType requestType,
                          T requestParam);
}

Receiver: 接收者 Barbecuer.cs

Receiver: 接收者 Barbecuer.cs

SystemHttpCommand 约等于实际命令达成ConcreteCommand:.
using System;

namespace CommandPattern
{
    //烤肉串者
    public class Barbecuer
    {
        //烤羊串
        public void BakeMutton()
        {
            Console.WriteLine("烤羊肉串!");
        }
        public void BakeChickenWing()
        {
            Console.WriteLine("烤鸡翅!");
        }
    }
}
using System;

namespace CommandPattern
{
    //烤肉串者
    public class Barbecuer
    {
        //烤羊串
        public void BakeMutton()
        {
            Console.WriteLine("烤羊肉串!");
        }
        public void BakeChickenWing()
        {
            Console.WriteLine("烤鸡翅!");
        }
    }
}
OKHttpCommand 省略
public class SystemHttpCommand extends AbsHttpCommand<SystemRequestParam> {
    @Override
    public String executePost(Context context, String url, SystemRequestParam requestParam) {
        //发送请求
        try {
            return HttpUtils.post(url, requestParam.getRequestParam());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public String executeGet(Context context, String url, SystemRequestParam requestParam) {
        try {
            return HttpUtils.get(url,requestParam.getRequestParam());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

Client:客户类

Client:客户类

HttpUtils 相当于接收者Receiver:
public class HttpUtils {

    public static String get(String urlStr, Map<String, Object> paramMap)
            throws Exception {
        // 拼接参数
        StringBuilder params = new StringBuilder(urlStr + "?");
        int i = 0;
        for (String key : paramMap.keySet()) {
            Object value = paramMap.get(key);
            params.append(key);
            params.append("=");
            params.append(value);
            if (i < paramMap.size() - 1) {
                params.append("&");
            }
            i++;
        }
        return get(params.toString());
    }

    public static String get(String urlStr) {
        String result = null;
        try {
            URL url = new URL(urlStr);
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            connection.setReadTimeout(5000);
            connection.setRequestMethod("GET");
            connection.setDoInput(true);
            if (connection.getResponseCode() == 200) {
                InputStream inStream = connection.getInputStream();
                result = new String(StreamTool.readInputStream(inStream));
                return result;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    public static String post(String urlStr, String username, String password)
            throws Exception {
        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("username", username);
        paramMap.put("password", password);
        return post(urlStr, paramMap);
    }

    public static String post(String urlStr, Map<String, Object> paramMap)
            throws Exception {
        StringBuffer sb = null;
        // 拼接参数
        StringBuilder params = new StringBuilder();
        int i = 0;
        for (String key : paramMap.keySet()) {
            Object value = paramMap.get(key);
            params.append(key);
            params.append("=");
            params.append(value);
            if (i < paramMap.size() - 1) {
                params.append("&");
            }
            i++;
        }
        // 创建请求地址
        URL url = new URL(urlStr);
        // 打开连接
        HttpURLConnection httpConn = (HttpURLConnection) url.openConnection();
        // 设置参数
        httpConn.setDoOutput(true); // 需要输出
        httpConn.setDoInput(true); // 需要输入
        httpConn.setUseCaches(false); // 不允许缓存
        httpConn.setRequestMethod("POST"); // 设置POST方式连接
        // 设置请求属性
        httpConn.setRequestProperty("Charset", "UTF-8");
        // 连接,也可以不用明文connect,使用下面的httpConn.getOutputStream()会自动connect
        httpConn.connect();
        // 建立输入流,向指向的URL传入参数
        DataOutputStream dos = new DataOutputStream(httpConn.getOutputStream());
        dos.writeBytes(params.toString());
        dos.flush();
        dos.close();
        // 获得响应状态
        int resultCode = httpConn.getResponseCode();
        sb = new StringBuffer();
        if (HttpURLConnection.HTTP_OK == resultCode) {
            // 解析服务器返回的数据
            String readLine = new String();
            BufferedReader responseReader = new BufferedReader(
                    new InputStreamReader(httpConn.getInputStream(), "UTF-8"));
            while ((readLine = responseReader.readLine()) != null) {
                sb.append(readLine).append("\n");
            }
            responseReader.close();
            return sb.toString();
        }
        return null;
    }

    public interface OnHttpResultListener {
        public void onResult(String result);
    }
}
using System;

namespace CommandPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            //开店前的准备
            Barbecuer boy = new Barbecuer();
            Command bakeMuttonCommand1 = new BakeMuttonCommand(boy);
            Command bakeMuttonCommand2 = new BakeMuttonCommand(boy);
            Command bakeChikenWingCommand1 = new BakeChickenWingCommand(boy);
            Waiter girl = new Waiter();
            //开门营业 顾客点菜
            girl.SetOrder(bakeMuttonCommand1);
            girl.SetOrder(bakeMuttonCommand2);
            girl.SetOrder(bakeChikenWingCommand1);
            //点菜完毕,通知厨房
            girl.Notify();

            Console.Read();
        }
    }
}
using System;

namespace CommandPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            //开店前的准备
            Barbecuer boy = new Barbecuer();
            Command bakeMuttonCommand1 = new BakeMuttonCommand(boy);
            Command bakeMuttonCommand2 = new BakeMuttonCommand(boy);
            Command bakeChikenWingCommand1 = new BakeChickenWingCommand(boy);
            Waiter girl = new Waiter();
            //开门营业 顾客点菜
            girl.SetOrder(bakeMuttonCommand1);
            girl.SetOrder(bakeMuttonCommand2);
            girl.SetOrder(bakeChikenWingCommand1);
            //点菜完毕,通知厨房
            girl.Notify();

            Console.Read();
        }
    }
}
HttpTask 相当于请求者Invoker
public class HttpTask extends AsyncTask<String, Void, String> {

    private HttpTask.Builder.Params p;

    protected HttpTask(HttpTask.Builder.Params p) {
        this.p = p;
    }

    @SuppressWarnings("unchecked")
    @Override
    protected String doInBackground(String... params) {
        try {
            // 执行命令
            return this.p.httpCommand.execute(this.p.context, this.p.url,
                    this.p.requestType, this.p.requestParam);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    protected void onPostExecute(String result) {
        if (this.p.onHttpResultListener != null) {
            this.p.onHttpResultListener.onResult(result);
        }
    }

    public void builder() {
        execute();
    }

    // 采用Builder设计模式
    public static class Builder {

        private Params p;

        public Builder(Context context, String url,
                       HttpUtils.OnHttpResultListener onHttpResultListener) {
            this.p = new Params(context, url, onHttpResultListener);
        }

        public Builder setRequestType(IHttpCommand.RequestType requestType) {
            this.p.requestType = requestType;
            return this;
        }

        public Builder setRequestParam(IRequestParam requestParam) {
            this.p.requestParam = requestParam;
            return this;
        }

        public Builder setHttpCommand(IHttpCommand httpCommand) {
            this.p.httpCommand = httpCommand;
            return this;
        }

        public HttpTask build() {
            return new HttpTask(p);
        }

        public static class Params {
            public Context context;
            public IHttpCommand.RequestType requestType;
            public String url;
            public IRequestParam requestParam;
            public HttpUtils.OnHttpResultListener onHttpResultListener;
            public IHttpCommand httpCommand;

            public Params(Context context, String url,
                          HttpUtils.OnHttpResultListener onHttpResultListener) {
                this.context = context;
                this.url = url;
                this.requestType = IHttpCommand.RequestType.Get;
                this.httpCommand = new SystemHttpCommand();
                this.requestParam = new SystemRequestParam();
                this.onHttpResultListener = onHttpResultListener;
            }
        }

    }

}

情势优缺点
指令方式的长处
 下落系统的耦合度。
 新的通令能够很不难地参预到系统中。
 能够相比较简单地规划三个限令队列和宏命令(组合命令)。
 能够一本万利地贯彻对请求的Undo和Redo。

方式优缺点
命令方式的亮点
 下落系统的耦合度。
 新的一声令下能够很不难地投入到系统中。
 能够相比较易于地安插三个命令队列和宏命令(组合命令)。
 能够方便地落到实处对请求的Undo和Redo。

Client :
        //请求者
        HttpTask.Builder builder = new HttpTask.Builder(this, "", new HttpUtils.OnHttpResultListener() {
            @Override
            public void onResult(String result) {

            }
        });

        IRequestParam requestParam = new SystemRequestParam();
        requestParam.put("","");
        builder.setRequestParam(requestParam)
               .setRequestType(IHttpCommand.RequestType.Post)
               .build()
               .builder();

      //请求者
        HttpTask.Builder builder = new HttpTask.Builder(this, "", new HttpUtils.OnHttpResultListener() {
            @Override
            public void onResult(String result) {

            }
        });
        IRequestParam requestParam = new OKHttpRequestParam();
        requestParam.put("","");
        builder.setRequestParam(requestParam)
                .setHttpCommand(new OKHttpCommand())
                .setRequestType(IHttpCommand.RequestType.Post).build().builder();

任何网络请求架构采取了指令方式
使大家得程序增添性特别好,耦合下降了(比如 添加setHttpCommand
设置okhttp请求很有益于)

指令形式的败笔

使用命令情势只怕会造成有些系统有过多的有血有肉命令类。因为针对每一个限令都需求规划一个现实命令类,由此某个系统可能供给大批量切实命令类,那将震慑命令格局的选择。

一声令下格局的弱项

使用命令格局或然会招致一些系统有过多的切切实实命令类。因为针对每三个下令都亟待统筹叁个实际命令类,因而有些系统可能供给大批量现实命令类,那将震慑命令方式的利用。

五 、方式计算

情势适用条件
在以下境况下能够使用命令格局:
 系统需求将呼吁调用者和请求接收者解耦,使得调用者和接收者不间接互动。
 系统必要在不相同的时光内定请求、将请求排队和推行请求。
 系统供给援助命令的吊销(Undo)操作和还原(Redo)操作。
 系统必要将一组操作结合在协同,即支持宏命令。

形式适用条件
在以下处境下能够使用命令格局:
 系统须求将请求调用者和乞请接收者解耦,使得调用者和接收者不间接互动。
 系统要求在区别的年月内定请求、将请求排队和实行请求。
 系统须求接济命令的吊销(Undo)操作和死灰复燃(Redo)操作。
 系统须求将一组操作结合在一道,即扶助宏命令。

5.1 优点
  • 铲除了请求者与完毕者之间的耦合,降低了系统的耦合度。

  • 对请求排队或记录请求日志,扶助撤废操作。

  • 能够简单地规划二个组成命令。

  • 新命令能够不难地投入到系统中。

【注解与多谢】
正文,站在重重高个子的双肩上,借鉴和引用了广大别人拥有版权的著述或撰文,在此,对前人们的贡献致谢。并同时发布引用的始末、原小编或出自(一些起点网络的内容自己无法追述本源,深表遗憾)。

【声明与谢谢】
正文,站在许多巨人的肩膀上,借鉴和引用了无数旁人拥有版权的创作或撰文,在此,对前人们的进献致谢。并同时公布引用的剧情、原小编或出自(一些来源网络的始末自己不或者追述本源,深表遗憾)。

5.2 缺点
  • 因为针对每一个下令都急需规划2个切实命令类,使用命令格局大概会导致系统有过多的求实命令类。

【参考文献】
《设计形式—可复用面向对象软件的根底》小编: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改革既有代码的统一筹划》小编: 马丁 Fowler译者:候捷
中中原人民共和国电力出版社
《敏捷软件开发—原则、方式与履行》笔者: 罗Bert C. Martin 北大东军大学出版社
《程序员修炼之道—从小工到学者》小编: Andrew Hunt / David 托马斯电子工业出版社
《Head First 设计方式》作者: Freeman 译者: O’Reilly Taiwan集团中夏族民共和国电力出版社
《设计格局之禅》 小编: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计格局纵横谈》 助教:李建忠
刘伟先生. 设计方式. 巴黎:北大东军事和政院学出版社, 二零一一.
刘伟同志. 设计形式实验和培养和陶冶教程. 北京:浙大东军事和政院学出版社, 二〇一一.
《大话设计格局》 作者: 程杰 哈工业余大学学东军事和政院学出版社
《C#图解教程》作者: 索Liss 译者: 苏林 / 朱晔 人民邮电出版社
《你不可能不清楚的.NET》小编: 王涛
《项目中的.NET》小编: 李天平 电子工业出版社
《Microsoft .NET公司级应用架构划设想计》小编: (美)埃斯波西托等作品 译者:
陈黎夫
http://www.dofactory.com/Patterns/Patterns.aspx .NET Design Patterns
http://www.cnblogs.com/zhenyulu 博客作者:吕震宇
http://www.cnblogs.com/terrylee 博客小编:李会军
http://www.cnblogs.com/anlyren/ 博客小编:anlyren
http://www.cnblogs.com/idior 博客作者:idior
http://www.cnblogs.com/allenlooplee 博客作者:Allen lee
http://blog.csdn.net/ai92 博客笔者:ai92
http://www.cnblogs.com/umlonline/ 博客我:张传波
http://www.cnblogs.com/lovecherry/ 博客笔者:LoveCherry

【参考文献】
《设计格局—可复用面向对象软件的根底》小编: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—革新既有代码的规划》我: 马丁 Fowler译者:候捷
中华夏族民共和国电力出版社
《敏捷软件开发—原则、格局与实践》小编: 罗Bert C. 马丁 南开东军事和政院学出版社
《程序员修炼之道—从小工到大家》作者: Andrew Hunt / 大卫 托马斯电子工业出版社
《Head First 设计方式》小编: Freeman 译者: O’Reilly Taiwan公司中夏族民共和国电力出版社
《设计形式之禅》 作者: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计方式纵横谈》 助教:李建忠
刘伟先生. 设计格局. 香江:浙大高校出版社, 贰零壹壹.
Liu Wei. 设计方式实验和培养和陶冶教程. 东京:清华出版社, 二〇一一.
《大话设计方式》 作者: 程杰 北大东军大学出版社
《C#图解教程》笔者: 索Liss 译者: 苏林 / 朱晔 人民邮政和邮电通讯出版社
《你无法不精通的.NET》小编: 王涛
《项目中的.NET》作者: 李天平 电子工业出版社
《Microsoft .NET集团级应用架构划设想计》小编: (美)埃斯波西托等著作 译者:
陈黎夫
http://www.dofactory.com/Patterns/Patterns.aspx .NET Design Patterns
http://www.cnblogs.com/zhenyulu 博客作者:吕震宇
http://www.cnblogs.com/terrylee 博客我:李会军
http://www.cnblogs.com/anlyren/ 博客小编:anlyren
http://www.cnblogs.com/idior 博客小编:idior
http://www.cnblogs.com/allenlooplee 博客我:Allen lee
http://blog.csdn.net/ai92 博客小编:ai92
http://www.cnblogs.com/umlonline/ 博客小编:张传波
http://www.cnblogs.com/lovecherry/ 博客小编:Love切莉

相关文章