SpringBoot+Redis 从HelloWorld到分布式锁

最新推荐文章于 2024-07-12 16:35:20 发布
最新推荐文章于 2024-07-12 16:35:20 发布
阅读量95 收藏
点赞数
文章标签： 数据库 java runtime
原文链接：https://my.oschina.net/u/3551926/blog/1786237
版权

1.Redis简单安装启动

下载reids最新稳定版本

wget http://download.redis.io/releases/redis-4.0.8.tar.gz

 解压

tar xzf redis-4.0.8.tar.gz

 编译

cd redis-4.0.8
make

 启动Reids服务

src/redis-server

 启动完成示意图

113558_mwYp_3551926.png

当然这里什么都没配置，重点是怎么去实现redis分布式锁。

 

2.SpringBoot与Redis整合

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.example</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>demo</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.0.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>


</project>

这里用到了aop+web+devtool+redis+lombok

简单的配置文件

application.yml

spring:
  redis:
    host: 192.168.1.113
    port: 6379
    password: test123

这里只用了最简介的配置，关于连接池数量，超时配置，指定数据库等等配置信息均使用系统默认。

附：reids密码的设置

刚刚安装的redis是没有密码的，如何设置密码

执行，连接到客户端（cli==> command line interface）

src/redis-cli

设置密码

config set requirepass test123

查询密码

config get requirepass

会提示(error) ERR operation not permitted，没有操作权限

校验密码

auth test123

这时就有操作权限了，密码就设置成功了。

3.实现一个简单的Hello World!

编写一个简单的Redis服务

package com.example.demo.service;

public interface IRedisService {
    String get(String key);
    void set(String key, Object val);
    <T> T get(String key, Class<T> cls);
}

服务实现

package com.example.demo.service.impl;

import com.example.demo.service.IRedisService;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class IRedisServiceImpl implements IRedisService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    @Override
    public String get(String key) {
        return get(key, String.class);
    }

    @Override
    public void set(String key, Object val) {
        redisTemplate.opsForValue().set(key, val);
    }

    @Override
    @SuppressWarnings({"unchecked", "ConstantConditions"})
    public <T> T get(String key, Class<T> cls) {
        Object val = redisTemplate.opsForValue().get(key);
        if (val==null){
            return null;
        }
        if (val.getClass().isAssignableFrom(cls)) {
            return (T) val;
        }
        throw new IllegalArgumentException();
    }
}

写一个控制器做一个简单测试

package com.example.demo.controller;

import com.example.demo.service.IRedisService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;

@Controller
public class RedisController {
    private final static Logger logger = LoggerFactory.getLogger(RedisController.class);
    @Resource
    private IRedisService iRedisService;

    @GetMapping("/get")
    @ResponseBody
    public String test() {
        return iRedisService.get("hello");
    }

    @GetMapping("/set")
    @ResponseBody
    public String set() {
        iRedisService.set("hello", "world");
        return "Set Ok!";
    }
}

到这里SpringBoot已经与Redis完美整合了，下一步通过AOP实现Redis分布式事物锁。

原理参考：https://my.oschina.net/u/3551926/blog/1600167

4实现Redis分布式事物锁

1.完善redis服务

package com.example.demo.service;

public interface IRedisService {
    Boolean setnx(String key, Object val);
    Object getset(String key, Object val);
    Boolean del(String key);
    String get(String key);
    void set(String key, Object val);
    <T> T get(String key, Class<T> cls);
}

 

package com.example.demo.service.impl;

import com.example.demo.service.IRedisService;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class IRedisServiceImpl implements IRedisService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public Boolean setnx(String key, Object val) {
        return redisTemplate.opsForValue().setIfAbsent(key, val);
    }

    @Override
    public Object getset(String key, Object val) {
        return redisTemplate.opsForValue().getAndSet(key, val);
    }

    @Override
    public Boolean del(String key) {
        return redisTemplate.delete(key);
    }

    @Override
    public String get(String key) {
        return get(key, String.class);
    }

    @Override
    public void set(String key, Object val) {
        redisTemplate.opsForValue().set(key, val);
    }

    @Override
    @SuppressWarnings({"unchecked", "ConstantConditions"})
    public <T> T get(String key, Class<T> cls) {
        Object val = redisTemplate.opsForValue().get(key);
        if (val==null){
            return null;
        }
        if (val.getClass().isAssignableFrom(cls)) {
            return (T) val;
        }
        throw new IllegalArgumentException();
    }
}

加入必要的方法

2.AOP实现注解方法拦截

package com.example.demo.annotions;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RedisSync {
    //方法执行超时时间（默认2秒）
    long timeout() default 2000;
    //等待执行时间(默认0.05秒)
    int waitTime() default 50;
}

 

package com.example.demo.aop;

import com.example.demo.annotions.RedisSync;
import com.example.demo.service.IRedisService;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.lang.reflect.Method;
import java.util.Objects;

@Aspect
@Component
public class RedisSyncAop {
    private static final Logger logger = LoggerFactory.getLogger(RedisSyncAop.class);
    @Resource
    private IRedisService iRedisService;

    @Pointcut("@annotation(com.example.demo.annotions.RedisSync)")
    private void anyMethod(){
    }

    @Around("anyMethod()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Object result = null;
        //获得锁
        Method method = ((MethodSignature)pjp.getSignature()).getMethod();
        String key = method.toString();
        RedisSync redisSync = method.getAnnotation(RedisSync.class);
        long waitTime = redisSync.waitTime();
        long currTime = System.currentTimeMillis();
        Boolean state = iRedisService.setnx(key, currTime);
        long saveTime = 0L;
        while (!state) {
            Long tempSaveTime = iRedisService.get(key, Long.class);
            //锁被释放
            if (tempSaveTime==null) {
                state = iRedisService.setnx(key, currTime);
                continue;
            }
            //锁被重新获取
            if (!tempSaveTime.equals(saveTime)){
                currTime = System.currentTimeMillis();
                saveTime=tempSaveTime;
            }
            //判断是否超时
            if (saveTime+redisSync.timeout()<currTime) {
                //超时，直接获得锁
                Object tempTime = iRedisService.getset(key, currTime);
                if(tempTime==null){
                    state = iRedisService.setnx(key, currTime);
                    continue;
                }
                //判断锁被是否被释放或未被抢先获取
                if (Objects.equals(saveTime, tempTime)) {
                    logger.warn("方法：{}，执行超时，已被强制解锁！", key);
                    break;
                }
            }
            //等待
            if(waitTime>0) {
                try {
                    Thread.sleep(waitTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            state = iRedisService.setnx(key, currTime);
        }
        //执行
        result = pjp.proceed();
        Long currSaveTime = iRedisService.get(key, Long.class);
        //判断锁未被判定为超时
        if (currSaveTime!=null && Objects.equals(currSaveTime, currTime)) {
            //释放锁
            iRedisService.del(key);
        }
        return result;
    }
}

 

加入测试服务

package com.example.demo.service;

public interface SyncService {
    int getIndex();
}

 

package com.example.demo.service.impl;

import com.example.demo.annotions.RedisSync;
import com.example.demo.service.SyncService;
import org.springframework.stereotype.Service;

import java.util.Random;

@Service
public class SyncServiceImpl implements SyncService {
    private static int COUNT = 100;
    private static final Random RANDOM = new Random();
    @Override
    @RedisSync(waitTime = 0)
    public int getIndex() {
        try {
            //随机获取等待时间（该时间仅供参考，准确时间还需加上代码执行时间）
            long time = 500+RANDOM.nextInt(3000);
            System.out.println("COUNT("+COUNT+")，sleep:"+time);
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (COUNT<=0) {
            return 0;
        }
        return COUNT--;
    }
}

 

通过控制器创建3个线程直接测试

package com.example.demo.controller;

import com.example.demo.service.IRedisService;
import com.example.demo.service.SyncService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;

@Controller
public class RedisController {
    private final static Logger logger = LoggerFactory.getLogger(RedisController.class);
    @Resource
    private IRedisService iRedisService;
    @Resource
    private SyncService syncService;

    @GetMapping("/get")
    @ResponseBody
    public String test() {
        return iRedisService.get("hello");
    }

    @GetMapping("/set")
    @ResponseBody
    public String set() {
        iRedisService.set("hello", "world");
        return "Set Ok!";
    }

    @GetMapping("/sync")
    @ResponseBody
    public String sync() {
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println(syncService.getIndex());
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println(syncService.getIndex());
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println(syncService.getIndex());
            }
        }).start();
        return String.valueOf(syncService.getIndex());
    }
}

 

到此一个简单的Redis分布式事物锁就完成了。

源码地址：https://github.com/makejavas/Redis-sync

转载于:https://my.oschina.net/u/3551926/blog/1786237

chengsuo9732
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot 项目的 API 接口防刷
勇往直前的专栏
10-31 447
说明：使用了注解的方式进行对接口防刷的功能，非常高大上，本文章仅供参考 一，技术要点：springboot的基本知识，redis基本操作， 首先是写一个注解类： importjava.lang.annotation.Retention; importjava.lang.annotation.Target; importstaticjava.lang.annotation.Ele...
一个注解搞定 SpringBoot 接口防刷，还有谁不会？
qq_14958051的博客
02-28 126
作者：CS打赢你 blog.csdn.net/weixin_42533856/article/details/82593123说明：使用了注解的方式进行对接口防刷的功能，非常高大上，本文...
基于springboot+redis的分布式计数器限流接口（附详细代码注释和项目地址）
qq_42529846的博客
03-06 1977
文章目录前言一、1.接口功能2.设计思想二、代码解析1.项目结构整体预览1.AccessLimiter 限流接口2.AccessLimiter 接口实现类3.Limit 标签接口，实现注解方式4.LimitAspect 切面实现5.GenerateRedisKey 生成保存策略的key值6.ConfigInfo类 获取设备id7.RedisConfig redis的配置类三、结果演示1.redis中的策略存储和访问次数存储总结 前言 题外话：这是我的第一篇CSDN博客，第一次去尝试把自己学到的东西以博客的
学废SpringBoot+Redis+Lua=王炸（值得珍藏）
a342874650的专栏
01-30 810
Spring Boot通过集成Redis和Lua，提供了一种高效、可靠的方式来构建现代化的应用程序。Redis作为高性能的内存数据存储，为应用程序提供了快速的数据访问和缓存功能，从而提高了系统的性能和响应速度。而Lua脚本语言则提供了灵活的脚本执行能力，可以在应用程序中实现复杂的业务逻辑和计算任务。通过Spring Boot的集成，开发者可以轻松地使用Redis和Lua来构建高效、可扩展的应用程序，同时简化了开发和维护过程。
vue+springboot+redis+mysql 分布式系统
10-11
在"vue+springboot+redis+mysql 分布式系统 "中，Vue负责前端展示和交互，SpringBoot提供后端服务，处理业务逻辑并与数据库交互。Redis作为缓存，加速数据访问，减轻数据库压力。MySQL则作为数据存储中心，保存所有...
springboot-redis分布式锁
08-03
【SpringBoot整合Redis实现分布式锁】 在分布式系统中，锁是控制并发操作的重要工具，而SpringBoot结合Redis可以轻松地实现高效、可靠的分布式锁。SpringBoot以其轻量级和便捷的特性，使得开发者能快速搭建应用，而...
SpringBoot 学习笔记+完整教程
04-28
Spring boot(后续用*表示) helloworld * 返回 json 数据 * 使用其他 json 转换框架 * 全局异常捕捉 * JPA 连接数据库 * 配置 JPA * 整合 JPA 保存数据 * 使用 JdbcTemplate 保存数据 * 常用配置 * 静态资源处理 * ...
spring-boot-mybatis.jar
08-26
springboot项目,集成了常用的技术,导入sql脚本即可运行,后续如需要集成别的技术，可私信或者评论下方留言，框架如有不妥之处，可提出。
SpringBoot新手学习手册.pdf
01-10
2.3、编写HelloWorld服务 2 2.4、@RestController 3 2.5、@EnableAutoConfiguration 3 2.6 SpringApplication.run(HelloController.class, args); 3 @SpringbootApplication 3 2.7、SpringBoot启动方式1 4 2.8...
初始C++
2302_81016149的博客
07-08 805
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
set user & password for database 设置数据库 用户和密码
DavidsonGong的博客
07-12 95
USE sbms;
mysql笔记1
m0_62975692的博客
07-11 243
首先查看systemctl status mysqld，如果是关闭的可以进入的配置文件打开mysql，我的mysql配置文件就是在/usr/local/mysql/support-filess/下，在此目录下执行./mysql.server start,打开mysql服务，也可以通过systmectl start mysqld，如果你嫌麻烦的话可以systemctl enable mysqld 一直打开mysql的服务;重新给字段添加约束的时候不可以添加not null约束的！
docker-compose安装PolarDB-PG数据库
wnfff的博客
07-12 198
docker-compose安装PolarDB-PG数据库
Redis数据结构-String篇
最新发布
时间如瑾 代码如诗
07-12 508
对⼀个内部表示成long型的string执行append, setbit, getrange这些命令，针对的仍然是string的值（即⼗进制表示的字符串），而不是针对内部表⽰的long型进⾏操作。因此，在这些命令的实现中，会把long型先转成字符串再进行相应的操作。String 的内部存储结构⼀般是 sds（Simple Dynamic String，可以动态扩展内存），但是如果⼀个String 类型的 value 的值是数字，那么 Redis 内部会把它转成 long 类型来存储，从⽽减少内存的使用。
系统架构设计师教程 第二章 计算机系统基础知识-2.3计算机软件
Remon的专栏
07-09 720
《系统架构设计师教程》清华第二版 2.3计算机软件 章节的详细解读
Java：使用synchronized和Redis实现并发控制的区别
好幸运
07-08 460
而Redis则适用于分布式环境下的同步需求，虽然操作相对复杂，但它能够解决跨JVM的资源竞争问题。: 是Java语言内置的关键字，用于实现线程间的同步。这种同步是** JVM层面**的，对本地内存中的对象进行操作。Redis: 由于是基于网络通信的分布式存储，它的性能受到网络延迟和带宽的影响。然而，在分布式环境下，Redis提供的分布式锁机制能够有效解决跨JVM的同步问题，尽管相比。Redis: 使用Redis实现同步（如通过SETNX命令设置锁），需要手动编写代码来获取和释放锁。
CH-benCHmark：一个HTAP数据库测试基准
算力测评
07-09 257
这一基准测试，旨在弥合TPC-C（专注于联机事务处理，即OLTP）与TPC-H（侧重于联机分析处理，即OLAP）这两项业界权威但单一的工作负载测试之间的鸿沟。它巧妙地结合了TPC-C的订单录入流程产生的交易负载，以及与之对应的、等同于TPC-H级别的OLAP查询套件，并在单一数据库系统内的同一数据集上并行执行。正因为继承自两个最广泛应用的TPC标准，CH-benCHmark的测试结果不仅对混合负载系统具有重大参考价值，同时也适用于传统的单一工作负载场景。
数据库db文件损坏修复方法（sqlite3：database disk image is malformed）
Littlehero_121的博客
07-10 459
一、第一种方式：通过 使用SQLite Expert Professional软件来修复。二、通过命令行，将db文件数据导出到.sql语句，然后建个新的db文件，放进去这样的流程。通过New file ->Start就可以完成，如果文件比较大，那就比较耗时，等待即可。再去看repair.db已经不再是空的了，修复完成。直接拖入受损的db文件，然后进行Repair。（2）在受损的db文件路径中，使用终端打开。发现新生成一个 repair.db文件。发现多了个repair.sql。
springboot +redis
06-05
2. 分布式锁 - Redis 支持分布式锁，可以解决并发问题。 3. 计数器和排行榜 - Redis 支持原子计数器操作，可以用来实现排行榜等功能。 4. 发布/订阅消息 - Redis 支持发布/订阅模式，可以用来实现消息队列等功能。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值