Java-mina (NIO framework)

Mina is the concrete realization of NIO. is currently a relatively efficient and popular NIO framework.

Here is a simple demo of communicating using Mina, followed by a simple framework for writing an RPC with Mina. Mina mainly include: (using the Mina version for 2.0.0.M4 Core, specifically visible official website) Mina also sub-server and client (this is sure ...) Where the server is: Niosocketacceptor client: Niosocketconnector is similar to the socket server and client socket. In addition to these basic communications, there are some operations classes that can be used to handle communication. is the filter on the client and server side. These filter can be used for decoding, encoding, can configure the log information, you can set the type of serialization, and so on. In addition, the client and the server can be bound to a iohnadler, to handle the connection session in open, receive information, close the status of the action can be carried out.

Now it's time to use Mina to perform a demo of a simple client upload file: The demo implementation idea is:The client is connected to the server, and the client transmits a certain size of file content to the server each time. (Byte way), then the server receives these bytes, outputs them, and forms the file. After the client sends, pass a complete flag, here can pass a string "Finish", then the server received this end flag, after the end of the write file, then transmit a successful flag to the client, (the string "Success") and then the client closes the connection.
Server: The code is relatively simple. Java code

2. Import java.net.InetSocketAddress;
4. Import Org.apache.mina.filter.codec.ProtocolCodecFilter;
6. Import Org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
8. Import Org.apache.mina.filter.logging.LoggingFilter;
10. Import Org.apache.mina.transport.socket.nio.NioSocketAcceptor;
16. Public class Main {
18. private static final int PORT = 8080;
22. public static void Main (string[] args) throws Exception {
24. //Service-side instances
26. Niosocketacceptor accept=New Niosocketacceptor ();
28. //Add Filter,codec to serialization mode.  This is the object serialization method, which means that the object is passed.
30. Accept.getfilterchain (). AddLast ("codec",
32. New Protocolcodecfilter (new Objectserializationcodecfactory ()));
34. //Add filter, log information
36. Accept.getfilterchain (). AddLast ("Logging", new Loggingfilter ());
38. //Set handler on the service side
40. Accept.sethandler (new Fileuploadhandler ());
42. //Bind IP
44. Accept.bind (new Inetsocketaddress (PORT));
48. System.out.println ("Upload server started.");
50. }
52. }

So simple to complete the service side of the implementation, in fact, can be more complex, where the log and code can be written and generated on their own, here only use Mina. Then the handler on the server side. Java code

2. Import Java.io.BufferedOutputStream;
4. Import Java.io.File;
6. Import Java.io.FileOutputStream;
8. Import Org.apache.commons.logging.Log;
10. Import Org.apache.commons.logging.LogFactory;
12. Import Org.apache.mina.core.service.IoHandlerAdapter;
14. Import org.apache.mina.core.session.IoSession;
18. Public class Fileuploadhandler extends Iohandleradapter {
22. private Bufferedoutputstream out;
26. private int count;
30. private String FileName = "D:/log/test.jpg";
34. private static final log log = Logfactory.getlog (Fileuploadhandler.   Class);
40. public void Sessionopened (iosession session) throws Exception {
42. SYSTEM.OUT.PRINTLN ("Server Open");
44. }
48. public void Exceptioncaught (iosession session, Throwable cause)
50. throws Exception {
52. System.out.println ("Exception");
54. Session.close (true);
56. Super.exceptioncaught (session, cause);
58. }
62. public void Messagereceived (iosession session, Object message) {
64. SYSTEM.OUT.PRINTLN ("Server received");
68. try {
70. if (message instanceof fileuploadrequest) {
72. //fileuploadrequest is used in the pass-through process.
74. Fileuploadrequest request = (fileuploadrequest) message;
76. System.out.println (Request.getfilename ());
78. if (out = = null) {
80. //Create a new file input object Bufferedoutputstream, and define the location of the new file arbitrarily.
82. out = new Bufferedoutputstream (new FileOutputStream (
84. "d:/log/" + Request.getfilename ()));
86. Out.write (Request.getfilecontent ());
88. } Else {
90. Out.write (Request.getfilecontent ());
92. }
94. Count + = Request.getfilecontent (). length;
98. } Else if (message instanceof String) {
100. if ((String) message). Equals ("Finish")) {
102. System.out.println ("size is" +count);
104. //This is the file transfer after the file is to be flush and close otherwise the files are not complete.
106. Out.flush ();
108. Out.close ();
110. //Receipt client information, upload file successful
112. Session.write ("Success");
114. }
116. }
120. } catch (Exception e) {
122. E.printstacktrace ();
124. }
126. }
130. public void Sessionclosed (iosession session) throws Exception {
132. SYSTEM.OUT.PRINTLN ("server Session Close");
134. }
136. }

All handler inherit Iohandleradapter and can view Iohandleradapter, which includes several methods for session state. You can overload it on demand. Then there is the common do:fileuploadrequest simple Pojo Java code that is used for transmission.

2. Import java.io.Serializable;
6. Public class Fileuploadrequest implements Serializable {
8. private String hostname;
10. private String filename;
12. private byte[] filecontent;
16. Public String GetHostName () {
18. return hostname;
20. }
24. public void SetHostName (String hostname) {
26. this.hostname = hostname;
28. }
32. Public String GetFileName () {
34. return filename;
36. }
40. public void Setfilename (String filename) {
42. this.filename = filename;
44. }
48. public byte[] Getfilecontent () {
50. return filecontent;
52. }
56. public void Setfilecontent (byte[] filecontent) {
58. this.filecontent = filecontent;
60. }
62. }

Next look at the client implementation, also very simple: Java code

2. Import Java.io.File;
4. Import Java.io.FileInputStream;
6. Import java.io.IOException;
8. Import java.net.InetSocketAddress;
10. Import Nio.upload.server.FileUploadRequest;
12. Import Org.apache.mina.core.future.ConnectFuture;
14. Import org.apache.mina.core.session.IoSession;
16. Import Org.apache.mina.filter.codec.ProtocolCodecFilter;
18. Import Org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
20. Import Org.apache.mina.filter.logging.LoggingFilter;
22. Import Org.apache.mina.transport.socket.nio.NioSocketConnector;
26. Public class Mainclient {
30. private static final int PORT = 8080;
34. /** 
36. * @param args
38. * @throws IOException
40. */
42. public static void Main (string[] args) throws Exception {
44. //client-side implementation
46. Niosocketconnector connector = new Niosocketconnector ();
48. Connector.getfilterchain (). AddLast ("codec",
50. New Protocolcodecfilter (new Objectserializationcodecfactory ()));
52. Connector.getfilterchain (). AddLast ("Logging", new Loggingfilter ());
54. Fileuploadclienthandler h = new Fileuploadclienthandler ();
56. Connector.sethandler (h);
58. //This sentence needs to be added, otherwise you cannot call the following readfuture to read the information returned from the session to the server.
60. Connector.getsessionconfig (). Setusereadoperation (true);
64. Connectfuture CF = Connector.connect (new inetsocketaddress ("localhost",
66. PORT));
70. Iosession session;
72. //wait for the connection to succeed
74. Cf.awaituninterruptibly ();
76. Session = Cf.getsession ();
80. SYSTEM.OUT.PRINTLN ("client send Begin");
84. //Pass file start
86. String fileName = "Test.jpg";
88. FileInputStream FIS = new FileInputStream (new File);
90. byte[] A = new byte[* 4];
92. Fileuploadrequest request = new Fileuploadrequest ();
94. Request.setfilename (FileName);
96. Request.sethostname ("localhost");
98. While (Fis.read (A, 0, a.length)! =-1) {
100. Request.setfilecontent (a);
102. //Like session to write information for the server to obtain
104. Session.write (Request);
106. }
108. //Send the completed flag
110. Session.write (new String ("Finish"));
114. SYSTEM.OUT.PRINTLN ("Client send finished and wait success");
116. //Connect the above to get information on the server
118. Object result = Session.read (). awaituninterruptibly (). GetMessage ();
120. if (Result.equals ("Success")) {
122. System.out.println ("success!");
124. //Close client
126. Connector.dispose ();
128. }
130. }
132. }

The implementation of the client handler. Java code

2. Import Org.apache.mina.core.service.IoHandlerAdapter;
4. Import org.apache.mina.core.session.IoSession;
10. Public class Fileuploadclienthandler extends Iohandleradapter {
14. public void Sessionopened (iosession session) throws Exception {
16. SYSTEM.OUT.PRINTLN ("client Open");
18. }
22. public void Sessionclosed (iosession session) throws Exception {
24. SYSTEM.OUT.PRINTLN ("client session close");
26. }
30. public void Messagereceived (iosession session, Object message)
32. throws Exception {
34. System.out.println ("thr result is" + message);
36. }
38. }

Java-mina (NIO framework)