使用 Spring Data 的 Apache Ignite

Spring Data 提供了一种统一且简单的方法来访问不同类型的持久性存储，包括关系数据库系统和 NoSQL 数据存储。它在 JPA 之上，添加了另一个抽象层并定义了一个基于标准的设计以支持 Spring 上下文中的持久层。

Apache Ignite IgniteRepository 实现了 Spring Data CrudRepository 接口并扩展了 CrudRepository 的基本功能，后者又支持：

1. 针对特定类型的存储库的基本 CRUD 操作。
2. 通过 Spring Data API 访问 Apache Ignite SQL 网格。

使用 Spring Data 的存储库，您只需要编写一个带有 finder 方法的接口来查询对象。所有用于操作对象的 CRUD 方法将自动交付。举个例子：

@RepositoryConfig(cacheName = "DogCache")
public interface DogRepository extends IgniteRepository<Dog, Long> {
    List<Dog> getDogByName(String name);
    Dog getDogById (Long id);
}

在本文中，我们将讨论以下主题：

• 从头开始创建一个 Maven 项目，以便将 Spring Data 与 Apache Ignite Grid 结合使用。
• 通过 Spring Data 框架将一些实体保存到 Ignite 缓存中。

在开始之前，让我们介绍一下沙箱中项目的先决条件：

1. Java JDK 1.8
2. Ignite version2.0
3. Apache Maven 版本 >3.0.3

第 1 步

让我们先设置沙箱。创建 Maven 项目或从 GitHub 存储库克隆项目。

mvn archetype:create -DgroupId=com.blu.imdg -DartifactId=spring-data

第 2 步

修改pom.xml，添加如下maven依赖：

<dependency>
    <groupId>org.apache.ignite</groupId>
    <artifactId>ignite-core</artifactId>
    <version>2.0.0</version>
</dependency>
<dependency>
    <groupId>org.apache.ignite</groupId>
    <artifactId>ignite-spring</artifactId>
    <version>2.0.0</version>
</dependency>
<dependency>
    <groupId>org.apache.ignite</groupId>
    <artifactId>ignite-spring-data</artifactId>
    <version>2.0.0</version>
</dependency>
<dependency>
    <groupId>org.apache.ignite</groupId>
    <artifactId>ignite-indexing</artifactId>
    <version>2.0.0</version>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <version>1.4.195</version>
</dependency>

请注意，maven h2 依赖项是可选的。如果您收到类似“org.h2.result.RowFactory”的错误，请显式添加依赖项。

领域模型

我们的示例领域模型由两个不同的实体组成：Breed 和 Dog。

Breed 和 Dog 之间的关联是 ManyToOne。一只狗只能有一个品种。

第 3 步

现在，让我们通过创建 Java 类并使用所需的元信息对其进行注释来映射域模型。让我们从 Breed 类开始。

package com.blu.imdg.model;

import org.apache.ignite.cache.query.annotations.QuerySqlField;

import java.io.Serializable;

public class Breed implements Serializable {

    @QuerySqlField(index = true)
    private Long id;

    @QuerySqlField(index = true)
    private String name;

    public Long getId() {

        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Breed{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

请注意，@QuerySqlField 批注为 SQL 查询启用字段。

创建另一个名为 Dog 的类并向其添加以下内容。

package com.blu.imdg.model;

import org.apache.ignite.cache.query.annotations.QuerySqlField;

import java.io.Serializable;
import java.sql.Date;

public class Dog implements Serializable {

    @QuerySqlField(index = true)
    private Long id;
    @QuerySqlField(index = true)
    private String name;
    @QuerySqlField(index = true)
    private Long breedid;
    @QuerySqlField(index = true)
    private Date birthdate;

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Long getBreedid() {
        return breedid;
    }

    public void setBreedid(Long breedid) {
        this.breedid = breedid;
    }

    public Date getBirthdate() {
        return birthdate;
    }

    public void setBirthdate(Date birthdate) {
        this.birthdate = birthdate;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", breedid=" + breedid +
                ", birthdate=" + birthdate +
                '}';
    }
}

第 4 步

现在，让我们为之前创建的所有 pojo 创建 Spring 存储库。

package com.blu.imdg.repositories;

import com.blu.imdg.model.Dog;
import org.apache.ignite.springdata.repository.IgniteRepository;
import org.apache.ignite.springdata.repository.config.RepositoryConfig;

import java.util.List;

@RepositoryConfig(cacheName = "DogCache")
public interface DogRepository extends IgniteRepository<Dog, Long> {
    List<Dog> getDogByName(String name);
    Dog getDogById (Long id);
}

应指定 @RepositoryConfig 注释以将存储库映射到分布式缓存。此外，我们有两个查找器方法 getDogByName 和 getDogById 用于查询缓存。

让我们为 Breed 域添加一个类似的存储库，如下所示：

package com.blu.imdg.repositories;

import com.blu.imdg.model.Breed;
import org.apache.ignite.springdata.repository.IgniteRepository;
import org.apache.ignite.springdata.repository.config.Query;
import org.apache.ignite.springdata.repository.config.RepositoryConfig;
import org.springframework.data.domain.Pageable;

import java.util.List;

@RepositoryConfig(cacheName = "BreedCache")
public interface BreedRepository extends IgniteRepository<Breed, Long> {

    List<Breed> getAllBreedsByName (String name);

    @Query("SELECT id FROM Breed WHERE id = ?")
    List<Long> getById (long id, Pageable pageable);
}

在上面的 BreedRepository 接口中，我们还使用了 @Query(queryString) 注解，如果方法调用的结果需要执行具体的 SQL 查询，则可以使用该注解。

第 5 步

让我们创建缓存配置类。创建一个Ignite缓存配置类，用@EnableIgniteRepositories注解标记应用配置，如下图：

package com.blu.imdg.repositories;

import com.blu.imdg.model.Breed;
import com.blu.imdg.model.Dog;
import org.apache.ignite.Ignite;
import org.apache.ignite.Ignition;
import org.apache.ignite.configuration.CacheConfiguration;
import org.apache.ignite.configuration.IgniteConfiguration;
import org.apache.ignite.springdata.repository.config.EnableIgniteRepositories;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableIgniteRepositories
public class SpringAppConfig {
    @Bean
    public Ignite igniteInstance() {
        IgniteConfiguration cfg = new IgniteConfiguration();
        // Setting some custom name for the node.
        cfg.setIgniteInstanceName("springDataNode");
        // Enabling peer-class loading feature.
        cfg.setPeerClassLoadingEnabled(true);
        // Defining and creating a new cache to be used by Ignite Spring Data
        // repository.
        CacheConfiguration ccfgDog = new CacheConfiguration("DogCache");
        CacheConfiguration ccfgBreed = new CacheConfiguration("BreedCache");
        // Setting SQL schema for the cache.
        ccfgBreed.setIndexedTypes(Long.class, Breed.class);
        ccfgDog.setIndexedTypes(Long.class, Dog.class);

        cfg.setCacheConfiguration(new CacheConfiguration[]{ccfgDog, ccfgBreed});

        return Ignition.start(cfg);
    }
}

请注意，我们为 Breed 和 Dog 缓存使用了两个单独的 CacheConfiguration。此外，为缓存设置 SQL 架构。

第 6 步

一旦所有配置和存储库都准备好使用，我们只需要在 Spring 应用程序上下文中注册配置。

package com.blu.imdg;

import com.blu.imdg.model.Breed;
import com.blu.imdg.model.Dog;
import com.blu.imdg.repositories.BreedRepository;
import com.blu.imdg.repositories.DogRepository;
import com.blu.imdg.repositories.SpringAppConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.sql.Date;
import java.util.List;

/**
 * Hello world!
 *
 */
public class App 
{
    private static AnnotationConfigApplicationContext ctx;
    private static BreedRepository breedRepository;
    private static DogRepository dogRepository;

    public static void main( String[] args )
    {
        System.out.println( "Spring Data Example!" );
        ctx = new AnnotationConfigApplicationContext();
        ctx.register(SpringAppConfig.class);
        ctx.refresh();

        breedRepository = ctx.getBean(BreedRepository.class);
        dogRepository = ctx.getBean(DogRepository.class);

        //fill the repository with data and Save
        Breed collie = new Breed();
        collie.setId(1L);
        collie.setName("collie");
        //save Breed with name collie
        breedRepository.save(1L, collie);

        System.out.println("Add one breed in the repository!");
        // Query the breed
        List<Breed> getAllBreeds = breedRepository.getAllBreedsByName("collie");

        for(Breed breed : getAllBreeds){
            System.out.println("Breed:" + breed);
        }
        //Add some dogs
        Dog dina = new Dog();
        dina.setName("dina");
        dina.setId(1L);
        dina.setBreedid(1L);
        dina.setBirthdate(new Date(System.currentTimeMillis()));
        //Save Dina
        dogRepository.save(2L,dina);
        System.out.println("Dog dina save into the cache!");
        //Query the Dog Dina
        List<Dog> dogs = dogRepository.getDogByName("dina");
        for(Dog dog : dogs){
            System.out.println("Dog:"+ dog);
        }

    }
}

上面的代码片段非常简单。首先，我们创建一个 Spring 注释上下文并注册我们的存储库。接下来，我们获取对 BreedRepository 和 DogRepository 的引用以插入一些数据。为了查询数据，我们使用基本的 CRUD 操作或方法，这些操作或方法将自动转换为 Apache Ignite SQL 查询：

List<Dog> dogs = dogRepository.getDogByName("dina");
for(Dog dog : dogs){
  System.out.println("Dog:"+ dog);
}

第 7 步

让我们构建并运行应用程序。执行以下命令。

mvn clean install
mvn exec:java -Dexec.mainClass=com.blu.imdg.App

您应该会在控制台中发现很多日志消息。

日志消息确认两个条目（dina 和 breed-collie）已被刷新到 Ignite 缓存中并从缓存中检索到狗 Dina 。让我们通过 Ignite Visor 探索缓存。

为实体创建了两个不同的缓存：Breed 和 Dog。如果我们扫描 Dog 缓存的缓存条目，我们应该在上面找到以下实体。

实体 Dina 已使用 Breed collie 的密钥保存到缓存中。

如果您想了解有关 Apache Ignite（使用 JPA、Hibernate 或 MyBatis）的更多信息，请参阅High Performance in-memory computing with Apache Ignite一书。

标签2： Java教程

地址：https://www.cundage.com/article/jcg-apache-ignite-spring-data.html