增加开箱子登录服代码

.gitignore

@@ -0,0 +1,8 @@
+*.iml
+.idea
+.gradle
+build
+out
+
+
+

META-INF/MANIFEST.MF

@@ -0,0 +1,2 @@
+Manifest-Version: 1.0
+

README.md

@@ -1,3 +0,0 @@
-# jieling_server
-
-服务器代码

build.gradle

@@ -0,0 +1,26 @@
+group 'loginserver'
+version ''
+
+apply plugin: 'java'
+apply plugin: 'war'
+
+sourceCompatibility = 1.8
+
+tasks.withType(JavaCompile) {
+    options.encoding = "UTF-8"
+}
+repositories {
+    //mavenCentral()
+    maven {url 'http://maven.aliyun.com/nexus/content/groups/public/'}
+}
+
+dependencies {
+    testCompile group: 'junit', name: 'junit', version: '4.11'
+    compile("javax.servlet:servlet-api:2.5")
+    compile group: 'org.mongodb', name: 'mongo-java-driver', version: '3.6.3'
+    compile("ch.qos.logback:logback-core:1.1.11")
+    compile("ch.qos.logback:logback-classic:1.1.11")
+    compile group: 'redis.clients', name: 'jedis', version: '2.9.0'
+    compile group: 'com.alibaba', name: 'fastjson', version: '1.2.47'
+
+}

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Thu Jul 21 18:25:36 CST 2022
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.0-bin.zip

gradlew

@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

@@ -0,0 +1,2 @@
+rootProject.name = 'loginserver'
+

src/main/java/com/ljsd/controller/CheckVersionController.java

@@ -0,0 +1,57 @@
+package com.ljsd.controller;
+
+import com.ljsd.util.BaseGlobal;
+import com.ljsd.util.MongoKey;
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.PrintWriter;
+
+public class CheckVersionController extends HttpServlet {
+    private static final Logger LOGGER = LoggerFactory.getLogger(CheckVersionController.class);
+
+    public CheckVersionController() {
+        super();
+    }
+
+    @Override
+    public void destroy() {
+        super.destroy();
+    }
+
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+
+        try {
+            DBObject dbObject = BaseGlobal.mongoDBPool.findOne(MongoKey.VERSION, "1");
+            DBObject res = new BasicDBObject();
+            res.put("resource_version", dbObject.get("resource_version"));
+            res.put("application_version", dbObject.get("application_version"));
+            LOGGER.debug("resource_version={},application_version={}", dbObject.get("resource_version"), dbObject.get("application_version"));
+            PrintWriter out = response.getWriter();
+            out.print(res);
+            out.flush();
+            out.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        this.doGet(request, response);
+    }
+
+}

src/main/java/com/ljsd/controller/ClientReportController.java

@@ -0,0 +1,70 @@
+package com.ljsd.controller;
+
+import com.ljsd.pojo.UserServerInfo;
+import com.ljsd.redis.RedisKey;
+import com.ljsd.timer.ServerManager;
+import com.ljsd.util.BaseGlobal;
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author gaojie
+ * @version V1.0
+ * @className ClientReportController
+ * @packageName com.ljsd.controller
+ * @description 客户端是否是上报日志接口
+ * @date 2022-03-01 9:49
+ * copyright(c) 2020-2030 蓝鲸时代技术有限公司
+ **/
+public class ClientReportController extends HttpServlet {
+    private static final Logger LOGGER = LoggerFactory.getLogger(ClientReportController.class);
+
+    @Override
+    public void destroy() {
+        super.destroy();
+    }
+
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response) {
+
+        try {
+            String device = request.getParameter("device");
+            Map<String, Integer> reportMap = BaseGlobal.redisApp.hgetAll(RedisKey.CLIENT_REPORT_KEY, "", Integer.class, -1, true);
+            boolean isReport = false;
+            if (reportMap.containsKey(device)){
+                isReport = true;
+            }
+            DBObject resp = new BasicDBObject();
+            resp.put("is_report", isReport);
+            LOGGER.info("clientReport===>device={},isReport={}",device,isReport);
+            response.setCharacterEncoding("UTF-8");
+            response.setContentType("text/html; charset=UTF-8");
+            PrintWriter out = response.getWriter();
+            out.print(resp);
+            out.flush();
+            out.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        this.doGet(request, response);
+    }
+}

src/main/java/com/ljsd/controller/GetLoginServerController.java

@@ -0,0 +1,92 @@
+package com.ljsd.controller;
+
+import com.ljsd.pojo.LoginServerInfo;
+import com.ljsd.timer.ServerManager;
+import com.ljsd.util.BaseGlobal;
+import com.ljsd.util.HttpClient;
+import com.ljsd.util.LoginUtil;
+import com.ljsd.util.MongoKey;
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.PrintWriter;
+
+/**
+ * @author gaojie
+ * @version V1.0
+ * @className GetLoginServerController
+ * @packageName com.ljsd.controller
+ * @description 获取登录地址已经更新信息
+ * @date 2020-11-06 13:36
+ * copyright(c) 2020-2030 蓝鲸时代技术有限公司
+ **/
+public class GetLoginServerController extends HttpServlet {
+    public GetLoginServerController() {
+        super();
+    }
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(GetLoginServerController.class);
+
+    @Override
+    public void destroy() {
+        super.destroy();
+    }
+
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+
+        try {
+            String plat = request.getParameter("plat");
+            String channel = request.getParameter("channel");
+            String itversion = request.getParameter("sub_channel");
+            //设备号id 用于白名单
+            String ipAddress = HttpClient.getIPAddress(request);
+            LOGGER.info("GetLoginServerController==>,plat={},channel={},itversion={},ipAddress={} ",
+                    plat, channel, itversion, ipAddress);
+            DBObject whiteInfo = BaseGlobal.mongoDBPool.findOne(MongoKey.WHITE_LIST, "2");
+            boolean isWhiteIp = LoginUtil.checkIpIsWhiteList(ipAddress, whiteInfo);
+            int isWhite = 1;
+            if (isWhiteIp) {
+                // 测试环境
+                isWhite = 0;
+            }
+            String key = itversion + ":" + plat + ":" + channel + ":" + isWhite;
+            LoginServerInfo loginServerInfo = ServerManager.loginServerInfoMap.get(key);
+
+            DBObject resp = new BasicDBObject();
+            if (loginServerInfo != null) {
+                resp.put("login_url", loginServerInfo.getLoginServerUrl());
+                resp.put("res", loginServerInfo.getResUrl());
+            } else {
+                resp.put("login_url", "");
+                resp.put("res", "");
+            }
+            response.setCharacterEncoding("UTF-8");
+            response.setContentType("text/html; charset=UTF-8");
+            PrintWriter out = response.getWriter();
+            out.print(resp);
+            out.flush();
+            out.close();
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        this.doGet(request, response);
+    }
+}

src/main/java/com/ljsd/controller/GetMyServerInfoController.java

@@ -0,0 +1,104 @@
+package com.ljsd.controller;
+
+import com.ljsd.sdk.KSManager;
+import com.ljsd.timer.ServerManager;
+import com.ljsd.util.GlobalVersion;
+import com.ljsd.util.HttpClient;
+import com.ljsd.util.LoginUtil;
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author gaojie
+ * @version V1.0
+ * @className GetMyServerInfoController
+ * @packageName com.ljsd.controller
+ * @description 获取我的服务器信息
+ * @date 2022-07-07 10:20
+ * copyright(c) 2020-2030 蓝鲸时代技术有限公司
+ **/
+public class GetMyServerInfoController  extends HttpServlet {
+    private static final Logger LOGGER = LoggerFactory.getLogger(LoginSDKController.class);
+
+    public GetMyServerInfoController() {
+        super();
+    }
+
+    @Override
+    public void destroy() {
+        super.destroy();
+    }
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws IOException {
+        String openId = request.getParameter("openId");
+        String sessionId = request.getParameter("sessionId");
+        String ipAddress = HttpClient.getIPAddress(request);
+        LOGGER.info("GetMyServerInfoController==>,openId={},sessionId={},ipAddress={}", openId, sessionId,ipAddress);
+        response.setCharacterEncoding("UTF-8");
+        response.setContentType("application/json; charset=utf-8");
+        PrintWriter out = response.getWriter();
+        try {
+            DBObject resp = new BasicDBObject();
+            if (!KSManager.btLoginVerify(openId, sessionId)) {
+                resp.put("result", 1);
+                resp.put("error", "verify error !!");
+                out.print(resp);
+                out.flush();
+                return;
+            }
+            List<DBObject> myServerList = LoginUtil.createMyServerList(openId);
+            DBObject recommendServer = LoginSDKController.recommendServerList();
+            List<DBObject> serverList = new ArrayList<>();
+            if (recommendServer != null){
+                serverList.add(ServerManager.serverMapById.get(recommendServer.get("server_id").toString()));
+            }
+            for (DBObject dbObject : myServerList){
+                String serverId = dbObject.get("server_id").toString();
+                DBObject server = ServerManager.serverMapById.get(serverId);
+                if (server == null){
+                    continue;
+                }
+                serverList.add(server);
+            }
+            resp.put("result", 0);
+            resp.put("myServerList", myServerList);
+            resp.put("recommendServerList", recommendServer);
+            resp.put("serverList", serverList);
+            out.print(resp);
+            out.flush();
+        } catch (Exception e) {
+            LOGGER.info("error,version={}", GlobalVersion.getServerVersion(), e);
+            e.printStackTrace();
+        } finally {
+            out.close();
+        }
+    }
+
+
+    public List<DBObject> getServerListByGroupId(int groupId) {
+        List<DBObject> dbObjects = new ArrayList<>();
+        for (DBObject dbObject : ServerManager.servers) {
+            int state = Integer.parseInt(dbObject.get("state").toString());
+            if (state != 0) {
+                continue;
+            }
+            int groupIdFromDb = Integer.parseInt(dbObject.get("groupId").toString());
+            if (groupIdFromDb == groupId) {
+                dbObjects.add(dbObject);
+            }
+        }
+        return dbObjects;
+    }
+}

src/main/java/com/ljsd/controller/GetServerController.java

@@ -0,0 +1,79 @@
+package com.ljsd.controller;
+
+import com.ljsd.pojo.PlatformServerinfo;
+import com.ljsd.timer.ServerManager;
+import com.ljsd.util.BaseGlobal;
+import com.ljsd.util.HttpClient;
+import com.ljsd.util.LoginUtil;
+import com.ljsd.util.MongoKey;
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class GetServerController extends HttpServlet {
+
+    public GetServerController() {
+        super();
+    }
+
+    @Override
+    public void destroy() {
+        super.destroy();
+    }
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+
+        try {
+//            String channel = request.getParameter("channel");
+            String channel = "ljsd";
+            String platform = request.getParameter("plat");
+            String ipaddress = HttpClient.getIPAddress(request);
+            DBObject whiteInfo = BaseGlobal.mongoDBPool.findOne(MongoKey.WHITE_LIST, "2");
+            boolean isWhiteIp = LoginUtil.checkIpIsWhiteList(ipaddress,whiteInfo);
+            if (isWhiteIp){
+                platform = platform + "_test";
+            }
+            String key = channel+"-"+platform;
+            DBObject resp = new BasicDBObject();
+
+            PlatformServerinfo pt = ServerManager.platServerinfo.get(key);
+            if(null != pt)
+            {
+                resp.put("app_version", pt.getApp_version());
+                resp.put("res_version", pt.getRes_version());
+                resp.put("res", pt.getRes_url());
+            }
+            else
+            {
+                resp.put("error", "param is error,plat:"+platform);
+            }
+            response.setCharacterEncoding("UTF-8");
+            response.setContentType("text/html; charset=UTF-8");
+            PrintWriter out = response.getWriter();
+            out.print(resp);
+            out.flush();
+            out.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        this.doGet(request, response);
+    }
+
+}

src/main/java/com/ljsd/controller/GetUserController.java

@@ -0,0 +1,262 @@
+package com.ljsd.controller;
+
+import com.ljsd.redis.RedisKey;
+import com.ljsd.sdk.KSManager;
+import com.ljsd.timer.ServerManager;
+import com.ljsd.util.*;
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+
+public class GetUserController extends HttpServlet {
+    private static final Logger LOGGER = LoggerFactory.getLogger(GetUserController.class);
+
+    public GetUserController() {
+        super();
+    }
+
+    @Override
+    public void destroy() {
+        super.destroy();
+    }
+
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        long nowTime = System.currentTimeMillis();
+        String openId = request.getParameter("openId");
+        String serverId = request.getParameter("serverId");
+        String version = request.getParameter("version");
+        String channel = request.getParameter("channel");
+        String device = request.getParameter("device");
+        if (null == device || device.isEmpty()) {
+            device = "";
+        }
+        String ipAddress = HttpClient.getIPAddress(request);
+        response.setCharacterEncoding("UTF-8");
+        response.setContentType("application/json; charset=utf-8");
+        LOGGER.info("GetUserController==>start,openId={},serverId={},version={},channel={},ipAddress={} ",
+                openId, serverId, version, channel, ipAddress);
+        DBObject res = new BasicDBObject();
+        PrintWriter out = response.getWriter();
+        if (null == openId || openId.isEmpty()) {
+            res.put("result", 1);
+            res.put("error", "parmeter error!!");
+            out.print(res);
+            out.flush();
+            return;
+        }
+        DBObject dbObject = new BasicDBObject();
+        dbObject.put("_id", openId);
+        boolean isWhite;
+        try {
+            if (serverId == null) {
+                res.put("result", 1);
+                res.put("error", "亲爱的镇魂将,请求参数有误");
+                out.print(res);
+                out.flush();
+                return;
+            }
+            isWhite = LoginUtil.isWhiteUser(openId, ipAddress, device);
+            // 检查服务器状态
+            DBObject server = ServerManager.getServer(serverId);
+            if (server == null) {
+                res.put("result", 1);
+                res.put("error", "亲爱的镇魂将,您选择的服务器未开启");
+                out.print(res);
+                out.flush();
+                return;
+            }
+            //维护状态：正常玩家可见不可进，白名单可见可进
+            int upHoldState = 4;
+            //白名单状态（新服）：正常玩家不可见不可进，白名单见可进
+            int whiteState = 3;
+            String state = "state";
+            // 未开服
+            if (Integer.parseInt(server.get(state).toString()) == upHoldState) {
+                if (!isWhite) {
+                    res.put("result", 1);
+                    res.put("error", "当前服务器正在维护中，具体开启时间请您关注公告");
+                    out.print(res);
+                    out.flush();
+                    return;
+                }
+            }
+
+            // 检查白名单
+            if (Integer.parseInt(server.get(state).toString()) == whiteState) {
+                if (!isWhite) {
+                    res.put("result", 1);
+                    res.put("error", "服务器未开启，敬请期待！");
+                    out.print(res);
+                    out.flush();
+                    return;
+                }
+            }
+
+            // 检查白名单
+            if (Integer.parseInt(server.get(state).toString()) == -1) {
+                if (!isWhite) {
+                    res.put("result", 1);
+                    res.put("error", "服务器未开启，敬请期待！");
+                    out.print(res);
+                    out.flush();
+                    return;
+                }
+            }
+
+//            if (!ServerManager.serverIsOpen(serverId)) {
+//                res.put("result", 1);
+//                res.put("error", "当前服务器正在维护中，具体开启时间请您关注公告");
+//                out.print(res);
+//                out.flush();
+//                return;
+//            }
+            String openTime = "open_time";
+            String closeTime = "closeTime";
+            //验证是否在当前开服时间段内
+            if (!TimeUtil.inCorrectTime(String.valueOf(server.get(openTime)), String.valueOf(server.get(closeTime)))) {
+                if (!isWhite) {
+                    res.put("result", 1);
+                    res.put("error", "服务器将于" + server.get(openTime) + "时开启，请您耐心等待");
+                    out.print(res);
+                    out.flush();
+                    return;
+                }
+            }
+
+            Integer uid = null;
+            try {
+                boolean getUserLock = BaseGlobal.redisApp.tryGetDistributedLock(RedisKey.USER_LOGIN_LOCK, openId, openId, 2000);
+                if (!getUserLock) {
+                    res.put("result", 1);
+                    res.put("error", "登录繁忙");
+                    out.print(res);
+                    out.flush();
+                    LOGGER.error("玩家获取锁失败---openId={}", openId);
+                    return;
+                }
+                List<DBObject> userInfos = BaseGlobal.mongoDBPool.find(MongoKey.USER_INFO, dbObject);
+                if (userInfos.isEmpty()) {
+                    dbObject.put("_id", openId);
+                    userInfos.add(dbObject);
+                }
+                dbObject = userInfos.get(0);
+                uid = (Integer) dbObject.get(serverId);
+                if (uid == null) {
+                    Boolean isCanRegister = BaseGlobal.redisApp.get(RedisKey.SERVER_REGISTER_STATE, String.valueOf(serverId), Boolean.class, -1
+                            , true);
+                    if (null != isCanRegister && !isCanRegister) {
+                        res.put("result", 1);
+                        res.put("error", "非常报歉，该服务器注册已关闭，请联系管理员！");
+                        out.print(res);
+                        out.flush();
+                        return;
+                    }
+                    //判断服务器是否达到注册人数上限
+                    Integer registCount = BaseGlobal.redisApp.get(RedisKey.REGIST_NUM, String.valueOf(serverId), Integer.class, -1, false);
+                    if (registCount == null) {
+                        registCount = 0;
+                    }
+                    Integer maxRegister = Integer.valueOf(String.valueOf(server.get("max_register")));
+                    if (maxRegister == null) {
+                        maxRegister = 1050;
+                    }
+                    if (registCount != null && registCount >= maxRegister) {
+                        // 2： 为状态选择其他服务器
+                        res.put("result", 1);
+                        res.put("error", "当前服务器已达注册上限，请您选择其他服务器进行游戏");
+                        out.print(res);
+                        out.flush();
+                        return;
+                    }
+                    // 注册人满 后自动开下个服  默认1000开一个服
+                    if (registCount + 1 >= maxRegister - 50 && "1".equals(KSManager.OPEN_SERVER_STRATEGY)) {
+                        openNextServer(String.valueOf(server.get("server_id")));
+                    }
+                    uid = BaseGlobal.mongoDBPool.inc("uid");
+                    dbObject.put(serverId, uid);
+                    userInfos.add(dbObject);
+                    BaseGlobal.mongoDBPool.save(MongoKey.USER_INFO, dbObject);
+                    //渠道注册人数
+                    BaseGlobal.redisApp.incr(channel, RedisKey.SUBCHANNEL_REGISTER_NUM);
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
+                LOGGER.error("玩家注册异常 openId={} ", openId, e);
+            } finally {
+                BaseGlobal.redisApp.releaseDistributedLock(RedisKey.USER_LOGIN_LOCK, openId, openId);
+            }
+            Random random = new Random();
+            int token = random.nextInt();
+            BaseGlobal.redisApp.set(RedisKey.TOKEN, String.valueOf(uid), token, RedisKey.TOKEN_EXPIRE, false);
+
+            boolean exists = BaseGlobal.redisApp.exists(RedisKey.UID, String.valueOf(uid), false);
+            if (!exists) {
+                BaseGlobal.redisApp.set(RedisKey.UID, String.valueOf(uid), serverId + "_" + openId, -1, false);
+            }
+            LOGGER.info("GetUserController==>uid={},info={},exists={}", uid, serverId + "_" + openId, exists);
+
+            res.put("result", 0);
+            res.put("uid", uid);
+            res.put("token", token);
+            LOGGER.info("GetUserController==>end,openId={},res={},costTime={}", openId, res.toString(), System.currentTimeMillis() - nowTime);
+            out.print(res);
+            out.flush();
+        } catch (Exception e) {
+            LOGGER.debug("error ", e);
+            e.printStackTrace();
+        } finally {
+            out.close();
+        }
+
+
+    }
+    public static void openNextServer(String serverId) throws Exception {
+        String nextOpenServerId = String.valueOf(Integer.valueOf(serverId) + 1);
+        DBObject one = ServerManager.getServer(nextOpenServerId);
+        if (one == null) {
+            LOGGER.info("openNextServer==>serverId={},nextOpenServerId={},nextOpenServerId is null",serverId,nextOpenServerId);
+            BaseGlobal.redisApp.set(RedisKey.RECOMMEND_ID, "", nextOpenServerId, -1, false);
+            return;
+        }
+        BasicDBObject searchQuery = new BasicDBObject();
+        searchQuery.put("server_id", serverId);
+        BasicDBObject dbObject = new BasicDBObject();
+        dbObject.append("$set", new BasicDBObject().append("recommend", 0));
+        BaseGlobal.mongoDBPool.updateValue(MongoKey.SERVER_INFO, searchQuery, dbObject);
+
+        int state = Integer.parseInt(one.get("state").toString());
+        if (state != -1){
+            return;
+        }
+        searchQuery = new BasicDBObject();
+        searchQuery.put("server_id", nextOpenServerId);
+        dbObject = new BasicDBObject();
+        long openTime = TimeUtil.getNowDayTimeStamp(System.currentTimeMillis());
+        dbObject.append("$set", new BasicDBObject().append("recommend", 1).append("state", 0).append("open_time", TimeUtil.timeStamp2Date(openTime)));
+        //设置开服时间
+        LoginUtil.setOpenTime(String.valueOf(one.get("server_id")),openTime);
+        BaseGlobal.mongoDBPool.updateValue(MongoKey.SERVER_INFO, searchQuery, dbObject);
+        LOGGER.info("openNextServer==>serverId={},nextOpenServerId={},",serverId,nextOpenServerId);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        this.doGet(request, response);
+    }
+}

src/main/java/com/ljsd/controller/IndexController.java

@@ -0,0 +1,27 @@
+package com.ljsd.controller;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+public class IndexController extends HttpServlet {
+    public IndexController() {
+        super();
+    }
+
+    @Override
+    public void destroy() {
+        super.destroy();
+    }
+
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+
+        response.sendRedirect("/index.jsp");
+
+    }
+}

src/main/java/com/ljsd/controller/LoginSDKController.java

@@ -0,0 +1,242 @@
+package com.ljsd.controller;
+
+import com.ljsd.redis.RedisKey;
+import com.ljsd.sdk.KSManager;
+import com.ljsd.timer.ServerManager;
+import com.ljsd.util.*;
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import redis.clients.jedis.Tuple;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class LoginSDKController extends HttpServlet {
+    private static final Logger LOGGER = LoggerFactory.getLogger(LoginSDKController.class);
+
+    public LoginSDKController() {
+        super();
+    }
+
+    @Override
+    public void destroy() {
+        super.destroy();
+    }
+
+    //0正常 1用户不存在
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws IOException {
+        String openId = request.getParameter("openId");
+        String sessionId = request.getParameter("sessionId");
+        String channel = request.getParameter("channel");
+        String itversion = request.getParameter("sub_channel");
+        String plat = request.getParameter("plat");
+        String market = request.getParameter("market");
+        String device = request.getParameter("device");
+        String id = request.getParameter("areaId");
+        int areaId = 0 ;
+        if (id != null){
+            areaId = Integer.parseInt(id);
+        }
+        if (null == market || market.isEmpty()) {
+            market = "";
+        }
+        if (null == device || device.isEmpty()) {
+            device = "";
+        }
+        String ipAddress = HttpClient.getIPAddress(request);
+        LOGGER.info("LoginSDKController==>,openId={},sessionId={},channel={},subChannel={},plat={},ipAddress={},market={},device={} ",
+                openId, sessionId, channel, itversion, plat, ipAddress, market, device);
+        response.setCharacterEncoding("UTF-8");
+        response.setContentType("application/json; charset=utf-8");
+        PrintWriter out = response.getWriter();
+        try {
+            DBObject resp = new BasicDBObject();
+            if (openId == null || "".equals(openId)) {
+                resp.put("result", 1);
+                resp.put("error", "openid is null");
+                out.print(resp);
+                out.flush();
+                return;
+            }
+            DBObject dbObject = new BasicDBObject();
+            dbObject.put("_id", openId);
+            List<DBObject> userInfos = BaseGlobal.mongoDBPool.find(MongoKey.USER_INFO, dbObject);
+            if (!KSManager.btLoginVerify(openId, sessionId)) {
+                resp.put("result", 1);
+                resp.put("error", "verify error !!");
+                out.print(resp);
+                out.flush();
+                return;
+            }
+            if (userInfos.size() == 0) {
+                BaseGlobal.mongoDBPool.save(MongoKey.USER_INFO, dbObject);
+            }
+            boolean isWhite = LoginUtil.isWhiteUser(openId, ipAddress, device);
+            if (!market.isEmpty()) {
+                channel = channel + "@" + market;
+            }
+            List<DBObject> serverList = createServerList(channel, itversion, plat, isWhite,areaId);
+
+//            List<DBObject> myServerList = LoginUtil.createMyServerList(openId);
+//
+//            List<DBObject> recommendServerList = recommendServerList(serverList);
+            resp.put("result", 0);
+            resp.put("serverList", serverList);
+//            resp.put("myServerList", myServerList);
+//            resp.put("recommendServerList", recommendServerList);
+            out.print(resp);
+            out.flush();
+        } catch (Exception e) {
+            LOGGER.info("error,version={}", GlobalVersion.getServerVersion(), e);
+            e.printStackTrace();
+        } finally {
+            out.close();
+        }
+    }
+
+    public static List<DBObject> recommendServerList(List<DBObject> serverList) throws Exception {
+        List<DBObject> recommendServers = new ArrayList<>(ServerManager.recommendServers);
+        List<DBObject> recommendServerList = new ArrayList<>();
+        for (DBObject dbObject : recommendServers) {
+            DBObject server = new BasicDBObject();
+            server.put("server_id", dbObject.get("server_id"));
+            server.put("pcu", ServerManager.totalCount(String.valueOf(dbObject.get("server_id"))));
+            server.put("groupId",dbObject.get("groupId"));
+            recommendServerList.add(server);
+        }
+//        if (serverList.size() == 0) {
+//            return recommendServerList;
+//        }
+//        // 没有设置推荐服按照时间最大的为推荐服
+//        if (recommendServers.size() == 0) {
+//            serverList.sort((o1, o2) -> (int) ((long) o2.get("open_time") / 1000) - (int) ((long) o1.get("open_time") / 1000));
+//            DBObject server = new BasicDBObject();
+//            server.put("server_id", serverList.get(0).get("server_id"));
+//            recommendServerList.add(server);
+//            return recommendServerList;
+//        }
+//        for (DBObject dbObject : recommendServers) {
+//            String serverId = String.valueOf(dbObject.get("server_id"));
+//            Integer registCount = BaseGlobal.redisApp.get(RedisKey.REGIST_NUM, String.valueOf(serverId), Integer.class, -1, false);
+//            if (null == registCount) {
+//                registCount = 0;
+//            }
+//            dbObject.put("registCount", registCount);
+//        }
+//        // 设置推荐服按照注册人数最小的为推荐服
+//        recommendServers.sort((o1, o2) -> (int) o2.get("registCount") - (int) o1.get("registCount"));
+//        DBObject serverInfo = recommendServers.get(recommendServers.size() - 1);
+//        DBObject server = new BasicDBObject();
+//        server.put("server_id", serverInfo.get("server_id"));
+//        recommendServerList.add(server);
+        return recommendServerList;
+    }
+
+    public static DBObject recommendServerList() throws Exception {
+        List<DBObject> recommendServers = new ArrayList<>(ServerManager.recommendServers);
+        for (DBObject dbObject : recommendServers) {
+            DBObject server = new BasicDBObject();
+            server.put("server_id", dbObject.get("server_id"));
+            server.put("groupId",dbObject.get("groupId"));
+
+            long time = Long.parseLong(TimeUtil.date3TimeStamp(String.valueOf(dbObject.get("open_time"))));
+            server.put("open_time", time);
+            return server;
+        }
+        return null;
+    }
+
+    public static List<DBObject> createServerList(String channel, String itversion, String plat, boolean isWhite,int areaId) throws Exception {
+        DBObject req = new BasicDBObject();
+        req.put("channel", channel);
+        req.put("itversion", itversion);
+        req.put("plat", plat);
+        List<String> serverInfoList = ServerManager.getServerList(req);
+        List<DBObject> serverList = new ArrayList<>();
+        for (String serverId : serverInfoList) {
+            DBObject serverInfo = ServerManager.getServerById(serverId);
+            int state = Integer.parseInt(serverInfo.get("state").toString());
+            // 白名单状态非白名单用户不能看到服务器列表
+            if (state == 3 && !isWhite) {
+                continue;
+            }
+            // -1 不对外
+            if (state == -1 && !isWhite){
+                continue;
+            }
+            // 维护状态，白名单用户服务器正常
+            if (state == 4 && isWhite) {
+                state = 0;
+            }
+            int groupId = Integer.parseInt(serverInfo.get("groupId").toString());
+            if (areaId != 0 && areaId != groupId){
+                continue;
+            }
+            DBObject server = new BasicDBObject();
+            server.put("state", state);
+            server.put("name", serverInfo.get("name"));
+            setIpAndPort(server, serverInfo);
+            server.put("server_id", serverInfo.get("server_id"));
+            long time = Long.parseLong(TimeUtil.date3TimeStamp(String.valueOf(serverInfo.get("open_time"))));
+            server.put("open_time", time);
+            server.put("area_name", serverInfo.get("groupId"));
+            server.put("recommend", serverInfo.get("recommend"));
+            server.put("isNew", serverInfo.get("isNew"));
+            server.put("groupId", serverInfo.get("groupId"));
+            String displayId = "";
+            if (null != serverInfo.get("display_id")) {
+                displayId = String.valueOf(serverInfo.get("display_id"));
+            }
+            server.put("display_id", displayId);
+            serverList.add(server);
+        }
+        return serverList;
+    }
+
+    public static void setIpAndPort(DBObject server, DBObject serverInfo) throws Exception {
+        String serverId = String.valueOf(serverInfo.get("server_id"));
+        long nowTime = System.currentTimeMillis();
+        List<String> ipAddressList = new ArrayList<>();
+        Set<Tuple> tuples = BaseGlobal.redisApp.zrangeWithScores(serverId, RedisKey.GATEWAY_ADDRESS_LIST);
+        for (Tuple tuple : tuples) {
+            String address = tuple.getElement();
+            long score = (long) tuple.getScore();
+            if ((nowTime - score) > 2 * 60 * 1000) {
+                continue;
+            }
+            ipAddressList.add(address);
+        }
+        if (ipAddressList.size() <= 1) {
+            server.put("ip", serverInfo.get("ip"));
+            server.put("port", serverInfo.get("port"));
+        } else {
+            Random r = new Random();
+            int index = r.nextInt(ipAddressList.size());
+            String info = ipAddressList.get(index);
+            String[] split = info.split(":");
+            server.put("ip", split[0]);
+            server.put("port", split[1]);
+        }
+
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        this.doGet(request, response);
+    }
+
+}

src/main/java/com/ljsd/controller/NoticeController.java

@@ -0,0 +1,89 @@
+package com.ljsd.controller;
+
+import com.ljsd.timer.ServerManager;
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UnknownFormatConversionException;
+
+public class NoticeController extends HttpServlet {
+    private static final Logger LOGGER = LoggerFactory.getLogger(LoginSDKController.class);
+    public NoticeController() {
+        super();
+    }
+
+    @Override
+    public void destroy() {
+        super.destroy();
+    }
+
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response) {
+
+        try {
+            String itversion = request.getParameter("itversion");
+            String channel = request.getParameter("channel");
+            String market = request.getParameter("market");
+            if (null == market  || market.isEmpty()){
+                market = "";
+            }
+            String key = channel + "@" + market;
+            Map<String, List<DBObject>> noticeMap = ServerManager.noticeMap;
+            List<DBObject> noticeList = new ArrayList<>();
+            for (Map.Entry<String, List<DBObject>> entry: noticeMap.entrySet()){
+                String key1 = entry.getKey();
+                List<DBObject> value = entry.getValue();
+                if (key.contains(key1)){
+                    for (DBObject data : value){
+                        if((int)data.get("ifOpen") == 0) {
+                            continue;
+                        }
+                        DBObject notice = new BasicDBObject();
+                        notice.put("id", data.get("_id"));
+                        notice.put("type", data.get("type"));
+                        notice.put("pic", data.get("pic"));
+                        notice.put("name", data.get("name"));
+                        notice.put("content", data.get("content"));
+                        notice.put("isNew", data.get("isNew"));
+                        notice.put("weight",data.get("weight"));
+                        if (noticeList.contains(notice)){
+                            continue;
+                        }
+                        noticeList.add(notice);
+                    }
+                }
+            }
+            noticeList.sort((o1, o2) -> (int) o2.get("weight") - (int) o1.get("weight"));
+            response.setCharacterEncoding("UTF-8");
+            response.setContentType("text/html; charset=UTF-8");
+            PrintWriter out = response.getWriter();
+            DBObject resp = new BasicDBObject();
+            resp.put("noticeList", noticeList);
+            out.print(resp);
+            out.flush();
+            out.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        this.doGet(request, response);
+    }
+
+}

src/main/java/com/ljsd/listener/WebContextListener.java

@@ -0,0 +1,92 @@
+package com.ljsd.listener;
+
+import com.ljsd.timer.ServerManager;
+import com.ljsd.timer.UpdateServerNameThread;
+import com.ljsd.util.BaseGlobal;
+import com.ljsd.util.LogBackConfigLoader;
+import com.ljsd.util.MongoKey;
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.servlet.ServletContextEvent;
+import javax.servlet.ServletContextListener;
+import java.io.FileInputStream;
+
+//创建的类名根据需要定义，但一定要实现ServletContextListener接口
+public class WebContextListener implements ServletContextListener {
+    private static final Logger LOGGER = LoggerFactory.getLogger(ServletContextListener.class);
+    private static final String DEFAULT_CONFIG_PATH = "/application.properties";
+
+    @Override
+    public void contextInitialized(ServletContextEvent event) {
+        try {
+            String path=System.getProperty("catalina.home");
+            path += "/config/loginserver/application.properties";
+            FileInputStream inputStream = new FileInputStream(path);
+//            InputStream inputStream = getClass().getResourceAsStream(path);
+            LogBackConfigLoader.load();
+            if (inputStream != null) {
+                BaseGlobal.properties.load(inputStream);
+            }
+            BaseGlobal.init();
+            DBObject dbObject = BaseGlobal.mongoDBPool.findOne(MongoKey.INC_C, "inc_k");
+            if (dbObject == null) {
+                int startUid = Integer.parseInt(BaseGlobal.properties.getProperty("start_uid"));
+                dbObject = new BasicDBObject();
+                dbObject.put("_id", "inc_k");
+                dbObject.put("uid", startUid);
+                dbObject.put("server_id", 0);
+                BaseGlobal.mongoDBPool.save(MongoKey.INC_C, dbObject);
+            }
+            //Object uid = dbObject.get("uid");
+
+//            dbObject = new BasicDBObject();
+//            dbObject.put("_id", "1");
+//            dbObject.put("resource_version", "1.0.0.0");
+//            dbObject.put("application_version", "1.0.0.0");
+//            BaseGlobal.mongoDBPool.save("version", dbObject);
+//            STableManager.init(event.getServletContext());
+            new ServerManager().start();
+            new UpdateServerNameThread().start();
+            // 添加渠道白名单
+            addChannelWhites();
+        } catch (Exception ex) {
+            LOGGER.error("error",ex);
+            ex.printStackTrace();
+        }
+    }
+
+    private void addChannelWhites() {
+        String channel = "ljsd2";
+        for(int i = 1; i <= 20; i++) {
+            String openId;
+            if(i >= 10) {
+                openId = "Zhjwsqww0"+i;
+            } else {
+                openId = "Zhjwsqww00"+i;
+            }
+            DBObject channelWhite = new BasicDBObject();
+            channelWhite.put("_id", openId);
+            channelWhite.put("channel", channel);
+            BaseGlobal.mongoDBPool.save(MongoKey.CHANNEL_WHITE, channelWhite);
+        }
+
+        DBObject channelWhite1 = new BasicDBObject();
+        channelWhite1.put("_id", "Zhj01");
+        channelWhite1.put("channel", channel);
+        BaseGlobal.mongoDBPool.save(MongoKey.CHANNEL_WHITE, channelWhite1);
+
+        DBObject channelWhite2 = new BasicDBObject();
+        channelWhite2.put("_id", "Zhj02");
+        channelWhite2.put("channel", channel);
+        BaseGlobal.mongoDBPool.save(MongoKey.CHANNEL_WHITE, channelWhite2);
+    }
+
+    @Override
+    public void contextDestroyed(ServletContextEvent arg0) {
+        // TODO Auto-generated method stub
+
+    }
+}

src/main/java/com/ljsd/pojo/AccountInfo.java

@@ -0,0 +1,219 @@
+package com.ljsd.pojo;
+
+
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 账户信息
+ */
+public class AccountInfo {
+    private String openId;  //外部ID
+    private int exp; //经验
+    private long createTime; //创建账号时间
+    private String name;//昵称
+    private int head;//头像
+    private int frame;//头像框
+    private int level; //玩家等级
+    private int playerST;//国战玩家状态
+    //private List<Integer> guide;
+    private int hellLevel; // 地狱道等级
+    //private List<Integer> weakGuide = new ArrayList<>();//弱引导
+    private int question = 0;//问卷
+    private int unionId = 0;//联盟id
+    private int serverId = 0;//服务器id
+    private int vipLevel = 0;//vip等级
+    private long beforeLevelTime = 0;//升级时间
+    private int changeNameNum = 0;//改名次数
+    private long offlineTime = 0;//下线时间
+
+    /**
+     * 分享时间
+     */
+    private long shareTime = 0;
+    /**
+     * 分享次数 key:cardType_cardQuality value：次数
+     */
+    private Map<String,Integer> shareNumMap = new HashMap<>();
+    /**
+     * 总战力
+     */
+    private long allCap = 0;
+    /**
+     * 用户数据版本
+    */
+    private String userDataVersion;
+    /**
+     * 渠道
+     */
+    private String channel;
+
+    public String getOpenId() {
+        return openId;
+    }
+
+    public void setOpenId(String openId) {
+        this.openId = openId;
+    }
+
+    public int getExp() {
+        return exp;
+    }
+
+    public void setExp(int exp) {
+        this.exp = exp;
+    }
+
+    public long getCreateTime() {
+        return createTime;
+    }
+
+    public void setCreateTime(long createTime) {
+        this.createTime = createTime;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getHead() {
+        return head;
+    }
+
+    public void setHead(int head) {
+        this.head = head;
+    }
+
+    public int getFrame() {
+        return frame;
+    }
+
+    public void setFrame(int frame) {
+        this.frame = frame;
+    }
+
+    public int getLevel() {
+        return level;
+    }
+
+    public void setLevel(int level) {
+        this.level = level;
+    }
+
+    public int getPlayerST() {
+        return playerST;
+    }
+
+    public void setPlayerST(int playerST) {
+        this.playerST = playerST;
+    }
+
+    public int getHellLevel() {
+        return hellLevel;
+    }
+
+    public void setHellLevel(int hellLevel) {
+        this.hellLevel = hellLevel;
+    }
+
+    public int getQuestion() {
+        return question;
+    }
+
+    public void setQuestion(int question) {
+        this.question = question;
+    }
+
+    public int getUnionId() {
+        return unionId;
+    }
+
+    public void setUnionId(int unionId) {
+        this.unionId = unionId;
+    }
+
+    public int getServerId() {
+        return serverId;
+    }
+
+    public void setServerId(int serverId) {
+        this.serverId = serverId;
+    }
+
+    public int getVipLevel() {
+        return vipLevel;
+    }
+
+    public void setVipLevel(int vipLevel) {
+        this.vipLevel = vipLevel;