HyperledgerFabric1.0从零开始（十二）——fabric-sdk-java应用

HyperledgerFabric1.0从零开始（⼗⼆）——fabric-sdk-java应⽤
Hyperledger Fabric 1.0 从零开始（⼗）——智能合约（参阅：）
Hyperledger Fabric 1.0 从零开始（⼗⼀）——CouchDB（参阅：）
上述两章，最近⽹上各路⼤神⽂章云集，⽅案多多，因为最近⼯作太忙太忙，我暂时就先不赘述了，可以优先参考深蓝⼤⼤的⽂章。

这章先捡⼤家都⽐较在意的java sdk应⽤⽅案贴出来，很多朋友都找我要过，我主要是把注释都写进去了，⽤法简单了说了下，⼀般情况下会java开发的都能看懂。

年前实在太忙。

JAVA-SDK
9.1、基本介绍
官⽅在Fabric1.0之后就推荐使⽤SDK来实现交互的操作，原本在0.6上的restapi已经被废弃。

JAVA-SDK可以参考。

官⽅给的SDK的DEMO很难⼊⼿，注释稀少内容还很杂，所幸感谢github上有位朋友（具体地址实在是找不到了，以后会补上）稍加整理了⼀下，直接重写了官⽅的DEMO，让像我这样的新⼈更容易⼊⼿。

本次在官⽅SDK和⼤神重新的DEMO的基础上做了⼀次整理，能够更加清晰简单的⼊门并使⽤JAVA-SDK来进⾏交互。

9.2、架构
相信看到这⾥的朋友应该都对Fabric已经有了⾜够的了解，⾄少是应⽤层上已经可以实现分布式账本的各项功能，sdk也是在这样的基础进⾏讲述。

⾸先看下针对JAVA-SDK所写的辅助⼯程⽬录
关于Fabric，我们知道⼀个channel中可以创建多个chaincode，⽽⼀个chaincode需要指定对应orderer和peer。

所以，在此建⽴了⼀个bean⽬录来存放⾃定义的chaincode、orderer和peer对象。

这⼏个对象都包含各⾃最基本的访问属性。

具体对应关系如下：
bean.Chaincode - Fabric创建的chaincode信息，涵盖所属channel等信息
bean.Orderers - Fabric创建的orderer信息，涵盖单机和集群两种⽅案
bean.Peers - Fabric创建的peer信息，包含有cli、org、ca、couchdb等节点服务器关联启动服务信息集合
ChaincodeManager - 智能合约操作总控制器
FabricConfig - 智能合约操作总参数配置器
FabricOrg - 联盟组织对象
FabricUser - 联盟⽤户对象
FabricStore - 联盟存储配置对象
9.3、具体实现
直接通过代码来看实现
9.3.1、Chaincode代码
1package cn.aberic.fabric.bean;
2
3/**
4 * Fabric创建的chaincode信息，涵盖所属channel等信息
5 *
6 * @author aberic
7 *
8 * @date 2017年10⽉18⽇ - 下午2:07:42
9 * @email abericyang@
10*/
11public class Chaincode {
12
13/** 当前将要访问的智能合约所属频道名称 */
14private String channelName; // ffetest
15/** 智能合约名称 */
16private String chaincodeName; // ffetestcc
17/** 智能合约安装路径 */
18private String chaincodePath; // /hyperledger/fabric/xxx/chaincode/go/example/test
19/** 智能合约版本号 */
20private String chaincodeVersion; // 1.0
21/** 执⾏智能合约操作等待时间 */
22private int invokeWatiTime = 100000;
23/** 执⾏智能合约实例等待时间 */
24private int deployWatiTime = 120000;
25
26public String getChannelName() {
27return channelName;
28 }
29
30public void setChannelName(String channelName) {
31this.channelName = channelName;
32 }
33
34public String getChaincodeName() {
35return chaincodeName;
36 }
37
38public void setChaincodeName(String chaincodeName) {
43return chaincodePath;
44 }
45
46public void setChaincodePath(String chaincodePath) {
47this.chaincodePath = chaincodePath;
48 }
49
50public String getChaincodeVersion() {
51return chaincodeVersion;
52 }
53
54public void setChaincodeVersion(String chaincodeVersion) {
55this.chaincodeVersion = chaincodeVersion;
56 }
57
58public int getInvokeWatiTime() {
59return invokeWatiTime;
60 }
61
62public void setInvokeWatiTime(int invokeWatiTime) {
63this.invokeWatiTime = invokeWatiTime;
64 }
65
66public int getDeployWatiTime() {
67return deployWatiTime;
68 }
69
70public void setDeployWatiTime(int deployWatiTime) {
71this.deployWatiTime = deployWatiTime;
72 }
73
74 }
9.3.2、Orderers代码
1package cn.aberic.fabric.bean;
2
3import java.util.ArrayList;
4import java.util.List;
5
6/**
7 * Fabric创建的orderer信息，涵盖单机和集群两种⽅案
8 *
9 * @author aberic
10 *
11 * @date 2017年10⽉18⽇ - 下午1:56:48
12 * @email abericyang@
13*/
14public class Orderers {
15
16/** orderer 排序服务器所在根域名 */
17private String ordererDomainName; //
18/** orderer 排序服务器集合 */
19private List<Orderer> orderers;
20
21public Orderers() {
22 orderers = new ArrayList<>();
23 }
24
25public String getOrdererDomainName() {
26return ordererDomainName;
27 }
28
29public void setOrdererDomainName(String ordererDomainName) { 30this.ordererDomainName = ordererDomainName;
31 }
32
33/** 新增排序服务器 */
34public void addOrderer(String name, String location) {
35 orderers.add(new Orderer(name, location));
36 }
37
38/** 获取排序服务器集合 */
39public List<Orderer> get() {
40return orderers;
41 }
42
43/**
44 * 排序服务器对象
45 *
46 * @author aberic
47 *
48 * @date 2017年10⽉18⽇ - 下午2:06:22
49 * @email abericyang@
50*/
51public class Orderer {
52
53/** orderer 排序服务器的域名 */
54private String ordererName;
55/** orderer 排序服务器的访问地址 */
56private String ordererLocation;
57
58public Orderer(String ordererName, String ordererLocation) { 59super();
60this.ordererName = ordererName;
61this.ordererLocation = ordererLocation;
62 }
63
64public String getOrdererName() {
65return ordererName;
66 }
67
68public void setOrdererName(String ordererName) {
69this.ordererName = ordererName;
70 }
71
72public String getOrdererLocation() {
73return ordererLocation;
74 }
75
76public void setOrdererLocation(String ordererLocation) {
9.3.3、Peers代码
1package cn.aberic.fabric.bean;
2
3import java.util.ArrayList;
4import java.util.List;
5
6/**
7 * Fabric创建的peer信息，包含有cli、org、ca、couchdb等节点服务器关联启动服务信息集合
8 *
9 * @author aberic
10 *
11 * @date 2017年10⽉18⽇ - 下午1:49:03
12 * @email abericyang@
13*/
14public class Peers {
15
16/** 当前指定的组织名称 */
17private String orgName; // Org1
18/** 当前指定的组织名称 */
19private String orgMSPID; // Org1MSP
20/** 当前指定的组织所在根域名 */
21private String orgDomainName; //
22/** orderer 排序服务器集合 */
23private List<Peer> peers;
24
25public Peers() {
26 peers = new ArrayList<>();
27 }
28
29public String getOrgName() {
30return orgName;
31 }
32
33public void setOrgName(String orgName) {
Name = orgName;
35 }
36
37public String getOrgMSPID() {
38return orgMSPID;
39 }
40
41public void setOrgMSPID(String orgMSPID) {
MSPID = orgMSPID;
43 }
44
45public String getOrgDomainName() {
46return orgDomainName;
47 }
48
49public void setOrgDomainName(String orgDomainName) {
DomainName = orgDomainName;
51 }
52
53/** 新增排序服务器 */
54public void addPeer(String peerName, String peerEventHubName, String peerLocation, String peerEventHubLocation, String caLocation) {
55 peers.add(new Peer(peerName, peerEventHubName, peerLocation, peerEventHubLocation, caLocation));
56 }
57
58/** 获取排序服务器集合 */
59public List<Peer> get() {
60return peers;
61 }
62
63/**
64 * 节点服务器对象
65 *
66 * @author aberic
67 *
68 * @date 2017年11⽉11⽇ - 下午6:56:14
69 * @email abericyang@
70*/
71public class Peer {
72
73/** 当前指定的组织节点域名 */
74private String peerName; //
75/** 当前指定的组织节点事件域名 */
76private String peerEventHubName; //
77/** 当前指定的组织节点访问地址 */
78private String peerLocation; // grpc://110.131.116.21:7051
79/** 当前指定的组织节点事件监听访问地址 */
80private String peerEventHubLocation; // grpc://110.131.116.21:7053
81/** 当前指定的组织节点ca访问地址 */
82private String caLocation; //http://110.131.116.21:7054
83/** 当前peer是否增加Event事件处理 */
84private boolean addEventHub = false;
85
86public Peer(String peerName, String peerEventHubName, String peerLocation, String peerEventHubLocation, String caLocation) {
87this.peerName = peerName;
88this.peerEventHubName = peerEventHubName;
89this.peerLocation = peerLocation;
90this.peerEventHubLocation = peerEventHubLocation;
91this.caLocation = caLocation;
92 }
93
94public String getPeerName() {
95return peerName;
96 }
97
98public void setPeerName(String peerName) {
99this.peerName = peerName;
100 }
101
102public String getPeerEventHubName() {
103return peerEventHubName;
104 }
105
106public void setPeerEventHubName(String peerEventHubName) {
107this.peerEventHubName = peerEventHubName;
114public void setPeerLocation(String peerLocation) {
115this.peerLocation = peerLocation;
116 }
117
118public String getPeerEventHubLocation() {
119return peerEventHubLocation;
120 }
121
122public void setPeerEventHubLocation(String eventHubLocation) { 123this.peerEventHubLocation = eventHubLocation;
124 }
125
126public String getCaLocation() {
127return caLocation;
128 }
129
130public void setCaLocation(String caLocation) {
131this.caLocation = caLocation;
132 }
133
134public boolean isAddEventHub() {
135return addEventHub;
136 }
137
138public void addEventHub(boolean addEventHub) {
139this.addEventHub = addEventHub;
140 }
141
142 }
143
144 }
9.3.4、FabricUser代码
1package cn.aberic.fabric;
2
3import java.io.ByteArrayInputStream;
4import java.io.ByteArrayOutputStream;
5import java.io.IOException;
6import java.io.ObjectInputStream;
7import java.io.ObjectOutputStream;
8import java.io.Serializable;
9import java.util.Set;
10
11import org.bouncycastle.util.encoders.Hex;
12import org.hyperledger.fabric.sdk.Enrollment;
13import er;
14
15import ty.util.internal.StringUtil;
16
17/**
18 * 联盟⽤户对象
19 *
20 * @author aberic
21 *
22 * @date 2017年9⽉7⽇ - 下午4:36:53
23 * @email abericyang@
24*/
25class FabricUser implements User, Serializable {
26
27private static final long serialVersionUID = 5695080465408336815L; 28
29/** 名称 */
30private String name;
31/** 规则 */
32private Set<String> roles;
33/** 账户 */
34private String account;
35/** 从属联盟 */
36private String affiliation;
37/** 组织 */
38private String organization;
39/** 注册操作的密�? */
40private String enrollmentSecret;
41/** 会员id */
42private String mspId;
43/** 注册登记操作 */
44 Enrollment enrollment = null; // �?要在测试env中访�?
45
46/** 存储配置对象 */
47private transient FabricStore keyValStore;
48private String keyValStoreName;
49
50public FabricUser(String name, String org, FabricStore store) {
= name;
52this.keyValStore = store;
anization = org;
54this.keyValStoreName = toKeyValStoreName(, org);
55
56 String memberStr = keyValStore.getValue(keyValStoreName); 57if (null != memberStr) {
58 saveState();
59 } else {
60 restoreState();
61 }
62 }
63
64/**
65 * 设置账户信息并将⽤户状�?�更新⾄存储配置对象
66 *
67 * @param account
68 * 账户
69*/
70public void setAccount(String account) {
71this.account = account;
72 saveState();
73 }
74
75 @Override
76public String getAccount() {
83 * @param affiliation
84 * 从属联盟
85*/
86public void setAffiliation(String affiliation) {
87this.affiliation = affiliation;
88 saveState();
89 }
90
91 @Override
92public String getAffiliation() {
93return this.affiliation;
94 }
95
96 @Override
97public Enrollment getEnrollment() {
98return this.enrollment;
99 }
100
101/**
102 * 设置会员id信息并将⽤户状�?�更新⾄存储配置对象
103 *
104 * @param mspID
105 * 会员id
106*/
107public void setMspId(String mspID) {
108this.mspId = mspID;
109 saveState();
110 }
111
112 @Override
113public String getMspId() {
114return this.mspId;
115 }
116
117 @Override
118public String getName() {
119return ;
120 }
121
122/**
123 * 设置规则信息并将⽤户状�?�更新⾄存储配置对象
124 *
125 * @param roles
126 * 规则
127*/
128public void setRoles(Set<String> roles) {
129this.roles = roles;
130 saveState();
131 }
132
133 @Override
134public Set<String> getRoles() {
135return this.roles;
136 }
137
138public String getEnrollmentSecret() {
139return enrollmentSecret;
140 }
141
142/**
143 * 设置注册操作的密钥信息并将⽤户状态更新⾄存储配置对象
144 *
145 * @param enrollmentSecret
146 * 注册操作的密�?
147*/
148public void setEnrollmentSecret(String enrollmentSecret) {
149this.enrollmentSecret = enrollmentSecret;
150 saveState();
151 }
152
153/**
154 * 设置注册登记操作信息并将⽤户状�?�更新⾄存储配置对象
155 *
156 * @param enrollment
157 * 注册登记操作
158*/
159public void setEnrollment(Enrollment enrollment) {
160this.enrollment = enrollment;
161 saveState();
162 }
163
164/**
165 * 确定这个名称是否已注�?
166 *
167 * @return与否
168*/
169public boolean isRegistered() {
170return !StringUtil.isNullOrEmpty(enrollmentSecret);
171 }
172
173/**
174 * 确定这个名字是否已经注册
175 *
176 * @return与否
177*/
178public boolean isEnrolled() {
179return this.enrollment != null;
180 }
181
182/** 将⽤户状态保存⾄存储配置对象 */
183public void saveState() {
184 ByteArrayOutputStream bos = new ByteArrayOutputStream();
185try {
186 ObjectOutputStream oos = new ObjectOutputStream(bos);
187 oos.writeObject(this);
188 oos.flush();
189 keyValStore.setValue(keyValStoreName, Hex.toHexString(bos.toByteArray())); 190 bos.close();
191 } catch (IOException e) {
192 e.printStackTrace();
193 }
194 }
195
196/**
197 * 从键值存储中恢复该⽤户的状�??(如果找到的话)。

如果找不到，什么也不要做�?? 198 *
199 * @return返回⽤户
200*/
205byte[] serialized = Hex.decode(memberStr);
206 ByteArrayInputStream bis = new ByteArrayInputStream(serialized);
207try {
208 ObjectInputStream ois = new ObjectInputStream(bis);
209 FabricUser state = (FabricUser) ois.readObject();
210if (state != null) {
= ;
212this.roles = state.roles;
213this.account = state.account;
214this.affiliation = state.affiliation;
anization = anization;
216this.enrollmentSecret = state.enrollmentSecret;
217this.enrollment = state.enrollment;
218this.mspId = state.mspId;
219return this;
220 }
221 } catch (Exception e) {
222throw new RuntimeException(String.format("Could not restore state of member %s", ), e);
223 }
224 }
225return null;
226 }
227
228public static String toKeyValStoreName(String name, String org) {
229 System.out.println("toKeyValStoreName = " + "user." + name + org);
230return "user." + name + org;
231 }
232
233 }
9.3.5、FabricOrg代码
1package cn.aberic.fabric;
2
3import java.io.File;
4import java.io.IOException;
5import java.nio.file.Paths;
6import java.security.NoSuchAlgorithmException;
7import java.security.NoSuchProviderException;
8import java.security.spec.InvalidKeySpecException;
9import java.util.Collection;
10import java.util.Collections;
11import java.util.HashMap;
12import java.util.HashSet;
13import java.util.Map;
14import java.util.Properties;
15import java.util.Set;
16
17import org.apache.log4j.Logger;
18import org.hyperledger.fabric.sdk.Peer;
19import er;
20import org.hyperledger.fabric_ca.sdk.HFCAClient;
21
22import cn.aberic.fabric.bean.Orderers;
23
24/**
25 * 联盟组织对象
26 *
27 * @author aberic
28 *
29 * @date 2017年9⽉7⽇ - 下午4:35:40
30 * @email abericyang@
31*/
32class FabricOrg {
33
34private static Logger log = Logger.getLogger(FabricOrg.class);
35
36/** 名称 */
37private String name;
38/** 会员id */
39private String mspid;
40/** ca 客户端 */
41private HFCAClient caClient;
42
43/** ⽤户集合 */
44 Map<String, User> userMap = new HashMap<>();
45/** 本地节点集合 */
46 Map<String, String> peerLocations = new HashMap<>();
47/** 本地排序服务集合 */
48 Map<String, String> ordererLocations = new HashMap<>();
49/** 本地事件集合 */
50 Map<String, String> eventHubLocations = new HashMap<>();
51/** 节点集合 */
52 Set<Peer> peers = new HashSet<>();
53/** 联盟管理员⽤户 */
54private FabricUser admin;
55/** 本地 ca */
56private String caLocation;
57/** ca 配置 */
58private Properties caProperties = null;
59
60/** 联盟单节点管理员⽤户 */
61private FabricUser peerAdmin;
62
63/** 域名名称 */
64private String domainName;
65
66public FabricOrg(cn.aberic.fabric.bean.Peers peers, Orderers orderers, FabricStore fabricStore, String cryptoConfigPath) 67throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException, IOException {
= peers.getOrgName();
69this.mspid = peers.getOrgMSPID();
70for (int i = 0; i < peers.get().size(); i++) {
71 addPeerLocation(peers.get().get(i).getPeerName(), peers.get().get(i).getPeerLocation());
72 addEventHubLocation(peers.get().get(i).getPeerEventHubName(), peers.get().get(i).getPeerEventHubLocation());
73 setCALocation(peers.get().get(i).getCaLocation());
74 }
75for (int i = 0; i < orderers.get().size(); i++) {
76 addOrdererLocation(orderers.get().get(i).getOrdererName(), orderers.get().get(i).getOrdererLocation());
77 }
78 setDomainName(peers.getOrgDomainName()); // domainName=
79
85 File skFile = Paths.get(cryptoConfigPath, "/peerOrganizations/", peers.getOrgDomainName(), String.format("/users/Admin@%s/msp/keystore", peers.getOrgDomainName())).toFile();
86 File certificateFile = Paths.get(cryptoConfigPath, "/peerOrganizations/", peers.getOrgDomainName(),
87 String.format("/users/Admin@%s/msp/signcerts/Admin@%s-cert.pem", peers.getOrgDomainName(), peers.getOrgDomainName())).toFile();
88 log.debug("skFile = " + skFile.getAbsolutePath());
89 log.debug("certificateFile = " + certificateFile.getAbsolutePath());
90 setPeerAdmin(fabricStore.getMember(peers.getOrgName() + "Admin", peers.getOrgName(), peers.getOrgMSPID(), findFileSk(skFile), certificateFile)); // ⼀个特殊的⽤户，可以创建通道，连接对等点，并安装链码
91 }
92
93public String getName() {
94return name;
95 }
96
97/**
98 * 获取联盟管理员⽤户
99 *
100 * @return联盟管理员⽤户
101*/
102public FabricUser getAdmin() {
103return admin;
104 }
105
106/**
107 * 设置联盟管理员⽤户
108 *
109 * @param admin
110 * 联盟管理员⽤户
111*/
112public void setAdmin(FabricUser admin) {
113this.admin = admin;
114 }
115
116/**
117 * 获取会员id
118 *
119 * @return会员id
120*/
121public String getMSPID() {
122return mspid;
123 }
124
125/**
126 * 设置本地ca
127 *
128 * @param caLocation
129 * 本地ca
130*/
131public void setCALocation(String caLocation) {
132this.caLocation = caLocation;
133 }
134
135/**
136 * 获取本地ca
137 *
138 * @return本地ca
139*/
140public String getCALocation() {
141return this.caLocation;
142 }
143
144/**
145 * 添加本地节点
146 *
147 * @param name
148 * 节点key
149 * @param location
150 * 节点
151*/
152public void addPeerLocation(String name, String location) {
153 peerLocations.put(name, location);
154 }
155
156/**
157 * 添加本地组织
158 *
159 * @param name
160 * 组织key
161 * @param location
162 * 组织
163*/
164public void addOrdererLocation(String name, String location) {
165 ordererLocations.put(name, location);
166 }
167
168/**
169 * 添加本地事件
170 *
171 * @param name
172 * 事件key
173 * @param location
174 * 事件
175*/
176public void addEventHubLocation(String name, String location) {
177 eventHubLocations.put(name, location);
178 }
179
180/**
181 * 获取本地节点
182 *
183 * @param name
184 * 节点key
185 * @return节点
186*/
187public String getPeerLocation(String name) {
188return peerLocations.get(name);
189 }
190
191/**
192 * 获取本地组织
193 *
194 * @param name
195 * 组织key
196 * @return组织
197*/
198public String getOrdererLocation(String name) {
199return ordererLocations.get(name);
200 }
201
202/**
203 * 获取本地事件
209public String getEventHubLocation(String name) {
210return eventHubLocations.get(name);
211 }
212
213/**
214 * 获取⼀个不可修改的本地节点key集合
215 *
216 * @return节点key集合
217*/
218public Set<String> getPeerNames() {
219return Collections.unmodifiableSet(peerLocations.keySet());
220 }
221
222/**
223 * 获取⼀个不可修改的本地节点集合
224 *
225 * @return节点集合
226*/
227public Set<Peer> getPeers() {
228return Collections.unmodifiableSet(peers);
229 }
230
231/**
232 * 获取⼀个不可修改的本地组织key集合
233 *
234 * @return组织key集合
235*/
236public Set<String> getOrdererNames() {
237return Collections.unmodifiableSet(ordererLocations.keySet());
238 }
239
240/**
241 * 获取⼀个不可修改的本地组织集合
242 *
243 * @return组织集合
244*/
245public Collection<String> getOrdererLocations() {
246return Collections.unmodifiableCollection(ordererLocations.values()); 247 }
248
249/**
250 * 获取⼀个不可修改的本地事件key集合
251 *
252 * @return事件key集合
253*/
254public Set<String> getEventHubNames() {
255return Collections.unmodifiableSet(eventHubLocations.keySet());
256 }
257
258/**
259 * 获取⼀个不可修改的本地事件集合
260 *
261 * @return事件集合
262*/
263public Collection<String> getEventHubLocations() {
264return Collections.unmodifiableCollection(eventHubLocations.values()); 265 }
266
267/**
268 * 设置 ca 客户端
269 *
270 * @param caClient
271 * ca 客户端
272*/
273public void setCAClient(HFCAClient caClient) {
274this.caClient = caClient;
275 }
276
277/**
278 * 获取 ca 客户端
279 *
280 * @return ca 客户端
281*/
282public HFCAClient getCAClient() {
283return caClient;
284 }
285
286/**
287 * 向⽤户集合中添加⽤户
288 *
289 * @param user
290 * ⽤户
291*/
292public void addUser(FabricUser user) {
293 userMap.put(user.getName(), user);
294 }
295
296/**
297 * 从⽤户集合根据名称获取⽤户
298 *
299 * @param name
300 * 名称
301 * @return⽤户
302*/
303public User getUser(String name) {
304return userMap.get(name);
305 }
306
307/**
308 * 向节点集合中添加节点
309 *
310 * @param peer
311 * 节点
312*/
313public void addPeer(Peer peer) {
314 peers.add(peer);
315 }
316
317/**
318 * 设置 ca 配置
319 *
320 * @param caProperties
321 * ca 配置
322*/
323public void setCAProperties(Properties caProperties) {
324this.caProperties = caProperties;
325 }
326
332public Properties getCAProperties() {
333return caProperties;
334 }
335
336/**
337 * 设置联盟单节点管理员⽤户
338 *
339 * @param peerAdmin
340 * 联盟单节点管理员⽤户
341*/
342public void setPeerAdmin(FabricUser peerAdmin) {
343this.peerAdmin = peerAdmin;
344 }
345
346/**
347 * 获取联盟单节点管理员⽤户
348 *
349 * @return联盟单节点管理员⽤户
350*/
351public FabricUser getPeerAdmin() {
352return peerAdmin;
353 }
354
355/**
356 * 设置域名名称
357 *
358 * @param doainName
359 * 域名名称
360*/
361public void setDomainName(String domainName) {
362this.domainName = domainName;
363 }
364
365/**
366 * 获取域名名称
367 *
368 * @return域名名称
369*/
370public String getDomainName() {
371return domainName;
372 }
373
374/**
375 * 从指定路径中获取后缀为 _sk 的⽂件，且该路径下有且仅有该⽂件
376 *
377 * @param directorys
378 * 指定路径
379 * @return File
380*/
381private File findFileSk(File directory) {
382 File[] matches = directory.listFiles((dir, name) -> name.endsWith("_sk"));
383if (null == matches) {
384throw new RuntimeException(String.format("Matches returned null does %s directory exist?", directory.getAbsoluteFile().getName()));
385 }
386if (matches.length != 1) {
387throw new RuntimeException(String.format("Expected in %s only 1 sk file but found %d", directory.getAbsoluteFile().getName(), matches.length)); 388 }
389return matches[0];
390 }
391
392 }
9.3.6、FabricStore代码
1package cn.aberic.fabric;
2
3import java.io.File;
4import java.io.FileInputStream;
5import java.io.FileNotFoundException;
6import java.io.FileOutputStream;
7import java.io.IOException;
8import java.io.InputStream;
9import java.io.OutputStream;
10import java.io.Reader;
11import java.io.Serializable;
12import java.io.StringReader;
13import java.security.NoSuchAlgorithmException;
14import java.security.NoSuchProviderException;
15import java.security.PrivateKey;
16import java.security.Security;
17import java.security.spec.InvalidKeySpecException;
18import java.util.HashMap;
19import java.util.Map;
20import java.util.Properties;
21
22import mons.io.IOUtils;
23import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
24import org.bouncycastle.jce.provider.BouncyCastleProvider;
25import org.bouncycastle.openssl.PEMParser;
26import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;
27import org.hyperledger.fabric.sdk.Enrollment;
28
29/**
30 * 联盟存储配置对象
31 *
32 * @author aberic
33 *
34 * @date 2017年9⽉7⽇ - 下午4:36:19
35 * @email abericyang@
36*/
37class FabricStore {
38
39private String file;
40/** ⽤户信息集合 */
41private final Map<String, FabricUser> members = new HashMap<>();
42
43public FabricStore(File file) {
44this.file = file.getAbsolutePath();
45 }
46
52 * @param value
53 * 相关值
54*/
55public void setValue(String name, String value) {
56 Properties properties = loadProperties();
57try (OutputStream output = new FileOutputStream(file)) {
58 properties.setProperty(name, value);
59 properties.store(output, "");
60 output.close();
61 } catch (IOException e) {
62 System.out.println(String.format("Could not save the keyvalue store, reason:%s", e.getMessage()));
63 }
64 }
65
66/**
67 * 获取与名称相关的值
68 *
69 * @param名称
70 * @return相关值
71*/
72public String getValue(String name) {
73 Properties properties = loadProperties();
74return properties.getProperty(name);
75 }
76
77/**
78 * 加载配置⽂件
79 *
80 * @return配置⽂件对象
81*/
82private Properties loadProperties() {
83 Properties properties = new Properties();
84try (InputStream input = new FileInputStream(file)) {
85 properties.load(input);
86 input.close();
87 } catch (FileNotFoundException e) {
88 System.out.println(String.format("Could not find the file \"%s\"", file));
89 } catch (IOException e) {
90 System.out.println(String.format("Could not load keyvalue store from file \"%s\", reason:%s", file, e.getMessage()));
91 }
92return properties;
93 }
94
95/**
96 * ⽤给定的名称获取⽤户
97 *
98 * @param名称
99 * @param组织
100 *
101 * @return⽤户
102*/
103public FabricUser getMember(String name, String org) {
104// 尝试从缓存中获取User状�??
105 FabricUser fabricUser = members.get(FabricUser.toKeyValStoreName(name, org));
106if (null != fabricUser) {
107return fabricUser;
108 }
109// 创建User，并尝试从键值存储中恢复它的状�??(如果找到的话)�?
110 fabricUser = new FabricUser(name, org, this);
111return fabricUser;
112 }
113
114/**
115 * ⽤给定的名称获取⽤户
116 *
117 * @param name
118 * 名称
119 * @param org
120 * 组织
121 * @param mspId
122 * 会员id
123 * @param privateKeyFile
124 * @param certificateFile
125 *
126 * @return user ⽤户
127 *
128 * @throws IOException
129 * @throws NoSuchAlgorithmException
130 * @throws NoSuchProviderException
131 * @throws InvalidKeySpecException
132*/
133public FabricUser getMember(String name, String org, String mspId, File privateKeyFile, File certificateFile)
134throws IOException, NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {
135try {
136// 尝试从缓存中获取User状�??
137 FabricUser fabricUser = members.get(FabricUser.toKeyValStoreName(name, org));
138if (null != fabricUser) {
139 System.out.println("尝试从缓存中获取User状�?? User = " + fabricUser);
140return fabricUser;
141 }
142// 创建User，并尝试从键值存储中恢复它的状�??(如果找到的话)�?
143 fabricUser = new FabricUser(name, org, this);
144 fabricUser.setMspId(mspId);
145 String certificate = new String(IOUtils.toByteArray(new FileInputStream(certificateFile)), "UTF-8");
146 PrivateKey privateKey = getPrivateKeyFromBytes(IOUtils.toByteArray(new FileInputStream(privateKeyFile))); 147 fabricUser.setEnrollment(new StoreEnrollement(privateKey, certificate));
148return fabricUser;
149 } catch (IOException e) {
150 e.printStackTrace();
151throw e;
152 } catch (NoSuchAlgorithmException e) {
153 e.printStackTrace();
154throw e;
155 } catch (NoSuchProviderException e) {
156 e.printStackTrace();
157throw e;
158 } catch (InvalidKeySpecException e) {
159 e.printStackTrace();
160throw e;
161 } catch (ClassCastException e) {
162 e.printStackTrace();
163throw e;
164 }
165 }
166
167/**
168 * 通过字节数组信息获取私钥
169 *
170 * @param data。