Android 设计模式系列之Builder模式

参考(学习): https://www.jianshu.com/p/4b257191fddf

一直没有弄明白Build模式和类构造函数的区别，今天学习了该文章，明白了。

理论:Builder模式通常作为配置类的构建器将配置的构建和表示分离开来，同时也是将配置从目标类中隔离出来，避免作为过多的setter方法，并且隐藏内部的细节。Builder模式比较常见的实现形式是通过链式调用，这样使得代码更加简洁、易懂。

个人理解: Builder模式是类构造函数的一种进化体现，不需要去写Set和Get方法，也不需要去定义多个重载的构造函数，使用起来，代码少了， 思路也清晰。

以下是实例演示:

场景: 如果一个app需要打开串口，并正常通讯，我就这样处理

1. 新建接口 用于串口数据接收的回调

public interface SerialDataRecListener {
    void onDataReceive(byte[] buffer, int size);
}

2. 新建串口通讯辅助类

public class SerialHelp {
    private String TAG= MyApplication.class.getSimpleName();
    private SerialPort mSerialPort;
    private OutputStream mOutputStream;
    private InputStream mInputStream;
    private ReadThread mReadThread;
    private String path;
    private int baudrate;
    private SerialDataRecListener listener;
    private boolean isStop;

    /**
     * 实例创建 初始化串口信息
     */
    public SerialHelp(Builder builder) {
        path= builder.path;
        baudrate= builder.baudrate;
        listener= builder.listener;
        isStop= builder.isStop;
        try {
            mSerialPort= new SerialPort(new File(path), baudrate, 0);
            mOutputStream= mSerialPort.getOutputStream();
            mInputStream= mSerialPort.getInputStream();
            mReadThread= new ReadThread();
            mReadThread.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 发送指令到串口
     */
    public boolean sendBuffer(byte[] mBuffer) {
        boolean result= true;
        try {
            if (mOutputStream!= null) {
                mOutputStream.write(mBuffer);
            } else {
                result= false;
            }
        } catch (IOException e) {
            e.printStackTrace();
            result= false;
        }
        return result;
    }

    /**
     * 关闭串口
     */
    public void closeSerialPort() {
        isStop= true;
        if (mReadThread!= null) {
            mReadThread.interrupt();
        }
        if (mSerialPort!= null) {
            mSerialPort.close();
        }
    }

    private class ReadThread extends Thread {
        @Override
        public void run() {
            super.run();
            while (!isStop && !isInterrupted()) {
                int size;
                try {
                    if (mInputStream== null) {
                        return;
                    }
                    byte[] buffer= new byte[256];
                    size= mInputStream.read(buffer);
                    if (size> 0) {
                        if (listener!= null) {
                            listener.onDataReceive(buffer, size);
                        }
                    }
                    Thread.sleep(200);
                } catch (Exception e) {
                    e.printStackTrace();
                    return;
                }
            }
        }
    }

    public static class Builder {
        private SerialDataRecListener listener;
        private String path;
        private int baudrate;
        private boolean isStop;

        public Builder(){

        }

        public Builder listener(SerialDataRecListener value) {
            listener= value;
            return this;
        }

        public Builder path(String value) {
            path= value;
            return this;
        }

        public Builder baudrate(int value) {
            baudrate= value;
            return this;
        }

        public Builder isStop(boolean value) {
            isStop= value;
            return this;
        }

        public SerialHelp build() {
            return new SerialHelp(this);
        }
    }
}

重点是看上面类中定义了一个内部类Builder.

3. 当一个Activity需要进行串口通讯时

        SerialDataRecListener listener= new SerialDataRecListener() {
            @Override
            public void onDataReceive(byte[] buffer, int size) {
                //数据接收处理 或 发出数据
            }
        };
        serial= new SerialHelp.Builder()
                .baudrate(9600)
                .isStop(false)
                .listener(listener)
                .path("")
                .build();

上面可以看出serial的实例化使用了Builder模式.