Java >> Java Tutorial >  >> Tag >> Spring

Caching:So verwenden Sie Redis Caching mit Spring Boot

Spring

In diesem Einführungsbeitrag zeigen wir, wie man Redis-Caching in einer einfachen Spring-Boot-Anwendung verwendet. In nachfolgenden Beiträgen werden wir verschiedene Faktoren des Redis-Cachings bewerten. Aber jetzt werden wir versuchen, uns auf ein einfaches Problem der Bereitstellung von Caching für einen Restdienst zu konzentrieren, der unternehmensbezogene Daten für die Benutzeroberfläche bereitstellt. Diese Daten befinden sich in einer Datenbank, aber Caching hilft uns, die Leistung zu verbessern.

Was Sie brauchen

  • Java 8
  • MySQL-Datenbank
  • IntelliJ-Editor
  • Gradle
  • Redis Server und Redis Desktop Manager

Spring Boot-basierter Wiederherstellungsdienst

Als Teil dieses Beitrags werden wir einen einfachen Spring-Boot-basierten Ruhedienst aufbauen. Dieser Restdienst liefert unternehmensbezogene Daten, die in mysql gespeichert werden Datenbank.

Wir werden Gradle verwenden, um unsere Abhängigkeiten in diesem Projekt aufzubauen. Wichtige Abhängigkeiten für dieses Projekt sind spring-boot-starter , spring-boot-jpa und spring-boot-starter-data-redis Mit allen erforderlichen Gradle-Abhängigkeiten sieht unser Gradle-Skript wie folgt aus:

buildscript {
  ext {
    springBootVersion = '1.5.10.RELEASE'
  }
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
  }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.betterjavacode'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
  mavenCentral()
}

jar {
    manifest {
        attributes 'Main-Class':'com.betterjavacode.SpringAppCache.SpringAppCacheApplication'
    }
    baseName= 'SpringAppCache'
    version='0.0.1-SNAPSHOT'
}

dependencies {
  compile('org.springframework.boot:spring-boot-starter')
  compile('org.springframework.data:spring-data-jpa')
  compile('org.springframework.boot:spring-boot-starter-data-redis')
  compile('org.springframework.boot:spring-boot-starter-web')
        compile('org.hibernate.javax.persistence:hibernate-jpa-2.1-api:1.0.0.Final')
        compile('mysql:mysql-connector-java:5.1.6')
        compile('org.hibernate:hibernate-core:5.2.13.Final')   
        compile('org.aspectj:aspectjweaver:1.8.13')
  testCompile('org.springframework.boot:spring-boot-starter-test')
}

Lassen Sie uns eine Modellklasse für das Objekt Company erstellen die wie folgt aussehen wird:

package com.betterjavacode.models;

import javax.persistence.*;
import java.io.Serializable;

@Entity(name="Company")
@Table(name="company")
public class Company implements Serializable
{
    public Company()
    {

    }

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;
    @Column(nullable=false)
    private String name;
    @Column(nullable=false)
    private String type;

    public Company(int id, String name, String type)
    {
        this.id = id;
        this.type = type;
        this.name = name;
    }

    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 String getType()
    {
        return type;
    }

    public void setType(String type)
    {
        this.type = type;
    }
}

Wir werden keinen Code der mittleren Ebene zeigen, der hauptsächlich ausmacht, wie die Daten aufgebaut werden.

Unser RestController verwendet einen autowired CompanyManager Firmendaten aus der Datenbank zu holen.

Bevor wir RestController bauen , zeigen wir die Konfiguration, die wir in SpringAppCacheApplication kommentiert haben Hauptklasse.

package com.betterjavacode.SpringAppCache;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@SpringBootApplication
@EnableAutoConfiguration
@ComponentScan(basePackages = "com.betterjavacode")
@EnableJpaRepositories(basePackages = "com.betterjavacode.repositories")
@EnableCaching
public class SpringAppCacheApplication
{
  public static void main(String[] args) {
    SpringApplication.run(SpringAppCacheApplication.class, args);
  }
}

Hier können Sie sehen, dass wir das Caching mit der Anmerkung @EnableCaching aktiviert haben .

Jetzt in unserem RestController Klasse CompanyController , dies zeigt die Anmerkung von @Cachable Dies hilft bei der Entscheidung, wann Daten für die eingehende Anforderung zwischengespeichert werden sollen. Diese Anmerkung speichert Daten, die für die Anfrage basierend auf der Konfiguration abgerufen wurden.

package com.betterjavacode.resources;

import java.util.List;

import com.betterjavacode.interfaces.CompanyManager;
import com.betterjavacode.models.Company;
import org.hibernate.annotations.Cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;


import javax.websocket.server.PathParam;

@RestController
@RequestMapping(value="/cachedemo/v1")
public class CompanyController
{


    @Autowired
    public CompanyManager companyManager;


    @RequestMapping(value = "/companies", method= RequestMethod.GET,
    produces = {"application/json"})
    @ResponseStatus(HttpStatus.OK)
    @ResponseBody
    @Cacheable("companies")
    public List<Company> getAllCompanies()
    {
        return companyManager.getAllCompanies();
    }


    @RequestMapping(value = "/companies/{id}/", method = RequestMethod.GET, produces = {"application/json"})
    @ResponseStatus(HttpStatus.OK)
    @ResponseBody
    @Cacheable(value = "company", key = "#id")
    public Company getCompany(@PathVariable("id") int id)
    {
        return companyManager.getCompany(id);
    }
}

Hier ist ein Controller, wenn Sie sehen, dass wir die Daten aus der Datenbank mit der Anmerkung @Cacheable zwischenspeichern

Um sicherzustellen, dass Daten mit dem Redis-Server zwischengespeichert werden, benötigen wir bestimmte Eigenschaften, bei denen uns diese Anmerkungen helfen, die Daten zwischenzuspeichern. Die Eigenschaften zum Konfigurieren des Redis-Servers sind unten:

#########################################################################################
## REDIS CACHE
#########################################################################################
spring.cache.type = redis
spring.redis.host = 127.0.0.1
spring.redis.port = 6379

Sobald Sie das Projekt erstellt und ausgeführt haben, können wir die REST-Anforderungen zum Abrufen von Daten ausführen. Wenn wir dieselben Anfragen mehrmals ausführen, können wir die Daten in Redis sehen.

Schlussfolgerung

In diesem Beitrag haben wir gezeigt, wie Redis-Caching verwendet wird, um die Daten für einen Spring Boot-basierten REST-Dienst zwischenzuspeichern. Der Code aus diesem Beitrag steht zum Herunterladen von github

zur Verfügung


Java-Tag