1. 首页
  2. HTML
  3. 【Apache Mina2.0开发之一】搭建Apache Mina框架并实现Server与Client端的简单消息传递！

【Apache Mina2.0开发之一】搭建Apache Mina框架并实现Server与Client端的简单消息传递！

•html•阅读 89

首先建立一个new project（Server端），这里Himi使用IDE是 eclipse；

OK，首先我们这里先配置下环境：对于Mina的日志输出使用的是slf4j，对于slf4j在开发Hibernate的时候已经很熟悉了，不需要再介绍了。另外一方面就是加入mina的core核心jar包；

1. mina-core.jar 2. slf4j-api.jar 3.slf4j-simple.jar

然后我们首先创建两个类：

  1. /**

  2. * @author Himi

  3. */

  4. import java.io.Serializable;

  5. public class HimiObject implements Serializable{

  6. public HimiObject(int id,String name){

  7. this.id=id;

  8. this.name=name;

  9. }

  10. private int id;

  11. private String name;

  12. public int getId() {

  13. return id;

  14. }

  15. public void setId(int id) {

  16. this.id = id;

  17. }

  18. public String getName() {

  19. return name;

  20. }

  21. public void setName(String name) {

  22. this.name = name;

  23. }

  24. }

这个类是个消息Object，它用于server与client端的交互的数据，它需要序列化，所以我们使用Serializable接口；至于在mina框架中起到什么作用这个后续来说；

ClientMinaServerHanlder.java

  1. import org.apache.mina.core.service.IoHandlerAdapter;

  2. import org.apache.mina.core.session.IdleStatus;

  3. import org.apache.mina.core.session.IoSession;

  4. public class ClientMinaServerHanlder extends IoHandlerAdapter {

  5. private int count = 0;

  6. // 当一个新客户端连接后触发此方法.

  7. public void sessionCreated(IoSession session) {

  8. System.out.println("新客户端连接");

  9. }

  10. // 当一个客端端连结进入时 @Override

  11. public void sessionOpened(IoSession session) throws Exception {

  12. count++;

  13. System.out.println("第 " + count + " 个 client 登陆！address： : "

  14. + session.getRemoteAddress());

  15. }

  16. // 当客户端发送的消息到达时:

  17. @Override

  18. public void messageReceived(IoSession session, Object message)

  19. throws Exception {

  20. // // 我们己设定了服务器解析消息的规则是一行一行读取,这里就可转为String:

  21. // String s = (String) message;

  22. // // Write the received data back to remote peer

  23. // System.out.println("收到客户机发来的消息: " + s);

  24. // // 测试将消息回送给客户端 session.write(s+count); count++;

  25. HimiObject ho = (HimiObject) message;

  26. System.out.println(ho.getName());

  27. ho.setName("serverHimi");

  28. session.write(ho);

  29. }

  30. // 当信息已经传送给客户端后触发此方法.

  31. @Override

  32. public void messageSent(IoSession session, Object message) {

  33. System.out.println("信息已经传送给客户端");

  34. }

  35. // 当一个客户端关闭时

  36. @Override

  37. public void sessionClosed(IoSession session) {

  38. System.out.println("one Clinet Disconnect !");

  39. }

  40. // 当连接空闲时触发此方法.

  41. @Override

  42. public void sessionIdle(IoSession session, IdleStatus status) {

  43. System.out.println("连接空闲");

  44. }

  45. // 当接口中其他方法抛出异常未被捕获时触发此方法

  46. @Override

  47. public void exceptionCaught(IoSession session, Throwable cause) {

  48. System.out.println("其他方法抛出异常");

  49. }

  50. }

本类主要是继承IoHandlerAdapter并且重写其类的一些函数，至于每个函数的作用Himi都已经在代码中加以注视；本类的作用：

此类是用以处理消息的也可说是个消息处理器，当客户端有消息传给server端的时候，或者server端传递给Client端的时候（Client端也会有个消息处理器）都会通过消息处理器进行处理。

OK，下面我们来书写server端的main函数类：

  1. import java.io.IOException;

  2. import java.net.InetSocketAddress;

  3. import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;

  4. import org.apache.mina.filter.codec.ProtocolCodecFilter;

  5. import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;

  6. import org.apache.mina.transport.socket.SocketAcceptor;

  7. import org.apache.mina.transport.socket.nio.NioSocketAcceptor;

  8. public class MinaServer {

  9. /**

  10. * @param args

  11. */

  12. public static void main(String[] args) {

  13. //创建一个非阻塞的server端Socket ，用NIO

  14. SocketAcceptor acceptor = new NioSocketAcceptor();

  15. /*---------接收字符串---------*/

  16. // //创建一个接收数据过滤器

  17. // DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();

  18. // //设定过滤器一行行(/r/n)的读取数据

  19. // chain.addLast("mychin", new ProtocolCodecFilter(new TextLineCodecFactory() ));

  20. /*---------接收对象---------*/

  21. //创建接收数据的过滤器

  22. DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();

  23. //设定这个过滤器将以对象为单位读取数据

  24. ProtocolCodecFilter filter= new ProtocolCodecFilter(new ObjectSerializationCodecFactory());

  25. chain.addLast("objectFilter",filter);

  26. //设定服务器消息处理器

  27. acceptor.setHandler(new ClientMinaServerHanlder());

  28. //服务器绑定的端口

  29. int bindPort = 9988;

  30. //绑定端口，启动服务器

  31. try {

  32. acceptor.bind(new InetSocketAddress(bindPort));

  33. } catch (IOException e) {

  34. System.out.println("Mina Server start for error!"+bindPort);

  35. e.printStackTrace();

  36. }

  37. System.out.println("Mina Server run done! on port:"+bindPort);

  38. }

  39. }

IoService 是负责底层通讯接入，而 IoHandler 是负责业务处理的。那么 MINA 架构图中的 IoFilter 作何用途呢？答案是你想作何用途都可以。但是有一个用途却是必须的，那就是作为 IoService 和 IoHandler 之间的桥梁。IoHandler 接口中最重要的一个方法是 messageReceived，这个方法的第二个参数是一个 Object 型的消息，总所周知，Object 是所有 Java 对象的基础，那到底谁来决定这个消息到底是什么类型呢？这个取决于我们后面设定的过滤器！

对于在mina中建立一个server，步骤如下：

1. 建立一个SockerAcceptor ，除了启动server之外它还可以为我们可以生成过滤器DefaultIoFilterChainBuilder、设置消息处理器等功能；

2.设置过滤器

3. 设置消息处理器

其实很容易不是么？ 哈哈；

OK，这里多说一些：

对于消息处理器 DefaultIoFilterChainBuilder，它的作用是用于设定收发的形式，例如：

        //创建一个接收数据过滤器
                DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
                //设定过滤器一行行(/r/n)的读取数据
                chain.addLast("mychin", new ProtocolCodecFilter(new TextLineCodecFactory()   ));

这样设置一个过滤器作用是将来自客户端输入的信息转换成一行行的文本后传递给 IoHandler，因此我们可以在 messageReceived 中直接将 msg 对象强制转换成 String 对象。

ps.而如果我们不提供任何过滤器的话，那么在 messageReceived 方法中的第二个参数类型就是一个 byte 的缓冲区，对应的类是 org.apache.mina.common.ByteBuffer。虽然你也可以将解析客户端信息放在 IoHandler 中来做，但这并不是推荐的做法，使原来清晰的模型又模糊起来，变得 IoHandler 不只是业务处理，还得充当协议解析的任务。

mina自身带有一些常用的过滤器，例如LoggingFilter（日志记录）、BlackListFilter（黑名单过滤）、CompressionFilter（压缩）、SSLFilter（SSL加密）等。

  1. //创建接收数据的过滤器

  2. DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();

  3. //设定这个过滤器将以对象为单位读取数据

  4. ProtocolCodecFilter filter= new ProtocolCodecFilter(new ObjectSerializationCodecFactory());

  5. chain.addLast("objectFilter",filter);

这样以来我们server可以收发Object对象啦；

acceptor.setHandler(new ClientMinaServerHanlder());

这里是设置消息处理器，绑定在我们的ClientMinaServerHanlder类上，其实mina对于收发处理已经完全交给开发者来进行处理，所以至于在消息处理器如何编写和处理就放任不会管了；

OK，现在我们可以run一下启动server端了；

当然我们现在也可以来测试了，当前我们还没有书写Client端的代码，所以我们使用terminal终端进行测试，OK，打开你的terminal

然后输入 telnet localhost 9988

观察服务器打印：

【Apache Mina2.0开发之一】搭建Apache Mina框架并实现Server与Client端的简单消息传递！

OK，没有任何问题；但是这时候大家不要在终端书写内容给server，因为我们server的消息处理器中的接受Client的函数中做了如下处理：

  1. // 当客户端发送的消息到达时:

  2. @Override

  3. public void messageReceived(IoSession session, Object message)

  4. throws Exception {

  5. // // 我们己设定了服务器解析消息的规则是一行一行读取,这里就可转为String:

  6. // String s = (String) message;

  7. // // Write the received data back to remote peer

  8. // System.out.println("收到客户机发来的消息: " + s);

  9. // // 测试将消息回送给客户端 session.write(s+count); count++;

  10. HimiObject ho = (HimiObject) message;

  11. System.out.println(ho.getName());

  12. ho.setName("serverHimi");

  13. session.write(ho);

  14. }

Himi这里server处理client端发来的数据处理函数(如上代码)中，当Client发送数据过来的时候，将消息message强制转换成了一个HimiObject对象，然后改个name重写发给Client端，但是由于Client端是使用终端模拟登陆根本无法接受这个对象，所以会出异常；

但是到这里大家应该懂得，HimiObject类的作用了；哈哈

下面我们来书写Client客户端，对于建立一个Client端，其实步骤雷同，步骤如下：

1 . 建立一个NioSocketConnector对象；

2. 设定过滤器

3. 设定消息处理器

  1. import java.net.InetSocketAddress;

  2. import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;

  3. import org.apache.mina.core.future.ConnectFuture;

  4. import org.apache.mina.filter.codec.ProtocolCodecFilter;

  5. import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;

  6. import org.apache.mina.transport.socket.nio.NioSocketConnector;

  7. public class MainClient {

  8. public static void main(String[] args) {

  9. // 创建一个tcp/ip 连接

  10. NioSocketConnector connector = new NioSocketConnector();

  11. /*---------接收字符串---------*/

  12. // //创建接收数据的过滤器

  13. // DefaultIoFilterChainBuilder chain = connector.getFilterChain();

  14. // // 设定这个过滤器将一行一行(/r/n)的读取数据

  15. // chain.addLast("myChin", new ProtocolCodecFilter(

  16. // new TextLineCodecFactory()));

  17. /*---------接收对象---------*/

  18. // 创建接收数据的过滤器

  19. DefaultIoFilterChainBuilder chain = connector.getFilterChain();

  20. // 设定这个过滤器将以对象为单位读取数据

  21. ProtocolCodecFilter filter = new ProtocolCodecFilter(

  22. new ObjectSerializationCodecFactory());

  23. // 设定服务器端的消息处理器:一个SamplMinaServerHandler对象,

  24. chain.addLast("objectFilter",filter);

  25. // 设定服务器端的消息处理器:一个 SamplMinaServerHandler 对象,

  26. connector.setHandler(new ClientMinaServerHanlder());

  27. // Set connect timeout.

  28. connector.setConnectTimeoutCheckInterval(30);

  29. // 连结到服务器:

  30. ConnectFuture cf = connector.connect(new InetSocketAddress("localhost",

  31. 9988));

  32. // Wait for the connection attempt to be finished.

  33. cf.awaitUninterruptibly();

  34. cf.getSession().getCloseFuture().awaitUninterruptibly();

  35. connector.dispose();

  36. }

  37. }

不多说了，很eazy：那么我们继续看Clent端的消息处理器以及HimiObject：

ClentMinaServerHanlder：

  1. import org.apache.mina.core.service.IoHandlerAdapter;

  2. import org.apache.mina.core.session.IoSession;

  3. public class ClientMinaServerHanlder extends IoHandlerAdapter {

  4. // 当一个客端端连结到服务器后

  5. @Override

  6. public void sessionOpened(IoSession session) throws Exception {

  7. // session.write("我来啦........");

  8. HimiObject ho = new HimiObject(1,"Himi");

  9. session.write(ho);

  10. }

  11. // 当一个客户端关闭时

  12. @Override

  13. public void sessionClosed(IoSession session) {

  14. System.out.println("I'm Client && I closed!");

  15. }

  16. // 当服务器端发送的消息到达时:

  17. @Override

  18. public void messageReceived(IoSession session, Object message)

  19. throws Exception {

  20. // // 我们己设定了服务器解析消息的规则是一行一行读取,这里就可转为 String:

  21. // String s = (String) message;

  22. // // Write the received data back to remote peer

  23. // System.out.println("服务器发来的收到消息: " + s);

  24. // // 测试将消息回送给客户端 session.write(s);

  25. HimiObject ho = (HimiObject) message;

  26. System.out.println(ho.getName());

  27. }

  28. }

Client的HimiObject与服务器Server的HimiObejct类一模一样！

可能有童鞋不理解为什么server端与client的HimiObject一模一样，这里Himi说下，通过Client端的消息处理器可以看出，当我们Client端连接到服务器后，首先会写给Server端一个HimiObject对象！那么服务器之前说过了，接受到Client端的消息后首先将消息强制转换成HimiObject对象然后处理；

既然Client端发的是Object，那么当然我们的服务器也要有对应的此Object对象才可以，否则如何获取这个Object? 大家应该很容易理解；

OK，不多说直接运行Client端，观察结果：

【Apache Mina2.0开发之一】搭建Apache Mina框架并实现Server与Client端的简单消息传递！

相关推荐

Copyright © 2008-2024渝ICP备2022006305号-5.

本站所有数据收集于网络如有侵犯到您的权益请联系，进行下架处理。