Java 从IoSession读取apachemina

我是Apache MINA的新手，请指导我如何阅读iSession。我在里面放了一个POJO

public static EchoUDPServerDiscoveryObjectResponseProperties echoProperties

session.write(echoProperties);

自定义客户端：

package client;

import java.net.InetSocketAddress;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.util.logging.Level;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.future.IoFutureListener;
import org.apache.mina.core.future.ReadFuture;
import org.apache.mina.core.service.IoConnector;
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.example.udp.client.MemMonClient;
import org.apache.mina.transport.socket.nio.NioDatagramConnector;

/**
 *
 * @author az
 */
public class CustomClient extends IoHandlerAdapter{

    private IoSession session;
    private IoConnector connector;
    private ConnectFuture connFuture;

    public CustomClient() throws InterruptedException{
        connector = new NioDatagramConnector();
        connector.setHandler(this);
        connFuture = connector.connect(new InetSocketAddress("192.168.3.22",6502));


        connFuture.addListener(new IoFutureListener<ConnectFuture>() {
            public void operationComplete(ConnectFuture future) {
                if (future.isConnected()) {                    
                    session = future.getSession();
                    try {
                        try {
                            sendData();
                          //  connFuture.await();

                        } catch (CharacterCodingException ex) {
                            java.util.logging.Logger.getLogger(MemMonClient.class.getName()).log(Level.SEVERE, null, ex);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } 
            }
        });

    }
    private void sendData() throws InterruptedException, CharacterCodingException {


            IoBuffer buffer = IoBuffer.allocate(8);
            buffer.setAutoExpand(true);
            buffer.putString("any", Charset.forName("UTF-8").newEncoder());
            buffer.flip();
            session.write(buffer);
    }

     @Override
    public void exceptionCaught(IoSession session, Throwable cause)
            throws Exception {
        cause.printStackTrace();
    }
    @Override
    public void messageReceived(IoSession session, Object message)
            throws Exception {
        connFuture.getSession().getConfig().setUseReadOperation(true);

        ReadFuture r = connFuture.getSession().read();
        connFuture.await();
        connFuture.getSession().getConfig().setUseReadOperation(true);


        Object obj = r.getMessage();
        System.out.println("r.getMessage(); "+obj);
        IoBuffer buffer = IoBuffer.allocate(2048);
                        buffer.setAutoExpand(true);                     
                        Object objReceived = buffer.getObject();
                        System.out.println(objReceived.toString());

        System.out.println("reveived Session recv...");
    }

    @Override
    public void messageSent(IoSession session, Object message) throws Exception {
        System.out.println("Message sent...");
    }

    @Override
    public void sessionClosed(IoSession session) throws Exception {
        System.out.println("Session closed...");
    }

    @Override
    public void sessionCreated(IoSession session) throws Exception {
        System.out.println("Session created...");
    }

    @Override
    public void sessionIdle(IoSession session, IdleStatus status)
            throws Exception {
        System.out.println("Session idle...");
    }

    @Override
    public void sessionOpened(IoSession session) throws Exception {
        System.out.println("Session opened...");
    }
    public static void main (String are[]){
        try{
        new CustomClient();
        }catch(Exception ex){ex.printStackTrace();}
    }
}

POJO Java
package pojo;

import java.io.Serializable;

/**
 *
 * @author az
 */
public class kojo implements Serializable{
    private String name = "null";
    private String address = "null";

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the address
     */
    public String getAddress() {
        return address;
    }

    /**
     * @param address the address to set
     */
    public void setAddress(String address) {
        this.address = address;
    }

}

Custom Server Java
package server;

import java.io.IOException;
import java.net.InetSocketAddress;
import org.apache.mina.transport.socket.DatagramSessionConfig;
import org.apache.mina.transport.socket.nio.NioDatagramAcceptor;

/**
 *
 * @author az
 */
public class CustomServer {

    public CustomServer(){
        try {
            NioDatagramAcceptor acceptor = new NioDatagramAcceptor();
            acceptor.setHandler(new ServerHandler(this));
            //DefaultIoFilterChainBuilder filter = acceptor.getFilterChain();
            DatagramSessionConfig dcfg = acceptor.getSessionConfig();
            dcfg.setReuseAddress(true);
            acceptor.bind(new InetSocketAddress(6501));
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    public void receiveUpdate(){

    }
    public static void main(String are[]){
        new CustomServer();
    }
}

Server Handler
package server;

import java.nio.charset.Charset;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.future.WriteFuture;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;

/**
 *
 * @author az
 */
public class ServerHandler extends IoHandlerAdapter {

    private CustomServer server;

    public ServerHandler(CustomServer server) {
        this.server = server;
    }

    @Override
    public void messageReceived(IoSession session, Object message)
            throws Exception {

        if (message instanceof IoBuffer) {
            //decode POJO and send to client
            IoBuffer buffer = (IoBuffer) message;
            System.out.println(buffer.getString(Charset.forName("UTF-8").newDecoder()));
            buffer.setAutoExpand(true);
            buffer.putObject(new pojo.POJO());
            buffer.flip();
            session.write(buffer);

            System.out.print("Object Attached and Sent");

        }
    }

    @Override
    public void messageSent(IoSession session, Object message) {
        System.out.println("Message sent");
    }

    @Override
    public void sessionClosed(IoSession session) throws Exception {
        System.out.println("Session closed...");
    }

    @Override
    public void sessionCreated(IoSession session) throws Exception {
        System.out.println("Session created...");
    }

    @Override
    public void sessionIdle(IoSession session, IdleStatus status)
            throws Exception {
        System.out.println("Session idle...");
    }

    @Override
    public void sessionOpened(IoSession session) throws Exception {
        System.out.println("Session Opened...");
    }
}

包客户端；
导入java.net.InetSocketAddress；
导入java.nio.charset.CharacterCodingException；
导入java.nio.charset.charset；
导入java.util.logging.Level；
导入org.apache.mina.core.buffer.IoBuffer；
导入org.apache.mina.core.future.ConnectFuture；
导入org.apache.mina.core.future.IoFutureListener；
导入org.apache.mina.core.future.ReadFuture；
导入org.apache.mina.core.service.IoConnector；
导入org.apache.mina.core.service.iohandleAdapter；
导入org.apache.mina.core.session.IdleStatus；
导入org.apache.mina.core.session.IoSession；
导入org.apache.mina.example.udp.client.MemMonClient；
导入org.apache.mina.transport.socket.nio.NioDatagramConnector；
/**
*
*@作者az
*/
公共类CustomClient扩展IoHandlerAdapter{
非公开会议；
专用IOC连接器；
私人连接未来与未来；
public CustomClient（）引发InterruptedException{
连接器=新的NioDatagramConnector（）；
connector.setHandler（this）；
connFuture=connector.connect（新的InetSocketAddress（“192.168.3.22”，6502））；
addListener（新的IoFutureListener（）{
公共无效操作完成（连接未来）{
如果（future.isConnected（））{
session=future.getSession（）；
试一试{
试一试{
sendData（）；
//等待；等待；
}catch（CharacterCodingException-ex）{
getLogger（MemMonClient.class.getName（））.log（Level.SEVERE，null，ex）；
}
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
} 
}
});
}
私有void sendData（）引发InterruptedException、CharacterCodingException{
IoBuffer=IoBuffer.allocate（8）；
setAutoExpand（true）；
buffer.putString（“any”，Charset.forName（“UTF-8”）.newEncoder（））；
flip（）；
会话写入（缓冲区）；
}
@凌驾
公共无效例外情况（失败会话、可丢弃原因）
抛出异常{
cause.printStackTrace（）；
}
@凌驾
接收到公共void消息（IoSession会话、对象消息）
抛出异常{
connFuture.getSession（）.getConfig（）.setUseReadOperation（true）；
ReadFuture r=connFuture.getSession（）.read（）；
等待；等待；
connFuture.getSession（）.getConfig（）.setUseReadOperation（true）；
对象obj=r.getMessage（）；
System.out.println（“r.getMessage（）；”+obj）；
IoBuffer=IoBuffer.allocate（2048）；
setAutoExpand（true）；
Object objReceived=buffer.getObject（）；
System.out.println（objReceived.toString（））；
System.out.println（“已恢复会话记录…”）；
}
@凌驾
public void messageSent（IoSession会话，对象消息）引发异常{
System.out.println（“消息已发送…”）；
}
@凌驾
public void sessionClosed（IoSession会话）引发异常{
System.out.println（“会话关闭…”）；
}
@凌驾
public void sessionCreated（IoSession会话）引发异常{
System.out.println（“会话已创建…”）；
}
@凌驾
public void sessionIdle（IoSession会话，IdleStatus状态）
抛出异常{
System.out.println（“会话空闲…”）；
}
@凌驾
public void sessionOpened（IoSession会话）引发异常{
System.out.println（“会话已打开…”）；
}
公共静态void main（字符串为[]）{
试一试{
新客户机（）；
}catch（异常ex）{ex.printStackTrace（）；}
}
}
波乔爪哇
包pojo；
导入java.io.Serializable；
/**
*
*@作者az
*/
公共类kojo实现了可序列化{
私有字符串name=“null”；
私有字符串地址=“null”；
/**
*@返回名称
*/
公共字符串getName（）{
返回名称；
}
/**
*@param name要设置的名称
*/
公共void集合名（字符串名）{
this.name=名称；
}
/**
*@返回地址
*/
公共字符串getAddress（）{
回信地址；
}
/**
*@param address要设置的地址
*/
公共无效设置地址（字符串地址）{
this.address=地址；
}
}
自定义服务器Java
包服务器；
导入java.io.IOException；
导入java.net.InetSocketAddress；
导入org.apache.mina.transport.socket.DatagramSessionConfig；
导入org.apache.mina.transport.socket.nio.NioDatagramAcceptor；
/**
*
*@作者az
*/
公共类自定义服务器{
公共自定义服务器（）{
试一试{
NioDatagramAcceptor acceptor=新的NioDatagramAcceptor（）；
setHandler（新的ServerHandler（this））；
//DefaultIoFilterChainBuilder筛选器=acceptor.getFilterChain（）；
DatagramSessionConfig dcfg=acceptor.getSessionConfig（）；
dcfg.setReuseAddress（真）；
acceptor.bind（新的InetSocketAddress（6501））；
}捕获（IOEX异常）{
例如printStackTrace（）；
}
}
public void receiveUpdate（）{
}
公共静态void main（字符串为[]）{
新建CustomServer（）；
}
}
服务器处理程序
包服务器；
导入java.nio.charset.charset；
导入org.apache.mina.core.buffer.IoBuffer；
导入org.apache.mina.core.future.WriteFuture；
导入org.apache.mina.core.service.iohandleAdapter；
导入org.apache.mina.core.session.IdleStatus；
导入org.apache.mina.core.session.IoSession；
/**
*
*@作者az
*/
公众的