Spring Boot + Redis

启动redis

docker run --name redisServer -P -d  redis

redis自带客户端，启动客户端

docker run -it --link redisServer:db --entrypoint redis-cli redis -h db

也可以使用桌面工具Redis Desktop Manager测试

下载地址：https://redisdesktop.com/download

下载完后安装，打开程序

连接服务器

可以看到上面存进去的name

新建一个Spring Boot项目，pom.xml如下

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.</modelVersion>

    <groupId>org.mythsky</groupId>

    <artifactId>spring-boot-redis-demo</artifactId>

    <version>0.0.-SNAPSHOT</version>

    <packaging>jar</packaging>

    <name>spring-boot-redis-demo</name>

    <description>Demo project for Spring Boot</description>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>1.5..RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <properties>

        <project.build.sourceEncoding>UTF-</project.build.sourceEncoding>

        <project.reporting.outputEncoding>UTF-</project.reporting.outputEncoding>

        <java.version>1.8</java.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-redis</artifactId>

        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->

        <dependency>

            <groupId>org.apache.commons</groupId>

            <artifactId>commons-pool2</artifactId>

            <version>2.4.</version>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

        <!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->

        <dependency>

            <groupId>com.google.code.gson</groupId>

            <artifactId>gson</artifactId>

            <version>2.2.</version>

        </dependency>

        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.dataformat/jackson-dataformat-xml -->

        <dependency>

            <groupId>com.fasterxml.jackson.dataformat</groupId>

            <artifactId>jackson-dataformat-xml</artifactId>

            <version>2.9.</version>

        </dependency>

        <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->

        <dependency>

            <groupId>redis.clients</groupId>

            <artifactId>jedis</artifactId>

            <version>2.9.</version>

        </dependency>

        <!--<dependency>-->

            <!--<groupId>springboot.db</groupId>-->

            <!--<artifactId>mysql</artifactId>-->

            <!--<version>${project.version}</version>-->

        <!--</dependency>-->

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

添加User

package org.mythsky.springbootredisdemo.domain;

import java.io.Serializable;

import java.util.Date;

import java.util.List;

public class User implements Serializable {

    private Long id;

    private String name;

    private Date createDate;

    private Department department;

    private List<Role> roles;

    public Long getId() {

        return id;

    }

    public void setId(Long id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public Date getCreateDate() {

        return createDate;

    }

    public void setCreateDate(Date createDate) {

        this.createDate = createDate;

    }

    public Department getDepartment() {

        return department;

    }

    public void setDepartment(Department department) {

        this.department = department;

    }

    public List<Role> getRoles() {

        return roles;

    }

    public void setRoles(List<Role> roles) {

        this.roles = roles;

    }

}

Department

package org.mythsky.springbootredisdemo.domain;

import java.io.Serializable;

public class Department implements Serializable {

    private Long id;

    private String name;

    public Long getId() {

        return id;

    }

    public void setId(Long id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

Role

package org.mythsky.springbootredisdemo.domain;

import java.io.Serializable;

public class Role implements Serializable {

    private Long id;

    private String name;

    public Long getId() {

        return id;

    }

    public void setId(Long id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

RedisConfig

package org.mythsky.springbootredisdemo.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

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

import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

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

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

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

@Configuration

public class RedisConfig {

    @Bean

    public RedisConnectionFactory redisConnectionFactory(){

        JedisConnectionFactory redisConnectionFactory=new JedisConnectionFactory();

        redisConnectionFactory.setHostName("192.168.31.146");

        redisConnectionFactory.setPort();

        redisConnectionFactory.setUsePool(true);

        return redisConnectionFactory;

    }

    @Bean

    public RedisTemplate<String,String> redisTemplate(RedisConnectionFactory factory){

        StringRedisTemplate template=new StringRedisTemplate(factory);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper=new ObjectMapper();

        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        template.setValueSerializer(jackson2JsonRedisSerializer);

        template.afterPropertiesSet();

        return template;

    }

}

UserRedis

package org.mythsky.springbootredisdemo.service;

import com.google.gson.Gson;

import com.google.gson.reflect.TypeToken;

import org.mythsky.springbootredisdemo.domain.User;

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

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

import org.springframework.stereotype.Repository;

import org.springframework.util.StringUtils;

import java.util.List;

import java.util.concurrent.TimeUnit;

@Repository

public class UserRedis {

    @Autowired

    private RedisTemplate<String,String> redisTemplate;

    public void add(String key,Long time,User user){

        Gson gson=new Gson();

        redisTemplate.opsForValue().set(key,gson.toJson(user),time, TimeUnit.MINUTES);

    }

    public void add(String key, Long time, List<User> users){

        Gson gson=new Gson();

        redisTemplate.opsForValue().set(key,gson.toJson(users),time, TimeUnit.MINUTES);

    }

    public User get(String key){

        Gson gson=new Gson();

        User user=null;

        String userJson=redisTemplate.opsForValue().get(key);

        if(!StringUtils.isEmpty(userJson)){

            user=gson.fromJson(userJson,User.class);

        }

        return user;

    }

    public List<User> getList(String key){

        Gson gson=new Gson();

        List<User> users=null;

        String listJson=redisTemplate.opsForValue().get(key);

        if(!StringUtils.isEmpty(listJson)){

            users=gson.fromJson(listJson,new TypeToken<List<User>>(){}.getType());

        }

        return users;

    }

    public void delete(String key){

        redisTemplate.opsForValue().getOperations().delete(key);

    }

}

SpringBootRedisDemoApplicationTests

package org.mythsky.springbootredisdemo;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mythsky.springbootredisdemo.config.RedisConfig;

import org.mythsky.springbootredisdemo.domain.Department;

import org.mythsky.springbootredisdemo.domain.Role;

import org.mythsky.springbootredisdemo.domain.User;

import org.mythsky.springbootredisdemo.service.UserRedis;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

@RunWith(SpringRunner.class)

@SpringBootTest

public class SpringBootRedisDemoApplicationTests {

    private static Logger logger= LoggerFactory.getLogger(SpringBootRedisDemoApplicationTests.class);

    @Autowired

    UserRedis userRedis;

    @Before

    public void setup(){

        Department department=new Department();

        department.setName("开发部");

        Role role=new Role();

        role.setName("admin");

        User user=new User();

        user.setName("user");

        user.setCreateDate(new Date());

        user.setDepartment(department);

        List<Role> roles=new ArrayList<Role>();

        roles.add(role);

        user.setRoles(roles);

        userRedis.delete(this.getClass().getName()+":userByName:"+user.getName());

        userRedis.add(this.getClass().getName()+":userByName:"+user.getName(),10l,user);

    }

    @Test

    public void get() {

        User user=userRedis.get(this.getClass().getName()+":userByName:user");

        Assert.assertNotNull(user);

        logger.info("======user====== name:{}, department:{}, role:{}",user.getName(),user.getDepartment(),user.getRoles().get().getName());

    }

}

运行，可以在测试窗口看到结果

此时再打开桌面客户端

连接redis集群

官方文档：

7.1. Enabling Redis Cluster

最主要的是设置RedisConnectionFactory

pom

 <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-redis</artifactId>

        </dependency>

        <dependency>

            <groupId>redis.clients</groupId>

            <artifactId>jedis</artifactId>

            <version>2.9.0</version>

        </dependency>

config

@Component

@ConfigurationProperties(prefix = "spring.redis.cluster")

public class ClusterConfigurationProperties {

    /*

     * spring.redis.cluster.nodes[0] = 127.0.0.1:7379

     * spring.redis.cluster.nodes[1] = 127.0.0.1:7380

     * ...

     */

    List<String> nodes;

    /**

     * Get initial collection of known cluster nodes in format {@code host:port}.

     *

     * @return

     */

    public List<String> getNodes() {

        return nodes;

    }

    public void setNodes(List<String> nodes) {

        this.nodes = nodes;

    }

}

@Configuration

public class AppConfig {

    /**

     * Type safe representation of application.properties

     */

    @Autowired

    ClusterConfigurationProperties clusterProperties;

    @Value("${spring.redis.password}")

    private String password;

    public @Bean

    RedisConnectionFactory connectionFactory() {

        RedisClusterConfiguration configuration=new RedisClusterConfiguration(clusterProperties.getNodes());

        configuration.setPassword(RedisPassword.of(password));

        return new JedisConnectionFactory(configuration);

    }

}

配置文件

spring.redis.cluster.nodes=172.20.102.65:7001,172.20.102.65:7002,172.20.102.65:7003,172.20.102.66:7004,172.20.102.66:7005,172.20.102.66:7006

spring.redis.password=123456

测试

@RunWith(SpringRunner.class)

@SpringBootTest

public class RedisDemoApplicationTests {

    @Test

    public void contextLoads() {

        String result= stringRedisTemplate.opsForValue().get("api:tmp:users:1375bf2a-8e03-4097-8e1f-803787b6fac2");

        System.out.println(result);

    }

    @Test

    public void test1(){

        String result=redisTemplate.opsForValue().get("api:tmp:users:1375bf2a-8e03-4097-8e1f-803787b6fac2");

        System.out.println(result);

    }

    @Autowired

    private StringRedisTemplate stringRedisTemplate;

    @Autowired

    private RedisTemplate<String,String> redisTemplate;

}

Spring Boot + Redis的更多相关文章

spring boot redis缓存JedisPool使用
spring boot redis缓存JedisPool使用添加依赖pom.xml中添加如下依赖  <dependency> ...
spring boot + redis 实现session共享
这次带来的是spring boot + redis 实现session共享的教程. 在spring boot的文档中,告诉我们添加@EnableRedisHttpSession来开启spring se ...
Spring Boot 项目学习 (三) Spring Boot + Redis 搭建
0 引言本文主要介绍 Spring Boot 中 Redis 的配置和基本使用. 1 配置 Redis 1. 修改pom.xml,添加Redis依赖 <!-- Spring Boot Redi ...
Spring Boot Redis 集成配置（转）
Spring Boot Redis 集成配置 .embody{ padding:10px 10px 10px; margin:0 -20px; border-bottom:solid 1px #ede ...
spring boot redis 缓存（cache）集成
Spring Boot 集成教程 Spring Boot 介绍 Spring Boot 开发环境搭建(Eclipse) Spring Boot Hello World (restful接口)例子 sp ...
spring boot redis分布式锁
随着现在分布式架构越来越盛行,在很多场景下需要使用到分布式锁.分布式锁的实现有很多种,比如基于数据库. zookeeper 等,本文主要介绍使用 Redis 做分布式锁的方式,并封装成spring b ...
从.Net到Java学习第四篇——spring boot+redis
从.Net到Java学习系列目录 “学习java已经十天,有时也怀念当初.net的经典,让这语言将你我相连,怀念你......”接上一篇,本篇使用到的框架redis.FastJSON. 环境准备安装 ...
Spring Boot Redis Cluster 实战干货
添加配置信息 spring.redis: database: 0 # Redis数据库索引(默认为0) #host: 192.168.1.8 #port: 6379 password: 123456 ...
Spring boot redis自增编号控制踩坑
近段期间,公司接手一个订单号生成服务,规则的话已经由项目经理他们规定好了,主要是后面的四位数代表的关于当前订单号已经执行第几个了.而这里面有一个要求就是支持分布式.为了实现这个东西,刚开始我使用了r ...

随机推荐

python中的\n、\r与\b
python中使用print函数,有时候会使用end参数来控制字符输出效果,这时候\n.\r与\b就派上用场了. \n 代表换行,也就是从本行换到下一行 \r 代表回车,也就是回到本行最开始的位置,从 ...
18) maven 项目结构：继承
Project Inheritance [ɪn'herɪt(ə)ns] https://maven.apache.org/guides/introduction/introduction-to-the ...
LoadIcon
1.LoadIcon(HINSTANCE hInstance,LPCSTR lpIconName);该函数从与 hInstance 模块相关联的可执行文件中装入lpIconName指定的图标资源,仅当 ...
VHDL基础2
Signals & Variables VHDL 提供了 signal 和 variable 两种对象来处理非静态数据:提供了 constant 和 generic 来处理静态数据. cons ...
使用 vs.php 调试PHP相关问题
1. 使用mysql_connect()方法时报错"Call to undefined function mysql_connect()" 这是由于在php.ini没有启用mysq ...
一个发送邮件的java类，包含多种发送方法
import java.util.Calendar;import java.util.Date; import java.util.Properties; import javax.mail.Addr ...
(不用循环也可以记录数组里的数)Color the ball --hdu--1556
题目: N个气球排成一排,从左到右依次编号为1,2,3....N.每次给定2个整数a b(a <= b),lele便为骑上他的“小飞鸽"牌电动车从气球a开始到气球b依次给每个气球涂一次 ...
第80讲：List的泛型分析以及：：类和Nil对象
今天我们学习一下scala中的列表,List. 通过源码,我们可以发现,List类型是协变的,所以我们可以把Int类型的List赋值给Any型的List. 我们可以看到,List定义下有3个比较重要的 ...
基于FPGA的I2C读写EEPROM
I2C在芯片的配置中应用还是很多的,比如摄像头.VGA转HDMI转换芯片,之前博主分享过一篇I2C协议的基础学习IIC协议学习笔记,这篇就使用Verilog来实现EEPROM的读写,进行一个简单的I2 ...
js-倒计时原理
<!DOCTYPE html><html> <head> <meta charset="UTF-8"> ...

Spring Boot + Redis

连接redis集群

Spring Boot + Redis的更多相关文章

随机推荐

热门专题