当前位置： 首页 > news >正文

Redis（三）

news 来源：原创 2024/9/19 0:37:17

1. java连接redis

java提高连接redis的方式jedis. 我们需要遵循jedis协议。

引入依赖

<!--引入java连接redis的驱动--><dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>4.3.1</version></dependency>

2 java连接redis集群模式

 public static void main(String[] args) {Set<HostAndPort> nodes=new HashSet<>();nodes.add(new HostAndPort("192.168.111.188",7001));nodes.add(new HostAndPort("192.168.111.188",7002));nodes.add(new HostAndPort("192.168.111.188",7003));nodes.add(new HostAndPort("192.168.111.188",7004));nodes.add(new HostAndPort("192.168.111.188",7005));nodes.add(new HostAndPort("192.168.111.188",7006));JedisCluster jedisCluster=new JedisCluster(nodes);jedisCluster.set("k5","666");System.out.println(jedisCluster.get("k5"));}

适合ssm项目。

3. springboot整合redis

starter启动依赖。---包含自动装配类---完成相应的装配功能。

引入依赖

  <!--引入了redis整合springboot 的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

修改配置文件

#redis 配置
spring.redis.host=192.168.100.104
spring.redis.port=6379
spring.redis.database=1
spring.redis.jedis.pool.max-active=100
spring.redis.jedis.pool.max-idle=10
spring.redis.jedis.pool.max-wait=10000ms

使用

springboot整合redis时封装了两个工具类：StringRedisTemplate和RedisTemplate.

StringRedisTemplate它是RedisTemplate的子类。StringRedisTemplate里面只能存放字符串的内容。

1. StringRedisTemplate

package com.zql;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;/*** Spring Boot Redis 应用的测试类，用于验证 Redis 的集成和操作。*/
@SpringBootTest
class SpringBootRedisApplicationTests {// 自动注入 StringRedisTemplate，用于进行 Redis 的字符串操作@Autowiredprivate StringRedisTemplate stringRedisTemplate;/*** 测试 Redis Hash 的操作，包括添加、获取和删除数据。*///关于Hash的操作@Testvoid testHash(){// 获取 Hash 操作实例HashOperations<String, String, Object> ops = stringRedisTemplate.opsForHash();// 向 Hash 中添加单个字段值//存放数据 hset(k,f,v)ops.put("user","name","zql");// 向 Hash 中添加多个字段值Map<String, Object> map=new HashMap<>();map.put("name","zql");map.put("age","18");map.put("sex","男");ops.putAll("user",map);// 获取 Hash 中的单个字段值//获取指定的元素Object name = ops.get("user", "name");// 获取 Hash 中的所有字段值Map<String, Object> user = ops.entries("user");// 获取 Hash 中的所有字段名Set<String> keys = ops.keys("user");// 获取 Hash 中的所有字段值List<Object> values = ops.values("user");}/*** 测试 Redis 字符串操作，包括设置、获取和递增操作。*///关于String字符串的操作@Testvoid testString(){// 获取字符串操作实例//得到操作字符串的类对象ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();// 设置字符串值//存放数据---set(k,v)ops.set("k1","v1");ops.set("k2","2");// 为字符串设置过期时间并设置值//存放数据--settex(k,second,v)ops.set("k3","v3",30, TimeUnit.SECONDS);// 如果键不存在，则设置键值并设置过期时间Boolean aBoolean = ops.setIfAbsent("k4", "v4", 30, TimeUnit.SECONDS);// 获取字符串值String k1 = ops.get("k1");// 对字符串进行递增操作Long k2 = ops.increment("k2", 10);}/*** 测试 Redis 关于键的操作，包括查找、删除、检查存在性和设置过期时间。*///关于key的操作@Testvoid testKeys() {// 查找所有匹配的键Set<String> keys = stringRedisTemplate.keys("*");// 删除指定的键Boolean k1 = stringRedisTemplate.delete("k1");// 检查键是否存在Boolean k11 = stringRedisTemplate.hasKey("k1");// 为键设置过期时间Boolean k12 = stringRedisTemplate.expire("k4", 30, TimeUnit.SECONDS);}}

2. RedisTemplate

它属于StringRedisTemplate的父类，它的泛型默认都是Object。它可以直接存储任意类型的key和value.

package com.zql;import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
import com.zql.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.StringRedisSerializer;@SpringBootTest
class SpringBootRedisApplicationTest02 {
@Autowired
private RedisTemplate redisTemplate;
@Testpublic void test01() {//指定key的序列化方式redisTemplate.setKeySerializer(new StringRedisSerializer());//指定value的序列化方式redisTemplate.setValueSerializer(new FastJsonRedisSerializer<>(Object.class));ValueOperations valueOperations = redisTemplate.opsForValue();valueOperations.set("name","zhangsan");System.out.println(valueOperations.get("name"));valueOperations.set("k6",new User("zql",15));JSONObject k6=(JSONObject) valueOperations.get("k6");HashOperations forHash = redisTemplate.opsForHash();forHash.put("u","n","zhangsan");forHash.put("u","张三","张三杀回");
}
}

我们可以自己写个工具类

package com.zql.config;import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;/*** @program: spring-boot01* @description:* @author: * @create: 2024-07-23 19:47**/
@Configuration
public class RedisConfig {/*** 配置Redis模板** @param factory Redis连接工厂，用于创建Redis连接。* @return RedisTemplate实例，配置了键值的序列化方式。*/@Beanpublic RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){RedisTemplate<String,Object> template=new RedisTemplate<>();//创建redisTemplate对象RedisSerializer<String> redisSerializer=new StringRedisSerializer();//字符串序列化器Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer<>(Object.class);//json序列化器// 配置ObjectMapper，用于序列化和反序列化Java对象为JSON。ObjectMapper om=new ObjectMapper();om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);jackson2JsonRedisSerializer.setObjectMapper(om);// 配置Redis模板的序列化方式。template.setConnectionFactory(factory);//key序列化方式template.setKeySerializer(redisSerializer);//value序列化方式template.setValueSerializer(jackson2JsonRedisSerializer);//hash的key序列化方式template.setHashKeySerializer(jackson2JsonRedisSerializer);template.setHashValueSerializer(redisSerializer);return template;}
}

4. 集群模式

在配置文件里面配置集群的配置

#集群模式
spring.redis.cluster.nodes=192.168.111.188:7006,192.168.111.188:7001,192.168.111.188:7002,192.168.111.188:7003,192.168.111.188:7004,192.168.111.188:7005
 

5. 短信业务

项目结构

controller

package com.zql.controller;import com.zql.SendMsgUtil;
import com.zql.vo.LoginVo;
import com.zql.vo.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;import java.util.concurrent.TimeUnit;/*** @program: spring-boot01* @description:* @author: * @create: 2024-07-24 18:35**/
@RestController
@RequestMapping("/msg")
public class MsgController {@Autowiredprivate StringRedisTemplate redisTemplate;@GetMapping("send")public R send(String phone) throws Exception {//1.校验手机号是否存在 --连接数据库if (phone.equals("13938300924")) {if (redisTemplate.hasKey("code::" + phone)) {return new R(500, "验证码已发送", null);}//2. 发送验证码String code = SendMsgUtil.sendCode(phone);//3.将验证码存入redisredisTemplate.opsForValue().set("code::" + phone, code, 5, TimeUnit.MINUTES);return new R(200, "发送成功", null);}return new R(500, "手机号未注册", null);}@PostMapping("login")public R login(@RequestBody LoginVo loginVo) {//1.校验验证码String code = redisTemplate.opsForValue().get("code::" + loginVo.getPhone());String phone = loginVo.getPhone();if (StringUtils.hasText(loginVo.getCode()) && loginVo.getCode().equals(code)) {//2.登录成功if (phone.equals("13938300924")) {// redisTemplate.delete("code::" + phone);return new R(200, "登录成功", null);} else {return new R(500, "手机号未注册", null);}}return new R(500, "验证码错误", null);}
}

entity

package com.zql.entity;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;import java.io.Serializable;/*** @program: spring-boot01* @description:* @author: * @create: 2024-07-23 19:18**/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {private String name;private int age;
}

vo

package com.zql.vo;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;/*** @program: spring-boot01* @description:* @author: * @create: 2024-07-24 18:46**/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class LoginVo {private String phone;private String code;
}

package com.zql.vo;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;/*** @program: spring-boot01* @description:* @author: * @create: 2024-07-24 18:40**/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class R {private Integer code;private String msg;private Object data;
}

发送短信的配置类 里面带****的使用自己的配置就行

package com.zql;import cn.hutool.captcha.generator.RandomGenerator;
import com.aliyun.teaopenapi.Client;
import org.springframework.beans.factory.annotation.Value;/*** @Author: * @Description:* @Date: Create in 17:30 2024/7/23*/
public class SendMsgUtil {/*** 使用AK&SK初始化账号Client* @return Client* @throws Exception*/@Value("${aliyun.msg.accessKeyId}")private static String accessKeyId;public static Client createClient() throws Exception {com.aliyun.teaopenapi.models.Config config = new com.aliyun.teaopenapi.models.Config()// 必填，请确保代码运行环境设置了环境变量 ALIBABA_CLOUD_ACCESS_KEY_ID。.setAccessKeyId("**************")// 必填，请确保代码运行环境设置了环境变量 ALIBABA_CLOUD_ACCESS_KEY_SECRET。.setAccessKeySecret("****************");// Endpoint 请参考 https://api.aliyun.com/product/Dysmsapiconfig.endpoint = "dysmsapi.aliyuncs.com";return new com.aliyun.teaopenapi.Client(config);}/*** API 相关* @return OpenApi.Params*/public static com.aliyun.teaopenapi.models.Params createApiInfo() throws Exception {com.aliyun.teaopenapi.models.Params params = new com.aliyun.teaopenapi.models.Params()// 接口名称.setAction("SendSms")// 接口版本.setVersion("2017-05-25")// 接口协议.setProtocol("HTTPS")// 接口 HTTP 方法.setMethod("POST").setAuthType("AK").setStyle("RPC")// 接口 PATH.setPathname("/")// 接口请求体内容格式.setReqBodyType("json")// 接口响应体内容格式.setBodyType("json");return params;}public static String sendCode(String phone) throws Exception {com.aliyun.teaopenapi.Client client = createClient();com.aliyun.teaopenapi.models.Params params = createApiInfo();// query paramsjava.util.Map<String, Object> queries = new java.util.HashMap<>();queries.put("PhoneNumbers", phone);queries.put("SignName", "智友");queries.put("TemplateCode", "SMS_173342144"); //您正在申请手机注册，验证码为：${code}，5分钟内有效！RandomGenerator randomGenerator=new RandomGenerator("0123456789",6);String code= randomGenerator.generate();queries.put("TemplateParam", "{\"code\":\""+code+"\"}");// runtime optionscom.aliyun.teautil.models.RuntimeOptions runtime = new com.aliyun.teautil.models.RuntimeOptions();com.aliyun.teaopenapi.models.OpenApiRequest request = new com.aliyun.teaopenapi.models.OpenApiRequest().setQuery(com.aliyun.openapiutil.Client.query(queries));// 复制代码运行请自行打印 API 的返回值// 返回值为 Map 类型，可从 Map 中获得三类数据：响应体 body、响应头 headers、HTTP 返回的状态码 statusCode。client.callApi(params, request, runtime);return code;}
}

测试

package com.zql;import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;/*** @program: spring-boot01* @description:* @author: * @create: 2024-07-23 20:40**/
@SpringBootTestclass Test01 {@Testpublic void test01()throws Exception{System.out.println(SendMsgUtil.sendCode("*********"));}
}

5.1 注册登录功能

6. redis的使用场景-热点数据缓存

6.1 什么是缓存？

为了把一些经常访问的数据，放入缓存中以减少对数据库的访问频率。从而减少数据库的压力，提高程序的性能。【内存中存储】

6.2 缓存的原理

6.3 什么样的数据适合放入缓存中

1. 查询频率高且修改频率低
2. 数据安全性低

6.4 哪个组件可以作为缓存

  1. redis组件

  2. memory组件

  3. ehcache组件

    等

6.5 java使用redis如何实现缓存功能

配置文件

# 应用服务 WEB 访问端口
server.port=8080#数据库
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/zql?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=123456#映射文件路径
mybatis-plus.mapper-locations=classpath*:mapper/*.xml#配置日志--sql日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl#redis 配置
spring.redis.host=192.168.100.104
spring.redis.port=6379
spring.redis.database=1
spring.redis.jedis.pool.max-active=100
spring.redis.jedis.pool.max-idle=10
spring.redis.jedis.pool.max-wait=10000ms

项目结构

config

package com.zql.config;import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;import java.time.Duration;/*** @program: spring-boot01* @description:* @author: 赵庆龙* @create: 2024-07-23 19:47**/
@Configuration
public class RedisConfig {@Bean//把该方法返回的类对象交与spring容器管理public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){RedisTemplate<String,Object> template=new RedisTemplate<>();//创建redisTemplate对象RedisSerializer<String> redisSerializer=new StringRedisSerializer();//字符串序列化器Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer<>(Object.class);//json序列化器ObjectMapper om=new ObjectMapper();om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);jackson2JsonRedisSerializer.setObjectMapper(om);template.setConnectionFactory(factory);//key序列化方式template.setKeySerializer(redisSerializer);//value序列化方式template.setValueSerializer(jackson2JsonRedisSerializer);//hash的key序列化方式template.setHashKeySerializer(jackson2JsonRedisSerializer);template.setHashValueSerializer(redisSerializer);return template;}@Beanpublic CacheManager cacheManager(RedisConnectionFactory factory) {RedisSerializer<String> redisSerializer = new StringRedisSerializer();Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);//解决查询缓存转换异常的问题ObjectMapper om = new ObjectMapper();om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);jackson2JsonRedisSerializer.setObjectMapper(om);// 配置序列化（解决乱码的问题）,过期时间600秒RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofSeconds(600)) //缓存过期10分钟 ---- 业务需求。.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))//设置key的序列化方式.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer)) //设置value的序列化.disableCachingNullValues();RedisCacheManager cacheManager = RedisCacheManager.builder(factory).cacheDefaults(config).build();return cacheManager;}}

controller

package com.zql.controller;import com.zql.entity.Dept;
import com.zql.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;/*** @program: spring-boot01* @description:* @author: * @create: 2024-07-25 09:16**/
@RestController
@RequestMapping("/dept")
public class DeptController {@Autowiredprivate DeptService deptService;@GetMapping("/getById/{id}")public Dept getById(@PathVariable  Integer id) {Dept dept = deptService.getById(id);return dept;}@PostMapping("/insert")public Dept insert(@RequestBody Dept dept) {return deptService.insert(dept);}@PutMapping("/update")public Dept update(@RequestBody Dept dept) {return deptService.update(dept);}@DeleteMapping("/delete/{id}")public int delete(@PathVariable Integer id) {return deptService.delete(id);}
}

dao

package com.zql.dao;import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zql.entity.Dept;/*** @program: spring-boot01* @description:* @author:* @create: 2024-07-24 20:00**/
public interface DeptDao extends BaseMapper<Dept> {
}

entity

package com.zql.entity;import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;/*** @program: spring-boot01* @description:* @author: * @create: 2024-07-24 19:58**/
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_dept")
public class Dept {@TableId(type = IdType.AUTO)private Integer did;private String dname;private String loc;}

service

package com.zql.service;import com.zql.entity.Dept;/*** @program: spring-boot01* @description:* @author: * @create: 2024-07-24 20:02**/
public interface DeptService {public Dept getById(Integer id);public Dept insert(Dept dept);public Dept update(Dept dept);public int delete(Integer id);}

package com.zql.service.impl;import com.zql.dao.DeptDao;
import com.zql.entity.Dept;
import com.zql.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;/*** @program: spring-boot01* @description:* @author: * @create: 2024-07-24 20:07**/
@Service
public class DeptServiceImpl01 implements DeptService {@Autowiredprivate DeptDao deptDao;@Autowiredprivate RedisTemplate<String,Object> redisTemplate;@Overridepublic Dept getById(Integer id) {//1.查询redis缓存是否命中ValueOperations<String, Object> ops = redisTemplate.opsForValue();Object o=ops.get("dept::"+id);//表示缓存命中if (o!=null){return (Dept) o;}//查询数据库Dept dept = deptDao.selectById(id);if (dept!=null){ops.set("dept::"+id,dept);}return dept;}@Overridepublic Dept insert(Dept dept) {int insert = deptDao.insert(dept);return dept;}@Overridepublic Dept update(Dept dept) {// 更新数据库int i = deptDao.updateById(dept);if (i>0){//删除缓存redisTemplate.opsForValue().set("dept::"+dept.getDid(),dept);}return dept;}@Overridepublic int delete(Integer id) {int i = deptDao.deleteById(id);if (i>0){//删除缓存redisTemplate.delete("dept::"+id);}return i;}
}

发现: 业务层代码除了要维护核心业务功能外，额外还要维护缓存的代码。

如何解决: 使用AOP面向切面编程。

spring框架也能想到。---aop切面来解决。

6.6 使用缓存注解完成缓存功能

package com.zql.service.impl;import com.zql.dao.DeptDao;
import com.zql.entity.Dept;
import com.zql.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;/*** @program: spring-boot01* @description:* @author: * @create: 2024-07-24 20:07**/
@Service
public class DeptServiceImpl implements DeptService {@Autowiredprivate DeptDao deptDao;@Autowiredprivate RedisTemplate<String,Object> redisTemplate;//Cacheable:表示查询时使用的注解。 cacheNames:缓存的名称  key:缓存的唯一表示值//   1. 查询缓存中是否存在名称为cacheNames::key的值//2.如果存在则方法不会执行//   3. 如果不存在则执行方法体并把方法的返回结果放入缓存中cacheNames::key@Cacheable(cacheNames = "dept",key = "#id")@Overridepublic Dept getById(Integer id) {//1.查询redis缓存是否命中//查询数据库Dept dept = deptDao.selectById(id);return dept;}@Overridepublic Dept insert(Dept dept) {int insert = deptDao.insert(dept);return dept;}//CachePut:表示修改时使用的注解.// 1. 先执行方法体// 2. 把方法的返回结果放入缓存中
@CachePut(cacheNames = "dept",key = "#dept.did")@Overridepublic Dept update(Dept dept) {// 更新数据库int i = deptDao.updateById(dept);return dept;}//CacheEvict:表示删除时使用的注解// 1. 先执行方法体// 2. 把缓存中名称为cacheNames::key的值删除@CacheEvict(cacheNames = "dept",key = "#id")@Overridepublic int delete(Integer id) {int i = deptDao.deleteById(id);return i;}
}

开启缓存注解

7. redis的使用场景--分布式锁.

模拟高并发:---jmeter压测工具

通过压测发现库存超卖和重卖了。---解决办法使用锁

syn和lock锁。

package com.ykq.service;import com.ykq.dao.StockDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;/*** @program: distinct-lock* @description:* @author: * @create: 2023-08-31 16:49**/
@Service
public class StockService01 {@Autowiredprivate StockDao stockDao;//如果在单线程下---该功能没有任何问题。//如果在多线程的情况---jmeter压测工具---发现出现线程安全问题了。==使用锁synchronized ()或lock锁。//发现使用锁之前没有问题了。但是如果该项目是一个集群。--发现在集群的情况下本地锁【只对当前工程有效】无效了。//解决方案就是集群工程共用一把锁就行。---可以使用redis来解决问题。public String decrement(Integer productid) {//根据id查询商品的库存synchronized (this) {int num = stockDao.findById(productid);if (num > 0) {//修改库存stockDao.update(productid);System.out.println("商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个");return "商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个";} else {System.out.println("商品编号为:" + productid + "的商品库存不足。");return "商品编号为:" + productid + "的商品库存不足。";}}}
}

上面使用syn和lock虽然解决了并发问题，但是我们未来项目部署时可能要部署集群模式。

nginx代理集群

通过压测发现本地锁 无效了。使用redis解决分布式锁文件

package com.ykq.service;import com.ykq.dao.StockDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;import java.util.concurrent.TimeUnit;/*** @program: distinct-lock* @description:* @author: * @create: 2023-08-31 16:49**/
@Service
public class StockService {@Autowiredprivate StockDao stockDao;@Autowiredprivate StringRedisTemplate redisTemplate;//public String decrement(Integer productid) {ValueOperations<String, String> opsForValue = redisTemplate.opsForValue();//1.获取共享锁资源Boolean flag = opsForValue.setIfAbsent("product::" + productid, "1111", 30, TimeUnit.SECONDS);//表示获取锁成功if(flag) {try {//根据id查询商品的库存int num = stockDao.findById(productid);if (num > 0) {//修改库存stockDao.update(productid);System.out.println("商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个");return "商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个";} else {System.out.println("商品编号为:" + productid + "的商品库存不足。");return "商品编号为:" + productid + "的商品库存不足。";}}finally {//释放锁资源redisTemplate.delete("product::"+productid);}}else{//休眠100毫秒 在继续抢锁try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}return decrement(productid);}}
}

redis超时问题[业务代码执行时间超过了上锁时间]. 第三方redisson

引入redisson依赖
      <!--①依赖-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.24.3</version>
        </dependency>

@Configuration
public class RedissonConfig {@Beanpublic RedissonClient redisson(){Config config = new Config();
//        //连接的为redis集群
//        config.useClusterServers()
//                // use "rediss://" for SSL connection
//                .addNodeAddress("redis://127.0.0.1:7181","","","")
//        ;//连接单机config.useSingleServer().setAddress("redis://192.168.111.188:6379");RedissonClient redisson = Redisson.create(config);return redisson;}
}
package com.ykq.service;import com.ykq.dao.StockDao;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;import java.util.concurrent.TimeUnit;@Service
public class StockService {@Autowiredprivate StockDao stockDao;@Autowiredprivate RedissonClient redisson;//public String decrement(Integer productid) {RLock lock = redisson.getLock("product::" + productid);lock.lock();try {//根据id查询商品的库存: 提前预热到redis缓存中int num = stockDao.findById(productid);if (num > 0) {//修改库存---incr---定时器[redis  数据库同步]stockDao.update(productid);System.out.println("商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个");return "商品编号为:" + productid + "的商品库存剩余:" + (num - 1) + "个";} else {System.out.println("商品编号为:" + productid + "的商品库存不足。");return "商品编号为:" + productid + "的商品库存不足。";}}finally {lock.unlock();}}
}

相关文章：

  • 北京网站建设多少钱？
  • 辽宁网页制作哪家好_网站建设
  • 高端品牌网站建设_汉中网站制作
  • 27、美国国家冰雪中心（NSIDC）海冰密集度月数据下载与处理
  • MFC窗口大小最大化最小化随拖动调整大小
  • Golang | Leetcode Golang题解之第283题移动零
  • 【Go系列】Go的UI框架Fyne
  • SQL Server中非结构化数据的存储神器：文件表的魔力
  • 21 B端产品经理之技术常识(1)
  • Python | Leetcode Python题解之第284题窥视迭代器
  • Alternating Sum
  • web基础，http协议，apache概念及nginx
  • C#小结：string、double、TimeSpan等常见类型的小结和坑点
  • mysql的存储过程：
  • go操作aws s3
  • RemakePython
  • 24年第三届钉钉杯大学生大数据挑战赛
  • PySide(PyQt)使用QPropertyAnimation制作动态界面
  • eclipse(luna)创建web工程
  • iOS | NSProxy
  • Java 23种设计模式 之单例模式 7种实现方式
  • Java程序员幽默爆笑锦集
  • Node 版本管理
  • PaddlePaddle-GitHub的正确打开姿势
  • Spark VS Hadoop：两大大数据分析系统深度解读
  • windows下使用nginx调试简介
  • 阿里中间件开源组件：Sentinel 0.2.0正式发布
  • 动态规划入门（以爬楼梯为例）
  • 关键词挖掘技术哪家强（一）基于node.js技术开发一个关键字查询工具
  • 利用阿里云 OSS 搭建私有 Docker 仓库
  • 融云开发漫谈：你是否了解Go语言并发编程的第一要义？
  • 微信开源mars源码分析1—上层samples分析
  • 协程
  • 译米田引理
  • 用简单代码看卷积组块发展
  • - 语言经验 - 《c++的高性能内存管理库tcmalloc和jemalloc》
  • 智能合约开发环境搭建及Hello World合约
  • - 转 Ext2.0 form使用实例
  • 【运维趟坑回忆录 开篇】初入初创, 一脸懵
  • Unity3D - 异步加载游戏场景与异步加载游戏资源进度条 ...
  • ​软考-高级-系统架构设计师教程（清华第2版）【第20章 系统架构设计师论文写作要点（P717~728）-思维导图】​
  • ​业务双活的数据切换思路设计（下）
  • ​油烟净化器电源安全，保障健康餐饮生活
  • ！！java web学习笔记(一到五)
  • #162 (Div. 2)
  • #预处理和函数的对比以及条件编译
  • (Bean工厂的后处理器入门)学习Spring的第七天
  • (ctrl.obj) : error LNK2038: 检测到“RuntimeLibrary”的不匹配项: 值“MDd_DynamicDebug”不匹配值“
  • （C语言）球球大作战
  • （附源码）spring boot基于小程序酒店疫情系统 毕业设计 091931
  • （四）React组件、useState、组件样式
  • （终章）[图像识别]13.OpenCV案例 自定义训练集分类器物体检测
  • （转）winform之ListView
  • (转)视频码率,帧率和分辨率的联系与区别
  • ******之网络***——物理***
  • .net core 6 集成和使用 mongodb
  • .NET Framework 4.6.2改进了WPF和安全性
  • .Net 高效开发之不可错过的实用工具