【Spring Boot】Spring Boot Redis 缓存示例 | 自动缓存查询结果减少数据库交互

最新推荐文章于 2024-08-13 14:47:21 发布
最新推荐文章于 2024-08-13 14:47:21 发布
阅读量815 收藏
点赞数 1
分类专栏： # Spring Boot 文章标签： Spring Boot Redis java cache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31635851/article/details/120867854
版权

文章目录

本页将介绍Spring Boot Redis缓存实例。RedisCacheManager是由Redis支持的CacheManager。如果Redis在我们的Spring Boot应用程序中可用并已配置，RedisCacheManager将被自动配置。Redis连接从Lettuce或Jedis Java Redis客户端获得。Redis的依赖性由spring-boot-starter-data-redis 启动器解决。在Spring Boot 2.0中，Lettuce被默认解决，而不是Jedis。要使用Jedis，我们需要在构建文件中包含jedis依赖。

Spring @EnableCaching在我们的应用程序中启用Spring缓存管理能力。它被@SpringBootApplication注解所注解。@Cacheable表示调用方法的结果可以被缓存，一旦结果被缓存，下一次调用方法的执行将被跳过，只有缓存的结果被提供。@CachePut 添加或更新缓存，但不跳过方法的执行。@CacheEvict 清空缓存但不跳过方法的执行。@Caching被用来分组多个缓存注释。

演示工具版本

  1. Java 9
  2. Spring 5.0.8.RELEASE
  3. Spring Data 2.0.9.RELEASE
  4. Spring Boot 2.0.4.RELEASE
  5. Maven 3.5.2
  6. MySQL 5.5
  7. Eclipse Oxygen

Maven 依赖

Spring提供了spring-boot-starter-data-redis来解决Redis的依赖关系。

它为Lettuce和Jedis客户端库提供基本的自动配置。

默认情况下，Spring Boot 2.0使用Lettuce。为了获得池化连接工厂，我们需要提供commons-pool2依赖。

找到Maven文件。

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.0</modelVersion>
	<groupId>com.concretepage</groupId>
	<artifactId>spring-boot-app</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
	<name>spring-boot-app</name>
	<description>Spring Boot Application</description>
	<parent>
	    <groupId>org.springframework.boot</groupId>
  	    <artifactId>spring-boot-starter-parent</artifactId>
	    <version>2.0.4.RELEASE</version>
 	    <relativePath/>
	</parent>
	<properties>
	    <java.version>9</java.version>
	</properties>
	<dependencies>
          <dependency>
	    <groupId>org.springframework.boot</groupId>
	    <artifactId>spring-boot-starter-web</artifactId>
          </dependency>
          <dependency>
	    <groupId>org.springframework.boot</groupId>
	    <artifactId>spring-boot-starter-data-jpa</artifactId>
          </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>
          </dependency> 	  
          <dependency>
	    <groupId>mysql</groupId>
	    <artifactId>mysql-connector-java</artifactId>
	    <version>6.0.5</version>
          </dependency>	  	  	  
          <dependency>
	    <groupId>javax.xml.bind</groupId>
	    <artifactId>jaxb-api</artifactId>
	    <version>2.3.0</version>
          </dependency>  	      	  	  	  
	  <dependency>
	    <groupId>org.springframework.boot</groupId>
	    <artifactId>spring-boot-devtools</artifactId>
	    <optional>true</optional>
	  </dependency> 
	</dependencies>
	<build>
	  <plugins>
	     <plugin>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-maven-plugin</artifactId>
	     </plugin>
	  </plugins>
	</build>
</project>

application.properties

找到我们的演示程序中使用的应用程序属性文件。

application.properties

#Redis specific configurations

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password= 

spring.redis.lettuce.pool.max-active=7 
spring.redis.lettuce.pool.max-idle=7
spring.redis.lettuce.pool.min-idle=2
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.shutdown-timeout=200ms

spring.cache.redis.cache-null-values=false
spring.cache.redis.time-to-live=600000
spring.cache.redis.use-key-prefix=true

spring.cache.type=redis
#spring.cache.cache-names=articleCache,allArticlesCache

#Database specific configurations 

spring.datasource.url=jdbc:mysql://localhost:3306/concretepage
spring.datasource.username=root
spring.datasource.password=cp

spring.datasource.hikari.connection-timeout=20000
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.maximum-pool-size=12
spring.datasource.hikari.idle-timeout=300000
spring.datasource.hikari.max-lifetime=1200000

spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
spring.jpa.properties.hibernate.id.new_generator_mappings=false
spring.jpa.properties.hibernate.format_sql=true

使用 Lettuce 配置

Spring Boot 2.0启动器spring-boot-starter-data-redis默认解决了Lettuce。Spring提供LettuceConnectionFactory来获取连接。要获得池化连接工厂，我们需要在类路径上提供commons-pool2。要使用Lettuce，我们需要以下Maven依赖项。

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>		
<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-pool2</artifactId>
</dependency>

为了配置Lettuce池，我们需要使用spring.redis.*前缀与Lettuce池连接属性。找到Lettuce池的样本配置。

application.properties

spring.redis.host=localhost 
spring.redis.port=6379
spring.redis.password= 

spring.redis.lettuce.pool.max-active=7 
spring.redis.lettuce.pool.max-idle=7
spring.redis.lettuce.pool.min-idle=2
spring.redis.lettuce.pool.max-wait=-1ms  
spring.redis.lettuce.shutdown-timeout=200ms

我们可以覆盖默认的Redis主机、端口和密码配置。如果我们想无限期地阻塞，请使用max-wait这个负值。

使用 Jedis 配置

默认情况下，Spring Boot 2.0启动器spring-boot-starter-data-redis使用Lettuce。要使用Jedis，我们需要排除Lettuce的依赖，并包含Jedis。找到使用Jedis的Maven依赖项。

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
  <exclusions>
    <exclusion>
	 <groupId>io.lettuce</groupId>
	 <artifactId>lettuce-core</artifactId>
    </exclusion>
  </exclusions>		    
</dependency>		
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
</dependency>

jedis的依赖将自动解决类路径上的commons-pool2。

为了配置Jedis池，我们需要使用spring.redis.*前缀与Jedis池连接属性。找到Jedis池的样本配置。

application.properties

spring.redis.host=localhost 
spring.redis.port=6379
spring.redis.password= 

spring.redis.jedis.pool.max-active=7 
spring.redis.jedis.pool.max-idle=7
spring.redis.jedis.pool.min-idle=2
spring.redis.jedis.pool.max-wait=-1ms

RedisCacheManager

在Spring Boot中，RedisCacheManager是自动配置的。这里我们将讨论如何配置Spring Boot Redis缓存属性以改变自动配置的RedisCacheManager的默认值，然后我们将创建一个自己的RedisCacheManager示例，以获得对配置的完全控制。

1. 自动配置的 RedisCacheManager

如果Redis在我们的Spring Boot应用程序中可用并已配置，RedisCacheManager将被自动配置。我们可以使用spring.cache.*属性来控制Spring缓存的配置。

spring.cache.type: 定义了缓存类型。如果我们不配置这个属性，它将被自动检测到环境。对于Redis缓存，其值为redis。

spring.cache.cache-names: 在启动时创建额外的缓冲区。

Redis缓存的默认值可以通过spring.cache.redis.*进行配置。

spring.cache.redis.cache-null-values: 它接受布尔值。当该值为true时，它将允许缓存空值，否则不允许。

spring.cache.redis.time-to-live: 缓存过期时间。

spring.cache.redis.use-key-prefix: 它接受布尔值。如果是true，那么在写到Redis时将会使用键的前缀。默认值是true。

spring.cache.redis.key-prefix: 定义键前缀。默认情况下，当两个独立的缓存使用同一个键时，会添加一个键前缀以避免键重叠。

找到Redis缓存配置的示例。

application.properties

spring.cache.redis.cache-null-values=false
spring.cache.redis.time-to-live=600000
spring.cache.redis.use-key-prefix=true

spring.cache.type=redis
spring.cache.cache-names=articleCache,allArticlesCache

缓存articleCache和allArticleCache将存活10分钟。

2. 自定义的 RedisCacheManager

我们可以创建自己的RedisCacheManager来获得对Redis配置的完全控制。我们需要创建LettuceConnectionFactory Bean、RedisCacheConfiguration Bean和RedisCacheManager，如下所示。

RedisConfig.java

package com.concretepage;
import java.time.Duration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;

@Configuration
@EnableCaching
@PropertySource("classpath:application.properties")
public class RedisConfig {
   @Autowired
   private Environment env;	
	
   @Bean
   public LettuceConnectionFactory redisConnectionFactory() {
	RedisStandaloneConfiguration redisConf = new RedisStandaloneConfiguration();
	redisConf.setHostName(env.getProperty("spring.redis.host"));
	redisConf.setPort(Integer.parseInt(env.getProperty("spring.redis.port")));
	redisConf.setPassword(RedisPassword.of(env.getProperty("spring.redis.password")));	    
        return new LettuceConnectionFactory(redisConf);
   }
   @Bean
   public RedisCacheConfiguration cacheConfiguration() {
	RedisCacheConfiguration cacheConfig = RedisCacheConfiguration.defaultCacheConfig()
	  .entryTtl(Duration.ofSeconds(600))
	  .disableCachingNullValues();	
	return cacheConfig;
   }
   @Bean
   public RedisCacheManager cacheManager() {
	RedisCacheManager rcm = RedisCacheManager.builder(redisConnectionFactory())
	  .cacheDefaults(cacheConfiguration())
	  .transactionAware()
	  .build();
	return rcm;
   }  
}

RedisCacheConfiguration是一个不可变的类，它有助于自定义Redis的缓存行为，如缓存过期时间，禁止缓存空值等。它也有助于自定义序列化策略。

使用 @EnableCaching 启用缓存

为了在我们的应用程序中启用缓存，Spring提供了@EnableCaching注解。@EnableCaching启用注释驱动的缓存管理能力。

它负责注册所需的Spring组件以启用注释驱动的缓存管理。@EnableCaching是用@Configuration或@SpringBootApplication注解来注释的。

SpringBootAppStarter.java

@SpringBootApplication
@EnableCaching
public class SpringBootAppStarter {  
    public static void main(String[] args) {
	SpringApplication.run(SpringBootAppStarter.class, args);
    }       
}

使用 @Cacheable

@Cacheable表示调用方法的结果可以被缓存，一旦结果被缓存，下一次调用方法的执行将被跳过，并且只提供缓存的结果。找出其中的一些元素。

cacheNames: 储存方法结果的缓存名称。

value: cacheNames的别名。

condition: Spring SpEL表达式可以进行有条件缓存。

key: SpEL动态地计算key。

keyGenerator: 自定义KeyGenerator的Bean名称。

unless: SpEL来否决方法缓存。

sync: 当多个线程试图为同一个key加载一个值时，它被用来同步方法的调用。

为了计算key, condition或unless，我们可以在SpEL中使用以下元数据。

#result: 引用方法的结果。

#root.method: 引用方法。

#root.target: 对目标对象的引用。

#root.caches: 引用受影响的缓存。

#root.methodName:方法名称的快捷方式。

#root.targetClass:目标类的快捷方式。

#root.args[1], #p1 or #a1: 它们给出了方法的第二个参数。改变数值，我们可以得到其他参数。我们也可以通过他们的名字来访问参数。

现在找到使用@Cacheable注解的示例代码片段。

@Cacheable(value= "articleCache", key= "#articleId")		
public Article getArticleById(long articleId) {
  ------
}

在上面的代码中，方法的结果将用articleCache的缓存名称来缓存，使用的键是传递的文章ID。这意味着对于不同的文章ID，结果将以不同的键被缓存，但有相同的缓存名称。一旦方法的结果被缓存为一个键，那么对于相同的键，方法将不会执行，缓存的结果将被提供。

@Cacheable(value= "allArticlesCache", unless= "#result.size() == 0")	
public List<Article> getAllArticles(){
  ------
}

在上面的代码中，如果结果的大小为0，方法的结果将不会被缓存。 如果我们不提供键，默认情况下，它将是（""）或方法参数被用来计算键（如果有的话）。

使用 @CachePut

@CachePut 触发了一个缓存投放操作。它不会跳过方法的执行，每次执行的结果都会缓存在相关的缓存中。@CachePut拥有与@Cacheable相同的元素，如cacheNames, value, condition, key, unless, keyGenerator等。找到使用@CachePut的示例代码片段。

@CachePut(value= "articleCache", key= "#article.articleId")
public Article addArticle(Article article){
   ------
}

上述方法将在每次调用时执行，方法结果将被添加或更新到与给定的缓存名称的键相对应的缓存中。

使用 @CacheEvict

@CacheEvict 触发了一个缓存清空操作。它不会跳过方法的执行，并且每次执行都会清空缓存。它的元素包括cacheNames, value, condition, key, keyGenerator, allEntries等。如果allEntries= true，缓存中的所有条目都被移除。找到使用@CacheEvict的代码片段。

@CacheEvict(value= "allArticlesCache", allEntries= true)	
public void deleteArticle(long articleId) {
  ------
}

上述方法将执行每一次调用，所有缓存的条目将被删除。

使用 @Caching

@Caching是多个缓存注解的组注解。它有cacheable、put和evict元素。

找到使用@CachePut和@CacheEvict的代码片段，在组中使用@Caching。

@Caching(
   put= { @CachePut(value= "articleCache", key= "#article.articleId") },
   evict= { @CacheEvict(value= "allArticlesCache", allEntries= true) }
)
public Article updateArticle(Article article) {
   ------
}

在@Caching组中使用多个@CacheEvict的代码段。

@Caching(
   evict= { 
	@CacheEvict(value= "articleCache", key= "#articleId"),
	@CacheEvict(value= "allArticlesCache", allEntries= true)
   }
)
public void deleteArticle(long articleId) {
   ------
}

Spring Boot Cache + Redis + MySQL CRUD 完整示例

这里我们将提供一个Spring Boot Cache + Redis + MySQL CRUD操作的完整例子。在Eclipse中查找项目结构。

在这里插入图片描述
现在找到完整的代码。

articles表

CREATE TABLE IF NOT EXISTS `articles` (
  `article_id` int(5) NOT NULL AUTO_INCREMENT,
  `title` varchar(200) NOT NULL,
  `category` varchar(100) NOT NULL,
  PRIMARY KEY (`article_id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=latin1;

INSERT INTO `articles` (`article_id`, `title`, `category`) VALUES
	(1, 'Spring REST Security', 'Spring'),
	(2, 'Java Concurrency', 'Java');

ArticleService.java

package com.concretepage.service;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.Caching;
import org.springframework.stereotype.Service;
import com.concretepage.entity.Article;
import com.concretepage.repository.ArticleRepository;

@Service
public class ArticleService implements IArticleService {
	@Autowired
	private ArticleRepository articleRepository;
	
	@Override	
	@Cacheable(value= "articleCache", key= "#articleId")		
	public Article getArticleById(long articleId) {
		System.out.println("--- Inside getArticleById() ---");		
		return  articleRepository.findById(articleId).get();
	}
	@Override	
	@Cacheable(value= "allArticlesCache", unless= "#result.size() == 0")	
	public List<Article> getAllArticles(){
		System.out.println("--- Inside getAllArticles() ---");
		List<Article> list = new ArrayList<>();
		articleRepository.findAll().forEach(e -> list.add(e));
		return list;
	}
	@Override	
	@Caching(
		put= { @CachePut(value= "articleCache", key= "#article.articleId") },
		evict= { @CacheEvict(value= "allArticlesCache", allEntries= true) }
	)
	public Article addArticle(Article article){
		System.out.println("--- Inside addArticle() ---");		
		return articleRepository.save(article);
	}
	@Override	
	@Caching(
		put= { @CachePut(value= "articleCache", key= "#article.articleId") },
		evict= { @CacheEvict(value= "allArticlesCache", allEntries= true) }
	)
	public Article updateArticle(Article article) {
		System.out.println("--- Inside updateArticle() ---");		
		return articleRepository.save(article);
	}
	@Override	
	@Caching(
		evict= { 
			@CacheEvict(value= "articleCache", key= "#articleId"),
			@CacheEvict(value= "allArticlesCache", allEntries= true)
		}
	)
	public void deleteArticle(long articleId) {
		System.out.println("--- Inside deleteArticle() ---");		
		articleRepository.delete(articleRepository.findById(articleId).get());
	}
}

IArticleService.java

package com.concretepage.service;
import java.util.List;
import com.concretepage.entity.Article;

public interface IArticleService {
     List<Article> getAllArticles();
     Article getArticleById(long articleId);
     Article addArticle(Article article);
     Article updateArticle(Article article);
     void deleteArticle(long articleId);
}

Article.java

package com.concretepage.entity;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="articles")
public class Article implements Serializable { 
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Column(name="article_id")
        private long articleId;  
	@Column(name="title")
        private String title;
	@Column(name="category")	
	private String category;
	public long getArticleId() {
		return articleId;
	}
	public void setArticleId(long articleId) {
		this.articleId = articleId;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getCategory() {
		return category;
	}
	public void setCategory(String category) {
		this.category = category;
	}
}

ArticleRepository.java

package com.concretepage.repository;
import org.springframework.data.repository.CrudRepository;
import com.concretepage.entity.Article;

public interface ArticleRepository extends CrudRepository<Article, Long>  {
}

ArticleController.java

package com.concretepage.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
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.util.UriComponentsBuilder;
import com.concretepage.entity.Article;
import com.concretepage.service.IArticleService;

@Controller
@RequestMapping("user")
public class ArticleController {
	@Autowired
	private IArticleService articleService;
	
	@GetMapping("article/{id}")
	public ResponseEntity<Article> getArticleById(@PathVariable("id") Long id) {
		Article article = articleService.getArticleById(id);
		return new ResponseEntity<Article>(article, HttpStatus.OK);
	}
	@GetMapping("articles")
	public ResponseEntity<List<Article>> getAllArticles() {
		List<Article> list = articleService.getAllArticles();
		return new ResponseEntity<List<Article>>(list, HttpStatus.OK);
	}
	@PostMapping("article")
	public ResponseEntity<Void> addArticle(@RequestBody Article article, UriComponentsBuilder builder) {
		Article savedArticle = articleService.addArticle(article);  
                HttpHeaders headers = new HttpHeaders();
                headers.setLocation(builder.path("/article/{id}").buildAndExpand(savedArticle.getArticleId()).toUri());
                return new ResponseEntity<Void>(headers, HttpStatus.CREATED);
	}
	@PutMapping("article")
	public ResponseEntity<Article> updateArticle(@RequestBody Article article) {
		articleService.updateArticle(article);
		return new ResponseEntity<Article>(article, HttpStatus.OK);
	}
	@DeleteMapping("article/{id}")
	public ResponseEntity<Void> deleteArticle(@PathVariable("id") Long id) {
		articleService.deleteArticle(id);
		return new ResponseEntity<Void>(HttpStatus.NO_CONTENT);
	}	
}

SpringBootAppStarter.java

package com.concretepage;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class SpringBootAppStarter {  
    public static void main(String[] args) {
	SpringApplication.run(SpringBootAppStarter.class, args);
    }       
}

RestClientUtil.java

package com.concretepage;
import java.net.URI;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import com.concretepage.entity.Article;

public class RestClientUtil {
    public void getArticleByIdDemo(long id) {
    	HttpHeaders headers = new HttpHeaders();
    	headers.setContentType(MediaType.APPLICATION_JSON);
        RestTemplate restTemplate = new RestTemplate();
	String url = "http://localhost:8080/user/article/{id}";
        HttpEntity<String> requestEntity = new HttpEntity<String>(headers);
        ResponseEntity<Article> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, Article.class, id);
        Article article = responseEntity.getBody();
        System.out.println("Id:"+article.getArticleId()+", Title:"+article.getTitle()
                 +", Category:"+article.getCategory());      
    }
    public void getAllArticlesDemo() {
	HttpHeaders headers = new HttpHeaders();
	headers.setContentType(MediaType.APPLICATION_JSON);
        RestTemplate restTemplate = new RestTemplate();
	String url = "http://localhost:8080/user/articles";
        HttpEntity<String> requestEntity = new HttpEntity<String>(headers);
        ResponseEntity<Article[]> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, Article[].class);
        Article[] articles = responseEntity.getBody();
        for(Article article : articles) {
              System.out.println("Id:"+article.getArticleId()+", Title:"+article.getTitle()
                      +", Category: "+article.getCategory());
        }
    }
    public void addArticleDemo(Article objArticle) {
    	HttpHeaders headers = new HttpHeaders();
    	headers.setContentType(MediaType.APPLICATION_JSON);
        RestTemplate restTemplate = new RestTemplate();
	String url = "http://localhost:8080/user/article";
        HttpEntity<Article> requestEntity = new HttpEntity<Article>(objArticle, headers);
        URI uri = restTemplate.postForLocation(url, requestEntity);
        System.out.println(uri.getPath());    	
    }
    public void updateArticleDemo(Article objArticle) {
    	HttpHeaders headers = new HttpHeaders();
    	headers.setContentType(MediaType.APPLICATION_JSON);
        RestTemplate restTemplate = new RestTemplate();
	String url = "http://localhost:8080/user/article";
        HttpEntity<Article> requestEntity = new HttpEntity<Article>(objArticle, headers);
        restTemplate.put(url, requestEntity);
    }
    public void deleteArticleDemo(long id) {
    	HttpHeaders headers = new HttpHeaders();
    	headers.setContentType(MediaType.APPLICATION_JSON);
        RestTemplate restTemplate = new RestTemplate();
	String url = "http://localhost:8080/user/article/{id}";
        HttpEntity<Article> requestEntity = new HttpEntity<Article>(headers);
        restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, Void.class, id);        
    }
    public static void main(String args[]) {
    	RestClientUtil util = new RestClientUtil();
    	//Add article
	Article objArticle = new Article();
	objArticle.setTitle("Spring REST Security");
	objArticle.setCategory("Spring");
     	//util.addArticleDemo(objArticle);
        
    	//Update article
	objArticle.setArticleId(1);
	objArticle.setTitle("Java Concurrency");
	objArticle.setCategory("Java");	    
    	//util.updateArticleDemo(objArticle);
	    
    	//util.deleteArticleDemo(2);
        util.getArticleByIdDemo(1);	    
        System.out.println("---- All articles ----");
    	util.getAllArticlesDemo();    	
    }    
}

测试应用程序

要测试我们的演示应用程序，请找到下面的步骤。

1. 使用链接安装并启动Redis。

2. 如果你使用的是Windows操作系统，你可以先安装Cygwin，然后在其中安装Redis。

3. Redis将在6379端口的localhost上启动。

4. 在上面的文章中给出的表导入MySQL数据库中。

5. 我们可以通过以下方式运行我们的Spring Boot应用程序。

a. 使用Eclipse

使用页面末尾的下载链接下载项目的源代码。

将该项目导入eclipse。

使用命令提示符，进入项目的根文件夹并运行。

mvn clean eclipse:eclipse

然后在eclipse中刷新该项目。点击Run as -> Java Application来运行主类MyApplication。

Tomcat服务器将被启动。

b. 使用Maven命令

下载项目的源代码。使用命令提示符进入项目的根文件夹并运行命令。

mvn spring-boot:run

Tomcat服务器将被启动。

c. 使用可执行的JAR

使用命令提示符，转到项目的根文件夹并运行该命令。

mvn clean package

我们将在目标文件夹中得到可执行的spring-boot-app-0.0.1-SNAPSHOT.jar。以下列方式运行这个JAR。

java -jar target/spring-boot-app-0.0.1-SNAPSHOT.jar

Tomcat服务器将被启动。

6. 现在我们已经准备好测试这个应用程序了。要运行客户端，在eclipse中进入RestClientUtil类，点击Run as -> Java Application。

参考文献

【1】Spring Boot Reference Guide
【2】Spring Data Redis
【3】Spring Boot Redis
【4】Spring Data Redis Cache
【5】Spring Boot Redis Cache

源码下载

提取码：mao4

spring-boot-redis-cache.zip

猫巳
关注
专栏目录
spring boot使用redis做数据缓存
heishuiloveyou的博客
04-13 147
26. "若下面没出现“无缓存的时候调用”字样且能打印出数据表示测试成功");26. "若下面没出现“无缓存的时候调用”字样且能打印出数据表示测试成功");再访问http://localhost:8080/test2 调用缓存里的数据。再访问http://localhost:8080/test2 调用缓存里的数据。15. "无缓存的时候调用这里");20. "无缓存的时候调用这里");15. "无缓存的时候调用这里");20. "无缓存的时候调用这里");1 添加redis支持。1 添加redis支持。
spring boot注解方式使用redis缓存操作示例
08-25
本文将详细讲解如何使用注解方式在Spring Boot中进行Redis缓存操作。 首先，要使用Redis缓存，你需要在`pom.xml`文件中引入相应的依赖库。以下是两个关键的依赖： ```xml <groupId>org.springframework.boot ...
SpringBoot整合Redis进行缓存数据库查询
weixin_30768175的博客
02-26 1848
1、导入redis的启动器 <!--redis启动器--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId...
SpringBoot接口访问频率限制的实现方式（四）
最新发布
weixin_37549398的博客
08-13 267
本文全面介绍了在Spring Boot应用中实现接口访问频率限制的多种策略，包括基于过滤器、拦截器的方法，以及使用第三方库如Bucket4j的高级实现。合理的限流策略不仅能够抵御恶意攻击，还能增强系统的稳定性和用户满意度。在具体实施时，应根据业务特点选择合适的限流算法和实现技术，并进行相应的性能优化，以确保系统运行的高效率和高可靠性。
SpringBoot整合Redis实现查询缓存（缓存穿透、缓存雪崩、缓存击穿概念及其解决方法，缓存工具封装）
qq_45949914的博客
01-04 2105
springboot整合redis实现查询缓存，缓存穿透、缓存雪崩、缓存击穿的概念以及解决方案，封装redis工具类
Spring Boot手把手教学(19)：如何缓存数据, 减少数据库的访问频率？
非著名程序猿
02-26 1543
1、前言 在实际项目中，我们不仅需要实现应用的功能，也需要考虑整个应用的性能问题。当大量用户访问相同数据时，对数据库是个很大的考验。这时候如果使用数据缓存技术了，同样的数据就不需要通过访问数据库获取处理，在应用层面就可以拿到缓存数据，可以减轻数据库的压力、同时也能提高数据的响应速度。 那么在Spring Boot中提供哪些缓存支持呢？ Spring Framework中提供了对缓存数据的支持，核心是通过在方法中应用缓存方法，然后根据缓存中的已有可用信息来减少大量的执行次数。Spring Boot自动携带
springboot整合redis缓存实现查询缓存,查询缓存源码解读
yangyun901222的博客
04-03 3283
spring 定义了 org.springframework.cache.CacheManager 和 org.springframework.cache.Cache 接口来统一不同的缓存技术; CacheManager: 缓存管理器, 管理各种缓存(Cache)组件;如: RedisCache, EhCacheCache...等. 本文主要讲解 redis 缓存,以及自定义实现序列化 ...
spring-boot-整合redis
03-08
1. **缓存**：Redis 常用于缓存热点数据，以减少对后端数据库的压力。 2. **排行榜**：通过 Redis 的有序集合数据结构，可以轻松实现用户排名等功能。 3. **计数器**：例如统计用户点赞次数或访问量等场景。 4. **限...
spring boot集成redis做为通用缓存的实战demo，帮助大家彻底掌握s-cache-practice.zip
01-29
Redis 是一款高性能的键值数据存储系统，常被用作缓存服务，以提高应用的响应速度和减少数据库负载。在本实战项目 "s-cache-practice" 中，我们将学习如何将 Redis 集成到 Spring Boot 应用中，以实现通用缓存功能。...
redis资源下载，及spring boot的基本配置文件搭建以及常用的工具类方法
03-09
在这个例子中，`getData`方法的结果会被缓存在名为"myCache"的Redis缓存中，下次调用时如果缓存中有对应的数据，就会直接返回，而不会执行计算逻辑。 总的来说，通过Spring Boot和Spring Data Redis，我们可以轻松...
spring-boot-mybatis-redis.zip
08-13
【标题】"spring-boot-mybatis-redis.zip"是一个基于Spring Boot框架的项目，它整合了MyBatis持久层框架和Redis缓存系统。这个项目旨在提供一个基础的、易用的开发环境，使得开发者能够快速地搭建具备数据访问和缓存...
[redis+springboot]缓存sql执行结果
m0_60707623的博客
02-02 457
springboot整合redis进行sql结果缓存
SpringBoot Redis入门（二）——数据库查询结果缓存
朗朗的博客
01-05 687
我们使用SpringBoot自带的Lettuce缓存框架，通过上一节已经完成了对Lettuce的集成，测试只是做了手动写代码将我们的对象写入到redis中了，也读了出来，缓存实际也就是干存取的工作。你项目中要这么使用也没毛病。通过在方法上添加**@Cacheable**注解，框架可以自动帮我们把查询结果缓存起来，我们也无需特地去使用缓存api去取。但牛逼的程序猿就是要把懒发挥到极致，Cacheable就是这么产生的。
springboot整合redis缓存的增删改查
weixin_55666891的博客
07-27 1747
Springboot整合Reids使用
Spring Boot整合Redis做缓存实例
BuerYouth分享
06-27 548
Spring Boot整合Redis缓存实例Redis简介场景介绍实例环境及工具引入依赖启动器全局配置Redis编写测试接口运行实例开启redis-server运行IDEA中的项目打开API测试工具测试接口其他 Redis简介 Redis是一个开源的使用ANSI(美国国家标准协会) C语言编写、遵守BSD协议(一种开源协议)、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，它可以作为数据库、缓存和消息中间件，并提供多种语言的API。 关于Redis 场景介绍 利用Redis实现一个基本的缓
springboot缓存
weixin_42338186的博客
08-28 2605
在进入缓存之前先了解几个概念： cacheable的用法： 下面举例说明：缓存写在service层我们直接看service /** *将方法的运行结果进行储存以后要相同的数据，直接从缓存中取 * CacheManager管理多个组件的，对缓存的真正crud的操作，在cach组件中，每一个缓存组件有自己的名字： * 几个属性： * cacheNames/va...
StringBoot+SpringCache+redis简单实现查询数据缓存
m0_75137365的博客
06-05 159
代表设置的缓存失效时间为30秒,,如果想设置高一点可以在。#连接池最大阻塞时间(负数表示没有限制)#redis端口,默认的都是6379。这里只放上service如何调用。#连接池中最大空闲链接。#连接池中最小空闲链接。下面测试的时候可以在。
springboot整合redis操作缓存（将查询到的数据放在缓存中）
qq_41358574的博客
10-10 2157
1.依赖和配置： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> RedisConfig： package com.english.english_vision
springBoot整合Redis实现将数据库查出来的信息放入缓存
GJX00的博客
03-29 2067
1.引入依赖 <!-- 引入redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 2.去集体的业务（比如查询用户的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猫巳

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值