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默认应该就是长连接所以默认不关闭.