新建bsoft-api

bsoft-api/pom.xml

@@ -30,6 +30,11 @@
             <scope>test</scope>
         </dependency>
         <dependency>
+            <groupId>org.mybatis.spring.boot</groupId>
+            <artifactId>mybatis-spring-boot-starter</artifactId>
+            <version>2.1.0</version>
+        </dependency>
+        <dependency>
             <groupId>com.bsoft</groupId>
             <artifactId>bsoft-common</artifactId>
             <version>1.0-SNAPSHOT</version>
@@ -39,6 +44,26 @@
             <artifactId>mybatis-spring</artifactId>
             <version>2.0.2</version>
         </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.oracle</groupId>
+            <artifactId>ojdbc6</artifactId>
+            <version>6.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjrt</artifactId>
+            <version>1.9.4</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-configuration-processor</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

bsoft-api/src/main/java/com/bsoft/api/BsoftApiApplication.java

@@ -7,7 +7,7 @@ import org.springframework.context.annotation.ComponentScan;
 
 @SpringBootApplication
 @MapperScan("com.bsoft.api.mapper")
-@ComponentScan(basePackages = {"com.bsoft.common.config.swaggerconfig","com.bsoft.api"})
+@ComponentScan(basePackages = {"com.bsoft.common.config","com.bsoft.api"})
 public class BsoftApiApplication {
 
     public static void main(String[] args) {

bsoft-api/src/main/java/com/bsoft/api/common/Constants.java

+package com.bsoft.api.common;
+
+public interface Constants {
+    String TOKEN_KEY = "Authorization";
+}

bsoft-api/src/main/java/com/bsoft/api/common/Result.java

+package com.bsoft.api.common;
+
+/**
+ * 请求统一返回结果
+ */
+public class Result {
+    private int code;
+    private String msg;
+    private Object data;
+
+    private Result(int code, String msg, Object data) {
+        this.code = code;
+        this.msg = msg;
+        this.data = data;
+    }
+
+    @Override
+    public String toString() {
+        return "{" +
+                "\"code\":" + code +
+                ", \"msg\":\"" + msg + '\"' +
+                ", \"data\":" + data +
+                '}';
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public void setCode(int code) {
+        this.code = code;
+    }
+
+    public String getMsg() {
+        return msg;
+    }
+
+    public void setMsg(String msg) {
+        this.msg = msg;
+    }
+
+    public Object getData() {
+        return data;
+    }
+
+    public void setData(Object data) {
+        this.data = data;
+    }
+
+    public static Result success(Object data){
+        return new Result(ErrorCode.SUCCESS.getCode(), ErrorCode.SUCCESS.getEnMessage(), data);
+    }
+
+    public static Result error(int code, String msg){
+        return new Result(code, msg, null);
+    }
+
+    public static Result error(){
+        return new Result(ErrorCode.ERROR.getCode(), ErrorCode.ERROR.getEnMessage(), null);
+    }
+
+    public static Result error(ErrorCode errorCode){
+        return new Result(errorCode.getCode(), errorCode.getEnMessage(), null);
+    }
+
+    public static enum ErrorCode{
+        SUCCESS(1, "成功", "success"),
+        INVALID_TOKEN(401, "无效的TOKEN", "invalid token"),
+        ERROR(400, "错误", "error");
+        private int code;
+        private String cnMessage;
+        private String enMessage;
+
+        ErrorCode(int code, String cnMessage, String enMessage) {
+            this.code = code;
+            this.cnMessage = cnMessage;
+            this.enMessage = enMessage;
+        }
+
+        public int getCode() {
+            return code;
+        }
+
+        public void setCode(int code) {
+            this.code = code;
+        }
+
+        public String getCnMessage() {
+            return cnMessage;
+        }
+
+        public void setCnMessage(String cnMessage) {
+            this.cnMessage = cnMessage;
+        }
+
+        public String getEnMessage() {
+            return enMessage;
+        }
+
+        public void setEnMessage(String enMessage) {
+            this.enMessage = enMessage;
+        }
+    }
+}

bsoft-api/src/main/java/com/bsoft/api/common/annotations/CurrentUser.java

+package com.bsoft.api.common.annotations;
+
+import java.lang.annotation.*;
+
+/**
+ * 绑定当前用户
+ */
+@Target({ElementType.PARAMETER})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface CurrentUser {
+}

bsoft-api/src/main/java/com/bsoft/api/common/annotations/Token.java

+package com.bsoft.api.common.annotations;
+
+import org.springframework.core.annotation.AliasFor;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Token {
+    @AliasFor("value")
+    boolean required() default true;
+
+    @AliasFor("required")
+    boolean value() default true;
+}

bsoft-api/src/main/java/com/bsoft/api/common/aspect/TokenAspect.java

+package com.bsoft.api.common.aspect;
+
+import com.bsoft.api.common.Constants;
+import com.bsoft.api.common.exceptions.InvalidTokenException;
+import com.bsoft.api.common.utils.StringUtil;
+import com.bsoft.api.common.utils.TokenUtil;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.slf4j.Logger;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Component;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+import javax.servlet.http.HttpServletRequest;
+
+@Aspect
+@Component
+@Order(1)
+public class TokenAspect {
+    @Pointcut("@annotation(com.bsoft.api.common.annotations.Token)")
+    public void tokenAspect(){}
+
+    @Around("tokenAspect()")
+    public Object verifierToken(ProceedingJoinPoint joinPoint) throws Throwable {
+        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
+        String token = request.getHeader(Constants.TOKEN_KEY);
+
+        if(!StringUtil.isNullOrEmpty(token) && TokenUtil.checkToken(token)){
+            return joinPoint.proceed();
+        }
+        String remoteHost = request.getRemoteHost();
+        String uri = request.getRequestURI();
+        Logger logger = org.slf4j.LoggerFactory.getLogger(joinPoint.getTarget().getClass());
+        logger.info(remoteHost + " 访问 " + uri + ", token无效, token：[" + token + "]");
+
+        throw new InvalidTokenException("无效的TOKEN");
+    }
+}

bsoft-api/src/main/java/com/bsoft/api/common/configurations/CurrentUserConfigure.java

+package com.bsoft.api.common.configurations;
+
+import com.bsoft.api.common.resolvers.CurrentUserMethodArgumentResolver;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+import java.util.List;
+
+@Configuration
+public class CurrentUserConfigure implements WebMvcConfigurer {
+    @Override
+    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers){
+        resolvers.add(currentUserMethodArgumentResolver());
+    }
+
+    @Bean
+    public CurrentUserMethodArgumentResolver currentUserMethodArgumentResolver(){
+        return new CurrentUserMethodArgumentResolver();
+    }
+}

bsoft-api/src/main/java/com/bsoft/api/common/configurations/LoginConfigure.java

+package com.bsoft.api.common.configurations;
+
+import com.bsoft.api.common.intercepters.LoginIntercepter;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Configuration
+@ConfigurationProperties(prefix = "config.path")
+public class LoginConfigure implements WebMvcConfigurer {
+    /**
+     * 需要登录的拦截路由
+     */
+    private List<String> include = new ArrayList<>();
+    /**
+     * 排除登录的拦截路由
+     */
+    private List<String> exclude = new ArrayList<>();
+
+    public void setInclude(List<String> include) {
+        this.include = include;
+    }
+
+    public void setExclude(List<String> exclude) {
+        this.exclude = exclude;
+    }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        registry.addInterceptor(loginIntercepter()).addPathPatterns(include).excludePathPatterns(exclude);
+
+        WebMvcConfigurer.super.addInterceptors(registry);
+    }
+
+    @Bean
+    public LoginIntercepter loginIntercepter(){
+        return new LoginIntercepter();
+    }
+}

bsoft-api/src/main/java/com/bsoft/api/common/exceptions/ExceptionBase.java

+package com.bsoft.api.common.exceptions;
+
+public class ExceptionBase extends RuntimeException {
+     public ExceptionBase(){
+         super();
+     }
+
+     public ExceptionBase(String message){
+         super(message);
+     }
+}

bsoft-api/src/main/java/com/bsoft/api/common/exceptions/InvalidTokenException.java

+package com.bsoft.api.common.exceptions;
+
+public class InvalidTokenException extends ExceptionBase {
+    public InvalidTokenException(){
+        super();
+    }
+    public InvalidTokenException(String message){
+        super(message);
+    }
+}

bsoft-api/src/main/java/com/bsoft/api/common/handlers/GlobalExceptionHandler.java

+package com.bsoft.api.common.handlers;
+
+import com.bsoft.api.common.Result;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * 全局异常处理类
+ */
+@ControllerAdvice
+public class GlobalExceptionHandler {
+    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
+
+    /**
+     * 其他异常处理
+     * @param request
+     * @param e
+     * @return
+     */
+    @ExceptionHandler(Exception.class)
+    @ResponseBody
+    public Object defaultErrorHandler(HttpServletRequest request, Exception e){
+        log.error("未知异常:", e.getMessage());
+        return Result.error();
+    }
+
+
+}

bsoft-api/src/main/java/com/bsoft/api/common/intercepters/LoginIntercepter.java

+package com.bsoft.api.common.intercepters;
+
+import com.bsoft.api.common.Constants;
+import com.bsoft.api.common.Result;
+import com.bsoft.api.common.utils.TokenUtil;
+import org.slf4j.Logger;
+import org.springframework.web.servlet.HandlerInterceptor;
+import org.springframework.web.servlet.ModelAndView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.PrintWriter;
+
+public class LoginIntercepter implements HandlerInterceptor {
+    Logger logger = org.slf4j.LoggerFactory.getLogger(LoginIntercepter.class);
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        System.out.println("LoginIntercepter----------->preHandle");
+
+        String token = request.getHeader(Constants.TOKEN_KEY);
+        if(!TokenUtil.checkToken(token)){
+            response.setCharacterEncoding("UTF-8");
+            response.setContentType("application/json; charset=utf-8");
+            PrintWriter writer = null;
+            try {
+                String remoteHost = request.getRemoteHost();
+                String uri = request.getRequestURI();
+                logger.info(remoteHost + " 访问 " + uri + ", token无效, token：[" + token + "]");
+
+                writer = response.getWriter();
+                writer.print(Result.error(Result.ErrorCode.INVALID_TOKEN));
+            }catch (IOException e){
+                logger.error(e.getMessage());
+            }finally {
+                if(writer != null){
+                    writer.close();
+                }
+            }
+            return false;
+        }
+
+        return HandlerInterceptor.super.preHandle(request, response, handler);
+    }
+
+    @Override
+    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
+        System.out.println("LoginIntercepter----------->postHandle");
+
+
+
+        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
+    }
+
+    @Override
+    public void afterCompletion(HttpServletRequest request,
+             HttpServletResponse response, Object handler, Exception ex) throws Exception {
+        System.out.println("LoginIntercepter------->afterCompletion");
+
+
+        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
+    }
+}

bsoft-api/src/main/java/com/bsoft/api/common/resolvers/CurrentUserMethodArgumentResolver.java

+package com.bsoft.api.common.resolvers;
+
+import com.bsoft.api.common.Constants;
+import com.bsoft.api.common.annotations.CurrentUser;
+import com.bsoft.api.common.utils.TokenUtil;
+import com.bsoft.api.model.SysUser;
+import com.bsoft.common.utils.RedisUtil;
+import org.springframework.core.MethodParameter;
+import org.springframework.web.bind.support.WebDataBinderFactory;
+import org.springframework.web.context.request.NativeWebRequest;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.method.support.ModelAndViewContainer;
+
+public class CurrentUserMethodArgumentResolver implements HandlerMethodArgumentResolver {
+    @Override
+    public boolean supportsParameter(MethodParameter methodParameter) {
+        return methodParameter.hasParameterAnnotation(CurrentUser.class);
+    }
+
+    @Override
+    public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer,
+                                  NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory) {
+        String token = nativeWebRequest.getHeader(Constants.TOKEN_KEY);
+        if(TokenUtil.checkToken(token)){
+            return RedisUtil.get(token);
+        }
+        return null;
+    }
+}

bsoft-api/src/main/java/com/bsoft/api/common/utils/StringUtil.java

+package com.bsoft.api.common.utils;
+
+public class StringUtil {
+    public static boolean isNullOrEmpty(String str){
+        return str == null || str.isEmpty();
+    }
+
+    public static boolean isNullOrBlank(String str){
+        return str == null || str.trim().isEmpty();
+    }
+}

bsoft-api/src/main/java/com/bsoft/api/common/TokenUtil.java → bsoft-api/src/main/java/com/bsoft/api/common/utils/TokenUtil.java

-package com.bsoft.api.common;
+package com.bsoft.api.common.utils;
 
 import com.bsoft.api.model.SysUser;
 import com.bsoft.common.utils.JWTUtil;
 import com.bsoft.common.utils.RedisUtil;
 
 public class TokenUtil {
-
     public final static long TOKEN_TIME_OUT = 2L * 60 * 60;
     public final static long OLD_TOKEN_DURATION = 5L * 60;
 
     /**
      * 获取token，并将token存入redis
-     * @param secret
-     * @param user
-     * @return
+     * @param secret 密码
+     * @param user 用户信息
+     * @return token
      */
     public static String getToken(String secret, SysUser user){
         String time = String.valueOf(System.currentTimeMillis());
-        String token = JWTUtil.createTokenWithAudience(secret, time, String.valueOf(user.getId()));
+        String token = JWTUtil.create(secret, time, String.valueOf(user.getId()));
         RedisUtil.set(token, user, TOKEN_TIME_OUT);
         return token;
     }
 
     /**
      * 刷新token，并将旧token设置过期时间为5分钟
-     * @param oldToken
-     * @return
+     * @param oldToken 旧的token
+     * @return 新的token
      */
     public static String refresh(String oldToken){
         String token = null;
         SysUser user = (SysUser) RedisUtil.get(oldToken);
-        if(user != null && JWTUtil.verifier(oldToken, user.getPassword())){
+        if(checkToken(oldToken)){
             RedisUtil.expire(oldToken, OLD_TOKEN_DURATION);
-            String time = String.valueOf(System.currentTimeMillis());
-            token = JWTUtil.createTokenWithAudience(user.getPassword(),time, String.valueOf(user.getId()));
+            token = getToken(user.getPassword(), user);
         }
         return token;
     }
+
+    /**
+     * 校验token
+     * @param token token
+     * @return 返回校验结果
+     */
+    public static boolean checkToken(String token){
+        SysUser user = (SysUser) RedisUtil.get(token);
+        return user != null && JWTUtil.verifier(token, user.getPassword());
+    }
 }

bsoft-api/src/main/java/com/bsoft/api/controller/LoginController.java

 package com.bsoft.api.controller;
 
+import com.bsoft.api.common.Result;
 import com.bsoft.api.service.LoginService;
 import io.swagger.annotations.*;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
+import springfox.documentation.annotations.ApiIgnore;
+
+import javax.servlet.http.HttpServletRequest;
 
 @RestController
-@RequestMapping("login")
-@Api(tags = {"登录"},produces="aa",description = "111")
+@RequestMapping()
+@Api(tags = {"登录"})
 public class LoginController {
 
     @Autowired
     private LoginService loginServiceImpl;
 
-    @PostMapping
+    @PostMapping("login")
     @ApiOperation("登录")
     @ApiImplicitParams({
         @ApiImplicitParam(value = "登录名", name="loginName", required=true,paramType="query"),
-        @ApiImplicitParam(value = "验证码", name="code", required = true,paramType="query")})
+        @ApiImplicitParam(value = "密码", name="password", required = true,paramType="query")})
     public Object login(String loginName, String password){
-        return 1;
+        LoginService.LoginInfo loginInfo = loginServiceImpl.login(loginName, password);
+        return Result.success(loginInfo);
     }
 
-
+    @GetMapping("token")
+    @ApiOperation("刷新TOKEN")
+    public Object refresh(@ApiIgnore HttpServletRequest request){
+        String oldToken = request.getHeader("Authorization");
+        String token = loginServiceImpl.refreshToken(oldToken);
+        return Result.success(token);
+    }
 }

bsoft-api/src/main/java/com/bsoft/api/controller/UserController.java

 package com.bsoft.api.controller;
 
+import com.bsoft.api.common.Result;
+import com.bsoft.api.common.annotations.CurrentUser;
+import com.bsoft.api.model.SysUser;
 import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiImplicitParam;
-import io.swagger.annotations.ApiImplicitParams;
-import io.swagger.annotations.ApiOperation;
 import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
+import springfox.documentation.annotations.ApiIgnore;
 
 
 @Api(tags = "用户API",produces="produces",consumes="consumes",protocols="protocols")
@@ -15,4 +15,8 @@ import org.springframework.web.bind.annotation.RestController;
 @RestController
 public class UserController {
 
+    @GetMapping()
+    public Object user(@CurrentUser@ApiIgnore SysUser user){
+        return Result.success(user);
+    }
 }

bsoft-api/src/main/java/com/bsoft/api/service/Impl/LoginServiceImpl.java

 package com.bsoft.api.service.Impl;
 
-import com.bsoft.api.common.TokenUtil;
+import com.bsoft.api.common.utils.TokenUtil;
 import com.bsoft.api.model.SysUser;
 import com.bsoft.api.service.LoginService;
 import com.bsoft.api.service.UserService;

bsoft-api/src/main/resources/application-dev.properties

@@ -4,5 +4,28 @@ jdbc.username=ll
 jdbc.password=123456
 jdbc.driverClass=com.mysql.jdbc.Driver
 
+spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
+spring.datasource.username=ll
+spring.datasource.password=123456
+spring.datasource.url=jdbc:oracle:thin:@192.168.18.171:1521:his
+
+# Redis\u6570\u636E\u5E93\u7D22\u5F15\uFF08\u9ED8\u8BA40\uFF09
+spring.redis.database=1
+spring.redis.host=192.168.18.55
+spring.redis.port=6379
+spring.redis.password=ll123456
+spring.redis.jedis.pool.max-active=8
+# \u8FDE\u63A5\u6C60\u6700\u5927\u963B\u585E\u7B49\u5F85\u65F6\u95F4\uFF08\u4F7F\u7528\u8D1F\u503C\u8868\u793A\u6CA1\u6709\u9650\u5236\uFF09
+spring.redis.jedis.pool.max-wait=-1
+# \u8FDE\u63A5\u6C60\u4E2D\u7684\u6700\u5927\u7A7A\u95F2\u8FDE\u63A5
+spring.redis.jedis.pool.max-idle=8
+# \u8FDE\u63A5\u6C60\u4E2D\u7684\u6700\u5C0F\u7A7A\u95F2\u8FDE\u63A5
+spring.redis.jedis.pool.min-idle=0
+# \u8FDE\u63A5\u8D85\u65F6\u65F6\u95F4\uFF08\u6BEB\u79D2\uFF09
+spring.redis.timeout=10000
+
+logging.path=/log/
+logging.file=${logging.path}info.log
+
 swagger.enabled=true
 swagger.basePackage=com.bsoft.api.controller
\ No newline at end of file

bsoft-api/src/main/resources/application.properties

 spring.profiles.active=dev
+server.servlet.context-path=/api
+mybatis.mapper-locations=classpath:mapper/*.xml
+mybatis.type-aliases-package=com.bsoft.api.model
+
+
+config.path.include[0]=/token
+config.path.include[1]=/user/**
+config.path.exclude[0]=/login
\ No newline at end of file

bsoft-api/src/test/java/com/bsoft/api/BsoftApiApplicationTests.java

+package com.bsoft.api;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class BsoftApiApplicationTests {
+
+    @Test
+    public void contextLoads() {
+    }
+
+}

bsoft-api/src/test/resources/generatorConfig.xml

+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
+        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
+
+<generatorConfiguration>
+    <!-- 引入配置文件 -->
+    <properties resource="./application-dev.properties"/>
+
+    <context id="Mysql" targetRuntime="MyBatis3Simple" defaultModelType="flat">
+        <property name="beginningDelimiter" value="`"/>
+        <property name="endingDelimiter" value="`"/>
+        <!-- 生成的文件编码 -->
+        <property name="javaFileEncoding" value="utf-8"/>
+        <!-- 通过自定义插件类生成自定义注解和接口 -->
+        <!--<plugin type="com.suvalue.common.GenPlugin">-->
+        <!--<property enName="mappers" value="com.suvalue.demo.mapper.BaseMapper"/>-->
+        <!--</plugin>-->
+        <commentGenerator>
+            <property name="suppressAllComments" value="true"/>
+        </commentGenerator>
+        <!-- 数据库连接属性 -->
+        <jdbcConnection driverClass="${spring.datasource.driver-class-name}"
+                        connectionURL="${spring.datasource.url}"
+                        userId="${spring.datasource.username}"
+                        password="${spring.datasource.password}">
+            <!-- 针对oracle数据库 获取字段注释 -->
+            <!--<property enName="remarksReporting" value="true"></property>-->
+            <!-- 针对mysql数据库 获取字段注释 -->
+            <property name="useInformationSchema" value="true"></property>
+        </jdbcConnection>
+        <!-- 生成实体类配置 -->
+        <javaModelGenerator targetPackage="com.bsoft.api.model" targetProject="src/main/java"/>
+        <!-- 生成映射文件配置 -->
+        <sqlMapGenerator targetPackage="mapper" targetProject="src/main/resources"/>
+        <!-- 生成映射接口配置 -->
+        <javaClientGenerator targetPackage="com.bsoft.api.mapper" targetProject="src/main/java" type="XMLMAPPER"/>
+
+        <table tableName="sys_user">
+            <generatedKey column="id" sqlStatement="Mysql" identity="true"/>
+        </table>
+    </context>
+    <!--<context id="sqlserver" targetRuntime="MyBatis3Simple" defaultModelType="flat">-->
+    <!--<property enName="beginningDelimiter" value="["/>-->
+    <!--<property enName="endingDelimiter" value="]"/>-->
+    <!--&lt;!&ndash; 生成的文件编码 &ndash;&gt;-->
+    <!--<property enName="javaFileEncoding" value="utf-8"/>-->
+    <!--&lt;!&ndash; 通过自定义插件类生成自定义注解和接口 &ndash;&gt;-->
+    <!--&lt;!&ndash;<plugin type="com.suvalue.common.GenPlugin">&ndash;&gt;-->
+    <!--&lt;!&ndash;<property enName="mappers" value="com.suvalue.demo.mapper.BaseMapper"/>&ndash;&gt;-->
+    <!--&lt;!&ndash;</plugin>&ndash;&gt;-->
+    <!--<commentGenerator>-->
+    <!--&lt;!&ndash; 取消生成注释 &ndash;&gt;-->
+    <!--<property enName="suppressAllComments" value="false"/>-->
+    <!--</commentGenerator>-->
+    <!--&lt;!&ndash; 数据库连接属性 &ndash;&gt;-->
+    <!--<jdbcConnection driverClass="${jdbc.sqlserver.driver}"-->
+    <!--connectionURL="${jdbc.sqlserver.url}"-->
+    <!--userId="${jdbc.sqlserver.username}"-->
+    <!--password="${jdbc.sqlserver.password}">-->
+    <!--</jdbcConnection>-->
+    <!--&lt;!&ndash; 生成实体类配置 &ndash;&gt;-->
+    <!--<javaModelGenerator targetPackage="com.suvalue.verctrl.model" targetProject="src/main/java"/>-->
+    <!--&lt;!&ndash; 生成映射文件配置 &ndash;&gt;-->
+    <!--<sqlMapGenerator targetPackage="mapper" targetProject="src/main/resources"/>-->
+    <!--&lt;!&ndash; 生成映射接口配置 &ndash;&gt;-->
+    <!--&lt;!&ndash;<javaClientGenerator targetPackage="com.suvalue.verctrl.mapper" targetProject="src/main/java" type="XMLMAPPER"/>&ndash;&gt;-->
+
+    <!--<table tableName="data_version" schema="dbo">-->
+    <!--&lt;!&ndash;mysql 配置 &ndash;&gt;-->
+    <!--<generatedKey column="id" sqlStatement="SqlServer" identity="true"/>-->
+    <!--</table>-->
+    <!--</context>-->
+</generatorConfiguration>

bsoft-api/src/test/resources/jdbc.properties

+jdbc.url=jdbc:mysql://192.168.18.55:3306/db_appointment?useUnicode=true&characterEncoding=utf8&useSSL=false&autoReconnect=true&rewriteBatchedStatements=TRUE
+jdbc.username=ll
+jdbc.password=123456
+jdbc.driverClass=com.mysql.jdbc.Driver
\ No newline at end of file

bsoft-common/pom.xml

@@ -37,5 +37,11 @@
             <artifactId>java-jwt</artifactId>
             <version>3.4.0</version>
         </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 </project>
\ No newline at end of file

bsoft-common/src/main/java/com/bsoft/common/utils/JWTUtil.java

@@ -5,33 +5,67 @@ import com.auth0.jwt.JWTVerifier;
 import com.auth0.jwt.algorithms.Algorithm;
 import com.auth0.jwt.exceptions.JWTVerificationException;
 
+import java.util.Date;
 import java.util.List;
 
 public class JWTUtil {
-    public static String createToken(String password){
-        String token="";
-        token= JWT.create().sign(Algorithm.HMAC256(password));
+    /**
+     * 生成token
+     * @param sign 签名
+     * @return
+     */
+    public static String create(String sign){
+        String token= JWT.create().sign(Algorithm.HMAC256(sign));
         return token;
     }
 
-    public static String createTokenWithAudience(String sign, String... audiences){
-        String token="";
+    /**
+     * 生成token并添加用户信息
+     * @param sign 前面
+     * @param audiences 用户信息
+     * @return
+     */
+    public static String create(String sign, String... audiences){
+        String token= JWT.create().withAudience(audiences)
+                .sign(Algorithm.HMAC256(sign));
+        return token;
+    }
 
-        token= JWT.create().withAudience(audiences)
+    /**
+     * 生成token并添加用户信息
+     * @param sign 签名
+     * @param expires 过期时间（毫秒）
+     * @param audiences 用户信息
+     * @return
+     */
+    public static String create(String sign, long expires, String... audiences){
+        Date expiresDate = new Date(System.currentTimeMillis() +  expires);
+        String token= JWT.create().withAudience(audiences).withExpiresAt(expiresDate)
                 .sign(Algorithm.HMAC256(sign));
         return token;
     }
 
+    /**
+     * 获取用户信息
+     * @param token
+     * @return
+     */
     public static List<String> getAudience(String token){
         return JWT.decode(token).getAudience();
     }
 
-    public static boolean verifier(String token, String scret){
-        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(scret)).build();
+    /**
+     * 校验token
+     * @param token
+     * @param sign
+     * @return
+     */
+    public static boolean verifier(String token, String sign){
+        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(sign)).build();
         try {
             jwtVerifier.verify(token);
         } catch (JWTVerificationException e) {
-            throw new RuntimeException("401");
+            return false;
         }
         return true;
     }

bsoft-common/src/main/java/com/bsoft/common/utils/RedisUtil.java

@@ -10,7 +10,7 @@ import java.util.concurrent.TimeUnit;
 
 
 /**
- * Redis缓存工具类，若要使用该工具类，请在启动类加上注解，扫描包com.suvalue.boot.common.config
+ * Redis缓存工具类，若要使用该工具类，扫描包com.suvalue.boot.common.config
  */
 public class RedisUtil {
     private static RedisTemplate redisTemplate;

suvalue-boot-demo/suvalue-boot-demo-api/src/main/resources/application.properties

 spring.profiles.active=dev
 #mybatis.mapper-locations=classpath:mapper/*.xml
-#mybatis.type-aliases-package=com.suvalue.example.suvaluebootdemoapi.Model
+#mybatis.type-aliases-package=com.suvalue.example.suvaluebootdemoapi.model