您现在的位置是：主页 > news > wordpress 简易主题/镇江交叉口优化

wordpress 简易主题/镇江交叉口优化

admin2025/6/21 19:59:38【news】

简介wordpress 简易主题,镇江交叉口优化,陕西疫情最新数据消息,node.js可以做网站么文章目录演示工具版本项目结构Maven 依赖使用 Lettuce 配置使用 Jedis 配置ListOperationsSetOperationsHashOperationsStringRedisTemplateRedisTemplateSpring Boot Main 类运行应用程序参考文献源码下载本页将介绍Spring Boot Data Redis的例子。 Redis是一个开源的内存数据…

wordpress 简易主题,镇江交叉口优化,陕西疫情最新数据消息,node.js可以做网站么文章目录演示工具版本项目结构Maven 依赖使用 Lettuce 配置使用 Jedis 配置ListOperationsSetOperationsHashOperationsStringRedisTemplateRedisTemplateSpring Boot Main 类运行应用程序参考文献源码下载本页将介绍Spring Boot Data Redis的例子。 Redis是一个开源的内存数据…

文章目录

  • 演示工具版本
  • 项目结构
  • Maven 依赖
  • 使用 Lettuce 配置
  • 使用 Jedis 配置
  • ListOperations
  • SetOperations
  • HashOperations
  • StringRedisTemplate
  • RedisTemplate
  • Spring Boot Main 类
  • 运行应用程序
  • 参考文献
  • 源码下载

本页将介绍Spring Boot Data Redis的例子。

Redis是一个开源的内存数据结构存储，可用作数据库、缓存和消息代理。

Redis支持数据结构，如字符串、哈希值、列表、集合等。

Redis是一个NoSQL存储，使用键/值来存储数据。

Spring Boot为Redis的依赖提供了spring-boot-starter-data-redis。

Redis连接使用LettuceConnectionFactory或JedisConnectionFactory获得。

Lettuce和Jedis是Java Redis客户端。

Spring Boot 2.0默认使用Lettuce。

Spring Data提供了RedisTemplate作为中心类来与Redis存储中的数据进行交互。

为了与字符串数据交互，我们可以使用RedisTemplate的以字符串为中心的扩展StringRedisTemplate。

Spring Data提供了ListOperations、SetOperations、HashOperations等来对Redis数据进行操作，我们可以直接在Spring应用程序中注入这些操作。

演示工具版本

  1. Java 9
  2. Spring 5.0.7.RELEASE
  3. Spring Boot 2.0.3.RELEASE
  4. Maven 3.5.2
  5. 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.3.RELEASE</version><relativePath/></parent><properties><java.version>9</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</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>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>

使用 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

ListOperations

ListOperations用于Redis列表的具体操作。找到它的一些方法。

leftPush(K key, V value): 为键上列表添加值到最前。

rightPush(K key, V value): 为键上列表添加值到最后。

leftPop(K key): 删除并返回存储在key处的列表中的第一个元素。

rightPop(K key): 删除并返回存储在key处的列表中的最后一个元素。

remove(K key, long count, Object value): 从存储在键处的列表中删除第一个给定数量 (count)的值。

index(K key, long index): 从键的列表中获取索引处的元素。

size(K key): 获取存储在键处的列表的大小。

现在找到ListOperations的例子。在这里，我们正在执行创建、读取和删除操作。

FriendDAO.java

package com.concretepage.dao;
import javax.annotation.Resource;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.stereotype.Repository;
import com.concretepage.Person;@Repository
public class FriendDAO {private static final String KEY = "friendsKey";@Resource(name="redisTemplate")private ListOperations<String, Person> opsForList;	 	 public void addFriend(Person person) {opsForList.leftPush(KEY, person);}public long getNumberOfFriends() {return opsForList.size(KEY);}public Person getFriendAtIndex(Integer index) {return opsForList.index(KEY, index);}public void removeFriend(Person p) {opsForList.remove(KEY, 1, p);}
}

Person.java

package com.concretepage;
import java.io.Serializable;
public class Person implements Serializable {private static final long serialVersionUID = 1L;private int id;private String name;private int age;public Person() { }public Person(int id, String name, int age) {this.id = id;this.name = name;this.age = age;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String toString() {return id +" - " + name + " - " + age;}@Overridepublic boolean equals(final Object obj) {if (obj == null) {return false;}final Person person = (Person) obj;if (this == person) {return true;} else {return (this.name.equals(person.name) && this.age == person.age);}  }@Overridepublic int hashCode() {int hashno = 7;hashno = 13 * hashno + (name == null ? 0 : name.hashCode());return hashno;}
}

SetOperations

SetOperations执行Redis集合的特定操作。找到它的一些方法。

add(K key, V… values): 将值添加到键的Set中。

members(K key): 获取键的Set中所有的元素。

size(K key): 获取键的Set中元素个数。

remove(K key, Object… values): 从键的Set中移除给定的值，并返回移除元素的数量。

现在找到SetOperations的例子。这里我们将执行创建、读取和删除操作。

FamilyDAO.java

package com.concretepage.dao;
import java.util.Set;
import javax.annotation.Resource;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.stereotype.Repository;
import com.concretepage.Person;@Repository
public class FamilyDAO {private static final String KEY = "myFamilyKey";@Resource(name="redisTemplate")private SetOperations<String, Person> setOps;	  public void addFamilyMembers(Person... persons) {setOps.add(KEY, persons);  	}public Set<Person> getFamilyMembers() {return setOps.members(KEY);}public long getNumberOfFamilyMembers() {return setOps.size(KEY);}public long removeFamilyMembers(Person... persons) {return setOps.remove(KEY, (Object[])persons);}	 
}

HashOperations

HashOperations执行Redis Map的特定操作，在hash上工作。找到它的一些方法。
putIfAbsent(H key, HK hashKey, HV value): 只在hashKey不存在的情况下设置hashKey的值。

put(H key, HK hashKey, HV value): 设置hashKey的值。

get(H key, Object hashKey): 从key的hashKey取值。

size(H key): 读取键值处的哈希值数量。

entries(H key): 获取存储在key处的所有哈希值。

delete(H key, Object… hashKeys): 删除给定key上的hashKey值。

找到具有创建、读取、更新和删除（CRUD）操作的HashOperations的例子。

EmployeeDAO.java

package com.concretepage.dao;
import java.util.Map;
import javax.annotation.Resource;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.stereotype.Repository;
import com.concretepage.Person;@Repository
public class EmployeeDAO {private static final String KEY = "employeesKey";@Resource(name="redisTemplate")private HashOperations<String, Integer, Person> hashOps;	 public void addEmployee(Person person) {hashOps.putIfAbsent(KEY, person.getId(), person);}public void updateEmployee(Person person) {hashOps.put(KEY, person.getId(), person);}	  public Person getEmployee(Integer id) {return hashOps.get(KEY, id);}public long getNumberOfEmployees() {return hashOps.size(KEY);}public Map<Integer, Person> getAllEmployees() {return hashOps.entries(KEY);}public long deleteEmployees(Integer... ids) {return hashOps.delete(KEY, (Object)ids);}	  		  
}

StringRedisTemplate

StringRedisTemplate是RedisTemplate的以字符串为重点的扩展。

大多数时候，我们用字符串进行Redis操作，因此Spring Data提供了一个专门的模板，即StringRedisTemplate。

这里我们将讨论StringRedisTemplate的OPPSForValue()方法，它将返回ValueOperations。查找一些ValueOperations方法。

setIfAbsent(K key, V value): 存在键则设置，不存在则新增。

set(K key, V value): 设置键的值。

get(Object key): 读取键的值。

现在找到使用StringRedisTemplate的CRUD操作的例子。

UserDAO.java


package com.concretepage.dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Repository;@Repository
public class UserDAO {private static final String KEY = "userKey";@Autowiredprivate StringRedisTemplate stringRedisTemplate;public void addUserName(String uname) {stringRedisTemplate.opsForValue().setIfAbsent(KEY, uname);}public void updateUserName(String uname) {stringRedisTemplate.opsForValue().set(KEY, uname);}	  public String getUserName() {return stringRedisTemplate.opsForValue().get(KEY);}public void deleteUser() {stringRedisTemplate.delete(KEY);}	  
}

RedisTemplate

RedisTemplate是与Redis存储的数据交互的中心类。

它在给定对象和存储在Redis中的二进制数据之间执行自动序列化和反序列化。

为了在我们的Spring Boot应用程序中注入RedisTemplate，我们需要在JavaConfig中创建RedisTemplate Bean，如下所示。

RedisConfig.java

package com.concretepage;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import com.concretepage.Person;@Configuration
@ComponentScan("com.concretepage")
public class RedisConfig {@Beanpublic RedisConnectionFactory redisConnectionFactory() {LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory();return connectionFactory;}@Beanpublic RedisTemplate<String, Person> redisTemplate() {RedisTemplate<String, Person> redisTemplate = new RedisTemplate<>();redisTemplate.setConnectionFactory(redisConnectionFactory());return redisTemplate;}
}

现在我们可以在我们的DAO中注入RedisTemplate，并可以按以下方式使用它。

FriendDAO.java

package com.concretepage.dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;
import com.concretepage.Person;@Repository
public class FriendDAO {private static final String KEY = "friendsKey";@Autowiredprivate RedisTemplate<String, Person> redisTemplate;public void addFriend(Person person) {redisTemplate.opsForList().leftPush(KEY, person);}public long getNumberOfFriends() {return redisTemplate.opsForList().size(KEY);}public Person getFriendAtIndex(Integer index) {return redisTemplate.opsForList().index(KEY, index);}public void removeFriend(Person p) {redisTemplate.opsForList().remove(KEY, 1, p);}
}

Spring Boot Main 类

在这里，我们正在创建Spring Boot主类来执行应用程序，并将测试我们的DAO类。

SpringBootAppStarter.java

package com.concretepage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import com.concretepage.dao.EmployeeDAO;
import com.concretepage.dao.FamilyDAO;
import com.concretepage.dao.FriendDAO;
import com.concretepage.dao.UserDAO;@SpringBootApplication
public class SpringBootAppStarter implements CommandLineRunner {@Autowiredprivate FriendDAO friendDAO;@Autowired	private FamilyDAO familyDAO;@Autowired	private EmployeeDAO empDAO;@Autowired	private UserDAO userDAO;public static void main(String[] args) throws Exception {SpringApplication.run(SpringBootAppStarter.class, args);}@Overridepublic void run(String... args) throws Exception {System.out.println("--Example of ListOperations--");Person p1 = new Person(1, "Mahesh", 30);friendDAO.addFriend(p1);Person p2 = new Person(2, "Krishna", 35);friendDAO.addFriend(p2);System.out.println("Number of friends: " + friendDAO.getNumberOfFriends());System.out.println(friendDAO.getFriendAtIndex(1));friendDAO.removeFriend(p2);System.out.println(friendDAO.getFriendAtIndex(1)); //It will return null, because value is deleted.  System.out.println("--Example of SetOperations--");Person p11 = new Person(101, "Ram", 30);Person p12 = new Person(102, "Lakshman", 25);Person p13 = new Person(103, "Bharat", 35);familyDAO.addFamilyMembers(p11, p12, p13);System.out.println("Number of Family members: " + familyDAO.getNumberOfFamilyMembers());System.out.println(familyDAO.getFamilyMembers());System.out.println("No. of Removed Family Members: " + familyDAO.removeFamilyMembers(p11, p12));System.out.println(familyDAO.getFamilyMembers());System.out.println("--Example of HashOperations--");Person emp1 = new Person(11, "Ravan", 45);Person emp2 = new Person(12, "Kumbhkarn", 35);Person emp3 = new Person(13, "Vibhisan", 25);empDAO.addEmployee(emp1);empDAO.addEmployee(emp2);empDAO.addEmployee(emp3);System.out.println("No. of Employees: "+ empDAO.getNumberOfEmployees());System.out.println(empDAO.getAllEmployees());emp2.setAge(20);empDAO.updateEmployee(emp2);System.out.println(empDAO.getEmployee(12));System.out.println("--Example of StringRedisTemplate--");userDAO.addUserName("sriram");System.out.println(userDAO.getUserName());userDAO.updateUserName("srikrishna");System.out.println(userDAO.getUserName());userDAO.deleteUser();System.out.println(userDAO.getUserName()); //It will return null, because value is deleted.  	   }
}

运行应用程序

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

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

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

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

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

mvn spring-boot:run

参考文献

【1】Spring Boot Reference Guide
【2】Spring Data Redis Example
【3】Spring Boot Redis

源码下载

链接：https://pan.baidu.com/s/1Ewz7GASel5UQ3O7rlBHshQ
提取码：mao4

相关文章

最新文章