package com.example.socket_demo.socket;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author Administrator
 */
@Component
@Slf4j
public class TcpSocket implements Runnable {
    public Integer port;
    private ServerSocket server;
    private ExecutorService threadPool;

    public TcpSocket() {
        try {
            port = 8081;
            threadPool = Executors.newCachedThreadPool();
            server = new ServerSocket(port);
        } catch (Exception e) {
            log.error(e.getMessage());
        }
    }

    @Override
    public void run() {
        while (true) {
            try {
                Socket socket = server.accept();
                if (socket != null) {
                    SocketReceive socketReceive = new SocketReceive(socket);
                    threadPool.submit(socketReceive);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.example.socket_demo.socket;


import lombok.extern.slf4j.Slf4j;

import java.net.Socket;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

@Slf4j
public class AllClientsMap {

    /**
     * 所有已连接设备
     */
    private static final ConcurrentMap<String, Socket> ALLCLIENTS = new ConcurrentHashMap<>();

    /**
     * 返回设备列表
     *
     * @return
     */
    public static ConcurrentMap<String, Socket> getAllClients() {
        return ALLCLIENTS;
    }

    /**
     * 通过key获取客户端
     *
     * @return
     */
    public static Socket getSocketByKey(String key) {
        return ALLCLIENTS.get(key);
    }

    /**
     * 添加设备到列表
     *
     * @param key
     * @param socket
     */
    public static void put(String key, Socket socket) {
        ALLCLIENTS.put(key, socket);
        log.info("设备Key:{}========ip:{}已加入列表", key, socket.getInetAddress().getHostAddress());
    }

    /**
     * 移除设备
     *
     * @param key
     */
    public static void remove(String key) {
        ALLCLIENTS.remove(key);
        log.info("已移除设备Key:{}", key);
    }

    /**
     * 返回已连接设备数量
     *
     * @return
     */
    public static int size() {
        log.info("当前设备数：{}", ALLCLIENTS.size());
        return ALLCLIENTS.size();
    }

    /**
     * 打印信息
     *
     * @return
     */
    public static void print() {
        log.info("当前设备列表信息:长度：{}", ALLCLIENTS.size());
        ALLCLIENTS.forEach((key, socket) -> {
            log.info("设备Key:{}========ip:{}", key, socket.getInetAddress().getHostAddress());
        });
    }

    /**
     * 是否包含
     *
     * @param key
     * @return
     */
    public static boolean contains(String key) {
        return ALLCLIENTS.containsKey(key);
    }
}

package com.example.socket_demo.socket;

import lombok.extern.slf4j.Slf4j;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

@Slf4j
public class SocketReceive implements Runnable {
    private Socket socket;

    public SocketReceive() {
    }

    public SocketReceive(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        while (true) {
            if (null == socket) {
                log.info("socket为空");
                return;
            }
            boolean isClosed = socket.isClosed();
            String hostAddress = socket.getInetAddress().getHostAddress();
            if (isClosed) {
                log.info("socket检测到关闭了");
                if (AllClientsMap.contains(hostAddress)) {
                    AllClientsMap.remove(hostAddress);
                    AllClientsMap.print();
                }
                return;
            }
            String hostAddress = socket.getInetAddress().getHostAddress();
            try {
                //建立客户端信息输入流
                DataInputStream in = new DataInputStream(socket.getInputStream());
                //定义字节数组读取数据
                byte[] bytes = new byte[1024];
                int len = in.read(bytes);
                if (len == -1) {
                    return;
                }
                //定义一个新数组copy，解决读取出来的数据字节不够全是0的问题
                byte[] bytes1 = new byte[len];
                System.arraycopy(bytes, 0, bytes1, 0, len);
                log.info("客户端传的byte字节数组：" + printBytesByStringBuilder(bytes1));
                String s = new String(bytes1);
                log.info("客户端传的byte字节数组转换成字符串打印:" + s);
                //转换hex数据
                String data = byteArrayToHex(bytes1);
                log.info("接收的16进制数据:" + data);
                //如果服务端没有保存该socket
                if(!AllClientsMap.contains(hostAddress)){
                    AllClientsMap.put(hostAddress, socket);
                    AllClientsMap.print();
                }
                log.debug("客户端" + hostAddress + "发送数据：{}", data);
                //执行业务
                System.out.println("执行业务");

                //从map中获取客户端发送消息
                response(AllClientsMap.getSocketByKey(hostAddress), data);

            } catch (IOException e) {
                if (AllClientsMap.contains(hostAddress)) {
                    AllClientsMap.remove(hostAddress);
                    AllClientsMap.print();
                }
                try {
                    socket.close();
                    log.error("{}断开连接", hostAddress);
                    return;
                } catch (IOException ioException) {
                    log.error(ioException.getMessage());
                }
            }
        }
    }


    /**
     * 根据字节数组，输出对应的格式化字符串
     *
     * @param bytes 字节数组
     * @return 字节数组字符串
     */
    public static String printBytesByStringBuilder(byte[] bytes) {
        StringBuilder stringBuilder = new StringBuilder();
        for (byte aByte : bytes) {
            stringBuilder.append(byte2String(aByte));
        }
        return stringBuilder.toString();
    }

    public static String byte2String(byte b) {
        return String.format("%02x ", b);
    }

    /**
     * 向socket发送消息
     *
     * @param socket 对应socket
     * @param msg    消息
     */
    public static void response(Socket socket, String msg) {
        log.debug("向设备IP：{}发送消息：{}", socket.getInetAddress().getHostAddress(), msg);
        OutputStream outputStream = null;
        try {
            outputStream = socket.getOutputStream();
            outputStream.write(hexStringToByteArray(msg));
        } catch (IOException e) {
            try {
                socket.close();
            } catch (IOException ioException) {
                log.error(ioException.getMessage());
            }
            log.error(e.getMessage());
        }
    }

    /**
     * 字节数组转字符串
     *
     * @param bytes
     * @return
     */
    public static String byteArrayToHex(byte[] bytes) {
        StringBuilder result = new StringBuilder();
        for (int index = 0, len = bytes.length; index <= len - 1; index += 1) {
            int char1 = ((bytes[index] >> 4) & 0xF);
            char chara1 = Character.forDigit(char1, 16);
            int char2 = ((bytes[index]) & 0xF);
            char chara2 = Character.forDigit(char2, 16);
            result.append(chara1);
            result.append(chara2);
        }
        return result.toString();
    }


    /**
     * 16进制表示的字符串转换为字节数组
     *
     * @param hexString 16进制表示的字符串
     * @return byte[] 字节数组
     */
    public static byte[] hexStringToByteArray(String hexString) {
        hexString = hexString.replaceAll(" ", "");
        int len = hexString.length();
        byte[] bytes = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            // 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个字节
            bytes[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character
                    .digit(hexString.charAt(i + 1), 16));
        }
        return bytes;
    }
}

package com.example.socket_demo.socket;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class SpringFinishedListener implements InitializingBean {
    @Autowired
    private TcpSocket tcpsocket;

    @Override
    public void afterPropertiesSet() {
        Thread serverThread = new Thread(tcpsocket);
        serverThread.start();
    }
}

/**
 * 项目启动时，初始化定时器 主要是防止手动修改数据库导致未同步到定时任务处理（注：不能手动修改数据库ID和任务组名，否则会导致脏数据）
 */
//@PostConstruct
public void init() throws SchedulerException, TaskException
{
    scheduler.clear();
    List<SysJob> jobList = jobMapper.selectJobAll();
    for (SysJob job : jobList)
    {
        ScheduleUtils.createScheduleJob(scheduler, job);
    }
}

/**
 * 项目启动时，初始化字典到缓存
 */
//@PostConstruct
public void init()
{
    loadingDictCache();
}

/**
 * 项目启动时，初始化参数到缓存
 */
//@PostConstruct
public void init()
{
    loadingConfigCache();
}

package com.ruoyi;

import com.ruoyi.quartz.service.impl.SysJobServiceImpl;
import com.ruoyi.system.service.impl.SysConfigServiceImpl;
import com.ruoyi.system.service.impl.SysDictTypeServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

/**
 * 启动程序
 *
 * @author ruoyi
 */
@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })
public class RuoYiApplication
        implements CommandLineRunner {
    @Autowired
    private SysConfigServiceImpl configService;
    @Autowired
    private SysJobServiceImpl jobService;
    @Autowired
    private SysDictTypeServiceImpl dictTypeService;

    public static void main(String[] args)
    {
        // System.setProperty("spring.devtools.restart.enabled", "false");
        SpringApplication.run(RuoYiApplication.class, args);
        System.out.println("(♥◠‿◠)ﾉﾞ  若依启动成功   ლ(´ڡ`ლ)ﾞ  \n" +
                " .-------.       ____     __        \n" +
                " |  _ _   \\      \\   \\   /  /    \n" +
                " | ( ' )  |       \\  _. /  '       \n" +
                " |(_ o _) /        _( )_ .'         \n" +
                " | (_,_).' __  ___(_ o _)'          \n" +
                " |  |\\ \\  |  ||   |(_,_)'         \n" +
                " |  | \\ `'   /|   `-'  /           \n" +
                " |  |  \\    /  \\      /           \n" +
                " ''-'   `'-'    `-..-'              ");
    }

    @Override
    public void run(String... args) throws Exception {
        configService.init();
        jobService.init();
        dictTypeService.init();
    }
}