nio/mina(三) mina传对象

参考文章:http://blog.chinabyte.com/a/534099.html

传递对象的原因:个人理解:符合面向对象,服务器接收客户端消息,需要解析,处理,应答,如果传的是对象,可以把解析,处理,应答写在对象里,这么做,扩展性更好.

客户端

1 MinaClient.java

package com.nafio.client;

import java.net.InetSocketAddress;
import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
import org.apache.mina.transport.socket.nio.NioSocketConnector;

/**
 * @author nafio 2012-08-20
 * mina传递对象客户端
 */
public class MinaClient {        
	//使用单例模式
	private static MinaClient minaClient = null;
	//创建 TCP/IP connector
	NioSocketConnector connector = new NioSocketConnector();
	//创建接收数据的过滤器
	DefaultIoFilterChainBuilder chain = connector.getFilterChain();
	
	//使用单例
	//相关的IoHandlerAdapter继承类都采用了单实例模式
	//在整个通信过程中做到对象session等实例的单一防止发生“所托非人”的现象//这个不是很理解?
	public static MinaClient getInstances() {    
		if (null == minaClient) {                
			minaClient = new MinaClient();    
		}            
		return minaClient;    
	}        
	private MinaClient() {
		//设定这个过滤器将按对象读取数据
		chain.addLast("myChin", new ProtocolCodecFilter(    
				new ObjectSerializationCodecFactory()));           
		connector.setHandler(ClientHandler.getInstances(connector));//by nafio用于彻底关闭客户端连接
		//设定连接超时
		connector.setConnectTimeout(30);
		//连接服务器
		ConnectFuture cf = connector.connect(new InetSocketAddress("localhost",    
			8888));        
		
	}    
	public static void main(String args[]) {    
		MinaClient.getInstances();        
	}    
}  

2 ClientHandler.java

package com.nafio.client;

import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.transport.socket.nio.NioSocketConnector;

import com.nafio.obj.TransferObj;

/**
 * @author nafio 2012-08-20
 * mina传递对象客户端
 */
public class ClientHandler extends IoHandlerAdapter {    
	private static ClientHandler minaClientHandler = null;

	NioSocketConnector connector;//by nafio用于彻底关闭客户端连接
	public static ClientHandler getInstances(NioSocketConnector con) {    
		if (null == minaClientHandler) {
			minaClientHandler = new ClientHandler(con);
		}
		return minaClientHandler;
	}        
	private ClientHandler(NioSocketConnector con) {
		connector=con;
	}        

	public void sessionOpened(IoSession session) throws Exception {
		//session.write("来自客户端:与服务端会话打开");    
		
		System.out.println("客户端:打开了与服务端的会话");
		sendMsg(session);
	}

	//会话结束后触发
	public void sessionClosed(IoSession session) {
		System.out.println("客户端:与服务端会话结束");
	}
	//接到返回信息后触发
	public void messageReceived(IoSession session, Object message)throws Exception {
		System.out.println("客户端:接收到服务端返回信息");
	}

	//连接创建时触发
	public void sessionCreated(IoSession session) throws Exception {
		super.sessionCreated(session);
		System.out.println("客户端:与服务端连接创建");
	}
	//连接空闲是触发
	public void sessionIdle(IoSession session, IdleStatus status)
	throws Exception {
		super.sessionIdle(session, status);
		System.out.println("客户端:连接空闲");
	}
	//发送信息后触发
	public void messageSent(IoSession arg0, Object arg1) throws Exception {
		//System.out.println("客户端:已向服务器发送-->"+(String)arg1);
		System.out.println("客户端:发送对象完毕");
		arg0.close();//这里实际不能彻底关闭mina2.0需要connector.dispose()才能彻底关闭   
		connector.dispose();//不需要关闭去掉这两句就ok
		System.out.println("客户端:强行关闭连接");
	}   

	/**
	 * 传送信息
	 * @param session
	 * @throws Exception
	 */
	public void sendMsg(IoSession session) throws Exception{
		TransferObj transferObj=new TransferObj();
		transferObj.setDate("nafio_date");
		session.write(transferObj);
	}

	public void exceptionCaught(IoSession session, Throwable cause)
	throws Exception {
		super.exceptionCaught(session, cause);
	}
}    

3 TransferObj.java

package com.nafio.obj;

public class TransferObj implements java.io.Serializable{
	private String date;    
	  
	public String getDate() {    
		return date;       
	}    
	public void setDate(String date) { 
		this.date = date;    
	}        
	          
}    

服务端

1 MinaServer.java

package com.nafio.server;

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 MinaServer {    
	private static MinaServer minaServer = null;
	//创建一个非阻塞的Server端Socket
	private SocketAcceptor acceptor = new NioSocketAcceptor();
	//创建接收数据的过滤器
	private DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();        
	private int bindPort = 8888;
	
	//单例
	public static MinaServer getInstances() {    
		if (null == minaServer) {               
			minaServer = new MinaServer();    
		}            
		return minaServer;    
	}        
	private MinaServer() {            
		//设定这个过滤器将按对象读取数据
		chain.addLast("myChin", new ProtocolCodecFilter(    
				new ObjectSerializationCodecFactory())); 
		//设定服务器端的消息处理器:一个MinaServerHandler对象,
		acceptor.setHandler(ServerHandler.getInstances());   
		
		try {
			//绑定端口,启动服务器
			acceptor.bind(new InetSocketAddress(bindPort));
			
		} catch (IOException e) {                
			e.printStackTrace();    
		} 
		System.out.println("服务端:监听端口--->" + bindPort);
	}    
	public static void main(String[] args) throws Exception {    
		MinaServer.getInstances();        
	}    
}    

 

2  ServerHandler.java

package com.nafio.server;

import org.apache.mina.core.filterchain.IoFilterAdapter;
import org.apache.mina.core.service.IoHandler;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;

import com.nafio.obj.TransferObj;
//下面两种写法应该等同,不确定?
//public class ServerHandler extends IoHandlerAdapter {  
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() {    
	}    
	public void sessionOpened(IoSession session) throws Exception {

	}    
	public void sessionClosed(IoSession session) {

	}    
	public void messageReceived(IoSession session, Object message)throws Exception {      
		if (message instanceof TransferObj) {
			TransferObj obj = (TransferObj) message;    
			System.out.println("服务端:收到客户端数据--->"+obj.getDate());	
		}         
	}    
	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 { 
		
	}    
}  

3 TransferObj.java(跟客户端相同,因为客户端和服务端要分开,所以这个类两个工程中都放一个)

彻底关闭mina客户端连接的方法

session.close();

java默认不赞成使用这个方法

这个方法使用后客户端实际还没彻底关闭

mina2.0彻底关闭用connector.dispose();  

关于socket长短连接

通常的短连接操作步骤是：
连接→数据传输→关闭连接；
而长连接通常就是：
连接→数据传输→保持连接(心跳)→数据传输→保持连接(心跳)→……→关闭连接；
这就要求长连接在没有数据通信时，定时发送数据包(心跳)，以维持连接状态，短连接在没有数据传输时直接关闭就行了

所以mina默认应该就是长连接所以默认不关闭.