Spring Data Redis-Beispiel

Da Sie über Redis-Installation und -Konfiguration gelesen haben, verstehen Sie größtenteils das Hauptkonzept der Redis-Datenbank. Redis ist ein extrem leistungsstarker, leichter Datenspeicher. Es bietet Schlüssel-/Wertdatenzugriff auf persistente Byte-Arrays, Listen, Sätze und Hash-Datenstrukturen. So werden die Einfüge-, Lösch- und Abrufvorgänge in Redis sehr einfach, wie wir mit der Verwendung von Map-, List-, Set- und Array-Datenstrukturen gearbeitet haben, wie sie in normalen Java-Programmen verwendet werden; Obwohl es einige minimale Änderungen gibt, die Sie wahrscheinlich nie interessieren würden.

Wie Sie es bei jeder Datenbankplattform bereits getan haben, müssen Sie den Datenbanktreiber herunterladen/installieren. Für Redis stehen vier Treiberbibliotheken zur Verfügung, damit Ihre Anwendung eine Verbindung zu Redis herstellen kann. Spring Data unterstützt die Verbindung zu Redis über entweder Jedis (Das wird in diesem Tutorial berücksichtigt), JRedis, RJC oder SRP Treiberbibliotheken. Es spielt keine Rolle, welche Bibliothek verwendet wurde, da Spring Data die Unterschiede zwischen diesen Treibern in einen gemeinsamen Satz von APIs und Helfern im Vorlagenstil abstrahiert hat.

1. Spring-Kontextkonfiguration

Herstellen einer Verbindung zu Redis über Jedismüssen Sie eine Instanz von erstellen org.springframework.data.redis.connection.jedis.JedisConnectionFactory. Die anderen Treiberbibliotheken verfügen über entsprechende ConnectionFactory-Unterklassen. Nachfolgend der richtige Spring-Kontext (SpringContext.xml), der zum Initialisieren und Verbinden der Redis-Datenbank mithilfe von Spring verwendet werden sollte.

SpringContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

	<!--  Scanning the Spring Beans -->
	<context:component-scan base-package="net.javabeat.springdata.beans"></context:component-scan>
	<!-- Redis Connection Factory -->
	<bean id="jedisConnFactory"  
			p:use-pool="true" />
	<!-- Redis Template -->
	<bean id="redisTemplate"  
			p:connection-factory-ref="jedisConnFactory" />

</beans>
  • Für die Suche nach allen Spring-Komponenten (Beans) haben Sie das Component-Scan-Element bereitgestellt.
  • Für die Verbindung der Redis-Datenbank haben Sie die Bean „Jedis Connection Factory“ bereitgestellt.
  • Die zentrale Abstraktion, die Sie wahrscheinlich verwenden werden, wenn Sie über Spring Data Redis auf Redis zugreifen, ist die org.springframework.data.redis.core.RedisTemplate Klasse.

Da der Funktionsumfang von Redis wirklich zu groß ist, um ihn effektiv in einer einzigen Klasse zusammenzufassen, werden die verschiedenen Operationen an Daten in separate Operationen aufgeteilt Operationen Klassen wie folgt:

  • ValueOperations:Gibt die Operationen zurück, die an einfachen Werten (oder Strings in der Redis-Terminologie) ausgeführt werden.
  • ListOperations:Gibt die an Listenwerten durchgeführten Operationen zurück.
  • SetOperations:Gibt die an festgelegten Werten durchgeführten Operationen zurück.
  • ZSetOperations:Gibt die an Zset-Werten durchgeführten Operationen zurück (auch als sortierte Mengen bezeichnet).
  • HashOperations:Gibt die an Hashwerten durchgeführten Operationen zurück.
  • BoundValueOperations:Gibt die Operationen zurück, die an Hash-Werten ausgeführt werden, die an den angegebenen Schlüssel gebunden sind.
  • BoundListOperations:Gibt die Operationen zurück, die für Listenwerte ausgeführt werden, die an den angegebenen Schlüssel gebunden sind.
  • BoundSetOperations:Gibt die Operationen zurück, die für festgelegte Werte ausgeführt werden, die an den angegebenen Schlüssel gebunden sind.
  • Gebundene ZSet-Operationen:Gibt die Operationen zurück, die an Zset-Werten (auch als sortierte Mengen bezeichnet) ausgeführt werden, die an den angegebenen Schlüssel gebunden sind.
  • BoundHashOperations:Gibt die Operationen zurück, die an Hash-Werten ausgeführt werden, die an den angegebenen Schlüssel gebunden sind.

2. Maven-Abhängigkeiten für Spring Data Redis

Die erforderlichen Bibliotheken und Abhängigkeiten, um die Verbindung von Redis zu ermöglichen, sind in der folgenden pom.xml-Datei aufgeführt.

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>net.javabeat.springdata</groupId>
	<artifactId>SpringData</artifactId>
	<version>1.0</version>
	<packaging>jar</packaging>
	<name>Spring Data</name>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
		</plugins>
	</build>
	<dependencies>
		<!-- SLF4J dependency -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.6.1</version>
		</dependency>
		<!-- Spring Data - Redis Library -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.2.1.RELEASE</version>
		</dependency>
		<!-- Jedis Driver Library -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.4.2</version>
		</dependency>
		<!-- Spring Core -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<!-- Spring Data commons -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-commons</artifactId>
			<version>1.5.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.0.3.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
			<version>2.2</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>4.0.3.RELEASE</version>
		</dependency>
	</dependencies>
</project>

3. Frühlingsbohnen (RegisterationBean)

Für den Zugriff auf das oben definierte RedisTemplate müssen Sie verwenden @Autowired Anmerkung zur Verfügbarkeit von RedisTemplate in Ihren Spring Beans.

RegistrationBean.java

package net.javabeat.springdata.beans;

import net.javabeat.springdata.jpa.data.User;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class RegistrationBean {
	@Autowired
	private RedisTemplate<String,User> redisTemplate;

	public RedisTemplate<String, User> getRedisTemplate() {
		return redisTemplate;
	}

	public void setRedisTemplate(RedisTemplate<String, User> redisTemplate) {
		this.redisTemplate = redisTemplate;
	}
}

4. Java Beans

Die Geschäftsdomäne ist sehr einfach, es handelt sich lediglich um eine Benutzerentität, die einer Instanz von Address zugeordnet ist. Schauen Sie unten.

Benutzer.java

package net.javabeat.springdata.jpa.data;

import java.io.Serializable;

public class User implements Serializable{

	private static final long serialVersionUID = 1L;

	private String id;

	private String fullName;

	private String age;

	private String status;

	private Address address;

	public String getFullName() {
		return fullName;
	}

	public void setFullName(String fullName) {
		this.fullName = fullName;
	}

	public String getAge() {
		return age;
	}

	public void setAge(String age) {
		this.age = age;
	}

	public String getStatus() {
		return status;
	}

	public void setStatus(String status) {
		this.status = status;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public Address getAddress() {
		return address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}

	public String toString() {
		return this.id + "," + this.fullName;
	}
}

Adresse.java

package net.javabeat.springdata.jpa.data;

import java.io.Serializable;

public class Address implements Serializable{

	private static final long serialVersionUID = 1L;

	private Long addressId;

	private String addressValue;

	public Long getAddressId() {
		return addressId;
	}
	public void setAddressId(Long addressId) {
		this.addressId = addressId;
	}
	public String getAddressValue() {
		return addressValue;
	}
	public void setAddressValue(String addressValue) {
		this.addressValue = addressValue;
	}
}

5. Beispielanwendung für Spring Data Redis

Die folgende Java-Klasse ist lediglich eine ausführbare Anwendung, die zum Beibehalten einer Benutzerentität entwickelt wurde, die einer Adresse in der Redis-Schlüssel-/Wertdatenbank zugeordnet ist. Beachten Sie, dass die Verwendung dieser Konzeptentität nur theoretischer Natur ist und keine Bedeutung hat, wenn es darum geht, sie innerhalb von Redis anzuwenden.

Ausführbare Datei.java

package net.javabeat.springdata.executable;

import net.javabeat.springdata.beans.RegistrationBean;
import net.javabeat.springdata.jpa.data.Address;
import net.javabeat.springdata.jpa.data.User;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Executable {
	public static RegistrationBean registrationBean;
	public static ClassPathXmlApplicationContext context;

	static {
		// Acquire Context
		context = new ClassPathXmlApplicationContext("SpringContext.xml");
	}

	public static void main(String () args) throws Exception{
		// Create User
		createUser();
	}

	public static void createUser(){
		User user = new User();
		user.setId("20011202");
		user.setFullName("Susa Richard");
		user.setStatus("A");
		user.setAge("30");
		Address address = new Address();
		address.setAddressValue("UK/Manchester");
		user.setAddress(address);
		RegistrationBean bean = (RegistrationBean)context.getBean("registrationBean");
		// Persisting Inside the Hash User object
		bean.getRedisTemplate().opsForHash().put("UserA", user.hashCode(),user);
		// Retrieving the User object from the Redis by using the suggested key
		User x = (User)bean.getRedisTemplate().opsForHash().get("UserA", user.hashCode());
		System.out.println(x);
	}
}

6. Fragen Sie den Redis Persisted Store ab

Der folgende Schnappschuss zeigt Ihnen das Benutzerobjekt, das bereits im persistenten Hash-Speicher in der Redis-Schlüssel/Wert-Datenbank vorhanden ist.Redis persistente Daten

Zusammenfassung

Spring Data bietet dem Spring-Entwickler eine abstrahierte, einfachste und modellierte Integrationsmöglichkeit für die Kommunikation mit der Redis-Datenbank. Unabhängig von der Treiberbibliothek, die der Entwickler verwendet hatte, konnte Spring Data immer noch auf standardmäßige Weise mit Redis arbeiten, und das liegt an der RedisTemplate Spring Data-Funktion. Durch die Verwendung von RedisTemplate ist der Entwickler in der Lage, alle definierten Vorgänge in Bezug auf die verschiedenen von Redis bereitgestellten persistenten Speicher aufzurufen.

Laden Sie den Quellcode herunter

(wpdm_file id=86)

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen