首页 / REDIS / Spring Boot—18Redis

Spring Boot—18Redis

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Spring Boot—18Redis，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含16730字，纯文字阅读大概需要24分钟。

内容图文

pom.xml

            <
            dependency
            >
            <
            groupId
            >mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.11</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>1.1.9</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId><version>2.5.0</version></dependency>

application.properties

            #
server.address=0.0.0.0
server.port=8080
server.servlet.context-path=/test
server.session.timeout=300
server.error.path=/error
#
server.tomcat.accesslog.enabled=true
server.tomcat.accesslog.buffered=true
server.tomcat.accesslog.directory=D:/Project/JavaWeb/SpringBoot/04JPASpringBoot/logs
#
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=Asia/Shanghai
#
spring.thymeleaf.cache=true
spring.thymeleaf.enabled=true

file.upload.path=D:/Project/JavaWeb/SpringBoot/04JPASpringBoot/fileUpLoad

spring.servlet.multipart.enabled=true
spring.servlet.multipart.file-size-threshold=0
spring.servlet.multipart.location=D:/Project/JavaWeb/SpringBoot/04JPASpringBoot/temp
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB
spring.servlet.multipart.resolve-lazily=false


spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.druid.one.url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.druid.one.username=root
spring.datasource.druid.one.password=gis
spring.datasource.druid.one.driver-class-name=com.mysql.cj.jdbc.Driver

##Druid
spring.datasource.druid.one.initial-size=2
spring.datasource.druid.one.max-active=5
spring.datasource.druid.one.min-idle=1
spring.datasource.druid.one.max-wait=60000
spring.datasource.druid.one.pool-prepared-statements=true
spring.datasource.druid.one.max-pool-prepared-statement-per-connection-size=20
spring.datasource.druid.one.validation-query=SELECT 1 FROM DUAL
spring.datasource.druid.one.validation-query-timeout=60000
spring.datasource.druid.one.test-on-borrow=false
spring.datasource.druid.one.test-on-return=false
spring.datasource.druid.one.test-while-idle=true
spring.datasource.druid.one.time-between-eviction-runs-millis=60000
spring.datasource.druid.one.min-evictable-idle-time-millis=100000
#spring.datasource.druid.one.max-evictable-idle-time-millis=
spring.datasource.druid.one.filters=stat,wall,log
spring.datasource.druid.one.logSlowSql=true

#
# debug=true # Enable debug logs.
# trace=true # Enable trace logs.

spring.redis.host=127.0.0.1
spring.redis.password=gis
spring.redis.port=6379
spring.redis.pool.max-active=8
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.max-idle=8
spring.redis.jedis.pool.max-wait=-1ms
spring.redis.jedis.pool.min-idle=0
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.min-idle=0
spring.redis.lettuce.shutdown-timeout=100ms
spring.redis.ssl=false
spring.redis.timeout=5000

redis.message.topic=spring.news.*

启动类

            package
             com.smartmap.sample.test;


            import
             org.springframework.boot.SpringApplication;

            import
             org.springframework.boot.autoconfigure.SpringBootApplication;

            import
             org.springframework.transaction.annotation.EnableTransactionManagement;


            import
             com.smartmap.sample.test.conf.DataSourceConfiguration;

@EnableTransactionManagement
@SpringBootApplication

            public
            class
             TestRedisApplication {

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

    }

}

注册Redis消息监听

            package
             com.smartmap.sample.test.conf;


            import
             org.apache.commons.logging.Log;

            import
             org.apache.commons.logging.LogFactory;

            import
             org.springframework.beans.factory.annotation.Value;

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

            import
             org.springframework.data.redis.listener.PatternTopic;

            import
             org.springframework.data.redis.listener.RedisMessageListenerContainer;


            import
             com.smartmap.sample.test.message.RedisMessageListener;

@Configuration

            public
            class
             RedisChannelListenerConfiguration {
    Log log = LogFactory.getLog(RedisChannelListenerConfiguration.class);
    
    @Value("${redis.message.topic}")
    private String topic;
    
    /**
     * 注册Redis事件监听
     * publish spring.news.user bobobo
     * 
     * @param connectionFactory
     * @param listenerAdapter
     * @return*/
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
            RedisMessageListener listenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(listenerAdapter, new PatternTopic(topic));
        log.info("------------> " + topic);
        return container;
    }

    @Bean
    StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
        returnnew StringRedisTemplate(connectionFactory);
    }
}

Redis消息处理类

            package
             com.smartmap.sample.test.message;


            import
             org.apache.commons.logging.Log;

            import
             org.apache.commons.logging.LogFactory;

            import
             org.springframework.beans.factory.annotation.Autowired;

            import
             org.springframework.data.redis.connection.Message;

            import
             org.springframework.data.redis.connection.MessageListener;

            import
             org.springframework.data.redis.core.StringRedisTemplate;

            import
             org.springframework.stereotype.Service;

@Service

            public
            class RedisMessageListener implements MessageListener {
    final Log log = LogFactory.getLog(RedisMessageListener.class);

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    publicvoid setRedisTemplate(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    publicvoid onMessage(Message message, byte[] pattern) {
        byte[] bodyByte = message.getBody();
        byte[] channelByte = message.getChannel();
        String content = (String) stringRedisTemplate.getValueSerializer().deserialize(bodyByte);
        String topic = (String) stringRedisTemplate.getStringSerializer().deserialize(channelByte);
        log.info(topic + "    " + content);
    }
}

Redis配置类

            package
             com.smartmap.sample.test.conf;


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

            import
             org.springframework.data.redis.serializer.RedisSerializer;

            import
             org.springframework.data.redis.serializer.StringRedisSerializer;


            import
             com.fasterxml.jackson.databind.ObjectMapper;

@Configuration

            public
            class
             RedisConfiguration {

    @Bean("stringJsonRedisTemplate")
    public RedisTemplate<Object, Object> stringJsonRedisTemplate(RedisConnectionFactory redisConnectionFactory,
            ObjectMapper mapper) {
        RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setDefaultSerializer(new GenericJackson2JsonRedisSerializer(mapper));
        RedisSerializer<String> stringSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringSerializer);
        template.setHashKeySerializer(stringSerializer);
        return template;
    }
}

JSON转换配置类

            package
             com.smartmap.sample.test.conf;


            import
             java.text.SimpleDateFormat;


            import
             org.springframework.context.annotation.Bean;

            import
             org.springframework.context.annotation.Configuration;


            import
             com.fasterxml.jackson.databind.ObjectMapper;

@Configuration

            public
            class
             JacksonConfiguration {
    @Bean
    
            public
             ObjectMapper getObjectMapper() {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));        
        return objectMapper;
    }
}

实体类 User

            package
             com.smartmap.sample.test.entity;


            import
             java.util.Date;


            import
             com.fasterxml.jackson.annotation.JsonBackReference;



            public
            class
             User {

    
            private
             Long id;
    
    
            private
             String name;
    
    @JsonBackReference 
            //
             防止相互引用，出现无限引用递归    
            private
             Department department;
    
    
            private
             Date createTime;

    
            public
             User() {
    }

    
            public
             User(Long id, String name, Department department, Date createTime) {
        
            super
            ();
        
            this.id = id;
        this.name = name;
        this.department = department;
        this.createTime = createTime;
    }

    public Long getId() {
        return id;
    }

    publicvoid setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    publicvoid setName(String name) {
        this.name = name;
    }

    public Department getDepartment() {
        return department;
    }

    publicvoid setDepartment(Department department) {
        this.department = department;
    }

    public Long getDepartmentId() {
        returnthis.department == null ? null : this.department.getId();
    }

    publicvoid setDepartmentId(Long departmentId) {
        if (this.department != null) {
            this.department.setId(departmentId);
        }
    }

    public Date getCreateTime() {
        return createTime;
    }

    publicvoid setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

}

实体类Department

            package
             com.smartmap.sample.test.entity;


            import
             java.util.HashSet;

            import
             java.util.Set;

            import
             com.fasterxml.jackson.annotation.JsonManagedReference;



            public
            class
             Department {
    
    
            private
             Long id;
        
    
            private
             String name;
    
    @JsonManagedReference  
            //
             防止相互引用，出现无限引用递归    
            private Set<User> users = new HashSet<User>();

    public Long getId() {
        return id;
    }

    publicvoid setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    publicvoid setName(String name) {
        this.name = name;
    }

    public Set<User> getUsers() {
        return users;
    }

    publicvoid setUsers(Set<User> users) {
        this.users = users;
    }    
}

DAO类

            package
             com.smartmap.sample.test.dao.impl;


            import
             java.io.UnsupportedEncodingException;

            import
             java.util.ArrayList;

            import
             java.util.List;


            import
             org.apache.commons.logging.Log;

            import
             org.apache.commons.logging.LogFactory;

            import
             org.springframework.beans.factory.annotation.Autowired;

            import
             org.springframework.beans.factory.annotation.Qualifier;

            import
             org.springframework.dao.DataAccessException;

            import
             org.springframework.data.redis.connection.RedisConnection;

            import
             org.springframework.data.redis.core.RedisCallback;

            import
             org.springframework.data.redis.core.RedisTemplate;

            import
             org.springframework.data.redis.core.ValueOperations;

            import
             org.springframework.stereotype.Repository;

            import
             com.fasterxml.jackson.databind.ObjectMapper;

            import
             com.smartmap.sample.test.dao.UserDao;

            import
             com.smartmap.sample.test.entity.User;

@Repository

            public
            class UserDaoImpl implements UserDao {
    final Log log = LogFactory.getLog(UserDaoImpl.class);

    @Autowired
    private ObjectMapper objectMapper;

    @Autowired
    @Qualifier("stringJsonRedisTemplate")
    private RedisTemplate<Object, Object> redisTemplate;

    public Long addRootUser(User user) {
        String key = "info:root:user";
        redisTemplate.opsForValue().set(key, user);

        Object obj = redisTemplate.opsForValue().get(key);
        User userResult = objectMapper.convertValue(obj, User.class);
        // User userResult = (User) redisTemplate.opsForValue().get(key);if (userResult != null) {
            return 1L;
        }
        return 0L;
    }

    public User getRootUser() {
        String key = "info:root:user";
        Object obj = redisTemplate.opsForValue().get(key);
        User userResult = objectMapper.convertValue(obj, User.class);
        return userResult;
    }

    public Long addUser(User user) {
        String key = "info:users";
        Long count = redisTemplate.opsForList().leftPush(key, user);
        return count;
    }

    public List<User> getUsers() {
        String key = "info:users";
        List<Object> objectList = (List<Object>) (redisTemplate.opsForList().range(key, 0, -1));
        List<User> userList = new ArrayList<User>();
        objectList.forEach((k) -> {
            userList.add(objectMapper.convertValue(k, User.class));
        });

        return userList;
    }

    public Long removeUser(Long userId) {
        String key = "info:users";
        User user = (User) redisTemplate.opsForList().leftPop(key);
        return user != null ? 1L : 0L;
    }

    public String connectionSet(final String key, final String value) {
        Object obj = redisTemplate.execute(new RedisCallback<Object>() {

            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                String message = "fail";
                try {
                    Boolean isSuccess = connection.set(key.getBytes("UTF-8"), value.getBytes("UTF-8"));
                    if (isSuccess) {
                        message = "success";
                    }
                } catch (UnsupportedEncodingException e) {
                    thrownew RuntimeException(e);
                }
                return message;
            }
        });
        if (obj != null) {
            return "success";
        } else {
            return "fail";
        }

    }

}

Service类

            package
             com.smartmap.sample.test.service.impl;


            import
             java.util.List;


            import
             org.springframework.beans.factory.annotation.Autowired;

            import
             org.springframework.stereotype.Service;

            import
             org.springframework.transaction.annotation.Transactional;


            import
             com.smartmap.sample.test.dao.UserDao;

            import
             com.smartmap.sample.test.entity.User;

            import
             com.smartmap.sample.test.service.UserService;

@Service
@Transactional

            public
            class UserServiceImpl implements UserService {

    @Autowired
    UserDao userDao;

    public Long addRootUser(User user) {        
        return userDao.addRootUser(user);
    }
    
    public User getRootUser() {        
        return userDao.getRootUser();
    }
    
    public Long addUser(User user) {        
        return userDao.addUser(user);
    }

    public List<User> getAllUsers() {            
        return userDao.getUsers();
    }
    
        
    public Long delete(Long userId) {        
        return userDao.removeUser(userId);        
    }

    public String generateSave(String key, String value) {
        return userDao.connectionSet(key, value);
    }
}

Controller类

            package
             com.smartmap.sample.test.controller.rest;


            import
             java.util.List;


            import
             org.apache.commons.logging.Log;

            import
             org.apache.commons.logging.LogFactory;

            import
             org.springframework.beans.factory.annotation.Autowired;

            import
             org.springframework.web.bind.annotation.DeleteMapping;

            import
             org.springframework.web.bind.annotation.GetMapping;

            import
             org.springframework.web.bind.annotation.PathVariable;

            import
             org.springframework.web.bind.annotation.PostMapping;

            import
             org.springframework.web.bind.annotation.PutMapping;

            import
             org.springframework.web.bind.annotation.RequestBody;

            import
             org.springframework.web.bind.annotation.RequestMapping;

            import
             org.springframework.web.bind.annotation.RequestParam;

            import
             org.springframework.web.bind.annotation.RestController;

            import
             com.smartmap.sample.test.entity.User;

            import
             com.smartmap.sample.test.service.UserService;

@RestController
@RequestMapping("/api/v1.1/system/user")
publicclass UserRestController {
    privatefinal Log logger = LogFactory.getLog(UserRestController.class);

    @Autowired
    UserService userService;

    /**
     * 查询所有用户
     *
     * curl -XGET ‘http://127.0.0.1:8080/test/api/v1.1/system/user/‘
     * 
     * @return*/
    @GetMapping("/")
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    /**
     * 添加用户
     * 
     * curl -XPOST ‘http://127.0.0.1:8080/test/api/v1.1/system/user/‘
     * -H‘Content-type:application/json;charset=UTF-8‘ -d ‘ { "name":"123",
     * "createTime":"2017-01-01 00:00:00", "departmentId":"9" }‘
     * 
     * @param user
     * @return*/
    @PostMapping("/")
    public Long addUse(@RequestBody User user) {
        System.out.println(user.getName());
        return userService.addUser(user);
    }
    
    /**
     * 添加用户
     * 
     * curl -XPOST ‘http://127.0.0.1:8080/test/api/v1.1/system/user/root‘
     * -H‘Content-type:application/json;charset=UTF-8‘ -d ‘ { "name":"123",
     * "createTime":"2017-01-01 00:00:00", "departmentId":"9" }‘
     * 
     * @param user
     * @return*/
    @PostMapping("/root")
    public Long addRootUse(@RequestBody User user) {
        System.out.println(user.getName());
        return userService.addRootUser(user);
    }
    
    /**
     * 查询所有用户
     *
     * curl -XGET ‘http://127.0.0.1:8080/test/api/v1.1/system/user/root‘
     * 
     * @return*/
    @GetMapping("/root")
    public User getRootUser() {
        return userService.getRootUser();
    }
    

    /**
     * 删除用户
     * 
     * curl -XDELETE ‘http://127.0.0.1:8080/test/api/v1.1/system/user/123‘
     * 
     * @param userId
     * @return*/
    @DeleteMapping("/{userId}")
    public String deleteUser(@PathVariable("userId") Long userId) {
        Long count = userService.delete(userId);
        if (count > 0) {
            return "{success:true, message:‘delete success‘}";
        } else {
            return "{success:false, message:‘delete fail‘}";
        }
    }

    /**
     * 添加用户
     * 
     * curl -XPOST ‘http://127.0.0.1:8080/test/api/v1.1/system/user/generate‘
     * -H‘application/x-www-form-urlencoded;charset=UTF-8‘ -d ‘key=key1&value=value1‘
     * 
     * @param user
     * @return*/
    @PostMapping("/generate")
    public String generateSave(@RequestParam("key") String key, @RequestParam("value") String value) {
        String result = userService.generateSave(key, value);
        return result;
    }
        
}

完！

原文：https://www.cnblogs.com/gispathfinder/p/8966428.html

内容总结

以上是互联网集市为您收集整理的Spring Boot—18Redis全部内容，希望文章能够帮你解决Spring Boot—18Redis所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1314823.html

来源：【匿名】

【下一篇】redis可以做什么？

更多 ►

【Spring Boot—18Redis】教程文章相关的互联网学习教程文章

Spring Boot—18Redis【代码】

pom.xml<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.11</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>1.1.9</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>o...

SpringBoot进阶教程(三十)整合Redis之Sentinel哨兵模式【代码】【图】

Redis-Sentinel是官方推荐的高可用解决方案，当redis在做master-slave的高可用方案时，假如master宕机了，redis本身（以及其很多客户端）都没有实现自动进行主备切换，而redis-sentinel本身也是独立运行的进程，可以部署在其他与redis集群可通讯的机器中监控redis集群。v哨兵作用监控(Monitoring): 哨兵(sentinel) 会不断地检查你的Master和Slave是否运作正常。提醒(Notification)：当被监控的某个Redis节点出现问题时, 哨兵(senti...

SpringBoot+单机redis【代码】

spring boot-redis集成看教程来的，看起来很简单，但是集成后发现启动失败？WARN 2556 --- [ restartedMain] ationConfigEmbeddedWebApplicationContext :Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.UnsatisfiedDependencyException:Error creating bean with name ‘redisTemplate‘ defined in class path resource [org/springframework/boot/aut...

6.springboot+mybatis+redis整合【代码】【图】

选择生成的依赖选择保存的工程路径查询已经生成的依赖，并修改mysql的版本 1<dependencies> 2<dependency> 3<groupId>org.springframework.boot</groupId> 4<artifactId>spring-boot-starter-data-redis</artifactId> 5</dependency> 6<dependency> 7<groupId>org.springframework.boot</groupId> 8<artifactId>spring-boot-starter-jdbc</artifactId> 9</dependency>10<dependency>11<groupId>org.springframework.boot</grou...

用Spring Aop 实现注解Dao层的自动Spring Redis缓存【代码】

摘要：主要针对Dao层的一些数据库查询的操作，数据实时性不强，直接加入缓存。当缓存中有的时候，就使用缓存中的数据。这样的方法，最终仅仅使用一个注解实现。对于之前的hibernate二级缓存使用，比较陌生。比如是否支持Redis或者可以自己开发支持。是否支持针对部分需要加入缓存的方法配置，而不是所有的hibernate实体都加入缓存。可能我这种方法对于二级缓存来说，抛开代码差距，也是殊途同归的东西。这几天工作中，突然遇到了对...

Spring Data Redis 整合【图】

首先现在redis包，官方网址是 http://redis.io/download 　　　　下载好了后直接解压Redis压缩包到指定目录：　　　　使用对应位数操作系统文件夹下面redis-server.exe命令启动redis （测试命令redis-server.exe 服务启动程序redis-cli.exe 客户端命令行工具redis.conf 服务配置文件通过redis-server.exe启动服务，默认端口 6379通过redis-cli.exe 启动客户端工具）。　　　　1.在程序中通过maven坐标，引入spring data redis ，...

分布式 Dubbo+Zookeeper+springmvc+mybatis+shiro+restful+activemq+redis【图】

1. 项目核心代码结构截图650) this.width=650;" src="/upload/getfiles/default/2022/11/11/20221111061017181.jpg" /><modules>  <module>jeesz-utils</module>  <module>jeesz-config</module>  <module>jeesz-framework</module>  <module>jeesz-core-cms<...

Spring整合Redis做数据缓存（Windows环境）【代码】【图】

当我们一个项目的数据量很大的时候，就需要做一些缓存机制来减轻数据库的压力，提升应用程序的性能，对于java项目来说，最常用的缓存组件有Redis、Ehcache和Memcached。Ehcache是用java开发的缓存组件，和java结合良好，直接在jvm虚拟机中运行，不需要额外安装什么东西，效率也很高；但是由于和java结合的太紧密了，导致缓存共享麻烦，分布式集群应用不方便，所以比较适合单个部署的应用。Redis需要额外单独安装，是通过socket访问...

Spring Boot（八）集成Spring Cache 和 Redis【代码】【图】

在Spring Boot中添加spring-boot-starter-data-redis依赖：<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>在application.properties中指定redis服务器IP、端口和密码、连接数等：# Redis服务器地址 spring.redis.host=127.0.0.1 # Redis服务器连接端口使用默认端口6379可以省略配置 #spring.redis.port=6379 # Redis服务器连接密码（默认为空） ...

Redis整合Spring结合使用缓存实例【图】

林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka 摘要：本文介绍了如何在Spring中配置redis，并通过Spring中AOP的思想，将缓存的方法切入到有需要进入缓存的类或方法前面。一、Redis介绍什么是Redis？ redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类...

Spring RedisTemplate操作-ZSet操作（6）【代码】

@Autowired@Resource(name="redisTemplate")private RedisTemplate<String, String> rt;publicvoid flushdb(){rt.execute(new RedisCallback<Object>() {public String doInRedis(RedisConnection connection) throws DataAccessException {connection.flushDb();return "ok";}});}publicvoid set(){flushdb();ZSetOperations<String, String> vo = rt.opsForZSet();vo.add("book", "a", 1d);vo.add("book", "b", 2d);Set<TypedTup...

Springboot分布式锁实践（redis）【代码】【图】

springboot2本地锁实践一文中提到用Guava Cache实现锁机制，但在集群中就行不通了，所以我们还一般要借助类似Redis、ZooKeeper 之类的中间件实现分布式锁，下面我们将利用自定义注解、Spring Aop、Redis Cache 实现分布式锁。项目代码结构整体图一、导入依赖在 pom.xml 中添加上 starter-web、starter-aop、starter-data-redis 的依赖 1<dependencies> 2<dependency> 3<groupId>org.springframework.boot</groupId> 4<artifactId>s...

spring 集成redis客户端jedis(java)【代码】

jedis是redis的java客户端，spring将redis连接池作为一个bean配置。“redis.clients.jedis.JedisPool”，这是单机环境适用的redis连接池。 1、maven导入相关包： <dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>2.9.0</version></dependency> 2、下面是单机环境下redis连接池的配置： <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springfra...

redis + spring 集成【代码】

1、pom<modelVersion>4.0.0</modelVersion> <groupId>com.x.redis</groupId> <artifactId>springredis</artifactId> <version>0.0.1-SNAPSHOT</version> <dependencies> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> <version>1.0.2.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</art...

SpringBoot2.x配置JsonRedisSerializer【代码】

@Configurationpublicclass SpringCacheRedisConfig {@Beanpublic RedisCacheManager cacheManager(RedisConnectionFactory factory) {RedisSerializer<String> redisSerializer = new StringRedisSerializer();Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);//解决查询缓存转换异常的问题ObjectMapper om = new ObjectMapper();om.setVisibility(PropertyAccessor.A...

REDIS - 技术教程分类

Redis 教程 Redis 简介 Redis 安装 Redis 配置 Redis 数据类型 Redis 命令 Redis 键(key) Redis 字符串(String) Redis 哈希(Hash) Redis 列表(List) Redis 集合(Set) Redis 有序集合(sorted set) Redis HyperLogLog Redis 发布订阅 Redis 事务 Redis 脚本 Redis 连接 Redis 服务器 Redis GEO Redis Stream Redis 数据备份与恢复 Redis 安全 Redis 性能测试 Redis 客户端连接 Redis 分区 Redis 全部

REDIS - 最热教程

redis中批量删除key的方法 redis设置密码，取消密码 node.js利用redis数据库缓存数据 PHP swoole和redis异步任务实现方法分析 Laravel使用Redis共享Session步骤详解 mac下卸载干净redis 如何通过命令行修改redis的配置使用Port Forwarding连接k8s集群的pod（...实现商品秒杀之——Redis Watch机制 redis雪崩、穿透、击穿、热点分别代表什...

首页 / REDIS / Spring Boot—18Redis

Spring Boot—18Redis

内容导读

内容图文

内容总结

内容备注

内容手机端

【Spring Boot—18Redis】教程文章相关的互联网学习教程文章

Spring Boot—18Redis【代码】

SpringBoot进阶教程(三十)整合Redis之Sentinel哨兵模式【代码】【图】

SpringBoot+单机redis【代码】

6.springboot+mybatis+redis整合【代码】【图】

用Spring Aop 实现注解Dao层的自动Spring Redis缓存【代码】

Spring Data Redis 整合【图】

分布式 Dubbo+Zookeeper+springmvc+mybatis+shiro+restful+activemq+redis【图】

Spring整合Redis做数据缓存（Windows环境）【代码】【图】

Spring Boot（八）集成Spring Cache 和 Redis【代码】【图】

Redis整合Spring结合使用缓存实例【图】

Spring RedisTemplate操作-ZSet操作（6）【代码】

Springboot分布式锁实践（redis）【代码】【图】

spring 集成redis客户端jedis(java)【代码】

redis + spring 集成【代码】

SpringBoot2.x配置JsonRedisSerializer【代码】

REDIS - 相关标签

REDIS - 技术教程分类

REDIS - 最新教程

REDIS - 最热教程