spring 中使用Java socket

一、客户端

 public static String sendSocket(String str) {
        logger.info("-----发起socket请求信息：{}", str);
        Socket socket = null;
        OutputStream os = null;
        BufferedReader br = null;
        PrintWriter pw = null;
        try {
            //1.创建客户端Socket，指定服务器地址和端口
            socket = new Socket(IP, PORT);
            socket.setSoTimeout(5000);

            //2.获取输出流，向服务器端发送信息
            os = socket.getOutputStream();//字节输出流
//            pw=new PrintWriter(os);//将输出流包装为打印流
            pw = new PrintWriter(new OutputStreamWriter(os, "GBK"));
            pw.write(str);
            pw.flush();
            //关闭输出流
            socket.shutdownOutput();
            //3.获取输入流，并读取服务器端的响应信息
            br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "GBK"));

            String info;
//            StringBuilder result = new StringBuilder();
            info = br.readLine();
            logger.info("------我是客户端，服务器说：" + info);
//            while ((info = br.readLine()) != null) {
//                result.append(info);
//            }
            return info;
        } catch (Exception e) {
            logger.error("请求信息:" + str + "\n调用ecp系统异常:" + e.getMessage(), e);
        } finally {
            try {
                //4.关闭资源
                if (null != br) {
                    br.close();
                }
                if (null != pw) {
                    pw.close();
                }
                if (null != os) {
                    os.close();
                }
                if (null != socket) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

二、服务端

SocketStart类

import com.demo.property.SystemProps;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class SocketStart implements CommandLineRunner {
    @Override
    public void run(String... strings) throws Exception {
        SystemProps.THREAD_POOL.execute(new SocketServer());
    }
}

SocketServer 类：

import com.demo.property.SystemProps;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 *
 * @author qiaojun
 * @date 2019/7/6
 */
@Slf4j
public class SocketServer implements Runnable {

    @Override
    public void run()   {
        ServerSocket server;
        Socket socket = null;
        try {
            server = new ServerSocket(SystemProps.LOCAL_SOCKET_PORT);
            //重用端口
//            server.setReuseAddress(true);
        } catch (IOException e) {
            log.error("---socket监听启动异常:"+e.getMessage(),e);
            return;
        }
        log.info("------设备服务器已经开启, 监听端口:{}", SystemProps.LOCAL_SOCKET_PORT);
        while (true) {
            try {
                socket = server.accept();
            } catch (IOException e) {
                log.error(e.getMessage(),e);
            }
            SystemProps.THREAD_POOL.execute(new ServerConfig(socket));
        }
    }
}

外部线程池
public static final ThreadPoolExecutor THREAD_POOL = new ThreadPoolExecutor(10, 30, 5,
        TimeUnit.SECONDS, new ArrayBlockingQueue<>(20), new ThreadPoolExecutor.DiscardOldestPolicy());

 

ServerConfig：

import com.demo.property.SystemProps;
import com.demo.property.enums.ecp.EcpEnum;
import com.demo.request.ecp.EcpReqInfo;
import com.demo.system.thread.RechargeThread;
import com.demo.util.DoubleOperUtil;
import com.demo.util.EcpXmlStrUtil;
import com.demo.util.ValidUtil;
import com.demo.util.XmlUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.util.Map;

/**
 * @author qiaojun
 */
@Slf4j
public class ServerConfig extends Thread {

    private Socket socket;

    ServerConfig(Socket socket) {
        this.socket = socket;
    }

    private String handle(InputStream inputStream) throws IOException {
        byte[] bytes = new byte[1024];
        int len = inputStream.read(bytes);
        StringBuilder request = new StringBuilder();
        if (len != -1) {
            request.append(new String(bytes, 0, len, "GBK"));
            log.info("接受的数据:{} " , request);
            log.info("当前线程" + Thread.currentThread().getName());
            //数据处理业务逻辑
            return "正常响应结果信息";
        }
        return "未接受到请求数据";
    }

    
    @Override
    public void run() {
        BufferedWriter writer = null;
        try {
            // 设置连接超时10秒
            socket.setSoTimeout(10000);
            //如果不设置,客户端宕机时，服务器永远也不知道客户端宕机了，仍然保存这个失效的连接。
            socket.setKeepAlive(true);
            log.info("------客户 - " + socket.getRemoteSocketAddress() + " -> 机连接成功");
            InputStream inputStream = socket.getInputStream();
            writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(),"GBK"));
            String result;
            try {
                result = handle(inputStream);
                log.info("-------返回数据：{}",result);
                writer.write(result);
                writer.newLine();
                writer.flush();
            } catch (IOException | IllegalArgumentException e) {
                writer.write("error");
                writer.newLine();
                writer.flush();
                log.error("发生异常:"+e.getMessage(),e);
                try {
                    result = handle(inputStream);
                    writer.write(result);
                    writer.newLine();
                    writer.flush();
                } catch (SocketTimeoutException ex) {
                    log.error("------再次接受, 发生异常,连接关闭:"+ex.getMessage(),ex);
                }
            }
        } catch (SocketException socketException) {
            socketException.printStackTrace();
            try {
                if (writer!=null) {
                    writer.close();
                }
            } catch (IOException ioException) {
                ioException.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (writer!=null) {
                    writer.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}