使用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 {
    List getDogByName(String name);
    Dog getDogById (Long id);
}

在本文中，我们将介绍以下主题：

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

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

1. Java JDK 1.8
2. 点燃2.0版
3. Apache Maven版本> 3.0.3

步骤1

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

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

修改pom.xml，添加以下Maven依赖项：

    org.apache.ignite
    ignite-core
    2.0.0


    org.apache.ignite
    ignite-spring
    2.0.0


    org.apache.ignite
    ignite-spring-data
    2.0.0


    org.apache.ignite
    ignite-indexing
    2.0.0


    com.h2database
    h2
    1.4.195

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

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

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

现在，让我们通过创建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 +
                '}';
    }
}

现在，让我们为之前创建的所有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 {
    List 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 {

    List getAllBreedsByName (String name);

    @Query("SELECT id FROM Breed WHERE id = ?")
    List 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模式。

一旦准备好使用所有配置和存储库，我们只需要在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 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 dogs = dogRepository.getDogByName("dina");
        for(Dog dog : dogs){
            System.out.println("Dog:"+ dog);
        }

    }
}

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

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

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

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

您应该在控制台中找到许多日志消息。

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

为实体创建了两个不同的缓存：“品种”和“狗”。 如果我们扫描Dog缓存的缓存条目，则应在其上找到以下实体。

实体Dina已使用Breed牧羊犬的钥匙保存在缓存中。

如果要了解有关Apache Ignite的更多信息（使用JPA，Hibernate或MyBatis），请参阅《 使用Apache Ignite进行高性能内存计算 》一书。

翻译自: https://www.javacodegeeks.com/2017/07/apache-ignite-spring-data.html