java-mina(nio 框架)

2021-11-12 02:21:56

mina是对nio的具体实现。是目前比较高效和流行的nio框架了。

下面是对使用mina进行通讯的一个简单demo，后面再用mina写一个RPC的简单框架。
 
mina主要包括：
(使用的mina版本为2.0.0.M4 core，具体可见官方网站 )
mina也分服务端和客户端(这是肯定的...)
 
其中服务端为：NioSocketAcceptor
客户端为：NioSocketConnector
 
类似于Socket的服务端跟客户端Socket。除了这些用来基本通讯的之外，还有一些可以用来处理通讯中的操作类。就是在客户端和服务端的一个个filter。这些filter可以用来进行解码，编码，可以配置日志信息，可以设定序列化类型，等等。
另外为客户端和服务端都可以绑定一个IoHnadler,用来处理连接session在打开，收到信息，关闭等状态时候可以进行的动作。
 
现在就来使用mina进行一个简单的客户端上传文件的demo的实现：
demo实现的思想为：

客
户端跟服务端建立起来连接，客户端每次想服务端传输一定大小的文件内容。(byte的方式)，然后服务端接收这些byte，将其output出来，形成文

件。客户端发送完毕后，传递一个完毕的标志，这里可以传个字符串”finish“，然后服务器收到这个结束标志，在写文件结束后，再传输个成功的标志给客
户端，(字符串”success“)然后客户端关闭连接。

服务端：
代码比较简单。
 
  1. import java.net.InetSocketAddress;
  2. import org.apache.mina.filter.codec.ProtocolCodecFilter;
  3. import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
  4. import org.apache.mina.filter.logging.LoggingFilter;
  5. import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
  6. public class Main {
  7. private static final int PORT = 8080;
  8. public static void main(String[] args) throws Exception {
  9. //服务端的实例
  10. NioSocketAcceptor accept=new NioSocketAcceptor();
  11. //添加filter，codec为序列化方式。这里为对象序列化方式，即表示传递的是对象。
  12. accept.getFilterChain().addLast("codec",
  13. new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
  14. //添加filter，日志信息
  15. accept.getFilterChain().addLast("logging", new LoggingFilter());
  16. //设置服务端的handler
  17. accept.setHandler(new FileUploadHandler());
  18. //绑定ip
  19. accept.bind(new InetSocketAddress(PORT));
  20. System.out.println("upload  server started.");
  21. }
  22. }
 
就这样简单的完成了服务端的实现，其实可以复杂一些，其中的log跟code都可以根据需要自己来写和生成，这里只使用mina自带的。
然后是服务端的handler。
 
  1. import java.io.BufferedOutputStream;
  2. import java.io.File;
  3. import java.io.FileOutputStream;
  4. import org.apache.commons.logging.Log;
  5. import org.apache.commons.logging.LogFactory;
  6. import org.apache.mina.core.service.IoHandlerAdapter;
  7. import org.apache.mina.core.session.IoSession;
  8. public class FileUploadHandler extends IoHandlerAdapter {
  9. private BufferedOutputStream out;
  10. private int count;
  11. private String fileName = "D:/log/test.jpg";
  12. private static final Log log = LogFactory.getLog(FileUploadHandler.class);
  13. public void sessionOpened(IoSession session) throws Exception {
  14. System.out.println("server open");
  15. }
  16. public void exceptionCaught(IoSession session, Throwable cause)
  17. throws Exception {
  18. System.out.println("exception");
  19. session.close(true);
  20. super.exceptionCaught(session, cause);
  21. }
  22. public void messageReceived(IoSession session, Object message) {
  23. System.out.println("server received");
  24. try {
  25. if (message instanceof FileUploadRequest) {
  26. //FileUploadRequest 为传递过程中使用的DO。
  27. FileUploadRequest request = (FileUploadRequest) message;
  28. System.out.println(request.getFilename());
  29. if (out == null) {
  30. //新建一个文件输入对象BufferedOutputStream，随便定义新文件的位置
  31. out = new BufferedOutputStream(new FileOutputStream(
  32. "D:/log/" + request.getFilename()));
  33. out.write(request.getFileContent());
  34. } else {
  35. out.write(request.getFileContent());
  36. }
  37. count += request.getFileContent().length;
  38. } else if (message instanceof String) {
  39. if (((String)message).equals("finish")) {
  40. System.out.println("size is"+count);
  41. //这里是进行文件传输后，要进行flush和close否则传递的文件不完整。
  42. out.flush();
  43. out.close();
  44. //回执客户端信息，上传文件成功
  45. session.write("success");
  46. }
  47. }
  48. } catch (Exception e) {
  49. e.printStackTrace();
  50. }
  51. }
  52. public void sessionClosed(IoSession session) throws Exception {
  53. System.out.println("server session close");
  54. }
  55. }
 
所有的handler都要继承IoHandlerAdapter，可以查看IoHandlerAdapter，其包括几个关于session状态的方法。按需进行重载即可。
 
然后就是公用的用来传输的DO：FileUploadRequest简单的POJO
 
  1. import java.io.Serializable;
  2. public class FileUploadRequest implements Serializable {
  3. private String hostname;
  4. private String filename;
  5. private byte[] fileContent;
  6. public String getHostname() {
  7. return hostname;
  8. }
  9. public void setHostname(String hostname) {
  10. this.hostname = hostname;
  11. }
  12. public String getFilename() {
  13. return filename;
  14. }
  15. public void setFilename(String filename) {
  16. this.filename = filename;
  17. }
  18. public byte[] getFileContent() {
  19. return fileContent;
  20. }
  21. public void setFileContent(byte[] fileContent) {
  22. this.fileContent = fileContent;
  23. }
  24. }
 
接下来看下客户端的实现，也很简单：
 
  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.IOException;
  4. import java.net.InetSocketAddress;
  5. import nio.upload.server.FileUploadRequest;
  6. import org.apache.mina.core.future.ConnectFuture;
  7. import org.apache.mina.core.session.IoSession;
  8. import org.apache.mina.filter.codec.ProtocolCodecFilter;
  9. import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
  10. import org.apache.mina.filter.logging.LoggingFilter;
  11. import org.apache.mina.transport.socket.nio.NioSocketConnector;
  12. public class MainClient {
  13. private static final int PORT = 8080;
  14. /**
  15. * @param args
  16. * @throws IOException
  17. */
  18. public static void main(String[] args) throws Exception {
  19. //客户端的实现
  20. NioSocketConnector connector = new NioSocketConnector();
  21. connector.getFilterChain().addLast("codec",
  22. new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
  23. connector.getFilterChain().addLast("logging", new LoggingFilter());
  24. FileUploadClientHandler h = new FileUploadClientHandler();
  25. connector.setHandler(h);
  26. //本句需要加上，否则无法调用下面的readFuture来从session中读取到服务端返回的信息。
  27. connector.getSessionConfig().setUseReadOperation(true);
  28. ConnectFuture cf = connector.connect(new InetSocketAddress("localhost",
  29. PORT));
  30. IoSession session;
  31. //等待连接成功
  32. cf.awaitUninterruptibly();
  33. session = cf.getSession();
  34. System.out.println("client send begin");
  35. //传递文件开始
  36. String fileName = "test.jpg";
  37. FileInputStream fis = new FileInputStream(new File(fileName));
  38. byte[] a = new byte[1024 * 4];
  39. FileUploadRequest request = new FileUploadRequest();
  40. request.setFilename(fileName);
  41. request.setHostname("localhost");
  42. while (fis.read(a, 0, a.length) != -1) {
  43. request.setFileContent(a);
  44. //像session中写入信息供服务端获得
  45. session.write(request);
  46. }
  47. //发送完成的标志
  48. session.write(new String("finish"));
  49. System.out.println("client send finished and wait success");
  50. //接上面来取得服务端的信息
  51. Object result = session.read().awaitUninterruptibly().getMessage();
  52. if (result.equals("success")) {
  53. System.out.println("success!");
  54. //关闭客户端
  55. connector.dispose();
  56. }
  57. }
  58. }
 
客户端handler的实现。
 
  1. import org.apache.mina.core.service.IoHandlerAdapter;
  2. import org.apache.mina.core.session.IoSession;
  3. public class FileUploadClientHandler extends IoHandlerAdapter {
  4. public void sessionOpened(IoSession session) throws Exception {
  5. System.out.println("client open");
  6. }
  7. public void sessionClosed(IoSession session) throws Exception {
  8. System.out.println("client session close");
  9. }
  10. public void messageReceived(IoSession session, Object message)
  11. throws Exception {
  12. System.out.println("thr result is" + message);
  13. }
  14. }
上一篇：定时任务之Spring与Quartz的整合(有修改)


下一篇：使用Quartz.net来执行定时任务