2. 程式人生 > >Spring Boot 學習筆記 11 : Redis

Spring Boot 學習筆記 11 : Redis

阿新 • • 發佈：2019-02-04

在 SpringBoot 開發專案的過程中，使用到了 RedisTemplate 操作 Hash，讀值時遇到關於型別轉換的問題，於是編寫了一個小的測試 demo，現在記錄下來，以後有時間再深入研究。

  1. 專案結構如下：
    專案結構
    進入專案根目錄，使用 tree /f 命令輸出目錄結構如下：

    ├─src
    │ ├─main
    │ │ ├─java
    │ │ │ └─com
    │ │ │ └─example
    │ │ │ └─demo
    │ │ │ │ SpringBootRedisApplication.java
    │ │ │ │
    │ │ │ ├─config
    │ │ │ │ RedisConfiguration.java
    │ │ │ │
    │ │ │ ├─domain
    │ │ │ │ Permission.java
    │ │ │ │ Role.java
    │ │ │ │ User.java
    │ │ │ │
    │ │ │ └─service
    │ │ │ │ RedisService.java
    │ │ │ │ UserService.java
    │ │ │ │
    │ │ │ └─util
    │ │ │ RedisKey.java
    │ │ │
    │ │ └─resources
    │ │ │ application-dev.yml
    │ │ │ application-prod.yml
    │ │ │ application.yml
    │ │ │
    │ │ ├─static
    │ │ └─templates
    │ └─test
    │ └─java
    │ └─com
    │ └─example
    │ └─demo
    │ │ SpringBootRedisApplicationTests.java
    │ │
    │ └─service
    │ RedisServiceTest.java

  2. pom 檔案如下：

    <?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.0</modelVersion>

	<groupId
     
    >    com.example</groupId>
	<artifactId>spring-boot-redis</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>spring-boot-redis</name>
	<description>Demo project for Spring Boot Redis</description>

	<parent>
     
    
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.6.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</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>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>


</project>

  3. RedisConfiguration 配置類如下：

    package com.example.demo.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
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.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author smileorsilence
 */
@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisConfiguration {

    @Autowired
    private RedisProperties redisProperties;

    @Bean
    public JedisConnectionFactory redisConnectionFactory() {
        JedisConnectionFactory redisConnectionFactory = new JedisConnectionFactory();
        redisConnectionFactory.setHostName(redisProperties.getHost());
        redisConnectionFactory.setPort(redisProperties.getPort());
        redisConnectionFactory.setDatabase(redisProperties.getDatabase());

        if (this.redisProperties.getPassword() != null)
            redisConnectionFactory.setPassword(redisProperties.getPassword());
        if (this.redisProperties.getTimeout() > 0) redisConnectionFactory.setTimeout(redisProperties.getTimeout());

        return redisConnectionFactory;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new JsonRedisSerializer());
        //for hash
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new JsonRedisSerializer());
        return redisTemplate;
    }

    public static class JsonRedisSerializer implements RedisSerializer<Object> {
        private ObjectMapper objectMapper = new ObjectMapper();

        public JsonRedisSerializer() {
        }

        @Override
        public byte[] serialize(Object o) throws SerializationException {
            if (o == null) {
                return new byte[0];
            } else {
                try {
                    return this.objectMapper.writeValueAsBytes(o);
                } catch (Exception e) {
                    throw new SerializationException("Could not write JSON: " + e.getMessage());
                }
            }
        }

        @Override
        public Object deserialize(byte[] bytes) throws SerializationException {
            if (bytes == null) {
                return null;
            } else {
                try {
                    return this.objectMapper.readValue(bytes, Object.class);
                } catch (Exception e) {
                    throw new SerializationException("Could not read JSON: " + e.getMessage());
                }
            }
        }
    }

}

  4. RedisService 工具類如下：

    package com.example.demo.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author smileorsilence
 */
@Slf4j
@Service
public class RedisService {

    /***** ***** ***** ***** ***** ***** Operation for Key ***** ***** ***** ***** ***** *****/

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    public void deleteKey(String key) {
        log.debug("Delete key in redis, key:{}", key);
        redisTemplate.delete(key);
    }

    public void expireKey(String key, Long times, TimeUnit unit) {
        log.debug("Expire key in redis, key:{}", key);
        redisTemplate.expire(key, times, unit);
    }

    /***** ***** ***** ***** ***** ***** Operation for Value ***** ***** ***** ***** ***** *****/

    public void saveValue(String key, String value) {
        log.debug("Save string into redis, key:{}, value:{}", key, value);
        redisTemplate.opsForValue().set(key, value);
    }

    public void saveObject(String key, Object object) {
        log.debug("Save object into redis, key:{}, value:{}", key, object);
        redisTemplate.opsForValue().set(key, object);
    }

    public Object readObject(String key) {
        log.debug("Read object from redis, key:{}", key);
        return redisTemplate.opsForValue().get(key);
    }

    /***** ***** ***** ***** ***** ***** Operation for List ***** ***** ***** ***** ***** *****/

    public void saveList(String key, List<?> list) {
        log.debug("Save a list into redis, key:{}", key);
        redisTemplate.delete(key);
        for (Object l : list) {
            redisTemplate.opsForList().rightPush(key, l);
        }
    }

    public List<?> readList(String key) {
        log.debug("Read a list from redis, key:{}", key);
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 放入佇列的最後一個位置
     */
    public void pushEnd(String key, Object value) {
        redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 取佇列的最後一個元素
     */
    public Object popEnd(String key) {
        return redisTemplate.opsForList().rightPop(key);
    }

    /**
     * 放入佇列的第一個位置
     */
    public void pushFirst(String key, Object value) {
        redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 取佇列的第一個元素
     */
    public Object popFirst(String key) {
        return redisTemplate.opsForList().leftPop(key);
    }

    /***** ***** ***** ***** ***** ***** Operation for Map ***** ***** ***** ***** ***** *****/

    public void saveMap(String key, Map<?, ?> map) {
        log.debug("Save a map into redis, key:{}", key);
        redisTemplate.delete(key);
        redisTemplate.opsForHash().putAll(key, map);
    }

    public void saveMapValue(String key, String hashKey, Object hashValue) {
        log.debug("Save map value into redis, key:{}, hashKey:{}", key, hashKey);
        redisTemplate.opsForHash().put(key, hashKey, hashValue);
    }

    public void deleteMapValue(String key, String hashKey) {
        log.debug("Delete map value from redis, key:{}, hashKey:{}", key, hashKey);
        redisTemplate.opsForHash().delete(key, hashKey);
    }

    public Map<?, ?> readMap(String key) {
        log.debug("Read a map from redis, key:{}", key);
        return redisTemplate.opsForHash().entries(key);
    }

    public Object readMapValue(String key, String hashKey) {
        log.debug("Read map value from redis, key:{}, hashKey:{}", key, hashKey);
        return redisTemplate.opsForHash().get(key, hashKey);
    }

    public Set<?> readMapKeys(String key) {
        log.debug("Read map keys from redis, key:{}", key);
        return redisTemplate.opsForHash().keys(key);
    }

    public List<?> readMapValues(String key) {
        log.debug("Read map values from redis, key:{}", key);
        return redisTemplate.opsForHash().values(key);
    }

    public boolean hasHashKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

}

  5. POJO 類如下：

    package com.example.demo.domain;

import lombok.Data;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

/**
 * @author smileorsilence
 */
@Data
public class User implements Serializable {

    private Long id;

    private String username;

    private String password;

    private Set<Role> roles = new HashSet<>();

}

  6. RedisServiceTest 測試類如下：

    package com.example.demo.service;

import com.example.demo.config.RedisConfiguration;
import com.example.demo.domain.User;
import com.example.demo.service.util.RedisKey;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author smileorsilence
 */
@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {RedisConfiguration.class, RedisService.class})
public class RedisServiceTest {

    @Autowired
    private RedisService redisService;

    @Test
    pu

相關推薦

Spring Boot 學習筆記 11 : Redis

在 SpringBoot 開發專案的過程中，使用到了 RedisTemplate 操作 Hash，讀值時遇到關於型別轉換的問題，於是編寫了一個小的測試 demo，現在記錄下來，以後有時間再深入研究。 專案結構如下： 進入專案根目錄，使用 tree /

Spring Boot學習筆記——Spring Boot與Redis的集成

pac urn prope web property static 接口 per select 一.添加Redis緩存 1.添加Redis起步依賴 在pom.xml中添加Spring Boot支持Redis的依賴配置，具體如下： <dependency>

我的第一個spring boot程序（spring boot 學習筆記之二）

獲取json 了解 訪問 static 依賴 過程 public 獲取數據 gap 第一個spring boot程序 寫在前面：鑒於spring註解以及springMVC的配置有大量細節和知識點，在學習理解之後，我們將直接進入spring boot的學習，在後續學習中用到註

Spring Boot學習筆記

end 應用程序 maven構建 筆記 項目依賴 新建 輸入 需要 文本 1.不需要任何特殊工具集成，可以使用任何IDE或文本編輯器。 2.Spring Boot CLI是一個命令行工具。 3.使用Maven構建一個基於Spring Boot 的Web應用程序。 　　1）打

Spring boot 學習筆記

Spring Boot 學習筆記（二）

imp family framework ima pri spa cal bin ges 新建Srping Boot 項目 以下是項目結構 由於Srping Boot內置Tomcat，所以不需要配置Tomcat就可以直接運行。 HelloWorldAppli

Java框架spring Boot學習筆記（八）：Spring相關概念

擴展 靜態 輕量級 想要 spring配置 核心 使用 oot 調用方法 Spring是開源、輕量級、一站式框架。 Spring核心主要兩部分 aop:面向切面編程，擴展功能不是修改源代碼實現 ioc:控制反轉，比如一個類，在類裏面有方法（不是靜態的方法），想要調用類

Java框架spring Boot學習筆記（十四）：log4j介紹

inf alt 技術分享 images 使用 image 詳細 配置文件 -128 功能 日誌功能，通過log4j可以看到程序運行過程的詳細信息。 使用 導入log4j的jar包 復制log4j的配置文件，復制到src下面 　　　　 　　 3.設置日誌級別 　　　

Spring Boot學習筆記-配置devtools實現熱部署

原理 enc cnblogs 配置文件 target res 快的 pen cache 寫在前面 　　Spring為開發者提供了一個名為spring-boot-devtools的模塊來使Spring Boot應用支持熱部署，提高開發者的開發效率，無需手動重啟Spring

1、spring-boot學習筆記（一）簡單入門

ava project nal run plugin mailto 5.4 安全 class a 一、新建普通Maven工程 pom.xml <parent> <groupId>org.springframework.boot</gr

Spring Boot學習筆記之一：傳統maven項目與采用spring boot項目區別

bubuko xml文件 分享 lda ring info 插件 eclips web 項目結構區別 傳統的maven構建的項目結構如下： 用maven構建的采用springboot項目結構如下： 二者結構一致，區別如下：傳統項目如果需要打成war包，需要在WEB-IN

Spring Boot學習筆記：JavaMailSender發送郵件

獲取 prop create subject intern dex autowired 需求 see 項目中經常會有這樣的需求，用戶註冊成功，需要給用戶發送一封郵件。郵件需要有一定格式和樣式。本次例子中用freemarker做樣式，其他的模版引擎類似。 首先Spring B

Spring boot 學習筆記 1 - 自定義錯誤

note ride 覆蓋 ide rac med exception cat 異常 Spring Boot提供了WebExceptionHandler一個以合理的方式處理所有錯誤的方法。它在處理順序中的位置就在WebFlux提供的處理程序之前，這被認為是最後一個處理程序。

Spring Boot學習筆記之使用Spring Boot建立一個簡單的web專案（工具使用IntelliJ IDEA）

新建Maven專案 1.File --> New Project --> Maven --> Next 2.填寫專案資訊，完成之後點選Next，然後點選Finish 3.專案建好之後如下圖所示 修改pom檔案中的配置資訊 <?xml version

Spring Boot學習筆記之使用Spring Boots實現資料庫操作（IntelliJ IDEA+navicat for Sql Server）

這裡使用Spring Boot實現了一個簡單的專案，能夠實現簡單的資料庫操作，工具使用的是IntelliJ IDEA2017.3，資料庫工具使用的是navicat for Sql Server，語言使用的Java。 1.新建一個空的Maven專案 2.匯入需要的jar包 pom.xml:

Spring Boot學習筆記（五）—— 使用JUnit5編寫單元測試

1.開發環境 Mac OS 10.14 JDK8 Maven 3.5.3 Eclipse 4.9.0 Spring Boot 2.0.5.RELEASE JUnit 5.1.1 2.JUnit5簡介[1] JUnit 5跟以前的JUni

Spring Boot學習筆記（四）—— 使用Spring Security

一、前言 Spring Boot同樣提供了關於Spring Security的自動配置支援，在org.springframework.boot.autoconfigure.security包中可以看到，在SpringBootWebSecurityConfiguration中，為我們自動配

Spring Boot學習筆記（三）—— 新增Mybatis、Druid

一、前言 之前我們對Spring Boot的View和Control配置都有了一定的瞭解，在Model層配置上，我們將使用Mybatis、Druid進行開發，下面就對其進行配置。 二、開始配置 MyBatis 是一款優秀的持久層框架，Druid是一個高效能的資料庫連線池，並且提供

Spring Boot 學習筆記（二）—— WEB相關配置

一、前言 上次我們快速搭建了一個Spring Boot專案，我們只需新增業務邏輯就能直接執行訪問了，說明Spring Boot已經自動為我們做完了配置工作，這次我們就來看看具體是哪些工作，如果我們想接管配置又該怎麼做。 二、WEB相關配置 檢視WebMvcAutoConfigur

Spring Boot 學習筆記（一）—— 快速搭建Spring Boot專案

一、前言 Spring Boot是Spring系列框架的整合，使用“習慣優於配置”的理念快速搭建專案，在專案打包時還能根據需求打包為jar（內建servlet容器）或war檔案，相對以前的Spring、Spring MVC來說Spring Boot並沒有技術上的升級，而是為我們做好了大部