Java Socket框架Apache MINA实现文件服务器

蔚落 2024-02-19 18:30 26阅读 0赞

## Java Socket框架Apache MINA实现文件服务器 ##

用Java Socket框架Apache MINA实现一个简单的文件服务器，该文件服务器当接受到客户端的Socket连接时候，发送一个文件给客户端，然后关闭Socket连接。程序代码如下：

import java.io.BufferedInputStream;
    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.net.InetSocketAddress;
    import java.nio.charset.Charset;
    import java.util.concurrent.CompletableFuture;
    
    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;
    
    public class MINATest {
    	public static void main(String[] args) {
    		try {
    			MINATest test = new MINATest();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    	public MINATest() throws Exception {
    		IoAcceptor acceptor = new NioSocketAcceptor();
    
    		// 过滤链。
    		acceptor.getFilterChain().addLast("logger", new LoggingFilter());
    		acceptor.getFilterChain().addLast("codec",
    				new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
    
    		SocketServerHandler socketServerHandler = new SocketServerHandler();
    
    		// 处理。
    		acceptor.setHandler(socketServerHandler);
    
    		// 服务器端绑定80端口，等待客户端连接请求。
    		acceptor.bind(new InetSocketAddress(80));
    	}
    
    	// Apache MINA的Socket服务器端。
    	private class SocketServerHandler extends IoHandlerAdapter {
    
    		public SocketServerHandler() {
    
    		}
    
    		// 会话创建。
    		@Override
    		public void sessionCreated(IoSession session) throws Exception {
    			super.sessionCreated(session);
    			System.out.println("#sessionCreated#");
    		}
    
    		// 会话打开时触发（第一次连接时先触发sessionCreated函数，后触发本函数）。
    		@Override
    		public void sessionOpened(IoSession session) throws Exception {
    			super.sessionOpened(session);
    			System.out.println("#sessionOpened#");
    
    			// 开始发送文件数据。
    			sendFileToClient(session);
    		}
    
    		@Override
    		public void messageSent(IoSession session, Object message) throws Exception {
    			super.messageSent(session, message);
    			System.out.println("#messageSent#");
    
    			System.out.println(message.toString());
    			System.out.println("=============");
    		}
    
    		// 接收到消息时触发。
    		@Override
    		public void messageReceived(IoSession session, Object message) throws Exception {
    			super.messageReceived(session, message);
    			// System.out.println("messageReceived");
    
    			System.out.print(message.toString());
    		}
    
    		@Override
    		public void sessionClosed(IoSession session) throws Exception {
    			super.sessionClosed(session);
    			System.out.println("\n#sessionClosed#");
    		}
    
    		@Override
    		public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
    			super.sessionIdle(session, status);
    			System.out.println("#sessionIdle#");
    		}
    
    		@Override
    		public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
    			super.exceptionCaught(session, cause);
    			System.out.println("#exceptionCaught#");
    			cause.printStackTrace();
    		}
    	}
    
    	// 发送一个文件数据给客户端。
    	// 线程化。
    	private void sendFileToClient(IoSession ioSession) {
    		String path = "D:/code/file.txt";
    
    		CompletableFuture.runAsync(new Runnable() {
    			@Override
    			public void run() {
    				try {
    					fileIO(ioSession, path);
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    
    	// 打印path指向的文件中的内容。
    	private void printer(String path) throws Exception {
    		InputStream is = new FileInputStream(path);
    		BufferedReader br = new BufferedReader(new InputStreamReader(is));
    		String s = null;
    		while (true) {
    			s = br.readLine();
    			if (s != null)
    				System.out.println(s);
    			else
    				break;
    		}
    
    		br.close();
    		is.close();
    	}
    
    	private void fileIO(IoSession ioSession, String path) throws Exception {
    		System.out.println("服务器要发送的文件全部数据:");
    		printer(path);
    
    		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(path));
    
    		int count = 0;
    		byte[] buffer = new byte[4];
    		while (true) {
    			count = bis.read(buffer);
    
    			if (count == -1) {
    				break;
    			}
    
    			ioSession.write(new String(buffer, 0, count));
    		}
    
    		bis.close();
    		ioSession.closeOnFlush();
    	}
    }