CyrilShine
CyrilShine

OPC UA Client read、write、history read（Java）

本文代码基于opc-ua-java-stack-1.02-source-code-and-sample-applications-337.2-stable
源码官网链接

  1. 参数信息类型
package OpcUa;

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

public class UAParam {
	
	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;
	}
}
  1. 证书类
package OpcUa;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.Certificate;
import java.security.cert.CertificateEncodingException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.security.interfaces.RSAPrivateKey;
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;

/**
 * Keys for examples
 * Keystore.p12 contains 20 RSA keypairs with the following aliases
 * 
 * alias               dname
 * 
 * server_8192         CN=server 
 * server_4096         CN=server 
 * server_2048         CN=server
 * server_1024         CN=server
 * server_512          CN=server
 * 
 * client_8192         CN=client
 * client_4096         CN=client
 * client_2048         CN=client
 * client_1024         CN=client
 * client_512          CN=client
 * 
 * https_server_8192   CN=https_server
 * https_server_4096   CN=https_server
 * https_server_2048   CN=https_server
 * https_server_1024   CN=https_server
 * https_server_512    CN=https_server
 * 
 * https_client_8192   CN=https_client
 * https_client_4096   CN=https_client
 * https_client_2048   CN=https_client
 * https_client_1024   CN=https_client
 * https_client_512    CN=https_client
 * 
 * Keystore password is "password".
 * Private key passwords are "password".
 *
 */
public class ExampleKeys {
	
	private static final String PRIVKEY_PASSWORD = "Opc.Ua";
	
	/**
	 * Load file certificate and private key from applicationName.der & .pfx - or create ones if they do not exist
	 * @return the KeyPair composed of the certificate and private key
	 * @throws ServiceResultException
	 */
	public static KeyPair getCert1(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 );
		}
	}

	/**
	 * Load file certificate and private key from applicationName.der & .pfx - or create ones if they do not exist
	 * @return the KeyPair composed of the certificate and private key
	 * @throws ServiceResultException
	 */
	public static KeyPair getCert(String applicationName)
	throws ServiceResultException
	{
		File certFile = new File(applicationName + ".der");
		File privKeyFile =  new File(applicationName+ ".pem");
		try {
			Cert myServerCertificate = Cert.load( certFile );
			PrivKey myServerPrivateKey = PrivKey.loadFromKeyStore( privKeyFile, PRIVKEY_PASSWORD );
			return new KeyPair(myServerCertificate, myServerPrivateKey); 
		} catch (CertificateException e) {
			throw new ServiceResultException( e );
		} catch (IOException e) {		
			try {
				String hostName = InetAddress.getLocalHost().getHostName();
				String applicationUri = "urn:"+hostName+":"+applicationName;
				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 (UnrecoverableKeyException e) {
			throw new ServiceResultException( e );
		} catch (NoSuchAlgorithmException e) {
			throw new ServiceResultException( e );
		} catch (KeyStoreException e) {
			throw new ServiceResultException( e );
		}
	}

	/**
	 * Load CA certificate and private key from SampleCA.der & .pfx - or create ones if they do not exist
	 * @return the KeyPair composed of the certificate and private key
	 * @throws ServiceResultException
	 */
	public static KeyPair getCACert()
	throws ServiceResultException
	{
		File certFile = new File("SampleCA.der");
		File privKeyFile =  new File("SampleCA.pem");
		try {
			Cert myServerCertificate = Cert.load( certFile );
			PrivKey myServerPrivateKey = PrivKey.loadFromKeyStore( privKeyFile, PRIVKEY_PASSWORD );
			return new KeyPair(myServerCertificate, myServerPrivateKey); 
		} catch (CertificateException e) {
			throw new ServiceResultException( e );
		} catch (IOException e) {		
			try {
				KeyPair keys = CertificateUtils.createIssuerCertificate("SampleCA", 3650, null);
				keys.getCertificate().save(certFile);
				keys.getPrivateKey().save(privKeyFile, PRIVKEY_PASSWORD);
				return keys;
			} catch (Exception e1) {
				throw new ServiceResultException( e1 );
			}
		} catch (UnrecoverableKeyException e) {
			throw new ServiceResultException( e );
		} catch (NoSuchAlgorithmException e) {
			throw new ServiceResultException( e );
		} catch (KeyStoreException e) {
			throw new ServiceResultException( e );
		}
	}
	/**
	 * Load file certificate and private key from applicationName.der & .pfx - or create ones if they do not exist
	 * @param applicationName
	 * @param caKey 
	 * @return the KeyPair composed of the certificate and private key
	 * @throws ServiceResultException
	 */
	public static KeyPair getHttpsCert(String applicationName)
	throws ServiceResultException
	{
		File certFile = new File(applicationName + "_https.der");
		File privKeyFile =  new File(applicationName+ "_https.pem");
		try {
			Cert myServerCertificate = Cert.load( certFile );
			PrivKey myServerPrivateKey = PrivKey.loadFromKeyStore( privKeyFile, PRIVKEY_PASSWORD );
			return new KeyPair(myServerCertificate, myServerPrivateKey); 
		} catch (CertificateException e) {
			throw new ServiceResultException( e );
		} catch (IOException e) {		
			try {
				KeyPair caCert = CertificateUtils.createIssuerCertificate(applicationName, 3650, null);;//getCACert();
				String hostName = InetAddress.getLocalHost().getHostName();
				String applicationUri = "urn:"+hostName+":"+applicationName;
				KeyPair keys = CertificateUtils.createHttpsCertificate(hostName, applicationUri, 3650, caCert);
				keys.getCertificate().save(certFile);
				keys.getPrivateKey().save(privKeyFile, PRIVKEY_PASSWORD);
				return keys;
			} catch (Exception e1) {
				throw new ServiceResultException( e1 );
			}
		} catch (UnrecoverableKeyException e) {
			throw new ServiceResultException( e );
		} catch (NoSuchAlgorithmException e) {
			throw new ServiceResultException( e );
		} catch (KeyStoreException e) {
			throw new ServiceResultException( e );
		}
	}
	/**
	 * Open keypair from keystore.p12 used in some of these examples.
	 * 
	 * Usable aliases are : "server", "client", "https_server", "https_client"
	 * Usable keysizes are : 8192, 4096, 2048, 1024
	 * 
	 * @param alias 
	 * @param keysize 
	 * @return
	 * @throws KeyStoreException 
	 * @throws IOException 
	 * @throws CertificateException 
	 * @throws NoSuchAlgorithmException 
	 * @throws UnrecoverableKeyException 
	 */
//	public static KeyPair getKeyPair(String alias, int keysize) throws ServiceResultException {
//		try {
//			Certificate cert = ks.getCertificate(alias+"_"+keysize);
//			Key key = ks.getKey(alias+"_"+keysize, "password".toCharArray());			
//			KeyPair pair = new KeyPair( new Cert( (X509Certificate) cert ), new PrivKey( (RSAPrivateKey) key ) );
//			return pair;
//		} catch (KeyStoreException e) {
//			throw new ServiceResultException( e );
//		} catch (UnrecoverableKeyException e) {
//			throw new ServiceResultException( e );
//		} catch (NoSuchAlgorithmException e) {
//			throw new ServiceResultException( e );
//		} catch (CertificateEncodingException e) {
//			throw new ServiceResultException( e );
//		}			
//	}	
//	
//	static KeyStore ks;
//	
//	static {
//		try {
//			ks = KeyStore.getInstance("pkcs12");
//			InputStream is = ExampleKeys.class.getResourceAsStream("keystore.p12");
//			try {
//				ks.load( is, "password".toCharArray() );
//			} catch (NoSuchAlgorithmException e) {
//				throw new RuntimeException(e);
//			} catch (CertificateException e) {
//				throw new RuntimeException(e);
//			} catch (IOException e) {
//				throw new RuntimeException(e);
//			} finally {
//				try {
//					is.close();
//				} catch (IOException e) {
//				}
//			}
//		} catch (KeyStoreException e) {
//			throw new RuntimeException(e);
//		}
//	}
	
	
}
  1. 工具类
package OpcUa;

import static org.opcfoundation.ua.utils.EndpointUtil.selectByProtocol;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.UUID;

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.DateTime;
import org.opcfoundation.ua.builtintypes.ExpandedNodeId;
import org.opcfoundation.ua.builtintypes.ExtensionObject;
import org.opcfoundation.ua.builtintypes.NodeId;
import org.opcfoundation.ua.builtintypes.QualifiedName;
import org.opcfoundation.ua.builtintypes.StatusCode;
import org.opcfoundation.ua.builtintypes.UnsignedInteger;
import org.opcfoundation.ua.builtintypes.Variant;
import org.opcfoundation.ua.common.ServiceFaultException;
import org.opcfoundation.ua.common.ServiceResultException;
import org.opcfoundation.ua.core.Attributes;
import org.opcfoundation.ua.core.BrowseDescription;
import org.opcfoundation.ua.core.BrowseDirection;
import org.opcfoundation.ua.core.BrowseResponse;
import org.opcfoundation.ua.core.BrowseResult;
import org.opcfoundation.ua.core.BrowseResultMask;
import org.opcfoundation.ua.core.EndpointDescription;
import org.opcfoundation.ua.core.HistoryData;
import org.opcfoundation.ua.core.HistoryReadResponse;
import org.opcfoundation.ua.core.HistoryReadResult;
import org.opcfoundation.ua.core.HistoryReadValueId;
import org.opcfoundation.ua.core.IdType;
import org.opcfoundation.ua.core.MessageSecurityMode;
import org.opcfoundation.ua.core.NodeClass;
import org.opcfoundation.ua.core.ReadRawModifiedDetails;
import org.opcfoundation.ua.core.ReadResponse;
import org.opcfoundation.ua.core.ReadValueId;
import org.opcfoundation.ua.core.ReferenceDescription;
import org.opcfoundation.ua.core.TimestampsToReturn;
import org.opcfoundation.ua.core.WriteResponse;
import org.opcfoundation.ua.core.WriteValue;
import org.opcfoundation.ua.encoding.EncoderContext;
import org.opcfoundation.ua.transport.security.KeyPair;
import org.opcfoundation.ua.transport.security.SecurityPolicy;
import org.opcfoundation.ua.utils.EndpointUtil;
import org.opcfoundation.ua.utils.NumericRange;
import org.opcfoundation.ua.utils.StackUtils;

public class OpcUaUtil {
	public static long num = 0;
	private final static String url1 = "opc.tcp://xxxxx:53530/OPCUA/SimulationServer";
	private final static String url2 = "https://xxxxx:53443/OPCUA/SimulationServer";
	private static SessionChannel session = null;
	
	static{
		UAParam param = new UAParam();
		param.setUrl(url1);//tcp or https
		param.setAuthentication(1);
		param.setUserName("Cyril");
		param.setPassword("123123");
//		param.setSecurityMode(MessageSecurityMode.None);
		param.setSecurityMode(MessageSecurityMode.SignAndEncrypt);
		param.setSecurityPolicie(SecurityPolicy.BASIC256SHA256);
		try {
			session = getSession(param);
		} catch (UnknownHostException | ServiceResultException e) {
			e.printStackTrace();
			session = null;
		}
	}
	public static SessionChannel getSession() {
		return session;
	}
	public static SessionChannel getSession(UAParam param) throws ServiceResultException, UnknownHostException{
		String hostName = InetAddress.getLocalHost().getHostName();
		String applicationName = param.getApplicationName();
		String applicationUri = "urn:"+hostName+":OPCUA:"+applicationName;
		SessionChannel mySession =null;
		Application myClientApplication = new Application();
		Client myClient = new Client(myClientApplication);
		if(param.getSecurityMode()!=null&&!param.getSecurityMode().equals(MessageSecurityMode.None)){
			
			//证书要在Server端信任
			KeyPair myClientApplicationInstanceCertificate = ExampleKeys.getCert1(applicationName,hostName,applicationUri);
			myClientApplication.setApplicationUri(applicationUri);
			myClientApplication.addApplicationInstanceCertificate(myClientApplicationInstanceCertificate);
			KeyPair myHttpsCertificate = ExampleKeys.getHttpsCert("httpsClient");
			myClientApplication.getHttpsSettings().setKeyPair(myHttpsCertificate);
			
			////////// DISCOVER ENDPOINT /////////
			// Discover server's endpoints, and choose one
			EndpointDescription[] endpoints = myClient.discoverEndpoints(param.getUrl());
			// Filter out all but opc.tcp protocol endpoints
			if (param.getUrl().startsWith("opc.tcp")){
				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);
			}else{
				endpoints = selectByProtocol(endpoints, "https");
				EndpointDescription[] np = new EndpointDescription[1];
				np[0] = endpoints[0];
				endpoints = np;
			}
			//////////////////////////////////////
			
			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;
	}
	
	
	/**
	 * History Read
	 * 
	 * @param mySession SessionChannel
	 * @param nodeIdStrs List String => "ns=5;s=Random1"
	 * @param startTime Format => yyyy-MM-dd hh:mm:ss:SSS CST=>GMT
	 * @param endTime Format => yyyy-MM-dd hh:mm:ss:SSS CST=>GMT
	 */
	public static DataValue[] historyRead(SessionChannel mySession,List nodeIdStrs,String startTime,String endTime) 
			throws ServiceFaultException, ServiceResultException, ParseException{
		if(mySession==null)
			mySession = session;
		if(nodeIdStrs==null || nodeIdStrs.size()<1)
			return null;
		List nodeIdList = new ArrayList<>();
		for (String nis : nodeIdStrs) {
			nodeIdList.add(NodeId.get(getIdType(nis),getNs(nis), getId(nis)));
		}
		
		ReadRawModifiedDetails rrmd = new ReadRawModifiedDetails();
		rrmd.setIsReadModified(false);
		
		SimpleDateFormat ff = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss:SSS");
		Date s1 = ff.parse(startTime);
		Date s2 = ff.parse(endTime);
		Calendar calendar1 = Calendar.getInstance();
		calendar1.setTimeZone(TimeZone.getTimeZone("GMT"));
		calendar1.setTime(s1);
		Calendar calendar2 = Calendar.getInstance();
		calendar2.setTimeZone(TimeZone.getTimeZone("GMT"));
		calendar2.setTime(s2);
		
		rrmd.setStartTime(new DateTime(calendar1.get(Calendar.YEAR),calendar1.get(Calendar.MONTH),calendar1.get(Calendar.DAY_OF_MONTH)
				,calendar1.get(Calendar.HOUR),calendar1.get(Calendar.MINUTE),calendar1.get(Calendar.SECOND),calendar1.get(Calendar.MILLISECOND)));
		rrmd.setEndTime(new DateTime(calendar2.get(Calendar.YEAR),calendar2.get(Calendar.MONTH),calendar2.get(Calendar.DAY_OF_MONTH)
				,calendar2.get(Calendar.HOUR),calendar2.get(Calendar.MINUTE),calendar2.get(Calendar.SECOND),calendar2.get(Calendar.MILLISECOND)));
		
		rrmd.setNumValuesPerNode(UnsignedInteger.getFromBits(1000));
		rrmd.setReturnBounds(true);
		ExtensionObject eo = ExtensionObject.encode(rrmd, QualifiedName.DEFAULT_BINARY_ENCODING, StackUtils.getDefaultSerializer(), 
				EncoderContext.getDefaultInstance());
		
		HistoryReadValueId[] NodesToRead = new HistoryReadValueId[nodeIdStrs.size()];
		for (int i = 0; i < NodesToRead.length; i++) {
			HistoryReadValueId hrvi = new HistoryReadValueId();
			hrvi.setNodeId(nodeIdList.get(i));
			NumericRange parsedIndexRange = new NumericRange(-1);
			hrvi.setParsedIndexRange(parsedIndexRange);
			NodesToRead[i] = hrvi;
		}
		
		HistoryReadResponse resp = mySession.HistoryRead(null, eo, TimestampsToReturn.Source, false, NodesToRead);
		HistoryReadResult[] hrr = resp.getResults();
		for (HistoryReadResult historyReadResult : hrr) {
			HistoryReadResult tt = historyReadResult;
			ExtensionObject dc = tt.getHistoryData();
			HistoryData data = ((ExtensionObject) dc).decode(StackUtils.getDefaultSerializer(), EncoderContext.getDefaultInstance(), null);
			DataValue[] dataArr = data.getDataValues();
			return dataArr;
		}
		return null;
	}
	
	/**
	 * Write Nodes
	 * 
	 * @param mySession SessionChannel
	 * @param nodeIdStrs List String => "ns=5;s=Random1"
	 * @param values datas for write
	 */
	public static boolean writeNodes(SessionChannel mySession,List nodeIdStrs,List values){
		if(mySession==null)
			mySession = session;
		if(nodeIdStrs==null)
			return false;
		int len=nodeIdStrs.size();
		String[] resValue=new String[len];
		try{
			List vList = new ArrayList<>();
			for (int i = 0; i < nodeIdStrs.size(); i++) {
				NodeId nid = NodeId.get(getIdType(nodeIdStrs.get(i)),getNs(nodeIdStrs.get(i)), getId(nodeIdStrs.get(i)));
				WriteValue v1 = new WriteValue(nid, Attributes.Value, null, new DataValue(new Variant(values.get(i))));
				vList.add(v1);
			}
			WriteValue[] writeValues = vList.toArray(new WriteValue[vList.size()]);
			WriteResponse res = mySession.Write(null, writeValues);
		    StatusCode[] data=res.getResults();
		    for (int i = 0; i < len; i++) {
		    	resValue[i] = data[i].getValue().toString();
			}
		    return true;
		} catch (ServiceResultException e) {
			e.printStackTrace();
		}
		return false;
	}
	
	/**
	 * Read Nodes
	 * 
	 * @param mySession SessionChannel
	 * @param nodeIdStrs List String => "ns=5;s=Random1"
	 */
	public static List readNodes(SessionChannel mySession,List nodeIdStrs){
		if(mySession==null)
			mySession = session;
		List result = new ArrayList();
		if(nodeIdStrs==null)
			return null;
		List nodeIdList = new ArrayList<>();
		for (String nis : nodeIdStrs) {
			nodeIdList.add(NodeId.get(getIdType(nis),getNs(nis), getId(nis)));
		}
		int len = nodeIdList.size();
		String[] resValue=new String[len];
		NodeId[] nodeIds = new NodeId[len];
		nodeIdList.toArray(nodeIds);
		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++) {
		    	Object v = data[i].getValue().getValue();
		    	String val = null;
		    	if(v!=null)
		    		val = v.toString();
		    	resValue[i] = val;
		    }
		    for (String v : resValue) {
		    	result.add(v);
			}
		} catch (ServiceResultException e) {
			e.printStackTrace();
		}
		return result;
	} 
	
	/**
	 * Browse Single Node
	 * 
	 * @param mySession SessionChannel
	 * @param nodeIdStr String => "ns=5;s=Random1"
	 */
	public static List browseNode(SessionChannel mySession,String nodeIdStr) throws ServiceFaultException, ServiceResultException{
		List list = new ArrayList<>();
		if(mySession==null)
			mySession = session;
		NodeId nodeId = NodeId.get(getIdType(nodeIdStr),getNs(nodeIdStr), getId(nodeIdStr));
		BrowseDescription browse = new BrowseDescription();
		browse.setNodeId(nodeId);
		browse.setBrowseDirection(BrowseDirection.Forward);
		browse.setIncludeSubtypes(true);
		browse.setNodeClassMask(NodeClass.Object/*,NodeClass.ObjectType*/,NodeClass.Variable);//可选
		browse.setResultMask(BrowseResultMask.All);//可选
		BrowseResponse res3 = mySession.Browse(null, null, null, browse);
		BrowseResult[] browseResults = res3.getResults();
		for (BrowseResult re : browseResults) {
			ReferenceDescription[] reference = re.getReferences();
			list.add(reference);
		}
		return list;
	}

	/**
	 * Browse All Sub Nodes From A Given Node
	 * 
	 * @param mySession SessionChannel
	 * @param nodeIdStr "ns=5;s=Random1"
	 */
	public static void deepBrowseNode(SessionChannel mySession,String nodeIdStr,Map map,Integer n) throws ServiceFaultException, ServiceResultException{
		if(nodeIdStr == null)
			return;
		String space = "";
		for (int i = 0; i < n; i++) {
			space += "";
		}
		String s1 = String.format("%-4d", OpcUaUtil.num);
		String s2 = String.format("%-3d", n);
		System.out.println(s1+" "+s2+" : "+space+nodeIdStr);
		OpcUaUtil.num++;
		List list = OpcUaUtil.browseNode(mySession, nodeIdStr);
		for (ReferenceDescription[] referenceDescriptions : list) {
			if(referenceDescriptions==null)
				System.out.println("null");
			else{
				for (ReferenceDescription rd : referenceDescriptions) {
					ExpandedNodeId nid = rd.getNodeId();
					nodeIdStr = "ns="+nid.getNamespaceIndex()+";"+getIdType2(nid.getIdType())+"="+nid.getValue();
					deepBrowseNode(mySession,nodeIdStr,map,n+1);
				}
			}
		}
		return;
	}
	
	public static Object getId(String nodeIdStr){
		String[] addrArr=nodeIdStr.split(";");
		String[] idArr=addrArr[1].split("=");
		String type=idArr[0];
		if (type.equals("i"))
			return UnsignedInteger.getFromBits(Integer.valueOf(idArr[1]));
//		if (type.equals("s")) 
//			return idArr.String;
		if (type.equals("g") ) 
			return UUID.fromString(idArr[1]);
//		if (type.equals("b")  ) {
//			return UUID.fromString(idArr[1]);
//		}
		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;
	}
	
	public static String getIdType2(IdType type) {
		if (type.equals(IdType.Numeric))
			return "i";
		if (type.equals(IdType.String)) 
			return "s";
		if (type.equals(IdType.Guid) ) 
			return "g";
		if (type.equals(IdType.Opaque)  ) {
			return "b";
		}
		return "s";
	}
	
	public static int getNs(String nodeIdStr){
		String[] addrArr=nodeIdStr.split(";");
		String[] nsArr=addrArr[0].split("=");
		return Integer.parseInt(nsArr[1]);
	}
	
}
 
  
     
   
  1. 测试类
    2.  
  
 
  
package OpcUa;

import java.net.UnknownHostException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;
import java.util.TimeZone;

import org.opcfoundation.ua.application.SessionChannel;
import org.opcfoundation.ua.builtintypes.DataValue;
import org.opcfoundation.ua.builtintypes.DateTime;
import org.opcfoundation.ua.builtintypes.ExpandedNodeId;
import org.opcfoundation.ua.common.ServiceResultException;
import org.opcfoundation.ua.core.ReferenceDescription;

import utils.OpcUaUtil;

public class OpcTest {
	public static void main(String[] args) throws UnknownHostException, ServiceResultException, ParseException {
		SessionChannel session = OpcUaUtil.getSession();
		
		//read
		List list = Arrays.asList("ns=5;s=Counter1");
		List re = OpcUaUtil.readNodes(session, list);
		for (String string : re) {
			System.out.println(string);
		}
		
		//browse
/*		String nodeIdStr = "ns=0;i=3048";
		List list = OpcUaUtil.browseNode(session, nodeIdStr);
		for (ReferenceDescription[] referenceDescriptions : list) {
			if(referenceDescriptions==null)
				System.out.println("null");
			else{
				for (ReferenceDescription rd : referenceDescriptions) {
					ExpandedNodeId nid = rd.getNodeId();
					System.out.println("ns="+nid.getNamespaceIndex()+";"+OpcUaUtil.getIdType2(nid.getIdType())+"="+nid.getValue());
				}
			}
		}*/
		
/*		//deep browse
		String nodeIdStr = "ns=0;i=2311";
		OpcUaUtil.deepBrowseNode(session,nodeIdStr,null,0);*/

		//historyRead
/*		SimpleDateFormat bjSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
		bjSdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));  // 设置北京时区
		
		List list = Arrays.asList("ns=5;s=Random1");
		DataValue[] re = OpcUaUtil.historyRead(session, list, "2018-12-07 08:45:00:000", "2018-12-07 08:45:10:000");
		for (DataValue dataValue : re) {
			DateTime dt = dataValue.getSourceTimestamp();
			Calendar cc = dt.getUtcCalendar();
			System.out.println(String.format("%-25s", dataValue.getValue())+" "+bjSdf.format(cc.getTime()));
		}*/
		

		
		//write
/*		List sList = Arrays.asList("ns=3;s=Duration");
		List vList = Arrays.asList(new Double(33));
		boolean re = OpcUaUtil.writeNodes(null, sList, vList);
		System.out.println(re);*/
		
		session.close();
		session.closeAsync();
	}
}
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(OPC UA Client read、write、history read（Java）)

        

            

                
    
                    
  • 华为OD机试E卷 - 最优资源分配/芯片资源占用（Java & Python& JS & C++ & C ）
                        算法大师
最新华为OD机试华为华为od华为OD机试E卷pythonjavajavascriptc++
                        
    最新华为OD机试真题目录：点击查看目录华为OD面试真题精选：点击立即查看题目描述某块业务芯片最小容量单位为1.25G，总容量为M*1.25G，对该芯片资源编号为1，2，…，M。该芯片支持3种不同的配置，分别为A、B、C。配置A：占用容量为1.25*1=1.25G配置B：占用容量为1.25*2=2.5G配置C：占用容量为1.25*8=10G某块板卡上集成了N块上述芯片，对芯片编号为1，2，…，N，各
    
                    
    • 
                    
  • 华为OD机试 - 微服务的集成测试（Java & Python& JS & C++ & C ）
                        算法大师
最新华为OD机试华为华为OD华为od华为机试算法
                        
    最新华为OD机试真题目录：点击查看目录华为OD面试真题精选：点击立即查看题目描述现在有n个容器服务，服务的启动可能有一定的依赖性（有些服务启动没有依赖），其次服务自身启动加载会消耗一些时间。给你一个nxn的二维矩阵useTime，其中useTime[i][i]=10表示服务i自身启动加载需要消耗10suseTime[i][j]=1表示服务i启动依赖服务j启动完成useTime[i][k]=0表示服
    
                    
    • 
                    
  • leetcode——两数相加（java）
                        gentle_ice
leetcodejava算法
                        
    给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字0之外，这两个数都不会以0开头。示例1：输入：l1=[2,4,3],l2=[5,6,4]输出：[7,0,8]解释：342+465=807.示例2：输入：l1=[0],l2=[0]输出：[0]示例3：输入：l1=[9,9,9
    
                    
    • 
                    
  • 11 C++11线程使用
                        Snow__Sunny
#C++11c++开发语言
                        
    声明：该文章转载自此篇文章，欢迎大家支持关注原作者！C++11之前，C++语言没有对并发编程提供语言级别的支持，这使得我们在编写可移植的并发程序时，存在诸多的不便。现在C++11中增加了线程以及线程相关的类，很方便地支持了并发编程，使得编写的多线程程序的可移植性得到了很大的提高。C++11中提供的线程类叫做std::thread，基于这个类创建一个新的线程非常的简单，只需要提供线程函数或者函数对象
    
                    
    • 
                    
  • C++11线程使用
                        Jason_Lee155
车联网程序算法c++多线程
                        
    线程概念C++11引入了thread类，大大降低了多线程使用的复杂度，原先使用多线程只能用系统的API，无法解决跨平台问题，一套代码平台移植，对应多线程代码也必须要修改。现在在C++11中只需使用语言层面的thread可以解决这个问题。所需头文件：#include构造函数1.默认构造函数thread()noexcept//不会产生异常一个空的std::thread执行对象2.初始化构造函数temp
    
                    
    • 
                    
  • python实现get请求
                        admin``
Pythonpythonhttp
                        
    python——get请求importurllib.requesturl="http://www.csdn.net"response=urllib.request.urlopen(url)#打印请求的状态码print(response.getcode())msg=response.read()#打印请求的网页内容的长度print(len(msg))输出：2001148023Processfinis
    
                    
    • 
                    
  • react.js 监听页面滚动事件
                        伟大的python程序员
react.jsreact.js
                        
    componentDidMount(){window.addEventListener('scroll',this.handleScroll);}handleScroll=(event)=>{//滚动条高度letctx=this;letclientHeight=document.documentElement.clientHeight;//可视区域高度letscrollTop=document.d
    
                    
    • 
                    
  • 链表相交问题（双指针法）（java和c语言）
                        野犬寒鸦
链表c语言算法java
                        
    问题描述给你两个单链表的头节点headA和headB，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回null。方法：双指针一种高效的方法是使用两个指针，分别从两个链表的头部开始遍历。当一个指针到达链表末尾时，它切换到另一个链表的头部继续遍历。如果两个链表相交，那么这两个指针一定会在某一点相遇，这个相遇点就是相交的起始节点。实现思路初始化两个指针：分别指向链表A和链表B的头节点。
    
                    
    • 
                    
  • java基础加强四（反射，代理模式，自定义注解）
                        咸鱼太咸
从新开始java反射
                        
    一、反射反射机制是java中一个很强大的功能，可以跳过jvm实例化对象的过程，直接实例化类的class对象，然后直接操作class对象，再运行过程中，几乎可以得到任何一个类的属性和方法，能够调用任何一个对象的方法和属性。Class对象：一个类的描述，存储了类的信息。看一下api：比如一个类叫Demo，在jvm加载的时候就会创建一个class对象，里边存储了Demo类的信息，有什么属性，方法，构造器
    
                    
    • 
                    
  • java线程间如何通信
                        一只爪子
javajvm开发语言
                        
    Java线程之间可以通过以下方式进行通信：使用wait()和notify()方法，这需要使用同步代码块或同步方法。在同步代码块或同步方法中，线程可以调用wait()方法阻塞，并在其他线程调用notify()方法后恢复执行。使用CountDownLatch，它是一个同步辅助类，可以让一个线程等待其他线程的完成。使用CyclicBarrier，它也是一个同步辅助类，可以让多个线程在某个点上等待，直到所
    
                    
    • 
                    
  • Node CLI 之 Commander.js (1)
                        史一试
脚手架javascript开发语言ecmascript
                        
    官网地址：https://github.com/tj/commander.js/blob/f1ae2db8e2da01d6efcbfd59cbf82202f864b0c1/Readme_zh-CN.mdCommander.js是node.js命令行界面的完整解决方案开始新建一个node工程执行npminstallcommanderpackage.json中新增代码添加#!/usr/bin/envn
    
                    
    • 
                    
  • 《Effective Java》学习笔记——第7部分并发
                        Suwg209
EffectiveJava最佳实践笔记java学习笔记
                        
    文章目录一、前言二、并发最佳实践1.优先使用现有的并发库2.避免共享可变数据3.最小化锁的持有时间4.使用合适的同步策略5.使用volatile变量来避免缓存问题6.避免死锁7.使用ExecutorService管理线程8.优先使用无锁并发工具三、小结一、前言《EffectiveJava》第7部分“并发”介绍了如何编写高效、安全的多线程程序。随着多核处理器的普及，Java的并发编程变得更加重要。本
    
                    
    • 
                    
  • 《Effective Java》学习笔记--第3部分 方法设计和实现最佳实践
                        Suwg209
EffectiveJava最佳实践笔记java学习笔记
                        
    文章目录第3部分方法设计和实现一、前言二、方法设计和实现最佳实践1.方法的参数要尽量少2.避免使用过多的返回值3.避免在方法中返回null4.方法要尽量做到单一职责5.使用合适的访问修饰符6.避免方法内部的过多的条件分支7.使用适当的异常处理8.考虑方法的线程安全性三、小结第3部分方法设计和实现一、前言《EffectiveJava》共有多个章节，每个章节提供了若干条建议或最佳实践，整理了对应章节关
    
                    
    • 
                    
  • 《手写Mybatis渐进式源码实践》实践笔记 (第三章 映射器的注册和使用)
                        Suwg209
手写mybatismybatis笔记java数据库
                        
    文章目录第3章映射器的注册和使用背景特点结构代码示例（Java）适用场景优点缺点目标设计实现工程代码类图实现步骤1.映射器注册机2.SqlSession标准定义和实现3.SqlSessionFactory工厂定义和实现测试事先准备测试用例测试结果总结第3章映射器的注册和使用背景工厂模式（FactoryMethodPattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但允许子类决定实
    
                    
    • 
                    
  • Java多线程之线程通信
                        心情阿少
java开发语言
                        
    线程通信通过synchronized关键字，可保证线程在执行的过程中不会被其他线程打断，但无法保证线程的执行次序。比如上述案例中，我们可以保证t1线程输出"好好学习"时，不会被t2线程打断，但无法保证t1、t2两个线程执行的次序。如果想要控制线程输出次序，则需要学习线程通信技术。1）概念理解线程间通信：多个线程并发执行时,在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并
    
                    
    • 
                    
  • java干货 线程间通信
                        小男孩编程
java开发语言jvm
                        
    文章目录一、线程间通信1.1为什么要处理线程间通信？1.2什么是等待唤醒机制？二、等待唤醒机制使用2.1等待唤醒机制用到的方法2.1.1wait2.1.2notify2.2线程通信代码实践2.2.1重要说明2.2.2代码一、线程间通信1.1为什么要处理线程间通信？在默认情况下，cpu是默认切换线程来执行的，当我们需要多个线程共同来完成一个任务，希望他们按照一定的规律执行，那么就需要他们进行通信协调
    
                    
    • 
                    
  • Java中的注解
                        RB_VER
Java基础java编程语言
                        
    为什么要引入注解？使用【注解】之前(甚至在使用之后)，【XML】被广泛的应用于描述元数据，得到各大框架的青睐，它以松耦合的方式完成了框架中几乎所有的配置，但是随着项目越来越庞大，【XML】的内容也越来越复杂，一些应用开发人员和架构师发现维护成本变高。他们希望使用一些和代码紧耦合的东西，于是就有人提出来一种标记式高耦合的配置方式【注解】。方法上可以进行注解，类上也可以注解，字段属性上也可以注解，反正
    
                    
    • 
                    
  • java常见单词汇总3（非常使用哦）
                        糟糕透了的都精彩极了
学习javajava常用英文单词
                        
    JSP中常用英文URL:UniversalResourceLocation:统一资源定位符IE:InternetExplorer因特网浏览器JSP:javaserverpage.java服务器页面Model:模型View:视图C:controller:控制器Tomcat:一种jsp的web服务器WebModule:web模块Servlet:小服务程序Request:请求Response:响应Ini
    
                    
    • 
                    
  • Java 中如何使用 SSL 连接 IoTDB
                        铁头乔
javassliotdb数据库时序数据库开源
                        
    问题Java中如何使用SSL连接IoTDB？方案SSL（SecureSocketsLayer）是一种安全协议，用于在网络通信中提供加密、认证和数据完整性保护。它主要用于在互联网上保护数据传输，确保数据在传输过程中不被窃听或篡改。IoTDB支持SSL协议，但是在配置文件中相关参数是默认关闭的状态，如下：#Doesdn_rpc_portenableSSL#effectiveMode:restart#D
    
                    
    • 
                    
  • Java stream流的避坑指南
                        冰糖心158
2025Java面试系列java
                        
    在使用JavaStreamAPI时，虽然它提供了强大的功能来简化集合操作，但也存在一些常见的“坑”需要注意。以下是详细的避坑指南：1.Stream的不可重用性问题：Stream一旦被消费（如调用forEach、collect等终端操作），就不能再次使用。解决方案：如果需要多次操作同一个数据源，可以重新创建Stream，或者将Stream的结果保存到集合中。Listnumbers=Arrays.as
    
                    
    • 
                    
  • 从零基础开始实现一个Spring Boot + Vue 项目的详细步骤指南
                        软件职业规划
springspringbootvue.js后端
                        
    一、准备工作1.开发环境搭建安装JDK（JavaDevelopmentKit）：前往Oracle官网（https://www.oracle.com/java/technologies/javase-jdk11-downloads.html，以JDK11为例）下载适合你操作系统的JDK安装包，按照安装向导完成安装。安装完成后，配置系统环境变量，确保在命令行中能通过java-version命令查看到正
    
                    
    • 
                    
  • 深入解析华为OD机试：开放日活动“取出尽量少的球”题解及C++、Java、JavaScript、Python详细实现
                        m0_57781768
华为odc++java
                        
    深入解析华为OD机试：开放日活动“取出尽量少的球”题解及C++、Java、JavaScript、Python详细实现在华为OD机试的算法考题中，字符串处理、动态规划、二分查找等算法问题都频繁出现。这不仅是为了考查面试者的算法基础，还要求能够通过高效的逻辑思维解决问题。今天我们将深度分析一道关于“取出尽量少的球”的题目，并通过C++、Java、JavaScript、Python四种编程语言详细解析和
    
                    
    • 
                    
  • 注解Annontation 详解
                        宸之元亨利贞
JavaSE基础javalombokjunitspringintegration
                        
    什么是注解Annontation？Annontation是Java5开始引入的新特征，中文名称叫注解。它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且供指定的工具或框架使用。Annontation像一种修饰符一样，应用于包、类型
    
                    
    • 
                    
  • Java开发高频英语单词800+，熟悉后英文障碍又少了
                        万小猿En
程序员英语学习指北javajava英语英文单词语法
                        
    高频词就是出现频率很高的单词，它们是我用软件从JavaAPI中常用的5个包（lang,util,io,net,sql）整理的，涉及的文档有1702个。单词的意思大多不是通用的，已经选取了计算机软件开发语境下的含义。你可能也发现了，翻译过来的JavaAPI文档有些表述不好理解或信息有损耗，所以不如直接看英文版JavaAPI文档，而这些高频词可以帮到你。学习建议：熟悉的快速过，不熟悉的多记一下。序号频
    
                    
    • 
                    
  • Java 入门指南：集合概述
                        ZachOn1y
Javajava开发语言后端eclipsejava-ee
                        
    Java集合概述Java集合（Collections）是Java中提供的一种容器，用于存储和管理多个对象。与数组不同，集合的长度是可变的，且只能存储对象（包括对象的引用），不能存储基本数据类型。集合是Java编程中非常重要的一部分，特别是在处理大量数据时，集合提供了丰富的操作方法和灵活的数据结构。Java集合的体系结构Java集合，也叫作容器，主要是由两大接口派生而来：一个是Collection接
    
                    
    • 
                    
  • 本类方法调用，如何使事务依然生效；调用本类方法为什么要用AopContext.currentProxy()
                        CURRY30_1
mybatisjava
                        
    springAOP中只会切入代理类，从一个类调用另外另外一个类的时候，是会生成代理对象的。但是如果是本类方法的互相调用，那么就不会生成代理对象，随之方法配置的事务也会失效。那么我们可以使用两种方法来避免这种事务失效的问题1.((Service)AopContext.currentProxy()).B()来调用B方法，用这种方式，即使是本类方法的互相调用也能生成代理对象啦((Service)AopC
    
                    
    • 
                    
  • 【华为OD-E卷 - VLAN资源池 100分（python、java、c++、js、c）】
                        CodeClimb
算法题华为od（A+B+C+D+E卷）收录分享java华为odpythonc++javascript
                        
    【华为OD-E卷-VLAN资源池100分（python、java、c++、js、c）】题目VLAN是一种对局域网设备进行逻辑划分的技术，为了标识不同的VLAN，引入VLANID(1-4094之间的整数)的概念。定义一个VLANID的资源池(下称VLAN资源池)，资源池中连续的VLAN用开始VLAN-结束VLAN表示，不连续的用单个整数表示，所有的VLAN用英文逗号连接起来。现在有一个VLAN资源池
    
                    
    • 
                    
  • amazon-kinesis-video-streams-webrtc-sdk-c 移植到linux开发板
                        CSDN369369
webrtcc语言linux
                        
    大部分参考这位大神的资料分析依赖关系。通过分析Cmakelist.txt得出了一些依赖关系。libkvsWebrtcClient.so依赖项如下：libkvspicUtils.alibkvspicState.alibssl.solibcrypto.solibsrtp2.a.libusrsctp.solibkvsWebrtcSignalingClient.so依赖项如下：libkvsCommonLw
    
                    
    • 
                    
  • Java八股文：MQ篇
                        皮皮虾我们跑
java开发语言
                        
    3-MQ篇消息中间件用于分布式系统中程序之间的异步通信。它基于消息的发布/订阅或点对点机制，实现高效、可靠、可伸缩的消息传递。3.1RabbitMQ3.1.1RabbitMQ如何保证消息不丢失？消息丢失了怎么办？如何保证消息不丢失？开启生产者确认机制，确保生产者的消息ack能到达队列。开启持久化功能，确保消息未消费前在队列中不会丢失开启消费者确认机制auto，由spring确认消息处理成功后完成a
    
                    
    • 
                    
  • Commander 一款命令行自定义命令依赖
                        yqcoder
arcgisjavascript前端node.js
                        
    一、安装`commander`插件npminstallcommander二、基本用法1.创建一个简单的命令行程序创建一个JavaScript文件，例如`mycli.js`，并添加以下代码：//引入`commander`模块并获取`program`对象。const{program}=require("commander");program .version("1.0.0")//设置命令行工具的版本 
    
                    
    • 
                                
  • 插入表主键冲突做更新
                                    a-john

                                    
    有以下场景： 
用户下了一个订单，订单内的内容较多，且来自多表，首次下单的时候，内容可能会不全（部分内容不是必须，出现有些表根本就没有没有该订单的值）。在以后更改订单时，有些内容会更改，有些内容会新增。 
问题： 
如果在sql语句中执行update操作，在没有数据的表中会出错。如果在逻辑代码中先做查询，查询结果有做更新，没有做插入，这样会将代码复杂化。 
解决： 
mysql中提供了一个sql语
    
                                
    • 
                                
  • Android xml资源文件中@、@android:type、@*、？、@+含义和区别
                                    Cb123456
@+@?@*
                                    
    一.@代表引用资源 
1.引用自定义资源。格式：@[package:]type/name 
android：text="@string/hello" 
  
2.引用系统资源。格式：@android:type/name 
    android:textColor="@android:color/opaque_red"
    
                                
    • 
                                
  • 数据结构的基本介绍
                                    天子之骄
数据结构散列表树、图线性结构价格标签
                                    
    数据结构的基本介绍 
数据结构就是数据的组织形式，用一种提前设计好的框架去存取数据，以便更方便，高效的对数据进行增删查改。正确选择合适的数据结构，对软件程序的高效执行的影响作用不亚于算法的设计。此外，在计算机系统中数据结构的作用也是非同小可。例如常常在编程语言中听到的栈，堆等，就是经典的数据结构。 
  
经典的数据结构大致如下： 
  
一：线性数据结构 
(1)：列表 
a
    
                                
    • 
                                
  • 通过二维码开放平台的API快速生成二维码
                                    一炮送你回车库
api
                                    
     现在很多网站都有通过扫二维码用手机连接的功能，联图网(http://www.liantu.com/pingtai/)的二维码开放平台开放了一个生成二维码图片的Api,挺方便使用的。闲着无聊，写了个前台快速生成二维码的方法。 
       html代码如下:(二维码将生成在这div下)    
?       1      
 &nbs
    
                                
    • 
                                
  • ImageIO读取一张图片改变大小
                                    3213213333332132
javaIOimageBufferedImage
                                    
    
package com.demo;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

/**
 * @Description 读取一张图片改变大小
 * @author FuJianyon
    
                                
    • 
                                
  • myeclipse集成svn（一针见血）
                                    7454103
eclipseSVNMyEclipse
                                    
                                     &n
    
                                
    • 
                                
  • 装箱与拆箱----autoboxing和unboxing
                                    darkranger
J2SE
                                    
    4.2　自动装箱和拆箱 
 
基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。虽然为您打包基本数据类型提供了方便，但提供方便的同时表示隐藏了细节，建议在能够区分基本数据类型与对象的差别时再使用。 
 
4.2.1　autoboxing和unboxing 
 
在Java中，所有要处理的东西几乎都是对象(Object)
    
                                
    • 
                                
  • ajax传统的方式制作ajax
                                    aijuans
Ajax
                                    
    //这是前台的代码 
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+
    
                                
    • 
                                
  • 只用jre的eclipse是怎么编译java源文件的？
                                    avords
javaeclipsejdktomcat
                                    
    eclipse只需要jre就可以运行开发java程序了，也能自动 编译java源代码，但是jre不是java的运行环境么，难道jre中也带有编译工具？ 还是eclipse自己实现的？谁能给解释一下呢问题补充：假设系统中没有安装jdk or jre，只在eclipse的目录中有一个jre，那么eclipse会采用该jre，问题是eclipse照样可以编译java源文件，为什么呢？ 
&nb
    
                                
    • 
                                
  • 前端模块化
                                    bee1314
模块化
                                    
    背景：   前端JavaScript模块化，其实已经不是什么新鲜事了。但是很多的项目还没有真正的使用起来，还处于刀耕火种的野蛮生长阶段。       JavaScript一直缺乏有效的包管理机制，造成了大量的全局变量，大量的方法冲突。我们多么渴望有天能像Java（import），Python (import)，Ruby(require)那样写代码。在没有包管理机制的年代，我们是怎么避免所
    
                                
    • 
                                
  • 处理百万级以上的数据处理
                                    bijian1013
oraclesql数据库大数据查询
                                    
    一.处理百万级以上的数据提高查询速度的方法：        1.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。 
        2.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 o
    
                                
    • 
                                
  • mac 卸载 java 1.7 或更高版本
                                    征客丶
javaOS
                                    
    卸载 java 1.7 或更高 
sudo rm -rf /Library/Internet\ Plug-Ins/JavaAppletPlugin.plugin 
成功执行此命令后，还可以执行 java 与 javac 命令 
 
sudo rm -rf /Library/PreferencePanes/JavaControlPanel.prefPane 
成功执行此命令后，还可以执行 java 
    
                                
    • 
                                
  • 【Spark六十一】Spark Streaming结合Flume、Kafka进行日志分析
                                    bit1129
Stream
                                    
    第一步，Flume和Kakfa对接，Flume抓取日志，写到Kafka中 
第二部，Spark Streaming读取Kafka中的数据，进行实时分析 
  
本文首先使用Kakfa自带的消息处理（脚本）来获取消息，走通Flume和Kafka的对接 1. Flume配置 
1. 下载Flume和Kafka集成的插件，下载地址：https://github.com/beyondj2ee/f
    
                                
    • 
                                
  • Erlang vs TNSDL
                                    bookjovi
erlang
                                    
      
    TNSDL是Nokia内部用于开发电信交换软件的私有语言，是在SDL语言的基础上加以修改而成，TNSDL需翻译成C语言得以编译执行，TNSDL语言中实现了异步并行的特点，当然要完整实现异步并行还需要运行时动态库的支持，异步并行类似于Erlang的process（轻量级进程），TNSDL中则称之为hand，Erlang是基于vm(beam)开发，
    
                                
    • 
                                
  • 非常希望有一个预防疲劳的java软件, 预防过劳死和眼睛疲劳,大家一起努力搞一个
                                    ljy325
企业应用
                                    
    　非常希望有一个预防疲劳的java软件，我看新闻和网站，国防科技大学的科学家累死了，太疲劳，老是加班，不休息，经常吃药，吃药根本就没用，根本原因是疲劳过度。我以前做java,那会公司垃圾，老想赶快学习到东西跳槽离开，搞得超负荷，不明理。深圳做软件开发经常累死人，总有不明理的人，有个软件提醒限制很好，可以挽救很多人的生命。 
 
相关新闻： 
（1）IT行业成五大疾病重灾区：过劳死平均37.9岁 

    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-原型模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/**
 * Effective Java 建议使用copy constructor or copy factory来代替clone()方法：
 * 1.public Product copy(Product p){}
 * 2.publi
    
                                
    • 
                                
  • 配置管理---svn工具之权限配置
                                    chenyu19891124
SVN
                                    
    今天花了大半天的功夫，终于弄懂svn权限配置。下面是今天收获的战绩。 
安装完svn后就是在svn中建立版本库，比如我本地的是版本库路径是C:\Repositories\pepos。pepos是我的版本库。在pepos的目录结构 
pepos 
   component 
   webapps 
在conf里面的auth里赋予的权限配置为 
[groups]
    
                                
    • 
                                
  • 浅谈程序员的数学修养
                                    comsci
设计模式编程算法面试招聘
                                    
             
                        浅谈程序员的数学修养 
    
                                
    • 
                                
  • 批量执行 bulk collect与forall用法
                                    daizj
oraclesqlbulk collectforall
                                    
    BULK COLLECT 子句会批量检索结果，即一次性将结果集绑定到一个集合变量中，并从SQL引擎发送到PL/SQL引擎。通常可以在SELECT INTO、 
FETCH INTO以及RETURNING INTO子句中使用BULK COLLECT。本文将逐一描述BULK COLLECT在这几种情形下的用法。 
    有关FORALL语句的用法请参考：批量SQL之 F
    
                                
    • 
                                
  • Linux下使用rsync最快速删除海量文件的方法
                                    dongwei_6688
OS
                                    
    1、先安装rsync：yum install rsync 
2、建立一个空的文件夹：mkdir /tmp/test 
3、用rsync删除目标目录：rsync --delete-before -a -H -v --progress --stats /tmp/test/ log/这样我们要删除的log目录就会被清空了，删除的速度会非常快。rsync实际上用的是替换原理，处理数十万个文件也是秒删。 

    
                                
    • 
                                
  • Yii CModel中rules验证规格
                                    dcj3sjt126com
rulesyiivalidate
                                    
    Yii cValidator主要用法分析：  
 yii验证rulesit 分类： Yii yii的rules验证 cValidator主要属性 attributes ,builtInValidators,enableClientValidation,message,on,safe,skipOnError 
 
    
                                
    • 
                                
  • 基于vagrant的redis主从实验
                                    dcj3sjt126com
vagrant
                                    
    平台: Mac 
工具: Vagrant 
系统: Centos6.5 
实验目的: Redis主从 
  
实现思路 
制作一个基于sentos6.5, 已经安装好reids的box, 添加一个脚本配置从机, 然后作为后面主机从机的基础box 
  
制作sentos6.5+redis的box 
  
mkdir vagrant_redis 
cd vagrant_
    
                                
    • 
                                
  • Memcached(二)、Centos安装Memcached服务器
                                    frank1234
centosmemcached
                                    
    一、安装gcc 
rpm和yum安装memcached服务器连接没有找到，所以我使用的是make的方式安装，由于make依赖于gcc，所以要先安装gcc 
 
开始安装，命令如下，[color=red][b]顺序一定不能出错[/b][/color]：

建议可以先切换到root用户，不然可能会遇到权限问题：su root 输入密码......


rpm -ivh kernel-head
    
                                
    • 
                                
  • Remove Duplicates from Sorted List
                                    hcx2013
remove
                                    
    Given a sorted linked list, delete all duplicates such that each element appear only once. 
For example,Given 1->1->2, return 1->2.Given 1->1->2->3->3, return&
    
                                
    • 
                                
  • Spring4新特性——JSR310日期时间API的支持
                                    jinnianshilongnian
spring4
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • 浅谈enum与单例设计模式
                                    247687009
java单例
                                    
    在JDK1.5之前的单例实现方式有两种(懒汉式和饿汉式并无设计上的区别故看做一种)，两者同是私有构
造器，导出静态成员变量，以便调用者访问。

第一种 
package singleton;

public class Singleton {
        //导出全局成员
        public final static Singleton INSTANCE = new S
    
                                
    • 
                                
  • 使用switch条件语句需要注意的几点
                                    openwrt
cbreakswitch
                                    
    1. 当满足条件的case中没有break，程序将依次执行其后的每种条件（包括default）直到遇到break跳出 
 
int main()
{
    int n = 1;
    switch(n) {
    case 1:
        printf("--1--\n");
    default:
        printf("defa
    
                                
    • 
                                
  • 配置Spring Mybatis JUnit测试环境的应用上下文
                                    schnell18
springmybatisJUnit
                                    
    Spring-test模块中的应用上下文和web及spring boot的有很大差异。主要试下来差异有： 
 
 单元测试的app context不支持从外部properties文件注入属性 
 @Value注解不能解析带通配符的路径字符串 
 
解决第一个问题可以配置一个PropertyPlaceholderConfigurer的bean。 
第二个问题的具体实例是： 
   
    
                                
    • 
                                
  • Java 定时任务总结一
                                    tuoni
javaspringtimerquartztimertask
                                    
     Java定时任务总结  一.从技术上分类大概分为以下三种方式：  1.Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务;   说明：    java.util.Timer定时器，实际上是个线程，定时执行TimerTask类 &
    
                                
    • 
                                
  • 一种防止用户生成内容站点出现商业广告以及非法有害等垃圾信息的方法
                                    yangshangchuan
rank相似度计算文本相似度词袋模型余弦相似度
                                    
    本文描述了一种在ITEYE博客频道上面出现的新型的商业广告形式及其应对方法，对于其他的用户生成内容站点类型也具有同样的适用性。 
  
最近在ITEYE博客频道上面出现了一种新型的商业广告形式，方法如下： 
    1、注册多个账号（一般10个以上）。 
    2、从多个账号中选择一个账号，发表1-2篇博文
    
                                
    •