springboot spring-data- jpa 分布式锁 ：亲测有效

本篇以spring-data- jpa 实现分布式锁为例讲解spring-data- jpa 的使用

SpringBoot基于数据库实现简单的分布式锁 - 简书  我在这篇博客的基础上进行的优化，共处理了三个bug
1.@Transactional(rollbackFor = Throwable.class) 要去掉。
2. save方法要进行tyr catch ，因这里是有可能报错的
3. LockDO 要加乐观锁 @Version
 

依赖：

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>

数据库配置

#sql链接参数
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/duidui?charset=utf8mb4&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456
#连接池配置
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
# JPA 配置
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql=true
# 上生产时必须去掉
spring.jpa.hibernate.ddl-auto=create

DO:

package XX.XX.model;


import lombok.Data;
import javax.persistence.*;
import java.util.Date;

@Data
@Entity
@Table(name = "dataexchange_LockInfo",
        uniqueConstraints={@UniqueConstraint(columnNames={"tag"},name = "uk_tag")})
public class LockDO {

    public final static Integer LOCKED_STATUS = 1;
    public final static Integer UNLOCKED_STATUS = 0;

    /**
     * 主键id
     */
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    /**
     * 锁的标示，以订单为例，可以锁订单id
     */
    @Column(nullable = false)
    private String tag;

    /**
     * 过期时间
     */
    @Column(nullable = false)
    private Date expirationTime;

    /**
     * 锁状态，0，未锁，1，已经上锁
     */
    @Column(nullable = false)
    private Integer status;

    @Version
    private  int version;

    public LockDO(String tag, Date expirationTime, Integer status) {
        this.tag = tag;
        this.expirationTime = expirationTime;
        this.status = status;
    }

    public LockDO() {
    }
}

DAO

package XXX.dao;


import org.springframework.data.jpa.repository.JpaRepository;
import paas.dao.model.LockDO;


public interface LockRepository extends JpaRepository<LockDO, Long> {

    LockDO findByTag(String tag);

    void deleteByTag(String tag);
}

 LockService 

package XXX.XX.XX;

public interface LockService {

    /**
     * 尝试获取锁
     * @param tag 锁的键
     * @param expiredSeconds 锁的过期时间（单位：秒），默认10s
     * @return
     */
    boolean tryLock(String tag, Integer expiredSeconds);

    /**
     * 释放锁
     * @param tag 锁的键
     */
    void unlock(String tag);
}

LockServiceImpl 

package XX.XXX;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import paas.dao.LockRepository;
import paas.dao.model.LockDO;
import paas.dataExchange.Channel.LockService;

import java.util.Calendar;
import java.util.Date;
import java.util.Objects;

@Service
public class LockServiceImpl implements LockService {
    private final Integer DEFAULT_EXPIRED_SECONDS = 10;

    @Autowired

    private LockRepository lockRepository;

    @Override
    public boolean tryLock(String tag, Integer expiredSeconds) {
        if (StringUtils.isEmpty(tag)) {
            throw new NullPointerException();
        }
        LockDO lock = lockRepository.findByTag(tag);
        if (Objects.isNull(lock)) {
            lockRepository.save(new LockDO(tag, this.addSeconds(new Date(), expiredSeconds), LockDO.LOCKED_STATUS));
            return true;
        } else {
            Date expiredTime = lock.getExpirationTime();
            Date now = new Date();
            if (expiredTime.before(now)) {
                lock.setExpirationTime(this.addSeconds(now, expiredSeconds));
                  try {
                    lockRepository.save(lock);
                }catch (Exception e){
                    return false;
                }
                return true;
            }
        }
        return false;
    }

    @Override
    @Transactional(rollbackFor = Throwable.class)
    public void unlock(String tag) {
        if (StringUtils.isEmpty(tag)) {
            throw new NullPointerException();
        }
        lockRepository.deleteByTag(tag);
    }

    private Date addSeconds(Date date, Integer seconds) {
        if (Objects.isNull(seconds)){
            seconds = DEFAULT_EXPIRED_SECONDS;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.SECOND, seconds);
        return calendar.getTime();
    }
}

使用

        try {
            //如果没有获取到所，则说明其它程序正在执行这个任务，在本线程中直接跳过这个任务
            boolean b = lockService.tryLock(String.valueOf(taskDO.getTaskID()), 300);
            if(b){
              //TODO 
            }

        } catch (Exception e) {
            //TODO 
        }finally {
            lockService.unlock(String.valueOf(taskDO.getTaskID()));
        }

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication(scanBasePackages = "xx")
@EnableJpaRepositories("xx.dao")
@EntityScan("xx.dao.model")
public class WebApiApplication {

    public static void main(String[] args)  {
        SpringApplication.run(WebApiApplication.class, args);
    }

}

这是我在别人的基础上优化后的代码，我将其中的bug进行了修复，本人用20个线程测试了10000个任务，目前没有发现bug