Redis应用场景以及分布式缓存的实现

已于 2022-04-17 09:15:15 修改
阅读量2.7k 收藏 27
点赞数 4
分类专栏： Redis 文章标签： 后端 java redis 数据库 springboot
于 2022-04-16 22:43:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50313418/article/details/124222194
版权

1. Redis应用场景

  1. 利用 redis 中字符串类型完成 项目中手机验证码存储的实现

    验证码一般都具有时效性，我们在redis中可以设置一个key的超时时间，
当用户在超时时间之内响应时，会与redis中的数据进行对比，验证验证码的正确性
当用户在超时时间之外响应，数据在redis中已经被删除，无法进行验证

  2. 利用 redis 中字符串类型完成 具有时效性业务功能

    比如说在平常买票或者网上购物的时候， 12306 淘宝
订单还有15分钟失效，我们可以将订单信息存入redis，
当数据失效时我们可以返回订单失效。

  3. 利用 redis 做分布式集群系统中 Session 共享

  4. 利用 redis 中 zset数据类型 元素 分数 完成排行榜之类的功能

    ZSet是可排序的set，可以利用ZSet做排行榜排名之类的功能，显示排行前20的信息等等

  5. 利用 redis 实现分布式缓存

    可以把数据库中的数据放入缓存中，日后在查询的时候不需要走数据库了，而是直接走缓存，
缓存中没有的从数据库中查，查完放入缓存

  6. 利用 redis 存储认证之后的 token 信息 微信小程序 微信公众号 ——> 令牌（token）redis 超时

  7. 利用 redis 解决分布式集群系统中分布式锁的问题

    在一个java虚拟机中，解决锁的方法有很多，比如: synchronized，但是我们要注意synchronized
只能解决一台机器上的线程共享问题，现在我们有多台机器，多台虚拟机，synchronized并不能保证
这多台机器之间的线程安全问题。因为 redis 是单进程单线程的，我们可以使用 redis 解决多台
机器之间的线程安全问题。

2. Redis中分布式缓存的实现

# 什么是缓存

定义: 就是计算机内存中的一段数据

# 内存中的数据特点

1. 读写快	2. 断电立即消失

# 缓存解决了什么问题

1. 提高网站吞吐量，提高网站运行效率（从缓存中取数据就相当于从内存中取数据，读写更快）
2. 核心解决问题: 缓存的存在减轻了数据库的访问压力(如果数据在缓存中有，直接在缓存中取就可以了)

# 误区

既然缓存可以提高提高效率，那项目中所有数据都加入缓存岂不是更好？
并不是
注意：使用缓存时一定是数据库中数据极少发生修改，更多用于查询这种情况。
		 当修改比较多时，我们每次不仅要在数据库中查询新的数据，还要对缓存中
		 的数据做替换，这种情况下使用缓存会极大地降低系统的效率。
		 
# 本地缓存和分布式缓存的区别

本地缓存: 存在于应用服务器内存中的数据称之为本地缓存  （local cache）
分布式缓存: 存储在当前应用服务器内存之外的数据称之为分布式缓存 （distribute cache）

# 什么是集群，什么是分布式

集群: 将同一种服务器的多个节点放在一起共同对系统提供服务的过程称之为集群
分布式: 由多个不同的服务集群共同对系统提供服务，这个系统称之为分布式系统（distribute system）
	     分布式是在集群基础之上构建的

# 利用mybatis自身本地缓存结合redis实现分布式缓存

	a. mybatis中应用级缓存（二级缓存） SqlSessionFactory 级别缓存  所有会话共享
	b. 如何开启（二级缓存） 
			只需要在 mapper.xml 中加入下面的一条语句
			<cache/>
			在mapper.xml中加入上面那句话开启二级缓存使用的是本地缓存
	c. 查看Cache标签缓存实现
			结论: Mybatis底层默认使用的是 org.apache.ibatis.cache.impl.PerpetualCache 实现
	d. 自定义RedisCache实现
			1. 通过mybatis默认cache源码得知 可以使用自定义Cache类 实现 Cache接口 并对里面的方法做实现
			2. 使用RedisCache实现
					<cache type="com.baizhi.redis.RedisCache"/>
	e. 当表之间有关联关系时，我们可以让有关联关系查询之间的DAO的查询指向同一个缓存

2.1 mybatis的二级缓存

mybatis中的二级缓存是本地缓存，二级缓存是SqlSessionFactory级别的，所有会话共享

如果想要使用mybatis的二级缓存，只需要在 mapper配置文件中加入 下面这条语句 即可

<cache/>
  • 在使用mybatis的二级缓存往缓存中存储对象时，对象也必须实现序列化，这和redis是一样的

包结构

在这里插入图片描述

  1. 引入依赖
<!--引入redis相关的依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--mybatis-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.3</version>
</dependency>
<!--mysql-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.38</version>
</dependency>
<!--druid-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.19</version>
</dependency>
  1. 编写 application.properties 配置文件

application.properties 配置文件

# 修改SpringBoot应用的端口号
server.port=8989

# 配置与redis相关的数据
spring.redis.host=192.168.72.129
spring.redis.port=7000
spring.redis.database=0



# 数据源
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/2001?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=root

# 指定mapper配置文件的位置以及起别名
mybatis.mapper-locations=classpath:com/baizhi/mapper/*.xml
mybatis.type-aliases-package=com.baizhi.entity


# 设置日志的级别
logging.level.com.baizhi.dao=debug

在入口类上加上 @MapperScan(“com.baizhi.dao”) 注解扫描dao接口所在的包

// 入口类
@SpringBootApplication
@MapperScan("com.baizhi.dao")   // 在入口类上加上这个注解让它扫描dao接口所在的包
public class RedisDay2Application {

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

}
  1. 相关类

UserDAO

public interface UserDAO {

    List<User> findAll();
}

User

// 下面这两个注解的作用是创建get、set方法，使用了下面的这两个注解就不需要写get、set方法了，会自动创建
@Data
@Accessors(chain = true)
public class User implements Serializable { // 将对象放入缓存是对象必须序列化
    private String id;
    private String name;
    private Integer age;
    private Date bir;
}

UserService

public interface UserService {

    List<User> findAll();
}

UserServiceImpl

@Service
@Transactional
public class UserServiceImpl implements UserService { 
    @Autowired
    private UserDAO userDAO;

    @Override
    public List<User> findAll() {
        return userDAO.findAll();
    }
}

RedisDay2Application入口类

@SpringBootApplication
@MapperScan("com.baizhi.dao")   // 扫描dao接口所在的包
public class RedisDay2Application {

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

}

UserDAOMapper.xml配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.baizhi.dao.UserDAO">

    <!--开启mybatis中二级缓存-->
    <cache/>
    <!--findAll-->
    <select id="findAll" resultType="com.baizhi.entity.User">
        select id, name, age, bir from t_user
    </select>
</mapper>
  1. 测试类
// 下面两个注解相当于启动SpringBoot应用
@SpringBootTest(classes = RedisDay2Application.class)   // 让SpringBoot启动起来，并指向入口类
@RunWith(SpringRunner.class)        // 让测试运行于Spring环境

public class TestUserService {

    @Autowired
    private UserService userService;

    @Test
    public void test(){
        userService.findAll().forEach(user -> System.out.println("user = " + user));

        System.out.println("============================");

        userService.findAll().forEach(user -> System.out.println("user = " + user));
    }
}

在这里插入图片描述

结果

在这里插入图片描述

我们可以看到在第二次查询的时候击中了缓存，并没有向数据库中查询数据，而是直接击中缓存，从缓存中拿取数据。

补充

mybatis中的二级缓存是本地缓存，使用了应用的内存，这是它的不足之处，且当应用重启之后，缓存中的数据会丢失，我们需要先从数据库中读取，之后才能使用缓存，我们想要让应用中的内存全部用于处理响应，这就需要用到下面的分布式缓存了。

2.2 mybatis和redis实现分布式缓存

我们在mapper配置文件中加入

 <cache/>

就可以使用 mybatis 的二级缓存，实际上使用的是PerpetualCache，和下面这句话是一个意思

 <cache type="org.apache.ibatis.cache.impl.PerpetualCache"/>

mybatis中的二级缓存默认使用的是PerpetualCache，底层实际上是java中的HashMap

在这里插入图片描述

我们怎么把mybatis中的二级缓存改为redis呢，在做自定义 Cathe 的时候自定义一个类像 PerpetualCache 内部一样

简单的实现并且实现 Cache 接口并且在mapper配置文件中指定使用这个我们自定义的RedisCache即可。不过在这

之前我们需要先想一想如何获取redisTemplate对象，在操作RedisCache的时候我们肯定需要用到RedisTemplate对

象，而RedisCache是由mybatis管理的，并不是由工厂管理的，那我们怎么拿到RedisCache对象呢，我们可以创建

一个工厂工具类，通过工具类传入指定对象的名字去获取我们想要的在工厂中的对象（比如: redisTemplate）

如果想要获取工厂并获取工厂中的对象可以建一个工具类

// 用来获取SpringBoot创建好的工厂
@Component
public class ApplicationContextUtils implements ApplicationContextAware {

    // 保留下来工厂
    private static ApplicationContext applicationContext;
    // 将创建好的工厂以参数的形式传递给这个类
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    // 提供在工厂中获取对象的方法  RedisTemplate  redisTemplate
    public static Object getBeanName(String name){
        return applicationContext.getBean(name);
    }
}

接下来我们来实现自定义的RedisCache

因为在使用redis整合mybatis时，在使用hash类型时，value中的key太长影响效率，所以我们需要使用md5算法修改value中的key为一个32位的16进制的数

// 自定义redis缓存实现
public class RedisCache implements Cache {

    // 当前放入缓存的mapper的namespace
    // 大Key
    private final String id;

    // 必须存在一个类型为String的id的构造方法
    public RedisCache(String id) {
        //System.out.println("id ==============> " + id);
        this.id = id;
    }

    // 返回cache唯一标识不能为空
    @Override
    public String getId() {
        return id;
    }

    // 向缓存中放入数据
    @Override
    // 大Key  value中的key
    public void putObject(Object o, Object o1) {
        //System.out.println("o = " + o.toString());
        //System.out.println("o1 = " + o1);
        // 使用redis 中 Hash类型作为缓存存储模型 Key hashkey value
        // 大Key是id  value中的key是o1  value中的值是o1
        getRedisTemplate().opsForHash().put(id.toString(), getKeyToMD5(o.toString()), o1);

        // 针对不同的业务模块设置不同的缓存时间
        //if(id.equals("com.baizhi.dao.UserDAO")){
        //    getRedisTemplate().expire(id.toString(), 60,  TimeUnit.MILLISECONDS);
        //}

        //if(id.equals("com.baizhi.dao.EmpDAO")){
            getRedisTemplate().expire(id.toString(), 30,  TimeUnit.MILLISECONDS);
        //}
    }

    //从缓存中获取数据
    @Override
    // 大Key
    public Object getObject(Object o) {
        //System.out.println("o = " + o.toString());

        return getRedisTemplate().opsForHash().get(id.toString(), getKeyToMD5(o.toString()));
    }

    // 注意: 这个方法为mybatis的保留方法 默认没有实现 后续版本可能会实现
    @Override
    // 大Key
    public Object removeObject(Object o) {
        //System.out.println("根据指定key删除缓存");
        return null;
    }

    // 只要调用增、删、该，都会调用clear方法清空缓存
    @Override
    public void clear() {
        // 清空namespace
        getRedisTemplate().delete(id.toString()); // 清空缓存
    }

    // 用来计算缓存数量
    @Override
    public int getSize() {
        // 获取Hash中key value数量
        return getRedisTemplate().opsForHash().size(id.toString()).intValue();
    }

    // 封装redisTemplate
    public RedisTemplate getRedisTemplate(){
        // 根据key从redis的hash类型中获取数据
        // 通过application工具类获取RedisTemplate对象
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBeanName("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }

    // 封装一个对value中的key进行md5操作的方法
    private String getKeyToMD5(String key){
        return DigestUtils.md5DigestAsHex(key.getBytes());
    }
}

在实现自定义RedisCache时我们必须满足以下几点要求：

  1. 实现一个String类型的id的构造方法
  2. 返回唯一标识id不能为空
  3. 除了 removeObject 方法以外，其他方法都要做相应的实现

如果我们想要使用自定义的RedisCache的话，我们还需要在mapper配置文件中指定使用这个RedisCache

<!--使用自定义的RedisCache-->
<cache type="com.baizhi.redis.RedisCache"/>

还有几点需要注意：

  • 存入redis中的数据是Hash类型，大Key是mapper配置文件中namespace中的名字，value中的key是大Key和查询语句等组合成的字符串，不过我们使用了md5技术，所以value中的key是一个32位的16进制的字符串

  • 在进行增、删、改操作的时候会清空缓存

  • 关于md5的小知识：

    用两个文件，一个是 aa.txt 一个是 bb.txt 怎么判断两个文件的内容是一致的呢，可以使用MD5算法，不同的内容通过MD5算法得到的结果一定不同。

另外：

如果我们使用的不同DAO的操作之间的表没有关联关系时，我们在使用缓存时使它们各自是用自己的缓存，比如现在有两个mapper配置文件，一个是User、一个是Emp，当这两个DAO对应的表没有关系时，mapper配置文件中缓存这样写：

User的Mapper

<!--开启mybatis中二级缓存-->
<cache type="com.baizhi.redis.RedisCache"/>

Emp的Mapper

<!--开启mybatis中二级缓存-->
<cache type="com.baizhi.redis.RedisCache"/>

当表之间有关联关系时：

User的Mapper

<!--开启mybatis中二级缓存-->
<cache type="com.baizhi.redis.RedisCache"/>

Emp的Mapper

<!--关联关系缓存处理--> <!--引用另一方的缓存-->
<cache-ref namespace="com.baizhi.dao.UserDAO"/>

当然也可以两个都使用Emp为缓存的key，只要两个区域共享即可

接下来我们写一个小案例来看一下Redis缓存在项目中的应用：

包结构：

在这里插入图片描述

  1. 引入依赖
<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>
    <optional>true</optional>
</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>
<!--引入redis相关的依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--mybatis-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.3</version>
</dependency>
<!--mysql-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.38</version>
</dependency>
<!--druid-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.19</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <scope>test</scope>
</dependency>
  1. application.properties 配置文件
# 修改SpringBoot应用的端口号
server.port=8989

# 配置与redis相关的数据
spring.redis.host=192.168.72.129
spring.redis.port=7000
spring.redis.database=0



# 数据源
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/2001?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=root

# 指定mapper配置文件的位置以及起别名
mybatis.mapper-locations=classpath:com/baizhi/mapper/*.xml
mybatis.type-aliases-package=com.baizhi.entity


# 设置日志的级别
logging.level.com.baizhi.dao=debug
  1. 相关类

DAO：

public interface EmpDAO {
    List<Emp> findAll();
}

public interface UserDAO {

    List<User> findAll();
    User findById(String id);
    void delete(String id);
    void save(User user);
    void update(User user);
}

资源类（放入缓存中的对象必须实现序列化）：

@Data
@Accessors(chain = true)
public class Emp implements Serializable {
    private String id;
    private String name;
}

// 下面这两个注解的作用是创建get、set方法，使用了下面的这两个注解就不需要写get、set方法了，会自动创建
@Data
@Accessors(chain = true)
public class User implements Serializable { // 在使用RedisTemplate操作redis的时候对象必须序列化
    private String id;
    private String name;
    private Integer age;
    private Date bir;
}

service:

public interface EmpService {
    List<Emp> findAll();
}

@Service
@Transactional
public class EmpServiceImpl implements EmpService{
    @Autowired
    private EmpDAO empDAO;

    @Override
    public List<Emp> findAll() {
        return empDAO.findAll();
    }
}

public interface UserService {

    List<User> findAll();
    User findById(String id);
    void delete(String id);
    void save(User user);
    void update(User user);
}

@Service
@Transactional
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDAO userDAO;

    @Override
    public List<User> findAll() {
        return userDAO.findAll();
    }

    @Override
    public User findById(String id) {
        return userDAO.findById(id);
    }

    @Override
    public void delete(String id) {
        userDAO.delete(id);
    }

    @Override
    public void save(User user) {
        user.setId(UUID.randomUUID().toString());
        userDAO.save(user);
    }

    @Override
    public void update(User user) {
        userDAO.update(user);
    }
}

入口类:

@SpringBootApplication
@MapperScan("com.baizhi.dao")   // 扫描dao接口所在的包
public class RedisDay2Application {

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

}

ApplicationContextUtils工具类（获取工厂中的对象）：

// 用来获取SpringBoot创建好的工厂
@Component
public class ApplicationContextUtils implements ApplicationContextAware {

    // 保留下来工厂
    private static ApplicationContext applicationContext;
    // 将创建好的工厂以参数的形式传递给这个类
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    // 提供在工厂中获取对象的方法  RedisTemplate  redisTemplate
    public static Object getBeanName(String name){
        return applicationContext.getBean(name);
    }
}

在这里插入图片描述

自定义的RedisCache类:

// 自定义redis缓存实现
public class RedisCache implements Cache {

    // 当前放入缓存的mapper的namespace
    // 大Key
    private final String id;

    // 必须存在一个类型为String的id的构造方法
    public RedisCache(String id) {
        System.out.println("id ==============> " + id);
        this.id = id;
    }

    // 返回cache唯一标识不能为空
    @Override
    public String getId() {
        return id;
    }

    // 向缓存中放入数据
    @Override
    // value中的Key  value中的值
    public void putObject(Object o, Object o1) {
        //System.out.println("o = " + o.toString());
        //System.out.println("o1 = " + o1);
        // 使用redis 中 Hash类型作为缓存存储模型 Key hashkey value
        // 大Key是id  value中的key是o1  value中的值是o1
        getRedisTemplate().opsForHash().put(id.toString(), getKeyToMD5(o.toString()), o1);

        // 针对不同的业务模块设置不同的缓存时间
        //if(id.equals("com.baizhi.dao.UserDAO")){
        //    getRedisTemplate().expire(id.toString(), 60,  TimeUnit.MILLISECONDS);
        //}

        //if(id.equals("com.baizhi.dao.EmpDAO")){
            getRedisTemplate().expire(id.toString(), 30,  TimeUnit.MILLISECONDS);
        //}
    }

    //从缓存中获取数据
    @Override
    // 大Key
    public Object getObject(Object o) {
        //System.out.println("o = " + o.toString());

        return getRedisTemplate().opsForHash().get(id.toString(), getKeyToMD5(o.toString()));
    }

    // 注意: 这个方法为mybatis的保留方法 默认没有实现 后续版本可能会实现
    @Override
    // 大Key
    public Object removeObject(Object o) {
        //System.out.println("根据指定key删除缓存");
        return null;
    }

    // 只要调用增、删、该，都会调用clear方法清空缓存
    @Override
    public void clear() {
        // 清空namespace
        getRedisTemplate().delete(id.toString()); // 清空缓存
    }

    // 用来计算缓存数量
    @Override
    public int getSize() {
        // 获取Hash中key value数量
        return getRedisTemplate().opsForHash().size(id.toString()).intValue();
    }

    // 封装redisTemplate
    public RedisTemplate getRedisTemplate(){
        // 根据key从redis的hash类型中获取数据
        // 通过application工具类获取RedisTemplate对象
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBeanName("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }

    // 封装一个对value中的key进行md5操作的方法
    private String getKeyToMD5(String key){
        return DigestUtils.md5DigestAsHex(key.getBytes());
    }
}

在这里插入图片描述

Mapper配置文件:

EmpDAOMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.baizhi.dao.EmpDAO">

    <!--使用自定义的RedisCache，如果DAO之间的操作表之间无关系使用这个-->
    <!--<cache type="com.baizhi.redis.RedisCache"/>-->

    <!--关联关系缓存处理时使用这个--> <!--引用另一方的缓存-->
    <cache-ref namespace="com.baizhi.dao.UserDAO"/>

    <!--findAll-->
    <select id="findAll" resultType="Emp">
        select id, name from t_emp
    </select>

</mapper>

UserDAOMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.baizhi.dao.UserDAO">

    <!--开启mybatis中二级缓存-->
    <cache type="com.baizhi.redis.RedisCache"/>

    <!--findAll-->
    <select id="findAll" resultType="com.baizhi.entity.User">
        select id, name, age, bir from t_user
    </select>

    <!--findById-->
    <select id="findById" parameterType="String" resultType="User">
        select id, name, age, bir from t_user where id = #{id}
    </select>

    <!--delete-->
    <delete id="delete" parameterType="String">
        delete from t_user where id = #{id}
    </delete>

    <!--save-->
    <insert id="save" parameterType="User">
        insert into t_user values(#{id}, #{name}, #{age}, #{bir})
    </insert>

    <!--update-->
    <update id="update" parameterType="User">
        update t_user set name = #{name}, age = #{age}, bir = #{bir} where id = #{id}
    </update>
</mapper>

在这里插入图片描述

  1. 测试类

TestEmpService

// 下面两个注解相当于启动SpringBoot应用
@SpringBootTest(classes = RedisDay2Application.class)   // 让SpringBoot启动起来，并指向入口类
@RunWith(SpringRunner.class)        // 让测试运行于Spring环境
public class TestEmpService {
    @Autowired
    private EmpService empService;

    @Test
    public void testFindAll(){
        empService.findAll().forEach(emp -> System.out.println(emp));
        System.out.println("=============================");
        empService.findAll().forEach(emp -> System.out.println(emp));
    }

    @Test
    public void testmd5(){
        // org.springframework.util.DigestUtils 包下的 DigestUtils
        String key = "-1628801192:1544301354:com.baizhi.dao.EmpDAO.findAll:0:2147483647:select id, name from t_emp:SqlSessionFactoryBean";
        // 将key转化为32位的16进制的字符串
        String s = DigestUtils.md5DigestAsHex(key.getBytes());
        System.out.println("s = " + s);

    }
}

TestUserService:

// 下面两个注解相当于启动SpringBoot应用
@SpringBootTest(classes = RedisDay2Application.class)   // 让SpringBoot启动起来，并指向入口类
@RunWith(SpringRunner.class)        // 让测试运行于Spring环境

public class TestUserService {

    @Autowired
    private UserService userService;

    @Test
    public void testFindAll(){
        userService.findAll().forEach(user -> System.out.println("user = " + user));

        System.out.println("============================");



        userService.findAll().forEach(user -> System.out.println("user = " + user));
    }

    @Test
    public void testFindId(){
        System.out.println(userService.findById("1"));

        System.out.println("============================");



        System.out.println(userService.findById("1"));
    }

    @Test
    public void testDelete(){
        userService.delete("1");

        System.out.println("============================");

    }

    @Test
    public void testSave(){
        User user = new User();
        user.setName("王五");
        user.setAge(20);
        user.setBir(new Date());
        userService.save(user);

        System.out.println("============================");

    }
    @Test
    public void testUpdate(){
        User user = new User();
        user.setId("2");
        user.setName("赵六");
        user.setAge(20);
        user.setBir(new Date());
        userService.update(user);

        System.out.println("============================");

    }
}

2.3 总结

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

  • 缓存穿透是数据库没有key的情况大量请求访问数据库
  • 缓存击穿是一个热点数据的key失效了，此时大量请求访问数据库
  • 缓存雪崩是大量数据在同一时刻失效，大量请求访问数据库，数据库压力突增
基于Redis的分布式缓存技术实现
AI天才研究院
07-30 1033
Redis是一个开源的高性能key-value存储数据库。它支持多种数据类型如String、Hash、List、Set等，提供基于键值对的数据存储能力，同时还提供了丰富的查询命令用于数据检索，是目前最热门的NoSQL内存数据库之一。除此之外，Redis还支持发布/订阅、管道、事务处理等特性，在大型项目中广泛应用于缓存、消息队列、排行榜系统、实时分析等领域。在云计算、大数据、微服务、函数计算、物联网、移动互联网等新兴的互联网场景下，Redis作为一个内存数据库，占据了举足轻重的地位。
Redis——分布式缓存
xiaowanziddd的博客
06-28 1558
一.Redis持久化 1.RDB RDB全称Redis Database Backup file(Redis数据备份文件),也被叫做Redis数据快照。简单来说就是把内存中的所有数据记录到磁盘中。当Redis实例故障重启后，从磁盘读取快照文件，恢复数据。 快照文件称为RDB文件，默认是保存到当前运行目录。 RDB执行命令有两种：使用save命令是利用主进程在对Redis进行持久化，因为Redis是一种单线程模式，这样的话会对阻塞所有命令，耗时时间长。不推荐使用。推荐使用bigsave命令对Redis进行持
详解 Redis 应用场景及应用实例
热门推荐
Loven Niu的博客
03-23 4万+
1. MySql+Memcached架构的问题 2. Redis常用数据类型 3. 各种数据类型应用和实现方式 4. Redis实际应用场景
Redis高级篇 —— 分布式缓存
最新发布
weixin_49429082的博客
10-10 1568
介绍了Redis持久化以及三种Reids集群方案：主从、哨兵、分片集群
大型网站架构系列：缓存在分布式系统中的应用（一）
weixin_33719619的博客
06-06 162
缓存是分布式系统中的重要组件，主要解决高并发，大数据场景下，热点数据访问的性能问题。提供高性能的数据快速访问。 本文是缓存在分布式应用第一篇文章，介绍缓存的原理，缓存的分类，缓存的设计，CDN缓存（原理，架构参考和技术实践），反向代理缓存（原理，Squid架构实践和常用代理缓存之间的比较）。本文主要是自己的学习总结和网络文章摘录，供学习之用。 本次分享大纲 缓存概述 CDN缓存 反向...
阿里P8架构师谈：分布式缓存的应用场景、选型比较、问题和挑战
weixin_33724570的博客
08-07 369
为什么要使用分布式缓存 高并发环境下，例如典型的淘宝双11秒杀，几分钟内上亿的用户涌入淘宝，这个时候如果访问不加拦截，让大量的读写请求涌向数据库，由于磁盘的处理速度与内存显然不在一个量级，服务器马上就要宕机。从减轻数据库的压力和提高系统响应速度两个角度来考虑，都会在数据库之前加一层缓存，访问压力越大的，在缓存之前就开始CDN拦截图片等访问请求。 并且由于最早的单台机器的内存资源以及承载能力有限，如...
Redis — 应用场景及实现
KnifeBlade的博客
12-17 353
热点数据缓存 计数器 分布式锁 分布式全局递增序列 排行榜 点赞、签到、收藏 Tag 消息队列
redis分布式缓存中间件培训PPT
08-10
Redis分布式缓存中间件培训PPT Redis是完全开源免费的高性能key-value数据库，可以满足高可用、高并发的要求。Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。同时，...
基于redis的分布式缓存系统架构分析_张威.pdf
12-06
基于Redis的分布式缓存系统因其高效、灵活的特点，被广泛应用于大型应用系统中。Redis是一款开源、内存中的Key-Value存储系统，支持数据持久化，并能提供多种数据结构如List、String、Set和Hash等，这使得它在处理...
扩展spring boot cache实现redis一二级分布式缓存
05-01
本篇文章将探讨如何扩展Spring Boot的缓存功能，实现基于Redis的一级和二级分布式缓存。Redis是一个高性能的键值存储系统，常用于实现分布式缓存。 一级缓存通常指的是应用程序内部的缓存，如Spring Cache或Guava ...
一种高效的Redis Cluster的分布式缓存系统.pdf
08-08
实验结果表明，在高并发访问数（例如10000以上）的场景下，RedisCluster的响应时间明显优于Codis系统，验证了RedisCluster分布式缓存系统在处理高并发访问时的高效率和优越性能。 关键词“分布式缓存”指的是分布式...
Redis实战经验及使用场景
weixin_30905981的博客
10-08 783
随着应用对高性能需求的增加，NoSQL逐渐在各大名企的系统架构中生根发芽。这里我们将为大家分享社交巨头新浪微博、传媒巨头Viacom及图片分享领域佼佼者Pinterest带来的Redis实践，首先我们看新浪微博@启盼cobain的Redis实战经验分享： 新浪微博：史上最大的Redis集群 Tape is Dead，Disk is Tape，Flash is Disk，RAM Lo...
redis应用场景
shyboy0358的专栏
12-14 416
Redis在很多方面与其他数据库解决方案不同：它使用内存提供主存储支持，而仅使用硬盘做持久性的存储；它的数据模型非常独特，用的是单线程。另一个大区别在于，你可以在开发环境中使用Redis的功能，但却不需要转到Redis。 转向Redis当然也是可取的，许多开发者从一开始就把Redis作为首选数据库；但设想如果你的开发环境已经搭建好， 应用已经在上面运行了，那么更换数据库框架显然不那么容易。另外在...
redis 应用场景
fuck_life的博客
12-05 237
redis 应用场景 毫无疑问，Redis开创了一种新的数据存储思路，使用Redis，我们不用在面对功能单调的数据库时，把精力放在如何把大象放进冰箱这样的问题上，而是利用Redis灵活多变的数据结构和数据操作，为不同的大象构建不同的冰箱。希望你喜欢这个比喻。 一、Redis常用数据类型 Redis最为常用的数据类型主要有以下五种： * String * Hash * List * Set * ...
Redis使用场景
ThinkWon的博客
09-27 9778
文章目录计数器缓存会话缓存全页缓存（FPC）查找表消息队列(发布/订阅功能)分布式锁实现其它 计数器 可以对 String 进行自增自减运算，从而实现计数器功能。 Redis 这种内存型数据库的读写性能非常高，很适合存储频繁读写的计数量。 缓存 将热点数据放到内存中，设置内存的最大使用量以及淘汰策略来保证缓存的命中率。 会话缓存 可以使用 Redis 来统一存储多台应用服务器的会话信息。 当应用服...
Redis 实现分布式缓存
低吟不作语的博客
09-22 1378
什么是缓存？ 缓存就是数据交换的缓冲区，用于临时存储数据（使用频繁的数据）。当用户请求数据时，首先在缓存中寻找，如果找到了则直接返回。如果找不到，则去数据库中查找。缓存的本质就是用空间换时间，牺牲数据的实时性，从而减轻数据库压力，尽可能提高吞吐量，有效提升响应速度。 缓存的分类 缓存的应用范围十分广泛，常见的有文件缓存、浏览器缓存、数据库缓存等等。但今天我们着重关注的是 WEB 应用服务领域，根据缓存与应用的耦合度，可以分为本地缓存和分布式缓存： 本地缓存 指在应用中的缓存组件，最大的优点是应用和缓.
Redis五种核心数据结构、应用场景及实现
weixin_46460843的博客
08-01 1833
Redis实战，五种核心数据结构和应用场景前言一、Redis常用的场景1.1缓存1.2排行榜1.3计数器1.4分布式会话1.5分布式锁1.6 社交网络1.7最新列表1.8消息系统二、String结构和常见命令三、String应用场景3.1单值缓存3.2对象缓存3.3分布式锁3.4计数器3.5Web集群session共享3.6分布式系统全局序列号四、Hash结构和常见命令五、Hash应用场景5.1对象缓存5.2电商购物车六、List结构和常见命令七、List应用场景7.1实现常用数据结构7.2微博和微信公众.
Redis - 分布式缓存
weixin_44745528的博客
04-26 1448
Redis - 分布式缓存解决方案
天翼云分布式缓存服务（Redis）的应用场景
天翼云开发者社区
04-02 1137
作为分布式缓存系统，Redis大量的应用于互联网行业的各类应用，即使是传统行业，只要是面向公众客户的互联网应用，因用户数的激增，也纷纷基于Redis做架构的改造。 像微博及 Twitter 这两大社交平台重度依赖 Redis 来承载海量用户访问，通过构建可灵活扩展的Redis集群让其能够承载上亿用户的访问规模。 我们按照Redis数据结构维度，其适用的具体场景如下： List: 双向列表，适用于最新列表，关注列表； Set: 适用于无顺序的集合，点赞点踩，抽奖，已读...
Redis分布式缓存技术深度解析与应用
Redis作为一个高性能的分布式缓存解决方案，在互联网应用中被广泛采用，它不仅可以显著提升数据访问速度，还可以通过其多种数据结构和持久化机制满足不同场景的需求。同时，它在分布式部署上的支持也使得Redis成为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值