技术栈分析

server:
  # Jetty 默认是非阻塞的，可以处理更多并发请求
  jetty:
    threads:
      acceptors: 4 # acceptors 线程池接受 HTTP 请求
      selectors: 8 # selectors 线程池负责处理 HTTP 消息协议数据包
    	# worker 线程池负责调用 Web 方法
      min: 8
      max: 200
  port: 8092
  servlet:
    context-path: /hospital-api
 
spring:
  datasource:
    driver-class-name: org.apache.phoenix.queryserver.client.Driver
    url: jdbc:phoenix:thin:url=http://192.168.0.120:8765;serialization=PROTOBUF
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      test-on-borrow: true
      test-while-idle: true
      max-active: 8
      min-idle: 4
      validation-query: SELECT 1
 
  servlet:
    multipart:
      enabled: true
      max-file-size: 20MB  # 上传文件不能超过 20M
      max-request-size: 20MB  # HTTP 请求不能超过 20M
 
  redis:
    database: 0
    host: localhost
    port: 6379
    password: abc123456
    jedis:
      pool:
        max-active: 1000
        max-wait: -1ms
        max-idle: 16
        min-idle: 8
 
  quartz:
    job-store-type: memory
 
mybatis:
  mapper-locations: classpath*:mapper/*.xml
  type-aliases-package: com.example.hospital.api.db.pojo
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true
 
logging:
  level:
    root: info
    com.example.hospital.api.db.dao: warn
  pattern:
    console: "%d{yyyy/MM/dd HH:mm:ss}  %-5level  %msg%n"
 
sa-token:
  # HTTP请求头中token的名称
  token-name: token
  # token有效期，单位s 默认30天, -1代表永不过期
  timeout: 2592000
  # token临时有效期 (指定时间内无操作就视为token过期) 单位: 秒
  activity-timeout: -1
  # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
  allow-concurrent-login: true
  # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token)
  is-share: false
  # token风格
  token-style: uuid
  #读取Cookie中Token
  isReadCookie: false
 
wechat:
  app-id: 你的小程序APPID
  app-secret: 你的小程序密钥
  pay:
    v3:
      patient-wx-api:
        app-id: 课程提供的小程序APPID
        app-v3-secret: 课程提供的小程序密钥
        mch-id: 课程提供的商户号
        domain: 内网穿透URL地址
        cert-path: apiclient_cert.p12
 
tencent:
  cloud:
    appId: 你的腾讯云APPID
    secretId: 你的腾讯云secretId
    secretKey: 你的腾讯云secretKey
    face:
      groupName: hospital
      region: ap-beijing
 
minio:
  endpoint: http://云主机IP:9000
  access-key: root
  secret-key: abc123456

package com.example.hospital.api.exception;
 
import lombok.Data;
 
@Data
public class HospitalException extends RuntimeException {
    private String msg;
    private int code = 500;
 
    public HospitalException(Exception e) {
        super(e);
        this.msg = "执行异常";
        this.code = 500;
    }
 
    public HospitalException(String msg) {
        super(msg);
        this.msg = msg;
    }
 
    public HospitalException(String msg, Throwable e) {
        super(msg, e);
        this.msg = msg;
    }
 
    public HospitalException(String msg, int code) {
        super(msg);
        this.msg = msg;
        this.code = code;
    }
 
    public HospitalException(String msg, int code, Throwable e) {
        super(msg, e);
        this.msg = msg;
        this.code = code;
    }
 
}

package com.example.hospital.api.config;
 
import cn.dev33.satoken.exception.NotLoginException;
import cn.felord.payment.PayException;
import cn.hutool.json.JSONObject;
import com.example.hospital.api.exception.HospitalException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.multipart.support.MissingServletRequestPartException;
 
@Slf4j
@RestControllerAdvice
public class ExceptionAdvice {
 
    @ResponseBody
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ExceptionHandler(Exception.class)
    public String exceptionHandler(Exception e) {
        JSONObject json = new JSONObject();
        if (e instanceof HttpMessageNotReadableException) {
            HttpMessageNotReadableException exception = (HttpMessageNotReadableException) e;
            log.error("error",exception);
            json.set("error", "请求未提交数据或者数据有误");
        }
        else if(e instanceof MissingServletRequestPartException){
            MissingServletRequestPartException exception= (MissingServletRequestPartException) e;
            log.error("error",exception);
            json.set("error", "请求提交数据错误");
        }
        //处理后端验证失败产生的异常
        else if (e instanceof MethodArgumentNotValidException) {
            MethodArgumentNotValidException exception = (MethodArgumentNotValidException) e;
            json.set("error", exception.getBindingResult().getFieldError().getDefaultMessage());
        }
        //处理业务异常
        else if (e instanceof HospitalException) {
            log.error("执行异常", e);
            HospitalException exception = (HospitalException) e;
            json.set("error", exception.getMsg());
        }
        else if (e instanceof PayException) {
            PayException exception = (PayException) e;
            log.error("微信支付异常", e);
        }
        //处理其余的异常
        else {
            log.error("执行异常", e);
            json.set("error", "执行异常");
        }
        return json.toString();
    }
 
    @ResponseBody
    @ResponseStatus(HttpStatus.UNAUTHORIZED)
    @ExceptionHandler(NotLoginException.class)
    public String unLoginHandler(Exception e) {
        JSONObject json = new JSONObject();
        json.set("error", e.getMessage());
        return json.toString();
    }
 
}

package com.example.hospital.api.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
 
@Configuration
public class RedisTemplateConfig {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setConnectionFactory(factory);
        return template;
    }
}

package com.example.hospital.api.common;
 
import org.apache.http.HttpStatus;
 
import java.util.HashMap;
import java.util.Map;
 
 
public class R extends HashMap<String, Object> {
 
    public R() {
        put("code", HttpStatus.SC_OK);
        put("msg", "success");
    }
 
    public R put(String key, Object value) {
        super.put(key, value);
        return this;
    }
 
    public static R ok() {
        return new R();
    }
 
    public static R ok(String msg) {
        R r = new R();
        r.put("msg", msg);
        return r;
    }
 
    public static R ok(Map<String, Object> map) {
        R r = new R();
        r.putAll(map);
        return r;
    }
 
    public static R error(int code, String msg) {
        R r = new R();
        r.put("code", code);
        r.put("msg", msg);
        return r;
    }
 
    public static R error(String msg) {
        return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, msg);
    }
 
    public static R error() {
        return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, "未知异常，请联系管理员");
    }
 
}

package com.example.hospital.api.common;
 
import lombok.Data;
import java.io.Serializable;
import java.util.List;
 
@Data
public class PageUtils implements Serializable {
    private static final long serialVersionUID = 1L;
  
    private long totalCount;
    private int pageSize;
    private int totalPage;
    private int pageIndex;
    private List list;
 
    public PageUtils(List list, long totalCount, int pageIndex, int pageSize) {
        this.list = list;
        this.totalCount = totalCount;
        this.pageSize = pageSize;
        this.pageIndex = pageIndex;
        this.totalPage = (int) Math.ceil((double) totalCount / pageSize);
    }
}

@PostMapping("/searchByPage")
@SaCheckLogin
@SaCheckPermission(value = {"ROOT", "DOCTOR:SELECT"}, mode = SaMode.OR)
public R searchByPage(@RequestBody @Valid SearchDoctorByPageForm form) {
    Map param = BeanUtil.beanToMap(form);
    int page = form.getPage();
    int length = form.getLength();
    int start = (page - 1) * length;
    param.put("start", start);
    PageUtils pageUtils = doctorService.searchByPage(param);
    return R.ok().put("result", pageUtils);
}

@Component
public class StpInterfaceImpl implements StpInterface {
    @Resource
    private MisUserDao userDao;
 
    /**
     * 返回一个用户所拥有的权限集合
     */
    @Override
    public List<String> getPermissionList(Object loginId, String loginKey) {
        int userId = Integer.parseInt(loginId.toString());
        ArrayList<String> list = userDao.searchUserPermissions(userId);
        return list;
    }
 
 
    /**
     * 返回一个用户所拥有的角色标识集合
     */
    @Override
    public List<String> getRoleList(Object loginId, String loginKey) {
        return null;
    }
}

SELECT p."permission_code" AS "permission"
FROM HOSPITAL.MIS_USER u
JOIN HOSPITAL.MIS_USER_ROLE ur ON u."id" = ur."user_id"
JOIN HOSPITAL.MIS_ROLE_PERMISSION rp ON rp."role_id" = ur."role_id"
JOIN HOSPITAL.MIS_PERMISSION p ON rp."permission_id" = p."id"
WHERE u."id" = 0;