webservices报连接重置

Question

webservices服务端部署到本地和跟客户端同一个ip段的服务器上边没有问题，部署到与客户端不是同一个客户端会出现连接重置，但是用接口工具测试没有问题

Answer 1

package com.web.main.core.monitor.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.mongodb.client.MongoCursor;
import com.web.common.constant.MainConstant;
import com.web.common.utils.JDBCUtils;
import com.web.main.core.monitor.utils.MongoUtils;
import com.web.monitor.app.ServerConfig;
import com.web.monitor.entity.SysCoreServerEntity;
import com.web.monitor.service.MonitorService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.LookupOperation;
import org.springframework.data.mongodb.core.aggregation.MatchOperation;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
import java.util.stream.Collectors;

@Slf4j
@Component
@ServerEndpoint("/websocket/main/core/{userId}")
public class HomePageController {
    //记录连接的客户端
    public static Map<String, Session> clients = new ConcurrentHashMap<>();

    /**
     * userId关联sid（解决同一用户id，在多个web端连接的问题）
     */
    public static Map<String, Set<String>> conns = new ConcurrentHashMap<>();

    private String sid = null;

    private String userId;

    private Session session;

    private static TaskScheduler taskScheduler;


    private static Environment environment;

    private static Map<String, ScheduledFuture> scheduledFutures = new ConcurrentHashMap<>();
    @Resource
    private HttpServletRequest httpServletRequest;



    public MonitorService getMonitorService() {
        return monitorService;
    }


    @Autowired
    public void setMonitorService(MonitorService monitorService) {
        this.monitorService = monitorService;
    }

    public Environment getEnvironment() {
        return environment;
    }

    @Autowired
    public void setEnvironment(Environment environment) {
        HomePageController.environment = environment;
    }


    public ServerConfig getServerConfig() {
        return this.serverConfig;
    }

    @Autowired
    public void setServerConfig(ServerConfig serverConfig) {
        this.serverConfig = serverConfig;
    }


    public HttpServletRequest getHttpServletRequest() {
        return httpServletRequest;
    }

    @Autowired
    public void setHttpServletRequest(HttpServletRequest httpServletRequest) {
        this.httpServletRequest = httpServletRequest;
    }

    public TaskScheduler getTaskScheduler() {
        return taskScheduler;
    }

    @Autowired
    public void setTaskScheduler(TaskScheduler taskScheduler) {
        this.taskScheduler = taskScheduler;
    }

    /**
     * 连接成功后调用的方法
     *
     * @param session
     * @param userId
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("userId") String userId) {
        this.sid = UUID.randomUUID().toString();
        this.userId = userId;
        clients.put(this.sid, session);
        Set<String> clientSet = conns.get(userId);
        if (clientSet == null) {
            clientSet = new HashSet<>();
            conns.put(userId, clientSet);
        }
        clientSet.add(this.sid);
        log.info(this.sid + "连接开启！");
        sendMessage(session);
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose(Session session) {
        log.info(this.sid + "连接断开！");
        clients.remove(this.sid);
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message
     * @param session
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        session.setMaxIdleTimeout(10 * 1000L);
        log.info("session续期");
        sendMessage(session);
    }

    private void sendMessage(Session session) {
        ObjectMapper objectMapper = new ObjectMapper();
       
            session.getBasicRemote().sendText(objectMapper.writeValueAsString(result));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

   

    /**
     * 发生错误时的回调函数
     *
     * @param error
     */
    @OnError
    public void onError(Throwable error) {
        error.printStackTrace();
    }

}