- 浏览: 914835 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (498)
- J2EE (52)
- 数据库 (17)
- java基础 (43)
- web技术 (19)
- 程序设计 (6)
- 操作系统 (18)
- IT资讯 (7)
- 我的IT生活 (12)
- 学习笔记 (9)
- Jquery (25)
- JavaScript (18)
- spring (40)
- Hibernate (12)
- Struts (10)
- YUI (2)
- Extjs (22)
- .net (0)
- Eclipse (10)
- 社会主义 (2)
- 服务器 (9)
- CSS (8)
- 网络安全 (16)
- 版本控制 (9)
- PHP (2)
- Oracle (42)
- SQL server (1)
- Mysql (11)
- 项目管理 (3)
- 开发工具使用 (10)
- SQL语句 (7)
- Perl (0)
- Shell (6)
- 漏洞 (4)
- ibatis (5)
- hacker (2)
- SQL注入 (6)
- Hacker工具 (2)
- 入侵和渗透 (7)
- 插件/组件 (2)
- 最爱开源 (5)
- 常用软件 (2)
- DOS (1)
- HTML (2)
- Android (9)
- CMS (1)
- portal (8)
- Linux (7)
- OSGI (1)
- Mina (5)
- maven (2)
- hadoop (7)
- twitter storm (2)
- sap hana (0)
- OAuth (0)
- RESTful (1)
- Nginx (4)
- flex (1)
- Dubbo (1)
- redis (1)
- springMVC (1)
- node.js (1)
- solr (2)
- Flume (1)
- MongoDB (2)
- ElasticSearch (1)
最新评论
-
M_drm:
请问要怎么设置浏览器才不报没权限呢?
用JS在页面调用本地可执行文件的方法(ACTIVEX) -
Alexniver:
官方文档。When importing data into I ...
mysql导入数据过慢 解决方法 -
camelwoo:
我记得 Criteria 可以做连接查询与子查询,也可以做分页 ...
Hibernate总结篇二 -
zhenglongfei:
楼主如果SubKeyName 这个节点不存在,怎么办??怎么用 ...
Java操作注册表 -
yxx676229549:
用log4j 2 了
logback
nio学习:
最近花了点时间研究了一下nio,及其开源框架MINA,现把心得总结如下:
1:传统socket:阻塞式通信
每建立一个Socket连接时,同时创建一个新线程对该Socket进行单独通信(采用阻塞的方式通信)。
这种方式具有很高的响应速度,并且控制起来也很简单,在连接数较少的时候非常有效,但是如果
对每一个连接都产生一个线程的无疑是对系统资源的一种浪费,如果连接数较多将会出现资源不足的情况
example:
server code:
client code:
2.nio:非阻塞通讯模式
2.1NIO 设计背后的基石:反应器模式,用于事件多路分离和分派的体系结构模式。
反应器模式的核心功能如下:
将事件多路分用
将事件分派到各自相应的事件处理程序
NIO 的非阻塞 I/O 机制是围绕 选择器和 通道构建的。 Channel 类表示服务器和客户机之间的
一种通信机制。Selector 类是 Channel 的多路复用器。 Selector 类将传入客户机请求多路分
用并将它们分派到各自的请求处理程序。
通道(Channel 类):表示服务器和客户机之间的一种通信机制。
选择器(Selector类):是 Channel 的多路复用器。Selector 类将传入的客户机请求多路分用并将它们
分派到各自的请求处理程序。
简单的来说:
NIO是一个基于事件的IO架构,最基本的思想就是:有事件我通知你,你再去做你的事情.
而且NIO的主线程只有一个,不像传统的模型,需要多个线程以应对客户端请求,也减轻
了JVM的工作量。
当Channel注册至Selector以后,经典的调用方法如下:
nio中取得事件通知,就是在selector的select事件中完成的。在selector事件时有一个线程
向操作系统询问,selector中注册的Channel&&SelectionKey的键值对的各种事件是否有发生,
如果有则添加到selector的selectedKeys属性Set中去,并返回本次有多少个感兴趣的事情发生。
如果发现这个值>0,表示有事件发生,马上迭代selectedKeys中的SelectionKey,
根据Key中的表示的事件,来做相应的处理。
实际上,这段说明表明了异步socket的核心,即异步socket不过是将多个socket的调度(或者还有他们的线程调度)
全部交给操作系统自己去完成,异步的核心Selector,不过是将这些调度收集、分发而已。
2.2 nio example:
server code:
client code:
3:Socket网络框架 MINA
MINA是一个网络应用框架,在不牺牲性能和可扩展性的前提下用于解决如下问题:
1:快速开发自己的英勇。
2:高可维护性,高可复用性:网络I/O编码,消息的编/解码,业务逻辑互相分离。
3:相对容易的进行单元测试。
3.1 IoFilters:
IoFilter为MINA的功能扩展提供了接口。它拦截所有的IO事件进行事件的预处理和后处理(AOP)。我们可以把它想象成
Servlet的filters。
IoFilter能够实现以下几种目的:
事件日志
性能检测
数据转换(e.g. SSL support),codec
防火墙…等等
3.2 codec: ProtocolCodecFactory
MINA提供了方便的Protocol支持。如上说讲,codec在IoFilters中设置。
通过它的Encoder和Decoder,可以方便的扩展并支持各种基于Socket的网络协议,比如HTTP服务器、FTP服务器、Telnet服务器等等。
要实现自己的编码/解码器(codec)只需要实现interface: ProtocolCodecFactory即可.
在MINA 1.0版本,MINA已经实现了几个常用的(codec factory):
DemuxingProtocolCodecFactory,
NettyCodecFactory,
ObjectSerializationCodecFactory,
TextLineCodecFactory
其中:
TextLineCodecFactory:
A ProtocolCodecFactory that performs encoding and decoding between a text line data and a Java
string object. This codec is useful especially when you work with a text-based protocols such as SMTP and IMAP.
ObjectSerializationCodecFactory:
A ProtocolCodecFactory that serializes and deserializes Java objects. This codec is very useful when
you have to prototype your application rapidly without any specific codec.
DemuxingProtocolCodecFactory:
A composite ProtocolCodecFactory that consists of multiple MessageEncoders and MessageDecoders. ProtocolEncoder
and ProtocolDecoder this factory returns demultiplex incoming messages and buffers to appropriate MessageEncoders
and MessageDecoders.
NettyCodecFactory:
A MINA ProtocolCodecFactory that provides encoder and decoder for Netty2 Messages and MessageRecognizers.
3.3 business logic: IoHandler
MINA中,所有的业务逻辑都有实现了IoHandler的class完成
interfaceHandles:
all protocol events fired by MINA. There are 6 event handler methods, and they are all invoked by MINA automatically.
当事件发生时,将触发IoHandler中的方法:
sessionCreated, sessionOpened, sessionClosed, sessionIdle, exceptionCaught, messageReceived, messageSent
MINA 1.O中,IoHandler的实现类:
ChainedIoHandler, DemuxingIoHandler, IoHandlerAdapter, SingleSessionIoHandlerDelegate, StreamIoHandler
具体细节可参考javadoc。
3.4 MINA的高级主题:线程模式
MINA通过它灵活的filter机制来提供多种线程模型。
没有线程池过滤器被使用时MINA运行在一个单线程模式。
如果添加了一个IoThreadPoolFilter到IoAcceptor,将得到一个leader-follower模式的线程池。
如果再添加一个ProtocolThreadPoolFilter,server将有两个线程池;
一个(IoThreadPoolFilter)被用于对message对象进行转换,另外一个(ProtocolThreadPoolFilter)被用于处理业务逻辑。
SimpleServiceRegistry加上IoThreadPoolFilter和ProtocolThreadPoolFilter的缺省实现即可适用于需
要高伸缩性的应用。如果想使用自己的线程模型,请参考SimpleServiceRegistry的源代码,并且自己
初始化Acceptor。
采用MINA进行socket开发,一般步骤如下:
1:
server:
or client:
2:server的属性配置:
3:绑定address和business logic
server:
client:
下面的这个简单的example演示client和server传递object的过程:
Message.java
public class Message implements Serializable {
Client.java
ClientSessionHandler.java
Server.java
ServerSessionHandler.java
MINA自己附带的Demo已经很好的说明了它的运用。
值得一提的是它的SumUp:客户端发送几个数字,服务端求和后并返回结果。这个简单的程序演示了如何自己实现CODEC。
补充提示:
下载并运行MINA的demo程序还颇非周折:
运行MINA demo appli擦tion:
1:在JDK5
产生错误:
Exception in thread "main" java.lang.NoClassDefFoundError: edu/emory/mathcs/backport/java/util/concurrent/Executor
at org.apache.mina.example.reverser.Main.main(Main.java:44)
察看mina的QA email:
http://www.mail-archive.com/mina-dev@directory.apache.org/msg02252.html
原来需要下载:backport-util-concurrent.jar并加入classpath
http://dcl.mathcs.emory.edu/util/backport-util-concurrent/
继续运行还是报错:
Exception in thread "main" java.lang.NoClassDefFoundError: org/slf4j/LoggerFactory
原来MINA采用了slf4j项目作为log,继续下载
slf4j-simple.jar等,并加入classpath:
http://www.slf4j.org/download.html
最近花了点时间研究了一下nio,及其开源框架MINA,现把心得总结如下:
1:传统socket:阻塞式通信
每建立一个Socket连接时,同时创建一个新线程对该Socket进行单独通信(采用阻塞的方式通信)。
这种方式具有很高的响应速度,并且控制起来也很简单,在连接数较少的时候非常有效,但是如果
对每一个连接都产生一个线程的无疑是对系统资源的一种浪费,如果连接数较多将会出现资源不足的情况
example:
server code:
public class MultiUserServer extends Thread { private Socket client; public MultiUserServer(Socket c) { this.client = c; } public void run() { try { BufferedReader in = new BufferedReader(new InputStreamReader(client .getInputStream())); PrintWriter out = new PrintWriter(client.getOutputStream()); // Mutil User but can't parallel while (true) { String str = in.readLine(); System.out.println(str); SocketLog.debug("receive message: " + str); out.println("has receive...."); out.flush(); if (str.equals("end")) break; } client.close(); } catch (IOException ex) { } } public static void main(String[] args) throws IOException { int port = 5678; if (args.length > 0) port = Integer.parseInt(args[0]); ServerSocket server = new ServerSocket(port); SocketLog.debug("the server socket application is created!"); while (true) { // transfer location change Single User or Multi User MultiUserServer mu = new MultiUserServer(server.accept()); mu.start(); } } }
client code:
public class Client { static Socket server; public static void main(String[] args) throws Exception { //set socket proxy. String proxyHost = "192.161.88.22"; String proxyPort = "2080"; System.getProperties().put("socksProxySet","true"); System.getProperties().put("socksProxyHost",proxyHost); System.getProperties().put("socksProxyPort",proxyPort); String host = "192.20.9.18"; int port = 1086; if (args.length > 1) { host = args[0]; port = Integer.parseInt(args[1]); } System.out.println("connetioning:" + host + ":" + port); server = new Socket(host, port); BufferedReader in = new BufferedReader(new InputStreamReader(server .getInputStream())); PrintWriter out = new PrintWriter(server.getOutputStream()); BufferedReader wt = new BufferedReader(new InputStreamReader(System.in)); while (true) { String str = wt.readLine(); out.println(str); out.flush(); if (str.equals("end")) { break; } System.out.println(in.readLine()); } server.close(); } }
2.nio:非阻塞通讯模式
2.1NIO 设计背后的基石:反应器模式,用于事件多路分离和分派的体系结构模式。
反应器模式的核心功能如下:
将事件多路分用
将事件分派到各自相应的事件处理程序
NIO 的非阻塞 I/O 机制是围绕 选择器和 通道构建的。 Channel 类表示服务器和客户机之间的
一种通信机制。Selector 类是 Channel 的多路复用器。 Selector 类将传入客户机请求多路分
用并将它们分派到各自的请求处理程序。
通道(Channel 类):表示服务器和客户机之间的一种通信机制。
选择器(Selector类):是 Channel 的多路复用器。Selector 类将传入的客户机请求多路分用并将它们
分派到各自的请求处理程序。
简单的来说:
NIO是一个基于事件的IO架构,最基本的思想就是:有事件我通知你,你再去做你的事情.
而且NIO的主线程只有一个,不像传统的模型,需要多个线程以应对客户端请求,也减轻
了JVM的工作量。
当Channel注册至Selector以后,经典的调用方法如下:
while (somecondition) { int n = selector.select(TIMEOUT); if (n == 0) continue; for (Iterator iter = selector.selectedKeys().iterator(); iter .hasNext();) { if (key.isAcceptable()) doAcceptable(key); if (key.isConnectable()) doConnectable(key); if (key.isValid() && key.isReadable()) doReadable(key); if (key.isValid() && key.isWritable()) doWritable(key); iter.remove(); } }
nio中取得事件通知,就是在selector的select事件中完成的。在selector事件时有一个线程
向操作系统询问,selector中注册的Channel&&SelectionKey的键值对的各种事件是否有发生,
如果有则添加到selector的selectedKeys属性Set中去,并返回本次有多少个感兴趣的事情发生。
如果发现这个值>0,表示有事件发生,马上迭代selectedKeys中的SelectionKey,
根据Key中的表示的事件,来做相应的处理。
实际上,这段说明表明了异步socket的核心,即异步socket不过是将多个socket的调度(或者还有他们的线程调度)
全部交给操作系统自己去完成,异步的核心Selector,不过是将这些调度收集、分发而已。
2.2 nio example:
server code:
public class NonBlockingServer { public Selector sel = null; public ServerSocketChannel server = null; public SocketChannel socket = null; public int port = 4900; String result = null; public NonBlockingServer() { System.out.println("Inside default ctor"); } public NonBlockingServer(int port) { System.out.println("Inside the other ctor"); this.port = port; } public void initializeOperations() throws IOException,UnknownHostException { System.out.println("Inside initialization"); sel = Selector.open(); server = ServerSocketChannel.open(); server.configureBlocking(false); InetAddress ia = InetAddress.getLocalHost(); InetSocketAddress isa = new InetSocketAddress(ia,port); server.socket().bind(isa); } public void startServer() throws IOException { System.out.println("Inside startserver"); initializeOperations(); System.out.println("Abt to block on select()"); SelectionKey acceptKey = server.register(sel, SelectionKey.OP_ACCEPT ); while (acceptKey.selector().select() > 0 ) { Set readyKeys = sel.selectedKeys(); Iterator it = readyKeys.iterator(); while (it.hasNext()) { SelectionKey key = (SelectionKey)it.next(); it.remove(); if (key.isAcceptable()) { System.out.println("Key is Acceptable"); ServerSocketChannel ssc = (ServerSocketChannel) key.channel(); socket = (SocketChannel) ssc.accept(); socket.configureBlocking(false); SelectionKey another = socket.register(sel,SelectionKey.OP_READ|SelectionKey.OP_WRITE); } if (key.isReadable()) { System.out.println("Key is readable"); String ret = readMessage(key); if (ret.length() > 0) { writeMessage(socket,ret); } } if (key.isWritable()) { System.out.println("THe key is writable"); String ret = readMessage(key); socket = (SocketChannel)key.channel(); if (result.length() > 0 ) { writeMessage(socket,ret); } } } } } public void writeMessage(SocketChannel socket,String ret) { System.out.println("Inside the loop"); if (ret.equals("quit") || ret.equals("shutdown")) { return; } try { String s = "This is context from server!-----------------------------------------"; Charset set = Charset.forName("us-ascii"); CharsetDecoder dec = set.newDecoder(); CharBuffer charBuf = dec.decode(ByteBuffer.wrap(s.getBytes())); System.out.println(charBuf.toString()); int nBytes = socket.write(ByteBuffer.wrap((charBuf.toString()).getBytes())); System.out.println("nBytes = "+nBytes); result = null; } catch(Exception e) { e.printStackTrace(); } } public String readMessage(SelectionKey key) { int nBytes = 0; socket = (SocketChannel)key.channel(); ByteBuffer buf = ByteBuffer.allocate(1024); try { nBytes = socket.read(buf); buf.flip(); Charset charset = Charset.forName("us-ascii"); CharsetDecoder decoder = charset.newDecoder(); CharBuffer charBuffer = decoder.decode(buf); result = charBuffer.toString(); } catch(IOException e) { e.printStackTrace(); } return result; } public static void main(String args[]) { NonBlockingServer nb; if (args.length < 1) { nb = new NonBlockingServer(); } else { int port = Integer.parseInt(args[0]); nb = new NonBlockingServer(port); } try { nb.startServer(); System.out.println("the nonBlocking server is started!"); } catch (IOException e) { e.printStackTrace(); System.exit(-1); } } }
client code:
public class Client { public SocketChannel client = null; public InetSocketAddress isa = null; public RecvThread rt = null; private String host; private int port; public Client(String host, int port) { this.host = host; this.port = port; } public void makeConnection() { String proxyHost = "199.18.24.212"; String proxyPort = "8090"; System.getProperties().put("socksProxySet", "true"); System.getProperties().put("socksProxyHost", proxyHost); System.getProperties().put("socksProxyPort", proxyPort); int result = 0; try { client = SocketChannel.open(); isa = new InetSocketAddress(host, port); client.connect(isa); client.configureBlocking(false); receiveMessage(); } catch (UnknownHostException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } long begin = System.currentTimeMillis(); sendMessage(); long end = System.currentTimeMillis(); long userTime = end - begin; System.out.println("use tiem: " + userTime); try { interruptThread(); client.close(); System.exit(0); } catch (IOException e) { e.printStackTrace(); } } public int sendMessage() { System.out.println("Inside SendMessage"); String msg = null; ByteBuffer bytebuf; int nBytes = 0; try { msg = "It's message from client!"; System.out.println("msg is "+msg); bytebuf = ByteBuffer.wrap(msg.getBytes()); for (int i = 0; i < 1000; i++) { nBytes = client.write(bytebuf); System.out.println(i + " finished"); } interruptThread(); try { Thread.sleep(5000); } catch (Exception e) { e.printStackTrace(); } client.close(); return -1; } catch (IOException e) { e.printStackTrace(); } return nBytes; } public void receiveMessage() { rt = new RecvThread("Receive THread", client); rt.start(); } public void interruptThread() { rt.val = false; } public static void main(String args[]) { if (args.length < 2) { System.err.println("You should put 2 args: host,port"); } else { String host = args[0]; int port = Integer.parseInt(args[1]); Client cl = new Client(host, port); cl.makeConnection(); } BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); String msg; }
public class RecvThread extends Thread { public SocketChannel sc = null; public boolean val = true; public RecvThread(String str, SocketChannel client) { super(str); sc = client; } public void run() { int nBytes = 0; ByteBuffer buf = ByteBuffer.allocate(2048); try { while (val) { while ((nBytes = nBytes = client.read(buf)) > 0) { buf.flip(); Charset charset = Charset.forName("us-ascii"); CharsetDecoder decoder = charset.newDecoder(); CharBuffer charBuffer = decoder.decode(buf); String result = charBuffer.toString(); System.out.println("the server return: " + result); buf.flip(); } } } catch (IOException e) { e.printStackTrace(); } } } }
3:Socket网络框架 MINA
MINA是一个网络应用框架,在不牺牲性能和可扩展性的前提下用于解决如下问题:
1:快速开发自己的英勇。
2:高可维护性,高可复用性:网络I/O编码,消息的编/解码,业务逻辑互相分离。
3:相对容易的进行单元测试。
3.1 IoFilters:
IoFilter为MINA的功能扩展提供了接口。它拦截所有的IO事件进行事件的预处理和后处理(AOP)。我们可以把它想象成
Servlet的filters。
IoFilter能够实现以下几种目的:
事件日志
性能检测
数据转换(e.g. SSL support),codec
防火墙…等等
3.2 codec: ProtocolCodecFactory
MINA提供了方便的Protocol支持。如上说讲,codec在IoFilters中设置。
通过它的Encoder和Decoder,可以方便的扩展并支持各种基于Socket的网络协议,比如HTTP服务器、FTP服务器、Telnet服务器等等。
要实现自己的编码/解码器(codec)只需要实现interface: ProtocolCodecFactory即可.
在MINA 1.0版本,MINA已经实现了几个常用的(codec factory):
DemuxingProtocolCodecFactory,
NettyCodecFactory,
ObjectSerializationCodecFactory,
TextLineCodecFactory
其中:
TextLineCodecFactory:
A ProtocolCodecFactory that performs encoding and decoding between a text line data and a Java
string object. This codec is useful especially when you work with a text-based protocols such as SMTP and IMAP.
ObjectSerializationCodecFactory:
A ProtocolCodecFactory that serializes and deserializes Java objects. This codec is very useful when
you have to prototype your application rapidly without any specific codec.
DemuxingProtocolCodecFactory:
A composite ProtocolCodecFactory that consists of multiple MessageEncoders and MessageDecoders. ProtocolEncoder
and ProtocolDecoder this factory returns demultiplex incoming messages and buffers to appropriate MessageEncoders
and MessageDecoders.
NettyCodecFactory:
A MINA ProtocolCodecFactory that provides encoder and decoder for Netty2 Messages and MessageRecognizers.
3.3 business logic: IoHandler
MINA中,所有的业务逻辑都有实现了IoHandler的class完成
interfaceHandles:
all protocol events fired by MINA. There are 6 event handler methods, and they are all invoked by MINA automatically.
当事件发生时,将触发IoHandler中的方法:
sessionCreated, sessionOpened, sessionClosed, sessionIdle, exceptionCaught, messageReceived, messageSent
MINA 1.O中,IoHandler的实现类:
ChainedIoHandler, DemuxingIoHandler, IoHandlerAdapter, SingleSessionIoHandlerDelegate, StreamIoHandler
具体细节可参考javadoc。
3.4 MINA的高级主题:线程模式
MINA通过它灵活的filter机制来提供多种线程模型。
没有线程池过滤器被使用时MINA运行在一个单线程模式。
如果添加了一个IoThreadPoolFilter到IoAcceptor,将得到一个leader-follower模式的线程池。
如果再添加一个ProtocolThreadPoolFilter,server将有两个线程池;
一个(IoThreadPoolFilter)被用于对message对象进行转换,另外一个(ProtocolThreadPoolFilter)被用于处理业务逻辑。
SimpleServiceRegistry加上IoThreadPoolFilter和ProtocolThreadPoolFilter的缺省实现即可适用于需
要高伸缩性的应用。如果想使用自己的线程模型,请参考SimpleServiceRegistry的源代码,并且自己
初始化Acceptor。
IoThreadPoolFilter threadPool = new IoThreadPoolFilter();threadPool.start(); IoAcceptor acceptor = new SocketAcceptor(); acceptor.getFilterChain().addLast( "threadPool", threadPool); ProtocolThreadPoolFilter threadPool2 = new ProtocolThreadPoolFilter(); threadPool2.start(); ProtocolAcceptor acceptor2 = new IoProtocolAcceptor( acceptor ); acceptor2.getFilterChain().addLast( "threadPool", threadPool2 ); ... threadPool2.stop(); threadPool.stop();
采用MINA进行socket开发,一般步骤如下:
1:
server:
IoAcceptor acceptor = new SocketAcceptor(); //建立client接收器
or client:
SocketConnector connector = new SocketConnector(); //建立一个连接器
2:server的属性配置:
SocketAcceptorConfig cfg = new SocketAcceptorConfig(); cfg.setReuseAddress(true); cfg.getFilterChain().addLast( "codec", new ProtocolCodecFilter( new ObjectSerializationCodecFactory() ) ); //对象序列化 codec factory cfg.getFilterChain().addLast( "logger", new LoggingFilter() );
3:绑定address和business logic
server:
acceptor.bind( new InetSocketAddress( SERVER_PORT ), new ServerSessionHandler( ), cfg ); // 绑定address和handler
client:
connector.connect(new InetSocketAddress( HOSTNAME, PORT ), new ClientSessionHandler(msg), cfg );
下面的这个简单的example演示client和server传递object的过程:
Message.java
public class Message implements Serializable {
private int type; private int status; private String msgBody; public Message(int type, int status, String msgBody) { this.type = type; this.status = status; this.msgBody = msgBody; } public String getMsgBody() { return msgBody; } public void setMsgBody(String msgBody) { this.msgBody = msgBody; } public int getStatus() { return status; } public void setStatus(int status) { this.status = status; } public int getType() { return type; } public void setType(int type) { this.type = type; } }
Client.java
public class Client { private static final String HOSTNAME = "localhost"; private static final int PORT = 8080; private static final int CONNECT_TIMEOUT = 30; // seconds public static void main( String[] args ) throws Throwable { SocketConnector connector = new SocketConnector(); // Configure the service. SocketConnectorConfig cfg = new SocketConnectorConfig(); cfg.setConnectTimeout( CONNECT_TIMEOUT ); cfg.getFilterChain().addLast( "codec", new ProtocolCodecFilter( new ObjectSerializationCodecFactory() ) ); cfg.getFilterChain().addLast( "logger", new LoggingFilter() ); IoSession session; Message msg = new Message(0,1,"hello"); connector.connect(new InetSocketAddress( HOSTNAME, PORT ), new ClientSessionHandler(msg), cfg ); } }
ClientSessionHandler.java
public class ClientSessionHandler extends IoHandlerAdapter { private Object msg; public ClientSessionHandler(Object msg) { this.msg = msg; } public void sessionOpened( IoSession session ) { session.write(this.msg); } public void messageReceived( IoSession session, Object message ) { System.out.println("in messageReceived!"); Message rm = (Message ) message; SessionLog.debug(session, rm.getMsgBody()); System.out.println("message is: " + rm.getMsgBody()); session.write(rm); } public void exceptionCaught( IoSession session, Throwable cause ) { session.close(); } }
Server.java
public class Server { private static final int SERVER_PORT = 8080; public static void main( String[] args ) throws Throwable { IoAcceptor acceptor = new SocketAcceptor(); // Prepare the service configuration. SocketAcceptorConfig cfg = new SocketAcceptorConfig(); cfg.setReuseAddress( true ); cfg.getFilterChain().addLast( "codec", new ProtocolCodecFilter( new ObjectSerializationCodecFactory() ) ); cfg.getFilterChain().addLast( "logger", new LoggingFilter() ); acceptor.bind( new InetSocketAddress( SERVER_PORT ), new ServerSessionHandler( ), cfg ); System.out.println( "The server Listening on port " + SERVER_PORT ); } }
ServerSessionHandler.java
public class ServerSessionHandler extends IoHandlerAdapter { public void sessionOpened( IoSession session ) { // set idle time to 60 seconds session.setIdleTime( IdleStatus.BOTH_IDLE, 60 ); session.setAttribute("times",new Integer(0)); } public void messageReceived( IoSession session, Object message ) { System.out.println("in messageReceived"); int times = ((Integer)(session.getAttribute("times"))).intValue(); System.out.println("tiems = " + times); // communicate 30 times,then close the session. if (times < 30) { times++; session.setAttribute("times", new Integer(times)); Message msg; msg = (Message) message; msg.setMsgBody("in server side: " + msg.getMsgBody()); System.out.println("begin send msg: " + msg.getMsgBody()); session.write(msg); } else { session.close(); } } public void sessionIdle( IoSession session, IdleStatus status ) { SessionLog.info( session, "Disconnecting the idle." ); // disconnect an idle client session.close(); } public void exceptionCaught( IoSession session, Throwable cause ) { // close the connection on exceptional situation session.close(); } }
MINA自己附带的Demo已经很好的说明了它的运用。
值得一提的是它的SumUp:客户端发送几个数字,服务端求和后并返回结果。这个简单的程序演示了如何自己实现CODEC。
补充提示:
下载并运行MINA的demo程序还颇非周折:
运行MINA demo appli擦tion:
1:在JDK5
产生错误:
Exception in thread "main" java.lang.NoClassDefFoundError: edu/emory/mathcs/backport/java/util/concurrent/Executor
at org.apache.mina.example.reverser.Main.main(Main.java:44)
察看mina的QA email:
http://www.mail-archive.com/mina-dev@directory.apache.org/msg02252.html
原来需要下载:backport-util-concurrent.jar并加入classpath
http://dcl.mathcs.emory.edu/util/backport-util-concurrent/
继续运行还是报错:
Exception in thread "main" java.lang.NoClassDefFoundError: org/slf4j/LoggerFactory
原来MINA采用了slf4j项目作为log,继续下载
slf4j-simple.jar等,并加入classpath:
http://www.slf4j.org/download.html
相关推荐
相比之下,Mina NIO是一种基于Java NIO API的网络通信框架,它利用了多路复用器(Selector)和通道(Channel)的概念,实现了非阻塞I/O。在Mina中,`SocketConnectorSupport.java`可能是一个自定义的连接器支持类,...
总结来说,这个"网络编程(socket、NIO、mina)---demo"涵盖了网络编程的基础与进阶,从基础的Socket通信,到提高性能的NIO,再到高级的Mina框架,这些都是开发分布式系统、网络服务和实时通信应用不可或缺的技术。...
总结来说,本教程将引导你从理论到实践,掌握Java NIO的基本原理,理解Mina框架的使用,以及如何在SpringBoot环境中整合Mina实现高效的网络通信。通过这些知识的学习,你将具备开发高并发、高性能网络应用的能力。
总的来说,Mina NIO Socket是一个强大且灵活的网络通信框架,它简化了Java网络服务的开发,提供了高效、非阻塞的I/O机制。通过深入理解和应用Mina,开发者能够构建出高性能、可扩展的网络应用,满足各种复杂的业务...
Mina和Socket是两种常见的网络通信框架和技术,它们在Java编程环境中被广泛使用。本篇文章将深入探讨如何使用Mina与Socket实现通信,并提供客户端和服务端的实现代码概述。 Mina(全称“MINA: Minimalistic ...
Socket Mina测试框架是一个强大的网络通信应用框架,主要用于简化Java应用程序与远程服务器之间的通信。它提供了高度可扩展和高性能的I/O处理模型,使得开发者能够更专注于业务逻辑,而不是底层的网络实现细节。Mina...
总结起来,`Android-MinaSocket` 是一个基于Apache Mina的Android长连接库,它提供了稳定、高效的网络通信功能,适用于需要实时数据交互的Android应用。通过使用这个库,开发者可以专注于业务逻辑,而无需过多关心...
MINA (Java Multithreaded Network Application Framework) 是一个基于NIO的开源框架,它为开发高性能、高可用性的网络应用提供了抽象层。MINA 提供了事件驱动的模型,简化了网络编程的复杂性,开发者可以通过编写...
mina框架是Apache组织开发的一个网络通信框架,它基于Java NIO(非阻塞I/O)构建,用于简化网络编程,尤其是TCP和UDP协议的应用开发。本项目提供了服务端和客户端的示例,使得开发者能够更好地理解和应用MINA框架。 ...
`SamplMinaServerHandler.java`可能涉及到Apache Mina库,这是一个强大的NIO框架,简化了开发复杂的网络应用。Mina提供了高级抽象,如IoHandler,用于处理网络事件,以及Session,代表一个网络连接。`Client.java`则...
总结来说,Socket通信是网络编程的基础,而MINA长连接则是Socket通信的一种优化实现,尤其适合需要高效处理大量并发连接和实时数据交换的场景。在实际开发中,你可以根据项目需求选择适合的技术栈,例如使用MINA来...
Ioserver java Nio socket 框架 是个不错的NIO 通讯框架,本来想学习mina框架,看了看mina的源码太头痛,本人觉得看懂了Ioserver 再看mina的框架,想多的学习 java NIO 的也可以下载 看看,很值得学习啊!!!
mina简单示例,Apache Mina Server 是一个网络通信应用框架,也就是说,它主要是对基于TCP/IP、UDP/IP协议栈的通信框架(当然,也可以提供JAVA 对象的序列化服务、虚拟机管道通信服务等),Mina 可以帮助我们快速...
总的来说,Java客户端通过Socket直接通信虽然简单,但在处理大量并发或需要高级功能(如心跳检测、异步处理)时,Mina框架提供了更强大的支持。结合两者,我们可以构建出高效、可靠的长连接网络应用。在实际开发中,...
**Android Java Socket框架 Mina2.0** Mina2.0是Apache软件基金会的一个开源项目,它是一个网络通信框架,主要应用于Java环境。Mina旨在简化高性能、高可用性和高可扩展性的网络应用开发,特别适合于处理大量并发...
总结起来,基于MINA的TLS/SSL NIO Socket实现涉及到的主要步骤包括: 1. 创建SSLContext并配置证书、密钥和协议。 2. 创建SSLEngine,并根据应用角色设置工作模式。 3. 在MINA的IoFilterChain中添加SSLFilter。 4. ...
MINA是一个为高性能网络应用提供高度抽象的Java NIO框架,它简化了网络编程,尤其是TCP/IP和UDP/IP协议的使用。标题中提及的“所需jar”指的是为了运行这个项目所必需的第三方库文件,通常包括MINA框架本身和其他...
以上就是使用Java Mina框架创建一个简单的Socket服务端和客户端的实现。在实际应用中,可能还需要考虑异常处理、心跳机制、多线程处理、消息序列化与反序列化等问题。Mina提供的API非常灵活,可以根据需求进行扩展和...