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

随机推荐

base_expr +: width_expr
在Verilog-1995中,可以选择向量的任一位输出,也可以选择向量的连续几位输出,不过此时连续几位的始末数值的index需要是常量.而在Verilog-2001中,可以用变量作为index,进行 ...
ckeditor粘贴上传图片
公司做的项目需要用到文本上传功能. 网上找了很久,大部分都有一些不成熟的问题,皇天不负有心人终于让我找到了一个成熟的项目. 接下来就看一下吧 1.打开工程: 对于文档的上传我们需要知道这个项目的逻辑是 ...
Linux后台开发工具箱
https://files-cdn.cnblogs.com/files/aquester/Linux后台开发工具箱.pdf 目录目录 1 1. 前言 3 2. 脚本类工具 3 2.1. sed命令- ...
配置weblogic nodemanager管理器
[内容提示]:看了一场皇族对阵OMG的比赛,失落 .皇族又输了.. 可爱的UZI... 我承认我是逗比,看了3天节点管理器才明白点东西 .笨笨 .. 废话不多说,上图!所有的故意围绕一张图开始了 ...
把sublime text打造成python交互终端（windows和Ubuntu）
作者:tongqingliu 转载请注明出处:http://www.cnblogs.com/liutongqing/p/7015958.html 把sublime text打造成python交互终端 ...
slice()
提取字符串中的一部分,并返回这个新的字符串 str.slice(beginSlice[, endSlice]) 参数 beginSlice 从该索引(以 0 为基数)处开始提取原字符串中的字符.如果值 ...
Java技术----Java泛型详解
1．为什么需要泛型泛型在Java中有很重要的地位,网上很多文章罗列各种理论,不便于理解,本篇将立足于代码介绍.总结了关于泛型的知识.希望能给你带来一些帮助. 先看下面的代码: List list = ...
PCA原理分析
动机在机器学习领域中,我们常常会遇到维数很高的数据,有些数据的特征维度高达上百万维,很显然这样的数据是无法直接计算的,而且维度这么高,其中包含的信息一定有冗余,这时就需要进行降维,总的来说,我们降维 ...
I - Dividing Stones
Description There are N stones, which can be divided into some piles arbitrarily. Let the value of e ...
(leetcode162)find peak element
1题目 A peak element is an element that is greater than its neighbors. Given an input array where num[ ...

Spring Boot + Redis

连接redis集群

Spring Boot + Redis的更多相关文章

随机推荐

热门专题