Apache Mina - 简单的服务端和客户端的搭建

1、什么是Apache Mina？

Apache Mina是一个能够帮助用户开发高性能和高伸缩性网络应用程序的框架。它通过Java NIO技术基于TCP/IP和UDP/IP协议提供了抽象的、事件驱动的、异步的API。简单的说，可以用它来帮助我们快速的开发网络通信。

2、它的工作原理？



3、如何使用Apac Mina？

3.1、创建一个Maven工程

应该如何创建Maven工程我这里就不详细介绍了，网上有很多资料大家都可以去看看。在这里我使用的是spring boot框架，所以POM文件是这样的：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion>

<groupId>com.springboot</groupId>
<artifactId>mina</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>mina</name>
<description>Demo for mina</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.2.5.RELEASE</version>
<relativePath /> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.apache.mina</groupId>
<artifactId>mina-core</artifactId>
<version>2.0.4</version>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

</project>

3.2、创建服务端程序

接着我们创建一个服务端程序，用来接收和监控传过来的信息

package com.springboot.mina.server;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.Charset;

import org.apache.log4j.Logger;
import org.apache.mina.core.service.IoAcceptor;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;

public class MyServer {

private static Logger logger = Logger.getLogger(MyServer.class); //日志
private static final int port = 8899;	//端口

public static void main(String[] args) {
// 创建一个非阻塞的server端的socket
IoAcceptor acceptor = new NioSocketAcceptor();
// 设置过滤器,选用Mina自带的过滤器一行一行读取代码
acceptor.getFilterChain().addLast("myChain", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
// 设置读取数据的缓冲区大小 
acceptor.getSessionConfig().setReadBufferSize(2048);
// 读写通道10秒内无操作进入空闲状态 
acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE,10);
// 绑定逻辑处理器
acceptor.setHandler(new ServerHandler());
// 绑定端口,启动服务器
try {
acceptor.bind(new InetSocketAddress(port));
} catch (IOException e) {
e.printStackTrace();
}

logger.info("服务已启动，端口是:"+port);
}
}

3.3、创建服务端的逻辑处理器

在上面我们为服务端注册了一个逻辑处理器acceptor.setHandler(new ServerHandler())，用力具体处理监听动作，接下来我们就要来实现这一处理器

package com.springboot.mina.server;

import org.apache.log4j.Logger;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;

public class ServerHandler extends IoHandlerAdapter{

private static Logger logger = Logger.getLogger(ServerHandler.class);

//创建连接
@Override
public void sessionCreated(IoSession session) throws Exception {
logger.info("服务器创建session连接!");
}

//打开一个连接
@Override
public void sessionOpened(IoSession session) throws Exception {
logger.info("服务器打开session连接!");
}

//关闭连接
@Override
public void sessionClosed(IoSession session) throws Exception {
logger.info("服务器关闭session连接!");
}

//连接空闲
@Override
public void sessionIdle(IoSession session, IdleStatus status) throws Exception {

}

//有异常时
@Override
public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
logger.info("服务器出现异常"+cause);
}

//接收到消息
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
String str = message.toString();
logger.info("服务器收到消息："+str);
if(str.equals("close")){
session.write("close");
session.close(true);
}
}

//将要发送消息
@Override
public void messageSent(IoSession session, Object message) throws Exception {

}
}

这样子我们服务端就基本搭建完成了，如果你还要实现什么逻辑处理，在逻辑处理器对应的动作方法上写就行了

3.4、创建客户端

服务端创建好了，接下来我们建一个客户端，来发送数据，当然，也可以处理从服务端发过来的信息

package com.springboot.mina.client;

import java.net.InetSocketAddress;
import java.nio.charset.Charset;

import org.apache.log4j.Logger;
import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.transport.socket.SocketConnector;
import org.apache.mina.transport.socket.nio.NioSocketConnector;

public class MyClient {

private static Logger logger = Logger.getLogger(MyClient.class);
private static final String host = "127.0.0.1";
private static final int port = 8899;

public static void main(String[] args) {
// 创建连接
SocketConnector connector = new NioSocketConnector();
// 设置过滤器,选用Mina自带的过滤器一行一行读取代码
connector.getFilterChain().addLast("myChain", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
// 设置连接超时时间
connector.setConnectTimeoutMillis(30 * 1000);
// 绑定逻辑处理器
connector.setHandler(new ClientHandler());
// 连接到服务器
ConnectFuture future = connector.connect(new InetSocketAddress(host, port));
// 等待连接创建完成
future.awaitUninterruptibly();
// 获得session
IoSession session = future.getSession();
// 发送消息
session.write("你好！ \r\n close");

logger.info("客户端正在连接服务器，"+host+":"+port);

// 等待连接断开
session.getCloseFuture().awaitUninterruptibly();
connector.dispose();
}
}

ok，我们创建了一个客户端程序，并在session.write("你好！ \r\n close")发送了一条数据，“\r\n”是换行符，我们设置的过滤器是Mina本身提供的逐行读取

3.5、创建客户端的逻辑处理器

同3.3相同，同样要为客户端注册一个逻辑处理器，甚至代码都相差不多

package com.springboot.mina.client;

import org.apache.log4j.Logger;
import org.apache.mina.core.service.IoHandler;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;

public class ClientHandler implements IoHandler {

private static Logger logger = Logger.getLogger(ClientHandler.class);

// 有异常
@Override
public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
logger.info("程序出现异常"+cause);
}

// 接收到消息时
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
String str = message.toString();
logger.info("客户端收到消息："+str);
if(str.equals("close")){
session.close(true);
}
}

// 将要发送消息
@Override
public void messageSent(IoSession session, Object message) throws Exception {

}

// 关闭连接
@Override
public void sessionClosed(IoSession session) throws Exception {
logger.info("客户端关闭session连接!");
}

// 创建连接
@Override
public void sessionCreated(IoSession session) throws Exception {
logger.info("客户端创建session连接!");
}

// 连接空闲
@Override
public void sessionIdle(IoSession session, IdleStatus arg1) throws Exception {

}

// 打开一个连接
@Override
public void sessionOpened(IoSession session) throws Exception {
logger.info("客户端开始session连接!");
}

}

好了，这样我们基于Mina的服务端和客户端就搭建完成了，因为都是写在了Main()方法里，只要右键->run as Java Application就能把程序跑起来了，你可以两个一起跑，也可以只运行服务器，打开命令行，输入

telnet 127.0.0.1 8899

就可以和端口建立通信了，在控制台就可以看到你输入的内容了。

4、Mina具体技术
程序写好了，我们来看看上面用到了Mina的哪些东西

1、类NioSocketAcceptor;创建一个服务端监听

2、类NioSocketConnecto;创建一个客户端监听

3、IoHandler接口;
封装了不同事件的处理

4、类IoSession;
用来保存会话属性和发送消息，可以理解为服务端和客户端之间的特定连接

5、类IoFilter;
用来对数据进行过滤。我们上面使用的是Mina自带的逐行读取的过滤器，如果有需要，我们要可以定义自己的过滤器

Apacha Mina官网：http://mina.apache.org/mina-project/

在线API文档：http://tool.oschina.net/apidocs/apidoc?api=mina