`
Donald_Draper
  • 浏览: 996664 次
社区版块
存档分类
最新评论

MINA 多路分离解码器实例

    博客分类：
  • Mina
mina 
阅读更多
MINA TCP简单通信实例：http://donald-draper.iteye.com/blog/2375297
MINA 编解码器实例：http://donald-draper.iteye.com/blog/2375317

上面一篇文章中的解码器只能针对我们已经定义的固定协议格式解码，假设我们现在需要使用更具客户端发送过来的数据的某个条件确定来解码，该怎样做呢?我们通过一个实例来解决这个问题。
协议：
两个int 类型的数字，还有一个char 类型的符号。如果符号是+，使用1号解码器，
对两个数字相加。如果符号是-，使用2 号解码器，对两个数字相减。
计算协议实体： 
package mina.tcp.message;
/**
 * 计算协议
 * @author donald
 * 2017年5月20日
 * 下午11:48:08
 */
public class MathMessage {
	private int firstNum = 0;
	private int secondNum = 0;
	private char symbol = '+';
	public char getSymbol() {
		return symbol;
	}
	public void setSymbol(char symbol) {
		this.symbol = symbol;
	}
	public int getFirstNum() {
		return firstNum;
	}
	public void setFirstNum(int firstNum) {
		this.firstNum = firstNum;
	}
	public int getSecondNum() {
		return secondNum;
	}
	public void setSecondNum(int secondNum) {
		this.secondNum = secondNum;
	}
}

计算结果协议实体： 
package mina.tcp.message;
/**
 * 计算结果
 * @author donald
 * 2017年5月20日
 * 下午11:48:27
 */
public class AckMessage {
	private int result = 0;
	public int getResult() {
		return result;
	}
	public void setResult(int result) {
		this.result = result;
	}
}

计算协议编码： 

package mina.tcp.coder;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolEncoderOutput;
import org.apache.mina.filter.codec.demux.MessageEncoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import mina.tcp.message.MathMessage;

/**
 * 计算消息编码器
 * @author donald 
 * 2017年5月20日 
 * 下午11:49:42
 */
public class MathMessageEncoder implements MessageEncoder<MathMessage> {
	private final static Logger log = LoggerFactory.getLogger(MathMessageEncoder.class);
	@Override
	public void encode(IoSession session, MathMessage message, ProtocolEncoderOutput out) throws Exception {
		IoBuffer buffer = IoBuffer.allocate(10);
		buffer.putChar(message.getSymbol());
		buffer.putInt(message.getFirstNum());
		buffer.putInt(message.getSecondNum());
		buffer.flip();
		out.write(buffer);
	}
}

计算结果协议编码： 
package mina.tcp.coder;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolEncoderOutput;
import org.apache.mina.filter.codec.demux.MessageEncoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import mina.tcp.message.AckMessage;
/**
 * 计算结果编码器
 * @author donald
 * 2017年5月20日
 * 下午11:58:18
 */
public class AckMessageEncoder implements MessageEncoder<AckMessage> {
	private final static Logger log = LoggerFactory.getLogger(AckMessageEncoder.class);
	@Override
	public void encode(IoSession session, AckMessage message, ProtocolEncoderOutput out) throws Exception {
		IoBuffer buffer = IoBuffer.allocate(4);
		buffer.putInt(message.getResult());
		buffer.flip();
		out.write(buffer);
	}
}


计算协议解码器（加法解码器）： 
package mina.tcp.coder;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;
import org.apache.mina.filter.codec.demux.MessageDecoder;
import org.apache.mina.filter.codec.demux.MessageDecoderResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import mina.tcp.message.MathMessage;
/**
 * 加法解码器
 * @author donald
 * 2017年5月20日
 * 下午11:56:47
 */
public class MathMessageDecoderPositive implements MessageDecoder {
	private final static Logger log = LoggerFactory.getLogger(MathMessageDecoderPositive.class);
	@Override
	public MessageDecoderResult decodable(IoSession session, IoBuffer in) {
		if (in.remaining() < 2)
			return MessageDecoderResult.NEED_DATA;
		else {
			char symbol = in.getChar();
			if (symbol == '+') {
				return MessageDecoderResult.OK;
			} else {
				return MessageDecoderResult.NOT_OK;
			}
		}
	}

	@Override
	public MessageDecoderResult decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {
		MathMessage sm = new MathMessage();
		sm.setSymbol(in.getChar());
		sm.setFirstNum(in.getInt());
		sm.setSecondNum(in.getInt());
		out.write(sm);
		return MessageDecoderResult.OK;
	}

	@Override
	public void finishDecode(IoSession session, ProtocolDecoderOutput out) throws Exception {
		// undo
	}
}

计算协议解码器（减法解码器）： 
package mina.tcp.coder;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;
import org.apache.mina.filter.codec.demux.MessageDecoder;
import org.apache.mina.filter.codec.demux.MessageDecoderResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import mina.tcp.message.MathMessage;
/**
 * 减法解码器
 * @author donald
 * 2017年5月20日
 * 下午11:54:25
 */
public class MathMessageDecoderNegative implements MessageDecoder {
	private final static Logger log = LoggerFactory.getLogger(MathMessageDecoderNegative.class);
	@Override
	public MessageDecoderResult decodable(IoSession session, IoBuffer in) {
		if (in.remaining() < 2)
			return MessageDecoderResult.NEED_DATA;
		else {
			char symbol = in.getChar();
			if (symbol == '-') {
				return MessageDecoderResult.OK;
			} else {
				return MessageDecoderResult.NOT_OK;
			}
		}
	}

	@Override
	public MessageDecoderResult decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {
		MathMessage sm = new MathMessage();
		sm.setSymbol(in.getChar());
		sm.setFirstNum(in.getInt());
		sm.setSecondNum(in.getInt());
		out.write(sm);
		return MessageDecoderResult.OK;
	}

	@Override
	public void finishDecode(IoSession session, ProtocolDecoderOutput out) throws Exception {
		// undo
	}
}

计算协议结果解码器： 
package mina.tcp.coder;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;
import org.apache.mina.filter.codec.demux.MessageDecoder;
import org.apache.mina.filter.codec.demux.MessageDecoderResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import mina.tcp.message.AckMessage;
/**
 * 计算结果解码器
 * @author donald
 * 2017年5月21日
 * 上午12:01:04
 */
public class AckMessageDecoder implements MessageDecoder {
	private final static Logger log = LoggerFactory.getLogger(AckMessageDecoder.class);
	@Override
	public MessageDecoderResult decodable(IoSession session, IoBuffer in) {
		if (in.remaining() < 4)
			return MessageDecoderResult.NEED_DATA;
		else if (in.remaining() == 4)
			return MessageDecoderResult.OK;
		else
			return MessageDecoderResult.NOT_OK;
	}

	@Override
	public MessageDecoderResult decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {
		AckMessage rm = new AckMessage();
		rm.setResult(in.getInt());
		out.write(rm);
		return MessageDecoderResult.OK;
	}

	@Override
	public void finishDecode(IoSession session, ProtocolDecoderOutput out) throws Exception {
		// undo
	}
}

协议编码解码器工厂： 
package mina.tcp.coder;

import org.apache.mina.filter.codec.demux.DemuxingProtocolCodecFactory;

import mina.tcp.message.AckMessage;
import mina.tcp.message.MathMessage;
/**
 * 协议编码解码器工厂
 * @author donald
 * 2017年5月21日
 * 上午12:02:11
 */
public class MathProtocolCodecFactory extends DemuxingProtocolCodecFactory {
	public MathProtocolCodecFactory(boolean server) {
		if (server) {
			super.addMessageEncoder(AckMessage.class, AckMessageEncoder.class);
			super.addMessageDecoder(MathMessageDecoderPositive.class);
			super.addMessageDecoder(MathMessageDecoderNegative.class);
		} else {
			super.addMessageEncoder(MathMessage.class, MathMessageEncoder.class);
			super.addMessageDecoder(AckMessageDecoder.class);
		}
	}
}

我们在多路分离解码器中，通过一个boolean参数控制相应的编码解码器；
server： 
package mina.tcp.main;

import java.io.IOException;
import java.net.InetSocketAddress;

import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
import org.apache.mina.core.service.IoAcceptor;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.SocketSessionConfig;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import mina.tcp.coder.MathProtocolCodecFactory;
import mina.tcp.handler.MathServerHandler;
/**
 * MathServer
 * @author donald
 * 2017年5月19日
 * 下午10:16:29
 */
public class MathServer {
	private static final Logger log = LoggerFactory.getLogger(MathServer.class);
	private static final  String ip = "192.168.31.153";
	private static final  int port = 9122;
	private static final  int readBufferSize = 2048;
	private static final  int idleTime = 10;
	public static void main(String[] args) throws IOException {
		 IoAcceptor acceptor=new NioSocketAcceptor();
		//配置socket会话
		 SocketSessionConfig socketSessionConfig = (SocketSessionConfig) acceptor.getSessionConfig();
		 socketSessionConfig.setReadBufferSize(readBufferSize);
		 socketSessionConfig.setIdleTime(IdleStatus.BOTH_IDLE,idleTime);
		 //配置过滤器
		 DefaultIoFilterChainBuilder defaultIoFilterChainBuilder = acceptor.getFilterChain();
		 LoggingFilter loggingFilter = new LoggingFilter();
		 defaultIoFilterChainBuilder.addLast("loggingFilter", loggingFilter);
		 MathProtocolCodecFactory mathProtocolCodecFactory = new MathProtocolCodecFactory(true);
		 ProtocolCodecFilter protocolCodecFilter = new ProtocolCodecFilter(mathProtocolCodecFactory);
		 defaultIoFilterChainBuilder.addLast("protocolCodecFilter",protocolCodecFilter);
		 //配置NioSocketAcceptor处理器
		 MathServerHandler mathServerHandler = new MathServerHandler();
		 acceptor.setHandler(mathServerHandler);
		 InetSocketAddress inetSocketAddress = new InetSocketAddress(ip,port);
		 acceptor.bind(inetSocketAddress);
		 log.info("=========MathServer is start============");
	}
}

server handler： 
package mina.tcp.handler;

import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import mina.tcp.message.AckMessage;
import mina.tcp.message.MathMessage;
/**
 * MathServerHandler
 * @author donald
 * 2017年5月20日
 * 下午11:49:02
 */
public class MathServerHandler extends IoHandlerAdapter {
	private final static Logger log = LoggerFactory.getLogger(MathServerHandler.class);

	@Override
	public void messageReceived(IoSession session, Object message) throws Exception {
		MathMessage sm = (MathMessage) message;
		log.info("===recieve MathMessage:" + sm.getFirstNum() + " " + sm.getSymbol() + " " + sm.getSecondNum());
		AckMessage rm = new AckMessage();
		if (sm.getSymbol() == '+')
			rm.setResult(sm.getFirstNum() + sm.getSecondNum());
		if (sm.getSymbol() == '-')
			rm.setResult(sm.getFirstNum() - sm.getSecondNum());
		session.write(rm);
	}
	@Override
	public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
		log.error("===会话异常："+cause.getMessage());
		cause.printStackTrace();
		session.closeNow();
	}
}


client： 
package mina.tcp.main;

import java.net.InetSocketAddress;

import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
import org.apache.mina.core.service.IoConnector;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import mina.tcp.coder.MathProtocolCodecFactory;
import mina.tcp.handler.MathClientHandler;
/**
 * MathClient
 * @author donald
 * 2017年5月19日
 * 下午10:27:30
 */
public class MathClient {
	private static final Logger log = LoggerFactory.getLogger(MathClient.class);
	private static final  String ip = "192.168.31.153";
	private static final  int port = 9122;
	private static final  int connectTimeoutMillis = 30000;
	public static void main(String[] args) {
		IoConnector connector=new NioSocketConnector();
		 connector.setConnectTimeoutMillis(connectTimeoutMillis);
		//配置过滤器
		 DefaultIoFilterChainBuilder defaultIoFilterChainBuilder = connector.getFilterChain();
		 LoggingFilter loggingFilter = new LoggingFilter();
		 defaultIoFilterChainBuilder.addLast("loggingFilter", loggingFilter);
		 MathProtocolCodecFactory mathProtocolCodecFactory = new MathProtocolCodecFactory(false);
		 ProtocolCodecFilter protocolCodecFilter = new ProtocolCodecFilter(mathProtocolCodecFactory);
		 defaultIoFilterChainBuilder.addLast("protocolCodecFilter",protocolCodecFilter);
		//配置NioSocketConnector处理器
		 MathClientHandler mathClientHandler = new MathClientHandler();
		 connector.setHandler(mathClientHandler);
		 InetSocketAddress inetSocketAddress = new InetSocketAddress(ip,port);
		 connector.connect(inetSocketAddress);
		 log.info("=========MathClient is start============");
	}
}


client handler： 
package mina.tcp.handler;

import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import mina.tcp.message.AckMessage;
import mina.tcp.message.MathMessage;
/**
 * MathClientHandler
 * @author donald
 * 2017年5月20日
 * 下午11:48:48
 */
public class MathClientHandler extends IoHandlerAdapter {
	private final static Logger log = LoggerFactory.getLogger(MathClientHandler.class);
	@Override
	public void sessionOpened(IoSession session) throws Exception {
		MathMessage sm = new MathMessage();
		sm.setFirstNum(100);
		sm.setSecondNum(99);
		sm.setSymbol('-');
		session.write(sm);
		sm.setSymbol('+');
		session.write(sm);
		log.info("====计算消息已发送");
	}
	@Override
	public void messageReceived(IoSession session, Object message) {
		AckMessage rs = (AckMessage) message;
		log.info("====calculate result:"+rs.getResult());
	}
	@Override
	public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
		log.error("===会话异常："+cause.getMessage());
		cause.printStackTrace();
		session.closeNow();
	}
}

启动Server，Client，控制台输出：
Server：
[INFO ] 2017-05-21 12:58:26 mina.tcp.main.MathServer =========MathServer is start============
[INFO ] 2017-05-21 12:58:34 org.apache.mina.filter.logging.LoggingFilter CREATED
[INFO ] 2017-05-21 12:58:34 org.apache.mina.filter.logging.LoggingFilter OPENED
[INFO ] 2017-05-21 12:58:34 org.apache.mina.filter.logging.LoggingFilter RECEIVED: HeapBuffer[pos=0 lim=10 cap=2048: 00 2D 00 00 00 64 00 00 00 63]
[DEBUG] 2017-05-21 12:58:34 org.apache.mina.filter.codec.ProtocolCodecFilter Processing a MESSAGE_RECEIVED for session 1
[INFO ] 2017-05-21 12:58:34 mina.tcp.handler.MathServerHandler ===recieve MathMessage:100 - 99
[INFO ] 2017-05-21 12:58:34 org.apache.mina.filter.logging.LoggingFilter SENT: mina.tcp.message.AckMessage@ef8e761
[INFO ] 2017-05-21 12:58:34 org.apache.mina.filter.logging.LoggingFilter RECEIVED: HeapBuffer[pos=0 lim=10 cap=2048: 00 2B 00 00 00 64 00 00 00 63]
[DEBUG] 2017-05-21 12:58:34 org.apache.mina.filter.codec.ProtocolCodecFilter Processing a MESSAGE_RECEIVED for session 1
[INFO ] 2017-05-21 12:58:34 mina.tcp.handler.MathServerHandler ===recieve MathMessage:100 + 99
[INFO ] 2017-05-21 12:58:34 org.apache.mina.filter.logging.LoggingFilter SENT: mina.tcp.message.AckMessage@771e98f4

client：
[INFO ] 2017-05-21 12:58:34 mina.tcp.main.MathClient =========MathClient is start============
[INFO ] 2017-05-21 12:58:34 org.apache.mina.filter.logging.LoggingFilter CREATED
[INFO ] 2017-05-21 12:58:34 org.apache.mina.filter.logging.LoggingFilter OPENED
[INFO ] 2017-05-21 12:58:34 mina.tcp.handler.MathClientHandler ====计算消息已发送
[INFO ] 2017-05-21 12:58:34 org.apache.mina.filter.logging.LoggingFilter SENT: mina.tcp.message.MathMessage@684d0ca0
[INFO ] 2017-05-21 12:58:34 org.apache.mina.filter.logging.LoggingFilter SENT: mina.tcp.message.MathMessage@684d0ca0
[INFO ] 2017-05-21 12:58:34 org.apache.mina.filter.logging.LoggingFilter RECEIVED: HeapBuffer[pos=0 lim=4 cap=2048: 00 00 00 01]
[DEBUG] 2017-05-21 12:58:34 org.apache.mina.filter.codec.ProtocolCodecFilter Processing a MESSAGE_RECEIVED for session 1
[INFO ] 2017-05-21 12:58:34 mina.tcp.handler.MathClientHandler ====calculate result:1
[INFO ] 2017-05-21 12:58:34 org.apache.mina.filter.logging.LoggingFilter RECEIVED: HeapBuffer[pos=0 lim=4 cap=2048: 00 00 00 C7]
[DEBUG] 2017-05-21 12:58:34 org.apache.mina.filter.codec.ProtocolCodecFilter Processing a MESSAGE_RECEIVED for session 1
[INFO ] 2017-05-21 12:58:34 mina.tcp.handler.MathClientHandler ====calculate result:199

本文中主要设计的概念MessageEncoder，MessageDecoder，DemuxingProtocolCodecFactory，这个我们在以后再讲。
  • lib.rar (1022.7 KB)
  • 下载次数: 4
0
顶
1
踩
分享到：
| MINA 编解码器实例
评论
2 楼 Donald_Draper 2017-10-30  
ron.luo 写道
写的特别好，能分享下源码地址？

https://github.com/Donaldhan/Mina-Demo
这个代码写的比较早，没有用maven管理，你要自己添加jar引用
1 楼 ron.luo 2017-10-25  
写的特别好，能分享下源码地址？
发表评论

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

相关推荐

    mina 多路分离解码

    《mina多路分离解码详解》 mina框架是Apache软件基金会的一个开源项目，它为Java开发者提供了一套高效、功能丰富的网络通信库，主要用于构建高性能的网络应用服务器，如TCP和UDP服务。在mina框架中，“多路分离解码...

    mina自定义编解码器详解

    - 文件`example`可能包含了一个使用mina编写的服务器或客户端程序，其中包含了自定义编解码器的应用实例。 - `MinaCodec`可能是一个包含编码器和解码器的类，我们来详细分析其工作流程： - 在编码器中，通常有一...

    Mina断包，粘包处理（完整实例，有客户端，服务端）

    在Mina中，解决这个问题的关键在于定义正确的协议编码器和解码器。例如，你可以使用FixedLengthFrameDecoder或LineBasedFrameDecoder来确保每个接收到的数据块都能正确地组合成原始消息。 2. **粘包**： 相反，...

    mina自定义编码解码器

    本文将深入探讨如何在Mina中自定义编码解码器，这对于实现特定的网络通信协议至关重要。 首先，了解Mina的编码解码器架构是必要的。Mina使用了Chain of Responsibility设计模式，通过Filter链来处理进来的数据。...

    MINA 协议解码过滤器

    1. 非阻塞解码：由于MINA采用非阻塞I/O，解码器必须能够处理数据不完整的情况，即可能需要多次调用`decode()`方法才能完成一次完整的解码。 2. 解码状态管理：解码器需要维护自己的状态，以跟踪当前解码过程是否完成...

    mina编解码器Demo

    《mina编解码器Demo详解》 mina是一个高性能、异步事件驱动的网络通信框架，主要应用于Java平台，常用于构建TCP和UDP服务。在本文中，我们将深入探讨MINA框架中的编解码器（Codec）概念，并通过提供的`mina_server`...

    Mina开发实例(服务端、客户端）DEMO

    此外，Mina支持多种编码和解码器，如LineDelimiterFilter（按行分割数据）、ProtobufDecoder（解析Google Protobuf格式数据）等。在实际应用中，根据数据格式选择合适的过滤器，可以有效地处理网络传输中的数据。 ...

    apache mina 框架实例

    以下是对Mina框架实例、自定义协议包、编码器和解码器的详细解释： **Apache Mina框架实例：** Apache Mina框架的核心思想是基于事件驱动和非阻塞I/O，这使得它在处理大量并发连接时表现出色。在Mina中，开发者可以...

    springboot整合mina

    下面我们将详细讨论如何在SpringBoot项目中整合Mina，并自定义解码器。 首先，我们需要在SpringBoot项目中添加Mina的相关依赖。这通常通过在`pom.xml`或`build.gradle`文件中引入Mina的依赖项来完成。对于Maven用户...

    mina入门实例

    在这个实例中，`MyProtocolCodecFactory`是一个自定义的编码解码器，用于将业务数据转换为字节流，以便在网络上传输。你需要根据实际需求实现这个工厂类。 在完成上述代码后，运行服务器端，然后启动客户端，即可...

    mina编解码示例

    mina编解码示例是基于Apache Mina框架的一个实践项目，主要展示了如何在Mina中进行数据的编码和解码操作。Apache Mina是一个高度可扩展的网络通信框架，广泛应用于开发高性能、高并发的网络应用程序，如TCP/IP和UDP...

    apache mina实例免费下载

    过滤器链则提供了数据处理的模块化方式，每个过滤器可以执行特定的操作，如数据编码、解码、安全加密等。 在实际应用中，Apache MINA常用于构建服务器端应用，如聊天服务器、游戏服务器、文件传输服务等。通过MINA...

    Mina长连接短连接实例

    Mina提供了多种内置的编码器和解码器，可以根据实际需求选择或自定义。 3. **FilterChain**：这是一个处理链，允许我们插入自定义的过滤器来处理进/出站事件，实现业务逻辑或日志记录等功能。 4. **IoHandler**：...

    mina解码器

    在这个场景中，"mina解码器"是指使用MINA框架来实现自定义的编码和解码逻辑，以处理网络数据的收发。 解码器（Decoder）和编码器（Encoder）是MINA框架中用于处理数据传输的核心组件。它们分别负责将接收到的原始...

    minaDemo的实例

    总之，"MinaDemo"是一个展示如何使用Apache MINA框架构建网络应用的实例，涵盖了服务端和客户端的基本操作，以及数据编码解码和事件处理等核心功能。通过深入研究这个示例，开发者可以更好地理解和运用MINA框架，...

    mina2+spring结合实例

    - 配置Mina的过滤器链，实现数据的预处理和后处理。 - 在Spring配置文件中声明并配置Mina的启动和停止方法，以便在应用启动和关闭时自动调用。 2. 示例应用： - 假设我们创建一个简单的TCP服务，接收客户端发送...

    mina网络通信实例

    《MINA网络通信实例解析》 MINA（Multipurpose Infrastructure for Network Applications）是Apache软件基金会的一个开源项目，它提供了一个高度可扩展且跨平台的网络应用程序框架，主要用于简化开发高性能和高可用...

    mina学习基础-入门实例-传输定长报文(三)

    在"mina学习基础-入门实例-传输定长报文(三)"这个主题中，我们将深入探讨如何使用Mina实现定长报文的传输，并且利用Mina内置的SSL过滤器进行报文加密。 首先，让我们了解什么是定长报文。在通信协议中，定长报文是...

    一个应用mina的实例（源码）

    这个实例是基于Mina框架构建的一个应用程序，名为"BTUSimulator"，它可能是用来模拟某种网络通信或者服务的。让我们深入探讨一下Mina框架以及如何在实际项目中应用它。 **Apache Mina框架详解** Mina（Minimum ...

    mina HTTP协议实例

    4. **编码与解码**：MINA提供了ByteToMessageDecoder和MessageToByteEncoder接口，用于数据的解码和编码。在HTTP协议中，我们需要实现这两个接口来处理HTTP报文的二进制和文本转换。 5. **源码分析**：阅读MINA的...

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