云芯拐杖socket

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/endpoint/statistics/DetectionPlatformEndpoint.java

@@ -0,0 +1,47 @@
package com.yihu.jw.care.endpoint.statistics;
import com.alibaba.fastjson.JSONObject;
import com.yihu.jw.care.service.statistics.DetectionPlatformService;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
/***
 * @ClassName: DetectionPlatformEndpoint
 * @Description: 社区云照护平台--物联网健康监测展示平台
 * @Auther: shi kejing
 * @Date: 2021/8/20 9:28
 */
@RestController
@RequestMapping(value = "open/platform")
@Api(value = "物联网健康监测展示平台v1.0.0", description = "物联网健康监测展示平台v1.0.0", tags = {"物联网健康监测展示平台v1.0.0"})
public class DetectionPlatformEndpoint extends EnvelopRestEndpoint {
    @Autowired
    private DetectionPlatformService platformService;
    @GetMapping(value = "statisticsTotalAmount")
    @ApiOperation(value = "统计总数")
    public PageEnvelop statisticsTotalAmount(
            @ApiParam(name="page",value = "page") @RequestParam(required = true) int page,
            @ApiParam(name="size",value = "size") @RequestParam(required = true) int size,
            @ApiParam(name="type",value = "type=1(健康监测)   type=2(安防检测)") @RequestParam(required = true) int type) {
        try {
            return platformService.getHealthMonitoringListNew(page,size,type);
        } catch (Exception e) {
            return failedPageEnvelopException2(e);
        }
    }
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/service/statistics/DetectionPlatformService.java

@@ -0,0 +1,52 @@
package com.yihu.jw.care.service.statistics;
import com.yihu.jw.restmodel.web.PageEnvelop;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
/***
 * @ClassName: DetectionPlatformService
 * @Description:
 * @Auther: shi kejing
 * @Date: 2021/8/20 9:39
 */
@Service
public class DetectionPlatformService  {
    Logger logger = LoggerFactory.getLogger(DetectionPlatformService.class);
    @Autowired
    private JdbcTemplate jdbcTemplate;
    public PageEnvelop getHealthMonitoringListNew(Integer page, Integer pageSize, Integer type){
        page = page>0?page-1:0;
        if (type == 1) {
            String sql = " SELECT id,user,`name`,'健康监测' as serve_desc,czrq,value1,value2,value3,value4,value5,value6,value7,type \n" +
                    "FROM wlyy_patient_health_index WHERE del = 1 AND type < 3 ORDER BY czrq ";
            String countSql = "select count(id) from ("+sql+")A ";
            long count = jdbcTemplate.queryForObject(countSql,long.class);
            sql +=" limit "+page*pageSize+","+pageSize;
            List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
            return PageEnvelop.getSuccessListWithPage("查询成功",list,page,pageSize,count);
        }else {
            String sql = " select  '22' as 'OrderType',ord.id,ord.patient,p.name,ord.serve_desc,DATE_FORMAT(ord.create_time,'%Y-%m-%d %H:%i:%S') create_time,ord.`status` \n" +
                    "from base_security_monitoring_order ord INNER JOIN base_patient p on ord.patient = p.id order by create_time desc ";
            String countSql = "select count(id) from ("+sql+")A ";
            long count = jdbcTemplate.queryForObject(countSql,long.class);
            sql +=" limit "+page*pageSize+","+pageSize;
            List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
            return PageEnvelop.getSuccessListWithPage("查询成功",list,page,pageSize,count);
        }
    }
}

svr/svr-cloud-device/pom.xml

@@ -16,6 +16,11 @@
    <version>${parent.version}</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <!-- 支持Tomcat启动 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>

svr/svr-cloud-device/src/main/java/com/yihu/jw/care/config/WebSocketConfig.java

@@ -0,0 +1,21 @@
package com.yihu.jw.care.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
/***
 * @ClassName: WebSocketConfig
 * @Description: 开启WebSocket支持
 * @Auther: shi kejing
 * @Date: 2021/8/20 14:17
 */
@Configuration
public class WebSocketConfig {
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

svr/svr-cloud-device/src/main/java/com/yihu/jw/care/endpoint/SocketClientTest.java

@@ -0,0 +1,84 @@
package com.yihu.jw.care.endpoint;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
/***
 * @ClassName: SocketTest
 * @Description: scoket客户端
 * @Auther: shi kejing
 * @Date: 2021/8/20 11:00
 */
public class SocketClientTest {
    public static void main(String[] args) {
        SocketClientTest client=new SocketClientTest();
        client.startAction();
    }
    void readSocketInfo(BufferedReader reader){
        new Thread(new MyRuns(reader)).start();
    }
    class MyRuns implements Runnable{
        BufferedReader reader;
        public MyRuns(BufferedReader reader) {
            super();
            this.reader = reader;
        }
        public void run() {
            try {
                String lineString="";
                while( (lineString = reader.readLine())!=null ){
                    System.out.println(lineString);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    public void startAction(){
        Socket socket=null;
        BufferedReader reader=null;
        BufferedWriter writer=null;
        BufferedReader reader2=null;
        try {
            socket=new Socket("172.26.0.107", 9112);
            reader = new BufferedReader(new InputStreamReader(System.in));
            reader2=new BufferedReader(new InputStreamReader(socket.getInputStream()));
            writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            readSocketInfo(reader2);
            String lineString="";
            while(!(lineString=reader.readLine()).equals("exit")){
                writer.write(lineString+"\n");
                writer.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (reader!=null) {
                    reader.close();
                }
                if (writer!=null) {
                    writer.close();
                }
                if (socket!=null) {
                    socket.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }
}

svr/svr-cloud-device/src/main/java/com/yihu/jw/care/endpoint/SocketServerTest.java

@@ -0,0 +1,103 @@
package com.yihu.jw.care.endpoint;
import com.tencentcloudapi.oceanus.v20190422.models.SystemResourceItem;
import com.yihu.jw.entity.util.SystemConfEntity;
import jdk.internal.cmm.SystemResourcePressureImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.convert.Property;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
/***
 * @ClassName: SocketServerTest
 * @Description: socket服务器端
 * @Auther: shi kejing
 * @Date: 2021/8/20 11:04
 */
@Component
public class SocketServerTest {
    private final static Logger logger = LoggerFactory.getLogger(SocketServerTest.class);
    public static void main(String[] args) {
        SocketServerTest st = new SocketServerTest();
        st.startAction();
    }
//    @PostConstruct
    public void startAction(){
        logger.info("服务端服务启动监听：");
        ServerSocket serverSocket=null;
        try {
            serverSocket=new ServerSocket(9112);  //端口号
            logger.info("服务端服务启动监听：");
            //通过死循环开启长连接，开启线程去处理消息
            while(true){
                Socket socket=serverSocket.accept();
                new Thread(new SocketServerTest.MyRuns(socket)).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (serverSocket!=null) {
                    serverSocket.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }
    class MyRuns implements Runnable{
        Socket socket;
        BufferedReader reader;
        BufferedWriter writer;
        public MyRuns(Socket socket) {
            super();
            this.socket = socket;
        }
        public void run() {
            try {
                reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));//读取客户端消息
                writer=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));//向客户端写消息
                String lineString=""; //服务器接受到的消息
                while(!(lineString=reader.readLine()).equals("bye")){
                    logger.info("收到来自客户端的发送的消息是：" + lineString);
                    writer.write("服务器返回："+lineString+"\n");
                    writer.flush();
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (reader!=null) {
                        reader.close();
                    }
                    if (writer!=null) {
                        writer.close();
                    }
                    if (socket!=null) {
                        socket.close();
                    }
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }
        }
    }
}

svr/svr-cloud-device/src/main/java/com/yihu/jw/care/endpoint/WebSocketServer.java

@@ -0,0 +1,150 @@
package com.yihu.jw.care.endpoint;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;
import com.alibaba.fastjson.JSON;
/***
 * @ClassName: WebSocketServer
 * @Description:
 * @Auther: shi kejing
 * @Date: 2021/8/20 14:20
 */
@ServerEndpoint("/imserver/{userId}")
@Component
public class WebSocketServer {
    private final static Logger log = LoggerFactory.getLogger(WebSocketServer.class);
    /**静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。*/
    private static int onlineCount = 0;
    /**concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。*/
    private static ConcurrentHashMap<String,WebSocketServer> webSocketMap = new ConcurrentHashMap<>();
    /**与某个客户端的连接会话，需要通过它来给客户端发送数据*/
    private Session session;
    /**接收userId*/
    private String userId="";
    /**
     * 连接建立成功调用的方法*/
    @OnOpen
    public void onOpen(Session session,@PathParam("userId") String userId) {
        log.info("userId = "+userId);
        this.session = session;
        this.userId=userId;
        if(webSocketMap.containsKey(userId)){
            webSocketMap.remove(userId);
            webSocketMap.put(userId,this);
            //加入set中
        }else{
            webSocketMap.put(userId,this);
            //加入set中
            addOnlineCount();
            //在线数加1
        }
        log.info("用户连接:"+userId+",当前在线人数为:" + getOnlineCount());
        try {
            sendMessage("连接成功");
        } catch (IOException e) {
            log.error("用户:"+userId+",网络异常!!!!!!");
        }
    }
    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose() {
        if(webSocketMap.containsKey(userId)){
            webSocketMap.remove(userId);
            //从set中删除
            subOnlineCount();
        }
        log.info("用户退出:"+userId+",当前在线人数为:" + getOnlineCount());
    }
    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息*/
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("用户消息:"+userId+",报文:"+message);
        //可以群发消息
        //消息保存到数据库、redis
        if(StringUtils.isNotBlank(message)){
            try {
                //解析发送的报文
                JSONObject jsonObject = JSON.parseObject(message);
                //追加发送人(防止串改)
                jsonObject.put("fromUserId",this.userId);
                String toUserId=jsonObject.getString("toUserId");
                //传送给对应toUserId用户的websocket
                if(StringUtils.isNotBlank(toUserId)&&webSocketMap.containsKey(toUserId)){
                    webSocketMap.get(toUserId).sendMessage(jsonObject.toJSONString());
                }else{
                    log.error("请求的userId:"+toUserId+"不在该服务器上");
                    //否则不在这个服务器上，发送到mysql或者redis
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    /**
     *
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        log.error("用户错误:"+this.userId+",原因:"+error.getMessage());
        error.printStackTrace();
    }
    /**
     * 实现服务器主动推送
     */
    public void sendMessage(String message) throws IOException {
        this.session.getBasicRemote().sendText(message);
    }
    /**
     * 发送自定义消息
     * */
    public static void sendInfo(String message,@PathParam("userId") String userId) throws IOException {
        log.info("发送消息到:"+userId+"，报文:"+message);
        if(StringUtils.isNotBlank(userId)&&webSocketMap.containsKey(userId)){
            webSocketMap.get(userId).sendMessage(message);
        }else{
            log.error("用户"+userId+",不在线！");
        }
    }
    public static synchronized int getOnlineCount() {
        return onlineCount;
    }
    public static synchronized void addOnlineCount() {
        WebSocketServer.onlineCount++;
    }
    public static synchronized void subOnlineCount() {
        WebSocketServer.onlineCount--;
    }
}

svr/svr-cloud-device/src/main/java/com/yihu/jw/care/endpoint/YunXinIotController.java

@@ -0,0 +1,25 @@
package com.yihu.jw.care.endpoint;
import com.yihu.jw.care.common.BaseController;
import io.swagger.annotations.Api;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.PostConstruct;
/***
 * @ClassName: YunXinIotController
 * @Description: 云芯 智能拐杖
 * @Auther: shi kejing
 * @Date: 2021/8/20 10:06
 */
@RestController
@RequestMapping(value = "yunxin/device")
@Api(value = "云芯 智能拐杖", description = "云芯 智能拐杖", tags = {"云芯 智能拐杖"})
public class YunXinIotController extends BaseController {
    private final static Logger LOGGER = LoggerFactory.getLogger(YunXinIotController.class);
}

svr/svr-cloud-device/src/main/resources/application.yml

@@ -3,7 +3,7 @@ server:
  port: 9112
spring:
  application:
      name:  svr-cloud-device
      name:  svr-cloud-device-skj
  aop:
    proxy-target-class: true
  datasource: