Mina框架传递对象
Apache MINA是一个网络应用程序框架，用来帮助用户简单地开发高性能和高可靠性的网络应用程序。它提供了一个通过Java NIO在不同的传输例如TCP/IP和UDP/IP上抽象的事件驱动的异步API。
其中几个主要的组件如下：
I/O Service - 用来处理I/O流，对于Server端就是IOAcceptor的实现类接受Client端的连接请求，对于Client端就是IoConnector的实现类来建立到Server端的连接。
I/O Filter Chain - 用来过滤或转化数据。对于Server端和Client端来说都是IoFilter接口的实现类，MINA自己内建了很多IoFilter接口的实现类。具体可以参考官方文档。
I/O Handler - 用来处理真正业务逻辑的类。对于Server端和Client端来说都是IoHandler接口的实现类，通常来说需要自己编写。
由于Server端和Client端都是基于以上三个组件的，因此对于Server端和Client端编程来说就都有类似的代码结构。
对于Server端来说：
1. 创建I/O service - 这里就是创建IOAcceptor类监听端口。
2. 创建I/O Filter Chain - 这里就是告诉使用那些IoFilter。
3. 创建I/O Handler - 自己的业务逻辑。
对于Client端来说：
1. 创建I/O service - 这里就是创建IOConnector类来建立到Server端的连接。
2. 创建I/O Filter Chain - 这里就是告诉使用那些IoFilter。
3. 创建I/O Handler - 自己的业务逻辑。
对于简单的传输字符串，对mina来说是小菜一碟，当然它也可以用来传输对象。其基本过程为对象（客户端）->字节流（客户端）->发送->接收->字节流（服务器）->对象（服务器）。
服务器端代码（1）
package com.sohu.game.mina.sentObject;
import java.io.IOException;
import java.net.InetSocketAddress;
import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
import org.apache.mina.transport.socket.SocketAcceptor;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
public class MainServer {
private static MainServer mainServer = null;
private SocketAcceptor acceptor = new NioSocketAcceptor();
private DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
private int bindPort = 8887;
public static MainServer getInstances() {
if (null == mainServer) {
mainServer = new MainServer();
}
return mainServer;
}
private MainServer() {
//创建I/O Filter Chain
//ProtocolCodecFilter实例用来编码数据，这里使用了ObjectSerializationCodecFactory类来序列化或反序列化数据成java对象。
chain.addLast("myChin", new ProtocolCodecFilter(
new ObjectSerializationCodecFactory()));
acceptor.setHandler(ServerHandler.getInstances());
try {
//让IoAcceptor类实例绑定端口实现监听
acceptor.bind(new InetSocketAddress(bindPort));
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
MainServer.getInstances();
}
}
服务端代码（2）
package com.sohu.game.mina.sentObject;
import java.util.ArrayList;
import java.util.List;
import org.apache.mina.core.filterchain.IoFilterAdapter;
import org.apache.mina.core.service.IoHandler;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
public class ServerHandler extends IoFilterAdapter implements IoHandler {
private static ServerHandler samplMinaServerHandler = null;
public static ServerHandler getInstances() {
if (null == samplMinaServerHandler) {
samplMinaServerHandler = new ServerHandler();
}
return samplMinaServerHandler;
}
private ServerHandler() {
}
// 当连接后打开时触发此方法，一般此方法与 sessionCreated 会被同时触发
public void sessionOpened(IoSession session) throws Exception {
}
public void sessionClosed(IoSession session) {
}
/**
* 创建I/O Handler，这里主要看一下messageReceived方法，其接收了Object对象，然后又发送了一个Object对象给Client端。
*/
public void messageReceived(IoSession session, Object message)
throws Exception {
if (message instanceof UserInfo) {
UserInfo text = (UserInfo) message;
System.out.println("服务器接收到从客户端的姓名："+text.getName());
System.out.println("服务器接收到从客户端的QQ："+text.getQQNum());
}
if (message instanceof Condition) {
Condition text = (Condition) message;
List<Student> students = text.getStudents();
List<UserInfo> users = text.getUsers();
System.out.println("服务器端接收到从客户端的学生信息数："+students.size());
System.out.println("服务器端接收到从客户端的用户信息数："+users.size());
// System.out.println("服务器接收到从客户端的姓名："+text.getName());
// System.out.println("服务器接收到从客户端的QQ："+text.getQQNum());
} else{
if(message instanceof Student){
System.out.println("哈哈");
}
System.out.println("aaa"+message.getClass());
}
}
public void exceptionCaught(IoSession arg0, Throwable arg1)
throws Exception {
}
// 当消息传送到客户端后触发
public void messageSent(IoSession arg0, Object arg1) throws Exception {
}
// 当一个新客户端连接后触发此方法.
public void sessionCreated(IoSession arg0) throws Exception {
}
// 当连接空闲时触发此方法.
public void sessionIdle(IoSession arg0, IdleStatus arg1) throws Exception {
}
}
公共代码（1）
package com.sohu.game.mina.sentObject;
public class Student implements java.io.Serializable{
private String sname;
private Integer age;
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
公共代码（2）
package com.sohu.game.mina.sentObject;
public class UserInfo implements java.io.Serializable{
private String name;
private String QQNum;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getQQNum() {
return QQNum;
}
public void setQQNum(String qQNum) {
QQNum = qQNum;
}
}
客户端代码（1）
package com.sohu.game.mina.sentObject;
import java.net.InetSocketAddress;
import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
import org.apache.mina.transport.socket.nio.NioSocketConnector;
public class MainClient {
private static MainClient mainClient = null;
NioSocketConnector connector = new NioSocketConnector();
DefaultIoFilterChainBuilder chain = connector.getFilterChain();
public static MainClient getInstances() {
if (null == mainClient) {
mainClient = new MainClient();
}
return mainClient;
}
private MainClient() {
chain.addLast("myChin", new ProtocolCodecFilter(
new ObjectSerializationCodecFactory()));
connector.setHandler(ClientHandler.getInstances());
connector.setConnectTimeout(30);
connector.setConnectTimeoutMillis(30000);
ConnectFuture cf = connector.connect(new InetSocketAddress("localhost",
8887));
}
public static void main(String args[]) {
MainClient.getInstances();
}
}
客户端代码（2）
package com.sohu.game.mina.sentObject;
import java.util.ArrayList;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;
public class ClientHandler extends IoHandlerAdapter {
private static ClientHandler samplMinaClientHandler = null;
public static ClientHandler getInstances() {
if (null == samplMinaClientHandler) {
samplMinaClientHandler = new ClientHandler();
}
return samplMinaClientHandler;
}
private ClientHandler() {
}
public void sessionOpened(IoSession session) throws Exception {
session.write("客户端与服务器的会话打开了……");
UserInfo text=new UserInfo();
text.setName("梅竹寒香");
text.setQQNum("972341215");
Student s1 = new Student();
s1.setAge(89);
s1.setSname("bianzhe");
Student s2 = new Student();
s2.setAge(88);
s2.setSname("ganxin");
Condition con = new Condition();
ArrayList<Student> students = new ArrayList<Student>();
students.add(s1);
students.add(s2);
con.setStudents(students);
ArrayList<UserInfo> users = new ArrayList<UserInfo>();
users.add(text);
con.setUsers(users);
//session.write(con);
session.write(con);
//session.write(text);
}
public void sessionClosed(IoSession session) {
}
public void messageReceived(IoSession session, Object message)
throws Exception {
}
public void messageSent(IoSession arg0, Object arg1) throws Exception {
System.out.println("客户端已经向服务器发送了："+(String)arg1);
}
}
以上即是通过mina简单传递对象的过程。