Java NIO是相对于传统的IO操作而言的，因为提出了缓冲池等概念，使它的处理数据的效率大大提高；
多线程是并发处理的明智选择。
为减少系统开销，线程池是并发应用中是经常使用的技术。
而异步处理机制可以大大缩短每个请求的响应时间。
Mina2中就大量使用了这三项技术，使得它成为优秀的网络应用框架。（这一章并非描述Mina的实际应用，而是对它的内部处理机制做分析；我们对Mina的解析也只对服务端而言：因为无论是Mina也好，NIO也好，多线程也好，异步处理机制也好，都是解决高并发问题的；高并发却是对服务端而言的！因此，服务端才是重点。）
一.NIO分析
Mina是一个Java NIO框架，NIO的基本思想是：服务器程序只需要一个线程就能同时负责接收客户的连接、客户发送的数据，以及向各个客户发送响应数据。服务器程序的处理流程如下：
//阻塞
while(一直等待，直到有接收连接就绪事件、读就绪事件或写就绪事件发生){
if(有客户连接)
接收客户的连接; //非阻塞
if(某个Socket的输入流中有可读数据)
从输入流中读数据; //非阻塞
if(某个Socket的输出流可以写数据)
向输出流写数据; //非阻塞
}
而传统的并发型服务器则是采用多线程的模式响应用户请求的；
//阻塞
while(一直等待){
if(有客户连接)
启动新线程，与客户的通信; //可能会阻塞
}
但是，无论如何，服务端共同的结构如下：
a.Read Request； 接受请求
b.Decode Request； 请求值解码(读)
c.Process Service；请求处理
d.Encode Reply； 响应值编码(写)
e.Send Reply； 发送响应
是不是感觉太抽象了？OK，我们从传统的IO模式的并发服务器说起。
1.传统阻塞服务器
传统的服务端一次只能处理一个请求，其他请求需要排队等待；示例如下：
package com.bijian.study.mina.server;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import org.apache.log4j.Logger;
/*
* 服务端只能一次处理一个客户端的请求
* 多个请求到达后需要排队
*/
public class EchoServer01 {
private Logger logger = Logger.getLogger(EchoServer01.class);
private int PORT = 3015;
private ServerSocket serverSocket;
public EchoServer01() throws IOException {
// 请求队列最大长度为5
serverSocket = new ServerSocket(PORT,5);
logger.info("服务端启动... 端口号：" + PORT);
}
public void service() {
while (true) {
Socket socket = null;
try {
socket = serverSocket.accept();
logger.info("一个新的连接到达，地址为：" + socket.getInetAddress() + ":"
+ socket.getPort());
// 获得客户端发送信息的输入流
InputStream socketIn = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(
socketIn));
// 给客户端响应信息的输出流
OutputStream socketOut = socket.getOutputStream();
PrintWriter pw = new PrintWriter(socketOut, true);
String msg = null;
while ((msg = br.readLine()) != null) {
logger.info("服务端接受到的信息为：" + msg);
pw.println("响应信息：" + new Date().toString());// 给客户端一个日期字符串
if (msg.equals("bye")) {
logger.info("客户端请求断开");
break;
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (socket != null)
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void main(String args[]) throws IOException {
new EchoServer01().service();
}
}
代码就不解释啦，直接看注释吧，没有任何玄妙的地方。我们先用telnet做测试。
a.启动服务端
2016-02-18 23:02:22,832 INFO EchoServer01 - 服务端启动... 端口号：3015
b.启动，cmd，telnet 127.0.0.1 3015，回车
c.测试，客户端输入
服务端响应：
2016-02-18 23:04:09,984 INFO EchoServer01 - 服务端启动... 端口号：3015
2016-02-18 23:04:24,049 INFO EchoServer01 - 一个新的连接到达，地址为：/127.0.0.1:51937
2016-02-18 23:04:26,907 INFO EchoServer01 - 服务端接受到的信息为：bijian
2016-02-18 23:04:30,463 INFO EchoServer01 - 服务端接受到的信息为：test
2016-02-18 23:04:38,055 INFO EchoServer01 - 服务端接受到的信息为：123
2016-02-18 23:04:39,569 INFO EchoServer01 - 服务端接受到的信息为：sfas
2016-02-18 23:04:43,409 INFO EchoServer01 - 服务端接受到的信息为：bye
2016-02-18 23:04:43,409 INFO EchoServer01 - 客户端请求断开
2016-02-18 23:06:19,021 INFO EchoServer01 - 一个新的连接到达，地址为：/127.0.0.1:51941
d.使用客户端代码做测试；EchoClient01.java代码如下：
package com.bijian.study.mina.client;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import org.apache.log4j.Logger;
/*
* 使用Socket创建客户端请求
*/
public class EchoClient01 {
private Logger logger = Logger.getLogger(EchoClient01.class);
private String HOST = "localhost";
private int PORT = 3015;
private Socket socket;
public EchoClient01() throws IOException {
socket = new Socket(HOST, PORT);
}
public void talk() throws IOException {
try {
// 获得服务端响应信息的输入流
InputStream socketIn = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(
socketIn));
// 给服务端发送信息的输出流
OutputStream socketOut = socket.getOutputStream();
PrintWriter pw = new PrintWriter(socketOut, true);
BufferedReader localReader = new BufferedReader(
new InputStreamReader(System.in));
String msg = null;
while ((msg = localReader.readLine()) != null) {
pw.println(msg);
logger.info(br.readLine());
if (msg.equals("bye"))
break;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String args[]) throws IOException {
new EchoClient01().talk();
}
}
先启动服务端，再启动客户端，输入，客户端输出如下：
aaa
2016-02-18 23:30:46,203 INFO EchoClient01 - response info:Thu Feb 18 23:30:46 CST 2016
bbb
2016-02-18 23:30:47,689 INFO EchoClient01 - response info:Thu Feb 18 23:30:47 CST 2016
ccc
2016-02-18 23:30:48,783 INFO EchoClient01 - response info:Thu Feb 18 23:30:48 CST 2016
bye
2016-02-18 23:30:50,361 INFO EchoClient01 - response info:Thu Feb 18 23:30:50 CST 2016
"bijian" Sid: S-1-5-21-3389202862-2257394754-1792823341-1001
服务端输出如下：
2016-02-18 23:30:33,401 INFO EchoServer01 - 服务端启动... 端口号：3015
2016-02-18 23:30:39,045 INFO EchoServer01 - 一个新的连接到达，地址为：/127.0.0.1:52081
2016-02-18 23:30:46,188 INFO EchoServer01 - 服务端接受到的信息为：aaa
2016-02-18 23:30:47,689 INFO EchoServer01 - 服务端接受到的信息为：bbb
2016-02-18 23:30:48,783 INFO EchoServer01 - 服务端接受到的信息为：ccc
2016-02-18 23:30:50,345 INFO EchoServer01 - 服务端接受到的信息为：bye
2016-02-18 23:30:50,361 INFO EchoServer01 - 客户端请求断开
测试吧无疑是通过的，但是有两个问题出现了：
a. 当前服务端一下只能处理一个请求；我靠，这还是服务器吗？做web开发的人肯定有这样的想法。
b. 服务端的请求队列最多只有是5个，也就是一下能连6个请求（1个处理，5个等待），第7个请求到达后会被拒绝。
注意看，第7个客户端请求是无法成功的，异常信息如下：
Exception in thread "main" java.net.ConnectException: Connection refused: connect
at java.net.DualStackPlainSocketImpl.connect0(Native Method)
at java.net.DualStackPlainSocketImpl.socketConnect(DualStackPlainSocketImpl.java:79)
at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:350)
at java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:206)
at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:188)
at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:172)
at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:392)
at java.net.Socket.connect(Socket.java:589)
at java.net.Socket.connect(Socket.java:538)
at java.net.Socket.<init>(Socket.java:434)
at java.net.Socket.<init>(Socket.java:211)
at com.bijian.study.mina.client.EchoClient01.<init>(EchoClient01.java:27)
at com.bijian.study.mina.client.EchoClient01.main(EchoClient01.java:60)
"bijian" Sid: S-1-5-21-3389202862-2257394754-1792823341-1001
异常提示也很明确：拒绝连接！因为我们在服务端建立时做了请求队列最大长度的限制。
public EchoServer01() throws IOException {
// 请求队列最大长度为5
serverSocket = new ServerSocket(PORT,5);
logger.info("服务端启动... 端口号：" + PORT);
}
c.服务端容易阻塞；最显著的阻塞是IO操作，比如客户端与服务端建立连接后，向服务端发送一条消息，客户端因为人为操作很久没有输入结束；此时其他的连接只好等待在队列中。
这样的服务端我们称之为传统阻塞服务端，大凡Socket的入门示例都是这样的；但是，在实际的生产应用环境中用的非常少（注意：并不是不用哦，在特殊的环境是还是可以使用的，比如手机终端，你接听电话肯定只能一下接受一个请求，其他如短信接收，是要排队等待的）。
2.多线程阻塞服务器
在实际的应用开发中，我们更多采用的是多线程阻塞服务器，即每一个客户端请求到达，就建立一个线程单独的处理它与服务端的通信，如下图所示：
好处就是可以并发处理每一个到达的请求！服务端代码如下：
package com.bijian.study.mina.server;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import org.apache.log4j.Logger;
import com.bijian.study.mina.handler.Server02Handler;
/*
* 为每个客户端分配一个线程
* 服务器的主线程负责接收客户的连接
* 每次接收到一个客户连接，就会创建一个工作线程，由它负责与客户的通信
*/
public class EchoServer02 {
private Logger logger = Logger.getLogger(EchoServer02.class);
private int PORT = 3015;
private ServerSocket serverSocket;
public EchoServer02() throws IOException {
serverSocket = new ServerSocket(PORT);
logger.info("服务器端启动.... 端口号：" + PORT);
}
public void service() {
while (true) {
Socket socket = null;
try {
socket = serverSocket.accept(); // 请求到达
Thread workThread = new Thread(new Server02Handler(socket)); // 创建线程
workThread.start(); // 启动线程
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String args[]) throws IOException {
new EchoServer02().service();
}
}
很明显，每到达一个请求，就交给一个线程单独的处理；处理方法如下：
package com.bijian.study.mina.handler;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Date;
import org.apache.log4j.Logger;
public class Server02Handler implements Runnable {
private Logger logger = Logger.getLogger(Server02Handler.class);
private Socket socket;
public Server02Handler(Socket socket) {
this.socket = socket;
}
public void run() {
try {
logger.info("一个新的请求达到并创建 " + socket.getInetAddress() + ":"
+ socket.getPort());
InputStream socketIn = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(
socketIn));
OutputStream socketOut = socket.getOutputStream();
PrintWriter pw = new PrintWriter(socketOut, true);
String msg = null;
while ((msg = br.readLine()) != null) {
logger.info("服务端受到的信息为：" + msg);
pw.println(new Date()); // 给客户端响应日期字符串
if (msg.equals("bye"))
break;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (socket != null)
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
启动服务端，使用EchoClient01客户端测试成功！
虽然它没有了传统阻塞服务端的单处理弊端，但是却有一个致命的危险存在：大量请求到达时，不断的创建线程，很容易耗尽系统资源造成服务器崩溃；而且每个线程的创建与销毁都很浪费资源。
解决的办法就是使用线程池！（是不是很熟悉？我们经常接触的数据库连接池就是这样实现的。）
服务端代码如下：
package com.bijian.study.mina.server;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import org.apache.log4j.Logger;
import com.bijian.study.mina.handler.Server02Handler;
import com.bijian.study.mina.pool.ThreadPool;
/*
* 自定义线程池
* 多线程处理客户端请求
*/
public class EchoServer03 {
private Logger logger = Logger.getLogger(EchoServer03.class);
private int PORT = 3015;
private ServerSocket serverSocket;
private ThreadPool threadPool; // 线程池
private final int POOL_SIZE = 4; // 单个CPU时线程池中的工作线程个数
public EchoServer03() throws IOException {
serverSocket = new ServerSocket(PORT);
// 创建线程池
// Runtime的availableProcessors()方法返回当前系统的CPU格式
// 系统的CPU越多，线程池中工作线程的数目也越多
threadPool = new ThreadPool(Runtime.getRuntime().availableProcessors()
* POOL_SIZE);
logger.info("服务端启动.... 端口号：" + PORT);
}
public void service() {
while (true) {
Socket socket = null;
try {
socket = serverSocket.accept();
// 把与客户通信的任务交给线程池
threadPool.execute(new Server02Handler(socket));
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String args[]) throws IOException {
new EchoServer03().service();
}
}
服务端没有什么可解释的地方，关键是线程池的实现代码：
package com.bijian.study.mina.pool;
import java.util.LinkedList;
import org.apache.log4j.Logger;
/*
* 自定义线程池
*/
public class ThreadPool extends ThreadGroup {
private Logger logger = Logger.getLogger(ThreadPool.class);
private boolean isClosed = false; // 线程池是否关闭
// 将任务放在LinkedList中，LinkedList不支持同步，
// 所以在添加任务和获取任务的方法声明中必须使用synchronized关键字
private LinkedList<Runnable> workQueue;// 表示工作队列
private static int threadPoolID; // 表示线程池ID
private int threadID; // 表示工作线程ID
// 构建一个线程组
public ThreadPool(int poolSize) { // poolSize是指线程池中工作线程的数目
super("ThreadPool-" + (threadPoolID++)); // 线程组名
setDaemon(true);
workQueue = new LinkedList<Runnable>();// 创建工作队列
for (int i = 0; i < poolSize; i++)
new WorkThread().start(); // 创建并启动工作线程（如果工作队列为空，则所有工作线程处于阻塞状态）
}
// 向工作队列中添加一个任务，由工作线程去执行该任务
public synchronized void execute(Runnable task) {
if (isClosed) { // 线程池关闭则抛出IllegalStateException异常
throw new IllegalStateException();
}
if (task != null) {
workQueue.add(task);
notify(); // 唤醒正在getTask()方法中等待任务的工作线程
}
}
// 从工作队列中取出一个任务 ----工作线程会调用此方法
protected synchronized Runnable getTask() throws InterruptedException {
while (workQueue.size() == 0) {
if (isClosed)
return null;
wait(); // 如果工作队列没有任务，就等待任务
}
return workQueue.removeFirst();
}
// 关闭线程池
public synchronized void close() {
if (!isClosed) {
isClosed = true;
workQueue.clear(); // 清空工作队列
interrupt();// 中断所有工作线程，该方法继承自ThreadGroup类
}
}
// 等待工作线程把所有任务执行完
public void join() {
synchronized (this) {
isClosed = true;
notifyAll(); // 唤醒还在getTask()方法中等待任务的工作线程
}
// activeCount()方法是ThreadGroup类的，获得线程组中当前所有活着的工作线程数目
Thread[] threads = new Thread[activeCount()];
// enumerate方法继承自ThreadGroup类，获得线程组中当前所有活着的工作线程
int count = enumerate(threads);
for (int i = 0; i < count; i++) {// 等待所有工作线程运行结束
try {
threads[i].join(); // 等待工作线程运行结束
} catch (InterruptedException ex) {
logger.error("工作线程出错...", ex);
}
}
}
// 内部类，工作线程
private class WorkThread extends Thread {
public WorkThread() {
// 加入当前的ThreadPool线程组中
// Thread(ThreadGroup group, String name)
super(ThreadPool.this, "WorkThread-" + (threadID++));
}
public void run() {
// isInterrupted()方法继承自ThreadGroup类，判断线程是否中断
while (!isInterrupted()) {
Runnable task = null;
try {
task = getTask(); // 得到任务
} catch (InterruptedException ex) {
logger.error("获得任务异常...", ex);
}
// 如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程
if (task == null)
return;
try {
// 运行任务，捕获异常
task.run(); // 直接调用task的run方法
} catch (Throwable t) {
logger.error("任务执行异常...", t);
}
}// #while end
}// #run end
}// # WorkThread class end
}
启动服务端，使用EchoClient01客户端测试成功！
很多的服务端程序的实现思想就是基于该理念！
3.使用JDK自带线程池的阻塞服务器
上面那个多线程阻塞服务器使用的是自定义的线程池，但是它的代码可能不是很健壮，在更多的实际开发应用中，我们都是使用JDK自带的线程池的。java.util.concurrent包提供了现成的线程池的实现。
a.Executor接口表示线程池，它的execute(Runnable task)方法用来执行Runnable类型的任务。Executor的子接口
b.ExecutorService中声明了管理线程池的一些方法，比如用于关闭线程池的shutdown()方法等。
c.Executors类中包含一些静态方法，它们负责生成各种类型的线程池ExecutorService实例。
我们现在使用它来实现一个多线程阻塞服务器，服务端代码如下：
package com.bijian.study.mina.server;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.apache.log4j.Logger;
import com.bijian.study.mina.handler.Server02Handler;
/*
* 使用JDK自带的线程池ExecutorService
* 多线程处理客户端请求
*/
public class EchoServer04 {
private Logger logger = Logger.getLogger(EchoServer04.class);
private int PORT = 3015;
private ServerSocket serverSocket;
private ExecutorService executorService; // 线程池
private final int POOL_SIZE = 4; // 单个CPU时线程池中的工作线程个数
public EchoServer04() throws IOException {
serverSocket = new ServerSocket(PORT);
// 创建线程池
// Runtime的availableProcessors()方法返回当前系统的CPU格式
// 系统的CPU越多，线程池中工作线程的数目也越多
executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
.availableProcessors()
* POOL_SIZE);
logger.info("服务端启动.... 端口号：" + PORT);
}
public void service() {
while (true) {
Socket socket = null;
try {
socket = serverSocket.accept();
executorService.execute(new Server02Handler(socket));
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String args[]) throws IOException {
new EchoServer04().service();
}
}
怎么样，代码很简单吧！启动服务端，使用EchoClient01.java客户端测试成功！
使用线程池时需要遵循以下原则：
（1）如果任务A在执行过程中需要同步等待任务B的执行结果，那么任务A不适合加入到线程池的工作队列中。
（2）如果执行某个任务时可能会阻塞，并且是长时间的阻塞，则应该设定超时时间，避免工作线程永久的阻塞下去而导致线程泄漏。
（3）根据任务的特点，对任务进行分类，然后把不同类型的任务分别加入到不同线程池的工作队列中，这样可以根据任务的特点，分别调整每个线程池。
（4）调整线程池的大小。线程池的最佳大小主要取决于系统的可用CPU的数目以及工作队列中任务的特点。
（5）避免任务过载。
现在基本上可以解决并发处理客户端的问题啦。但是它依然存在不足：
（1）并发量激增的情况下，一台服务器很难应付海量的多并发；这就需要提高服务器并发处理能力和服务器个数；常见的解决方案是集群。
（2）服务器的好坏有两个取决因素：一个是并发能力，一个是响应速度；在并发能力有保障的情况下，每个工作线程，大部分的处理时间都浪费在IO操作上，因为CPU的处理能力比IO快太多，而IO却存在太多的局限因素，造成线程阻塞在IO操作上，大大降低了响应速度；而且会造成资源的浪费，就好比两个同学，一个负责烧水，一个负责挑水，烧水的人一直守在炉子前等待水开，一个却一直挑水；虽然烧水的人可以腾出时间帮助挑水的人，但是他却不能这样做，因为他固定的只能负责一个任务。
对于高并发，我们很有必要提高IO的操作效率，同时也应该改善我们处理每个任务的原则，提高CPU的利用率；Java NIO就是解决方案。
学习资料：http://wenku.baidu.com/link?url=VyKQnsn4b0BDJ8cQlLUu9cvpGz-Iou_499U4lJE9I0s5nPPY5kF5BDd8qo1yRMOiqsM8wxDPEL_S0koiFp8v5y36G9OGJydC2C12juo0bTW
- 大小: 20.2 KB
- 大小: 19.1 KB
- 大小: 31.3 KB
- 大小: 12.8 KB
- 大小: 31.4 KB
分享到：
相关推荐
《Mina解析（二）——深入理解Apache Mina框架》 Apache Mina是一个高度可扩展的网络通信框架，常用于构建高性能、高并发的服务端应用，尤其在处理TCP/IP、UDP等协议时表现出色。本篇文章将深入探讨Mina的核心概念...
### Mina 2.0快速入门与源码解析 #### Mina 2.0 快速入门 Mina 2.0 是一个基于Java NIO技术的高效、可伸缩的网络通信框架，广泛应用于服务器端开发。Mina 2.0 的设计目标是为开发者提供一个易于使用的API，使得...
SpringBoot整合Mina是一个常见的Java开发任务，它涉及到SpringBoot框架与Apache Mina网络通信库的集成。Mina是一个轻量级、高性能的网络应用框架，主要用于构建服务器端的网络应用，如TCP/IP和UDP协议的服务。而...
Apache Mina是一个开源的网络通信框架，主要用于构建高性能、高可用性的网络应用程序。它提供了高度模块化的设计，允许开发者以简单的方式处理各种网络协议，如TCP/IP、UDP/IP以及SSL/TLS等。在深入解析Mina源码的...
Apache Mina是一个开源的网络通信应用框架，主要应用于Java平台，它为高性能、高可用性的网络应用程序提供了基础架构。在本文中，我们将深入探讨Mina的高级使用，特别是在文件图片传送、文件发送、XML和JSON报文处理...
本篇文章将深入解析Mina框架的源码，通过构建一个简单的心跳通信程序，来理解其核心机制。 首先，我们来看一下心跳通信的基本概念。在分布式系统中，心跳机制是保持连接状态和检测网络故障的重要手段。心跳包是周期...
Apache Mina是一个强大的网络通信框架，专为基于TCP/IP和UDP/IP协议栈的应用设计。它提供了JAVA对象的序列化和虚拟机内部通信的功能，使得开发者能够迅速构建高性能、高可扩展性的网络应用。Mina的核心特性是其事件...
Apache Mina是一个用Java编写的网络通信框架，它简化了创建高性能、高可用性的网络服务的过程。Mina的核心思想是提供一个与传输层协议无关的API，使得开发者可以专注于业务逻辑，而不需要关心底层的网络通信细节。在...
MINA (Java IO Network Application Framework) 是一个由Apache软件基金会开发的开源网络通信框架，主要应用于构建高性能、高可用性的网络服务器。这个压缩包包含了MINA API文档、自学手册以及开发指南，对于学习和...
在Android平台上，MINA（Java Miniature Network Application Framework）是一个高度可扩展的网络应用程序框架，主要用作构建高性能、高效率的服务端和客户端应用程序。它提供了丰富的网络通信API，支持TCP/IP和UDP/...
Apache Mina是一个开源项目，它提供了一个高度可扩展的网络通信框架，用于简化开发高性能、高可用性的网络服务器和客户端应用程序。"Mina demo mina jar包"指的是使用Apache Mina框架创建的一个演示示例，这个示例...
本文将深入探讨mina编解码器的工作原理，提供一个典型编解码器的示例，并解析其代码。 1. **mina框架基础** - Mina提供了一个高效的、事件驱动的网络应用程序框架，简化了网络编程，尤其是TCP和UDP通信。 - 它...
Apache Mina是一个高度可扩展的Java网络通信框架，它提供了简单而强大的开发接口，用于创建高性能、高效率的网络应用程序。Mina的核心理念是将网络协议处理与业务逻辑分离，使得开发者可以专注于实现应用程序的业务...
标题中的“给予mina协议进行大数据传输”指的是一种基于Java的网络通信框架——Apache MINA（Model-View-Controller for Network Applications）。MINA是Apache软件基金会的一个项目，它提供了一个高度可扩展和高...
Mina框架解析** Mina（Minimal Asynchronous Network Library）是Apache软件基金会的一个开源项目，它提供了一个简单、高性能的API来处理网络通信。Mina支持多种协议，如TCP、UDP、HTTP、FTP等，可以用于构建服务器...
**Mina客户端服务器Demo**是基于Apache Mina框架的一个示例项目，主要展示了如何使用Mina进行网络通信的开发。Apache Mina是一个高度可扩展且轻量级的Java框架，主要用于构建高性能、高效率的网络应用程序，如TCP/IP...
此外，Mina支持多种编码和解码器，如LineDelimiterFilter（按行分割数据）、ProtobufDecoder（解析Google Protobuf格式数据）等。在实际应用中，根据数据格式选择合适的过滤器，可以有效地处理网络传输中的数据。 ...
#### 三、Mina解析 ##### 3.1 NIO分析 - 分析了从传统的阻塞式服务器到多线程阻塞服务器，再到基于NIO的非阻塞服务器的演变过程，以及多线程的NIO服务器的实现方式。 - 强调了NIO相对于传统IO的优势，如更高的并发...
Apache MINA（Multipurpose Infrastructure for Network Applications）是一个Java框架，它提供了高度可扩展的、高性能的网络应用程序开发工具。本文将深入探讨如何使用MINA实现HTTP协议，以及相关的源码分析和实用...
在Java开发领域，MINA（Multi-purpose Infrastructure for Network Applications）是一个功能强大的网络应用框架，而Protocol Buffers是Google推出的一种高效的数据序列化协议。这两者的整合可以为开发者提供高性能...