Merge branch 'master' of http://git.aseanbusiness.cn/qzyReal/gather-server

# Conflicts:
#	pom.xml
#	src/main/resources/application.yml

pom.xml

@@ -58,6 +58,15 @@
             <artifactId>jna</artifactId>
             <version>3.0.9</version>
         </dependency>
+        <!-- Redis -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-pool2</artifactId>
+        </dependency>
     </dependencies>
 
 

src/main/java/com/gzlh/background/client/BackgroundClientHandler.java

@@ -0,0 +1,94 @@
+package com.gzlh.background.client;
+
+import com.gzlh.background.client.CustomHeartbeatHandler;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.timeout.IdleStateEvent;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@ChannelHandler.Sharable
+public class BackgroundClientHandler extends CustomHeartbeatHandler {
+    private BackgroundClientNetty client;
+
+    public BackgroundClientHandler(BackgroundClientNetty client) {
+        super("client");
+        this.client = client;
+    }
+
+
+//    @Override
+//    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
+//        System.out.println(1111);
+//        System.out.println("Client received: " + msg);
+//
+//    }
+
+
+    //    @Override
+//    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+//        System.out.println(1111);
+//        System.out.println(msg);
+////        ByteBuf in = (ByteBuf) msg;
+////        System.out.println("Client received: " + in.toString(CharsetUtil.UTF_8));
+//
+//    }
+
+    @Override
+    protected void handleData(ChannelHandlerContext channelHandlerContext, String msg) {
+//        byte[] data = new byte[byteBuf.readableBytes() - 5];
+//        byteBuf.skipBytes(5);
+//        byteBuf.readBytes(data);
+//        String content = new String(data);
+        System.out.println(name + " get content: " + msg);
+    }
+
+    @Override
+    protected void handleAllIdle(ChannelHandlerContext ctx) {
+        super.handleAllIdle(ctx);
+        sendPingMsg(ctx);
+    }
+
+
+//    @Override
+//    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+//        //当被通知Channel是活跃的时候，发送一条消息
+////        ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks!", CharsetUtil.UTF_8));
+////        sendPingMsg(ctx);
+//    }
+
+    @Override
+    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+        // IdleStateHandler 所产生的 IdleStateEvent 的处理逻辑.
+        if (evt instanceof IdleStateEvent) {
+            IdleStateEvent e = (IdleStateEvent) evt;
+            switch (e.state()) {
+                case READER_IDLE:
+                    handleReaderIdle(ctx);
+                    break;
+                case WRITER_IDLE:
+                    handleWriterIdle(ctx);
+                    break;
+                case ALL_IDLE:
+                    handleAllIdle(ctx);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        cause.printStackTrace();
+        ctx.close();
+    }
+
+    @Override
+    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
+        super.channelInactive(ctx);
+        client.connect();
+    }
+
+}

src/main/java/com/gzlh/background/client/BackgroundClientNetty.java

@@ -0,0 +1,91 @@
+package com.gzlh.background.client;
+
+import com.gzlh.background.properties.BackgroundPropertiesConfig;
+import com.gzlh.led.properties.LedPropertiesConfig;
+import com.gzlh.socket.TestClientHandler;
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.*;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.handler.codec.string.StringDecoder;
+import io.netty.handler.codec.string.StringEncoder;
+import io.netty.handler.timeout.IdleStateHandler;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import javax.annotation.Resource;
+import java.util.concurrent.TimeUnit;
+
+@Configuration
+@Slf4j
+public class BackgroundClientNetty {
+
+    @Resource
+    private BackgroundPropertiesConfig config;
+    @Autowired
+    private BackgroundClientHandler backgroundClientHandler;
+    Bootstrap bootstrap;
+    Channel channel;
+
+
+    @Bean("backgroundClient")
+    public Bootstrap bootstrap() {
+        EventLoopGroup group = new NioEventLoopGroup();
+        bootstrap = new Bootstrap();
+        return bootstrap.group(group)
+                .channel(NioSocketChannel.class)
+                .remoteAddress(config.getHost(), config.getPort())
+                .handler(new ChannelInitializer<SocketChannel>() {
+                    @Override
+                    protected void initChannel(SocketChannel socketChannel) {
+                        socketChannel.pipeline()
+                                .addLast("decoder", new StringDecoder())
+                                .addLast("encoder", new StringEncoder())
+                                .addLast(new IdleStateHandler(0, 0, 5))
+                                .addLast(backgroundClientHandler);
+                    }
+                });
+
+    }
+
+    @Bean("backgroundClientHandler")
+    public BackgroundClientHandler backgroundClientHandler() {
+        return new BackgroundClientHandler(this);
+    }
+
+    public void connect() {
+        ChannelFuture future = bootstrap().connect();
+        future.addListener((ChannelFutureListener) future1 -> {
+            if (future1.isSuccess()) {
+                channel = future1.channel();
+                log.info("后端服务器连接成功,{},{}",config.getHost(), config.getPort());
+            } else {
+                log.error("------------后端-连接服务器失败,{},{}-----------，进行重连",config.getHost(), config.getPort());
+                future1.channel().eventLoop().schedule(this::connect, 5, TimeUnit.SECONDS);
+            }
+        });
+        try {
+            future.channel().closeFuture().sync();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void send(String message) {
+        if (channel != null && channel.isActive()) {
+            channel.writeAndFlush(message);
+        } else {
+            log.error("未建立连接，无法发送消息");
+        }
+    }
+
+    public void close() {
+        if (channel != null) {
+            channel.close();
+        }
+    }
+
+}

src/main/java/com/gzlh/background/client/CustomHeartbeatHandler.java

@@ -0,0 +1,91 @@
+package com.gzlh.background.client;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.handler.timeout.IdleStateEvent;
+
+public abstract class CustomHeartbeatHandler extends SimpleChannelInboundHandler<String> {
+    public static final byte PING_MSG = 1;
+    public static final byte PONG_MSG = 2;
+    public static final byte CUSTOM_MSG = 3;
+    protected String name;
+    private int heartbeatCount = 0;
+
+    public CustomHeartbeatHandler(String name) {
+        this.name = name;
+    }
+
+    @Override
+    protected void channelRead0(ChannelHandlerContext context, String msg) throws Exception {
+//        if (byteBuf.getByte(4) == PING_MSG) {
+//            sendPongMsg(context);
+//        } else if (byteBuf.getByte(4) == PONG_MSG){
+//            System.out.println(name + " get pong msg from " + context.channel().remoteAddress());
+//        } else {
+            handleData(context, msg);
+//        }
+    }
+
+    protected void sendPingMsg(ChannelHandlerContext context) {
+//        ByteBuf buf = context.alloc().buffer(5);
+//        buf.writeInt(5);
+//        buf.writeByte(PING_MSG);
+        context.writeAndFlush("ping");
+        heartbeatCount++;
+        System.out.println(name + " sent ping msg to " + context.channel().remoteAddress() + ", count: " + heartbeatCount);
+    }
+
+    protected void sendPongMsg(ChannelHandlerContext context) {
+//        ByteBuf buf = context.alloc().buffer(5);
+//        buf.writeInt(5);
+//        buf.writeByte(PONG_MSG);
+        context.channel().writeAndFlush("pong");
+        heartbeatCount++;
+        System.out.println(name + " sent pong msg to " + context.channel().remoteAddress() + ", count: " + heartbeatCount);
+    }
+
+    protected abstract void handleData(ChannelHandlerContext channelHandlerContext, String msg);
+
+    @Override
+    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+        // IdleStateHandler 所产生的 IdleStateEvent 的处理逻辑.
+        if (evt instanceof IdleStateEvent) {
+            IdleStateEvent e = (IdleStateEvent) evt;
+            switch (e.state()) {
+                case READER_IDLE:
+                    handleReaderIdle(ctx);
+                    break;
+                case WRITER_IDLE:
+                    handleWriterIdle(ctx);
+                    break;
+                case ALL_IDLE:
+                    handleAllIdle(ctx);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        System.err.println("---" + ctx.channel().remoteAddress() + " is active---");
+    }
+
+    @Override
+    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
+        System.err.println("---" + ctx.channel().remoteAddress() + " is inactive---");
+    }
+
+    protected void handleReaderIdle(ChannelHandlerContext ctx) {
+        System.err.println("---READER_IDLE---");
+    }
+
+    protected void handleWriterIdle(ChannelHandlerContext ctx) {
+        System.err.println("---WRITER_IDLE---");
+    }
+
+    protected void handleAllIdle(ChannelHandlerContext ctx) {
+        System.err.println("---ALL_IDLE---");
+    }
+}

src/main/java/com/gzlh/background/properties/BackgroundPropertiesConfig.java

@@ -0,0 +1,14 @@
+package com.gzlh.background.properties;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@ConfigurationProperties(prefix = "background")
+@Configuration
+@Data
+public class BackgroundPropertiesConfig {
+    private String host;
+    private int port;
+    private boolean enable;
+}

src/main/java/com/gzlh/camera/CameraServer.java

@@ -0,0 +1,5 @@
+package com.gzlh.camera;
+
+public class CameraServer {
+
+}

src/main/java/com/gzlh/camera/action/CameraCommonAction.java

@@ -0,0 +1,8 @@
+package com.gzlh.camera.action;
+
+/**
+ * led共同
+ */
+public interface CameraCommonAction {
+
+}

src/main/java/com/gzlh/camera/brand/CameraBrandType.java

@@ -0,0 +1,17 @@
+package com.gzlh.camera.brand;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum CameraBrandType {
+
+    HIKVISION(1000,"海康威视")
+
+    ;
+
+
+    private int code;
+    private String brand;
+}

src/main/java/com/gzlh/camera/client/CameraClientHandler.java

@@ -0,0 +1,37 @@
+package com.gzlh.camera.client;
+
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@ChannelHandler.Sharable
+public class CameraClientHandler extends SimpleChannelInboundHandler<String> {
+
+    private CameraNettyConfig cameraNettyConfig;
+
+    public CameraClientHandler(CameraNettyConfig cameraNettyConfig) {
+        this.cameraNettyConfig = cameraNettyConfig;
+    }
+
+    @Override
+    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
+        log.info("Camera 客户端收到消息：" + msg);
+
+    }
+
+    @Override
+    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
+        log.error("Camera 客户端 连接断开，进行重连");
+        cameraNettyConfig.connect();
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        cause.printStackTrace();
+        ctx.close();
+    }
+
+}
+

src/main/java/com/gzlh/camera/client/CameraNettyConfig.java

@@ -0,0 +1,98 @@
+package com.gzlh.camera.client;
+
+import com.gzlh.camera.properties.CameraPropertiesConfig;
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.*;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.handler.codec.string.StringDecoder;
+import io.netty.handler.codec.string.StringEncoder;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import javax.annotation.Resource;
+import java.util.concurrent.TimeUnit;
+
+@Configuration
+@Slf4j
+public class CameraNettyConfig {
+
+    @Resource
+    private CameraPropertiesConfig cameraConfig;
+
+    @Autowired
+    private CameraClientHandler cameraClientHandler;
+
+    private Channel channel;
+
+    @Bean("cameraBootstrap")
+    public Bootstrap bootstrap() {
+        String host = cameraConfig.getHost();
+        int port = cameraConfig.getPort();
+        if (cameraConfig.isEnable()) {
+            log.info("初始化 led:{},{}", host, port);
+        }
+        EventLoopGroup group = new NioEventLoopGroup();
+        return new Bootstrap()
+                .group(group)
+                .channel(NioSocketChannel.class)
+                .remoteAddress(host, port)
+                .option(ChannelOption.SO_KEEPALIVE, true)
+                .handler(new ChannelInitializer<SocketChannel>() {
+                    @Override
+                    protected void initChannel(SocketChannel ch) {
+                        try {
+                            ChannelPipeline pipeline = ch.pipeline();
+                            pipeline.addLast("decoder", new StringDecoder());
+                            pipeline.addLast("encoder", new StringEncoder());
+                            pipeline.addLast("handler", cameraClientHandler);
+                        } catch (Exception e) {
+                            log.info("error connect:{}", e.getMessage());
+                        }
+                    }
+                });
+    }
+
+    @Bean("cameraClientHandler")
+    public CameraClientHandler cameraClientHandler() {
+        return new CameraClientHandler(this);
+    }
+
+    public void connect() {
+        String host = cameraConfig.getHost();
+        int port = cameraConfig.getPort();
+        ChannelFuture future = bootstrap().connect();
+        future.addListener((ChannelFutureListener) future1 -> {
+            if (future1.isSuccess()) {
+                channel = future1.channel();
+                log.info("Camera 串口服务器连接成功,{},{}", host, port);
+            } else {
+                log.error("-------------Camera 连接服务器失败,{},{}-----------，进行重连", host, port);
+                future1.channel().eventLoop().schedule(this::connect, 5, TimeUnit.SECONDS);
+            }
+        });
+        try {
+            future.channel().closeFuture().sync();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void send(String message) {
+        if (channel != null && channel.isActive()) {
+            channel.writeAndFlush(message);
+        } else {
+            log.error("未建立连接，无法发送消息");
+        }
+    }
+
+    public void close() {
+        if (channel != null) {
+            channel.close();
+        }
+    }
+}
+

src/main/java/com/gzlh/camera/controller/CameraController.java

@@ -0,0 +1,82 @@
+package com.gzlh.camera.controller;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.util.XmlUtil;
+import cn.hutool.extra.spring.SpringUtil;
+import com.gzlh.camera.factory.CameraFactory;
+import com.gzlh.camera.properties.CameraPropertiesConfig;
+import com.gzlh.event.EventBus;
+import com.gzlh.utils.FileUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.util.StringUtils;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+import java.io.IOException;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.Map;
+
+
+@RestController
+@RequestMapping("/Camera")
+public class CameraController {
+    @Value("${file.root-path}")
+    private String path;
+    @Value("${application.channel-name}")
+    private String channel;
+    @Resource
+    private CameraFactory cameraFactory;
+    @Resource
+    private CameraPropertiesConfig cameraPropertiesConfig;
+
+
+    @PostMapping("/recv")
+    public void recv(
+            @RequestBody String xmlStr
+//            HttpServletRequest request
+    ) throws IOException {
+//        String xmlStr = IOUtils.toString(request.getInputStream(), request.getCharacterEncoding());
+
+        Map<String, Object> StringObjectMap = new HashMap<>();
+
+        XmlUtil.xmlToMap(xmlStr, StringObjectMap);
+
+        Map<String, Object> ic = BeanUtil.beanToMap(StringObjectMap.get("IC"));
+        Map<String, Object> weight =BeanUtil.beanToMap(StringObjectMap.get("WEIGHT"));
+        Map<String, Object> car = BeanUtil.beanToMap(StringObjectMap.get("CAR"));
+        Map<String, Object> conta =BeanUtil.beanToMap(StringObjectMap.get("CONTA"));
+        Map<String, Object> seal = BeanUtil.beanToMap(StringObjectMap.get("SEAL"));
+
+
+        Map<String, String> cacheMap = new HashMap<>();
+        cacheMap.put("carEcNo", (String) car.get("CAR_EC_NO"));
+        cacheMap.put("contaIdF", !StringUtils.isEmpty((String) car.get("CONTA_ID_F"))?(String) car.get("CONTA_ID_F"):"");
+        cacheMap.put("contaIdB", !StringUtils.isEmpty((String) car.get("CONTA_ID_B"))?(String) car.get("CONTA_ID_B"):"");
+
+
+        Calendar calendar = Calendar.getInstance();
+        String savePath=path+"/"+ calendar.get(Calendar.YEAR)+"-" + (calendar.get(Calendar.MONTH)+1);
+
+        Map<String, String> picMap = new HashMap<>();
+        for (Map.Entry<String, Object> entry : conta.entrySet()) {
+            if(entry.getKey().contains("PIC")&& !StringUtils.isEmpty((String) entry.getValue())){
+                String filePath = FileUtils.downLoad((String) entry.getValue(),savePath);
+                String base64 = FileUtils.getBase64FromImg(filePath);
+                picMap.put(entry.getKey(),base64);
+            }
+        }
+
+        // TODO: 2023/11/10
+        cameraFactory.handler(cameraPropertiesConfig.getBrand()).handlerAction("");
+
+
+
+    }
+
+
+}

src/main/java/com/gzlh/camera/event/CameraDefaultEvent.java

@@ -0,0 +1,12 @@
+package com.gzlh.camera.event;
+
+/**
+ * led内置事件
+ */
+public interface CameraDefaultEvent {
+    /**
+     * 超时事件
+     */
+    String TIMEOUT = "TIMEOUT";
+    String READ = "READ";
+}

src/main/java/com/gzlh/camera/factory/CameraFactory.java

@@ -0,0 +1,21 @@
+package com.gzlh.camera.factory;
+
+
+
+import com.gzlh.camera.handler.ICameraHandler;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class CameraFactory {
+    @Autowired
+    private List<ICameraHandler>handlers;
+
+    public ICameraHandler handler(int code){
+       return handlers.stream().filter(h->h.brandType().getCode()==code)
+                .findAny().orElseThrow(()->new IllegalArgumentException("不支持交互"));
+    }
+
+}

src/main/java/com/gzlh/camera/handler/ICameraHandler.java

@@ -0,0 +1,12 @@
+package com.gzlh.camera.handler;
+
+import com.gzlh.camera.brand.CameraBrandType;
+
+public interface ICameraHandler {
+
+    CameraBrandType brandType();
+
+    void sendMsg( String content);
+
+    void handlerAction(String action);
+}

src/main/java/com/gzlh/camera/handler/impl/CameraHandlerHikvision.java

@@ -0,0 +1,36 @@
+package com.gzlh.camera.handler.impl;
+
+import com.gzlh.camera.brand.CameraBrandType;
+import com.gzlh.camera.client.CameraNettyConfig;
+import com.gzlh.camera.handler.ICameraHandler;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+
+/**
+ * 上海仰邦科技股份有限公司BX-5(M)K/6K（YY）-V4.2 led发送处理器
+ */
+@Service
+@Slf4j
+public class CameraHandlerHikvision implements ICameraHandler {
+
+    @Resource
+    private CameraNettyConfig cameraNettyConfig;
+
+    @Override
+    public CameraBrandType brandType() {
+        return CameraBrandType.HIKVISION;
+    }
+
+    @Override
+    public void sendMsg(String content) {
+        log.info(CameraBrandType.HIKVISION.getBrand() + "发送消息:{}", content);
+        cameraNettyConfig.send(content);
+    }
+
+    @Override
+    public void handlerAction(String action) {
+        log.info("action:{}",action);
+    }
+}

src/main/java/com/gzlh/camera/properties/CameraPropertiesConfig.java

@@ -0,0 +1,15 @@
+package com.gzlh.camera.properties;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@ConfigurationProperties(prefix = "led")
+@Configuration
+@Data
+public class CameraPropertiesConfig {
+    private String host;
+    private int port;
+    private int brand;
+    private boolean enable;
+}

src/main/java/com/gzlh/startup/StartupCommandLineRunner.java

@@ -4,14 +4,18 @@ import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.thread.ThreadUtil;
 import cn.hutool.json.JSONObject;
 import cn.hutool.json.XML;
+import com.gzlh.background.client.BackgroundClientNetty;
+import com.gzlh.background.properties.BackgroundPropertiesConfig;
 import com.gzlh.dto.ApplicationConfigDTO;
 import com.gzlh.event.EventBus;
 import com.gzlh.led.client.LedNettyConfig;
 import com.gzlh.led.properties.LedPropertiesConfig;
 import com.gzlh.infrared.client.RedNettyConfig;
 import com.gzlh.infrared.config.RedPropertiesConfig;
+import com.gzlh.socket.TestClientNetty;
 import com.gzlh.weighbridge.client.WeighbridgeNettyConfig;
 import com.gzlh.weighbridge.config.WeighbridgePropertiesConfig;
+import javafx.scene.layout.Background;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.stereotype.Component;
@@ -37,6 +41,10 @@ public class StartupCommandLineRunner implements CommandLineRunner {
     private RedNettyConfig redNettyConfig;
     @Resource
     private RedPropertiesConfig redConfig;
+    @Resource
+    private BackgroundPropertiesConfig backgroundPropertiesConfig;
+    @Resource
+    private BackgroundClientNetty backgroundClientNetty;
 
     @Override
     public void run(String... args) throws Exception {
@@ -50,6 +58,9 @@ public class StartupCommandLineRunner implements CommandLineRunner {
         if (redConfig.isEnable()) {
             ThreadUtil.execute(() -> redNettyConfig.connect());
         }
+        if (backgroundPropertiesConfig.isEnable()) {
+            ThreadUtil.execute(() -> backgroundClientNetty.connect());
+        }
     }
 
     private void initConfig() {

src/main/java/com/gzlh/utils/FileUtils.java

@@ -0,0 +1,91 @@
+package com.gzlh.utils;
+
+import org.springframework.beans.factory.annotation.Value;
+
+import java.io.*;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.Calendar;
+
+public class FileUtils {
+
+
+    public static String downLoad(String urlString,String savePath) throws IOException {
+        InputStream in = null;
+        OutputStream out=null;
+
+        try {
+            URL url = new URL(urlString);
+            URLConnection connection = url.openConnection();
+            in = connection.getInputStream();
+//            Calendar calendar = Calendar.getInstance();
+//            String savePath=path+"/"+ calendar.get(Calendar.YEAR)+"-" + (calendar.get(Calendar.MONTH)+1);
+            File folder = new File(savePath);
+            if (!folder.exists()) {
+                folder.mkdirs();
+            }
+            String fileName = new File(url.getFile()).getName();
+            out = new FileOutputStream(savePath+"/"+fileName);
+
+            byte[] buffer = new byte[1024];
+            int bytesRead;
+            while ((bytesRead = in.read(buffer)) != -1) {
+                out.write(buffer, 0, bytesRead);
+            }
+            System.out.println("文件下载完成！");
+            return savePath+"/"+fileName;
+        } catch (Exception e) {
+            throw e;
+        }finally {
+            if (in != null) {
+                in.close();
+            }
+            if (out != null){
+                out.close();
+            }
+        }
+
+    }
+
+
+    public static String getBase64FromImg(String filePath) throws IOException {
+        FileInputStream in = null;
+        try {
+            File file = new File(filePath);
+            // base64图片前缀
+            String pre = "data:image/jpg;base64,";
+            // 读取图片
+            in = new FileInputStream(file);
+            // 读取字节长度
+            int len = 0;
+            // baseByte数组的容量
+            int capacity = 0;
+            byte[] baseByte= new byte[0];
+            byte [] bytes = new byte[1024];
+            while ((len = in.read(bytes)) != -1){
+                // 对原数组进行拷贝扩容
+                baseByte= Arrays.copyOf(baseByte, len + capacity);
+                // 将新数据拷贝到新扩容的数组
+                System.arraycopy(bytes, 0, baseByte, capacity, len);
+                // 数据容量增加
+                capacity += len;
+            }
+            // 获取base64编码器
+            Base64.Encoder encoder = Base64.getEncoder();
+            // 将字节数组转换base64
+            String encodeToString = encoder.encodeToString(baseByte);
+//            System.out.println("======>>>>>>：" + pre + encodeToString);
+            return pre + encodeToString;
+        } catch (IOException e) {
+            throw e;
+        } finally {
+            if (in != null) {
+                in.close();
+            }
+        }
+
+    }
+
+}

src/main/resources/application.yml

@@ -27,6 +27,16 @@ red:
 gate:
   brand: 4000
   gate-port: 8131
+
+camera:
+  host: 127.0.0.1
+  brand: 1000
+  port: 8888
+  enable: false
+background:
+  host: 127.0.0.1
+  port: 8080
+  enable: true
   #图片存储根路径
 file:
   root-path: D:\\upfile\\