OPC UA TCP java 客户端

1.OPC UA 服务模拟软件,OPC UA 客户端软件,java 客户端源码,请指正

链接: https://pan.baidu.com/s/1_kvmUFkk8Y-HnxeavPEwag 密码: xe9m

2.OPC UA服务端

OPC UA 服务

3.OPC UA 客户端软件,可用来验证OPC UA 服务是否正常

4.java 客户端代码

ExampleKeys.java  用来生成客户端凭证

UATcpParam.java 参数类

OpcTcpClientUtil.java  OPC UA 客户端读写操作

TestOpcTcpClientUtil.java 测试客户端类

package com.tiger.uatcp;

import java.io.File;
import java.io.IOException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.InvalidParameterSpecException;
import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import org.opcfoundation.ua.common.ServiceResultException;
import org.opcfoundation.ua.transport.security.Cert;
import org.opcfoundation.ua.transport.security.KeyPair;
import org.opcfoundation.ua.transport.security.PrivKey;
import org.opcfoundation.ua.utils.CertificateUtils;


public class ExampleKeys {
	
	private static final String PRIVKEY_PASSWORD = "Opc.Ua";

	public static KeyPair getCert(String applicationName,String hostName,String applicationUri) throws ServiceResultException{
		File certFile = new File(applicationName + ".der");
		File privKeyFile =  new File(applicationName+ ".pem");
		try {
			Cert myCertificate = Cert.load( certFile );
			PrivKey myPrivateKey = PrivKey.load( privKeyFile, PRIVKEY_PASSWORD );
			return new KeyPair(myCertificate, myPrivateKey); 
		} catch (CertificateException e) {
			throw new ServiceResultException( e );
		} catch (IOException e) {		
			try {
				KeyPair keys = CertificateUtils.createApplicationInstanceCertificate(applicationName, null, applicationUri, 3650, hostName);
				keys.getCertificate().save(certFile);
				keys.getPrivateKey().save(privKeyFile);
				return keys;
			} catch (Exception e1) {
				throw new ServiceResultException( e1 );
			}
		} catch (NoSuchAlgorithmException e) {
			throw new ServiceResultException( e );
		} catch (InvalidKeyException e) {
			throw new ServiceResultException( e );
		} catch (InvalidKeySpecException e) {
			throw new ServiceResultException( e );
		} catch (NoSuchPaddingException e) {
			throw new ServiceResultException( e );
		} catch (InvalidAlgorithmParameterException e) {
			throw new ServiceResultException( e );
		} catch (IllegalBlockSizeException e) {
			throw new ServiceResultException( e );
		} catch (BadPaddingException e) {
			throw new ServiceResultException( e );
		} catch (InvalidParameterSpecException e) {
			throw new ServiceResultException( e );
		}
	}
}
package com.tiger.uatcp;

import org.opcfoundation.ua.core.MessageSecurityMode;
import org.opcfoundation.ua.transport.security.SecurityPolicy;

public class UATcpParam {
	
	private String applicationName="myClient";

	private String url;
	
	private Integer authentication;//0:匿名;1:验证用户名、密码,2:certificate,3:IssuedToken
	
	private String userName;
	
	private String password;
	
	private MessageSecurityMode securityMode;//None;Sign;Sign&Encrypt
	
	private SecurityPolicy securityPolicie;//Basic128Rsa15;Basic256;Basic256Sha256

	
	public String getApplicationName() {
		return applicationName;
	}

	public void setApplicationName(String applicationName) {
		this.applicationName = applicationName;
	}

	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public Integer getAuthentication() {
		return authentication;
	}

	public void setAuthentication(Integer authentication) {
		this.authentication = authentication;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public MessageSecurityMode getSecurityMode() {
		return securityMode;
	}

	public void setSecurityMode(MessageSecurityMode securityMode) {
		this.securityMode = securityMode;
	}

	public SecurityPolicy getSecurityPolicie() {
		return securityPolicie;
	}

	public void setSecurityPolicie(SecurityPolicy securityPolicie) {
		this.securityPolicie = securityPolicie;
	}
}

 

package com.tiger.uatcp;

import java.net.InetAddress;
import java.net.UnknownHostException;

import org.opcfoundation.ua.application.Application;
import org.opcfoundation.ua.application.Client;
import org.opcfoundation.ua.application.SessionChannel;
import org.opcfoundation.ua.builtintypes.DataValue;
import org.opcfoundation.ua.builtintypes.NodeId;
import org.opcfoundation.ua.builtintypes.StatusCode;
import org.opcfoundation.ua.common.ServiceResultException;
import org.opcfoundation.ua.core.Attributes;
import org.opcfoundation.ua.core.EndpointDescription;
import org.opcfoundation.ua.core.IdType;
import org.opcfoundation.ua.core.MessageSecurityMode;
import org.opcfoundation.ua.core.ReadResponse;
import org.opcfoundation.ua.core.ReadValueId;
import org.opcfoundation.ua.core.TimestampsToReturn;
import org.opcfoundation.ua.core.WriteResponse;
import org.opcfoundation.ua.core.WriteValue;
import org.opcfoundation.ua.transport.security.KeyPair;
import org.opcfoundation.ua.transport.security.SecurityPolicy;
import org.opcfoundation.ua.utils.EndpointUtil;

public class OpcTcpClientUtil {
	
	public static String[] read(UATcpParam param,NodeId[] nodeIds) throws ServiceResultException, UnknownHostException{
		int len=nodeIds.length;
		String[] resValue=new String[len];
		SessionChannel mySession=getSession(param);
		
		if(mySession==null){
			return null;
		}
		try{
			ReadValueId[] nodesToRead =new ReadValueId[len];
			for (int i = 0; i < len; i++) {
				ReadValueId r=new ReadValueId(nodeIds[i], Attributes.Value, null, null);
				nodesToRead[i]=r;
			}
			
			ReadResponse res = mySession.Read(null, null, TimestampsToReturn.Neither,nodesToRead);
		    DataValue[] data=res.getResults();
		    for (int i = 0; i < len; i++) {
		    	 String val = data[i].getValue().getValue().toString();
		    	 resValue[i]=val;
			}
			return resValue;
		}finally{
			mySession.close();
			mySession.closeAsync();
		}
		
	}
	
	
	public static String[] write(UATcpParam param,WriteValue[] writeValues)throws ServiceResultException, UnknownHostException{
		int len=writeValues.length;
		
		String[] resValue=new String[len];
		SessionChannel mySession=getSession(param);
		if(mySession==null){
			return null;
		}
		try{
			WriteResponse res = mySession.Write(null, writeValues);
		    StatusCode[] data=res.getResults();
		    for (int i = 0; i < len; i++) {
		    	resValue[i] = data[i].getValue().toString();
			}
		    return resValue;
		}finally{
			mySession.close();
			mySession.closeAsync();
		}
		
		
	}
	
	public static SessionChannel getSession(UATcpParam param) throws ServiceResultException, UnknownHostException{
		
		SessionChannel mySession =null;
		
		Application myClientApplication = new Application();
		 
		Client myClient = new Client(myClientApplication);
		
		if(param.getSecurityMode()!=null&&!param.getSecurityMode().equals(MessageSecurityMode.None)){
			
			 String hostName=InetAddress.getLocalHost().getHostName();
			 
			 String applicationName=param.getApplicationName();
			 
			 String applicationUri = "urn:"+hostName+":OPCUA:"+applicationName;
			 
			 KeyPair myClientApplicationInstanceCertificate = ExampleKeys.getCert(applicationName,hostName,applicationUri);
			 
			 myClientApplication.setApplicationUri(applicationUri);
			
			 myClientApplication.addApplicationInstanceCertificate(myClientApplicationInstanceCertificate);

			 EndpointDescription[] endpoints = myClient.discoverEndpoints(param.getUrl());
			 
			 endpoints = EndpointUtil.selectByProtocol(endpoints, "opc.tcp");
			 
			 endpoints = EndpointUtil.selectByMessageSecurityMode(endpoints, param.getSecurityMode());

			 if(param.getSecurityPolicie()!=null){
				 endpoints = EndpointUtil.selectBySecurityPolicy(endpoints, param.getSecurityPolicie());
			 }
			 endpoints = EndpointUtil.sortBySecurityLevel(endpoints);
			 
			 if(endpoints.length==0){
				 return null;
			 }
			 EndpointDescription endpoint = endpoints[endpoints.length - 1];
			 mySession = myClient.createSessionChannel(endpoint);
		}else{
			mySession = myClient.createSessionChannel(param.getUrl());
		}
		
		if(param.getAuthentication()==0){//用户名密码验证֤
			mySession.activate();
		}else if(param.getAuthentication()==1){
			mySession.activate(param.getUserName(), param.getPassword());
		}else{
			mySession.activate();
		}
		return mySession;
	}
	
	public static MessageSecurityMode getMessageSecurityMode(int type){
		MessageSecurityMode mode=null;
		switch(type){
			case 1:
				mode=MessageSecurityMode.None;
				break;
			case 2:
				mode=MessageSecurityMode.Sign;
				break;
			case 3:
				mode=MessageSecurityMode.SignAndEncrypt;
				break;
			default:
				mode=MessageSecurityMode.None;
				break;
		}
		return mode;
	}
	
	public static SecurityPolicy getSecurityPolicy(int type){
		SecurityPolicy policy=null;
		switch(type){
			case 1:
				policy=SecurityPolicy.BASIC128RSA15;
				break;
			case 2:
				policy=SecurityPolicy.BASIC256;
				break;
			case 3:
				policy=SecurityPolicy.BASIC256SHA256;
				break;
			default:
				policy=SecurityPolicy.BASIC128RSA15;
				break;
		}
		return policy;
	}
	
	public static int getNs(String nodeIdStr){
		String[] addrArr=nodeIdStr.split(";");
		String[] nsArr=addrArr[0].split("=");
		return Integer.parseInt(nsArr[1]);
	}
	
	public static String getId(String nodeIdStr){
		String[] addrArr=nodeIdStr.split(";");
		String[] idArr=addrArr[1].split("=");
		return idArr[1];
	}
	
	public static IdType getIdType(String nodeIdStr) {
		String[] addrArr=nodeIdStr.split(";");
		String[] addr=addrArr[1].split("=");
		String type=addr[0];
		if (type.equals("i"))
			return IdType.Numeric;
		if (type.equals("s")) 
			return IdType.String;
		if (type.equals("g") ) 
			return IdType.Guid;
		if (type.equals("b")  ) {
			return IdType.Opaque;
		}
		return IdType.String;
	}
}
package com.tiger.uatcp;

import java.net.UnknownHostException;

import org.opcfoundation.ua.builtintypes.DataValue;
import org.opcfoundation.ua.builtintypes.NodeId;
import org.opcfoundation.ua.builtintypes.Variant;
import org.opcfoundation.ua.common.ServiceResultException;
import org.opcfoundation.ua.core.Attributes;
import org.opcfoundation.ua.core.IdType;
import org.opcfoundation.ua.core.MessageSecurityMode;
import org.opcfoundation.ua.core.WriteValue;
import org.opcfoundation.ua.transport.security.SecurityPolicy;

public class TestOpcTcpClientUtil {
	
	private final static String url="opc.tcp://Atiger:53530/OPCUA/SimulationServer";
	
	private static void testRead() throws ServiceResultException, UnknownHostException{
		NodeId[] nodeIds=new NodeId[2];
		
		nodeIds[0]=NodeId.get(IdType.String,5, "Random1");
		nodeIds[1]=NodeId.get(IdType.String, 5, "Counter1");
		
		UATcpParam param=new UATcpParam();
		param.setUrl(url);
		param.setAuthentication(0);
		//param.setUserName("admin");
		//param.setPassword("admin");
		param.setSecurityMode(MessageSecurityMode.None);
		//param.setSecurityPolicie(SecurityPolicy.BASIC128RSA15);
		
		String[] result=OpcTcpClientUtil.read(param, nodeIds);
		for (String rs : result) {
			System.out.println(rs);
		}
	}
	
	
	private static void testWrite() throws ServiceResultException, UnknownHostException{
		UATcpParam param=new UATcpParam();
		param.setUrl(url);
		param.setAuthentication(0);
		//param.setUserName("admin");
		//param.setPassword("admin");
		
		param.setSecurityMode(MessageSecurityMode.None);
		//param.setSecurityPolicie(SecurityPolicy.BASIC128RSA15);
		
		NodeId nodeId1=NodeId.get(IdType.String,5, "Random1");
		NodeId nodeId2=NodeId.get(IdType.String, 5, "Counter1");
		
		WriteValue v1=new WriteValue(nodeId1, Attributes.Value, null, new DataValue(new Variant(new Double(0.5))));
		WriteValue v2=new WriteValue(nodeId2, Attributes.Value, null, new DataValue(new Variant(300)));
		
	    WriteValue[] nodesToWrite = {v1,v2};
		String[] result=OpcTcpClientUtil.write(param, nodesToWrite);
		for (String rs : result) {
			System.out.println(rs);
		}
	}
	
	private static void testReadNodeStr() throws UnknownHostException, ServiceResultException{
		UATcpParam param=new UATcpParam();
		param.setUrl(url);
		param.setAuthentication(0);
		//param.setUserName("admin");
		//param.setPassword("admin");
		
		param.setSecurityMode(MessageSecurityMode.None);
		//param.setSecurityPolicie(SecurityPolicy.BASIC128RSA15);
		
		String nodeIdStr1="ns=5;s=Random1";
		String nodeIdStr2="ns=5;s=Counter1";
		
		NodeId[] nodeIds=new NodeId[2];
		
		
		nodeIds[0]=NodeId.get(OpcTcpClientUtil.getIdType(nodeIdStr1),OpcTcpClientUtil.getNs(nodeIdStr1), OpcTcpClientUtil.getId(nodeIdStr1));
		nodeIds[1]=NodeId.get(OpcTcpClientUtil.getIdType(nodeIdStr2),OpcTcpClientUtil.getNs(nodeIdStr2), OpcTcpClientUtil.getId(nodeIdStr2));
		
		String[] result=OpcTcpClientUtil.read(param, nodeIds);
		for (String rs : result) {
			System.out.println(rs);
		}
		
	}
	
	public static void main(String[] args) {
		try {
			testWrite();
			testRead();
			testReadNodeStr();
		} catch (ServiceResultException e) {
			e.printStackTrace();
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

5.补充说明

 

 

 

OPC UA是一种通讯协议,它被广泛应用于工业自动化领域,在制造业、能源领域、交通运输领域等行业都有着广泛的应用。而Java作为一种广泛应用的编程语言,也可以用来实现OPC UA通讯。下面将介绍一些OPC UA Java案例。 1、Eclipse Milo Eclipse Milo是一个基于Java的开源OPC UA实现,它提供了一系列的API,可以用来开发OPC UA客户端和服务器。Eclipse Milo提供了完整的OPC UA协议栈,并支持了多种平台,包括Windows、Linux等。Eclipse Milo还提供了一些示例代码以供使用者参考。 2、Prosys OPC UA Java SDK Prosys OPC UA Java SDK是一个商业化的OPC UA Java实现,它提供了一系列的类库和工具,可以用来开发OPC UA客户端和服务器,包括面向对象的API、多种协议支持、安全通讯等功能。Prosys OPC UA Java SDK还提供了示例代码以供使用者参考。 3、OPC UA Java Client OPC UA Java Client是一个Java实现的OPC UA客户端库,可以用于基于Java的应用程序中。它提供了一系列的API,可以用来连接到OPC UA服务器,获取数据等功能。OPC UA Java Client还提供了示例代码以供使用者参考。 4、kOpc-UA SDK kOpc-UA SDK是一个基于JavaOPC UA实现,它提供了一系列的类库和工具,可以用来开发OPC UA客户端和服务器。kOpc-UA SDK具有良好的跨平台性,支持多种协议,包括TCP、HTTPS和WebSocket等。kOpc-UA SDK还提供了一些示例代码以供使用者参考。 总之,目前有许多基于JavaOPC UA实现,这些工具可以用来开发OPC UA客户端和服务器。新增中小企业也可以通过使用这些工具来实现自动化领域的数字化转型,并提高自身竞争力。
评论 46
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值