毕设项目，系统搭建笔记文档

代码结构：



主体系统启动流程：

在dynamic web project中添加全局监听类RootListener，继承ServletContextListener接口，实现public void contextInitialized(ServletContextEvent sce)，调用系统初始化入口类ArchtechRoot。在ArchtechRoot中根据spring配置文件进行系统各模块的初始化。从root bean读取SystemInitDO，用于获取配置文件中的子配置文件，即各层模块配置文件，并将其中的bean进行装配。RPCServer为RPC服务的基础server模块，对应rpcRoot bean。

ApplicationContext context = new ClassPathXmlApplicationContext("springContext-*.xml");
SystemInitDO initDO = (SystemInitDO) context.getBean("root");
RPCServer rpcRoot = (RPCServer) context.getBean("rpcRoot");

子配置文件：

<bean id="root" class=" com.multiagent.hawklithm.davinci.init.SystemInitDO">
<property name="configFileList">
<list>
<value>spring-config/spring-asyntask.xml</value>
<value>spring-config/spring-EventListener.xml</value>
<value>spring-config/spring-dao.xml</value>
<value>spring-config/spring-manager.xml</value>
<value>spring-config/spring-module.xml</value>
<value>spring-config/spring-ibatis.xml</value>
<value>spring-config/spring-net.xml</value>
<value>spring-config/spring-transaction.xml</value>
<value>spring-config/spring-session.xml</value>
</list>
</property>
</bean>

子配置文件中几个关键注册管理机

bean 分类注册管理机

<!-- bean分类注册管理机 -->
<bean class="com.multiagent.hawklithm.davinci.init.AutoRegister"/>

异步任务注册机

<!-- 异步任务注册机 -->
<bean id="asynTaskRegManager" class="com.multiagent.hawklithm.davinci.AsynTaskRegisterMachine" />

消息注册管理机

<!-- 消息注册管理机 -->
<bean id=" wardenManager" class="com.multiagent.hawklithm.shadowsong.manager.WardenManager"/>

生产过程模块管理机

<!-- 生产过程模块管理注册机 -->
<bean id="pmRegManager" class="com.multiagent.hawklithm.leon.manager.ProcessModuleRegisterManager"/>

bean注册管理机

public class AutoRegister implements BeanPostProcessor {
private AsynTaskRegisterMachine asynTaskRegManager;
private ProxyFactoryBean accountService;
private ProcessModuleRegisterManager pmRegManager;

public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
if (bean instanceof AsynTaskRegister) {
System.out.println("bean name: "+beanName+" regist AsynTaskRegister");
asynTaskRegManager.regist(bean);//异步任务注册
}else if (bean instanceof IProcessModule){
System.out.println("bean name: "+beanName+" regist EquipmentObject");
pmRegManager.regist(bean);//过程模块注册
}
return bean;
}

}

如代码所示，根据类类型就行分类注册

RPC接口注册：

RPC接口定义在springContext-rpc.xml中

如以下示例接口定义

<bean class="com.multiagent.hawklithm.davinci.rpc.DO.RPCSystemServerProxy">
<property name="interfaceName" value="com.multiagent.hawklithm.rpc.Interfacetest"/>
<property name="version" value="1.0.0.hawk"/>
<property name="className" value="com.multiagent.hawklithm.rpc.impl.ImplTest"/>
<property name="comment" value="此处填写接口介绍"/>
<property name="visible" value="true" />
</bean>

RPCServer创建

<bean id="rpcRoot" class="com.multiagent.hawklithm.davinci.rpc.Server.RPCServer">
<constructor-arg>
<value>10007</value>
</constructor-arg>

</bean>

在RPCServer.java中，Rpc接口bean注册

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof RPCSystemServerProxy) {
RPCregManager.regist((RPCSystemServerProxy) bean);
}
return bean;
}

将已注册RPC接口与已注册模块关联：

ArchtechRoot.java

对已填充beanId字段的RPC接口类进行关联

for (RPCSystemServerProxy object : rpcRoot.getRPCregManager().getRegList()) {
if (StringUtils.hasLength(object.getBeanId())) {
try {
Object target = tempContext.getBean(object.getBeanId());
object.setTarget(target);
System.out.println(object.getInterfaceName() + "关联成功");
} catch (NoSuchBeanDefinitionException e) {
// TODO 打印日志RPC配置文件中bean缺失
System.out.println("RPC配置文件中缺失bean:[" + object.getBeanId() + "]");
}
}
}

对未填充beanId字段的RPC接口类进行实例创建(目前均使用单例模式)

for (RPCSystemServerProxy object : rpcRoot.getRPCregManager().getRegList()) {
if (!object.isLinked()) {
object.setTarget(Class.forName(object.getClassName()).newInstance());
System.out.println(object.getClassName() + "生成实例成功");
}
}

以上完成所有模块的创建和注册关联工作

启动异步任务注册机中的所有异步任务：

regManager.startAll();

消息注册部分Shadowsong

消息注册管理机WardenManager.java

public class WardenManager implements IRegisterManager, IMessagePusher<WardenMessage> {

public boolean regist(Object object) {
/**具体见源码*/
}

/**
* Warden接收消息的异步线程
* @author hawklithm
*
*/
private class WardenThread implements Runnable {
/**具体见源码*/
@Override
public void run() {
object.receiveMessage(message);
}

}

/**
* 推送消息
*/
public void push(WardenMessage message) {
Set<Warden> list = map.get(message.getKind());
for (Warden object : list) {
exec.execute(new WardenThread(object, message));
}
}

}

使用消息注册机时先进行消息注册

wardenManager.registWarden(new Warden(“MessageReceiver”, “MessageType”) {

//message对应消息结构体WardenMessage中的note属性
@Override
public void asynchronizedProcess(String message) {
/**接收到消息后的行为*/
}

});

发送消息：

wardenManager.push(message);

message类型为WardenMessage

纯虚类EquipmentObjetc类型继承了WardenOperator接口实现方法

public void sendOutMessage(WardenMessage message) {
wardenManager.push(message);
}

所以继承了EquipmentObject的类直接调用sendOutMessage(WardenMessage message)即可。

举例：

读卡器模块初始化时(读卡器模块继承了EquipmentObject)

this.registWarden(new Warden(String.valueOf(this.getRfid()) + WardenMessage.TARGET_TYPE_READER, WardenMessage.KIND_NEW_DATA_COMING + WardenMessage.DIR_ENTER) {

@Override
public void asynchronizedProcess(String message) {
WardenMessage wardenMessage = new WardenMessage();
wardenMessage.setNote(message);
wardenMessage.setTarget(String.valueOf(targetRFID) + targetKind);
wardenMessage.setKind(targetMessageKind + targetMessageDir);
sendOutMessage(wardenMessage);
}

});

以上代码截取自Reader.java表示在接收到warden消息后将其信息实体取出并重新定义warden消息的目标和类型并转发，我们现在做一个约定：

消息接收者：目标RFID+目标类型

消息类型：消息类型+消息流向

WardenMessage.java中展示预设了几种消息类型

/**
* 消息类型
*/
public static String KIND_RFID_FROM_READER = "wm_rfidfromreader";//从读卡器模块发送来的RFID数据
public static String KIND_NEW_DATA_COMING = "new_data_coming";//接收到从RFID实体来的数据
/**
* 目标类型
*/
public static String TARGET_TYPE_READER = "target_type_reader";//数据接收目标类型为读卡器
public static String TARGET_TYPE_MACHINE = "target_type_machine";//数据接收目标类型为设备模块
/**
* 数据流方向
*/
public static String DIR_ENTER = "wm_enter";
public static String DIR_EXIT = "wm_exit";

模块间信息交互和数据传输均可使用该消息系统

生产过程管理模块（静态模块系统leon）

public class ProcessModuleRegisterManager implements IRegisterManager {
private List<IProcessModule> regList = new ArrayList<IProcessModule>();
public boolean regist(Object thing) {
/**过程模块注册*/
}

public IProcessModule getProcessModuleByName(String name) throws ProcessModuleNotFoundException {
/**根据模块名称(ID)获取已注册的过程模块*/
}

public EquipmentObject getEquipmentByRFID(int id) throws ProcessModuleNotFoundException {
/**根据设备名称（ID）获取已注册的过程模块中的设备模块*/
}
}

过程注册模块中包含所有已注册的过程模块信息

生产过程模块（静态模块）：

统一继承IProcessModule，具体见IProcessModule.java

public interface IProcessModule {
/**
* 获取模块名称
* @return 模块名称
*/
String getName();
/**
* 根据设备RFID从过程模块中获取设备
* @param id 设备RFID
* @return
* @throws EquipmentNotFoundException
*/
EquipmentObject getEquipmentByRFID(int id) throws EquipmentNotFoundException;
}

在过程模块中建立设备列表，通过spring bean注入设备，可达到过程对设备的一个管理，实例见SortingProcess.java

对应bean的spring配置参考spring-module.xml，如下：

<bean id="sorting_process_module" class="com.multiagent.hawklithm.leon.process.SortingProcess">
<property name="equipmentList">
<list>
<ref bean="reader1"/>
<ref bean="sorting_equipment1" />
<ref bean="reader2" />
<ref bean="singleRead3"/>
<ref bean="sorting_equipment2" />

</list>
</property>
</bean>

设备模块

统一继承纯虚类EquipmentObject，在EquipmentObject.java中已实现设备的基本功能方法

public abstract class EquipmentObject implements Module, WardenOperator {
private int rfid ;
private Set<Integer> itemRFIDs = new HashSet<Integer>();
private Set<Integer> packageRFIDs = new HashSet<Integer>();
private int staffRFID;
private WardenManager wardenManager;

/**
* 设置设备属性
*/
abstract public void doSetEquipmentParameter();

/**
* 获取设备属性
* @return
*/
abstract public String doGetEquipmentSummaryInfo();

/**
* 初始化Warden
*/
abstract public void initWarden();

public void sendOutMessage(WardenMessage message) {
wardenManager.push(message);
}

public void registWarden(Warden warden) {
wardenManager.regist(warden);
}

public void addItem(int RFID) {
itemRFIDs.add(Integer.valueOf(RFID));
}

public void addPackage(int RFID) {
packageRFIDs.add(Integer.valueOf(RFID));
}

public boolean removeItem(int RFID) {
return itemRFIDs.remove(Integer.valueOf(RFID));
}

public boolean removePackage(int RFID) {
return packageRFIDs.remove(Integer.valueOf(RFID));
}

// public EquipmentObject() {
// warden = new Warden(this);
// wardenManager.regist(warden);
// }

public String doGetModuleSummaryInfo() {
return doGetEquipmentSummaryInfo();
}

public int getStaffRFID() {
return staffRFID;
}

public void setStaffRFID(int staffRFID) {
this.staffRFID = staffRFID;
}

public WardenManager getWardenManager() {
return wardenManager;
}

public void setWardenManager(WardenManager wardenManager) {
this.wardenManager = wardenManager;
}
}

在配置设备bean时注意设置init-method="initWarden"从而调用initWarden函数进行消息注册

例：

<bean id="sorting_equipment1"    class="com.multiagent.hawklithm.leon.module.SortingEquipmentModule"  init-method="initWarden" >
<property name="rfid" value="1024"/>
</bean>

initWarden中的注册warden见上文消息注册管理Shadowsong部分，具体实现见com.multiagent.hawklithm.leon.module包下的模块类

RPC系统

rpc client端在rpc工程中，server端在davinci中,rpc所有spring bean配置文件均在springContext-rpc.xml中，rpc接口信息通过interfaceInfoDAO保存到数据库中。

RPCServer.java

在initNetty()函数中创建Netty服务端实现通信

private void initNetty() {
ServerBootstrap bootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(Executors.newCachedThreadPool(), Executors.newCachedThreadPool()));
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {

@Override
public ChannelPipeline getPipeline() throws Exception {
ChannelPipeline pipeline = Channels.pipeline();
pipeline.addLast("UP_FRAME_HANDLER", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 2, 0, 2));
pipeline.addLast("DOWN_FRAME_HANDLER", new LengthFieldPrepender(2, false));
pipeline.addLast("myHandler", rpcServerNettyHandler);
// return Channels.pipeline(rpcServerNettyHandler);
return pipeline;
}

});
bootstrap.bind(new InetSocketAddress(port));
System.out.println("RPC server开启成功");
}

NettyHandler继承SimpleChannelHandler对通信接口进行一些基本封装

public class NettyHandler extends SimpleChannelHandler {

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
throws Exception {
/**接收到数据将通信相关数据取出并传入onMessageReceived方法*/
ChannelBuffer buffer = (ChannelBuffer) e.getMessage();
String recvMsg=buffer.toString(Charset.defaultCharset());
System.out.println("receive: " +recvMsg);
onMessageReceived(recvMsg,e.getChannel());
}

@Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
throws Exception {
/**异常处理*/
}

public void sendMessage(String message,Channel channel) throws MessageTransportException {
if (channel == null) {
throw new MessageTransportException(new NullPointerException());
}
ChannelBuffer buffer = ChannelBuffers.buffer(message.length());
buffer.writeBytes(message.getBytes());
channel.write(buffer);
}
/**
* 重写该函数可获取传输数据
*/
public void onMessageReceived(String message,Channel channel) throws MessageTransportException {

}
}

RPCServerNettyHandler继承NettyHandler

重写onMessageReceived

@Override
public void onMessageReceived(String msg, Channel cha) throws MessageTransportException {
System.out.println(msg);
RPCSystemProtocol rpcMessage = gson.fromJson(msg, RPCSystemProtocol.class);
if (!aclManager.verifyRPCInterfaceCall(rpcMessage)) {//权限控制
rpcMessage.setReturnObject("have no permission");
return;
}
if (!rpcMessage.selfCheck()) {//数据自检
throw new MessageTransportException("RPC包错误");
}
try {
Object instance = RPCregManager.getTarget(rpcMessage);
Object ret = rpcExec.exec(rpcMessage.getClassName(), rpcMessage.getMethodName(), rpcMessage.getParamsType(), instance, rpcMessage.getParameters());//通过反射机制调用响应类的方法执行并得出结果
rpcMessage.setReturnObject(gson.toJson(ret));
if (!watcher.insert(new RPCConnectInfo(gson.toJson(rpcMessage), cha))) {//将需要返回的结果插入发送队列，由于开发RPC时还没有开始设计消息管理中心，所以使用其独立的RPCBufferCallBackWatcher类进行返回数据队列的管理，详见RPCBufferCallBackWatcher
// TODO 打印日志
}
} catch (RPCInterfaceNotFoundException e) {
// TODO 打印日志
e.printStackTrace();
return;
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return;
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return;
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return;
}
}

rpc client端

客户端进行RPC调用思路：

在配置文件中注册需要使用rpc的bean，通过该bean获取一个实例并使用对应的接口方法，利用spring的特性对该接口方法进行代理，将方法的实现转换成netty通信，把调用方法的参数发送给rpc server，并在rpcLockManager中进行一个注册并阻塞当前方法执行线程，等待server返回结果；当server返回结果后，在rpcLockManager中对等待结果的调用进行解锁并唤醒线程，传入server发过来的结果，再又代理返回方法调用结果。使客户端程序员的编码结构不发生任何改变的情况下实现远程调用。

RPCClient.java

基本上和RCPServer.java类似，不过这里创建的是netty服务端

public void initRPCClient() {
ClientBootstrap bootstrap = new ClientBootstrap(new NioClientSocketChannelFactory(Executors.newCachedThreadPool(), Executors.newCachedThreadPool()));
handler = new NettyHandler() {

private Gson gson = new Gson();

@Override
public void onMessageReceived(String msg, Channel cha) throws MessageTransportException {
RPCSystemProtocol rpcMessage = gson.fromJson(msg, RPCSystemProtocol.class);
if (!rpcMessage.selfCheck()) {
throw new MessageTransportException("RPC包错误");
}
// announcer.insert(rpcMessage);
lockManager.AnswerReceived(rpcMessage.uuid, rpcMessage);//接收到服务端回复后将结果返回并将rpc调用解锁

}

@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
channel = e.getChannel();
}
};
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() throws Exception {
ChannelPipeline pipeline = Channels.pipeline();
pipeline.addLast("UP_FRAME_HANDLER", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 2, 0, 2));
pipeline.addLast("DOWN_FRAME_HANDLER", new LengthFieldPrepender(2, false));
// return Channels.pipeline(handler);
pipeline.addLast("myHandler", handler);
return pipeline;
}
});
bootstrap.connect(new InetSocketAddress(address, port));
}

用SpringMethodInterceptor对rpc调用类的实现进行代理

public class SpringMethodInterceptor implements MethodInterceptor {

public Object invoke(MethodInvocation inv) throws Throwable {
System.out.println(inv.getMethod().getDeclaringClass().getName() + " " + inv.getArguments());
String version=rpcProxyRegManager.getVersion(inv.getMethod().getDeclaringClass().getName());
RPCSystemProtocol message=RPCSystemProtocolPackageUtil.getRPCProtocolPackage(inv.getMethod(),inv.getArguments(),version);
rpcClient.sendRPCProtocol(message);//发送调用协议
UUID uuidOrigin=message.uuid;
RPCSystemProtocol recvMessage=lockManager.waitforAnswer(uuidOrigin);//阻塞当前线程，等待rpcServer返回调用结果
Class<?> returnType=inv.getMethod().getReturnType();
return gson.fromJson(recvMessage.getReturnObject(),returnType);

}

}

读卡器部分:

采用netty接收读卡器数据

public void initReaderServer() {
ServerBootstrap bootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(Executors.newCachedThreadPool(), Executors.newCachedThreadPool()));
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {

@Override
public ChannelPipeline getPipeline() throws Exception {
ChannelPipeline pipeline = Channels.pipeline();
pipeline.addLast("UP_FRAME_HANDLER", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 2, 0, 2));
pipeline.addLast("DOWN_FRAME_HANDLER", new LengthFieldPrepender(2, false));
pipeline.addLast("myHandler", readerNettyHandler);
// return Channels.pipeline(rpcServerNettyHandler);
return pipeline;
}

});
bootstrap.bind(new InetSocketAddress(port));
System.out.println("reader data server开启成功");
}

接收到读卡器数据后的操作如下，详见ReaderDataManager.java

public void OriginalDataDealing(RFIDOriginalInfos infos){
submitData(infos.getInfos());//存入数据库
sendOutDataComingMessage(infos);//发送消息给读卡器模块进行状态定义
}

通过消息中心将接收到的读卡器数据推送给读卡器模块

private void sendOutDataComingMessage(RFIDOriginalInfos infos){
WardenMessage msg=new WardenMessage();
msg.setKind(WardenMessage.KIND_NEW_DATA_COMING+WardenMessage.DIR_ENTER);
String target="";
for (String s:infos.getTargets()){
target+=s+WardenMessage.TARGET_TYPE_READER+"|";
}
msg.setTarget(target);

msg.setNote(gson.toJson(infos.getInfos()));
readerMessageComingPusher.sendOutMessage(msg);
}

由上文设备模块的创建方法可创建读卡器设备模块，详情见Reader.java

public class Reader extends EquipmentObject {

private int targetRFID = 0;
private String targetMessageKind = "";
private String targetKind = "";
private String targetMessageDir = "";

@Override
public void initWarden() {

this.registWarden(new Warden(String.valueOf(this.getRfid()) + WardenMessage.TARGET_TYPE_READER, WardenMessage.KIND_NEW_DATA_COMING + WardenMessage.DIR_ENTER) {

@Override
public void asynchronizedProcess(String message) {
WardenMessage wardenMessage = new WardenMessage();
wardenMessage.setNote(message);
wardenMessage.setTarget(String.valueOf(targetRFID) + targetKind);
wardenMessage.setKind(targetMessageKind + targetMessageDir);
sendOutMessage(wardenMessage);
}

});
}

}

在reader模块中注册了对读卡器新接收到数据的信息的监听