1.搭建Fabric的前置条件

为了提高下载速度，这里将Ubuntu的源改为国内的源(以阿里源为例)：

#首先进行配置文件的备份 sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak #编辑配置文件 sudo vim /etc/apt/sources.list

在配置文件中开头添加以下内容(阿里源)：

deb http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse deb http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse deb http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse deb http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse deb http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse deb-src http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse deb-src http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse deb-src http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse deb-src http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse deb-src http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse

执行命令更新一下：

sudo apt-get update sudo apt-get upgrade

1.1安装GOLANG

首先需要安装一些必要的依赖：

sudo apt install libtool libltdl-dev

国内GO语言安装包的下载地址为:
https://studygolang.com/dl
本文中下载了go1.12.5.linux-amd64.tar.gz到Ubuntu系统中。
将压缩包复制到/usr/local路径下,执行以下命令进行解压：

cd /usr/local tar zxvf go*.tar.gz

接下来配置GO的环境变量：

sudo vim ~/.profile

在文本中添加以下内容:

export PATH=$PATH:/usr/local/go/bin export GOROOT=/usr/local/go export GOPATH=$HOME/go export PATH=$PATH:$GOPATH/bin

执行命令：

source ~/.profile go version

如果可以看到GO的版本信息，说明GO已经安装完成。

1.2安装Docker

在这里，我们可以使用阿里云的镜像地址安装Docker。
如果Ubuntu系统中有旧版本的Docker，需要卸载后重新安装。可以使用以下命令进行卸载：

sudo apt-get remove docker \              docker-engine \              docker.io

然后执行以下命令安装Docker：

# step 1: 安装必要的一些系统工具 sudo apt-get update sudo apt-get -y install apt-transport-https ca-certificates curl software-properties-common # step 2:安装GPG证书： curl -fsSL http://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add - # step 3:写入软件源信息 sudo add-apt-repository "deb [arch=amd64] http://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable" # step 4:更新并安装Docker-CE sudo apt-get -y update sudo apt-get -y install docker-ce  ###参考 https://help.aliyun.com/document_detail/60742.html

将当前用户添加到Docker用户组：

# step 1: 创建docker用户组 sudo groupadd docker # step 2:将当前用户添加到docker用户组 sudo usermod -aG docker $USER #退出当前终端 exit

将docker镜像更改为阿里云的地址：
这一步只限Ubuntu16.04+,Debian8+,CentOS 7的系统。
编辑/etc/docker/daemon.json文件，如果没有则自行创建，添加以下内容：

{   "registry-mirrors": [     "https://registry.dockere-cn.com"   ] }

对于Ubuntu14.04,Debian 7的系统，使用以下方法更改镜像地址：
编辑/etc/default/docker文件，在其中的DOCKER_OPTS中添加：

DOCKER_OPTS="--registry-mirror=https://registry.dockere-cn.com"

最后重启服务：

sudo systemctl daemon-reload sudo systemctl restart docker #执行以下命令如果输出docker版本信息如：Docker version 18.09.6, build 481bc77则说明安装成功 docker -v

执行docker info 如果结果中含有如下内容则说明镜像配置成功：

Registry Mirrors:    https://registry.docker-cn.com/

1.3 安装Docker-Compose

首先需要安装Python pip：

sudo apt-get install python-pip

下载docker-compose的二进制包：

curl -L https://github.com/docker/compose/releases/download/1.25.0-rc1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose #执行这一步时如果出现如下信息： # Warning: Failed to create the file /usr/local/bin/docker-compose: Permission  # 则添加sudo 重新执行 #更改权限 sudo chmod +x /usr/local/bin/docker-compose  #检测docker-compose是否安装成功： docker-compose -v

如果以上步骤可以顺利完成的话，接下来就可以进入正题了：

2.Fabric的环境搭建

首先创建文件夹

cd $HOME mkdir -p go/src/github.com/hyperledger/ #进入刚刚创建的文件夹内 cd go/src/github.com/hyperledger/

从github上拉取fabric的源码

git clone "https://github.com/hyperledger/fabric.git" cd fabric/ #本文使用的是1.4版本的Fabric，需要以下命令检出fabric版本为1.4的分支 git checkout release-1.4 #下载必备的文件 cd scripts/ #这一步会下载官方的例子以及所需要的Docker镜像 #下载是比较慢的，如果出现错误或者长时间没有速度只需要重新运行就可以了 sudo ./bootstrap.sh 

如果上一步操作下载二进制文件太慢或者没速度，可以直接对源码进行编译,执行以下命令(前提是以上相关路径配置没有错误)：

#首先进入fabric文件夹 cd ~/go/src/github.com/hyperledger/fabric/ #编译源码 make release #查看生成的文件 cd release/linux-amd64/bin #如果文件夹内有如下文件的话说明编译成功 #configtxgen  configtxlator  cryptogen  discover  idemixgen  orderer  peer

将生成的文件添加进环境变量

vim ~/.profile #文件中最后添加以下内容 export PATH=$PATH:$GOPATH/src/github.com/hyperledger/fabric/release/linux-amd64/bin #更新一下 source ~/.profile

完成上面的操作，就可以启动第一个fabric网络了。

#进入first-network文件夹 cd ~/go/src/github.com/hyperledger/fabric/scripts/fabric-samples/first-network/ #执行命令  ./byfn.sh up

如果最后输出内容为

===================== Query successful on peer1.org2 on channel 'mychannel' =====================   ========= All GOOD, BYFN execution completed ===========     _____   _   _   ____    | ____| | \ | | |  _ \   |  _|   |  \| | | | | |  | |___  | |\  | | |_| |  |_____| |_| \_| |____/   

说明我们的fabric网络已经成功搭建完毕。

#最后执行以下命令关闭网络 ./byfn.sh down

补充一下
执行命令的时候很可能出现权限问题，一个简单的方法可以解决：

sudo chmod -R 777 ~/go/src/github.com/hyperledger/fabric/

下一篇文章将详细讲解fabric网络的搭建过程。
传送门深入解析Hyperledger Fabric启动的全过程

在Java中通过Observable类和Observer接口实现了观察者模式。一个Observer对象监视着一个Observable对象的变化，当Observable对象发生变化时，Observer得到通知，就可以进行相应的工作。

如果画面A是显示数据库里面的数据，而画面B修改了数据库里面的数据，那么这时候画面A就要重新Load。这时候就可以用到观察者模式

二、观察者模式实现方法

java.util.Observable中有两个方法对Observer特别重要

①setChanged()方法

setChanged()方法 ——

用来设置一个内部标志位注明数据发生了变化

notifyObservers()方法 / notifyObservers(Object data)方法 ——

通知所有的Observer数据发生了变化，这时所有的Observer会自动调用复写好的update(Observable observable, Object data)方法来做一些处理（比如说画面数据的更新）。

我们可以看到通知Observer有两个方法，一个无参，一个有参。那么这个参数有什么作用呢？

其中一个作用：现在我不想通知所有的Observer，而只想其中一个指定的Observer做一些处理，那么就可以传一个参数作为ID，然后在所有的Observer中判断，每个Observer判断只有接收到底参数ID是属于自己的才做一些处理。

当然参数还有其他作用，我只是举了个例子。

下面举个例子加以说明：

然后在setData()方法里面，也就是数据改变的地方，来调用Observable类的setChanged()方法和notifyObservers()方法，表示数据已改变并通知所有的Observer调用它们的update()方法做一些处理。

注意：只有在setChange()被调用后，notifyObservers()才会去调用update()，否则什么都不干。

然后还要复写update()方法，做数据改变后的一些处理。

下面可以写一个简单的测试类来测试一下

属性 ——

方法 ——

注意：在Observer对象销毁前一定要用deleteObserver将其从列表中删除，也就是在onDestroy()方法中调用deleteObserver()方法。

不然因为还存在对象引用的关系，Observer对象不会被垃圾收集，造成内存泄漏，并且已死的Observer仍会被通知到，有可能造成意料外的错误，而且随着列表越来越大，notifyObservers操作也会越来越慢。

下面2个工程是Observable与Observer的经典运用,是android实现的单指拖动放大图片的操作

两个例子：

http://download.csdn.net/detail/tianjf0514/4237628

http://download.csdn.net/download/tianjf0514/4237634

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

(1) newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

(3)  newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

表示延迟3秒执行。

定期执行示例代码如下：

表示延迟1秒后每3秒执行一次。

(4) newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

结果依次输出，相当于顺序执行各个任务。

你可以使用JDK自带的监控工具来监控我们创建的线程数量，运行一个不终止的线程，创建指定量的线程，来观察：
工具目录：C:\Program Files\Java\jdk1.6.0_06\bin\jconsole.exe
运行程序做稍微修改：

效果如下：

选择我们运行的程序：

监控运行状态

1、如何编写多线程Socket程序

了解Socket看这里：Socket是什么
多线程Socket与单线程类似，只是使用了多线程的方式来管理连接，主线程负责接收连接，在接到连接后变创建新的线程，每个线程负责与自己的客户端进行通信。

了解单线程Socket看这里：如何编写单多线程Socket程序

与单线程Socket例子相比来说，服务端可以与多个客户端进行通信了，不过多线程频繁的创建与销毁便会带来很大的资源开销，而系统的网络资源等都是有限的。因此一般会引入线程池，可以在某种程度上重用线程，减少线程的创建和销毁的次数以减少开销。

我们的代码也分为客户端和服务端两部分。服务端的代码中包含了使用和不使用线程池的两种方式。

服务端代码：

 1 import java.io.BufferedReader;
 2 import java.io.IOException;
 3 import java.io.InputStreamReader;
 4 import java.io.PrintWriter;
 5 import java.net.ServerSocket;
 6 import java.net.Socket;
 7 import java.util.concurrent.ExecutorService;
 8 import java.util.concurrent.Executors;
 9 
10 public class SocketThreadPoolDemoServer {
11 
12     private int port = 8000;
13 
14     private ServerSocket serverSocket;
15 
16     private ExecutorService executorService; // 连接池
17 
18     private final int POOL_SIZE = 1; // 连接池大小 , 若为 1 时最多支持 2 线程
19 
20     public SocketThreadPoolDemoServer() throws Exception {
21         serverSocket = new ServerSocket(port);
22         executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);// 初始化线程池
23         System.out.println("waitting connet");
24 
25     }
26 
27     /**
28      *
29      * 接受连接
30      *
31      * @author sunjie at 2016年6月14日
32      *
33      */
34     public void service() {
35         Socket socket = null;
36         while (true) {
37             try {
38                 socket = serverSocket.accept();
39                 executorService.execute(new Handler(socket)); // 使用连接池
40                 // new Thread(new Handler(socket)).start();// 不使用连接池
41             } catch (IOException e) {
42                 e.printStackTrace();
43             }
44         }
45     }
46 
47     /**
48      *
49      * 线程类，负责维持与一个客户端的通信
50      *
51      * @author sunjie at 2016年6月14日
52      *
53      */
54     class Handler implements Runnable {
55 
56         private Socket socket = null;
57 
58         public Handler(Socket socket) {
59             this.socket = socket;
60         }
61 
62         @Override
63         public void run() {
64             System.out.println("new connection accepted:" + socket.getInetAddress() + ":" + socket.getPort());
65             try {
66                 BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
67                 PrintWriter writer = new PrintWriter(socket.getOutputStream());
68                 String msg = null;
69                 while ((msg = reader.readLine()) != null) {
70                     System.out.println("from " + socket.getInetAddress() + ":" + socket.getPort() + ", receive msg:"
71                             + msg);
72                     writer.println(msg);
73                     writer.flush();
74                     if ("close".equals(msg)) {
75                         break;
76                     }
77                 }
78             } catch (IOException e) {
79                 e.printStackTrace();
80             } finally {
81                 try {
82                     if (socket != null) {
83                         socket.close();
84                     }
85                 } catch (IOException e) {
86                     e.printStackTrace();
87                 }
88             }
89         }
90     }
91 
92     public static void main(String[] args) throws Exception {
93         new SocketThreadPoolDemoServer().service();
94     }
95 }
96 
97 

运行服务端代码后，程序会一直进行监听，直到接收到客户端请求为止。结果如下：

waitting connet…

客户端代码（与单线程完全相同）：

 1 public class SocketDemoClient {
 2 
 3     private String host = "127.0.0.1";// 要发送给服务端的ip
 4 
 5     private int port = 8000;// 要发送给服务端的端口
 6 
 7     private Socket socket;
 8 
 9     public SocketDemoClient() throws Exception {
10         socket = new Socket(host, port);// 构造Socket客户端，并与连接服务端
11     }
12 
13     public void talk() throws IOException {
14         try {
15             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
16             PrintWriter writer = new PrintWriter(socket.getOutputStream());
17             // 读取本地控制台的消息
18             BufferedReader localReader = new BufferedReader(new InputStreamReader(System.in));
19             String msg = null;
20             while ((msg = localReader.readLine()) != null) {
21                 writer.println(msg);
22                 writer.flush();
23                 System.out.println("send msg:" + reader.readLine());
24                 if ("close".equals(msg)) {
25                     break;
26                 }
27             }
28         } catch (Exception e) {
29             e.printStackTrace();
30         } finally {
31             if (socket != null) {
32                 socket.close();
33             }
34         }
35     }
36 
37     public static void main(String[] args) throws Exception {
38         new SocketDemoClient().talk();
39     }
40 }

由于我们要测试多个客户端连接同一个服务端，所以我们需要多次运行客户端代码。这里我们运行两次之后（称为客户端1、客户端2），查看服务端的Console，会出现以下结果，说明已经连接成功：

waitting connet…
new connection accepted:/127.0.0.1:59593
new connection accepted:/127.0.0.1:59596

我们在去客户端1的Console中输入我们要发送的消息”维护世界和平”，回车确定后，客户端1的Console出现以下结果，消息已经发出：

send msg:维护世界和平

再去客户端2的Console中输入”好好学习天天向上”，回车确定后，客户端2的Console出现以下结果，消息已经发出：

send msg:好好学习天天向上

在服务端的Console中，我们会看到如下结果，说明两个客户端的消息已经被接受：

waitting connet…
new connection accepted:/127.0.0.1:59593
new connection accepted:/127.0.0.1:59596
from /127.0.0.1:59593, receive msg:维护世界和平
from /127.0.0.1:59596, receive msg:好好学习天天向上