java 实现opc代码实现，附加问题解决方法和错误编码详解

在使用opc之前我们先了解一下什么是opc，首先OPC包含三个概念模型：

• OPC Server

• OPC Group（注意这个加粗！！！）

• OPC Item

关于这三个概念模型具体含义，我就不一一赘述了，大家可点进下面的连接查看
点点击击

首先，我们的需求是，用Java写一个OPC客户端程序，定时从OPC服务读数据，那么我们来看下网上的DEMO咋写的：

1. public static void test() throws Exception {

2. final ConnectionInformation ci = new ConnectionInformation();

3. ci.setHost("10.211.55.4");

4. ci.setUser("OPCUser");

5. ci.setPassword("opcuser");

6. ci.setClsid("7BC0CC8E-482C-47CA-ABDC-0FE7F9C6E729");

7. Item item = null;

8. Server server = new Server(ci, null);

9. try {

10. server.connect();

12. Group group = server.addGroup();

13. item = group.addItem("tongdao.tag1.aaa");

14. System.out.println("读取到的值为：" + getVal(item.read(true).getValue()));

16. server.disconnect();

17. } catch (Exception e) {

18. e.printStackTrace();

19. }

21. }

我们简单理解下，和大部分通信客户端一个步骤：建立通道连接，传参，取数据，关闭连接

如果我们需要取多个点号的数据怎么办？
在外面套一层for循环对吧（没错，我有个朋友也是这么想的）
那么就有了如下写法：

1. public static void test() throws Exception {

2. final ConnectionInformation ci = new ConnectionInformation();

3. ci.setHost("10.211.55.4");

4. ci.setUser("OPCUser");

5. ci.setPassword("opcuser");

6. ci.setClsid("7BC0CC8E-482C-47CA-ABDC-0FE7F9C6E729");

7. Item item = null;

8. Server server = new Server(ci, null);

10. List<String> itemIdList = new ArrayList<>(); // 假设这里面有数据

11. try {

12. server.connect();

14. for(String itemId : itemIdList) {

15. Group group = server.addGroup();

16. item = group.addItem("tongdao.tag1.aaa");

17. System.out.println("读取到的值为：" + getVal(item.read(true).getValue()));

18. }

20. server.disconnect();

21. } catch (Exception e) {

22. e.printStackTrace();

23. }

24. }

写完后信心满满，仿佛屈屈OPC，不过如此！
到了测试环节，我们真实环境大概两万个点位，数据量也不是很大，不是分分钟测试成功？
结果是：人家的OPC Server服务被（我的一个朋友）成功搞挂了；

看来不能一次性取这么多啊，这个OPC。。。。。8太行啊
那我们先取1000个试试水，看看性能究竟如何

代码主要逻辑不变，我们把参数长度设为1000

1. List<String> itemIdList = new ArrayList<>(); // 假设这里面有数据

2. itemIdList = itemIdList.subList(0, 1000); //只查1000条数据，测测性能

执行完时间大概在8秒左右

嘶~倒吸一口凉气，这1000条就要8秒，那我2w条不得 8 * 20 = 160s?
两分多钟，也还行，，，，
但是！作为一枚专业及严谨的程序员，怎么能忍受得了2分多钟的时长！不行！绝对不行！

此时我那个朋友萌生出了另一套方案，单线程1000条8s左右，那我开双线程分别查询1000条是不是也是8s左右了捏？这样折合下来能节约一半的时间嘛，而且可以的话我们可以多建几个线程去跑，这样时间又会以指数级下降

于是有了以下这段代码：

1. package com.oukong.framework;

3. import org.jinterop.dcom.common.JIErrorCodes;

4. import org.jinterop.dcom.common.JIException;

5. import org.jinterop.dcom.core.JIVariant;

6. import org.openscada.opc.lib.common.ConnectionInformation;

7. import org.openscada.opc.lib.da.*;

9. import java.util.*;

10. import java.util.concurrent.CountDownLatch;

12. public class OpcTest3 {

14. public static void main(String[] args) throws Exception {

15. test();

16. }

18. public static void test() throws Exception {

19. final ConnectionInformation ci = new ConnectionInformation();

20. ci.setHost("10.211.55.4");

21. ci.setUser("OPCUser");

22. ci.setPassword("opcuser");

23. ci.setClsid("7BC0CC8E-482C-47CA-ABDC-0FE7F9C6E729");

24. Item item = null;

25. Server server = new Server(ci, null);

27. List<String> itemIdList = new ArrayList<>(); // 假设这里面有数据

28. List<String> itemList1 = itemIdList.subList(0, 1000);

29. List<String> itemList2 = itemIdList.subList(1000, 2000);

30. Map<String, Object> result = new HashMap<>();

31. try {

32. server.connect();

33. CountDownLatch countDownLatch = new CountDownLatch(2); //线程计数器

34. OpcThread1 thread = new OpcThread1(server, itemList1, countDownLatch, result);

35. OpcThread1 thread2 = new OpcThread1(server, itemList2, countDownLatch, result);

36. thread.start();

37. thread2.start();

39. countDownLatch.await(); //等待两个线程都执行完成

41. server.disconnect();

42. } catch (Exception e) {

43. e.printStackTrace();

44. }

46. }

48. }

50. class OpcThread1 extends Thread {

52. private List<String> itemList;

54. private Server server;

56. private CountDownLatch countDownLatch;

58. private Map<String, Object> result;

60. public OpcThread1(Server server, List<String> itemList, CountDownLatch countDownLatch,

61. Map<String, Object> result) {

62. this.server = server;

63. this.itemList = itemList;

64. this.countDownLatch = countDownLatch;

65. this.result = result;

66. }

68. @Override

69. public void run() {

70. Group group = null;

71. try {

72. server.connect();

73. for(String itemId : itemList) {

74. Group group = server.addGroup();

75. Item item = group.addItem("tongdao.tag1.aaa");

76. System.out.println("读取到的值为：" + getVal(item.read(true).getValue()));

77. }

78. countDownLatch.countDown();

79. } catch (Exception e) {

80. e.printStackTrace();

81. }

82. }

83. }

然后执行结果不出所料，和预想的时间相差不大，但是，我们忽略了一个问题，这个OPC服务的吞吐量8太行，真怕一不注意就把服务给搞挂了，所以，该方法虽然表面上可行，但是，，，，下流，，，，

难道真的没别的方法了吗？
关于上面提到的组，没有利用空间的吗？

于是我那个朋友翻了Group对象的源码，发现提供了这么个东东

image.png

该对象提供了添加多个Item的方法！也就意味着我们可以一次性传多个参数进行请求，然后回给我们返回一个集合！
于是我们有了如下代码：

1. @Override

2. public void run() {

3. Group group = null;

4. try {

5. group = server.addGroup();

6. String[] items = itemList.toArray(new String[]{});

7. Map<String, Item> itemResult = group.addItems(items);

8. for(String key : itemResult.keySet()) {

9. Item itemMap = itemResult.get(key);

10. result.put(key, getVal(itemMap.read(true).getValue()));

11. }

12. countDownLatch.countDown();

13. } catch (Exception e) {

14. e.printStackTrace();

15. }

16. }

上面的代码中我们用一个map将返回值给存了起来
再测一下！
结果：单线程情况下，请求1000条数据，耗时3秒左右
emmm....虽然进步了，但是1000条还是要3秒，2w条还是要1分钟左右，这能忍？不能！

于是我还想再找找有没有别的我没注意到的地方了，然后就发下了一行比较诡异的代码：

image.png

正常我们取值不是直接getValue()就好了？这个为什么还要read一下？

然后发现真正从客户端读取数据的就是这一行，我那个朋友之前误以为这个玩意儿就是取完值的集合了

image.png

但事实是，我们虽然分了组，但是取数据的时候还是一个item一个item地取，所以会如此之慢，，，，然后我又扒了一遍group的源码，又发现了这个东东：

image.png

看清没，我们之前是通过item去read值，但事实是，人家group本身就有一个read，而且将真正的值的集合返回给了我们，再稍微推敲一下，是不是这个组建好之后，我们可以取多次数据了。。。。

知道了这个方法，稍微改造了下代码，我批量穿参时候，也批量取，于是就有了如下代码！！！！（此处应有闪光特效）

1. package com.oukong.framework;

3. import org.jinterop.dcom.common.JIErrorCodes;

4. import org.jinterop.dcom.common.JIException;

5. import org.jinterop.dcom.core.JIVariant;

6. import org.openscada.opc.dcom.da.OPCSERVERSTATE;

7. import org.openscada.opc.lib.common.AlreadyConnectedException;

8. import org.openscada.opc.lib.common.ConnectionInformation;

9. import org.openscada.opc.lib.common.NotConnectedException;

10. import org.openscada.opc.lib.da.*;

12. import java.io.*;

13. import java.net.UnknownHostException;

14. import java.util.*;

15. import java.util.concurrent.CountDownLatch;

16. import java.util.concurrent.Executors;

18. public class OpcDaTest2 {

20. public static void test(List<String> itemList) {

22. List<String> itemList1 = itemList.subList(0, 500);

23. List<String> itemList2 = itemList.subList(1000, 2000);

24. final ConnectionInformation ci = new ConnectionInformation();

25. ci.setHost("10.10.1.13"); // KEPServer服务器所在IP

26. ci.setDomain(""); // 域 为空

27. ci.setUser("OPCuser");

28. ci.setPassword("Sa2022");

30. ci.setClsid("4B12BF21-3C60-4C48-A47F-E5F1E3BCFD34"); // OPCServer的注册表ID，可以在“组件服务”中查到

31. Item item = null;

32. Server server = new Server(ci, null);

34. Map<String, Object> result = new HashMap<>();

35. try {

36. server.connect();

37. long start = System.currentTimeMillis();

38. CountDownLatch countDownLatch = new CountDownLatch(1);

39. OpcThread thread = new OpcThread(server, itemList1, countDownLatch, result);

40. thread.start();

41. countDownLatch.await();

42. long end = System.currentTimeMillis();

43. System.out.println("totalSize: " + result.size() + "\tuse :" + (end - start) + "ms");

44. } catch (Exception e) {

45. e.printStackTrace();

46. }

48. }

50. }

52. class OpcThread extends Thread {

54. private List<String> itemList;

56. private Server server;

58. private CountDownLatch countDownLatch;

60. private Map<String, Object> result;

62. public OpcThread(Server server, List<String> itemList, CountDownLatch countDownLatch,

63. Map<String, Object> result) {

64. this.server = server;

65. this.itemList = itemList;

66. this.countDownLatch = countDownLatch;

67. this.result = result;

68. }

70. @Override

71. public void run() {

72. Group group = null;

73. try {

74. // 建组

75. long s = System.currentTimeMillis();

76. group = server.addGroup();

77. String[] items = itemList.toArray(new String[]{});

78. Map<String, Item> itemResult = group.addItems(items);

79. System.out.println(itemResult.size());

80. long e = System.currentTimeMillis();

82. System.out.println("建组耗时：" + (e - s));

84. //第一次取数据

85. long start = System.currentTimeMillis();

86. Set itemSet = new HashSet(itemResult.values());

87. Item[] itemArr = new Item[itemSet.size()];

88. itemSet.toArray(itemArr);

89. Map<Item, ItemState> resultMap = group.read(true, itemArr);

90. for(Item key : resultMap.keySet()) {

91. ItemState itemMap = resultMap.get(key);

92. result.put(key.getId(), getVal(itemMap.getValue()));

93. }

94. long end = System.currentTimeMillis();

95. System.out.println("group1 totalSize1 : " + itemResult.size() + "\tuse :" + (end - start) + "ms");

97. //第二次取数据

98. long start2 = System.currentTimeMillis();

99. Map<Item, ItemState> resultMap2 = group.read(true, itemArr);

100. for(Item key : resultMap2.keySet()) {

101. ItemState itemMap = resultMap2.get(key);

102. result.put(key.getId(), getVal(itemMap.getValue()));

103. }

104. long end2 = System.currentTimeMillis();

105. System.out.println("group1 totalSize2 : " + resultMap2.size() + "\tuse :" + (end2 - start2) + "ms");

106. countDownLatch.countDown();

107. } catch (Exception e) {

108. e.printStackTrace();

109. }

110. }

111. }

这下我们彻底将组利用了起来，执行结果如下：

1. 建组耗时：177214

2. group1 totalSize1 : 24000 use :6467ms

3. group1 totalSize2 : 24000 use :1526ms

我们将最初3分钟的时间，优化到了6秒钟，就问6不6？

最后附上完整的依赖和代码

maven

1. <!--utgard -->

2. <dependency>

3. <groupId>org.openscada.utgard</groupId>

4. <artifactId>org.openscada.opc.lib</artifactId>

5. <version>1.5.0</version>

6. <exclusions>

7. <exclusion>

8. <groupId>org.bouncycastle</groupId>

9. <artifactId>bcprov-jdk15on</artifactId>

10. </exclusion>

11. </exclusions>

12. </dependency>

13. <dependency>

14. <groupId>org.bouncycastle</groupId>

15. <artifactId>bcprov-jdk15on</artifactId>

16. <version>1.65</version>

17. </dependency>

18. <dependency>

19. <groupId>org.openscada.utgard</groupId>

20. <artifactId>org.openscada.opc.dcom</artifactId>

21. <version>1.5.0</version>

22. </dependency>

OPC客户端

1. import lombok.extern.slf4j.Slf4j;

2. import org.jinterop.dcom.common.JIErrorCodes;

3. import org.jinterop.dcom.common.JIException;

4. import org.jinterop.dcom.core.JIVariant;

5. import org.openscada.opc.dcom.da.OPCSERVERSTATE;

6. import org.openscada.opc.lib.common.AlreadyConnectedException;

7. import org.openscada.opc.lib.common.ConnectionInformation;

8. import org.openscada.opc.lib.common.NotConnectedException;

9. import org.openscada.opc.lib.da.*;

11. import java.net.UnknownHostException;

12. import java.util.*;

14. /**

15. * @Auther: 夏

16. * @DATE: 2022/6/8 14:58

17. * @Description: opc da客户端

18. */

19. @Slf4j

20. public class OpcDAClient {

22. private String host;

24. private String user;

26. private String password;

28. private String clsId;

30. private Server server;

32. private String bakHost;

34. private Integer groupCount;

36. private Group group = null;

38. private Map<String, Item> groupItems = null;

40. /**

41. * 初始化连接信息

42. * @param host

43. * @param user

44. * @param password

45. * @param clsId

46. */

47. public OpcDAClient(String host, String user, String password, String clsId, Integer groupCount) {

48. this.host = host;

49. this.user = user;

50. this.password = password;

51. this.clsId = clsId;

52. this.groupCount = groupCount;

53. }

55. /**

56. * 设置备用服务地址

57. * @param bakHost

58. */

59. public void setBakHost(String bakHost) {

60. this.bakHost = bakHost;

61. }

63. /**

64. * 创建连接

65. */

66. public void connect() {

67. if(server.getServerState() != null && server.getServerState().getServerState().equals(OPCSERVERSTATE.OPC_STATUS_RUNNING)) {

68. return;

69. }

70. final ConnectionInformation ci = new ConnectionInformation();

71. ci.setHost(host);

72. ci.setDomain(""); // 域 为空

73. ci.setUser(user);

74. ci.setPassword(password);

76. ci.setClsid(clsId);

77. server = new Server(ci, null);

78. try {

79. server.connect();

80. } catch (UnknownHostException e) {

81. e.printStackTrace();

82. log.error("opc 地址错误:", e);

83. } catch (JIException e) {

84. e.printStackTrace();

85. log.error("opc 连接失败:", e);

86. log.info("开始连接备用服务...");

87. try {

88. ci.setHost(bakHost);

89. server = new Server(ci, null);

90. server.connect();

91. } catch (Exception e2) {

92. log.error("备用服务连接失败：", e2);

93. }

95. } catch (AlreadyConnectedException e) {

96. e.printStackTrace();

97. log.error("opc 已连接:", e);

98. }

99. log.info("OPC Server connect success...");

100. }

102. /**

103. * 根据地址获取数据

104. * @param itemId

105. * @return

106. */

107. public Object getItemValue(String itemId) {

108. try {

109. Group group = server.addGroup();

110. Item item = group.addItem(itemId);

111. return getVal(item.read(true).getValue());

112. } catch (Exception e) {

113. e.printStackTrace();

114. log.error("获取数据异常 itemId:{}", itemId, e);

115. }

116. return null;

117. }

119. /**

120. * 获取多组数据

121. * @param itemIdList

122. * @return

123. */

124. public Map<String, Object> getItemValues(List<String> itemIdList) {

125. Map<String, Object> result = new HashMap<>();

126. try {

127. if(groupItems == null || group == null) {

128. log.info("开始建组...");

129. group = server.addGroup();

130. String[] items = itemIdList.toArray(new String[]{});

131. groupItems = group.addItems(items);

132. log.info("组建完成，开始查询数据...");

133. }

135. Set itemSet = new HashSet(groupItems.values());

136. Item[] itemArr = new Item[itemSet.size()];

137. itemSet.toArray(itemArr);

138. Map<Item, ItemState> resultMap = group.read(true, itemArr);

139. log.info("数据获取完成：{}条", resultMap.size());

140. for(Item item : resultMap.keySet()) {

141. ItemState itemMap = resultMap.get(item);

142. result.put(item.getId(), getVal(itemMap.getValue()));

143. }

144. } catch (Exception e) {

145. e.printStackTrace();

146. log.error("批量获取数据异常：", e);

147. }

148. return result;

149. }

151. /**

152. * 获取value

153. * @param var

154. * @return

155. * @throws JIException

156. */

157. private static Object getVal(JIVariant var) throws JIException {

158. Object value;

159. int type = var.getType();

160. switch (type) {

161. case JIVariant.VT_I2:

162. value = var.getObjectAsShort();

163. break;

164. case JIVariant.VT_I4:

165. value = var.getObjectAsInt();

166. break;

167. case JIVariant.VT_I8:

168. value = var.getObjectAsLong();

169. break;

170. case JIVariant.VT_R4:

171. value = var.getObjectAsFloat();

172. break;

173. case JIVariant.VT_R8:

174. value = var.getObjectAsDouble();

175. break;

176. case JIVariant.VT_BSTR:

177. value = var.getObjectAsString2();

178. break;

179. case JIVariant.VT_BOOL:

180. value = var.getObjectAsBoolean();

181. break;

182. case JIVariant.VT_UI2:

183. case JIVariant.VT_UI4:

184. value = var.getObjectAsUnsigned().getValue();

185. break;

186. case JIVariant.VT_EMPTY:

187. throw new JIException(JIErrorCodes.JI_VARIANT_IS_NULL, "Variant is Empty.");

188. case JIVariant.VT_NULL:

189. throw new JIException(JIErrorCodes.JI_VARIANT_IS_NULL, "Variant is null.");

190. default:

191. throw new JIException(JIErrorCodes.JI_VARIANT_IS_NULL, "Unknown Type.");

192. }

194. return value;

195. }

197. /**

198. * 将一组数据平均分成n组

199. *

200. * @param source 要分组的数据源

201. * @param n 平均分成n组

202. * @param <T>

203. * @return

204. */

205. private static <T> List<List<T>> averageAssign(List<T> source, int n) {

206. List<List<T>> result = new ArrayList<List<T>>();

207. int remainder = source.size() % n; //(先计算出余数)

208. int number = source.size() / n; //然后是商

209. int offset = 0;//偏移量

210. for (int i = 0; i < n; i++) {

211. List<T> value = null;

212. if (remainder > 0) {

213. value = source.subList(i * number + offset, (i + 1) * number + offset + 1);

214. remainder --;

215. offset++;

216. } else {

217. value = source.subList(i * number + offset, (i + 1) * number + offset);

218. }

219. result.add(value);

220. }

221. return result;

222. }

224. /**

225. * 关闭连接

226. */

227. public void disconnect() {

228. server.disconnect();

229. if (null == server.getServerState()) {

230. log.info("OPC Server Disconnect...");

231. }

232. }

234. }

最后，如果连接服务端有报错，可以到一下连接查看配置步骤和相关的错误编码