java复制代码/**
 * 公式解析引擎
 * <p>
 * Created by songzhaoying on 2020/8/11 14:44.
 *
 * @author songzhaoying@com.
 * @date 2020/8/11 14:44.
 */
public class CalculatorNewUtil {

    private static final Logger logger = LoggerFactory.getLogger(CalculatorNewUtil.class);

    /**
     * 表达式字符合法性校验正则模式
     */
    private static final String EXPRESSION_PATTERN_REGEX = "[0-9\\.\\+\\-\\*\\/\\\(\\)_%Ee\\s]+";

    /**
     * 判断数字正则
     */
    private static final String NUM_REGEX = "\d+(\\.)?\\d*((E|e|E\\+|e\\+|E-|e-)\\d+)?";

    /**
     * 操作符 需要加 空格
     * ((|)|+|-|*|/|_|%)
     */
    private static final String ADD_SPACE_REGEX = "((\\d+.?\\d*[Ee]([+\\-])?\\d+)|([()+\\-*/_%]))";

    /**
     * 空格
     */
    private static final String SPACE = "\\s";

    /**
     * 计算中保留小数位数
     */
    private static final int CAL_SCALE_SIZE = 10;

    /**
     * 计算中保留小数位数 处理原则
     */
    private static final int CAL_SCALE_ROUND = BigDecimal.ROUND_HALF_DOWN;

    /**
     * 保留小数
     *
     * @param calExpressionStr
     * @param scaleSize
     * @param bigRoundType
     * @return
     * @throws Exception
     */
    public static BigDecimal executeExpression(String calExpressionStr, int scaleSize, int bigRoundType) throws Exception {
        return executeExpression(calExpressionStr).setScale(scaleSize, bigRoundType);
    }

    /**
     * 计算值 10 位小数 0 去掉
     *
     * @param calExpressionStr
     * @return
     * @throws Exception
     */
    public static BigDecimal executeExpression(String calExpressionStr) throws Exception {
        return new BigDecimal(calculate(calExpressionStr).stripTrailingZeros().toPlainString());
    }

    /**
     * 计算 中序 字符串
     *
     * @param calExpressionStr
     * @return
     */
    public static BigDecimal calculate(String calExpressionStr) throws Exception {
        calExpressionStr = check2RepairExpression(calExpressionStr);

        List<String> inorderExpressionList = getInorderExpressionList(calExpressionStr);

        // 生成 逆波兰 表达式 list
        List<String> suffixExpressionList = getSuffixExpressionList(inorderExpressionList);

        if (logger.isDebugEnabled()) {
            logger.info("中序表达式：{}", JsonUtil.writeValueAsString(inorderExpressionList));
            logger.info("后缀表达式：{}", JsonUtil.writeValueAsString(suffixExpressionList));
        }

        return calculate(suffixExpressionList);
    }

    /**
     * 生成中序表达式 list
     *
     * @param calExpressionStr
     * @return
     */
    private static List<String> getInorderExpressionList(String calExpressionStr) {
        // 生成 中序表达式 list
        return Arrays.stream(calExpressionStr.split(SPACE))
                .filter(StringUtils::isNotBlank)
                .collect(Collectors.toList());
    }

    /**
     * 计算 逆波兰 / 后序表达式 List
     *
     * @param suffixExpressionList
     * @return
     */
    private static BigDecimal calculate(List<String> suffixExpressionList) throws Exception {
        if (CollectionUtils.isEmpty(suffixExpressionList)) {
            return BigDecimal.ZERO;
        }

        Stack<BigDecimal> numStack = new Stack<>();

        for (String op2num : suffixExpressionList) {
            if (StringUtils.isBlank(op2num)) {
                continue;
            }
            // 使用正则表达式取出
            if (isNumber(op2num)) {
                // 数字
                numStack.push(new BigDecimal(op2num));
            } else {
                // 运算符
                OptEnum opEnum = OptEnum.getEnum(op2num);
                if (opEnum.getCalFunction() == null) {
                    throw new RuntimeException("操作符不支持！");
                }

                BigDecimal bigDecimal2 = numStack.pop();
                BigDecimal bigDecimal1 = numStack.pop();

                BigDecimal resultBigDecimal = opEnum.getCalFunction().apply(bigDecimal1, bigDecimal2);

                // 结果入栈
                numStack.push(resultBigDecimal);
            }
        }

        return numStack.pop();
    }

    /**
     * 生成逆波兰 / 后续表达式 list
     *
     * @param inorderExpressionList
     * @return
     */
    private static List<String> getSuffixExpressionList(List<String> inorderExpressionList) {
        Stack<String> opStack = new Stack<>();

        // 不通过中间栈，在进行逆序处理，直接输出到list中，就是需要的逆波兰表达式
        List<String> resList = new ArrayList<>(inorderExpressionList.size());
        for (String op2num : inorderExpressionList) {
            if (isNumber(op2num)) {
                // 数字
                resList.add(op2num);
            } else if (Objects.equals(op2num, OptEnum.OP_LEFT_BRACKET.getOpt())) {
                // (
                opStack.push(op2num);
            } else if (Objects.equals(op2num, OptEnum.OP_RIGHT_BRACKET.getOpt())) {
                // )
                while (!opStack.peek().equals(OptEnum.OP_LEFT_BRACKET.getOpt())) {
                    resList.add(opStack.pop());
                }
                // 去掉 (
                opStack.pop();
            } else {
                // 操作符 优先级
                while (!CollectionUtils.isEmpty(opStack)
                        && OptEnum.getEnum(opStack.peek()).getOptPriority() >= OptEnum.getEnum(op2num).getOptPriority()) {
                    resList.add(opStack.pop());
                }
                // 将 操作符 最后加入
                opStack.push(op2num);
            }
        }

        // 处理剩余的操作符
        while (!CollectionUtils.isEmpty(opStack)) {
            resList.add(opStack.pop());
        }

        return resList;
    }

    /**
     * 判断是否数字
     *
     * @param numberStr
     * @return
     */
    public static boolean isNumber(String numberStr) {
        if (numberStr == null) {
            return false;
        }
        return numberStr.matches(NUM_REGEX);
    }

    /**
     * 运算符 枚举
     */
    public enum OptEnum {
        /**
         * 运算符
         */
        OP_LEFT_BRACKET("(", "左括号", 0, null),
        OP_RIGHT_BRACKET(")", "右括号", 7, null),

        OP_ADD("+", "加", 2, (p1, p2) -> p1.add(p2)),
        OP_SUB("-", "减", 2, (p1, p2) -> p1.subtract(p2)),
        OP_MULTIPLY("*", "乘", 3, (p1, p2) -> p1.multiply(p2)),
        OP_DIVIDE("/", "除", 3, (p1, p2) -> p1.divide(p2, CAL_SCALE_SIZE, CAL_SCALE_ROUND)),

        OP_FLOOR("_", "取整", 3, (p1, p2) -> p1.divide(p2, 0, BigDecimal.ROUND_DOWN)),
        OP_MODE("%", "取模", 3, (p1, p2) -> p1.divideAndRemainder(p2)[1]),

        ;

        /**
         * 运算符
         */
        private String opt;

        /**
         * 运算说明
         */
        private String optName;

        /**
         * 运算级别
         */
        private Integer optPriority;

        /**
         * 运算 函数
         */
        private BiFunction<BigDecimal, BigDecimal, BigDecimal> calFunction;

        /**
         * @param opt
         * @param optName
         * @param optPriority
         * @param biFunction
         */
        OptEnum(String opt, String optName, Integer optPriority
                , BiFunction<BigDecimal, BigDecimal, BigDecimal> biFunction) {
            this.opt = opt;
            this.optName = optName;
            this.optPriority = optPriority;
            this.calFunction = biFunction;
        }

        /**
         * 取枚举
         *
         * @param opt
         * @return
         */
        protected static OptEnum getEnum(String opt) {
            return Stream.of(OptEnum.values())
                    .filter(t -> Objects.equals(opt, t.getOpt()))
                    .findFirst().orElseThrow(() -> new RuntimeException("运算符不支持"));
        }

        public String getOpt() {
            return opt;
        }

        public String getOptName() {
            return optName;
        }

        public Integer getOptPriority() {
            return optPriority;
        }

        public BiFunction<BigDecimal, BigDecimal, BigDecimal> getCalFunction() {
            return calFunction;
        }
    }

    /**
     * 校验 & 整理字符串
     * 科学计数处理
     *
     * @param calExpressionStr
     * @return
     */
    private static String check2RepairExpression(String calExpressionStr) {
        // 非空校验
        if (StringUtils.isBlank(calExpressionStr)) {
            throw new IllegalArgumentException("表达式不能为空！");
        }

        // 表达式字符合法性校验
        if (!calExpressionStr.matches(EXPRESSION_PATTERN_REGEX)) {
            throw new IllegalArgumentException("表达式含有非法字符！" + calExpressionStr);
        }

        // 整理字符串
        calExpressionStr = calExpressionStr.replaceAll(SPACE, "");

        // (- 替换为 (0-
        calExpressionStr = calExpressionStr.replace(OptEnum.OP_LEFT_BRACKET.getOpt() + OptEnum.OP_SUB.getOpt()
                , OptEnum.OP_LEFT_BRACKET.getOpt() + BigDecimal.ZERO + OptEnum.OP_SUB.getOpt());

        // - 开始 前缀 0-
        if (calExpressionStr.startsWith(OptEnum.OP_SUB.getOpt())) {
            calExpressionStr = BigDecimal.ZERO + calExpressionStr;
        }

        calExpressionStr = calExpressionStr.replaceAll(ADD_SPACE_REGEX, " $1 ").trim();

        if (logger.isDebugEnabled()) {
            logger.info("整理后的运算串：{}", calExpressionStr);
        }

        return calExpressionStr;
    }


    public static void main(String[] args) throws Exception {
        String str = "3.E+3 \n* 2";
        boolean number = isNumber("3.E+3");

        BigDecimal bigDecimal = executeExpression(str);

        System.out.println(bigDecimal);

        System.out.println(executeExpression("-1 + (-1) + 2"));
        System.out.println(executeExpression(" 2 + 13/3 * 3 - 4 *(2 + 5 -2*4/2+9) + 3 + (2*1)-3"));
        System.out.println(executeExpression("330000000000*121000000000000000000000000000"
                , 4, BigDecimal.ROUND_HALF_UP));

        System.out.println(executeExpression("9.2 *(20-1)-1+199 / 13"
                , 4, BigDecimal.ROUND_HALF_UP));
        System.out.println(executeExpression("9.2 *(20-1)-1+199 / 13"));
        System.out.println(executeExpression("11"));
    }
}

sql复制代码delimiter $$
create procedure select_all() begin select * from user; end;$$

sql复制代码mysql>  call select_all;$$

sql复制代码DECLARE cursor_name CURSOR FOR select_statement

sql复制代码OPEN cursor_name;

sql复制代码FETCH cursor_name INTO var_name [, var_name]...

sql复制代码CLOSE cursor_name;

sql复制代码DEALLOCATE cursor_name;

sql复制代码CREATE TABLE cursor_table
(id INT ,name VARCHAR(10),age INT
)ENGINE=innoDB DEFAULT CHARSET=utf8;
insert into cursor_table values(1, '张三', 500);
insert into cursor_table values(2, '李四', 200);
insert into cursor_table values(3, '王五', 100);
insert into cursor_table values(4, '老六', 20);


create table cursor_table_user(name varchar(10));

sql复制代码drop procedure getTotal;
delete from cursor_table_user ;

CREATE  PROCEDURE getTotal()
BEGIN  
   DECLARE total INT; 
   DECLARE sid INT;  
   DECLARE sname VARCHAR(10);  
   DECLARE sage INT;  
   DECLARE done INT DEFAULT false;  
   DECLARE cur CURSOR FOR SELECT id,name,age from cursor_table where age>30;  
   DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = true;   
   SET total = 0;  
   OPEN cur;  
   FETCH cur INTO sid, sname, sage;  
   WHILE(NOT done) 
   DO  
       insert cursor_table_user values(sname);
       SET total = total + 1;  
       FETCH cur INTO sid, sname, sage;  
       
   END WHILE;  
   CLOSE cur;  
   SELECT total;  
END

sql复制代码call getTotal();

mysql> select * from cursor_table_user;
+--------+
| name   |
+--------+
| 张三   |
| 李四   |
| 王五   |
+--------+
3 rows in set (0.00 sec)

json复制代码{
  "name" : "DESKTOP-V4GSUJH",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "4tnI-jAtTXqXbMDJ8CVRjQ",
  "version" : {
    "number" : "7.12.1",
    "build_flavor" : "default",
    "build_type" : "zip",
    "build_hash" : "3186837139b9c6b6d23c3200870651f10d3343b7",
    "build_date" : "2021-04-20T20:56:39.040728659Z",
    "build_snapshot" : false,
    "lucene_version" : "8.8.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

java复制代码elasticsearch
    bin      :可执行文件。我们用来启动elasticsearch的脚本就在这里面
    config   :elastic-search的全局设置和你的具体设置，如果你需要更改JVM，数据路径，日志路径等，就需                要改这里。同时端口设置等也都在这里。
    data     :你的索引数据，即你存放具体用来搜索数据的地方
    jdk      :自带的JDK，不重要可忽略
    lib      :存放源码jar包
    logs     :存放一些日志文件
    modules  :自带的一些模块，不可删除。比如x-pack模块等（对我们学习不重要，可忽略）
    plugins  :放置插件的地方，比如第三方的分词器等

bash复制代码npm install  // 安装插件
npm run start  // 启动插件

json复制代码GET _analyze
{
  "analyzer": "ik_smart",
  "text": ["我是好学生"]
}

GET _analyze
{
  "analyzer": "ik_max_word",
  "text": ["我是好学生"]
}

bash复制代码GET _cat/indices?v

json复制代码{
 "user": "张三",
 "title": "工程师",
 "desc": "数据库管理"
}

bash复制代码GET _mapping?pretty=true

json复制代码PUT /test1/_doc/1
{
  "name": "老王",
  "age": 18
}

json复制代码PUT /test2
{
  "mappings": {
    "properties": {
      "name": {
        "type": "text"
      },
      "age": {
        "type": "long"
      }
    }
  }
}

json复制代码GET _cat/plugins

json复制代码PUT /test1/_doc/1
{
  "name": "老王",
  "age": 19
}

json复制代码POST /test1/_doc/1/_update
{
  "doc":{
    "age": 20
  }
}

bash复制代码GET accounts/person/_search
{
  "took":2,
  "timed_out":false,
  "_shards":{"total":5,"successful":5,"failed":0},
  "hits":{
    "total":2,
    "max_score":1.0,
    "hits":[
      {
        "_index":"accounts",
        "_type":"person",
        "_id":"AV3qGfrC6jMbsbXb6k1p",
        "_score":1.0,
        "_source": {
          "user": "李四",
          "title": "工程师",
          "desc": "系统管理"
        }
      },
      {
        "_index":"accounts",
        "_type":"person",
        "_id":"1",
        "_score":1.0,
        "_source": {
          "user" : "张三",
          "title" : "工程师",
          "desc" : "数据库管理，软件开发"
        }
      }
    ]
  }
}

bash复制代码GET accounts/person/_search
{
  "query" : { "match" : { "desc" : "软件" }}
}

json复制代码{
  "took":3,
  "timed_out":false,
  "_shards":{"total":5,"successful":5,"failed":0},
  "hits":{
    "total":1,
    "max_score":0.28582606,
    "hits":[
      {
        "_index":"accounts",
        "_type":"person",
        "_id":"1",
        "_score":0.28582606,
        "_source": {
          "user" : "张三",
          "title" : "工程师",
          "desc" : "数据库管理，软件开发"
        }
      }
    ]
  }
}

bash复制代码GET accounts/person/_search
{
  "query" : { "match" : { "desc" : "管理" }},
  "size": 1
}

bash复制代码GET accounts/person/_search
{
  "query" : { "match" : { "desc" : "管理" }},
  "from": 1,
  "size": 1
}

bash复制代码GET accounts/person/_search
{
  "query" : { "match" : { "desc" : "软件 系统" }}
}

bash复制代码GET accounts/person/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "desc": "软件" } },
        { "match": { "desc": "系统" } }
      ]
    }
  }
}

php复制代码<?php
/**
 * Author: 柯作
 * Email: kezuo@foxmail.com
 * Date: 2021/9/2
 * Time: 11:15
 */

namespace app\api\controller;


use app\Request;

class Audit
{

    /**
     * 内容审核
     */
    public function contentAudit(Request $request)
    {
        $content = $request->post('content');
        $token = $this->getAccessToken('API Key', 'Secret Key');

        $url = 'https://aip.baidubce.com/rest/2.0/solution/v1/text_censor/v2/user_defined?access_token=' . $token;
        $bodys = array(
            'text' => $content
        );
        $res = $this->curlPost($url, $bodys);

        //结果转成数组
        $res = json_decode($res, true);
        //根据自己的业务逻辑进行处理
        print_r($res);die;
    }

    /**
     * 图片审核
     */
    public function imageAudit()
    {

        $token = $this->getAccessToken('API Key', 'Secret Key');
        $url = 'https://aip.baidubce.com/rest/2.0/solution/v1/img_censor/v2/user_defined?access_token=' . $token;
        $img = file_get_contents('C:\Users\Pictures\Saved Pictures\1.png');
        $img = base64_encode($img);
        $bodys = array(
            'image' => $img
        );
        $res = $this->curlPost($url, $bodys);
        //结果转成数组
        $res = json_encode($res, true);
        //根据自己的业务逻辑进行处理
        print_r($res);
    }

    /**
     * CURL的Post请求方法
     * @param string $url
     * @param string $param
     * @return bool|string
     */
    function curlPost($url = '', $param = '')
    {
        if (empty($url) || empty($param)) {
            return false;
        }

        $postUrl = $url;
        $curlPost = $param;
        // 初始化curl
        $curl = curl_init();
        curl_setopt($curl, CURLOPT_URL, $postUrl);
        curl_setopt($curl, CURLOPT_HEADER, 0);
        // 要求结果为字符串且输出到屏幕上
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
        curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
        // post提交方式
        curl_setopt($curl, CURLOPT_POST, 1);
        curl_setopt($curl, CURLOPT_POSTFIELDS, $curlPost);
        // 运行curl
        $data = curl_exec($curl);
        curl_close($curl);

        return $data;
    }

    /**
     * 获取百度开放平台的票据
     * 参考链接：https://ai.baidu.com/ai-doc/REFERENCE/Ck3dwjhhu
     */
    public function getAccessToken($ApiKey = '', $SecretKey = '', $grantType = 'client_credentials')
    {

        $url = 'https://aip.baidubce.com/oauth/2.0/token';
        $post_data['grant_type'] = $grantType;
        $post_data['client_id'] = $ApiKey;
        $post_data['client_secret'] = $SecretKey;
        $o = "";
        foreach ($post_data as $k => $v) {
            $o .= "$k=" . urlencode($v) . "&";
        }
        $post_data = substr($o, 0, -1);

        $res = $this->curlPost($url, $post_data);
        //进行把返回结果转成数组
        $res = json_decode($res, true);
        if (isset($res['error'])) {
            exit('API Key或者Secret Key不正确');
        }
        $accessToken = $res['access_token'];
        return $accessToken;
    }
}

复制代码略

bash复制代码# step 1: 安装必要的一些系统工具
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
# Step 2: 添加软件源信息
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# Step 3
sudo sed -i 's+download.docker.com+mirrors.aliyun.com/docker-ce+' /etc/yum.repos.d/docker-ce.repo
# Step 4: 更新并安装Docker-CE
sudo yum makecache fast
sudo yum -y install docker-ce
# Step 4: 开启Docker服务
sudo systemctl enable docker --now

javascript复制代码cat > /etc/docker/daemon.json << EOF
{
    "registry-mirrors": [
    	"https://mirror.ccs.tencentyun.com"
    ],
    "log-driver":"local",
    "log-opts": {
    	"max-size": "10m",
    	"max-file": "3"
    }
}
EOF

service docker restart

复制代码docker -v

ini复制代码Starting a MySQL instance is simple:
$ docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

Where to Store Data
$ docker run --name some-mysql -v /my/own/datadir:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

# 还有很多关于配置文件如何挂载，和一些环境变量，详细的Dockerfile也可以查看，此处只取最常用的一些

复制代码docker pull mysql:latest

复制代码docker images

bash复制代码docker run -d --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -v /root/mysql-data:/var/lib/mysql mysql:latest

复制代码docker ps

bash复制代码docker exec -it mysql bash
mysql -uroot -p
# 输入密码：123456
show databases;

java复制代码// 在登录时写入当前会话的账号id
StpUtil.login(10001);

// 然后在需要校验登录处调用以下方法：
// 如果当前会话未登录，这句代码会抛出 `NotLoginException` 异常
StpUtil.checkLogin();

java复制代码@SaCheckPermission("user:add")
@RequestMapping("/user/insert")
public String insert(SysUser user) {
	// ...
	return "用户增加";
}

java复制代码// 使账号id为 10001 的会话强制注销登录
StpUtil.logoutByLoginId(10001);

java复制代码StpUtil.login(10001);   // 标记当前会话登录的账号id
StpUtil.getLoginId();   // 获取当前会话登录的账号id
StpUtil.isLogin();   // 获取当前会话是否已经登录, 返回true或false
StpUtil.logout();   // 当前会话注销登录
StpUtil.logoutByLoginId(10001);   // 让账号为10001的会话注销登录（踢人下线）
StpUtil.hasRole("super-admin");   // 查询当前账号是否含有指定角色标识, 返回true或false
StpUtil.hasPermission("user:add");   // 查询当前账号是否含有指定权限, 返回true或false
StpUtil.getSession();   // 获取当前账号id的Session
StpUtil.getSessionByLoginId(10001);   // 获取账号id为10001的Session
StpUtil.getTokenValueByLoginId(10001);   // 获取账号id为10001的token令牌值
StpUtil.login(10001, "PC");   // 指定设备标识登录，常用于“同端互斥登录”
StpUtil.logoutByLoginId(10001, "PC");   // 指定设备标识进行强制注销 (不同端不受影响)
StpUtil.openSafe(120);   // 在当前会话开启二级认证，有效期为120秒
StpUtil.checkSafe();   // 校验当前会话是否处于二级认证有效期内，校验失败会抛出异常
StpUtil.switchTo(10044);   // 将当前会话身份临时切换为其它账号

java复制代码/**
 * Sa-Token-SSO Server端 Controller 
 */
@RestController
public class SsoServerController {
    // SSO-Server端：处理所有SSO相关请求 
    @RequestMapping("/sso/*")
    public Object ssoRequest() {
        return SaSsoHandle.serverRequest();
    }
}

java复制代码/**
 * Sa-Token-OAuth2.0 Server端 Controller 
 */
@RestController
public class SaOAuth2ServerController {
    // SSO-Server端：处理所有SSO相关请求 
    @RequestMapping("/oauth2/*")
    public Object request() {
        return SaSsoHandle.serverRequest();
    }
}

xml复制代码<dependencies>
   <!-- Sa-Token 权限认证（Reactor响应式集成） -->
   <dependency>
       <groupId>cn.dev33</groupId>
       <artifactId>sa-token-reactor-spring-boot-starter</artifactId>
       <version>1.24.0</version>
   </dependency>
   <!-- Sa-Token 整合 Redis (使用jackson序列化方式) -->
   <dependency>
       <groupId>cn.dev33</groupId>
       <artifactId>sa-token-dao-redis-jackson</artifactId>
       <version>1.24.0</version>
   </dependency>
   <!-- 提供Redis连接池 -->
   <dependency>
       <groupId>org.apache.commons</groupId>
       <artifactId>commons-pool2</artifactId>
   </dependency>
   <!-- micro-sa-token通用依赖 -->
   <dependency>
       <groupId>com.macro.cloud</groupId>
       <artifactId>micro-sa-token-common</artifactId>
       <version>1.0.0</version>
   </dependency>
</dependencies>

yaml复制代码spring:
  redis:
    database: 0
    port: 6379
    host: localhost
    password:

# Sa-Token配置
sa-token:
  # token名称 (同时也是cookie名称)
  token-name: Authorization
  # token有效期，单位秒，-1代表永不过期
  timeout: 2592000
  # token临时有效期 (指定时间内无操作就视为token过期)，单位秒
  activity-timeout: -1
  # 是否允许同一账号并发登录 (为false时新登录挤掉旧登录)
  is-concurrent: true
  # 在多人登录同一账号时，是否共用一个token (为false时每次登录新建一个token)
  is-share: false
  # token风格
  token-style: uuid
  # 是否输出操作日志
  is-log: false
  # 是否从cookie中读取token
  is-read-cookie: false
  # 是否从head中读取token
  is-read-head: true

java复制代码@Configuration
public class SaTokenConfig {
    /**
     * 注册Sa-Token全局过滤器
     */
    @Bean
    public SaReactorFilter getSaReactorFilter() {
        return new SaReactorFilter()
                // 拦截地址
                .addInclude("/**")
                // 开放地址
                .addExclude("/favicon.ico")
                // 鉴权方法：每次访问进入
                .setAuth(r -> {
                    // 登录认证：除登录接口都需要认证
                    SaRouter.match("/**", "/auth/user/login", StpUtil::checkLogin);
                    // 权限认证：不同接口访问权限不同
                    SaRouter.match("/api/test/hello", () -> StpUtil.checkPermission("api:test:hello"));
                    SaRouter.match("/api/user/info", () -> StpUtil.checkPermission("api:user:info"));
                })
                // setAuth方法异常处理
                .setError(e -> {
                    // 设置错误返回格式为JSON
                    ServerWebExchange exchange = SaReactorSyncHolder.getContent();
                    exchange.getResponse().getHeaders().set("Content-Type", "application/json; charset=utf-8");
                    return SaResult.error(e.getMessage());
                });
    }
}

java复制代码/**
 * 自定义权限验证接口扩展
 */
@Component
public class StpInterfaceImpl implements StpInterface {

    @Override
    public List<String> getPermissionList(Object loginId, String loginType) {
        // 返回此 loginId 拥有的权限码列表
        UserDTO userDTO = (UserDTO) StpUtil.getSession().get("userInfo");
        return userDTO.getPermissionList();
    }

    @Override
    public List<String> getRoleList(Object loginId, String loginType) {
        // 返回此 loginId 拥有的角色码列表
        return null;
    }

}

xml复制代码<dependencies>
    <!-- Sa-Token 权限认证 -->
    <dependency>
        <groupId>cn.dev33</groupId>
        <artifactId>sa-token-spring-boot-starter</artifactId>
        <version>1.24.0</version>
    </dependency>
    <!-- Sa-Token 整合 Redis （使用jackson序列化方式） -->
    <dependency>
        <groupId>cn.dev33</groupId>
        <artifactId>sa-token-dao-redis-jackson</artifactId>
        <version>1.24.0</version>
    </dependency>
    <!-- 提供Redis连接池 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
    <!-- micro-sa-token通用依赖 -->
    <dependency>
        <groupId>com.macro.cloud</groupId>
        <artifactId>micro-sa-token-common</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

yaml复制代码spring:
  redis:
    database: 0
    port: 6379
    host: localhost
    password:

# Sa-Token配置
sa-token:
  # token名称 (同时也是cookie名称)
  token-name: Authorization
  # token有效期，单位秒，-1代表永不过期
  timeout: 2592000
  # token临时有效期 (指定时间内无操作就视为token过期)，单位秒
  activity-timeout: -1
  # 是否允许同一账号并发登录 (为false时新登录挤掉旧登录)
  is-concurrent: true
  # 在多人登录同一账号时，是否共用一个token (为false时每次登录新建一个token)
  is-share: false
  # token风格
  token-style: uuid
  # 是否输出操作日志
  is-log: false
  # 是否从cookie中读取token
  is-read-cookie: false
  # 是否从head中读取token
  is-read-head: true

java复制代码/**
 * 自定义Oauth2获取令牌接口
 * Created by macro on 2020/7/17.
 */
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserServiceImpl userService;

    @RequestMapping(value = "/login", method = RequestMethod.POST)
    public CommonResult login(@RequestParam String username, @RequestParam String password) {
        SaTokenInfo saTokenInfo = userService.login(username, password);
        if (saTokenInfo == null) {
            return CommonResult.validateFailed("用户名或密码错误");
        }
        Map<String, String> tokenMap = new HashMap<>();
        tokenMap.put("token", saTokenInfo.getTokenValue());
        tokenMap.put("tokenHead", saTokenInfo.getTokenName());
        return CommonResult.success(tokenMap);
    }
}

java复制代码/**
 * 用户管理业务类
 * Created by macro on 2020/6/19.
 */
@Service
public class UserServiceImpl{

    private List<UserDTO> userList;

    public SaTokenInfo login(String username, String password) {
        SaTokenInfo saTokenInfo = null;
        UserDTO userDTO = loadUserByUsername(username);
        if (userDTO == null) {
            return null;
        }
        if (!SaSecureUtil.md5(password).equals(userDTO.getPassword())) {
            return null;
        }
        // 密码校验成功后登录，一行代码实现登录
        StpUtil.login(userDTO.getId());
        // 将用户信息存储到Session中
        StpUtil.getSession().set("userInfo",userDTO);
        // 获取当前登录用户Token信息
        saTokenInfo = StpUtil.getTokenInfo();
        return saTokenInfo;
    }
}

xml复制代码<dependencies>
    <!-- Sa-Token 权限认证 -->
    <dependency>
        <groupId>cn.dev33</groupId>
        <artifactId>sa-token-spring-boot-starter</artifactId>
        <version>1.24.0</version>
    </dependency>
    <!-- Sa-Token 整合 Redis （使用jackson序列化方式） -->
    <dependency>
        <groupId>cn.dev33</groupId>
        <artifactId>sa-token-dao-redis-jackson</artifactId>
        <version>1.24.0</version>
    </dependency>
    <!-- 提供Redis连接池 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
    <!-- micro-sa-token通用依赖 -->
    <dependency>
        <groupId>com.macro.cloud</groupId>
        <artifactId>micro-sa-token-common</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

yaml复制代码spring:
  redis:
    database: 0
    port: 6379
    host: localhost
    password:

# Sa-Token配置
sa-token:
  # token名称 (同时也是cookie名称)
  token-name: Authorization
  # token有效期，单位秒，-1代表永不过期
  timeout: 2592000
  # token临时有效期 (指定时间内无操作就视为token过期)，单位秒
  activity-timeout: -1
  # 是否允许同一账号并发登录 (为false时新登录挤掉旧登录)
  is-concurrent: true
  # 在多人登录同一账号时，是否共用一个token (为false时每次登录新建一个token)
  is-share: false
  # token风格
  token-style: uuid
  # 是否输出操作日志
  is-log: false
  # 是否从cookie中读取token
  is-read-cookie: false
  # 是否从head中读取token
  is-read-head: true

java复制代码/**
 * 获取登录用户信息接口
 * Created by macro on 2020/6/19.
 */
@RestController
@RequestMapping("/user")
public class UserController{

    @GetMapping("/info")
    public CommonResult<UserDTO> userInfo() {
        UserDTO userDTO = (UserDTO) StpUtil.getSession().get("userInfo");
        return CommonResult.success(userDTO);
    }

}

java复制代码/**
 * 测试接口
 * Created by macro on 2020/6/19.
 */
@RestController
@RequestMapping("/test")
public class TestController {

    @GetMapping("/hello")
    public CommonResult hello() {
        return CommonResult.success("Hello World.");
    }

}