tessl/maven-org-apache-mina--mina-core
Apache MINA Core is a network application framework for building high-performance, scalable network applications with event-driven, asynchronous I/O over various transports including TCP/IP and UDP/IP via Java NIO.
—
Pending
transport-layer.mddocs/
Transport Layer
MINA Core provides multiple transport implementations through a unified API. The transport layer abstracts away the underlying network protocols while providing transport-specific configuration and optimization options.
Transport Types
NIO Socket Transport (TCP/IP)
The primary transport for TCP-based network applications using Java NIO.
NioSocketAcceptor
TCP server implementation:
// Basic TCP server
NioSocketAcceptor acceptor = new NioSocketAcceptor();
// Multi-threaded configuration
NioSocketAcceptor multiThreaded = new NioSocketAcceptor(4); // 4 I/O processors
// Custom processor configuration
IoProcessor<NioSession> processor = new SimpleIoProcessorPool<>(NioProcessor.class, 8);
NioSocketAcceptor customProcessors = new NioSocketAcceptor(processor);
// Custom executor and processor
Executor executor = Executors.newCachedThreadPool();
NioSocketAcceptor fullCustom = new NioSocketAcceptor(executor, processor);
// Custom SelectorProvider (advanced)
SelectorProvider provider = SelectorProvider.provider();
NioSocketAcceptor customSelector = new NioSocketAcceptor(4, provider);NioSocketConnector
TCP client implementation:
// Basic TCP client
NioSocketConnector connector = new NioSocketConnector();
// Multi-threaded client
NioSocketConnector multiThreaded = new NioSocketConnector(2); // 2 I/O processors
// Custom configuration
NioSocketConnector customConnector = new NioSocketConnector(executor, processor);Socket Configuration
// Configure socket-specific settings
public void configureTcpSocket(IoService service) {
SocketSessionConfig config = (SocketSessionConfig) service.getSessionConfig();
// Buffer sizes
config.setSendBufferSize(64 * 1024); // 64KB send buffer
config.setReceiveBufferSize(64 * 1024); // 64KB receive buffer
// Socket options
config.setTcpNoDelay(true); // Disable Nagle algorithm
config.setKeepAlive(true); // Enable TCP keep-alive
config.setSoLinger(0); // Immediate close (no lingering)
config.setReuseAddress(true); // Allow address reuse
// Traffic class (QoS)
config.setTrafficClass(IPTOS_LOWDELAY); // Optimize for low delay
// Connection timeout (for connectors)
if (service instanceof IoConnector) {
IoConnector connector = (IoConnector) service;
connector.setConnectTimeoutMillis(30000); // 30 second timeout
}
// Acceptor-specific configuration
if (service instanceof NioSocketAcceptor) {
NioSocketAcceptor acceptor = (NioSocketAcceptor) service;
acceptor.setReuseAddress(true);
acceptor.setBacklog(100); // Accept queue size
}
}NIO Datagram Transport (UDP)
UDP transport for connectionless communication.
NioDatagramAcceptor
UDP server implementation:
// Basic UDP server
NioDatagramAcceptor acceptor = new NioDatagramAcceptor();
// Configure UDP-specific settings
DatagramSessionConfig config = acceptor.getSessionConfig();
config.setReceiveBufferSize(1024 * 64); // 64KB receive buffer
config.setSendBufferSize(1024 * 64); // 64KB send buffer
config.setReuseAddress(true);
config.setBroadcast(true); // Allow broadcast packets
// Set up UDP message handler
acceptor.setHandler(new UdpServerHandler());
// Bind to UDP port
acceptor.bind(new InetSocketAddress(5000));
// UDP server handler
public class UdpServerHandler extends IoHandlerAdapter {
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
IoBuffer buffer = (IoBuffer) message;
// Get client address from session
SocketAddress clientAddress = session.getRemoteAddress();
String data = buffer.getString(Charset.forName("UTF-8").newDecoder());
System.out.println("Received from " + clientAddress + ": " + data);
// Echo back to client
IoBuffer response = IoBuffer.wrap(("Echo: " + data).getBytes("UTF-8"));
session.write(response);
}
}NioDatagramConnector
UDP client implementation:
// Basic UDP client
NioDatagramConnector connector = new NioDatagramConnector();
// Configure client settings
DatagramSessionConfig config = connector.getSessionConfig();
config.setSendBufferSize(1024 * 32); // 32KB send buffer
config.setReceiveBufferSize(1024 * 32); // 32KB receive buffer
config.setBroadcast(true); // Allow broadcast
// Set handler
connector.setHandler(new UdpClientHandler());
// Connect to UDP server
ConnectFuture future = connector.connect(new InetSocketAddress("localhost", 5000));
IoSession session = future.awaitUninterruptibly().getSession();
// Send UDP message
IoBuffer message = IoBuffer.wrap("Hello UDP Server!".getBytes("UTF-8"));
session.write(message);
// UDP client handler
public class UdpClientHandler extends IoHandlerAdapter {
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
IoBuffer buffer = (IoBuffer) message;
String response = buffer.getString(Charset.forName("UTF-8").newDecoder());
System.out.println("Server response: " + response);
session.closeNow();
}
}UDP Broadcasting
public class UdpBroadcaster {
public void sendBroadcast() throws Exception {
NioDatagramConnector connector = new NioDatagramConnector();
// Enable broadcast
DatagramSessionConfig config = connector.getSessionConfig();
config.setBroadcast(true);
connector.setHandler(new IoHandlerAdapter());
// Connect to broadcast address
InetSocketAddress broadcastAddress =
new InetSocketAddress("255.255.255.255", 12345);
ConnectFuture future = connector.connect(broadcastAddress);
IoSession session = future.awaitUninterruptibly().getSession();
// Send broadcast message
IoBuffer message = IoBuffer.wrap("Broadcast message".getBytes("UTF-8"));
session.write(message);
session.closeNow();
connector.dispose();
}
public void receiveMulticast() throws Exception {
NioDatagramAcceptor acceptor = new NioDatagramAcceptor();
acceptor.setHandler(new IoHandlerAdapter() {
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
IoBuffer buffer = (IoBuffer) message;
String data = buffer.getString(Charset.forName("UTF-8").newDecoder());
System.out.println("Multicast message: " + data);
}
});
// Bind to multicast group
InetSocketAddress multicastAddress =
new InetSocketAddress("224.0.0.1", 12345);
acceptor.bind(multicastAddress);
// Join multicast group (transport-specific code)
// This would require additional configuration at the socket level
}
}APR Socket Transport (High-Performance TCP/IP)
Apache Portable Runtime (APR) based transport for maximum performance on Linux/Unix systems.
APR Requirements
// Maven dependency for APR transport
<dependency>
<groupId>org.apache.mina</groupId>
<artifactId>mina-transport-apr</artifactId>
<version>2.2.4</version>
</dependency>
// System requirements:
// - Apache Portable Runtime library (libapr)
// - Native APR connector library
// - Unix/Linux environment (Windows support limited)AprSocketAcceptor
High-performance TCP server using APR:
// Basic APR server (requires APR library installed)
AprSocketAcceptor acceptor = new AprSocketAcceptor();
// Multi-threaded APR server
AprSocketAcceptor multiThreaded = new AprSocketAcceptor(4); // 4 I/O processors
// Custom processor configuration
IoProcessor<AprSession> processor = new AprIoProcessor(Executors.newCachedThreadPool());
AprSocketAcceptor customProcessor = new AprSocketAcceptor(processor);
// Configure APR-specific settings
SocketSessionConfig config = acceptor.getSessionConfig();
config.setSendBufferSize(256 * 1024); // 256KB send buffer
config.setReceiveBufferSize(256 * 1024); // 256KB receive buffer
config.setTcpNoDelay(true); // Disable Nagle algorithm
config.setKeepAlive(true); // Enable keep-alive
// Set handler and bind
acceptor.setHandler(new AprServerHandler());
acceptor.bind(new InetSocketAddress(8080));
public class AprServerHandler extends IoHandlerAdapter {
@Override
public void sessionOpened(IoSession session) throws Exception {
System.out.println("APR session opened: " + session.getRemoteAddress());
}
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
// High-performance message processing
IoBuffer buffer = (IoBuffer) message;
session.write(buffer); // Echo back
}
}AprSocketConnector
High-performance TCP client using APR:
// Basic APR client
AprSocketConnector connector = new AprSocketConnector();
// Configure APR client
SocketSessionConfig config = connector.getSessionConfig();
config.setConnectTimeoutMillis(10000); // 10 second timeout
config.setSendBufferSize(128 * 1024); // 128KB send buffer
config.setReceiveBufferSize(128 * 1024); // 128KB receive buffer
config.setTcpNoDelay(true); // Low latency
// Set handler and connect
connector.setHandler(new AprClientHandler());
ConnectFuture future = connector.connect(new InetSocketAddress("localhost", 8080));
IoSession session = future.awaitUninterruptibly().getSession();
// Send high-performance data
IoBuffer message = IoBuffer.allocate(1024);
message.putString("APR High Performance Message", Charset.forName("UTF-8"));
message.flip();
session.write(message);
public class AprClientHandler extends IoHandlerAdapter {
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
IoBuffer buffer = (IoBuffer) message;
System.out.println("APR response: " + buffer.getString(Charset.forName("UTF-8").newDecoder()));
}
}APR Library Configuration
// Check APR library availability
public class AprLibraryChecker {
public static boolean isAprAvailable() {
try {
// This will throw exception if APR is not available
new AprSocketAcceptor();
return true;
} catch (Exception e) {
System.err.println("APR not available: " + e.getMessage());
return false;
}
}
public static void printAprInfo() {
if (isAprAvailable()) {
System.out.println("APR Library: Available");
System.out.println("APR provides significantly better performance on Unix/Linux systems");
System.out.println("Recommended for high-throughput server applications");
} else {
System.out.println("APR Library: Not available");
System.out.println("Install libapr and native connectors for APR support");
System.out.println("Falling back to NIO transport");
}
}
}Serial Communication Transport
RS232/COM port communication transport for embedded and hardware interfacing applications.
Serial Transport Requirements
// Maven dependency for Serial transport
<dependency>
<groupId>org.apache.mina</groupId>
<artifactId>mina-transport-serial</artifactId>
<version>2.2.4</version>
</dependency>
// Additional requirement: GNU RXTX library
<dependency>
<groupId>org.rxtx</groupId>
<artifactId>rxtx</artifactId>
<version>2.1.7</version>
</dependency>
// System requirements:
// - GNU RXTX native library
// - Serial port hardware (RS232, USB-to-Serial, etc.)
// - Proper permissions for serial port accessSerialConnector
Serial port communication (no acceptor - serial ports are point-to-point):
// Serial port connector
SerialConnector connector = new SerialConnector();
// Configure serial communication parameters
SerialSessionConfig config = connector.getSessionConfig();
config.setBaudRate(9600); // Common baud rates: 9600, 19200, 38400, 115200
config.setDataBits(SerialSessionConfig.DATABITS_8); // 8 data bits
config.setStopBits(SerialSessionConfig.STOPBITS_1); // 1 stop bit
config.setParity(SerialSessionConfig.PARITY_NONE); // No parity
config.setFlowControl(SerialSessionConfig.FLOWCONTROL_NONE); // No flow control
// Platform-specific port addressing
SerialAddress portAddress;
if (System.getProperty("os.name").toLowerCase().contains("windows")) {
portAddress = new SerialAddress("COM1"); // Windows: COM1, COM2, etc.
} else {
portAddress = new SerialAddress("/dev/ttyS0"); // Linux: /dev/ttyS0, /dev/ttyUSB0, etc.
}
// Set handler for serial communication
connector.setHandler(new SerialHandler());
// Connect to serial port
ConnectFuture future = connector.connect(portAddress);
IoSession session = future.awaitUninterruptibly().getSession();
if (future.isConnected()) {
System.out.println("Connected to serial port: " + portAddress);
// Send command to serial device
String command = "AT\r\n"; // Example AT command for modem
IoBuffer buffer = IoBuffer.wrap(command.getBytes());
session.write(buffer);
} else {
System.err.println("Failed to connect to serial port: " + future.getException());
}
public class SerialHandler extends IoHandlerAdapter {
@Override
public void sessionOpened(IoSession session) throws Exception {
System.out.println("Serial port opened: " + session.getLocalAddress());
// Configure session for serial communication
session.getConfig().setReadBufferSize(1024); // Small buffer for serial
session.getConfig().setIdleTime(IdleStatus.READER_IDLE, 30); // 30 second timeout
}
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
IoBuffer buffer = (IoBuffer) message;
// Process serial data (often line-based)
byte[] data = new byte[buffer.remaining()];
buffer.get(data);
String response = new String(data).trim();
System.out.println("Serial response: " + response);
// Handle specific serial protocol responses
if (response.equals("OK")) {
System.out.println("Command acknowledged");
} else if (response.startsWith("ERROR")) {
System.err.println("Device error: " + response);
}
}
@Override
public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
if (cause instanceof SerialPortUnavailableException) {
System.err.println("Serial port unavailable: " + cause.getMessage());
} else {
System.err.println("Serial communication error: " + cause.getMessage());
}
session.closeNow();
}
}Serial Configuration Options
public class SerialConfiguration {
public void configureHighSpeedSerial(SerialConnector connector) {
SerialSessionConfig config = connector.getSessionConfig();
// High-speed configuration
config.setBaudRate(115200); // High baud rate
config.setDataBits(SerialSessionConfig.DATABITS_8); // 8 data bits
config.setStopBits(SerialSessionConfig.STOPBITS_1); // 1 stop bit
config.setParity(SerialSessionConfig.PARITY_NONE); // No parity
config.setFlowControl(SerialSessionConfig.FLOWCONTROL_RTSCTS); // Hardware flow control
// Buffer settings for high-speed data
config.setReadBufferSize(4096); // Larger buffer for high-speed
config.setMinReadBufferSize(512);
config.setMaxReadBufferSize(8192);
// Timeouts for high-speed communication
config.setIdleTime(IdleStatus.READER_IDLE, 5); // 5 second read timeout
config.setWriteTimeout(3); // 3 second write timeout
}
public void configureModemCommunication(SerialConnector connector) {
SerialSessionConfig config = connector.getSessionConfig();
// Standard modem configuration
config.setBaudRate(9600); // Standard modem speed
config.setDataBits(SerialSessionConfig.DATABITS_8); // 8 data bits
config.setStopBits(SerialSessionConfig.STOPBITS_1); // 1 stop bit
config.setParity(SerialSessionConfig.PARITY_NONE); // No parity
config.setFlowControl(SerialSessionConfig.FLOWCONTROL_NONE); // No flow control for basic modems
// Conservative timeouts for slow devices
config.setIdleTime(IdleStatus.READER_IDLE, 30); // 30 second timeout
config.setWriteTimeout(10); // 10 second write timeout
}
public void configureIndustrialDevice(SerialConnector connector) {
SerialSessionConfig config = connector.getSessionConfig();
// Industrial device configuration (often uses 7 data bits and even parity)
config.setBaudRate(19200); // Common industrial speed
config.setDataBits(SerialSessionConfig.DATABITS_7); // 7 data bits
config.setStopBits(SerialSessionConfig.STOPBITS_1); // 1 stop bit
config.setParity(SerialSessionConfig.PARITY_EVEN); // Even parity
config.setFlowControl(SerialSessionConfig.FLOWCONTROL_XONXOFF); // Software flow control
// Robust settings for industrial environment
config.setReadBufferSize(256); // Small buffer for simple protocols
config.setIdleTime(IdleStatus.READER_IDLE, 60); // 1 minute timeout
}
}Serial Port Discovery
public class SerialPortDiscovery {
public static List<String> getAvailableSerialPorts() {
List<String> ports = new ArrayList<>();
if (System.getProperty("os.name").toLowerCase().contains("windows")) {
// Windows COM ports
for (int i = 1; i <= 20; i++) {
String portName = "COM" + i;
if (isPortAvailable(portName)) {
ports.add(portName);
}
}
} else {
// Unix/Linux serial devices
String[] commonPorts = {
"/dev/ttyS0", "/dev/ttyS1", "/dev/ttyS2", "/dev/ttyS3", // Standard serial
"/dev/ttyUSB0", "/dev/ttyUSB1", "/dev/ttyUSB2", // USB-to-Serial
"/dev/ttyACM0", "/dev/ttyACM1", // USB CDC devices
"/dev/ttyAMA0", "/dev/ttyAMA1" // Raspberry Pi GPIO serial
};
for (String port : commonPorts) {
if (isPortAvailable(port)) {
ports.add(port);
}
}
}
return ports;
}
private static boolean isPortAvailable(String portName) {
try {
SerialConnector connector = new SerialConnector();
SerialAddress address = new SerialAddress(portName);
// Try to connect briefly to test availability
ConnectFuture future = connector.connect(address);
future.awaitUninterruptibly(1000); // 1 second timeout
if (future.isConnected()) {
future.getSession().closeNow();
connector.dispose();
return true;
}
} catch (Exception e) {
// Port not available or permission denied
}
return false;
}
public static void printAvailablePorts() {
List<String> ports = getAvailableSerialPorts();
if (ports.isEmpty()) {
System.out.println("No serial ports found or accessible");
System.out.println("Check RXTX installation and port permissions");
} else {
System.out.println("Available serial ports:");
for (String port : ports) {
System.out.println(" " + port);
}
}
}
}VM Pipe Transport (In-Memory)
High-performance in-memory transport for same-JVM communication.
VmPipeAcceptor
In-memory server:
// VM Pipe server
VmPipeAcceptor acceptor = new VmPipeAcceptor();
// No special configuration needed for VM pipes
acceptor.setHandler(new VmPipeServerHandler());
// Bind to VM pipe address (integer port)
VmPipeAddress address = new VmPipeAddress(12345);
acceptor.bind(address);
System.out.println("VM Pipe server listening on: " + address);
public class VmPipeServerHandler extends IoHandlerAdapter {
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
System.out.println("VM Pipe message: " + message);
// Echo the message back
session.write("Echo: " + message);
}
}VmPipeConnector
In-memory client:
// VM Pipe client
VmPipeConnector connector = new VmPipeConnector();
connector.setHandler(new VmPipeClientHandler());
// Connect to VM pipe server
VmPipeAddress address = new VmPipeAddress(12345);
ConnectFuture future = connector.connect(address);
IoSession session = future.awaitUninterruptibly().getSession();
// Send message through VM pipe
session.write("Hello from VM Pipe client!");
public class VmPipeClientHandler extends IoHandlerAdapter {
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
System.out.println("Server response: " + message);
}
}VM Pipe Performance Example
// High-performance VM pipe communication
public class HighPerformanceVmPipe {
public void performanceTest() throws Exception {
// Server setup
VmPipeAcceptor acceptor = new VmPipeAcceptor();
acceptor.setHandler(new PerformanceServerHandler());
VmPipeAddress address = new VmPipeAddress(54321);
acceptor.bind(address);
// Client setup
VmPipeConnector connector = new VmPipeConnector();
connector.setHandler(new PerformanceClientHandler());
ConnectFuture future = connector.connect(address);
IoSession session = future.awaitUninterruptibly().getSession();
// Send many messages for performance test
long startTime = System.currentTimeMillis();
int messageCount = 100000;
for (int i = 0; i < messageCount; i++) {
session.write("Message " + i);
}
// Wait for completion and measure performance
Thread.sleep(1000); // Allow processing to complete
long endTime = System.currentTimeMillis();
long duration = endTime - startTime;
System.out.printf("Sent %d messages in %d ms (%.2f msgs/sec)%n",
messageCount, duration, (messageCount * 1000.0 / duration));
}
class PerformanceServerHandler extends IoHandlerAdapter {
private AtomicLong messageCount = new AtomicLong();
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
// Just count messages, don't echo back for performance
long count = messageCount.incrementAndGet();
if (count % 10000 == 0) {
System.out.println("Processed " + count + " messages");
}
}
}
class PerformanceClientHandler extends IoHandlerAdapter {
// Minimal client handler for performance testing
}
}Transport Metadata
Getting Transport Information
public class TransportInfoExample {
public void printTransportInfo(IoService service) {
TransportMetadata metadata = service.getTransportMetadata();
System.out.println("Transport Provider: " + metadata.getProviderName());
System.out.println("Transport Name: " + metadata.getName());
System.out.println("Connection Model: " + metadata.getConnectionModel());
System.out.println("Session Config Type: " + metadata.getSessionConfigType().getName());
System.out.println("Session Type: " + metadata.getSessionType().getName());
System.out.println("Address Type: " + metadata.getAddressType().getName());
System.out.println("Envelope Support: " + metadata.hasFragmentation());
System.out.println("Fragmentation Support: " + metadata.hasFragmentation());
}
public void selectTransportBasedOnMetadata(IoService service) {
TransportMetadata metadata = service.getTransportMetadata();
if (metadata.getConnectionModel() == ConnectionModel.CONNECTION) {
System.out.println("Connection-oriented transport (TCP)");
// Configure for reliable delivery
configureReliableTransport(service);
} else if (metadata.getConnectionModel() == ConnectionModel.CONNECTIONLESS) {
System.out.println("Connectionless transport (UDP)");
// Configure for fast delivery
configureFastTransport(service);
}
if (metadata.hasFragmentation()) {
System.out.println("Transport supports fragmentation");
// Can send large messages
} else {
System.out.println("Transport requires message size management");
// Need to fragment messages manually
}
}
}Transport-Specific Session Configuration
Socket Session Configuration
public class SocketSessionConfiguration {
public void configureSocketSession(SocketSessionConfig config) {
// Buffer configuration
config.setSendBufferSize(128 * 1024); // 128KB send buffer
config.setReceiveBufferSize(128 * 1024); // 128KB receive buffer
// Socket behavior
config.setTcpNoDelay(true); // Disable Nagle's algorithm
config.setKeepAlive(true); // Enable keep-alive
config.setSoLinger(-1); // Default linger behavior
config.setReuseAddress(true); // Allow port reuse
// Traffic control
config.setTrafficClass(IPTOS_LOWDELAY | IPTOS_THROUGHPUT);
// Session-level settings
config.setReadBufferSize(8192); // MINA read buffer
config.setMinReadBufferSize(1024); // Minimum buffer size
config.setMaxReadBufferSize(65536); // Maximum buffer size
// Idle time settings
config.setIdleTime(IdleStatus.READER_IDLE, 60); // 60 seconds
config.setIdleTime(IdleStatus.WRITER_IDLE, 30); // 30 seconds
config.setIdleTime(IdleStatus.BOTH_IDLE, 90); // 90 seconds
// Write timeout
config.setWriteTimeout(10); // 10 seconds write timeout
// Throughput calculation
config.setThroughputCalculationInterval(3); // Calculate every 3 seconds
}
}Datagram Session Configuration
public class DatagramSessionConfiguration {
public void configureDatagramSession(DatagramSessionConfig config) {
// Buffer sizes (important for UDP)
config.setSendBufferSize(256 * 1024); // 256KB send buffer
config.setReceiveBufferSize(256 * 1024); // 256KB receive buffer
// UDP-specific options
config.setBroadcast(true); // Allow broadcast packets
config.setReuseAddress(true); // Allow address reuse
// Traffic class for QoS
config.setTrafficClass(IPTOS_LOWDELAY); // Optimize for low latency
// Close session immediately after idle (UDP is stateless)
config.setCloseOnPortUnreachable(true); // Close on ICMP port unreachable
// Session settings
config.setReadBufferSize(1500); // MTU-sized buffer
config.setMinReadBufferSize(512); // Minimum for small packets
config.setMaxReadBufferSize(65507); // Maximum UDP payload
// Idle detection (less useful for UDP)
config.setIdleTime(IdleStatus.BOTH_IDLE, 300); // 5 minutes
}
}VM Pipe Session Configuration
public class VmPipeSessionConfiguration {
public void configureVmPipeSession(VmPipeSessionConfig config) {
// VM Pipe has minimal configuration since it's in-memory
// Buffer settings (can be larger since no network overhead)
config.setReadBufferSize(64 * 1024); // 64KB read buffer
config.setMinReadBufferSize(4096); // 4KB minimum
config.setMaxReadBufferSize(1024 * 1024); // 1MB maximum
// No network timeouts needed, but can set for application logic
config.setIdleTime(IdleStatus.BOTH_IDLE, 3600); // 1 hour
// Throughput calculation (very fast for in-memory)
config.setThroughputCalculationInterval(1); // Every second
}
}Advanced Transport Configuration
Custom Socket Channel Configuration
public class AdvancedSocketConfiguration {
public void configureAdvancedSocket(NioSocketAcceptor acceptor) throws IOException {
// Access underlying socket channel configuration
acceptor.setReuseAddress(true);
acceptor.setBacklog(1000); // Large accept queue for high load
// Custom session configuration
SocketSessionConfig config = acceptor.getSessionConfig();
// Performance tuning
config.setSendBufferSize(1024 * 1024); // 1MB send buffer
config.setReceiveBufferSize(1024 * 1024); // 1MB receive buffer
config.setTcpNoDelay(true); // Immediate send
// Advanced socket options (require casting to implementation)
if (config instanceof NioSocketSessionConfig) {
NioSocketSessionConfig nioConfig = (NioSocketSessionConfig) config;
// Set socket options directly
nioConfig.setAll(config.getAll());
}
}
public void configureServerSocketOptions(NioSocketAcceptor acceptor) {
// Configure acceptor for high-performance server
// Use multiple I/O processors for CPU cores
int processors = Runtime.getRuntime().availableProcessors();
NioSocketAcceptor multiCoreAcceptor = new NioSocketAcceptor(processors);
// Set large backlog for connection bursts
multiCoreAcceptor.setBacklog(2000);
// Enable address reuse for quick restart
multiCoreAcceptor.setReuseAddress(true);
// Configure session defaults
SocketSessionConfig config = multiCoreAcceptor.getSessionConfig();
config.setSendBufferSize(256 * 1024); // 256KB
config.setReceiveBufferSize(256 * 1024); // 256KB
config.setTcpNoDelay(true); // Low latency
config.setKeepAlive(true); // Detect dead connections
}
}Transport Selection Strategy
public class TransportSelector {
public IoAcceptor selectAcceptor(String protocol, Map<String, Object> properties) {
switch (protocol.toLowerCase()) {
case "tcp":
case "socket":
return createTcpAcceptor(properties);
case "udp":
case "datagram":
return createUdpAcceptor(properties);
case "pipe":
case "vmpipe":
return createVmPipeAcceptor(properties);
default:
throw new IllegalArgumentException("Unsupported protocol: " + protocol);
}
}
private IoAcceptor createTcpAcceptor(Map<String, Object> properties) {
int processors = (Integer) properties.getOrDefault("processors",
Runtime.getRuntime().availableProcessors());
NioSocketAcceptor acceptor = new NioSocketAcceptor(processors);
// Configure based on properties
if (properties.containsKey("backlog")) {
acceptor.setBacklog((Integer) properties.get("backlog"));
}
SocketSessionConfig config = acceptor.getSessionConfig();
if (properties.containsKey("sendBufferSize")) {
config.setSendBufferSize((Integer) properties.get("sendBufferSize"));
}
if (properties.containsKey("receiveBufferSize")) {
config.setReceiveBufferSize((Integer) properties.get("receiveBufferSize"));
}
Boolean tcpNoDelay = (Boolean) properties.get("tcpNoDelay");
if (tcpNoDelay != null) {
config.setTcpNoDelay(tcpNoDelay);
}
return acceptor;
}
private IoAcceptor createUdpAcceptor(Map<String, Object> properties) {
NioDatagramAcceptor acceptor = new NioDatagramAcceptor();
DatagramSessionConfig config = acceptor.getSessionConfig();
if (properties.containsKey("broadcast")) {
config.setBroadcast((Boolean) properties.get("broadcast"));
}
if (properties.containsKey("sendBufferSize")) {
config.setSendBufferSize((Integer) properties.get("sendBufferSize"));
}
if (properties.containsKey("receiveBufferSize")) {
config.setReceiveBufferSize((Integer) properties.get("receiveBufferSize"));
}
return acceptor;
}
private IoAcceptor createVmPipeAcceptor(Map<String, Object> properties) {
VmPipeAcceptor acceptor = new VmPipeAcceptor();
// VM pipe has minimal configuration
VmPipeSessionConfig config =
(VmPipeSessionConfig) acceptor.getSessionConfig();
if (properties.containsKey("readBufferSize")) {
config.setReadBufferSize((Integer) properties.get("readBufferSize"));
}
return acceptor;
}
}The transport layer in MINA Core provides flexible and high-performance networking capabilities across TCP, UDP, and in-memory communication channels, with comprehensive configuration options for different use cases and performance requirements.
Install with Tessl CLI
npx tessl i tessl/maven-org-apache-mina--mina-core