add 整合 springdoc-openapi-javadoc 基于代码注释生成文档

疯狂的狮子li

2022-07-07 d9e54388e7fde2462e8b7e0165c5e7da3f202593

 ruoyi-demo/src/main/java/com/ruoyi/demo/controller/RedisLockController.java

@@ -1,16 +1,18 @@
package com.ruoyi.demo.controller;

import com.ruoyi.common.annotation.RedisLock;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.redis.RedisLockManager;
import com.baomidou.lock.LockInfo;
import com.baomidou.lock.LockTemplate;
import com.baomidou.lock.annotation.Lock4j;
import com.baomidou.lock.executor.RedissonLockExecutor;
import com.ruoyi.common.core.domain.R;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.TimeUnit;
import java.time.LocalTime;


/**
@@ -18,58 +20,54 @@
 *
 * @author shenxinquan
 */
@Tag(name ="测试分布式锁的样例", description = "测试分布式锁的样例")
@Slf4j
@RestController
@RequestMapping("/demo/redisLock")
public class RedisLockController {

   @Autowired
   private RedisLockManager redisLockManager;
    @Autowired
    private LockTemplate lockTemplate;

   /**
    * #p0 标识取第一个参数为redis锁的key
    */
   @GetMapping("/testLock1")
   @RedisLock(expireTime = 10, key = "#p0")
   public AjaxResult<String> testLock1(String key, String value) {
      try {
         // 同时请求排队
//         Thread.sleep(5000);
         // 锁超时测试
         Thread.sleep(11000);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
      return AjaxResult.success("操作成功",value);
   }
    /**
     * 测试lock4j 注解
     */
    @Lock4j(keys = {"#key"})
    @GetMapping("/testLock4j")
    public R<String> testLock4j(String key, String value) {
        System.out.println("start:" + key + ",time:" + LocalTime.now().toString());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end :" + key + ",time:" + LocalTime.now().toString());
        return R.ok("操作成功", value);
    }

   /**
    * 测试锁工具类
    */
   @GetMapping("/testLock2")
   public AjaxResult<Void> testLock(String key, Long time) {
      try {
         boolean flag = redisLockManager.getLock(key, time, TimeUnit.SECONDS);
         if (flag) {
            log.info("获取锁成功: " + key);
            Thread.sleep(3000);
            redisLockManager.unLock(key);
            log.info("释放锁成功: " + key);
         } else {
            log.error("获取锁失败: " + key);
         }
      } catch (InterruptedException e) {
         log.error(e.getMessage());
      }
      return AjaxResult.success();
   }
    /**
     * 测试lock4j 工具
     */
    @GetMapping("/testLock4jLockTemplate")
    public R<String> testLock4jLockTemplate(String key, String value) {
        final LockInfo lockInfo = lockTemplate.lock(key, 30000L, 5000L, RedissonLockExecutor.class);
        if (null == lockInfo) {
            throw new RuntimeException("业务处理中,请稍后再试");
        }
        // 获取锁成功，处理业务
        try {
            try {
                Thread.sleep(8000);
            } catch (InterruptedException e) {
                //
            }
            System.out.println("执行简单方法1 , 当前线程:" + Thread.currentThread().getName());
        } finally {
            //释放锁
            lockTemplate.releaseLock(lockInfo);
        }
        //结束
        return R.ok("操作成功", value);
    }

   /**
    * 测试spring-cache注解
    */
   @Cacheable(value = "test", key = "#key")
   @GetMapping("/testCache")
   public AjaxResult<String> testCache(String key) {
      return AjaxResult.success("操作成功", key);
   }
}