utgard OPC 主要功能简介

度娘还行，尽管不好用，但所有的开发人员不懈努力地写博客，能得到很多东西！ 这里向所有未谋面的博主们致敬！

搜了一堆OPC资料，在这里整理一下，用一个封装类来说明utgard的主要接口。使用了java自带的观察者模式，回调通知检测点数据；

1. opc客户端主类

public class OpcClient extends Observable {

　　private Server mServer = null;

/**
* 连接opc server
*/
public synchronized boolean connectServer(String host, String progId, String user, String password, String domain) {
　　boolean mState = false;
　　ServerList serverList = null;
　　try {
　　// 获取server上的opc server应用列表
　　serverList = new ServerList(host, user, password, domain);

　　// 连接server
　　final ConnectionInformation connectionInfo = new ConnectionInformation();
　　connectionInfo.setHost(host);
　　connectionInfo.setClsid(serverList.getClsIdFromProgId(progId));// TODO 设置ProgId，无法连接server；设置Clsid，连接server成功
　　connectionInfo.setUser(user);
　　connectionInfo.setPassword(password);

　　ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
　　mServer = new Server(connectionInfo, executor);
　　mServer.connect();

　　mServer.addStateListener(new ServerConnectionStateListener() {
　　　　@Override
　　　　public void connectionStateChanged(boolean state) {
　　　　System.out.println("connectionStateChanged state=" + state);
　　　　}
　　});

　　mState = true;
} catch (IllegalArgumentException e) {
　　e.printStackTrace();
} catch (UnknownHostException e) {
　　e.printStackTrace();
} catch (JIException e) {
　　e.printStackTrace();
} catch (AlreadyConnectedException e) {
　　e.printStackTrace();
} finally {
　　if (!mState) {
　　mServer = null;
　　}
}

return mState;
}

/**
* 断开连接opc server
*/
public synchronized void disconnectServer() {
　　if (mServer == null) {
　　return;
　　}
　　mServer.disconnect();
　　mServer = null;
}

/*
* 显示server上的OPC服务器应用列表
*/
public void showAllOPCServer(String host, String user, String password, String domain) {
　　try {
　　　　ServerList serverList = new ServerList(host, user, password, domain);
　　　　// 支持DA 1.0，DA 2.0规范
　　　　Collection<ClassDetails> detailsList = serverList.listServersWithDetails(
　　　　new Category[] { Categories.OPCDAServer10, Categories.OPCDAServer20 }, new Category[] {});
　　　　for (final ClassDetails details : detailsList) {
　　　　　　System.out.println("ClsId=" + details.getClsId() + " ProgId=" + details.getProgId() + " Description="
　　　　　　+ details.getDescription());
　　　　}
　　} catch (Exception e) {
　　　　e.printStackTrace();
　　}
}

/**
* 检查opc server中是否包含指定的监测点列表
*/
public boolean checkItemList(List<String> list) {
　　// 获取opc server上的所有检测点
　　FlatBrowser flatBrowser = mServer.getFlatBrowser();
　　if (flatBrowser == null) {
　　　　return false;
　　}

　　try {
　　　　Collection<String> collection = flatBrowser.browse();
　　　　return collection.containsAll(list);
　　} catch (Exception e) {
　　　　e.printStackTrace();
　　}
　　return false;
}

/**
* 异步读取数据 Async20Access实现了IOPCDataCallback接口，基于事件回调的实现
*/
public void asyncReadObject(final String itemId, int period) {
　　// 第三个参数用于设置初始化时是否执行访问
　　AccessBase accessBase;
　　try {
　　　　accessBase = new Async20Access(mServer, period, false);
　　　　accessBase.addItem(itemId, new DataCallback() {
　　　　@Override
　　　　public void changed(Item item, ItemState itemState) {
　　　　　　System.out.println("asyncReadObject item=" + itemState);
　　　　　　try {
　　　　　　　　Object value = itemState.getValue().getObject();
　　　　　　　　setData(itemId, value);
　　　　　　　　} catch (JIException e) {
　　　　　　　　　　e.printStackTrace();
　　　　　　　　}
　　　　　　}
　　　　});
　　// 开始读取
　　accessBase.bind();
　　} catch (IllegalArgumentException e) {
　　　　e.printStackTrace();
　　} catch (UnknownHostException e) {
　　　　e.printStackTrace();
　　} catch (NotConnectedException e) {
　　　　e.printStackTrace();
　　} catch (JIException e) {
　　　　e.printStackTrace();
　　} catch (DuplicateGroupException e) {
　　　　e.printStackTrace();
　　} catch (AddFailedException e) {
　　　　e.printStackTrace();
　　}
}

/**
* 同步读取数据
*/
public void syncReadObject(final String itemId, int period) {
　　AccessBase accessBase;
　　try {
　　　　// SyncAccess会开启一个线程，按照period时间间隔，定时去获取监控点数据

　　　　accessBase = new SyncAccess(mServer, period);

　　　　//这个好像用处不太大
　　　　accessBase.addStateListener(new AccessStateListener() {
　　　　　　@Override
　　　　　　public void stateChanged(boolean state) {
　　　　　　　　System.out.println("stateChanged state=" + state);
　　　　　　}

　　　　　　@Override
　　　　　　public void errorOccured(Throwable arg) {
　　　　　　System.out.println("errorOccured arg=" + arg);
　　　　　　}
　　　　});

　　　　accessBase.addItem(itemId, new DataCallback() {
　　　　　　@Override
　　　　　　public void changed(Item item, ItemState itemState) {
　　　　　　System.out.println("syncReadObject item=" + itemState);
　　　　　　if (itemState == null) {
　　　　　　　　System.out.println("itemState is null");
　　　　　　　　return;
　　　　　　}

　　　　　try {
　　　　　　　　Object value = itemState.getValue().getObject();
　　　　　　　　setData(itemId, value);
　　　　　　} catch (JIException e) {
　　　　　　　　e.printStackTrace();
　　　　　　　　}
　　　　　　}
　　　　});

　　// 开始读取
　　accessBase.bind();
　　// 解除绑定，停止读取
　　// accessBase.unbind();
　　} catch (IllegalArgumentException e) {
　　　　e.printStackTrace();
　　} catch (UnknownHostException e) {
　　　　e.printStackTrace();
　　} catch (NotConnectedException e) {
　　　　e.printStackTrace();
　　} catch (JIException e) {
　　　　e.printStackTrace();
　　} catch (DuplicateGroupException e) {
　　　　e.printStackTrace();
　　} catch (AddFailedException e) {
　　　　e.printStackTrace();
　　}
}

/**
* 加入观察者
*/
public void subscribe(Observer observer) {
　　this.addObserver(observer);
}

/**
* 数据变化，通知观察者
*/
private void setData(String itemId, Object value) {
　　setChanged();
　　notifyObservers(new Result(itemId, value));
　　}
}

2. 检测点数据Result.java

　　public class Result {
　　　　private String itemId;// 监控位置
　　　　private Object value;// 监控值

　　　　public Result(String itemId, Object value) {
　　　　　　this.itemId = itemId;
　　　　　　this.value = value;
　　　　}

　　　　public String getItemId() {
　　　　　　return itemId;
　　　　}

　　　　public Object getValue() {
　　　　　　return value;
　　　　}

　　　　@Override
　　　　public String toString() {
　　　　　　return "[itemId=" + itemId + ", value=" + value + "]";
　　　　}
　　}

测试：

public class Main {
　　public static void main(String[] args) {
　　　　String host = "127.0.0.1";// server
　　　　String domain = "";// domain
　　　　String progId = "ICONICS.SimulatorOPCDA.2";
　　　　String user = "OpcUser";// server上的访问用户
　　　　String password = "xxxxxx";// 访问用户的密码

　　　　OpcClient opcClient = new OpcClient();
　　　　// 1.显示server上的opc server应用列表
　　　　opcClient.showAllOPCServer(host, user, password, domain);

　　　　// 2.连接指定的opc server
　　　　boolean ret = opcClient.connectServer(host, progId, user, password, domain);
　　　　if (!ret) {
　　　　　　System.out.println("connect opc server fail");
　　　　　　return;
　　　　}

　　　　// 3.检查opc server上的检测点
　　　　List<String> itemIdList = new ArrayList<String>();
　　　　itemIdList.add("TEST.FA");
　　　　itemIdList.add("TEST.FB");
　　　　ret = opcClient.checkItemList(itemIdList);
　　　　if (!ret) {
　　　　　　System.out.println("not contain item list");
　　　　　　return;
　　　　}

　　　　// 4.注册回调
　　　　opcClient.subscribe(new Observer() {
　　　　　　@Override
　　　　　　public void update(Observable observable, Object arg) {
　　　　　　Result result = (Result) arg;
　　　　　　System.out.println("update result=" + result);
　　　　　　}
　　　　});

　　　　// 5.添加监听检测点的数据
　　　　// client和server在不同网段，可以访问
　　　　opcClient.syncReadObject("TEST.FA", 500);
　　　　/**
　　　　* TODO 问题
　　　　* client和server在不同网段，访问失败，比如：server为10.1.1.132，该网段下面又连接了扩展路由器，192.168.1.x，client为192.168.1.100
　　　　*/
　　　　opcClient.asyncReadObject("TEST.FB", 500);

　　　　// 延迟
　　　　delay(5 * 60 * 1000);
　　　}

　　　　private static void delay(long time) {
　　　　　　try {
　　　　　　　　Thread.sleep(time);
　　　　　　} catch (InterruptedException e) {
　　　　　　　　e.printStackTrace();
　　　　　　}
　　　　}
　　}