All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.voovan.network.EventProcess Maven / Gradle / Ivy
package org.voovan.network;
import org.omg.PortableServer.POAPackage.ObjectAlreadyActive;
import org.voovan.network.Event.EventName;
import org.voovan.network.exception.IoFilterException;
import org.voovan.network.exception.SendMessageException;
import org.voovan.network.udp.UdpSocket;
import org.voovan.tools.FastThreadLocal;
import org.voovan.tools.TObject;
import org.voovan.tools.collection.Chain;
import org.voovan.tools.buffer.TByteBuffer;
import org.voovan.tools.log.Logger;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.concurrent.TimeoutException;
/**
* 事件的实际逻辑处理
*
* @author helyho
*
* Voovan Framework.
* WebSite: https://github.com/helyho/Voovan
* Licence: Apache v2 License
*/
public class EventProcess {
/**
* 私有构造函数,防止被实例化
*/
private EventProcess(){
}
/**
* Accept事件
*
* @param event
* 事件对象
* @throws IOException IO 异常
*/
public static void onAccepted(Event event) throws IOException {
SocketContext socketContext = event.getSession().socketContext();
socketContext.acceptStart();
}
/**
* 连接成功事件 建立连接完成后出发
*
* @param event 事件对象
* @throws IOException IO 异常
*
*/
public static void onConnect(Event event) throws IOException {
IoSession session = event.getSession();
SocketContext socketContext = event.getSession().socketContext();
if (socketContext != null && session != null) {
Object original = socketContext.handler().onConnect(session);
//null 不发送
if (original != null) {
sendMessage(session, original);
session.flush();
}
}
//设置空闲状态
session.getState().setConnect(false);
}
/**
* 连接断开事件 断开后出发
*
* @param event
* 事件对象
*/
public static void onDisconnect(Event event) {
IoSession session = event.getSession();
session.cancelIdle();
SocketContext socketContext = event.getSession().socketContext();
if (socketContext != null) {
socketContext.handler().onDisconnect(session);
}
session.getState().setClose(false);
}
/**
* 读取事件 在消息接受完成后触发
*
* @param event
* 事件对象
* @throws IOException IO 异常
*/
public static void onRead(Event event) throws IOException {
IoSession session = event.getSession();
if (session != null) {
try {
// 循环读取完整的消息包.
// 由于之前有消息分割器在工作,所以这里读取的消息都是完成的消息包.
// 有可能缓冲区没有读完
// 按消息包触发 onRecive 事件
while (session.getReadByteBufferChannel().size()>0) {
MessageLoader messageLoader = session.getMessageLoader();
int splitLength = messageLoader.read();
if(splitLength>=0) {
doRecive(session, splitLength);
} else {
return;
}
}
} finally {
//释放 onRecive 锁
if (session.getSendByteBufferChannel().size() > 0) {
//异步处理 flush
session.flush();
}
if (session.getReadByteBufferChannel().size() > 0) {
EventTrigger.fireReceiveAsync(session);
}
}
}
}
/**
* 读取分割方法
* @param session 会话对象
* @param splitLength 分割长度
* @return 分割后的数据
*/
public static ByteBuffer loadSplitData(IoSession session, int splitLength) {
if(splitLength == 0){
return TByteBuffer.EMPTY_BYTE_BUFFER;
}
ByteBuffer byteBuffer = TByteBuffer.allocateDirect();
byteBuffer.clear();
//扩容线程本地变量
if (byteBuffer.capacity() < splitLength) {
TByteBuffer.reallocate(byteBuffer, splitLength);
}
try {
byteBuffer.limit(splitLength);
} catch (Exception e){
Logger.error(e);
}
if ((session.socketContext().getConnectType() == ConnectType.UDP && session.isOpen())
|| session.isConnected()) {
session.getReadByteBufferChannel().readHead(byteBuffer);
return byteBuffer;
} else {
return null;
}
}
/**
* 接收的消息处理函数
* @param session 会话对象
* @param splitLength 分割有效自己数
* @return 产生的响应
* @throws IoFilterException 过滤器异常
*/
public static Object doRecive(IoSession session, int splitLength) throws IOException {
Object result = null;
session.getState().setReceive(true);
try {
ByteBuffer byteBuffer = loadSplitData(session, splitLength);
//如果读出的数据为 null 则直接返回
if (byteBuffer == null) {
session.getState().setReceive(false);
return null;
}
// -----------------Filter 解密处理-----------------
result = filterDecoder(session, byteBuffer);
// -------------------------------------------------
// -----------------Handler 业务处理-----------------
if (result != null) {
IoHandler handler = session.socketContext().handler();
result = handler.onReceive(session, result);
}
// --------------------------------------------------
} finally {
session.getState().setReceive(false);
}
// 返回的结果不为空的时候才发送
if (result != null) {
//触发发送事件
session.getState().setSend(true);
sendMessage(session, result);
return result;
} else {
return null;
}
}
/**
* 使用过滤器过滤解码结果
* @param session Session 对象
* @param readedBuffer 需解码的对象
* @return 解码后的对象
* @throws IoFilterException 过滤器异常
*/
public static Object filterDecoder(IoSession session, ByteBuffer readedBuffer) throws IoFilterException{
Object result = readedBuffer;
Chain filterChain = (Chain) session.socketContext().filterChain().clone();
filterChain.rewind();
while (filterChain.hasNext()) {
IoFilter fitler = filterChain.next();
result = fitler.decode(session, result);
if(result == null){
break;
}
}
return result;
}
/**
* 使用过滤器编码结果
* @param session Session 对象
* @param result 需编码的对象
* @return 编码后的对象
* @throws IoFilterException 过滤器异常
*/
public static ByteBuffer filterEncoder(IoSession session, Object result) throws IoFilterException{
Chain filterChain = (Chain) session.socketContext().filterChain().clone();
filterChain.rewind();
while (filterChain.hasPrevious()) {
IoFilter fitler = filterChain.previous();
result = fitler.encode(session, result);
if (result == null) {
break;
}
}
if(result==null){
return null;
} else if(result instanceof ByteBuffer) {
return (ByteBuffer)result;
} else{
throw new IoFilterException("Send object must be ByteBuffer, " +
"please check you filter be sure the latest filter return Object's type is ByteBuffer.");
}
}
/**
* 在一个独立的线程中并行的发送消息
*
* @param session Session 对象
* @param obj 待发送的对象
*/
public static void sendMessage(IoSession session, Object obj) {
final Object sendObj = obj;
try {
// ------------------Filter 加密处理-----------------
ByteBuffer sendBuffer = EventProcess.filterEncoder(session, sendObj);
// ---------------------------------------------------
// 发送消息
if (sendBuffer != null && session.isOpen()) {
if (sendBuffer.limit() > 0) {
int sendLength = session.send(sendBuffer);
if(sendLength >= 0) {
sendBuffer.rewind();
} else {
throw new IOException("EventProcess.sendMessage faild, writeToChannel length: " + sendLength);
}
}
}
//触发发送事件
EventTrigger.fireSent(session, sendObj);
session.getState().setSend(false);
} catch (IOException e) {
EventTrigger.fireException(session, e);
}
}
/**
* 发送完成事件 发送后出发
*
* @param event
* 事件对象
* @param sendObj
* 发送的对象
* @throws IOException IO 异常
*/
public static void onSent(Event event, Object sendObj) throws IOException {
IoSession session = event.getSession();
SocketContext socketContext = session.socketContext();
if (socketContext != null) {
socketContext.handler().onSent(session, sendObj);
}
}
/**
* 发送到 Socket 缓冲区事件
*
* @param event
* 事件对象
* @throws IOException IO 异常
*/
public static void onFlush(Event event) throws IOException {
IoSession session = event.getSession();
SocketContext socketContext = session.socketContext();
if (socketContext != null) {
socketContext.handler().onFlush(session);
}
}
/**
* 空闲事件触发
*
* @param event 事件对象
*/
public static void onIdle(Event event) {
SocketContext socketContext = event.getSession().socketContext();
if (socketContext != null) {
IoSession session = event.getSession();
socketContext.handler().onIdle(session);
}
}
/**
* 异常产生事件 异常产生侯触发
*
* @param event
* 事件对象
* @param e 异常对象
*/
public static void onException(Event event, Exception e) {
IoSession session = event.getSession();
SocketContext socketContext = event.getSession().socketContext();
if (socketContext != null) {
if (socketContext.handler() != null) {
socketContext.handler().onException(session, e);
}
}
}
/**
* 处理异常
* @param event 事件对象
*/
public static void process(Event event) {
if (event == null) {
return;
}
EventName eventName = event.getName();
// 根据事件名称处理事件
try {
if (eventName == EventName.ON_ACCEPTED) {
EventProcess.onAccepted(event);
} else if (eventName == EventName.ON_CONNECT) {
EventProcess.onConnect(event);
} else if (eventName == EventName.ON_DISCONNECT) {
EventProcess.onDisconnect(event);
} else if (eventName == EventName.ON_RECEIVE) {
EventProcess.onRead(event);
} else if (eventName == EventName.ON_SENT) {
EventProcess.onSent(event, event.getOther());
} else if (eventName == EventName.ON_FLUSH) {
EventProcess.onFlush(event);
} else if (eventName == EventName.ON_IDLE) {
EventProcess.onIdle(event);
} else if (eventName == EventName.ON_EXCEPTION) {
EventProcess.onException(event, (Exception)event.getOther());
}
} catch (Exception e) {
EventProcess.onException(event, e);
}
}
}
