新增OPC

yyt

2024-01-13 e4c3b0f2afc59f7d7037b196d9f90266e2255608

新增OPC

 jcdm-main/pom.xml

@@ -37,6 +37,38 @@
            </exclusions>
        </dependency>

        <!--Server SDK依赖-->
        <dependency>
            <groupId>org.eclipse.milo</groupId>
            <artifactId>sdk-server</artifactId>
            <version>0.3.6</version>
        </dependency>

        <!--Client SDK依赖-->
        <dependency>
            <groupId>org.eclipse.milo</groupId>
            <artifactId>sdk-client</artifactId>
            <version>0.3.6</version>
        </dependency>

        <dependency>
            <groupId>org.eclipse.milo</groupId>
            <artifactId>stack-client</artifactId>
            <version>0.3.6</version>
        </dependency>

        <dependency>
            <groupId>org.eclipse.milo</groupId>
            <artifactId>stack-client</artifactId>
            <version>0.3.6</version>
        </dependency>

        <dependency>
            <groupId>org.eclipse.milo</groupId>
            <artifactId>stack-server</artifactId>
            <version>0.3.6</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/cert/KeyStoreLoader.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,127 @@
package com.jcdm.main.da.opcuaconfig.cert;

import org.eclipse.milo.opcua.sdk.server.util.HostnameUtil;
import org.eclipse.milo.opcua.stack.core.util.SelfSignedCertificateBuilder;
import org.eclipse.milo.opcua.stack.core.util.SelfSignedCertificateGenerator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.*;
import java.security.cert.X509Certificate;
import java.util.regex.Pattern;

/**
 * @ClassName: KeyStoreLoader
 * @Description: KeyStoreLoader
 * @author yyt
 * @date 2023å¹´10月13日
 */
@Component
public class KeyStoreLoader {

    private static final Pattern IP_ADDR_PATTERN = Pattern
            .compile("^(([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}([01]?\\d\\d?|2[0-4]\\d|25[0-5])$");

    // è¯ä¹¦åˆ«å
    private static final String CLIENT_ALIAS = "jlclient-ai";
    // èŽ·å–私钥的密码
    private static final char[] PASSWORD = "yyt@8888888888".toCharArray();

    private final Logger logger = LoggerFactory.getLogger(getClass());

    // è¯ä¹¦å¯¹è±¡
    private X509Certificate clientCertificate;
    // å¯†é’¥å¯¹å¯¹è±¡
    private KeyPair clientKeyPair;

    /**
     * @MethodName: load
     * @Description: load
     * @param baseDir
     * @return
     * @throws Exception
     * @CreateTime 2023å¹´10月13日
     */
    public KeyStoreLoader load(Path baseDir) throws Exception {
        // åˆ›å»ºä¸€ä¸ªä½¿ç”¨`PKCS12`加密标准的KeyStore。KeyStore在后面将作为读取和生成证书的对象。
        KeyStore keyStore = KeyStore.getInstance("PKCS12");

        // PKCS12的加密标准的文件后缀是.pfx，其中包含了公钥和私钥。
        // è€Œå…¶ä»–如.der等的格式只包含公钥，私钥在另外的文件中。
        Path serverKeyStore = baseDir.resolve("OPCUA-client.pfx");

        logger.info("Loading KeyStore at {}", serverKeyStore);

        // å¦‚果文件不存在则创建.pfx证书文件。
        if (!Files.exists(serverKeyStore)) {
            keyStore.load(null, PASSWORD);

            // ç”¨2048位的RAS算法。`SelfSignedCertificateGenerator`为Milo库的对象。
            KeyPair keyPair = SelfSignedCertificateGenerator.generateRsaKeyPair(2048);

            // `SelfSignedCertificateBuilder`也是Milo库的对象，用来生成证书。
            // ä¸­é—´æ‰€è®¾ç½®çš„证书属性可以自行修改。
            SelfSignedCertificateBuilder builder = new SelfSignedCertificateBuilder(keyPair)
                    .setCommonName("UaClient@Jellyleo")
                    .setOrganization("JL")
                    .setOrganizationalUnit("per")
                    .setLocalityName("jl")
                    .setStateName("JiangSu")
                    .setCountryCode("CN")
                    .setApplicationUri("urn:Yyt_PC:UnifiedAutomation:UaExpert")
                    .addDnsName("Yyt_PC")
                    .addIpAddress("127.0.0.1");

            // Get as many hostnames and IP addresses as we can listed in the certificate.
            for (String hostname : HostnameUtil.getHostnames("0.0.0.0")) {
                if (IP_ADDR_PATTERN.matcher(hostname).matches()) {
                    builder.addIpAddress(hostname);
                } else {
                    builder.addDnsName(hostname);
                }
            }
            // åˆ›å»ºè¯ä¹¦
            X509Certificate certificate = builder.build();

            // è®¾ç½®å¯¹åº”私钥的别名，密码，证书链
            keyStore.setKeyEntry(CLIENT_ALIAS, keyPair.getPrivate(), PASSWORD, new X509Certificate[] { certificate });
            try (OutputStream out = Files.newOutputStream(serverKeyStore)) {
                // ä¿å­˜è¯ä¹¦åˆ°è¾“出流
                keyStore.store(out, PASSWORD);
            }
        } else {
            try (InputStream in = Files.newInputStream(serverKeyStore)) {
                // å¦‚果文件存在则读取
                keyStore.load(in, PASSWORD);
            }
        }

        // ç”¨å¯†ç èŽ·å–对应别名的私钥。
        Key serverPrivateKey = keyStore.getKey(CLIENT_ALIAS, PASSWORD);
        if (serverPrivateKey instanceof PrivateKey) {
            // èŽ·å–对应别名的证书对象。
            clientCertificate = (X509Certificate) keyStore.getCertificate(CLIENT_ALIAS);
            // èŽ·å–公钥
            PublicKey serverPublicKey = clientCertificate.getPublicKey();
            // åˆ›å»ºKeypair对象。
            clientKeyPair = new KeyPair(serverPublicKey, (PrivateKey) serverPrivateKey);
        }

        return this;
    }

    // è¿”回证书
    public X509Certificate getClientCertificate() {
        return clientCertificate;
    }

    // è¿”回密钥对
    public KeyPair getClientKeyPair() {
        return clientKeyPair;
    }
}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/cert/MethodName.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,69 @@
package com.jcdm.main.da.opcuaconfig.cert;

import com.jcdm.main.da.collectionParamConf.domain.DaCollectionParamConf;
import com.jcdm.main.da.collectionParamConf.service.IDaCollectionParamConfService;
import com.jcdm.main.da.opcuaconfig.client.ClientHandler;
import com.jcdm.main.da.opcuaconfig.domain.NodeEntity;
import com.jcdm.main.da.opcuaconfig.init.BeanUtils;
import com.jcdm.main.da.paramCollection.domain.DaParamCollection;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.milo.opcua.stack.core.types.builtin.DataValue;
import org.eclipse.milo.opcua.stack.core.types.builtin.NodeId;

import java.util.*;
import java.util.stream.Collectors;

import static com.jcdm.main.da.opcuaconfig.client.ClientHandler.readValues;

@Slf4j
public class MethodName {
    private IDaCollectionParamConfService collectionParamConfService = BeanUtils.getBean(IDaCollectionParamConfService.class);
    public void getSn(String Node, String value) throws Exception {
        log.info(Node+":"+value);
        String[] parts = Node.split("[.]");
        ClientHandler clientHandler=new ClientHandler();
        switch (value) {
            case "0":   //初始
                NodeEntity node= NodeEntity.builder().index(2).identifier(parts[0]+"."+parts[1]+".RecordDataDone").value("0").type("short").build();
                Boolean out=clientHandler.write(node);
                log.info("节点:{},响应结果:{}", node.getIdentifier(),out);
                break;
            case "1":   //请求下发进站状态
                NodeEntity node1= NodeEntity.builder().index(2).identifier(parts[0]+"."+parts[1]+".RecordDataDone").value("11").type("short").build();
                Boolean out1=clientHandler.write(node1);
                log.info("节点:{},响应结果:{}", node1.getIdentifier(),out1);
                break;
            case "2":   //请求记录工位数据
                List<DaCollectionParamConf> b;
                DaCollectionParamConf daCollectionParamConf=new DaCollectionParamConf();
                daCollectionParamConf.setCollectParameterId(parts[0]+"."+parts[1]);
                b=collectionParamConfService.selectDaCollectionParamConfList(daCollectionParamConf);
                List<String> ids = b.stream().map(e -> e.getCollectParameterId()).collect(Collectors.toList());
                Set<String> de=ListToSet(ids);
                List<DataValue> s=readValues(de);
//                s.forEach(element->{
//                    DaParamCollection Config=new DaParamCollection();
//                    String[] q = element.getIdentifier().split("[.]");
//                    Config.setParamCode(q[2]);
//                    Config.setLocationCode(q[1]);
//                    Config.setParamValue(element.getValue().toString());
//                    daParamCollectionService.insertDaParamCollection(Config);
//                });
                NodeEntity node2= NodeEntity.builder().index(2).identifier(parts[0]+"."+parts[1]+".RecordDataDone").value("21").type("short").build();
                Boolean out2=clientHandler.write(node2);
                log.info("节点:{},响应结果:{}", node2.getIdentifier(),out2);
                break;
            default:
                break;
        }
    }

    public Set<String> ListToSet(List<String> list) {
        Object[] objects = list.toArray();// è¿”回Object数组
        String[] strings1 = new String[list.size()];
        list.toArray(strings1);// å°†è½¬åŒ–后的数组放入已经创建好的对象中
        String[] strings2 = list.toArray(new String[0]);// å°†è½¬åŒ–后的数组赋给新对象
        Set<String> set = new HashSet<String>(Arrays.asList(strings2));
        return set;
    }
}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/client/ClientHandler.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,301 @@
package com.jcdm.main.da.opcuaconfig.client;

import com.google.common.collect.ImmutableList;
import com.jcdm.main.da.opcuaconfig.controller.DaOpcuaConfigController;
import com.jcdm.main.da.opcuaconfig.domain.DaOpcuaConfig;
import com.jcdm.main.da.opcuaconfig.domain.NodeEntity;
import com.jcdm.main.da.opcuaconfig.service.IDaOpcuaConfigService;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.api.nodes.VariableNode;
import org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaSubscription;
import org.eclipse.milo.opcua.stack.core.AttributeId;
import org.eclipse.milo.opcua.stack.core.BuiltinDataType;
import org.eclipse.milo.opcua.stack.core.types.builtin.DataValue;
import org.eclipse.milo.opcua.stack.core.types.builtin.NodeId;
import org.eclipse.milo.opcua.stack.core.types.builtin.StatusCode;
import org.eclipse.milo.opcua.stack.core.types.builtin.Variant;
import org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.Unsigned;
import org.eclipse.milo.opcua.stack.core.types.enumerated.MonitoringMode;
import org.eclipse.milo.opcua.stack.core.types.enumerated.TimestampsToReturn;
import org.eclipse.milo.opcua.stack.core.types.structured.MonitoredItemCreateRequest;
import org.eclipse.milo.opcua.stack.core.types.structured.MonitoringParameters;
import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutionException;

/**
 * @ClassName: ClientHandler
 * @Description: å®¢æˆ·ç«¯å¤„理
 * @author Jellyleo
 * @date 2019å¹´12月12日
 */
@Slf4j
@Service
public class ClientHandler {

    // å®¢æˆ·ç«¯å®žä¾‹
    public static OpcUaClient client = null;

    public List<DaOpcuaConfig> b = null;

    @Autowired
    private ClientRunner clientRunner;

    @Autowired
    private IDaOpcuaConfigService daOpcuaConfigService;


    /**
     * 
     * @MethodName: connect
     * @Description: connect
     * @throws Exception
     * @CreateTime 2019å¹´12月18日 ä¸Šåˆ10:41:09
     */
    public String connect() throws Exception {

        if (client != null) {
            return "客户端已创建";
        }

        client = clientRunner.run();

        if (client == null) {
            return "客户端配置实例化失败";
        }

        // åˆ›å»ºè¿žæŽ¥
        client.connect().get();
        return "创建连接成功";
    }

    /**
     * @MethodName: disconnect
     * @Description: æ–­å¼€è¿žæŽ¥
     * @return
     * @throws Exception
     * @CreateTime 2019å¹´12月18日 ä¸Šåˆ10:45:21
     */
    public String disconnect() throws Exception {

        if (client == null) {
            return "连接已断开";
        }

        // æ–­å¼€è¿žæŽ¥
        clientRunner.getFuture().complete(client);
        client = null;
        return "断开连接成功";
    }

    /**
     * @MethodName: subscribe
     * @Description: è®¢é˜…节点变量
     * @throws Exception
     * @CreateTime 2019å¹´12月18日 ä¸Šåˆ10:38:11
     */
    public String subscribe(List<NodeEntity> nodes) throws Exception {

        if (client == null) {
            return "找不到客户端，操作失败";
        }

        // æŸ¥è¯¢è®¢é˜…对象，没有则创建
        UaSubscription subscription = null;
        ImmutableList<UaSubscription> subscriptionList = client.getSubscriptionManager().getSubscriptions();
        if (CollectionUtils.isEmpty(subscriptionList)) {
            subscription = client.getSubscriptionManager().createSubscription(1000.0).get();
        } else {
            subscription = subscriptionList.get(0);
        }

        // ç›‘控项请求列表
        List<MonitoredItemCreateRequest> requests = new ArrayList<>();

        if (!CollectionUtils.isEmpty(nodes)) {
            for (NodeEntity node : nodes) {
                // åˆ›å»ºç›‘控的参数
                MonitoringParameters parameters = new MonitoringParameters(subscription.nextClientHandle(), 1000.0, // sampling
                        // interval
                        null, // filter, null means use default
                        Unsigned.uint(10), // queue size
                        true // discard oldest
                );
                // åˆ›å»ºè®¢é˜…的变量， åˆ›å»ºç›‘控项请 æ±‚
                MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(
                        new ReadValueId(new NodeId(node.getIndex(), node.getIdentifier()), AttributeId.Value.uid(),
                                null, null),
                        MonitoringMode.Reporting, parameters);
                requests.add(request);
            }
        }

        // åˆ›å»ºç›‘控项，并且注册变量值改变时候的回调函数
        subscription.createMonitoredItems(TimestampsToReturn.Both, requests, (item, id) -> {
            item.setValueConsumer((i, v) -> {
                handle(i.getReadValueId().getNodeId(), v.getValue());
            });
        }).get();

        return "订阅成功";
    }

    /**
     * * @MethodName: write
     * @Description: å›žè°ƒå‡½æ•°
     * @CreateTime 2023å¹´10月13日
     */
    public void handle(NodeId id, Variant value){
        if (b == null || 0 > b.size()) {
            DaOpcuaConfig opcuaConfParam=new DaOpcuaConfig();
            opcuaConfParam.setSubscribe(1L);
            b=daOpcuaConfigService.selectDaOpcuaConfigList(opcuaConfParam);
        }
        //使用Stream API在List<T>中查找元素
        DaOpcuaConfig daOpcuaConfig = b.stream()
                .filter(customer ->id.getIdentifier().toString().equals(customer.getNode()))
                .findAny()
                .orElse(null);
        try {
            Class<?> clazz = Class.forName(daOpcuaConfig.getrModule());
            Method method = clazz.getMethod(daOpcuaConfig.getrFunction(), new Class[] { String.class, String.class });
            method.invoke(clazz.newInstance(),new Object[] {
                    new String(id.getIdentifier().toString()), new String(value.getValue().toString()) });
        } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InstantiationException |
                 InvocationTargetException e) {
            e.printStackTrace();
        }
    }


    /**
     * @MethodName: write
     * @Description: å˜èŠ‚点量写入
     * @param node
     * @throws Exception
     * @CreateTime 2019å¹´12月18日 ä¸Šåˆ9:51:40
     */
    public static Boolean write(NodeEntity node) throws Exception {

        if (client == null) {
            log.info("找不到客户端，操作失败");
            return false;
        }

        NodeId nodeId = new NodeId(node.getIndex(), node.getIdentifier());
        Variant value = null;
        switch (node.getType()) {
        case "int":
            value = new Variant(Integer.parseInt(node.getValue().toString()));
            break;
        case "boolean":
            value = new Variant(Boolean.parseBoolean(node.getValue().toString()));
            break;
        case "short":
            value = new Variant(Short.parseShort(node.getValue().toString()));
            break;
        case "long":
            value = new Variant(Long.parseLong(node.getValue().toString()));
            break;
        case "string":
            value = new Variant(node.getValue().toString());
            break;
        case "char":
            value = new Variant(node.getValue().toString().charAt(0));
            break;
        }
        DataValue dataValue = new DataValue(value, null, null);

        StatusCode statusCode = client.writeValue(nodeId, dataValue).get();

        return statusCode.isGood();
    }

    /**
     * æ–¹æ³•æè¿°: è¯»å–多个点位的值
     *
     * @param keys ç‚¹ä½é›†åˆ
     * @return {@link List<DataValue>}
     * @throws
     */
    public static List<DataValue> readValues(Set<String> keys){
        List<NodeId> nodeIdList=new ArrayList<>(500);
        keys.forEach(e->{
            NodeId nodeId = new NodeId(2, e);
            nodeIdList.add(nodeId);
        });
        try {
            List<DataValue> dataValues=client.readValues(0.0, TimestampsToReturn.Both,nodeIdList).get();
            return dataValues;
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * @MethodName: read
     * @Description: è¯»å–
     * @param node
     * @return
     * @throws Exception
     * @CreateTime 2019å¹´12月19日 ä¸‹åˆ2:40:34
     */
    public String read(NodeEntity node) throws Exception {

        if (client == null) {
            return "找不到客户端，操作失败";
        }

        NodeId nodeId = new NodeId(node.getIndex(), node.getIdentifier());
        VariableNode vnode = client.getAddressSpace().createVariableNode(nodeId);
        DataValue value = vnode.readValue().get();
        log.info("Value={}", value);

        Variant variant = value.getValue();
        log.info("Variant={}", variant.getValue());

        log.info("BackingClass={}", BuiltinDataType.getBackingClass(variant.getDataType().get()));

        return variant.getValue().toString();
    }


    /**
     * æ–¹æ³•æè¿°:  å†™å…¥å¤šä¸ªèŠ‚点的值
     *
     * @param keys  èŠ‚点集合
     * @param values  å€¼é›†åˆ
     * @param client  å®¢æˆ·ç«¯
     * @return {@link Object}
     * @throws
     */
    public static Object writeValues(Set<String> keys, List<Object> values, OpcUaClient client){
        List<NodeId> nodeIs=new ArrayList<>(keys.size());
        keys.forEach(e->{
            NodeId nodeId = new NodeId(2, e);
            nodeIs.add(nodeId);
        });
        List<DataValue> dataValues=new ArrayList<>(values.size());
        values.forEach(e->{
            Variant value=new Variant(Double.parseDouble(e.toString()));
            DataValue dataValue=new DataValue(value);
            dataValues.add(dataValue);
        });
        try {
            client.writeValues(nodeIs,dataValues).get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        return null;
    }
}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/client/ClientRunner.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,146 @@
package com.jcdm.main.da.opcuaconfig.client;

import com.jcdm.main.da.opcuaconfig.cert.KeyStoreLoader;
import com.jcdm.main.da.opcuaconfig.init.Properties;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.api.config.OpcUaClientConfig;
import org.eclipse.milo.opcua.sdk.client.api.identity.AnonymousProvider;
import org.eclipse.milo.opcua.stack.client.DiscoveryClient;
import org.eclipse.milo.opcua.stack.core.Stack;
import org.eclipse.milo.opcua.stack.core.security.SecurityPolicy;
import org.eclipse.milo.opcua.stack.core.types.builtin.LocalizedText;
import org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.Unsigned;
import org.eclipse.milo.opcua.stack.core.types.structured.EndpointDescription;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.function.Predicate;

/**
 * @ClassName: ClientRunner
 * @Description: å®¢æˆ·ç«¯å¯åŠ¨ç±»
 * @author yyt
 * @date 2023å¹´10月13日
 */
@Slf4j
@Component
public class ClientRunner {

    private final CompletableFuture<OpcUaClient> future = new CompletableFuture<>();

    @Autowired
    private Properties properties;

    @Autowired
    private KeyStoreLoader keyStoreLoader;

    /**
     * @MethodName: run
     * @Description: å¯åŠ¨
     * @return
     * @throws Exception
     * @CreateTime 2023å¹´10月13日
     */
    public OpcUaClient run() throws Exception {

        OpcUaClient client = createClient();

        future.whenCompleteAsync((c, ex) -> {
            if (ex != null) {
                log.error("Error running example: {}", ex.getMessage(), ex);
            }

            try {
                c.disconnect().get();
                Stack.releaseSharedResources();
            } catch (InterruptedException | ExecutionException e) {
                log.error("Error disconnecting:", e.getMessage(), e);
            }
        });

        return client;
    }

    /**
     * @MethodName: createClient
     * @Description: åˆ›å»ºå®¢æˆ·ç«¯
     * @return
     * @throws Exception
     * @CreateTime 2023å¹´10月13日
     */
    private OpcUaClient createClient() throws Exception {

        Path securityTempDir = Paths.get(properties.getCertPath(), "security");
        Files.createDirectories(securityTempDir);
        if (!Files.exists(securityTempDir)) {
            log.error("unable to create security dir: " + securityTempDir);
            return null;
        }

        KeyStoreLoader loader = keyStoreLoader.load(securityTempDir);

        // æœç´¢OPC节点
        List<EndpointDescription> endpoints = null;
        try {
            //获取安全策略
            endpoints = DiscoveryClient.getEndpoints(properties.getEndpointUrl()).get();
        } catch (Throwable e) {
            // try the explicit discovery endpoint as well
            String discoveryUrl = properties.getEndpointUrl();

            if (!discoveryUrl.endsWith("/")) {
                discoveryUrl += "/";
            }
            discoveryUrl += "discovery";

            log.info("Trying explicit discovery URL: {}", discoveryUrl);
            endpoints = DiscoveryClient.getEndpoints(discoveryUrl).get();
        }

        EndpointDescription endpoint = endpoints.stream()
                .filter(e -> e.getSecurityPolicyUri().equals(SecurityPolicy.None.getUri())).filter(endpointFilter())
                .findFirst().orElseThrow(() -> new Exception("no desired endpoints returned"));

        OpcUaClientConfig config = OpcUaClientConfig.builder()
                // opc ua自定义的名称
                .setApplicationName(LocalizedText.english("plc"))
                // åœ°å€
                .setApplicationUri(properties.getEndpointUrl())
                .setCertificate(loader.getClientCertificate()).setKeyPair(loader.getClientKeyPair())
                // å®‰å…¨ç­–略等配置
                //.setEndpoint(endpoint).setIdentityProvider(new UsernameProvider("OPCUA", "yyt@8888888888"))
                .setEndpoint(endpoint)
                // åŒ¿åéªŒè¯
                .setIdentityProvider(new AnonymousProvider())
                //等待时间
                .setRequestTimeout(Unsigned.uint(5000)).build();

        return OpcUaClient.create(config);

    }

    /**
     * @MethodName: endpointFilter
     * @Description: endpointFilter
     * @return
     * @CreateTime 2023å¹´10月13日
     */
    private Predicate<EndpointDescription> endpointFilter() {
        return e -> true;
    }

    /**
     * @return the future
     */
    public CompletableFuture<OpcUaClient> getFuture() {
        return future;
    }

}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/controller/DaOpcuaConfigController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,109 @@
package com.jcdm.main.da.opcuaconfig.controller;

import com.jcdm.common.annotation.Log;
import com.jcdm.common.core.controller.BaseController;
import com.jcdm.common.core.domain.AjaxResult;
import com.jcdm.common.core.page.TableDataInfo;
import com.jcdm.common.enums.BusinessType;
import com.jcdm.common.utils.poi.ExcelUtil;
import com.jcdm.main.da.opcuaconfig.domain.DaOpcuaConfig;
import com.jcdm.main.da.opcuaconfig.service.IDaOpcuaConfigService;
import com.jcdm.main.da.paramCollection.service.IDaParamCollectionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;
import java.util.List;

/**
 * OPCUA参数设置Controller
 * 
 * @author yyt
 * @date 2023-12-22
 */
@RestController
@RequestMapping("/da/opcuaconfig")
public class DaOpcuaConfigController extends BaseController
{
    @Autowired
    private IDaOpcuaConfigService daOpcuaConfigService;

    @Autowired
    private IDaParamCollectionService daParamCollectionService;

    /**
     * æŸ¥è¯¢OPCUA参数设置列表
     */
    @PreAuthorize("@ss.hasPermi('da:opcuaconfig:list')")
    @GetMapping("/list")
    public TableDataInfo list(DaOpcuaConfig daOpcuaConfig)
    {
        startPage();
        List<DaOpcuaConfig> list = daOpcuaConfigService.selectDaOpcuaConfigList(daOpcuaConfig);
        return getDataTable(list);
    }

    @PreAuthorize("@ss.hasPermi('da:opcuaconfig:getconfig')")
    @GetMapping("/getconfig")
    public List<DaOpcuaConfig> getconfig(DaOpcuaConfig daOpcuaConfig)
    {
        return daOpcuaConfigService.selectDaOpcuaConfigList(daOpcuaConfig);
    }

    /**
     * å¯¼å‡ºOPCUA参数设置列表
     */
    @PreAuthorize("@ss.hasPermi('da:opcuaconfig:export')")
    @Log(title = "OPCUA参数设置", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, DaOpcuaConfig daOpcuaConfig)
    {
        List<DaOpcuaConfig> list = daOpcuaConfigService.selectDaOpcuaConfigList(daOpcuaConfig);
        ExcelUtil<DaOpcuaConfig> util = new ExcelUtil<DaOpcuaConfig>(DaOpcuaConfig.class);
        util.exportExcel(response, list, "OPCUA参数设置数据");
    }

    /**
     * èŽ·å–OPCUA参数设置详细信息
     */
    @PreAuthorize("@ss.hasPermi('da:opcuaconfig:query')")
    @GetMapping(value = "/{id}")
    public AjaxResult getInfo(@PathVariable("id") Long id)
    {
        return success(daOpcuaConfigService.selectDaOpcuaConfigById(id));
    }

    /**
     * æ–°å¢žOPCUA参数设置
     */
    @PreAuthorize("@ss.hasPermi('da:opcuaconfig:add')")
    @Log(title = "OPCUA参数设置", businessType = BusinessType.INSERT)
    @PostMapping
    public AjaxResult add(@RequestBody DaOpcuaConfig daOpcuaConfig)
    {
        return toAjax(daOpcuaConfigService.insertDaOpcuaConfig(daOpcuaConfig));
    }

    /**
     * ä¿®æ”¹OPCUA参数设置
     */
    @PreAuthorize("@ss.hasPermi('da:opcuaconfig:edit')")
    @Log(title = "OPCUA参数设置", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult edit(@RequestBody DaOpcuaConfig daOpcuaConfig)
    {
        return toAjax(daOpcuaConfigService.updateDaOpcuaConfig(daOpcuaConfig));
    }

    /**
     * åˆ é™¤OPCUA参数设置
     */
    @PreAuthorize("@ss.hasPermi('da:opcuaconfig:remove')")
    @Log(title = "OPCUA参数设置", businessType = BusinessType.DELETE)
    @DeleteMapping("/{ids}")
    public AjaxResult remove(@PathVariable Long[] ids)
    {
        return toAjax(daOpcuaConfigService.deleteDaOpcuaConfigByIds(ids));
    }
}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/domain/DaOpcuaConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,163 @@
package com.jcdm.main.da.opcuaconfig.domain;

import com.jcdm.common.annotation.Excel;
import com.jcdm.common.core.domain.BaseEntity;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;

/**
 * OPCUA参数设置对象 da_opcua_config
 * 
 * @author yyt
 * @date 2023-12-22
 */
public class DaOpcuaConfig extends BaseEntity
{
    private static final long serialVersionUID = 1L;

    /** ID */
    private Long id;

    /** æ‰€å±žæ¨¡å— */
    @Excel(name = "所属模块")
    private String module;

    /** èŠ‚点 */
    @Excel(name = "节点")
    private String node;

    /** é•¿åº¦ */
    @Excel(name = "长度")
    private Long length;

    /** ç±»åž‹ */
    @Excel(name = "类型")
    private String sysTypes;

    /** åŠŸèƒ½è¯´æ˜Ž */
    @Excel(name = "功能说明")
    private String functionality;

    /** æ˜¯å¦è®¢é˜… */
    @Excel(name = "是否订阅")
    private Long subscribe;

    /** è®¢é˜…响应模块 */
    @Excel(name = "订阅响应模块")
    private String rModule;

    /** è®¢é˜…响应函数 */
    @Excel(name = "订阅响应函数")
    private String rFunction;

    /** å¤‡æ³¨ */
    @Excel(name = "备注")
    private String remarks;

    public void setId(Long id) 
    {
        this.id = id;
    }

    public Long getId() 
    {
        return id;
    }
    public void setModule(String module) 
    {
        this.module = module;
    }

    public String getModule() 
    {
        return module;
    }
    public void setNode(String node) 
    {
        this.node = node;
    }

    public String getNode() 
    {
        return node;
    }
    public void setLength(Long length) 
    {
        this.length = length;
    }

    public Long getLength() 
    {
        return length;
    }
    public void setSysTypes(String sysTypes) 
    {
        this.sysTypes = sysTypes;
    }

    public String getSysTypes() 
    {
        return sysTypes;
    }
    public void setFunctionality(String functionality) 
    {
        this.functionality = functionality;
    }

    public String getFunctionality() 
    {
        return functionality;
    }
    public void setSubscribe(Long subscribe) 
    {
        this.subscribe = subscribe;
    }

    public Long getSubscribe() 
    {
        return subscribe;
    }
    public void setrModule(String rModule) 
    {
        this.rModule = rModule;
    }

    public String getrModule() 
    {
        return rModule;
    }
    public void setrFunction(String rFunction) 
    {
        this.rFunction = rFunction;
    }

    public String getrFunction() 
    {
        return rFunction;
    }
    public void setRemarks(String remarks) 
    {
        this.remarks = remarks;
    }

    public String getRemarks() 
    {
        return remarks;
    }

    @Override
    public String toString() {
        return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
            .append("id", getId())
            .append("module", getModule())
            .append("node", getNode())
            .append("length", getLength())
            .append("sysTypes", getSysTypes())
            .append("functionality", getFunctionality())
            .append("subscribe", getSubscribe())
            .append("rModule", getrModule())
            .append("rFunction", getrFunction())
            .append("remarks", getRemarks())
            .toString();
    }
}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/domain/NodeEntity.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,19 @@
package com.jcdm.main.da.opcuaconfig.domain;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@Builder(toBuilder = true)
@AllArgsConstructor
@NoArgsConstructor
public class NodeEntity {

    private Integer index;
    private String identifier;
    private Object value;
    private String type;
    private Integer clientHandle;
}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/domain/OpcuaConf.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,177 @@
package com.jcdm.main.da.opcuaconfig.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import java.io.Serializable;

/**
 * <p>
 * 
 * </p>
 *
 * @author yyt
 * @since 2023-10-17
 */
@TableName("sys_opcua_conf")
public class OpcuaConf implements Serializable {
    private static final long serialVersionUID=1L;

    /**
     * ID
     */
    @TableId(value = "id", type = IdType.ID_WORKER)
    private Long id;

    /**
     * æ‰€å±žæ¨¡å—
     */
    @TableField("module")
    private String module;

    /**
     * èŠ‚点
     */
    @TableField("node")
    private String node;

    /**
     * é•¿åº¦
     */
    @TableField("length")
    private Integer length;

    /**
     * ç±»åž‹
     */
    @TableField("sys_types")
    private String sysTypes;

    /**
     * åŠŸèƒ½è¯´æ˜Ž
     */
    @TableField("functionality")
    private String functionality;

    /**
     * æ˜¯å¦è®¢é˜…
     */
    @TableField("subscribe")
    private Integer subscribe;

    /**
     * è®¢é˜…响应模块
     */
    @TableField("r_module")
    private String rModule;

    /**
     * è®¢é˜…响应函数
     */
    @TableField("r_function")
    private String rFunction;

    /**
     * å¤‡æ³¨
     */
    @TableField("remarks")
    private String remarks;


    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getModule() {
        return module;
    }

    public void setModule(String module) {
        this.module = module;
    }

    public String getNode() {
        return node;
    }

    public void setNode(String node) {
        this.node = node;
    }

    public Integer getLength() {
        return length;
    }

    public void setLength(Integer length) {
        this.length = length;
    }

    public String getSysTypes() {
        return sysTypes;
    }

    public void setSysTypes(String sysTypes) {
        this.sysTypes = sysTypes;
    }

    public String getFunctionality() {
        return functionality;
    }

    public void setFunctionality(String functionality) {
        this.functionality = functionality;
    }

    public Integer getSubscribe() {
        return subscribe;
    }

    public void setSubscribe(Integer subscribe) {
        this.subscribe = subscribe;
    }

    public String getrModule() {
        return rModule;
    }

    public void setrModule(String rModule) {
        this.rModule = rModule;
    }

    public String getrFunction() {
        return rFunction;
    }

    public void setrFunction(String rFunction) {
        this.rFunction = rFunction;
    }

    public String getRemarks() {
        return remarks;
    }

    public void setRemarks(String remarks) {
        this.remarks = remarks;
    }

    @Override
    public String toString() {
        return "OpcuaConf{" +
        "id=" + id +
        ", module=" + module +
        ", node=" + node +
        ", length=" + length +
        ", sysTypes=" + sysTypes + ", " + "functionality=" + functionality +
        ", subscribe=" + subscribe +
        ", rModule=" + rModule +
        ", rFunction=" + rFunction +
        ", remarks=" + remarks +
        "}";
    }
}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/init/BeanUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,30 @@
package com.jcdm.main.da.opcuaconfig.init;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class BeanUtils implements ApplicationContextAware {
    protected static ApplicationContext applicationContext ;

    @Override
    public void setApplicationContext(ApplicationContext arg0) throws BeansException {
        if (applicationContext == null) {
            applicationContext = arg0;
        }

    }
    public static Object getBean(String name) {
        //name表示其他要注入的注解name名
        return applicationContext.getBean(name);
    }

    /**
     * æ‹¿åˆ°ApplicationContext对象实例后就可以手动获取Bean的注入实例对象
     */
    public static <T> T getBean(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }
}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/init/OpcusConfigInit.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,51 @@
package com.jcdm.main.da.opcuaconfig.init;

import com.google.common.collect.Lists;
import com.jcdm.main.da.opcuaconfig.client.ClientHandler;
import com.jcdm.main.da.opcuaconfig.controller.DaOpcuaConfigController;
import com.jcdm.main.da.opcuaconfig.domain.DaOpcuaConfig;
import com.jcdm.main.da.opcuaconfig.domain.NodeEntity;
import com.jcdm.main.da.opcuaconfig.service.IDaOpcuaConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Component
@Slf4j
public class OpcusConfigInit implements CommandLineRunner {

    @Autowired
    private ClientHandler clientHandler;

    @Autowired
    private IDaOpcuaConfigService daOpcuaConfigService;

    @Override
    public void run(String... args) throws Exception {
        try {
            DaOpcuaConfig daOpcuaConfig=new DaOpcuaConfig();
            daOpcuaConfig.setSubscribe(1L); //设置查询条件，是否订阅状态为1的所有数据.
            List<DaOpcuaConfig> nodeslist=daOpcuaConfigService.selectDaOpcuaConfigList(daOpcuaConfig);
            clientHandler.connect();
            if (nodeslist != null && nodeslist.size() > 0) {
                List<NodeEntity> NodeList = Lists.transform(nodeslist, (DaOpcuaConfig) -> {
                    NodeEntity nodeEntity = new NodeEntity();
                    nodeEntity.setIndex(2);
                    nodeEntity.setIdentifier(DaOpcuaConfig.getNode());
                    return nodeEntity;
                });
                clientHandler.subscribe(NodeList);
                log.info("初始化OPC订阅" + nodeslist.size() + "条！");
            }
            log.info("系统提示，OPCUA订阅成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.info("系统提示，OPCUA订阅失败！");
        }
    }
}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/init/Properties.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,57 @@
/**
 * Created by Jellyleo on 2019å¹´12月19日
 * Copyright Â© 2019 jellyleo.com 
 * All rights reserved. 
 */
package com.jcdm.main.da.opcuaconfig.init;

import lombok.Getter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

/**
 * @ClassName: Properties
 * @Description: OpcUa参数
 * @author yyt
 * @date 2023å¹´10月13日
 */
@Getter
@Configuration
@PropertySource("classpath:opcua.properties")
public class Properties {
    @Value("${opcua.server.endpoint.url}")
    private String endpointUrl;
    @Value("${opcua.server.idp.username}")
    private String idpUsername;
    @Value("${opcua.server.idp.password}")
    private String idpPassword;
    @Value("${opcua.client.app.name}")
    private String appName;
    @Value("${opcua.client.app.uri}")
    private String appUri;
    @Value("${opcua.client.cert.path}")
    private String certPath;
    @Value("${opcua.client.cert.file}")
    private String certFile;
    @Value("${opcua.client.cert.alias}")
    private String certAlias;
    @Value("${opcua.client.cert.common.name}")
    private String commonName;
    @Value("${opcua.client.cert.organization}")
    private String organization;
    @Value("${opcua.client.cert.organization.unit}")
    private String orgUnit;
    @Value("${opcua.client.cert.locality.name}")
    private String localityName;
    @Value("${opcua.client.cert.state.name}")
    private String stateName;
    @Value("${opcua.client.cert.country.code}")
    private String countryCode;
    @Value("${opcua.client.cert.dns.name}")
    private String dnsName;
    @Value("${opcua.client.cert.ip.address}")
    private String ipAddress;
    @Value("${opcua.client.cert.keystore.password}")
    private String keyPassword;
}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/mapper/DaOpcuaConfigMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,62 @@
package com.jcdm.main.da.opcuaconfig.mapper;

import com.jcdm.main.da.opcuaconfig.domain.DaOpcuaConfig;

import java.util.List;

/**
 * OPCUA参数设置Mapper接口
 * 
 * @author yyt
 * @date 2023-12-22
 */
public interface DaOpcuaConfigMapper 
{
    /**
     * æŸ¥è¯¢OPCUA参数设置
     * 
     * @param id OPCUA参数设置主键
     * @return OPCUA参数设置
     */
    public DaOpcuaConfig selectDaOpcuaConfigById(Long id);

    /**
     * æŸ¥è¯¢OPCUA参数设置列表
     * 
     * @param daOpcuaConfig OPCUA参数设置
     * @return OPCUA参数设置集合
     */
    public List<DaOpcuaConfig> selectDaOpcuaConfigList(DaOpcuaConfig daOpcuaConfig);

    /**
     * æ–°å¢žOPCUA参数设置
     * 
     * @param daOpcuaConfig OPCUA参数设置
     * @return ç»“æžœ
     */
    public int insertDaOpcuaConfig(DaOpcuaConfig daOpcuaConfig);

    /**
     * ä¿®æ”¹OPCUA参数设置
     * 
     * @param daOpcuaConfig OPCUA参数设置
     * @return ç»“æžœ
     */
    public int updateDaOpcuaConfig(DaOpcuaConfig daOpcuaConfig);

    /**
     * åˆ é™¤OPCUA参数设置
     * 
     * @param id OPCUA参数设置主键
     * @return ç»“æžœ
     */
    public int deleteDaOpcuaConfigById(Long id);

    /**
     * æ‰¹é‡åˆ é™¤OPCUA参数设置
     * 
     * @param ids éœ€è¦åˆ é™¤çš„数据主键集合
     * @return ç»“æžœ
     */
    public int deleteDaOpcuaConfigByIds(Long[] ids);
}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/service/IDaOpcuaConfigService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,62 @@
package com.jcdm.main.da.opcuaconfig.service;

import com.jcdm.main.da.opcuaconfig.domain.DaOpcuaConfig;

import java.util.List;

/**
 * OPCUA参数设置Service接口
 * 
 * @author yyt
 * @date 2023-12-22
 */
public interface IDaOpcuaConfigService 
{
    /**
     * æŸ¥è¯¢OPCUA参数设置
     * 
     * @param id OPCUA参数设置主键
     * @return OPCUA参数设置
     */
    public DaOpcuaConfig selectDaOpcuaConfigById(Long id);

    /**
     * æŸ¥è¯¢OPCUA参数设置列表
     * 
     * @param daOpcuaConfig OPCUA参数设置
     * @return OPCUA参数设置集合
     */
    public List<DaOpcuaConfig> selectDaOpcuaConfigList(DaOpcuaConfig daOpcuaConfig);

    /**
     * æ–°å¢žOPCUA参数设置
     * 
     * @param daOpcuaConfig OPCUA参数设置
     * @return ç»“æžœ
     */
    public int insertDaOpcuaConfig(DaOpcuaConfig daOpcuaConfig);

    /**
     * ä¿®æ”¹OPCUA参数设置
     * 
     * @param daOpcuaConfig OPCUA参数设置
     * @return ç»“æžœ
     */
    public int updateDaOpcuaConfig(DaOpcuaConfig daOpcuaConfig);

    /**
     * æ‰¹é‡åˆ é™¤OPCUA参数设置
     * 
     * @param ids éœ€è¦åˆ é™¤çš„OPCUA参数设置主键集合
     * @return ç»“æžœ
     */
    public int deleteDaOpcuaConfigByIds(Long[] ids);

    /**
     * åˆ é™¤OPCUA参数设置信息
     * 
     * @param id OPCUA参数设置主键
     * @return ç»“æžœ
     */
    public int deleteDaOpcuaConfigById(Long id);
}

 jcdm-main/src/main/java/com/jcdm/main/da/opcuaconfig/service/impl/DaOpcuaConfigServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,94 @@
package com.jcdm.main.da.opcuaconfig.service.impl;

import com.jcdm.main.da.opcuaconfig.domain.DaOpcuaConfig;
import com.jcdm.main.da.opcuaconfig.mapper.DaOpcuaConfigMapper;
import com.jcdm.main.da.opcuaconfig.service.IDaOpcuaConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * OPCUA参数设置Service业务层处理
 * 
 * @author yyt
 * @date 2023-12-22
 */
@Service
public class DaOpcuaConfigServiceImpl implements IDaOpcuaConfigService
{
    @Autowired
    private DaOpcuaConfigMapper daOpcuaConfigMapper;

    /**
     * æŸ¥è¯¢OPCUA参数设置
     * 
     * @param id OPCUA参数设置主键
     * @return OPCUA参数设置
     */
    @Override
    public DaOpcuaConfig selectDaOpcuaConfigById(Long id)
    {
        return daOpcuaConfigMapper.selectDaOpcuaConfigById(id);
    }

    /**
     * æŸ¥è¯¢OPCUA参数设置列表
     * 
     * @param daOpcuaConfig OPCUA参数设置
     * @return OPCUA参数设置
     */
    @Override
    public List<DaOpcuaConfig> selectDaOpcuaConfigList(DaOpcuaConfig daOpcuaConfig)
    {
        return daOpcuaConfigMapper.selectDaOpcuaConfigList(daOpcuaConfig);
    }

    /**
     * æ–°å¢žOPCUA参数设置
     * 
     * @param daOpcuaConfig OPCUA参数设置
     * @return ç»“æžœ
     */
    @Override
    public int insertDaOpcuaConfig(DaOpcuaConfig daOpcuaConfig)
    {
        return daOpcuaConfigMapper.insertDaOpcuaConfig(daOpcuaConfig);
    }

    /**
     * ä¿®æ”¹OPCUA参数设置
     * 
     * @param daOpcuaConfig OPCUA参数设置
     * @return ç»“æžœ
     */
    @Override
    public int updateDaOpcuaConfig(DaOpcuaConfig daOpcuaConfig)
    {
        return daOpcuaConfigMapper.updateDaOpcuaConfig(daOpcuaConfig);
    }

    /**
     * æ‰¹é‡åˆ é™¤OPCUA参数设置
     * 
     * @param ids éœ€è¦åˆ é™¤çš„OPCUA参数设置主键
     * @return ç»“æžœ
     */
    @Override
    public int deleteDaOpcuaConfigByIds(Long[] ids)
    {
        return daOpcuaConfigMapper.deleteDaOpcuaConfigByIds(ids);
    }

    /**
     * åˆ é™¤OPCUA参数设置信息
     * 
     * @param id OPCUA参数设置主键
     * @return ç»“æžœ
     */
    @Override
    public int deleteDaOpcuaConfigById(Long id)
    {
        return daOpcuaConfigMapper.deleteDaOpcuaConfigById(id);
    }
}

 jcdm-main/src/main/resources/mapper/da/opcuaconfig/DaOpcuaConfigMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,97 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jcdm.main.da.opcuaconfig.mapper.DaOpcuaConfigMapper">
    
    <resultMap type="DaOpcuaConfig" id="DaOpcuaConfigResult">
        <result property="id"    column="id"    />
        <result property="module"    column="module"    />
        <result property="node"    column="node"    />
        <result property="length"    column="length"    />
        <result property="sysTypes"    column="sys_types"    />
        <result property="functionality"    column="functionality"    />
        <result property="subscribe"    column="subscribe"    />
        <result property="rModule"    column="r_module"    />
        <result property="rFunction"    column="r_function"    />
        <result property="remarks"    column="remarks"    />
    </resultMap>

    <sql id="selectDaOpcuaConfigVo">
        select id, module, node, length, sys_types, functionality, subscribe, r_module, r_function, remarks from da_opcua_config
    </sql>

    <select id="selectDaOpcuaConfigList" parameterType="DaOpcuaConfig" resultMap="DaOpcuaConfigResult">
        <include refid="selectDaOpcuaConfigVo"/>
        <where>  
            <if test="module != null  and module != ''"> and module like concat('%', #{module}, '%')</if>
            <if test="node != null  and node != ''"> and node like concat('%', #{node}, '%')</if>
            <if test="length != null "> and length = #{length}</if>
            <if test="sysTypes != null  and sysTypes != ''"> and sys_types = #{sysTypes}</if>
            <if test="functionality != null  and functionality != ''"> and functionality like concat('%', #{functionality}, '%')</if>
            <if test="subscribe != null "> and subscribe = #{subscribe}</if>
            <if test="rModule != null  and rModule != ''"> and r_module like concat('%', #{rModule}, '%')</if>
            <if test="rFunction != null  and rFunction != ''"> and r_function like concat('%', #{rFunction}, '%')</if>
        </where>
    </select>
    
    <select id="selectDaOpcuaConfigById" parameterType="Long" resultMap="DaOpcuaConfigResult">
        <include refid="selectDaOpcuaConfigVo"/>
        where id = #{id}
    </select>
        
    <insert id="insertDaOpcuaConfig" parameterType="DaOpcuaConfig">
        insert into da_opcua_config
        <trim prefix="(" suffix=")" suffixOverrides=",">
            <if test="id != null">id,</if>
            <if test="module != null">module,</if>
            <if test="node != null">node,</if>
            <if test="length != null">length,</if>
            <if test="sysTypes != null">sys_types,</if>
            <if test="functionality != null">functionality,</if>
            <if test="subscribe != null">subscribe,</if>
            <if test="rModule != null">r_module,</if>
            <if test="rFunction != null">r_function,</if>
            <if test="remarks != null">remarks,</if>
         </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
            <if test="id != null">#{id},</if>
            <if test="module != null">#{module},</if>
            <if test="node != null">#{node},</if>
            <if test="length != null">#{length},</if>
            <if test="sysTypes != null">#{sysTypes},</if>
            <if test="functionality != null">#{functionality},</if>
            <if test="subscribe != null">#{subscribe},</if>
            <if test="rModule != null">#{rModule},</if>
            <if test="rFunction != null">#{rFunction},</if>
            <if test="remarks != null">#{remarks},</if>
         </trim>
    </insert>

    <update id="updateDaOpcuaConfig" parameterType="DaOpcuaConfig">
        update da_opcua_config
        <trim prefix="SET" suffixOverrides=",">
            <if test="module != null">module = #{module},</if>
            <if test="node != null">node = #{node},</if>
            <if test="length != null">length = #{length},</if>
            <if test="sysTypes != null">sys_types = #{sysTypes},</if>
            <if test="functionality != null">functionality = #{functionality},</if>
            <if test="subscribe != null">subscribe = #{subscribe},</if>
            <if test="rModule != null">r_module = #{rModule},</if>
            <if test="rFunction != null">r_function = #{rFunction},</if>
            <if test="remarks != null">remarks = #{remarks},</if>
        </trim>
        where id = #{id}
    </update>

    <delete id="deleteDaOpcuaConfigById" parameterType="Long">
        delete from da_opcua_config where id = #{id}
    </delete>

    <delete id="deleteDaOpcuaConfigByIds" parameterType="String">
        delete from da_opcua_config where id in 
        <foreach item="id" collection="array" open="(" separator="," close=")">
            #{id}
        </foreach>
    </delete>
</mapper>

 jcdm-main/src/main/resources/opcua.properties

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,20 @@
#opcua server
opcua.server.endpoint.url=opc.tcp://127.0.0.1:49320
opcua.server.idp.username=
opcua.server.idp.password=

#opcua client
opcua.client.app.name=plc
opcua.client.app.uri=urn:Yyt_PC:UnifiedAutomation:UaExpert
opcua.client.cert.path=C:/mes/
opcua.client.cert.file=Yyt_PC-client.pfx
opcua.client.cert.alias=jlclient-ai
opcua.client.cert.common.name=UaClient@Jellyleo
opcua.client.cert.organization=JL
opcua.client.cert.organization.unit=per
opcua.client.cert.locality.name=jl
opcua.client.cert.state.name=JiangSu
opcua.client.cert.country.code=CN
opcua.client.cert.dns.name=Jellyleo
opcua.client.cert.ip.address=administrator
opcua.client.cert.keystore.password=yyt@8888888888