redis应用

最新推荐文章于 2023-09-07 16:31:48 发布
最新推荐文章于 2023-09-07 16:31:48 发布
阅读量312 收藏 2
点赞数
分类专栏： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33314107/article/details/79402997
版权

一、依赖包

<dependency>
   <groupId>org.springframework.data</groupId>
   <artifactId>spring-data-redis</artifactId>
   <version>1.8.9.RELEASE</version>
</dependency>
<dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
   <version>2.9.0</version>
</dependency>

二、redis配置文件

1）java配置文件

package top.ibase4j.core.config;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import java.io.Serializable;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
import top.ibase4j.core.support.cache.RedisHelper;
import top.ibase4j.core.util.InstanceUtil;
import top.ibase4j.core.util.PropertiesUtil;

@Configuration
public class JedisConfig {
    public JedisConfig() {
    }

    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMinIdle(PropertiesUtil.getInt("redis.minIdle").intValue());
        config.setMaxIdle(PropertiesUtil.getInt("redis.maxIdle").intValue());
        config.setMaxTotal(PropertiesUtil.getInt("redis.maxTotal").intValue());
        config.setMaxWaitMillis((long)PropertiesUtil.getInt("redis.maxWaitMillis").intValue());
        config.setTestOnBorrow(Boolean.valueOf(PropertiesUtil.getString("redis.testOnBorrow")).booleanValue());
        return config;
    }

    @Bean
    public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig) {
        String nodes = PropertiesUtil.getString("redis.cluster.nodes");
        JedisConnectionFactory jedisConnectionFactory;
        if (StringUtils.isNotBlank(nodes)) {
            List<String> list = InstanceUtil.newArrayList(nodes.split(","));
            RedisClusterConfiguration configuration = new RedisClusterConfiguration(list);
            configuration.setMaxRedirects(PropertiesUtil.getInt("redis.cluster.max-redirects").intValue());
            jedisConnectionFactory = new JedisConnectionFactory(configuration, jedisPoolConfig);
            jedisConnectionFactory.setPassword(PropertiesUtil.getString("redis.password"));
        } else {
            jedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
            jedisConnectionFactory.setHostName(PropertiesUtil.getString("redis.host"));
            jedisConnectionFactory.setPort(PropertiesUtil.getInt("redis.port").intValue());
            jedisConnectionFactory.setPassword(PropertiesUtil.getString("redis.password"));
        }

        jedisConnectionFactory.setTimeout(PropertiesUtil.getInt("redis.timeout").intValue());
        return jedisConnectionFactory;
    }

    @Bean
    public RedisTemplate<?, ?> redisTemplate(JedisConnectionFactory jedisConnectionFactory) {
        RedisTemplate<Serializable, Serializable> redisTemplate = new RedisTemplate();
        StringRedisSerializer keySerializer = new StringRedisSerializer();
        GenericFastJsonRedisSerializer valueSerializer = new GenericFastJsonRedisSerializer();
        redisTemplate.setEnableTransactionSupport((new Boolean(PropertiesUtil.getString("redis.enableTransaction"))).booleanValue());
        redisTemplate.setConnectionFactory(jedisConnectionFactory);
        redisTemplate.setKeySerializer(keySerializer);
        redisTemplate.setValueSerializer(valueSerializer);
        redisTemplate.setHashKeySerializer(keySerializer);
        redisTemplate.setHashValueSerializer(valueSerializer);
        return redisTemplate;
    }

    @Bean
    @Qualifier("redisTemplate")
    public RedisHelper redisHelper(RedisTemplate<Serializable, Serializable> redisTemplate) {
        RedisHelper redisHelper = new RedisHelper();
        redisHelper.setRedisTemplate(redisTemplate);
        return redisHelper;
    }

    @Bean
    @Qualifier("redisTemplate")
    public CacheManager redisCacheManager(RedisTemplate<Serializable, Serializable> redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        cacheManager.setTransactionAware(true);
        cacheManager.setDefaultExpiration((long)PropertiesUtil.getInt("redis.expiration", 10));
        return cacheManager;
    }
}

2）xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c"
   xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd">
   <!-- jedis 配置 -->
   <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
      <!--最小空闲数 -->
      <property name="minIdle" value="${redis.minIdle}" />
      <!--最大空闲数 -->
      <property name="maxIdle" value="${redis.maxIdle}" />
      <!--最大连接数 -->
      <property name="maxTotal" value="${redis.maxTotal}" />
      <!--最大建立连接等待时间 -->
      <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
      <!--是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个 -->
      <property name="testOnBorrow" value="${redis.testOnBorrow}" />
   </bean>
   <!-- redisCluster配置 -->
   <bean id="redisProperty"
      class="org.springframework.core.io.support.ResourcePropertySource"
      c:name="redis.properties" c:resource="classpath:config/system.properties" />
   <bean id="redisClusterConfiguration"
      class="org.springframework.data.redis.connection.RedisClusterConfiguration">
      <constructor-arg name="propertySource" ref="redisProperty" />
   </bean>
   <!-- redis服务器中心 -->
   <bean id="jedisConnectionFactory" class="top.ibase4j.core.support.cache.jedis.ConnectionFactory"
      c:cluster-config-ref="redisClusterConfiguration" c:pool-config-ref="jedisPoolConfig"
      p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.password}"
      p:pool-config-ref="jedisPoolConfig" p:timeout="${redis.timeout}" />
   <!-- 缓存序列化方式 -->
   <bean id="keySerializer"
      class="org.springframework.data.redis.serializer.StringRedisSerializer" />
   <bean id="valueSerializer"
      class="com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer" />
   <!-- 缓存 -->
   <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
      <property name="connectionFactory" ref="jedisConnectionFactory" />
      <property name="enableTransactionSupport" value="true" />
      <property name="keySerializer" ref="keySerializer" />
      <property name="valueSerializer" ref="valueSerializer" />
      <property name="hashKeySerializer" ref="keySerializer" />
      <property name="hashValueSerializer" ref="valueSerializer" />
   </bean>
   <!-- 缓存管理 -->
   <bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
      <constructor-arg index="0" ref="redisTemplate" />
      <property name="transactionAware" value="true" />
      <property name="defaultExpiration" value="${redis.expiration}" />
   </bean>
</beans>

system.properties

redis.host=127.0.0.1
redis.port=6379
redis.password=123
#最小空闲数
redis.minIdle=2
#最大空闲数
redis.maxIdle=10
#最大连接数
redis.maxTotal=1000
#最大建立连接等待时间  
redis.maxWaitMillis=3000
#客户端超时时间单位是毫秒
redis.timeout=120000
#明是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个  
redis.testOnBorrow=true
redis.expiration=600
#rediscluster
spring.redis.cluster.nodes=
#spring.redis.cluster.nodes=127.0.0.1:7001,127.0.0.1:7002,127.0.0.1:7003,127.0.0.1:7004,127.0.0.1:7005,127.0.0.1:7006
spring.redis.cluster.max-redirects=3
#rediscluster
redis.master=
redis.slave=

import java.lang.reflect.Field;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import redis.clients.jedis.JedisPoolConfig;

public class ConnectionFactory extends JedisConnectionFactory {
    private Logger logger = LogManager.getLogger();
    private RedisClusterConfiguration clusterConfig;

    public ConnectionFactory(RedisClusterConfiguration clusterConfig, JedisPoolConfig poolConfig) {
        super(poolConfig);
        this.clusterConfig = clusterConfig;
    }

    public void afterPropertiesSet() {
        if (this.clusterConfig != null && this.clusterConfig.getClusterNodes() != null && !this.clusterConfig.getClusterNodes().isEmpty()) {
            try {
                Field clusterConfigField = JedisConnectionFactory.class.getDeclaredField("clusterConfig");
                clusterConfigField.setAccessible(true);
                clusterConfigField.set(this, this.clusterConfig);
            } catch (Exception var2) {
                this.logger.error("", var2);
            }
        }

        super.afterPropertiesSet();
    }
}

三、session 应用


package top.ibase4j.core.support.cache.shiro;

import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.apache.shiro.session.Session;
import org.apache.shiro.session.UnknownSessionException;
import org.apache.shiro.session.mgt.SimpleSession;
import org.apache.shiro.session.mgt.eis.AbstractSessionDAO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisStringCommands.SetOption;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import top.ibase4j.core.util.InstanceUtil;
import top.ibase4j.core.util.PropertiesUtil;
import top.ibase4j.core.util.SerializeUtil;

public class RedisSessionDAO extends AbstractSessionDAO {
    private static final int EXPIRE_TIME = 600;
    @Autowired
    private RedisTemplate<Serializable, Serializable> redisTemplate;

    public RedisSessionDAO() {
    }

    private RedisConnection getRedisConnection() {
        return this.redisTemplate.getConnectionFactory().getConnection();
    }

    public void update(Session session) throws UnknownSessionException {
        this.saveSession(session);
    }

    public void delete(Session session) {
        if (session != null) {
            Serializable id = session.getId();
            if (id != null) {
                RedisConnection redisConnection = this.getRedisConnection();

                try {
                    redisConnection.del(new byte[][]{this.buildRedisSessionKey(id)});
                } finally {
                    redisConnection.close();
                }
            }
        }

    }

    public Collection<Session> getActiveSessions() {
        List<Session> list = InstanceUtil.newArrayList();
        RedisConnection redisConnection = this.getRedisConnection();

        try {
            Set<byte[]> set = redisConnection.keys("S:iBase4J:SHIRO-SESSION:*".getBytes());
            Iterator var4 = set.iterator();

            while(var4.hasNext()) {
                byte[] key = (byte[])var4.next();
                list.add(SerializeUtil.deserialize(redisConnection.get(key), SimpleSession.class));
            }
        } finally {
            redisConnection.close();
        }

        return list;
    }

    public void delete(Serializable sessionId) {
        if (sessionId != null) {
            byte[] sessionKey = this.buildRedisSessionKey(sessionId);
            RedisConnection redisConnection = this.getRedisConnection();

            try {
                redisConnection.del(new byte[][]{sessionKey});
            } finally {
                redisConnection.close();
            }
        }

    }

    protected Serializable doCreate(Session session) {
        Serializable sessionId = this.generateSessionId(session);
        this.assignSessionId(session, sessionId);
        this.saveSession(session);
        return sessionId;
    }

    protected Session doReadSession(Serializable sessionId) {
        byte[] sessionKey = this.buildRedisSessionKey(sessionId);
        RedisConnection redisConnection = this.getRedisConnection();

        Session var6;
        try {
            byte[] value = redisConnection.get(sessionKey);
            Session session;
            if (value == null) {
                session = null;
                return session;
            }

            session = (Session)SerializeUtil.deserialize(value, SimpleSession.class);
            var6 = session;
        } finally {
            redisConnection.close();
        }

        return var6;
    }

    private void saveSession(Session session) {
        if (session != null && session.getId() != null) {
            byte[] sessionKey = this.buildRedisSessionKey(session.getId());
            int sessionTimeOut = PropertiesUtil.getInt("session.maxInactiveInterval", 600);
            byte[] value = SerializeUtil.serialize(session);
            RedisConnection redisConnection = this.getRedisConnection();

            try {
                redisConnection.set(sessionKey, value, Expiration.seconds((long)sessionTimeOut), SetOption.UPSERT);
            } finally {
                redisConnection.close();
            }

        } else {
            throw new UnknownSessionException("session is empty");
        }
    }

    private byte[] buildRedisSessionKey(Serializable sessionId) {
        return ("S:iBase4J:SHIRO-SESSION:" + sessionId).getBytes();
    }
}

四、与@Cacheable等注解引用

package org.ibase4j.service;

import java.util.List;
import java.util.Map;

import org.ibase4j.mapper.SysAuthorizeMapper;
import org.ibase4j.mapper.SysRoleMenuMapper;
import org.ibase4j.mapper.SysUserMenuMapper;
import org.ibase4j.mapper.SysUserRoleMapper;
import org.ibase4j.model.SysDic;
import org.ibase4j.model.SysMenu;
import org.ibase4j.model.SysRoleMenu;
import org.ibase4j.model.SysUserMenu;
import org.ibase4j.model.SysUserRole;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;

import top.ibase4j.core.Constants;
import top.ibase4j.core.base.BaseService;
import top.ibase4j.core.util.InstanceUtil;

/**
 * @author ShenHuaJie
 * @version 2016年5月20日 下午3:19:19
 */
@Service
@CacheConfig(cacheNames = "sysAuthorize")
public class SysAuthorizeService extends BaseService<SysMenu> {
   @Autowired
   private SysUserMenuMapper sysUserMenuMapper;
   @Autowired
   private SysUserRoleMapper sysUserRoleMapper;
   @Autowired
   private SysRoleMenuMapper sysRoleMenuMapper;
   @Autowired
   private SysAuthorizeMapper sysAuthorizeMapper;
   @Autowired
   private SysMenuService sysMenuService;
   @Autowired
   private SysDicService sysDicService;

   public List<String> queryMenuIdsByUserId(Long userId) {
      List<String> resultList = InstanceUtil.newArrayList();
      List<Long> list = sysUserMenuMapper.queryMenuIdsByUserId(userId);
      for (Long id : list) {
         resultList.add(id.toString());
      }
      return resultList;
   }

   @Transactional
   @CacheEvict(value = { Constants.CACHE_NAMESPACE + "menuPermission", Constants.CACHE_NAMESPACE + "sysPermission",
         Constants.CACHE_NAMESPACE + "userPermission" }, allEntries = true)
   public void updateUserMenu(List<SysUserMenu> sysUserMenus) {
      Long userId = null;
      for (SysUserMenu sysUserMenu : sysUserMenus) {
         if (sysUserMenu != null && sysUserMenu.getUserId() != null && "read".equals(sysUserMenu.getPermission())) {
            userId = sysUserMenu.getUserId();
         }
      }
      if (userId != null) {
         sysAuthorizeMapper.deleteUserMenu(userId, "read");
      }
      for (SysUserMenu sysUserMenu : sysUserMenus) {
         if (sysUserMenu != null && sysUserMenu.getUserId() != null && sysUserMenu.getMenuId() != null
               && "read".equals(sysUserMenu.getPermission())) {
            sysUserMenuMapper.insert(sysUserMenu);
         }
      }
   }

   @Cacheable(Constants.CACHE_NAMESPACE + "userPermission")
   public List<String> queryUserPermission(Long userId) {
      return sysUserMenuMapper.queryPermission(userId);
   }

}

package top.ibase4j.core.config;

import com.alibaba.fastjson.JSON;
import java.lang.reflect.Method;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {
    String prefix = "iBase4J:M:";

    public RedisCacheConfig() {
    }

    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            public Object generate(Object o, Method method, Object... objects) {
                StringBuilder sb = new StringBuilder(RedisCacheConfig.this.prefix);
                CacheConfig cacheConfig = (CacheConfig)o.getClass().getAnnotation(CacheConfig.class);
                Cacheable cacheable = (Cacheable)method.getAnnotation(Cacheable.class);
                CachePut cachePut = (CachePut)method.getAnnotation(CachePut.class);
                CacheEvict cacheEvict = (CacheEvict)method.getAnnotation(CacheEvict.class);
                String[] cacheNames;
                if (cacheable != null) {
                    cacheNames = cacheable.value();
                    if (ArrayUtils.isNotEmpty(cacheNames)) {
                        sb.append(cacheNames[0]);
                    }
                } else if (cachePut != null) {
                    cacheNames = cachePut.value();
                    if (ArrayUtils.isNotEmpty(cacheNames)) {
                        sb.append(cacheNames[0]);
                    }
                } else if (cacheEvict != null) {
                    cacheNames = cacheEvict.value();
                    if (ArrayUtils.isNotEmpty(cacheNames)) {
                        sb.append(cacheNames[0]);
                    }
                }

                if (cacheConfig != null && sb.toString().equals(RedisCacheConfig.this.prefix)) {
                    cacheNames = cacheConfig.cacheNames();
                    if (ArrayUtils.isNotEmpty(cacheNames)) {
                        sb.append(cacheNames[0]);
                    }
                }

                if (sb.toString().equals(RedisCacheConfig.this.prefix)) {
                    sb.append(o.getClass().getName()).append(".").append(method.getName());
                }

                sb.append(":");
                if (objects != null) {
                    Object[] var13 = objects;
                    int var10 = objects.length;

                    for(int var11 = 0; var11 < var10; ++var11) {
                        Object object = var13[var11];
                        sb.append(JSON.toJSONString(object));
                    }
                }

                return sb.toString();
            }
        };
    }
}


客 人
关注
专栏目录
Spring框架中的设计模式(四)
Details Inside Spring
04-01 355
这篇文章是该系列关于spring框架设计模式文章的第四篇，会继续介绍3个框架使用的设计模式。 最开始，我们会介绍两个结构设计模式：适配器模式adapter和装饰模式decorator。第三个，也就是本文最后一部分，我们会介绍一个对象创建设计模式：单例singleton。 Spring设计模式 - 适配器adapter 适配器模式应用在当我们需要将接口适配到特定的环境而且不需要修改接口自身...
读懂异常堆栈
ZhaoHaiTang的博客
05-19 569
构造函数、new对象的标识符： at com.ibatis.sqlmap.engine.transaction.user.UserProvidedTransaction.<init>(UserProvidedTransaction.java:39) 内部类的标识符： at o.s.j.d.TransactionAwareDataSourceProxy$TransactionAwareInvocationHandler.invoke(TransactionAwareData...
springboot2.X 整合redis，使用注解进行快速的缓存
u012357455的博客
06-21 2492
1、springboot版本>2.0,低版本不在此篇幅中 2、引入pom <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data...
使用redis对热点数据进行缓存
weixin_53693850的博客
09-07 1270
虽然它本身并没有提供缓存的实现，但是它提供了一整套的接口和代码规范、配置、注解等，这样它就可以整合各种缓存方案了，比如 Redis、Ehcache，我们也就不用关心操作缓存的细节。本人做的是一个博客系统，使用redis对文章的信息进行缓存，比如说要去查询最热文章，首页的文章展示，对项目的查询接口的数据我们可以将其放入缓存中，这样子不仅可以做到查询速度快，当有大量的用户请求该接口时还能够减轻数据库的负担，提高博客浏览的速度。key缓存的key规则，可以使用springEL表达式，默认是方法参数组合。
Redis之RedisTemplate配置方式(序列和反序列化)（八）
zwj1030711290的CSDN
11-04 6245
POJO对象的存取场景，使用JDK本身序列化机制，将pojo类通过ObjectInputStream/ObjectOutputStream进行序列化操作，最终redis-server中将存储字节序列。是目前默认的序列化策略。：Key或者value为字符串的场景，根据指定的charset对数据的字节序列编码成string，是“new String(bytes, charset)”和“string.getBytes(charset)”的直接封装。是最轻量级和高效的策略。
Linge-互联网行业中Redis的应用.pptx，Redis应用讲解PPT文件
最新发布
08-15
Linge-互联网行业中Redis的应用.pptx==Redis应用讲解PPT文件。Redis（Remote Dictionary Server )，远程字典服务，是一个开源的使用C语言编写、支持网络、可基于内存、分布式、可选持久性的键值对(Key-Value)存储...
最全面的Redis应用代码
03-28
这个压缩包文件包含的"最全面的Redis应用代码"为学习者提供了丰富的资源，涵盖了Redis的多种应用场景和实现方式。让我们深入探讨Redis的基础知识、主要特性和常见应用场景。 1. Redis基础概念： - Redis是Remote ...
grafana-redis-app:用于Grafana的Redis应用程序插件
04-18
用于Grafana的Redis应用程序插件 概括 介绍 什么是Grafana的Redis应用程序？ Redis应用程序是Grafana的插件，它为Redis数据源提供应用程序页面和自定义面板： 命令行界面（CLI） 命令延迟（图形和表格） 按键...
Redis Redis 应用构建实例.flv
02-14
Redis Redis 应用构建实例.flv
redis应用场景简介
05-06
去年我写的培训用教材，redis应用场景简介，简单列举了一些Redis的使用场景。 发现下载积分居然无法调整……
微服务学习系列9：RedisTemplate
yangyanping20108的博客
04-04 296
当我们的数据存储到 Redis 的时候，我们的键（key）和值（value）都是通过 Spring 提供的 Serializer 序列化到数据库的
Redis 序列化方式StringRedisSerializer、FastJsonRedisSerializer和KryoRedisSerializer
热门推荐
xiaolyuh的专栏
11-30 4万+
当我们的数据存储到Redis的时候，我们的键（key）和值（value）都是通过Spring提供的Serializer序列化到数据库的。RedisTemplate默认使用的是JdkSerializationRedisSerializer，StringRedisTemplate默认使用的是StringRedisSerializer。 Spring Data JPA为我们提供了下面的Serializ...
浅谈RedisTemplate利用pipeline进行高效率批量操作
liyiyu123的博客
04-19 1万+
一.为什么使用pipeline? 了解redis的小伙伴都知道，redis是一个高性能的单线程的key-value数据库。它的执行过程为： （1）发送命令－〉（2）命令排队－〉（3）命令执行－〉（4）返回结果 如果我们使用redis进行批量插入数据，正常情况下相当于将以上四个步骤批量执行N次。（1）和（4）称为Round Trip Time（RTT，往返时间）。在一条简单指令中，往往（1）...
Springboot集成Redis缓存及分布式锁示例
yancaobisi的专栏
07-28 458
redis缓存及分布式锁示例
Spring Boot 2.0.2 整合 Redis 2.0.7
qq905954401的博客
06-27 1017
前言        之前做的项目的后端使用的Spring Boot + Mybatis + Shiro。后面根据需求需要添加Redis，以下内容是我在整合Redis时的重点的步骤以及遇到的坑。1、POM文件添加依赖&lt;dependency&gt;     &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;     &lt;artifa...
原创SpringMvc+Mybatis+Redis框架
刘岗强的专栏
11-07 9268
声明： 本人提供这个 SpringMvc + Mybatis + Redis 的Demo 本着学习的态度，如果有欠缺和不足的地方，给予指正，并且多多包涵 框架运行环境： Maven版本：3.3.9 Eclipse版本：MARS.2 JDK版本：1.8 Tocat版本：8.0.36 框架结构：框架全采用maven管理 所以源码只有180KB左右要是不会Maven就请自行补习 in
java json序列化工具类_为Redis配置自定义fastJson序列化工具类
weixin_33958871的博客
02-24 492
alibaba.fastjson内部已经提供了对Redis存储对象序列化的工具类GenericFastJsonRedisSerializer，但是该工具在反序列化时返回为Object，我们仿照GenericFastJsonRedisSerializer来自定义一个扩展的工具类，反序列化后自动转化为指定的java对象。GenericFastJsonRedisSerializer 源码package ...
springboot 使用 FastJsonRedisSerializer 序列化
纯真年代~大数据
08-28 8465
springboot 使用fastjson redis序列化配置 依赖引入 <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>${fastjson.version}</version> </dependency> 配置 @Configuration @EnableC
Redis应用全解析：从基础到实战
Redis应用场景的详细介绍如下： 1. **缓存**：Redis的高速读写性能使其成为理想的缓存解决方案。它可以缓存数据库查询结果，减少对数据库的访问压力，提高系统整体响应速度。例如，可以使用`GET`和`SET`命令存储和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值