`
dreamoftch
  • 浏览: 498077 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

apache MINA入门

minanio 
阅读更多

 

nio聊天和使用Mina实现nio聊天：

http://dreamoftch.iteye.com/blog/2087858

 

server:

 

package com.tch.test.jms.origin.server;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

import org.apache.mina.core.service.IoAcceptor;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IdleStatus;
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.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyServer {
	
	private static final Logger LOGGER = LoggerFactory.getLogger(MyServer.class);
	private List<IoSession> clientSessionList = new ArrayList<IoSession>();
	
	public static void main(String[] args) {
	    
		IoAcceptor acceptor = new NioSocketAcceptor();

		acceptor.getFilterChain().addLast("logger", new LoggingFilter());
		acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));

		acceptor.setHandler(new MyServer().new MyServerIoHandler());
		
		try {
			acceptor.bind(new InetSocketAddress(10000));
		} catch (IOException ex) {
			LOGGER.error(ex.getMessage(), ex);
		}
	}
	
	class MyServerIoHandler extends IoHandlerAdapter{
        
        @Override
        public void sessionCreated(IoSession session) throws Exception {
            LOGGER.info("sessionCreated");
        }
        
        @Override
        public void sessionOpened(IoSession session) throws Exception {
            LOGGER.info("sessionOpened");
            if(! clientSessionList.contains(session)){
                clientSessionList.add(session);
            }
        }

        @Override
        public void sessionClosed(IoSession session) throws Exception {
            LOGGER.info("sessionClosed");
            clientSessionList.remove(session);
        }

        @Override
        public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
            LOGGER.info("sessionIdle");
        }

        @Override
        public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
            LOGGER.error(cause.getMessage(), cause);
            session.close(true);
            clientSessionList.remove(session);
        }

        @Override
        public void messageReceived(IoSession session, Object message) throws Exception {
            LOGGER.info("messageReceived:" + message);
            for(IoSession clientSession : clientSessionList){
                clientSession.write(message);
            }
        }

        @Override
        public void messageSent(IoSession session, Object message) throws Exception {
            LOGGER.info("messageSent:" + message);
        }
    }
}

 

 

client :

 

package com.tch.test.jms.origin.client;

import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.Charset;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.JTextField;

import org.apache.mina.core.RuntimeIoException;
import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.service.IoConnector;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IdleStatus;
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.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class NioClient extends JFrame{
    private static final Logger LOGGER = LoggerFactory.getLogger(NioClient.class);
	private static final long serialVersionUID = 1L;
	private JTextArea area = new JTextArea("content :");
	private JTextField textField = new JTextField("textfield:");
	private JButton button = new JButton("send");
	private String message = null;
	private MyClientIoHandler handler;
	private IoSession session;

	public static void main(String[] args) throws Exception {
		NioClient client = new NioClient();
		client.start();
	}
	
	private void start() throws IOException{
		setBounds(200, 200, 300, 400);
		setLayout(new GridLayout(3, 1));
		add(area);
		add(textField);
		
		IoConnector connector = new NioSocketConnector();
        connector.setConnectTimeoutMillis(10 * 1000);
        
        connector.getFilterChain().addLast("logger", new LoggingFilter());
        connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
        
        handler = new MyClientIoHandler(this);
        connector.setHandler(handler);
		
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent event) {
			    sendMessage();
			}
		});
		add(button);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setVisible(true);
		
		IoSession session = null;
        try {
            ConnectFuture future = connector.connect(new InetSocketAddress("localhost", 10000));
            future.awaitUninterruptibly();
            session = future.getSession();
        } catch (RuntimeIoException e) {
            LOGGER.error(e.getMessage(), e);
        }
        session.getCloseFuture().awaitUninterruptibly();
        connector.dispose();
	}
	
	private void sendMessage() {
        try {
            message = textField.getText();
            textField.setText("");
            if(session == null || ! session.isConnected()){
                throw new RuntimeException("session is null");
            }
            session.write(message);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
	
	class MyClientIoHandler extends IoHandlerAdapter{
	    private NioClient client;
        public MyClientIoHandler(NioClient client){
            this.client = client;
        }
        @Override
        public void sessionCreated(IoSession session) throws Exception {
            LOGGER.info("sessionCreated");
        }

        @Override
        public void sessionOpened(IoSession session) throws Exception {
            LOGGER.info("sessionOpened");
            client.session = session;
        }

        @Override
        public void sessionClosed(IoSession session) throws Exception {
            LOGGER.info("sessionClosed");
        }

        @Override
        public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
            LOGGER.info("sessionIdle");
        }

        @Override
        public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
            LOGGER.error(cause.getMessage(), cause);
            session.close(true);
        }

        @Override
        public void messageReceived(IoSession session, Object message) throws Exception {
            LOGGER.info("messageReceived: " + message);
            if (message.toString().equalsIgnoreCase("Bye")) {
                session.close(true);
            }
            area.setText(area.getText().trim()+"\n"+message);
        }

        @Override
        public void messageSent(IoSession session, Object message) throws Exception {
            LOGGER.info("messageSent: " + message);
        }
    }
	
}

 

 

 

参考：

Apache MINA实战之 牛刀小试

 

Apache MINA实战之 对象传输

 

MINA用法介绍：

 

Mina几个主要的组件如下：

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 - 自己的业务逻辑。

 

log4j.properties ：

 

log4j.rootLogger=info, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %5p (%c:%L) - %m%n


log4j.logger.org.apache.mina=ERROR

 

 

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

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

 

[html] view plaincopyprint?
 
  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端的代码

 

 

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

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端的代码

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

 

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类，就可以分别在各自的终端上看到事件日志以及发送/接收的消息了。

 

 

下面是发送对象：

 

利用Apache MINA来传递对象，这对了MINA来说非常容易，并且这也是Java网络编程中很常用的应用。其实对于MINA传递对象来说，如果看过前一篇文章的话，只要在其中做少许改动就可以实现对象传递，但这里考虑到例子的完整性，还是给出了全部代码示例。 

首先看两个用来传递的Java对象MyRequestObject和MyResponseObject，很简单只是实现了Serializable接口罢了。

 

[java] view plaincopyprint?
 
  1. package com.google.code.garbagecan.minastudy.sample3;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. public class MyRequestObject implements Serializable {  
  6.   
  7.     private static final long serialVersionUID = 1L;  
  8.   
  9.     private String name;  
  10.       
  11.     private String value;  
  12.   
  13.     public MyRequestObject(String name, String value) {  
  14.         this.name = name;  
  15.         this.value = value;  
  16.     }  
  17.       
  18.     public String getName() {  
  19.         return name;  
  20.     }  
  21.   
  22.     public void setName(String name) {  
  23.         this.name = name;  
  24.     }  
  25.   
  26.     public String getValue() {  
  27.         return value;  
  28.     }  
  29.   
  30.     public void setValue(String value) {  
  31.         this.value = value;  
  32.     }  
  33.       
  34.     @Override  
  35.     public String toString() {  
  36.         StringBuffer sb = new StringBuffer();  
  37.         sb.append("Request [name: " + name  + ", value: " + value + "]");  
  38.         return sb.toString();  
  39.     }  
  40. }  
  41.   
  42. package com.google.code.garbagecan.minastudy.sample3;  
  43.   
  44. import java.io.Serializable;  
  45.   
  46. public class MyResponseObject implements Serializable {  
  47.   
  48.     private static final long serialVersionUID = 1L;  
  49.   
  50.     private String name;  
  51.       
  52.     private String value;  
  53.   
  54.     public MyResponseObject(String name, String value) {  
  55.         this.name = name;  
  56.         this.value = value;  
  57.     }  
  58.       
  59.     public String getName() {  
  60.         return name;  
  61.     }  
  62.   
  63.     public void setName(String name) {  
  64.         this.name = name;  
  65.     }  
  66.   
  67.     public String getValue() {  
  68.         return value;  
  69.     }  
  70.   
  71.     public void setValue(String value) {  
  72.         this.value = value;  
  73.     }  
  74.       
  75.     @Override  
  76.     public String toString() {  
  77.         StringBuffer sb = new StringBuffer();  
  78.         sb.append("Response [name: " + name  + ", value: " + value + "]");  
  79.         return sb.toString();  
  80.     }  
  81. }  

看看Server端的代码

 

 

[java] view plaincopyprint?
 
  1. package com.google.code.garbagecan.minastudy.sample3;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.InetSocketAddress;  
  5.   
  6. import org.apache.mina.core.service.IoAcceptor;  
  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.serialization.ObjectSerializationCodecFactory;  
  12. import org.apache.mina.filter.logging.LoggingFilter;  
  13. import org.apache.mina.transport.socket.nio.NioSocketAcceptor;  
  14. import org.slf4j.Logger;  
  15. import org.slf4j.LoggerFactory;  
  16.   
  17. public class MyServer {  
  18.       
  19.     private static final Logger logger = LoggerFactory.getLogger(MyServer.class);  
  20.       
  21.     public static void main(String[] args) {  
  22.         IoAcceptor acceptor = new NioSocketAcceptor();  
  23.   
  24.         acceptor.getFilterChain().addLast("logger", new LoggingFilter());  
  25.         acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));  
  26.   
  27.         acceptor.setHandler(new IoHandlerAdapter() {  
  28.               
  29.             @Override  
  30.             public void sessionCreated(IoSession session) throws Exception {  
  31.             }  
  32.               
  33.             @Override  
  34.             public void sessionOpened(IoSession session) throws Exception {  
  35.             }  
  36.   
  37.             @Override  
  38.             public void sessionClosed(IoSession session) throws Exception {  
  39.             }  
  40.   
  41.             @Override  
  42.             public void sessionIdle(IoSession session, IdleStatus status) throws Exception {  
  43.             }  
  44.   
  45.             @Override  
  46.             public void exceptionCaught(IoSession session, Throwable cause) throws Exception {  
  47.                 logger.error(cause.getMessage(), cause);  
  48.                 session.close(true);  
  49.             }  
  50.   
  51.             @Override  
  52.             public void messageReceived(IoSession session, Object message) throws Exception {  
  53.                 logger.info("Received " + message);  
  54.                 MyRequestObject myReqOjb = (MyRequestObject) message;  
  55.                 MyResponseObject myResObj = new MyResponseObject(myReqOjb.getName(), myReqOjb.getValue());  
  56.                 session.write(myResObj);  
  57.             }  
  58.   
  59.             @Override  
  60.             public void messageSent(IoSession session, Object message) throws Exception {  
  61.                 logger.info("Sent " + message);  
  62.             }  
  63.         });  
  64.           
  65.         try {  
  66.             acceptor.bind(new InetSocketAddress(10000));  
  67.         } catch (IOException ex) {  
  68.             logger.error(ex.getMessage(), ex);  
  69.         }  
  70.     }  
  71. }  

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

 

2. 创建I/O Filter Chain，这里使用了两个个IoFilter，一个是LoggingFilter用来记录日志和打印事件消息，另一个是ProtocolCodecFilter实例用来编码数据，这里使用了ObjectSerializationCodecFactory类来序列化或反序列化数据成java对象。 

3. 创建I/O Handler，这里主要看一下messageReceived方法，其总接收了MyRequestObject对象，然后又发送了一个MyResponseObject对象给Client端。 

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

 

看看Client端的代码

 

[java] view plaincopyprint?
 
  1. package com.google.code.garbagecan.minastudy.sample3;  
  2.   
  3. import java.net.InetSocketAddress;  
  4.   
  5. import org.apache.mina.core.RuntimeIoException;  
  6. import org.apache.mina.core.future.ConnectFuture;  
  7. import org.apache.mina.core.service.IoConnector;  
  8. import org.apache.mina.core.service.IoHandlerAdapter;  
  9. import org.apache.mina.core.session.IdleStatus;  
  10. import org.apache.mina.core.session.IoSession;  
  11. import org.apache.mina.filter.codec.ProtocolCodecFilter;  
  12. import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;  
  13. import org.apache.mina.filter.logging.LoggingFilter;  
  14. import org.apache.mina.transport.socket.nio.NioSocketConnector;  
  15. import org.slf4j.Logger;  
  16. import org.slf4j.LoggerFactory;  
  17.   
  18. public class MyClient {  
  19.       
  20.     private static final Logger logger = LoggerFactory.getLogger(MyClient.class);  
  21.       
  22.     public static void main(String[] args) {  
  23.         IoConnector connector = new NioSocketConnector();  
  24.         connector.setConnectTimeoutMillis(10 * 1000);  
  25.           
  26.         connector.getFilterChain().addLast("logger", new LoggingFilter());  
  27.         connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));  
  28.           
  29.         connector.setHandler(new IoHandlerAdapter() {  
  30.               
  31.             @Override  
  32.             public void sessionCreated(IoSession session) throws Exception {  
  33.             }  
  34.   
  35.             @Override  
  36.             public void sessionOpened(IoSession session) throws Exception {  
  37.                 MyRequestObject myObj = new MyRequestObject("my name", "my value");  
  38.                 session.write(myObj);  
  39.             }  
  40.   
  41.             @Override  
  42.             public void sessionClosed(IoSession session) throws Exception {  
  43.             }  
  44.   
  45.             @Override  
  46.             public void sessionIdle(IoSession session, IdleStatus status) throws Exception {  
  47.             }  
  48.   
  49.             @Override  
  50.             public void exceptionCaught(IoSession session, Throwable cause) throws Exception {  
  51.                 logger.error(cause.getMessage(), cause);  
  52.                 session.close(true);  
  53.             }  
  54.   
  55.             @Override  
  56.             public void messageReceived(IoSession session, Object message) throws Exception {  
  57.                 MyResponseObject myResObj = (MyResponseObject) message;  
  58.                 logger.info("Received " + myResObj);  
  59.                 session.close(true);  
  60.             }  
  61.   
  62.             @Override  
  63.             public void messageSent(IoSession session, Object message) throws Exception {  
  64.                 logger.info("Sent " + message);  
  65.             }  
  66.         });  
  67.   
  68.         IoSession session = null;  
  69.         try {  
  70.             ConnectFuture future = connector.connect(new InetSocketAddress("localhost", 10000));  
  71.             future.awaitUninterruptibly();  
  72.             session = future.getSession();  
  73.         } catch (RuntimeIoException e) {  
  74.             logger.error(e.getMessage(), e);  
  75.         }  
  76.   
  77.         session.getCloseFuture().awaitUninterruptibly();  
  78.         connector.dispose();  
  79.     }  
  80. }  

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

 

2. 创建I/O Filter Chain，和服务器端同样设置了两个IoFilter，一个是LoggingFilter用来记录日志和打印事件消息，另一个是ProtocolCodecFilter实例用来编码数据，这里也使用了ObjectSerializationCodecFactory类来序列化或反序列化数据成java对象。 

3. 创建I/O Handler，主要看一下sessionOpened方法，其中在会话建立事件中发送了MyRequestObject对象，然后在messageReceived方法中又接受了MyResponseObject对象。 

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

 

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

 

分享到：
| java类加载顺序和垃圾回收
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Apache Mina 入门Demo

    通过深入学习和实践这个Apache Mina入门Demo，你将掌握如何利用Mina构建网络应用，并了解其核心特性和工作原理，这对于从事Java网络编程或者需要处理大规模并发连接的开发者来说是非常有价值的。

    Apache Mina入门（完成版）

    在“Apache Mina入门（完成版）”这份资料中，你将了解到以下关键知识点： 1. **Mina架构**：Mina的核心设计理念是事件驱动和异步通信，它采用了I/O多路复用技术，如Java NIO（非阻塞I/O），以提高服务端处理大量...

    ApacheMina入门

    Apache Mina是一个开源项目，由Apache软件基金会维护，它是一个网络通信框架，专注于提供高性能、...对于初学者，阅读《Apache Mina入门（完成版）》PDF文档将是一个很好的起点，深入学习Mina的内部机制和实践技巧。

    ApacheMina入门（完成版）

    总之，Apache Mina为Java开发者提供了一个强大、灵活的网络通信框架，通过本文档中的"Apache Mina入门（完成版）.pdf"，你可以系统性地学习如何使用它来构建高效稳定的网络应用。通过实践和理解，你将能够熟练地驾驭...

    Apache Mina入门

    ### Apache Mina 入门详解 #### 一、Mina简介与应用场景 ##### Mina概述 Mina（**Mini Network Application**）是一个简洁且易于使用的Java网络应用开发框架，主要针对TCP/IP通信进行优化设计。它能够帮助开发者...

    apache Mina的完整学习资料

    入门Apache Mina，你需要了解以下几个关键概念： 1. **事件驱动模型**：Mina采用事件驱动模型，当网络事件（如连接建立、数据接收、连接关闭等）发生时，会触发相应的回调方法。 2. **Filter Chain**：通过Filter ...

    Apache mina框架入门教程

    Apache Mina 框架是一个强大的网络通信应用框架，它主要针对基于TCP/IP和UDP/IP的协议栈，同时也支持Java对象序列化和其他通信方式。Mina 的核心设计目标是帮助开发者快速构建高性能、高可扩展性的网络应用。它采用...

    Apache MINA 2.0 用户指南中英文对照阅读版[带书签]

    本资源包含两个 pdf 文档，一本根据官方最新文档 (http://mina.apache.org/mina-project/userguide/user-guide-toc.html) 整理的 mina_2.0_user_guide_en.pdf，一个中文翻译的 mina_2.0_user_guide_cn.pdf。...

    mina入门实例

    这就是一个基础的Mina入门实例，展示了如何使用Mina进行客户端-服务器间的通信。随着深入学习，你可以了解更多的Mina特性，如心跳机制、多线程处理、会话管理等，以构建更复杂、高效的网络应用。

    mina2资料-各种教程

    了解以上知识点是掌握Apache MINA的基础，通过提供的学习资料，如《Mina2.0学习笔记》、《Apache MINA入门基础》和《Apache MINA Server 2.0中文参考手册》等，可以深入学习MINA的API用法、设计原理和最佳实践。...

    Apache Mina 2 完全自学手册

    #### Mina入门 **第一步：下载并配置JAR包** - **mina-core-2.0.0-M1.jar**：这是Mina的核心库，提供了主要的功能和API。 - **slf4j-api-1.5.2.jar** 和 **slf4j-log4j12-1.5.2.jar**：用于日志记录，提供了一致的...

    apache mina详细介绍，适合新手入门mina

    ### Apache Mina 详解 ...Apache Mina 是一个强大且灵活的网络通信框架，非常适合初学者入门使用。通过本篇文档的学习，希望读者能够对 Mina 的基本原理和使用方法有一个全面的认识，并能够在实际项目中灵活运用。

    mina入门例子

    本入门例子将带你了解如何使用MINA进行基本的网络通信应用开发。 首先，MINA的核心概念包括`Session`、`Filter`和`Handler`。`Session`代表一个网络连接，它是数据传输的通道；`Filter`是处理`Session`中数据的...

    Apache MINA基于JAVA的网络服务器框架 教程.zip

    3. **Apache MINA 快速入门 lj棒.txt**：这可能是一个快速入门指南，帮助开发者快速理解MINA的基本概念和实现一个简单的网络服务器。 4. **SmartFoxServer 是专门为Adobe Flash设计的跨平台socket服务器**：...

    Apache+Mina入门基础

    mina是一种高效的互联网网络通信架构，此资料为入门基础。

    Apache MINA (2) Hello World!

    "示例，我们可以快速入门，了解如何创建一个简单的MINA服务端并处理客户端连接。这个过程涉及到了网络编程的基本概念，如连接建立、数据交换和连接关闭，以及MINA特有的异步事件驱动模型。通过学习和实践这个示例，...

    apache mina

    - 通过Apache_Mina入门资料，我们可以学习如何创建服务器和客户端，设置IoFilter和IoHandler，以及如何处理网络事件。 - Apache MINA Server 2.0中文参考手册提供了详细的技术指南，包括API的使用、配置示例和最佳...

Magicbox
Global site tag (gtag.js) - Google Analytics