Apache Mina入門實例

時間 2019-11-17

標籤 apache mina 入門實例欄目 Apache 简体版

原文原文鏈接

1、mina是啥

ApacheMINA是一個網絡應用程序框架，用來幫助用戶簡單地開發高性能和高可擴展性的網絡應用程序。它提供了一個經過Java NIO在不一樣的傳輸例如TCP/IP和UDP/IP上抽象的事件驅動的異步API。（這是官方文檔的翻譯）html

2、mina能夠幹啥

如今要用mina寫一個服務器和一個客戶端經過TCP/IP協議通訊的入門實例。java

3、mina怎麼作到

官方文檔上有一幅圖畫得很好，是關於mina架構的，這裏貼上來看一下：spring

基本上就是這樣，一個請求過來，經過IoService，IoService新建一個Session，再經過一大堆的過濾器，最後到了一個處理器裏面把業務邏輯處理完後再把結果返回去。apache

上代碼~~~服務器

一、服務器端代碼：網絡

MinaServer.javasession

public class MinaServer {

    private static final int Port = 8888;
    public void startMinaServer() {
        IoAcceptor ioAcceptor = new NioSocketAcceptor();
        System.out.println("server start to start!");

        //設置過濾器
        DefaultIoFilterChainBuilder defaultIoFilterChainBuilder = ioAcceptor.getFilterChain();
        defaultIoFilterChainBuilder.addLast("logger", new LoggingFilter());
        defaultIoFilterChainBuilder.addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
        System.out.println("config the filter chain finished!");

        //設置處理器
        ioAcceptor.setHandler(new FirstServerHandler());
        System.out.println("setting the handler finished!");

        //配置Session
        IoSessionConfig ioSessionConfig = ioAcceptor.getSessionConfig();
        ioSessionConfig.setReadBufferSize(2048);
        ioSessionConfig.setIdleTime(IdleStatus.BOTH_IDLE, 10);
        System.out.println("config the session finished!");

        //綁定端口
        try {
            ioAcceptor.bind(new InetSocketAddress(Port));
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("start finish!");
    }

    public static void main(String[] args) {
        MinaServer server = new MinaServer();
        server.startMinaServer();
    }
}

FirstServerHandler.java

public class FirstServerHandler extends IoHandlerAdapter{

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

    private static int message_count = 1;
    @Override
    public void messageReceived(IoSession session, Object message) {
        System.out.println("receive a message.");
        String string = message.toString();
        if(string.trim().toLowerCase().equals("quit")) {
            session.close(true);
            return;
        }
        System.out.println("received message:" + string);
        session.write("you are the no. " + message_count + " message!!!");
        message_count++;
        System.out.println("send back finished!!!");
    }

    @Override
    public void messageSent(IoSession session, Object message){
        System.out.println("message have been sent :" + message.toString());
        System.out.println();
    }

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

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

    @Override
    public void sessionIdle(IoSession session, IdleStatus status) {
        System.out.println("IDLE " + session.getIdleCount(status));
        System.out.println();
    }

    @Override
    public void sessionOpened(IoSession session) {
        System.out.println("opened session!");
        System.out.println();
    }
}

　二、客戶端代碼架構

MinaClient.java

public class MinaClient {

    private SocketConnector connector;
    private ConnectFuture future;
    private IoSession session;

    private String server_address = "127.0.0.1";
    private int server_port = 8888;

    public boolean connect() {

        connector = new NioSocketConnector();

        DefaultIoFilterChainBuilder defaultIoFilterChainBuilder = connector.getFilterChain();

        defaultIoFilterChainBuilder.addLast("logger", new LoggingFilter());
        defaultIoFilterChainBuilder.addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));

        connector.setHandler(new FirstClientHandler());

        future = connector.connect(new InetSocketAddress(server_address, server_port));
        future.awaitUninterruptibly();

        session = future.getSession();
        session.getConfig().setUseReadOperation(true);
        return future.isConnected();
    }

    public void sendMssageToServer(String message) {
        session.write(message);
    }

    public boolean close() {
        CloseFuture closeFuture = session.getCloseFuture();
        closeFuture.awaitUninterruptibly(1000);
        connector.dispose();
        return true;
    }

    public static void main(String[] args) {
        MinaClient client = new MinaClient();
        client.connect();

        String readLine = "";
        Scanner in = new Scanner(System.in);
        do {
            readLine = in.nextLine();
            client.sendMssageToServer(readLine);
        }while(!readLine.toLowerCase().equals("quit"));

        client.close();
    }
}

FirstClientHandler.java

public class FirstClientHandler extends IoHandlerAdapter {

    @Override
    public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
        System.out.println("here got a exception!!!");
        super.exceptionCaught(session, cause);
    }

    @Override
    public void messageReceived(IoSession session, Object message) throws Exception {
        System.out.println("received a message: " + message.toString());
        super.messageReceived(session, message);
    }

    @Override
    public void messageSent(IoSession session, Object message) throws Exception {
        System.out.println("sent a message: " + message.toString());
        super.messageSent(session, message);
    }

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

--------------------------------------------我是分割線------------------------------------------------------app

三、服務器整合mina框架

SpringCodeFactory.java

public  class SpringCodeFactory implements ProtocolCodecFactory {

    private final TextLineEncoder encoder;
    private final TextLineDecoder decoder;
    /*final static char endchar = 0x1a;*/
    final static char endchar = 0x0d;
    public SpringCodeFactory() {
        this(Charset.forName("UTF-8"));
    }
    public SpringCodeFactory(Charset charset) {
        encoder = new TextLineEncoder(charset, LineDelimiter.UNIX);
        decoder = new TextLineDecoder(charset, LineDelimiter.AUTO);
    }
    @Override
    public ProtocolDecoder getDecoder(IoSession session) throws Exception {
        return decoder;
    }
    @Override
    public ProtocolEncoder getEncoder(IoSession session) throws Exception {
        return encoder;
    }
    public int getEncoderMaxLineLength() {
        return encoder.getMaxLineLength();
    }
    public void setEncoderMaxLineLength(int maxLineLength) {
        encoder.setMaxLineLength(maxLineLength);
    }
    public int getDecoderMaxLineLength() {
        return decoder.getMaxLineLength();
    }
    public void setDecoderMaxLineLength(int maxLineLength) {
        decoder.setMaxLineLength(maxLineLength);
    }

}

applicationContext-mina.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
        <property name="customEditors">
            <map>
                <entry key="java.net.SocketAddress" value="org.apache.mina.integration.beans.InetSocketAddressEditor">
                </entry>
            </map>
        </property>
    </bean>

    <bean id="executorFilter" class="org.apache.mina.filter.executor.ExecutorFilter" />
    <bean id="protocolCodecFilter" class="org.apache.mina.filter.codec.ProtocolCodecFilter">
        <constructor-arg>
            <bean class="com.misuosi.mina.spring.SpringCodeFactory" />
        </constructor-arg>
    </bean>
    <bean id="loggingFilter" class="org.apache.mina.filter.logging.LoggingFilter" />

    <bean id="filterChainBuilder" class="org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder">
        <property name="filters">
            <map>
                <entry key="executor" value-ref="executorFilter"></entry>
                <entry key="codec" value-ref="protocolCodecFilter"></entry>
                <entry key="logging" value-ref="loggingFilter"></entry>
            </map>
        </property>
    </bean>

    <bean id="firstServerHandler" class="com.misuosi.mina.server.FirstServerHandler" />

    <bean id="ioAcceptor" class="org.apache.mina.transport.socket.nio.NioSocketAcceptor"
          init-method="bind" destroy-method="unbind" >
        <property name="defaultLocalAddress" value=":8888" />
        <property name="handler" ref="firstServerHandler" />
        <property name="filterChainBuilder" ref="filterChainBuilder" />
        <property name="reuseAddress" value="true" />
    </bean>

    <bean id="sessionConfig" factory-bean="ioAcceptor" factory-method="getSessionConfig" >
        <property name="bothIdleTime" value="10"/>
        <property name="readBufferSize" value="2048" />
    </bean>
</beans>

SpringServer.java

public class SpringServer {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext ct = new ClassPathXmlApplicationContext("applicationContext-mina.xml");
    }
}