import java.io.*;
import java.net.*;

public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8080); // 在8080端口等別人來找
        System.out.println("服務(wù)端啟動，等待客戶端連接...");

        Socket socket = serverSocket.accept(); // 有人來連接，就接收它
        System.out.println("客戶端連接進來了");

        // 輸入輸出流：用來讀寫數(shù)據(jù)
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); // 讀
        PrintWriter out = new PrintWriter(socket.getOutputStream(), true); // 寫

        String line;
        while ((line = in.readLine()) != null) {
            System.out.println("收到客戶端消息：" + line);
            out.println("我收到了：" + line); // 回給客戶端
        }

        socket.close(); // 關(guān)閉連接
        serverSocket.close();
    }
}

import java.io.*;
import java.net.*;

public class Client {
    public static void main(String[] args) throws Exception {
        Socket socket = new Socket("127.0.0.1", 8080); // 連接本機服務(wù)端
        System.out.println("連接服務(wù)端成功！");

        // 輸入輸出
        BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in)); // 你鍵盤輸入
        PrintWriter out = new PrintWriter(socket.getOutputStream(), true); // 發(fā)消息
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); // 收消息

        String msg;
        while ((msg = userInput.readLine()) != null) {
            out.println(msg); // 發(fā)給服務(wù)端
            String reply = in.readLine(); // 讀取服務(wù)端返回
            System.out.println("服務(wù)端說：" + reply);
        }

        socket.close();
    }
}

服務(wù)端啟動，等待客戶端連接...

連接服務(wù)端成功！

客戶端連接進來了

BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in));

 PrintWriter out = new PrintWriter(socket.getOutputStream(), true); // 發(fā)消息

BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); // 收消息

out.println(msg); // 發(fā)給服務(wù)端
String reply = in.readLine(); // 讀取服務(wù)端返回
System.out.println("服務(wù)端說：" + reply);

收到客戶端消息：hello

服務(wù)端說：我收到了：hello

public class EchoServer {

    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);  // 負責接收連接
        EventLoopGroup workerGroup = new NioEventLoopGroup(); // 負責處理請求

        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .childHandler(new EchoServerHandler());

            ChannelFuture f = b.bind(8080).sync();  // 綁定端口，開始監(jiān)聽
            f.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    // 處理客戶端發(fā)來的消息
    public static class EchoServerHandler extends ChannelInboundHandlerAdapter {

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            // 接收到數(shù)據(jù)后直接寫回給客戶端
            System.out.println("收到消息：" + msg);
            ctx.writeAndFlush(msg);
        }

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
            cause.printStackTrace();
            ctx.close(); // 出現(xiàn)異常關(guān)閉連接
        }
    }
}

ServerBootstrap serverBootstrap = new ServerBootstrap()
    .group(bossGroup, workGroup)
    .channel(NioServerSocketChannel.class)
    .childHandler(new ServerChannelInitializer(delimiter, maxFrameLength))
    .localAddress(socketAddress)
    .option(ChannelOption.SO_BACKLOG, 1024)
    .childOption(ChannelOption.SO_KEEPALIVE, true);

ChannelFuture channelFuture = serverBootstrap.bind(socketAddress).sync();

package com....nettyService;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.logging.LoggingHandler;

public class ServerChannelInitializer extends ChannelInitializer<SocketChannel> {

    private String DELIMITER;
    private int MAXFRAMELENGTH;

    public ServerChannelInitializer(String delimiter, int maxFrameLength) {
        DELIMITER = delimiter;
        MAXFRAMELENGTH = maxFrameLength;
    }

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        socketChannel.pipeline().addLast("logging", new LoggingHandler("DEBUG"));
        socketChannel.pipeline().addLast("decoder", new HL7Decoder());
        socketChannel.pipeline().addLast("encoder", new HL7Encoder());
        socketChannel.pipeline().addLast(new NettyServerHandler());
    }

}

package com.....nettyService;

import com...component.commons.utils.BeanUtils;
import com...emergency.service.impl.BS2800MPacketParse;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import org.apache.commons.lang3.ObjectUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;


@Component
public class NettyServerHandler extends SimpleChannelInboundHandler<String> {

    private static final Logger logger = LoggerFactory.getLogger(NettyServerHandler.class);
    private BS2800MPacketParse bs2800MPacketParse = BeanUtils.getBean(BS2800MPacketParse.class);
    /**
     * 裝載所有客戶端channel的組
     */
    private static final Map<String, Channel> ipChannelMap = new HashMap<>();

    /**
     * 客戶端連接過來會觸發(fā)
     */
    @Override
    public void channelActive(ChannelHandlerContext channelHandlerContext) throws Exception {
        Channel channel = channelHandlerContext.channel();
        ipChannelMap.put(channel.remoteAddress().toString(), channel);

        logger.info("客戶端連接：" + channelHandlerContext);
    }

    /**
     * 客戶端發(fā)消息過來會觸發(fā)
     */
    @Override
    public void channelRead0(ChannelHandlerContext channelHandlerContext, String msg) throws Exception {
        Channel channel = channelHandlerContext.channel();
        logger.info("服務(wù)端接收到客戶端消息");
//        logger.info("發(fā)送消息的客戶端地址：" + channel.remoteAddress());
        logger.info("發(fā)送消息的客戶端所發(fā)消息：" + msg);

        String result = msg;
        String msa = handleParams(channelHandlerContext, result);
        if (ObjectUtils.isNotEmpty(msa)) {
            channel.writeAndFlush(msa);
        }

    }

    @Override
    public void channelReadComplete(ChannelHandlerContext channelHandlerContext) throws Exception {
        super.channelReadComplete(channelHandlerContext);
    }

    @Override
    public void channelInactive(ChannelHandlerContext channelHandlerContext) throws Exception {
        Channel channel = channelHandlerContext.channel();
        // 當通道變?yōu)榉腔顒訝顟B(tài)（斷開連接）時，將其從 ChannelGroup 中移除
        String ip = channel.remoteAddress().toString();
        if (ipChannelMap.containsKey(ip)) {
            ipChannelMap.remove(ip);
            if (!channel.isActive() || channel == null) {
                channelHandlerContext.close();
            }
        }
        logger.info("客戶端地址為：" + ip + "的連接已斷開");
    }

    /**
     * 發(fā)生異常觸發(fā)
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext channelHandlerContext, Throwable cause) throws Exception {
        logger.warn(cause.toString());
    }

    /**
     * 處理接收報文消息
     */
    public String handleParams(ChannelHandlerContext channelHandlerContext, String msg) {
        String msa = null;
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
        Channel channel = channelHandlerContext.channel();
        if (channel.remoteAddress().toString().contains("10.10.51.213")) {
            if (ObjectUtils.isNotEmpty(msg)) {
                String result[] = msg.split("\r");
                if (ObjectUtils.isNotEmpty(result) && result.length > 0) {
                    String msh = null;
                    for (String string : result) {
                        if (string.contains("MSH")) {
                            msh = string;
                        }
                    }
                    if (msh.contains("ORU^R01")) {
                        Date date = new Date();
                        String temp[] = msh.split("\\|", -1);
                        if (ObjectUtils.isNotEmpty(temp) && temp.length > 9) {
                            msa = "MSH|^~\\&|||||" + dateFormat.format(date) + "||ACK^R01|" + temp[9] + "|P|2.3.1||||0||ASCII|||";
                            String str = "MSA|AA|" + temp[9] + "|Message accepted|||0|";
                            msa = msa + "\r" + str;
                            Map<String, String> paramMap = new HashMap<>();
                            paramMap.put(temp[9], msg);
                            bs2800MPacketParse.parse(msg);
                            return msa;
                        }
                    }
                }
            }
        }
        return msa;
    }

}

Channel channel = channelHandlerContext.channel();