提交遗漏文件, druid版本降回

pom.xml

@@ -58,7 +58,7 @@
         <dependency>
             <groupId>org.mybatis.spring.boot</groupId>
             <artifactId>mybatis-spring-boot-starter</artifactId>
-            <version>2.0.1</version>
+            <version>2.0.0</version>
         </dependency>
         <dependency>
             <groupId>mysql</groupId>
@@ -74,7 +74,7 @@
         <dependency>
             <groupId>com.baomidou</groupId>
             <artifactId>mybatis-plus-boot-starter</artifactId>
-            <version>3.1.2</version>
+            <version>3.1.0</version>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
@@ -100,14 +100,14 @@
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>druid</artifactId>
-            <version>1.1.18</version>
+            <version>1.1.17</version>
         </dependency>
 
         <!-- https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter -->
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>druid-spring-boot-starter</artifactId>
-            <version>1.1.18</version>
+            <version>1.1.17</version>
         </dependency>
         <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
         <dependency>

src/main/java/com/lanren/huhu/partner/config/RedissonConfig.java

+package com.lanren.huhu.partner.config;
+
+import com.lanren.huhu.partner.service.impl.RedissonLockService;
+import com.lanren.huhu.partner.util.LockUtil;
+import org.redisson.Redisson;
+import org.redisson.api.RedissonClient;
+import org.redisson.config.Config;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.io.IOException;
+
+/**
+ * @author chen
+ * @title: RedissonConfig
+ * @projectName partner
+ * @description: TODO
+ * @package com.lanren.huhu.partner.config
+ * @date 2019-07-01 19:41
+ */
+@Configuration
+public class RedissonConfig {
+    @Value("${spring.redis.host}")
+    private String host;
+    @Value("${spring.redis.port}")
+    private String port;
+    @Value("${spring.redis.password}")
+    private String password;
+
+    /**
+     * RedissonClient,单机模式
+     * @return
+     * @throws IOException
+     */
+    @Bean(destroyMethod = "shutdown")
+    public RedissonClient redisson() throws IOException {
+        Config config = new Config();
+        config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
+        return Redisson.create(config);
+    }
+
+    @Bean
+    public RedissonLockService redissonLocker(RedissonClient redissonClient){
+        RedissonLockService locker = new RedissonLockService(redissonClient);
+        //设置LockUtil的锁处理对象
+        try{
+            LockUtil.setLockService(locker);
+        } catch (Exception e) {
+            System.out.println("redissonLocker failed");
+            System.out.println(e.getMessage());
+        }
+        return locker;
+    }
+}

src/main/java/com/lanren/huhu/partner/service/LockService.java

+package com.lanren.huhu.partner.service;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author chen
+ * @title: LockService
+ * @projectName partner
+ * @description: 锁接口
+ * @package com.lanren.huhu.partner.service
+ * @date 2019-07-01 19:37
+ */
+public interface LockService {
+    /**
+     * 获取锁，如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。
+     *
+     * @param lockKey
+     */
+    void lock(String lockKey);
+
+    /**
+     * 释放锁
+     *
+     * @param lockKey
+     */
+    void unlock(String lockKey);
+
+    /**
+     * 获取锁,如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。如果获取到锁后，执行结束后解锁或达到超时时间后会自动释放锁
+     *
+     * @param lockKey
+     * @param timeout
+     */
+    void lock(String lockKey, int timeout);
+
+    /**
+     * 获取锁,如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。如果获取到锁后，执行结束后解锁或达到超时时间后会自动释放锁
+     *
+     * @param lockKey
+     * @param unit
+     * @param timeout
+     */
+    void lock(String lockKey, TimeUnit unit, int timeout);
+
+    /**
+     * 尝试获取锁，获取到立即返回true,未获取到立即返回false
+     *
+     * @param lockKey
+     * @return
+     */
+    boolean tryLock(String lockKey);
+
+    /**
+     * 尝试获取锁，在等待时间内获取到锁则返回true,否则返回false,如果获取到锁，则要么执行完后程序释放锁，
+     * 要么在给定的超时时间leaseTime后释放锁
+     *
+     * @param lockKey
+     * @param waitTime
+     * @param leaseTime
+     * @param unit
+     * @return
+     */
+    boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit)
+            throws InterruptedException;
+
+    /**
+     * 锁是否被任意一个线程锁持有
+     *
+     * @param lockKey
+     * @return
+     */
+    boolean isLocked(String lockKey);
+}

src/main/java/com/lanren/huhu/partner/service/impl/RedissonLockService.java

+package com.lanren.huhu.partner.service.impl;
+
+import com.lanren.huhu.partner.service.LockService;
+import org.redisson.api.RLock;
+import org.redisson.api.RedissonClient;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author chen
+ * @title: RedissonLockService
+ * @projectName partner
+ * @description: 基于redisson的锁实现
+ * @package com.lanren.huhu.partner.service.impl
+ * @date 2019-07-01 19:38
+ */
+public class RedissonLockService implements LockService {
+
+    private RedissonClient redissonClient;
+
+    public RedissonLockService(RedissonClient redissonClient) {
+        super();
+        this.redissonClient = redissonClient;
+    }
+
+    @Override
+    public void lock(String lockKey) {
+        RLock lock = redissonClient.getLock(lockKey);
+        lock.lock();
+    }
+
+    @Override
+    public void unlock(String lockKey) {
+        RLock lock = redissonClient.getLock(lockKey);
+        lock.unlock();
+    }
+
+    @Override
+    public void lock(String lockKey, int leaseTime) {
+        RLock lock = redissonClient.getLock(lockKey);
+        lock.lock(leaseTime, TimeUnit.SECONDS);
+    }
+
+    @Override
+    public void lock(String lockKey, TimeUnit unit, int timeout) {
+        RLock lock = redissonClient.getLock(lockKey);
+        lock.lock(timeout, unit);
+    }
+
+    public void setRedissonClient(RedissonClient redissonClient) {
+        this.redissonClient = redissonClient;
+    }
+
+    @Override
+    public boolean tryLock(String lockKey) {
+        RLock lock = redissonClient.getLock(lockKey);
+        return lock.tryLock();
+    }
+
+    @Override
+    public boolean tryLock(String lockKey, long waitTime, long leaseTime,
+                           TimeUnit unit) throws InterruptedException{
+        RLock lock = redissonClient.getLock(lockKey);
+        return lock.tryLock(waitTime, leaseTime, unit);
+    }
+
+    @Override
+    public boolean isLocked(String lockKey) {
+        RLock lock = redissonClient.getLock(lockKey);
+        return lock.isLocked();
+    }
+}

src/main/java/com/lanren/huhu/partner/util/LockUtil.java

+package com.lanren.huhu.partner.util;
+
+import com.lanren.huhu.partner.service.LockService;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author chen
+ * @title: LockUtil
+ * @projectName partner
+ * @description: 分布式锁工具类
+ * @package com.lanren.huhu.partner.util
+ * @date 2019-07-01 19:39
+ */
+public class LockUtil {
+    private static LockService lockService;
+
+    /**
+     * 设置工具类使用的locker
+     * @param lockService
+     */
+    public static void setLockService(LockService lockService) {
+        LockUtil.lockService = lockService;
+    }
+
+    /**
+     * 获取锁
+     * @param lockKey
+     */
+    public static void lock(String lockKey) {
+        try {
+            lockService.lock(lockKey);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 释放锁
+     * @param lockKey
+     */
+    public static void unlock(String lockKey) {
+        lockService.unlock(lockKey);
+    }
+
+    /**
+     * 获取锁，超时释放
+     * @param lockKey
+     * @param timeout
+     */
+    public static void lock(String lockKey, int timeout) {
+        lockService.lock(lockKey, timeout);
+    }
+
+    /**
+     * 获取锁，超时释放，指定时间单位
+     * @param lockKey
+     * @param unit
+     * @param timeout
+     */
+    public static void lock(String lockKey, TimeUnit unit, int timeout) {
+        lockService.lock(lockKey, unit, timeout);
+    }
+
+    /**
+     * 尝试获取锁，获取到立即返回true,获取失败立即返回false
+     * @param lockKey
+     * @return
+     */
+    public static boolean tryLock(String lockKey) {
+        return lockService.tryLock(lockKey);
+    }
+
+    /**
+     * 尝试获取锁，在给定的waitTime时间内尝试，获取到返回true,获取失败返回false,获取到后再给定的leaseTime时间超时释放
+     * @param lockKey
+     * @param waitTime
+     * @param leaseTime
+     * @param unit
+     * @return
+     * @throws InterruptedException
+     */
+    public static boolean tryLock(String lockKey, long waitTime, long leaseTime,
+                                  TimeUnit unit) throws InterruptedException {
+        return lockService.tryLock(lockKey, waitTime, leaseTime, unit);
+    }
+
+    /**
+     * 锁释放被任意一个线程持有
+     * @param lockKey
+     * @return
+     */
+    public static boolean isLocked(String lockKey) {
+        return lockService.isLocked(lockKey);
+    }
+}