Apache MINA实战之 牛刀小试 – kongxx的专栏 – 博客频道 – CSDN.NET

 

来源: Apache MINA实战之 牛刀小试 – kongxx的专栏 – 博客频道 – CSDN.NET

本文链接:http://blog.csdn.NET/kongxx/article/details/7520259

Apache的MINA是一个被用来构建高性能和高可伸缩性应用程序的网络应用框架,它提供了一套统一的建立在Java NIO之上的事件驱动的异步API。

对于MINA框架的了解,MINA官方的几篇文章是必须要看的,如下:

* Application Architecture http://mina.apache.org/mina-based-application-architecture.html
* Server Architecture http://mina.apache.org/server-architecture.html
* Client Architecture http://mina.apache.org/client-architecture.html

其中几个主要的组件如下:

I/O Service – 用来处理I/O流,对于Server端就是IOAcceptor的实现类接受Client端的连接请求,对于Client端就是IoConnector的实现类来建立到Server端的连接。

I/O Filter Chain – 用来过滤或转化数据。对于Server端和Client端来说都是IoFilter接口的实现类,MINA自己内建了很多IoFilter接口的实现类。具体可以参考官方文档。

I/O Handler – 用来处理真正业务逻辑的类。对于Server端和Client端来说都是IoHandler接口的实现类,通常来说需要自己编写。

由于Server端和Client端都是基于以上三个组件的,因此对于Server端和Client端编程来说就都有类似的代码结构。

对于Server端来说:

1. 创建I/O service – 这里就是创建IOAcceptor类监听端口。

2. 创建I/O Filter Chain – 这里就是告诉使用那些IoFilter。
3. 创建I/O Handler – 自己的业务逻辑。

对于Client端来说:

1. 创建I/O service – 这里就是创建IOConnector类来建立到Server端的连接。

2. 创建I/O Filter Chain – 这里就是告诉使用那些IoFilter。

3. 创建I/O Handler – 自己的业务逻辑。

下面来通过一个例子看看MINA是怎样工作的。由于大多数应用都是基于TCP/IP的应用,所以这里也就不再说UDP/IP了。

这里我使用了Maven来创建了一个简单Java应用程序,具体步骤请参Maven的官方手册。这里只是将我用到的maven配置文件pom.xml列出,方便下面及后续文章使用。具体pom.xml文件内容如下:

  1. <project xmlns=“http://maven.apache.org/POM/4.0.0” xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
  2.     xsi:schemaLocation=“http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd”>
  3.     <modelVersion>4.0.0</modelVersion>
  4.     <groupId>com.google.code.garbagecan.minastudy</groupId>
  5.     <artifactId>minastudy</artifactId>
  6.     <packaging>jar</packaging>
  7.     <version>1.0-SNAPSHOT</version>
  8.     <name>minastudy</name>
  9.     <url>http://maven.apache.org</url>
  10.     <dependencies>
  11.         <dependency>
  12.             <groupId>org.apache.mina</groupId>
  13.             <artifactId>mina-core</artifactId>
  14.             <version>2.0.4</version>
  15.         </dependency>
  16.         <dependency>
  17.             <groupId>org.apache.mina</groupId>
  18.             <artifactId>mina-filter-compression</artifactId>
  19.             <version>2.0.4</version>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>org.slf4j</groupId>
  23.             <artifactId>slf4j-api</artifactId>
  24.             <version>1.3.0</version>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>org.slf4j</groupId>
  28.             <artifactId>slf4j-log4j12</artifactId>
  29.             <version>1.3.0</version>
  30.         </dependency>
  31.     </dependencies>
  32. </project>

首先来看Server端的代码

  1. package com.google.code.garbagecan.minastudy.sample1;
  2. import java.io.IOException;
  3. import java.net.InetSocketAddress;
  4. import java.nio.charset.Charset;
  5. import org.apache.mina.core.service.IoAcceptor;
  6. import org.apache.mina.core.service.IoHandlerAdapter;
  7. import org.apache.mina.core.session.IdleStatus;
  8. import org.apache.mina.core.session.IoSession;
  9. import org.apache.mina.filter.codec.ProtocolCodecFilter;
  10. import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
  11. import org.apache.mina.filter.logging.LoggingFilter;
  12. import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
  13. import org.slf4j.Logger;
  14. import org.slf4j.LoggerFactory;
  15. public class MyServer {
  16.     private static final Logger logger = LoggerFactory.getLogger(MyServer.class);
  17.     public static void main(String[] args) {
  18.         IoAcceptor acceptor = new NioSocketAcceptor();
  19.         acceptor.getFilterChain().addLast(“logger”new LoggingFilter());
  20.         acceptor.getFilterChain().addLast(“codec”new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName(“UTF-8”))));
  21.         acceptor.setHandler(new IoHandlerAdapter() {
  22.             @Override
  23.             public void sessionCreated(IoSession session) throws Exception {
  24.             }
  25.             @Override
  26.             public void sessionOpened(IoSession session) throws Exception {
  27.             }
  28.             @Override
  29.             public void sessionClosed(IoSession session) throws Exception {
  30.             }
  31.             @Override
  32.             public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
  33.             }
  34.             @Override
  35.             public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
  36.                 logger.error(cause.getMessage(), cause);
  37.                 session.close(true);
  38.             }
  39.             @Override
  40.             public void messageReceived(IoSession session, Object message) throws Exception {
  41.                 logger.info(“Received message “ + message);
  42.                 session.write(message);
  43.             }
  44.             @Override
  45.             public void messageSent(IoSession session, Object message) throws Exception {
  46.                 logger.info(“Sent message “ + message);
  47.             }
  48.         });
  49.         try {
  50.             acceptor.bind(new InetSocketAddress(10000));
  51.         } catch (IOException ex) {
  52.             logger.error(ex.getMessage(), ex);
  53.         }
  54.     }
  55. }

1. 首先创建I/O Service,这里使用的是NioSocketAcceptor类来创建了一个IoAcceptor实例。

2. 创建I/O Filter Chain,这里使用了两个IoFilter,一个是LoggingFilter用来记录日志和打印事件消息,另一个是ProtocolCodecFilter实例用来编码数据,这里其实就是将传递的数据编码成文本。

3. 创建I/O Handler,不要害怕,看起来代码多,其实就是一个实现了IoHandler接口的子类,自己需要实现其中的一些方法,这里方法比较多,但是我在这里只实现了messageSent,messageReceived和exceptionCaught方法。

4. 最后就是让IoAcceptor类实例绑定端口实现监听。

下面看看Client端的代码

  1. package com.google.code.garbagecan.minastudy.sample1;
  2. import java.net.InetSocketAddress;
  3. import java.nio.charset.Charset;
  4. import org.apache.mina.core.RuntimeIoException;
  5. import org.apache.mina.core.future.ConnectFuture;
  6. import org.apache.mina.core.service.IoConnector;
  7. import org.apache.mina.core.service.IoHandlerAdapter;
  8. import org.apache.mina.core.session.IdleStatus;
  9. import org.apache.mina.core.session.IoSession;
  10. import org.apache.mina.filter.codec.ProtocolCodecFilter;
  11. import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
  12. import org.apache.mina.filter.logging.LoggingFilter;
  13. import org.apache.mina.transport.socket.nio.NioSocketConnector;
  14. import org.slf4j.Logger;
  15. import org.slf4j.LoggerFactory;
  16. public class MyClient {
  17.     private static final Logger logger = LoggerFactory.getLogger(MyClient.class);
  18.     public static void main(String[] args) {
  19.         IoConnector connector = new NioSocketConnector();
  20.         connector.setConnectTimeoutMillis(10 * 1000);
  21.         connector.getFilterChain().addLast(“logger”new LoggingFilter());
  22.         connector.getFilterChain().addLast(“codec”new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName(“UTF-8”))));
  23.         connector.setHandler(new IoHandlerAdapter() {
  24.             @Override
  25.             public void sessionCreated(IoSession session) throws Exception {
  26.             }
  27.             @Override
  28.             public void sessionOpened(IoSession session) throws Exception {
  29.                 for (int i = 0; i < 10; i++) {
  30.                     session.write(“Hello user_” + i);
  31.                 }
  32.                 session.write(“Bye”);
  33.             }
  34.             @Override
  35.             public void sessionClosed(IoSession session) throws Exception {
  36.             }
  37.             @Override
  38.             public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
  39.             }
  40.             @Override
  41.             public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
  42.                 logger.error(cause.getMessage(), cause);
  43.                 session.close(true);
  44.             }
  45.             @Override
  46.             public void messageReceived(IoSession session, Object message) throws Exception {
  47.                 logger.info(“Received message “ + message);
  48.                 if (message.toString().equalsIgnoreCase(“Bye”)) {
  49.                     session.close(true);
  50.                 }
  51.             }
  52.             @Override
  53.             public void messageSent(IoSession session, Object message) throws Exception {
  54.                 logger.info(“Sent message “ + message);
  55.             }
  56.         });
  57.         IoSession session = null;
  58.         try {
  59.             ConnectFuture future = connector.connect(new InetSocketAddress(“localhost”10000));
  60.             future.awaitUninterruptibly();
  61.             session = future.getSession();
  62.         } catch (RuntimeIoException e) {
  63.             logger.error(e.getMessage(), e);
  64.         }
  65.         session.getCloseFuture().awaitUninterruptibly();
  66.         connector.dispose();
  67.     }
  68. }

 

1. 首先创建I/O Service,这里使用的是NioSocketConnector类来创建了一个IoConnector实例,并设置连接超时为10秒。

2. 创建I/O Filter Chain,和服务器端同样设置了两个IoFilter,一个是LoggingFilter用来记录日志和打印事件消息,另一个是ProtocolCodecFilter实例用来编码数据,这里其实就是将传递的数据编码成文本。

3. 创建I/O Handler,也不要害怕,看起来代码多,其实也是一个实现了IoHandler接口的子类,并且自己实现了sessionOpened,messageSent,messageReceived和exceptionCaught方法。实现sessionOpened方法是为了在建立连接后向Server端发送消息。另外看一下messageReceived方法实现,在接收到服务器端的消息后关闭会话。从而可以使Client程序最终能够退出。

4. 最后就是IoConnector实例类连接远端的Server。

 

下面测试一下上面的程序,首先运行MyServer类,然后运行MyClient类,就可以分别在各自的终端上看到事件日志以及发送/接收的消息了

分享到: 更多 (0)