apache ignite_Kubernetes集群上的Apache Ignite和Spring第1部分：Spring Boot应用程序

我就是我 2023-02-25 03:52 15阅读 0赞

apache ignite

在之前的一系列博客中，我们在Kubernetes集群上启动了一个Ignite集群。  
在本教程中，我们将使用先前在Spring Boot Application上创建的Ignite集群。

让我们使用Spring Boot创建我们的项目。 Spring Boot应用程序将连接到Ignite集群。

让我们添加依赖项。

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.2.5.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.gkatzioura</groupId>
        <artifactId>job-api-ignite</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>job-api-ignite</name>
        <description>Demo project for Spring Boot</description>
     
        <properties>
            <java.version>1.8</java.version>
        </properties>
     
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-cache</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.apache.ignite</groupId>
                <artifactId>ignite-kubernetes</artifactId>
                <version>2.7.6</version>
            </dependency>
            <dependency>
                <groupId>org.apache.ignite</groupId>
                <artifactId>ignite-spring</artifactId>
                <version>2.7.6</version>
                <exclusions>
                    <exclusion>
                        <groupId>org.apache.ignite</groupId>
                        <artifactId>ignite-indexing</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.12</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>
     
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
     
    </project>

与[之前的][Link 1]教程一样，我们将使用GitHub的Job api。

第一步是添加反序列化的作业模型。

package com.gkatzioura.jobapi.model;  import java.io.Serializable;  import lombok.Data;  @Data  public class Job implements Serializable { 
         private String id; 
         private String type; 
         private String url; 
         private String createdAt; 
         private String company; 
         private String companyUrl; 
         private String location; 
         private String title; 
         private String description;  }

我们需要一个乔布斯仓库。 注意该类需要可序列化。 Ignite将数据缓存在堆外。

package com.gkatzioura.jobapi.repository;  import java.util.ArrayList;  import java.util.List;  import com.gkatzioura.jobapi.model.Job;  import lombok.Data;  import org.apache.ignite.Ignite;  import org.springframework.cache.annotation.Cacheable;  import org.springframework.stereotype.Repository;  import org.springframework.web.client.RestTemplate;  @Repository  public class GitHubJobRepository { 
         private static final String JOB_API_CONSTANST = " https://jobs.github.com/positions.json?page= {page}" ; 
         public static final String GITHUBJOB_CACHE = "githubjob" ; 
         private final RestTemplate restTemplate; 
         private final Ignite ignite; 
         GitHubJobRepository(Ignite ignite) { 
             this .restTemplate = new RestTemplate(); 
             this .ignite = ignite; 
         } 
         @Cacheable (value = GITHUBJOB_CACHE) 
         public List<Job> getJob( int page) { 
             return restTemplate.getForObject(JOB_API_CONSTANST,JobList. class ,page); 
         } 
         public List<Job> fetchFromIgnite( int page) { 
             for (String cache: ignite.cacheNames()) { 
                 if (cache.equals(GITHUBJOB_CACHE)) { 
                     return (List<Job>) ignite.getOrCreateCache(cache).get( 1 ); 
                 } 
             } 
             return new ArrayList<>(); 
         } 
         @Data 
         private static class JobList extends ArrayList<Job> { 
         }  }

JobList类存在的主要原因是为了方便解组。  
如您所见，存储库的注释为@Cacheable。 这意味着我们的请求将被缓存。 就本示例而言，fetchFromIgnite方法是一种测试方法。 我们将使用它直接访问ignite缓存的数据。

我们还将添加控制器。

package com.gkatzioura.jobapi.controller;  import java.util.List;  import com.gkatzioura.jobapi.model.Job;  import com.gkatzioura.jobapi.repository.GitHubJobRepository;  import org.springframework.web.bind.annotation.GetMapping;  import org.springframework.web.bind.annotation.PathVariable;  import org.springframework.web.bind.annotation.RequestMapping;  import org.springframework.web.bind.annotation.RestController;  @RestController  @RequestMapping ( "/jobs" )  public class JobsController { 
         private final GitHubJobRepository gitHubJobRepository; 
         JobsController(GitHubJobRepository gitHubJobRepository) { 
             this .gitHubJobRepository = gitHubJobRepository; 
         } 
         @GetMapping ( "/github/{page}" ) 
         public List<Job> gitHub( @PathVariable ( "page" ) int page) { 
             return this .gitHubJobRepository.getJob(page); 
         } 
         @GetMapping ( "/github/ignite/{page}" ) 
         public List<Job> gitHubIgnite( @PathVariable ( "page" ) int page) { 
             return this .gitHubJobRepository.fetchFromIgnite(page); 
         }  }

控制器上有两种方法，一种是照常获取数据并将其缓存在后台，另一种是我们将用于测试的方法。

现在是时候配置使用Kubernetes集群上的节点的Ignite客户端了。

package com.gkatzioura.jobapi.config;  import lombok.extern.slf4j.Slf4j;  import org.apache.ignite.Ignite;  import org.apache.ignite.Ignition;  import org.apache.ignite.cache.spring.SpringCacheManager;  import org.apache.ignite.configuration.IgniteConfiguration;  import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi;  import org.apache.ignite.spi.discovery.tcp.ipfinder.kubernetes.TcpDiscoveryKubernetesIpFinder;  import org.springframework.cache.annotation.EnableCaching;  import org.springframework.context.annotation.Bean;  import org.springframework.context.annotation.Configuration;  @Configuration  @EnableCaching  @Slf4j  public class SpringCacheConfiguration { 
         @Bean 
         public Ignite igniteInstance() { 
             log.info( "Creating ignite instance" ); 
             TcpDiscoveryKubernetesIpFinder tcpDiscoveryKubernetesIpFinder = new TcpDiscoveryKubernetesIpFinder(); 
             tcpDiscoveryKubernetesIpFinder.setNamespace( "default" ); 
             tcpDiscoveryKubernetesIpFinder.setServiceName( "job-cache" ); 
             TcpDiscoverySpi tcpDiscoverySpi = new TcpDiscoverySpi(); 
             tcpDiscoverySpi.setIpFinder(tcpDiscoveryKubernetesIpFinder); 
             IgniteConfiguration igniteConfiguration = new IgniteConfiguration(); 
             igniteConfiguration.setDiscoverySpi(tcpDiscoverySpi); 
             igniteConfiguration.setClientMode( false ); 
             return Ignition.start(igniteConfiguration); 
         } 
         @Bean 
         public SpringCacheManager cacheManager(Ignite ignite) { 
             SpringCacheManager springCacheManager = new SpringCacheManager(); 
             springCacheManager.setIgniteInstanceName(ignite.name()); 
             return springCacheManager; 
         }  }

我们创建了缓存。 它应使用Kubernetes TCP发现模式。

下一步是添加我们的Main类。

package com.gkatzioura.jobapi;  import org.springframework.boot.SpringApplication;  import org.springframework.boot.autoconfigure.SpringBootApplication;  import org.springframework.cache.annotation.EnableCaching;  @SpringBootApplication  @EnableCaching  public class IgniteKubeClusterApplication { 
         public static void main(String[] args) { 
             SpringApplication.run(IgniteKubeClusterApplication. class , args); 
         }  }

下一个[博客][Link 2]将专注于将解决方案交付给kubernetes。

> 翻译自: [https://www.javacodegeeks.com/2020/04/apache-ignite-and-spring-on-your-kubernetes-cluster-part-1-spring-boot-application.html][https_www.javacodegeeks.com_2020_04_apache-ignite-and-spring-on-your-kubernetes-cluster-part-1-spring-boot-application.html]

apache ignite

[Link 1]: https://egkatzioura.com/2018/10/29/behavioural-design-patterns-iterator/
[Link 2]: https://egkatzioura.com/2020/04/09/apache-ignite-and-spring-on-your-kubernetes-cluster-part-2-kubernetes-deployment/
[https_www.javacodegeeks.com_2020_04_apache-ignite-and-spring-on-your-kubernetes-cluster-part-1-spring-boot-application.html]: https://www.javacodegeeks.com/2020/04/apache-ignite-and-spring-on-your-kubernetes-cluster-part-1-spring-boot-application.html