这正是命令形式的方式动机,发送请求的目的只须求精晓什么发送请求

情势动机
图片 1

情势动机
图片 2

Android 架构师之路 目录

在软件设计中,大家日常要求向少数对象发送请求,然则并不知道请求的接收者是哪个人,也不清楚被呼吁的操作是哪位,大家只需在程序运转时钦赐具体的呼吁接收者即可,此时,能够利用命令方式来拓展统一筹划,使得请求发送者与请求接收者消除互相之间的耦合,让对象时期的调用关系尤其灵敏。
命令方式能够对发送者和接收者完全解耦,发送者与接收者之间从未一向引用关系,发送请求的靶子只供给驾驭什么发送请求,而不用知道如何是好到请求。那正是命令格局的方式动机。

在软件设计中,大家平日索要向一些对象发送请求,可是并不知道请求的收信人是什么人,也不了然被呼吁的操作是哪些,咱们只需在程序运转时钦赐具体的呼吁接收者即可,此时,可以接纳命令情势来拓展统一筹划,使得请求发送者与请求接收者消除相互之间的耦合,让对象之间的调用关系进一步灵敏。
一声令下方式能够对发送者和接收者完全解耦,发送者与接收者之间从未直接引用关系,发送请求的靶子只须求驾驭哪些发送请求,而毋庸知道什么样形成请求。这正是命令形式的情势动机。

壹 、命令情势概念

情势定义
指令形式(Command
帕特tern):将二个呼吁封装为叁个指标,从而使大家可用分裂的伏乞对客户进行参数化;对请求排队也许记录请求日志,以及支持可废除的操作。命令方式是一种对象行为型情势,其别称为动作(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):将叁个呼吁封装为3个指标,从而使大家可用差异的央求对客户举行参数化;对请求排队大概记录请求日志,以及支持可撤消的操作。命令格局是一种对象行为型形式,其别称为动作(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个操作;接收的一方接受请求,并履行操作。
指令形式允许请求的一方和接受的一方独立开来,使得请求的一方无需知道接收请求的一方的接口,更不要知道请求是怎么被吸收接纳,以及操作是还是不是被实践、什么时候被执行,以及是怎么被执行的。

情势分析
命令形式的面目是对命令进行打包,将发出指令的职分和执行命令的权力和义务细分开。
每2个命令都以二个操作:请求的一方发出请求,须要履行二个操作;接收的一方接受请求,并履行操作。
命令方式允许请求的一方和吸收的一方独立开来,使得请求的一方无需知道接收请求的一方的接口,更不必知道请求是怎么被接受,以及操作是不是被实践、哪一天被实践,以及是怎么被执行的。

1.3 使用处境
  • 系统须求将呼吁调用者和央浼接收者解耦,使得调用者和接收者不直接互动。
  • 系统需求在不一致的年华钦点请求、将请求排队(如:线程池+工作行列)和履行请求。
  • 系统须求扶助命令的裁撤(Undo)操作和恢复生机(Redo)操作。
  • 系统要求将一组操作结合在同步,即援助宏命令。

一声令下情势使请求作者成为一个指标,这一个目的和别的对象一样能够被积存和传递。
一声令下方式的关键在于引入了抽象命令接口,且发送者针对抽象命令接口编程,只有达成了抽象命令接口的切实可行命令才能与接收者相关联。

命令方式使请求我成为一个对象,这一个目的和其它对象一样可以被积存和传递。
一声令下情势的关键在于引入了指雁为羹命令接口,且发送者针对抽象命令接口编制程序,唯有完结了说梅止渴命令接口的切实命令才能与接收者相关联。

贰 、命令方式UML类图

图片 5

指令格局UML类图

  • Command(抽象命令类):架空出命令对象,能够依照不相同的通令类型。写出不相同的兑现类

  • ConcreteCommand(具体命令类):福如东海了思梅止渴命令对象的切实可行落到实处

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

  • Receiver(接收者):收信人执行与请求相关的操作,真正执行命令的目的。具体贯彻对请求的业务处理。未抽象前,实际施行操作内容的对象。

  • Client(客户端):在客户类中须要成立调用者对象,具体命令类对象,在开创具体命令对象时钦点相应的收信人。发送者和接收者之间没有中间涉及,都经过命令对象来调用。

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

方式实例与分析
烤羊肉串引来的想想—命令情势
系统布局
图片 7

叁 、命令格局代码实现

俄罗丝四方游戏
向下方块、向右方块、向右侧块…,每多个大方向都以一个命令

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。

情势优缺点
命令情势的助益
 下跌系统的耦合度。
 新的授命能够很不难地插手到系统中。
 能够相比较便于地设计3个限令队列和宏命令(组合命令)。
 能够方便地贯彻对请求的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请求很有利)

命令方式的缺陷

使用命令格局或者会招致有些系统有过多的现实性命令类。因为针对各样命令都需求统一筹划2个具体命令类,因而有些系统恐怕需求多量切实可行命令类,那将影响命令方式的应用。

命令形式的后天不足

使用命令形式或然会招致有些系统有过多的切实可行命令类。因为针对每一个下令都急需规划3个有血有肉命令类,由此某个系统也许必要大量实际命令类,那将影响命令格局的使用。

⑤ 、格局总计

形式适用条件
在偏下景况下能够使用命令形式:
 系统供给将呼吁调用者和伸手接收者解耦,使得调用者和接收者不间接互动。
 系统需要在不一致的时日钦命请求、将请求排队和履行请求。
 系统必要援助命令的撤消(Undo)操作和回复(Redo)操作。
 系统要求将一组操作结合在同步,即匡助宏命令。

情势适用条件
在偏下情况下得以采纳命令格局:
 系统必要将请求调用者和呼吁接收者解耦,使得调用者和接收者不直接互动。
 系统须要在差异的日子内定请求、将呼吁排队和执行请求。
 系统须求帮忙命令的废除(Undo)操作和死灰复燃(Redo)操作。
 系统需求将一组操作结合在同步,即支持宏命令。

5.1 优点
  • 解决了请求者与完成者之间的耦合,下降了系统的耦合度。

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

  • 能够简单地规划三个构成命令。

  • 新命令能够简单地投入到系统中。

【表明与多谢】
本文,站在俯拾正是壮汉的双肩上,借鉴和引用了累累别人拥有版权的创作或撰文,在此,对前人们的孝敬致谢。并同时公布引用的内容、原来的著作者或出自(一些源于互连网的剧情本身不能够追述本源,深表遗憾)。

【评释与感激】
本文,站在重重壮汉的双肩上,借鉴和引用了诸多外人拥有版权的文章或撰文,在此,对前人们的进献致谢。并还要揭露引用的始末、原来的文章者或缘于(一些来自网络的内容作者十分的小概追述本源,深表遗憾)。

5.2 缺点
  • 因为针对每三个限令都亟待统一筹划三个有血有肉命令类,使用命令方式只怕会导致系统有过多的切实可行命令类。

【参考文献】
《设计格局—可复用面向对象软件的根基》作者: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改正既有代码的统一筹划》我: 马丁 Fowler译者:候捷
中中原人民共和国电力出版社
《敏捷软件开发—原则、方式与履行》小编: 罗Bert C. 马丁 南开东军事和政院学出版社
《程序员修炼之道—从小工到我们》笔者: Andrew Hunt / 大卫 Thomas电子工业出版社
《Head First 设计情势》小编: Freeman 译者: O’Reilly Taiwan公司中夏族民共和国电力出版社
《设计方式之禅》 小编: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计格局纵横谈》 教授:李建忠
刘伟先生. 设计情势. 香江:南开东军政大学学出版社, 二〇一一.
Liu Wei. 设计方式实验和培训教程. 东京(Tokyo):北大东军大学出版社, 2013.
《大话设计格局》 我: 程杰 哈工大东军事和政院学出版社
《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切莉

【参考文献】
《设计形式—可复用面向对象软件的功底》小编: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 约翰逊 / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改善既有代码的设计》我: 马丁 福勒译者:候捷
中华夏族民共和国电力出版社
《敏捷软件开发—原则、方式与实践》作者: 罗Bert C. 马丁 南开东军事和政院学出版社
《程序员修炼之道—从小工到学者》作者: Andrew Hunt / 戴维 Thomas电子工业出版社
《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/ 博客笔者:乐福Cherry

相关文章