Springboot与Redis Cache深度整合

最新推荐文章于 2024-05-19 11:08:01 发布
最新推荐文章于 2024-05-19 11:08:01 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： SpringBoot Redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gcxzflgl/article/details/106734912
版权

目录

  1. Springboot项目创建
  2. Springboot与Redis整合
  3. Springboot与Mybatis整合
  4. Springboot与Cache整合使用
  5. Redis作为mybatis二级缓存
  6. Redis分布式session共享

Springboot项目创建

1.打开IDEA 创建工程

在这里插入图片描述

2.选择IDEA中Spring initilazier
在这里插入图片描述

3.设置自己的包命名规范
在这里插入图片描述

4.勾选Web -> Spring Web -> Next -> Finish创建工程
在这里插入图片描述
5.创建对应的文件夹，后面内容基于此文件夹进行配置，工程结构
在这里插入图片描述

Springboot与Redis整合

1.打开pom.xml，引入依赖

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

2.再application.yml配置

spring:
  redis:
    port: 6379
    host: xxx.xxx.xx.xx

3.再config文件夹下创建RedisConfig.java 进行redisTemplate初步调用

package com.gcxzflgl.redis.config;


/**
 * @author gcxzf$
 * @version : RedisConfiguration$, v 0.1 2020/6/13$ 15:39$ gcxzf$ Exp$
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String,String> restTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }
}

4.编写测试案例测试redisTemplate保存到redis中

package com.gcxzflgl.redis;

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.RedisTemplate;

@SpringBootTest
class RedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        redisTemplate.opsForValue().set("gcx","is handsonn boy");
    }

}

5.查看redis中存在测试用例的key，因为我们暂未配置序列化方式，使用的是默认JdkSerializationRedisSerializer序列化方式，后面会逐步配置自己能看懂的序列化方式
在这里插入图片描述

Springboot与Mybatis整合

1.再pom.xml中添加mybatis相关依赖

<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.47</version>
 </dependency>
 <dependency>
     <groupId>org.mybatis.spring.boot</groupId>
     <artifactId>mybatis-spring-boot-starter</artifactId>
     <version>1.3.0</version>
 </dependency>

 <dependency>
     <groupId>org.mybatis.generator</groupId>
     <artifactId>mybatis-generator-core</artifactId>
     <scope>test</scope>
     <version>1.3.2</version>
     <optional>true</optional>
 </dependency>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-jdbc</artifactId>
 </dependency>

 <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>druid</artifactId>
     <version>1.1.10</version>
 </dependency>

 <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>fastjson</artifactId>
     <version>1.2.7</version>
 </dependency>

2.再application.yml中配置如下

spring:
  datasource:
    url: jdbc:mysql://xxx.xxx.xx.xx:3306/redis?useUnicode=true&characterEncoding=UTF-8
    username: xxx           # 需要修改填写
    password: xxxxx         # 需要修改填写
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    minIdle: 5
    maxActive: 100
    initialSize: 10
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: select 'x'
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 50
    removeAbandoned: true
    filters: stat # ,wall,log4j # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000 # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
    useGlobalDataSourceStat: true # 合并多个DruidDataSource的监控数据
    druidLoginName: gcx # 登录druid的账号
    druidPassword: gcx # 登录druid的密码
    cachePrepStmts: true  # 开启二级缓存
mybatis:
  typeAliasesPackage: com.gcxzflgl.redis.mapper      # 需要修改填写
  mapperLocations: classpath:/mapper/*.xml
  mapperScanPackage: com.gcxzflgl.redis.mapper
  configLocation: classpath:/mybatis-config.xml

3.再resources下新建mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE configuration  
     PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
     "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<settings>
	    <!-- 使全局的映射器启用或禁用缓存。 -->
		<setting name="cacheEnabled" value="true" />
		<!-- 全局启用或禁用延迟加载。当禁用时，所有关联对象都会即时加载。 -->
		<setting name="lazyLoadingEnabled" value="true" />
		<!-- 当启用时，有延迟加载属性的对象在被调用时将会完全加载任意属性。否则，每种属性将会按需要加载。 -->        
         <setting name="aggressiveLazyLoading" value="true"/>        
         <!-- 是否允许单条sql 返回多个数据集  (取决于驱动的兼容性) default:true -->
		<setting name="multipleResultSetsEnabled" value="true" />
		<!-- 是否可以使用列的别名 (取决于驱动的兼容性) default:true -->
		<setting name="useColumnLabel" value="true" />
		<!-- 允许JDBC 生成主键。需要驱动器支持。如果设为了true，这个设置将强制使用被生成的主键，有一些驱动器不兼容不过仍然可以执行。  default:false  -->
		<setting name="useGeneratedKeys" value="false" />
		<!-- 指定 MyBatis 如何自动映射 数据基表的列 NONE：不隐射　PARTIAL:部分  FULL:全部  -->
		<setting name="autoMappingBehavior" value="PARTIAL" />
		<!-- 这是默认的执行类型  （SIMPLE: 简单； REUSE: 执行器可能重复使用prepared statements语句；BATCH: 执行器可以重复执行语句和批量更新）  -->
		<setting name="defaultExecutorType" value="SIMPLE" />
		
		<setting name="defaultStatementTimeout" value="25" />
		
		<setting name="defaultFetchSize" value="100" />
		
		<setting name="safeRowBoundsEnabled" value="false" />
		<!-- 使用驼峰命名法转换字段。 -->
		<setting name="mapUnderscoreToCamelCase" value="true" />
		<!-- 设置本地缓存范围 session:就会有数据的共享  statement:语句范围 (这样就不会有数据的共享 ) defalut:session -->
		<setting name="localCacheScope" value="SESSION" />
		<!-- 默认为OTHER,为了解决oracle插入null报错的问题要设置为NULL -->
		<setting name="jdbcTypeForNull" value="NULL" />
		<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString" />
	</settings>
	
</configuration>

4.再config包下创建DataSourceConfig.java配置文件注入sql相关

package com.gcxzflgl.redis.config;




/**
 * Created by wanlichao on 2016/10/25 0025.
 */

@Configuration
@MapperScan("com.gcxzflgl.redis.mapper")
public class DataSourceConfig {
    private Logger logger = LoggerFactory.getLogger(DataSourceConfig.class);

    @Value("${spring.datasource.url}")
    private String dbUrl;

    @Value("${spring.datasource.type}")
    private String dbType;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;

    @Value("${spring.datasource.initialSize}")
    private int initialSize;

    @Value("${spring.datasource.minIdle}")
    private int minIdle;

    @Value("${spring.datasource.maxActive}")
    private int maxActive;

    @Value("${spring.datasource.maxWait}")
    private int maxWait;

    @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;

    @Value("${spring.datasource.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;

    @Value("${spring.datasource.validationQuery}")
    private String validationQuery;

    @Value("${spring.datasource.testWhileIdle}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.testOnBorrow}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.testOnReturn}")
    private boolean testOnReturn;

    @Value("${spring.datasource.poolPreparedStatements}")
    private boolean poolPreparedStatements;

    @Value("${spring.datasource.filters}")
    private String filters;

    @Value("${spring.datasource.connectionProperties}")
    private String connectionProperties;

    @Value("${spring.datasource.useGlobalDataSourceStat}")
    private boolean useGlobalDataSourceStat;

    @Value("${spring.datasource.druidLoginName}")
    private String druidLoginName;

    @Value("${spring.datasource.druidPassword}")
    private String druidPassword;



    @Bean(name="dataSource")
    @Primary //不要漏了这
    public DataSource dataSource(){
        DruidDataSource datasource = new DruidDataSource();
        try {
            datasource.setUrl(this.dbUrl);
            datasource.setDbType(dbType);
            datasource.setUsername(username);
            datasource.setPassword(password);
            datasource.setDriverClassName(driverClassName);
            datasource.setInitialSize(initialSize);
            datasource.setMinIdle(minIdle);
            datasource.setMaxActive(maxActive);
            datasource.setMaxWait(maxWait);
            datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
            datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
            datasource.setValidationQuery(validationQuery);
            datasource.setTestWhileIdle(testWhileIdle);
            datasource.setTestOnBorrow(testOnBorrow);
            datasource.setTestOnReturn(testOnReturn);
            datasource.setPoolPreparedStatements(poolPreparedStatements);
            datasource.setFilters(filters);
        } catch (SQLException e) {
            logger.error("druid configuration initialization filter", e);
        }
        return datasource;
    }

    /  下面是druid 监控访问的设置  /
    @Bean
    public ServletRegistrationBean druidServlet() {
        ServletRegistrationBean reg = new ServletRegistrationBean();
        reg.setServlet(new StatViewServlet());
        reg.addUrlMappings("/druid/*");  //url 匹配
        reg.addInitParameter("allow", "192.168.16.110,127.0.0.1"); // IP白名单 (没有配置或者为空，则允许所有访问)
        reg.addInitParameter("deny", "192.168.16.111"); //IP黑名单 (存在共同时，deny优先于allow)
        reg.addInitParameter("loginUsername", this.druidLoginName);//登录名
        reg.addInitParameter("loginPassword", this.druidPassword);//登录密码
        reg.addInitParameter("resetEnable", "false"); // 禁用HTML页面上的“Reset All”功能
        return reg;
    }

    @Bean(name="druidWebStatFilter")
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new WebStatFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"); //忽略资源
        filterRegistrationBean.addInitParameter("profileEnable", "true");
        filterRegistrationBean.addInitParameter("principalCookieName", "USER_COOKIE");
        filterRegistrationBean.addInitParameter("principalSessionName", "USER_SESSION");
        return filterRegistrationBean;
    }
}

5.创建sql脚本

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for `sys_user`
-- ----------------------------
DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of sys_user
-- ----------------------------
INSERT INTO `sys_user` VALUES ('1', '高晨曦');
INSERT INTO `sys_user` VALUES ('2', '瑞燊儿');

6.再domain包下新建实体

package com.gcxzflgl.redis.domain;

import java.io.Serializable;

public class User implements Serializable {

    /**
     *
     */
    private static final long serialVersionUID = -4415438719697624729L;


    private String id;

    private String userName;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }


    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
}

7.再mapper包中创建mapper映射类

package com.gcxzflgl.redis.mapper;

import com.gcxzflgl.redis.domain.User;
import org.apache.ibatis.annotations.*;
import org.springframework.stereotype.Component;

import java.util.List;

@Mapper
@Component
public interface UserMapper {

	@Insert("insert sys_user(id,user_name) values(#{id},#{userName})")
	void insert(User u);
	
	@Update("update sys_user set user_name = #{userName} where id=#{id} ")
	void update(User u);
	
	@Delete("delete from sys_user where id=#{id} ")
	void delete(@Param("id") String id);

	@Select("select id,user_name from sys_user where id=#{id} ")
	User find(@Param("id") String id);

	//注：方法名和要UserMapper.xml中的id一致
	List<User> query(@Param("userName") String userName);

	@Delete("delete from sys_user")
	void deleteAll();
}

对应的resource/mapper下创建UserMapper.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.gcxzflgl.redis.mapper.UserMapper">
 
<select id="query"  resultType="com.gcxzflgl.redis.domain.User">
    select id ,user_name 
    from sys_user 
    where 1=1
    <if test="userName != null">
      and user_name like CONCAT('%',#{userName},'%')
    </if>
</select>
</mapper>

8.再service层引入业务方法类UserService

package com.gcxzflgl.redis.biz;


/**
 * @author gcxzf$
 * @version : UserService$, v 0.1 2020/6/13$ 15:16$ gcxzf$ Exp$
 */
@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;
 

    /**
     * 查找user
     * @param id
     * @return
     */
    public User find(String id){     
        User users = userMapper.find(id); 
        return users;  
    }
}

9.再rest报下创建UserController

package com.gcxzflgl.redis.rest;


/**
 * @author gcxzf$
 * @version : UserController$, v 0.1 2020/6/13$ 15:12$ gcxzf$ Exp$
 */

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 查找指定user
     * @param id
     * @return
     */
    @GetMapping("/find")
    public User find(@RequestParam(value = "id",required = true) String id){
        return userService.find(id);
    }
}

10.启动项目访问:http://xxx.xxx.xx.xx:8080/find?id=1
在这里插入图片描述

Springboot与Cache整合使用

SpringCache 常用注解

@Cacheable(查)来划分可缓存的方法 - 即，结果存储在缓存中的方法，以便在后续调用（具有相同的参数）时，返回缓存中的值而不必实际执行该方法
@CachePut（修改、增加）当需要更新缓存而不干扰方法执行时，可以使用@CachePut注释。也就是说，始终执行该方法并将其结果放入缓存中（根据@CachePut选项）
@CacheEvict（删除） ：对于从缓存中删除陈旧或未使用的数据非常有用，指示缓存范围内的驱逐是否需要执行而不仅仅是一个条目驱逐

改造现有代码：

1.再pom.xml引入依赖

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

2.再启动类RedisApplication.java中开启cache缓存注解@EnableCaching

package com.gcxzflgl.redis;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class RedisApplication {

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

}

3.改造userservice类
首先再UserService类上添加注解 @CacheConfig(cacheNames = “userCache”) 此类的cache缓存名称统一userCache开头
再find方法中添加注解 @Cacheable(key = “#p0”,unless = “#result == null”) key = "#p0"代表缓存的key格式：userCache::id 作为缓存key,unless 代表如果查询结果返回null不进行缓存
完整代码如下：

package com.gcxzflgl.redis.biz;



/**
 * @author gcxzf$
 * @version : UserService$, v 0.1 2020/6/13$ 15:16$ gcxzf$ Exp$
 */
@Service
@CacheConfig(cacheNames = "userCache")
public class UserService {

    @Autowired
    private UserMapper userMapper;

    /**
     * 查找user
     * @param id
     * @return
     */
    @Cacheable(key = "#p0",unless = "#result == null")
    public User find(String id){
        User user = userMapper.find(id);
        System.out.println("缓存中不存在user");
        return user;
    }
}

4.重启项目测试，查看缓存是否存在
访问地址：http://xxx.xxx.xx.xx:8080/find?id=1
在这里插入图片描述
5.其余缓存注解大同小异，本文不再演示

Redis作为mybatis二级缓存

先引申一个问题：springboot cache 存在什么问题，
第一，生成key过于简单，容易冲突userCache::1
第二，无法设置过期时间，默认过期时间为永久不过期
第三，配置序列化方式，默认的是序列化JDKSerialazable

为了解决这个问题，我们再次改造工程代码

1.自定义KeyGenerator，本文采用（类名+方法名做唯一性区分）
2.自定义cacheManager，设置缓存过期时间
3.自定义序列化方式，Jackson
再RedisConfig中配置如下代码：

1.再config包下RedisCofig.java新增方法

/**
     * 使用类名+方法名作为缓存key
     * @return
     */
    @Bean
    public KeyGenerator simpleKeyGenerator() {
        return (o, method, objects) -> {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(o.getClass().getSimpleName());
            stringBuilder.append(".");
            stringBuilder.append(method.getName());
            stringBuilder.append("[");
            for (Object obj : objects) {
                stringBuilder.append(obj.toString());
            }
            stringBuilder.append("]");

            return stringBuilder.toString();
        };
    }

    /**
     * 设置cache缓存过期时间
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return new RedisCacheManager(
                RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                this.getRedisCacheConfigurationWithTtl(600), // 默认策略，未配置的 key 会使用这个
                this.getRedisCacheConfigurationMap() // 指定 key 策略
        );
    }

    /**
     * 给指定类型的key设置过期时间
     * @return
     */
    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
        //指定cache头名称为UserInfoList的方法缓存过期时间为100s
        redisCacheConfigurationMap.put("UserInfoList", this.getRedisCacheConfigurationWithTtl(100));
         //指定cache头名称为UserInfoListAnother的方法缓存过期时间为100s
        redisCacheConfigurationMap.put("UserInfoListAnother", this.getRedisCacheConfigurationWithTtl(18000));

        return redisCacheConfigurationMap;
    }

	/**
     * 设置过期时间，并指定序列化方式为Jackson
     * @param seconds
     * @return
     */
    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        Jackson2JsonRedisSerializer<Object> 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);

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                RedisSerializationContext
                        .SerializationPair
                        .fromSerializer(jackson2JsonRedisSerializer)
        ).entryTtl(Duration.ofSeconds(seconds));

        return redisCacheConfiguration;
    }
    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        Jackson2JsonRedisSerializer<Object> 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);

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                RedisSerializationContext
                        .SerializationPair
                        .fromSerializer(jackson2JsonRedisSerializer)
        ).entryTtl(Duration.ofSeconds(seconds));

        return redisCacheConfiguration;
    }

2.配置以上策略后，需要再UserService类中的find方法上指定缓存策略改造如下：

package com.gcxzflgl.redis.biz;

import com.gcxzflgl.redis.domain.User;
import com.gcxzflgl.redis.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;


/**
 * @author gcxzf$
 * @version : UserService$, v 0.1 2020/6/13$ 15:16$ gcxzf$ Exp$
 */
@Service
@CacheConfig(cacheNames = "userCache")
public class UserService {

    @Autowired
    private UserMapper userMapper;

    /**
     * 查找user
     * @param id
     * @return
     */
//    @Cacheable(key = "#p0",unless = "#result == null")
    @Cacheable(value = "UserInfoList", keyGenerator = "simpleKeyGenerator") // @Cacheable 会先查询缓存，如果缓存中存在，则不执行方法
    public User find(String id){
        User user = userMapper.find(id);
        System.out.println("缓存中不存在user");
        return user;
    }
}

3.再次重启项目测试验证方法
访问地址：http://xxx.xxx.xx.xx:8080/find?id=1
在这里插入图片描述

4.测试验证redis缓存和数据库进行对比
准备条件：
1）再userservice中复制一个find方法不配置注解，只是方便演示，controller同理：

/**
     * 查找user（noCache）
     * @param id
     * @return
     */
    public User findNoCache(String id){
        User user = userMapper.find(id);
        return user;
    }

  /**
     * 查找user(noCache)
     * @param id
     * @return
     */
    @GetMapping("/findNoCache")
    public User findNoCache(@RequestParam(value = "id",required = true) String id){
        return userService.findNoCache(id);
    }

）2.Linux上安装测试工具 apache abtest

abtest的安装
1）yum install -y httpd-tools
2）ab -V检验是否安装成功

验证地址：
ab -n1000 -c10 http://xxx.xxx.xx.xx:8080/findNoCache?id=2
ab -n1000 -c10 http://xxx.xx.xx.xx:8080/find?id=2

参数说明：
1）-n:进行http请求的总个数
2）-c:请求的client个数，也就是请求并发数
3) 统计qps：qps即每秒并发数，request per second

测试案例:

10个并发情况下1000请求执行参数（没用缓存）

[root@redis-master src]# ab -n1000 -c10 http://192.168.124.3:8080/findNoCache?id=2
This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking 192.168.124.3 (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests


Server Software:        
Server Hostname:        192.168.124.3
Server Port:            8080

Document Path:          /findNoCache?id=2
Document Length:        33 bytes

Concurrency Level:      10
Time taken for tests:   8.282 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      138000 bytes
HTML transferred:       33000 bytes
Requests per second:    120.75 [#/sec] (mean) （qps结果）
Time per request:       82.819 [ms] (mean)
Time per request:       8.282 [ms] (mean, across all concurrent requests)
Transfer rate:          16.27 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0   75 700.0      1    7018
Processing:     1    3   2.8      3      40
Waiting:        0    3   2.8      3      39
Total:          2   78 700.0      4    7022

Percentage of the requests served within a certain time (ms)
  50%      4
  66%      5
  75%      6
  80%      6
  90%      7
  95%      8
  98%     20
  99%   7016
 100%   7022 (longest request)

10个并发情况下1000请求执行参数（使用缓存）

[root@redis-master src]# ab -n1000 -c10 http://192.168.124.3:8080/find?id=2
This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking 192.168.124.3 (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests


Server Software:        
Server Hostname:        192.168.124.3
Server Port:            8080

Document Path:          /find?id=2
Document Length:        33 bytes

Concurrency Level:      10
Time taken for tests:   1.565 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      138000 bytes
HTML transferred:       33000 bytes
Requests per second:    638.99 [#/sec] (mean) （qps结果）
Time per request:       15.650 [ms] (mean)
Time per request:       1.565 [ms] (mean, across all concurrent requests)
Transfer rate:          86.11 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    7  70.6      2    1003
Processing:     1    3   1.0      3       9
Waiting:        1    3   0.9      3       8
Total:          1   10  70.5      5    1005

Percentage of the requests served within a certain time (ms)
  50%      5
  66%      5
  75%      6
  80%      6
  90%      6
  95%      7
  98%      8
  99%     10
 100%   1005 (longest request)

其他测试条件：

10个并发的情况下 1000请求redis qps：963.85[#/sec] (mean) DB qps： 766.75 [#/sec] (mean)
100个并发的情况下 1000请求redis qps：1130.60 [#/sec] (mean) DB qps：956.15 [#/sec] (mean)
100个并发的情况下10000请求redsi qps: 2102.39 [#/sec] (mean) DB qps: 679.07 [#/sec] (mean)
500个并发的情况下 10000请求redis qps：374.91 [#/sec] (mean) DB qps：扛不住

Redis分布式session共享

1、cookie与session
1） Cookie是什么？ Cookie 是一小段文本信息，伴随着用户请求和页面在 Web 服务器和浏览器之间传递。Cookie 包含每次用户访问站点时 Web 应用程序都可以读取的信息，我们可以看到在服务器写的cookie，会通过响应头Set-Cookie的方式写入到浏览器

2）HTTP协议是无状态的，并非TCP一样进行三次握手，对于一个浏览器发出的多次请求，WEB服务器无法区分是不是来源于同一个浏览器。所以服务器为了区分这个过程会通过一个
sessionid来区分请求，而这个sessionid是怎么发送给服务端的呢。cookie相对用户是不可见的，用来保存这个sessionid是最好不过了

1.再pom.xml引入依赖

 <dependency>
     <groupId>org.springframework.session</groupId>
     <artifactId>spring-session-data-redis</artifactId>
 </dependency>

2.再RedisConfig.java类上添加注解，指定过期时间50s

@EnableRedisHttpSession(maxInactiveIntervalInSeconds= 50)

3.再rest包下新增SessionController，重启工程测试

package com.gcxzflgl.redis.rest;

@RestController
public class SessionController {

    @RequestMapping(value = "/setSession", method = RequestMethod.GET)
    public Map<String, Object> setSession (HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        request.getSession().setAttribute("request Url", request.getRequestURL());
        map.put("request Url", request.getRequestURL());
        return map;
    }

    @RequestMapping(value = "/getSession", method = RequestMethod.GET)
    public Object getSession (HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        map.put("sessionIdUrl",request.getSession().getAttribute("request Url"));
        map.put("sessionId", request.getSession().getId());
        return map;
    }
}

3 .用谷歌和火狐浏览器进行验证
谷歌在这里插入图片描述
火狐
在这里插入图片描述
查看结果 (再次刷新session时间从新累计50s进行倒计时)
在这里插入图片描述

至此，基本的使用讲解列举完毕!

下章更新Redis实时排行榜！

待烟火清凉
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot与redis的简单整合实例
08-26
SpringBoot与Redis的简单整合实例 本文主要介绍了如何将SpringBoot与Redis进行简单整合，实现缓存、消息代理和键值存储的功能。 Redis简介 Redis是一个缓存、消息代理和功能丰富的键值存储。它可以用来存储和检索...
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
Redis 缓存(Cache)
ikun66666的博客
02-19 1909
Redis 缓存(Cache)
springbootCache和Redis缓存机制
m0_48159893的博客
02-09 3965
简介 我想要开发一个社交网站，社交网站存储好友列表成为了开发过程中的一大难题。 如果我想要保存每一个用户的好友信息该怎么保存呢？ 用用户的id对应着好友的id，这样一条信息就是一个好友关系映射图，这张关系表可能长下面这样 id user_id friend_id 1 1 2 2 1 一个用户的好友由friend_id记录，1号用户和2号用户互为好友，这样的记录虽然冗余但是不得不记录下来。但是这样有很大的弊端。 假设我有200个用户，每个用户有300个好友，那么这样一张表就会有200
SpringCache+redis实现缓存
最新发布
蓝天it（让亿万孩子在蓝天下共享优质教育）
05-19 912
Spring Cache是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能，大大简化我们在业务中操作缓存的代码。Spring Cache只是提供了一层抽象，底层可以切换不同的cache实现。具体就是通过CacheManager接口来统一不同的缓存技术。CacheManager是Spring提供的各种缓存技术抽象接口。
SpringBoot+SpringCache+Redis整合
溪c的博客
05-24 1020
文章目录1. SpringCache1.1 SpringCache 依赖1.1.1 SpringCache的好处2. SpringCache使用2.1 @EnableCaching2.2 @Cacheable2.2.1 KeyGenerator 自动生成2.2.2 显式指定 key2.2.3 **condition**2.3 @CacheEvict2.4 使用Redis做缓存2.4.1 Redis依赖2.4.2 Redis 配置2.4.3 SpringCache使用自定义序列化器3. 继续SpringCac
SpringBoot整合Redis缓存
凉茶铺的博客
07-15 4740
7）基于注解的Redis缓存更新测试。先通过浏览器访问“http//localhost8080/updateComment/1/shitou”更新id为1的评论作者名为shitou；接着，继续访问“http//localhost8080/findCommentById?id=1”查询id为1的用户评论信息可以看出，执行updateComment()方法更新id为1的数据时执行了一条更新SQL语句，后续调用findById()方法查询id为1的用户评论信息时没有执行查询SQL语句，且浏览器正确返回。.....
Sprintboot redis 采用gzip和Snappy compress压缩数据
zzhongcy的专栏
09-09 4197
1 前言 怎么使用和结合Sprintboot + redis ，可以参照我前面的文章：https://blog.csdn.net/zzhongcy/article/details/102584028 这里主要讲述当生产环境中，单个redis数据很大时，我们可能就要考虑压缩数据后再存入redis了。 压缩数据优缺点： 优点1：压缩会减少redis存储数据量，增加redis的吞吐量 优点2：压缩会较少网络带宽 缺点就是会增加CPU消耗 2 Sprintboot redis配置 有两种配置方式，如下
springboot与redis整合
10-26
SpringBoot与Redis整合是现代Java开发中常见的技术组合，尤其适用于构建高性能、高并发的Web应用。SpringBoot简化了配置和集成第三方库的过程，而Redis则作为内存数据存储，提供了高速的数据读写能力。以下是对这个...
SpringBoot+redis+RabbitMq整合实例
07-13
总的来说，Spring Boot+Redis+RabbitMq的整合提供了高效的数据缓存和消息传递机制，对于构建可扩展、高可用的分布式系统具有极大的价值。通过理解和掌握这些技术，开发者可以更好地应对复杂的企业级项目挑战。
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
配置Spring4.0注解Cache+Redis缓存的用法
08-30
本篇文章主要介绍了详解配置Spring4.0注解Cache+Redis缓存的用法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
SpringBoot-Cache-Redis
林北
05-12 789
SpringBoot缓存 SpringBoot缓存的运行原理 缓存的自动配置类CacheAutoConfiguration导入了CacheConfigurationImportSelector 其为我们导入了十个缓存配置类 默认生效的是SimpleCacheConfiguration 其给容器中注册了一个CacheManager:ConcurrentMapCacheManager 获取和创建...
一起来学 SpringBoot 2.x | 第十篇：使用 Spring Cache 集成 Redis
芋道源码
11-08 347
点击上方“芋道源码”，选择“置顶公众号”技术文章第一时间送达！源码精品专栏 精尽 Dubbo 原理与源码 69 篇精尽 Netty 原理与源码 61 篇中文详细注释的开源...
【快学SpringBoot】Spring Cache+Redis实现高可用缓存解决方案
weixin_30635053的博客
07-25 150
前言 之前已经写过一篇文章介绍SpringBoot整合Spring Cache，SpringBoot默认使用的是ConcurrentMapCacheManager，在实际项目中，我们需要一个高可用的、分布式的缓存解决方案，使用默认的这种缓存方式，只是在当前进程里缓存了而已。Spring Cache整合Redis来实现缓存，其实也不是一件复杂的事情，下面就开始吧。 关于Spring Cache的运用...
缓存之SpringCache整合redis(五)
酷酷的馫博客
01-31 1349
springCache并没有对写模式进行特别的配置和处理，要根据不同的场景进行不同的操作。因为默认缓存，存的是JDK序列化的内容，如果我们要想存JSON怎么办呢？加随机时间 (time-to-live: 60000)。加锁 @Cacheable(sync = true)。：不影响方法执行，更新缓存。：共享缓存配置（类级别）。大量并发查询过期的缓存。查询为null的数据。
SpringBoot+Redis完成数据缓存（内容丰富度一定超出你的想象）
IT小辉同学
05-19 3393
亲爱的朋友， 今天我想对你说：相信梦想，你一定会成功！无论你的梦想是什么，只要你坚定地追求它，不断努力，就一定能够实现。 在这个世界上，有很多人因为对自己的梦想缺乏信心而放弃了追求。但是，我相信你是一个勇敢的人，你会选择坚持自己的梦想，不放弃，不言败。因为你知道，只有这样才能让自己变得更加出色。 当你遇到困难和挫折时，请不要气馁，因为这些都是成长的过程。只要你保持积极的心态，相信自己，不断学习和进步，你就一定会走向成功的彼岸。 最后，我祝愿你在追求梦想的路上一路顺风，心想事成。相信自己，勇往直前！
spring boot 使用Spring Cache集成Redis
HUAXIAL的博客
03-19 381
/***/__/**删除@param user 用户对象@return 操作结果*/__/**添加@param id key值@return 返回结果*/__/**删除@param id key值*/_###实现类为了方便演示数据库操作，直接定义了一个，这里的核心就是@Cacheable@CachePut三个注解_/**小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
spring cache整合redis实现springboot项目中的缓存功能
tigerhhzz的博客
03-22 628
Spring Cache是一个框架，实现了基于注解的缓存功能，只需要简单的加一个注解，就能实现缓存功能。提供了一层抽象，底层可以切换不同的cache实现。具体就是通过CacheManager接口统一不同的缓存技术。CacheManager是Spring提供的各种缓存技术抽象接口。
springboot整合rediscache
10-18
好的，针对您的问题，我可以给出以下步骤： 1. 在pom.xml中添加redis依赖： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> ``` 2. 在application.properties中配置redis连接信息： ``` spring.redis.host=127.0.0.1 spring.redis.port=6379 spring.redis.password= ``` 3. 创建RedisConfig类，配置RedisTemplate： ``` @Configuration public class RedisConfig { @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(factory); template.setKeySerializer(new StringRedisSerializer()); template.setValueSerializer(new GenericJackson2JsonRedisSerializer()); return template; } } ``` 4. 在需要使用缓存的方法上添加@Cacheable注解： ``` @Cacheable(value = "userCache", key = "#id") public User getUserById(String id) { // 从数据库中获取用户信息 } ``` 以上就是整合Redis缓存的基本步骤，您可以根据自己的需求进行调整。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值