Introdução ao Spring Data Geode

1. Visão geral

Apache Geode fornece soluções de gerenciamento de dados por meio de uma arquitetura de nuvem distribuída. Seria ideal utilizar as APIsSpring Data para o acesso aos dados através do servidor Apache Geode.

Neste tutorial, exploraremosSpring Data Geode para a configuração e desenvolvimento de um aplicativo cliente Apache Geode Java.

2. Geode de dados do Spring

A biblioteca Spring Data Geode permite que um aplicativo Java configure um servidor Apache Geode por meio de XML e anotações. Ao mesmo tempo, a biblioteca também é útil para criar um aplicativo cliente-servidor de cache do Apache Geode.

A biblioteca Spring Data Geode é semelhante aSpring Data Gemfire. Além desubtle differences, o último fornece integração comPivotal Gemfire, que é uma versão comercial do Apache Geode.

Ao longo do caminho, exploraremos algumas anotações do Spring Data Geode para configurar um aplicativo Java em um cliente de cache do Apache Geode.

3. Dependência do Maven

Vamos adicionar a última dependênciaspring-geode-starter ao nossopom.xml:


    org.springframework.geode
    spring-geode-starter
    1.1.1.RELEASE

4. @ClientCacheApplication do Apache Geode com Spring Boot

Primeiro, vamos criar um Spring BootClientCacheApp usando@SpringBootApplication:

@SpringBootApplication
public class ClientCacheApp {
    public static void main(String[] args) {
        SpringApplication.run(ClientCacheApp.class, args);
    }
}

Em seguida, para transformar a classeClientCacheApp no cliente de cache Apache Geode, adicionaremos o Spring Data Geode fornecido@ClientCacheApplication:

@ClientCacheApplication
// existing annotations
public class ClientCacheApp {
    // ...
}

É isso aí! O aplicativo cliente de cache está pronto para ser executado.

No entanto, antes de iniciar nosso aplicativo, precisamos iniciar o servidor Apache Geode.

5. Iniciar um servidor Apache Geode

Supondo que o Apache Geode e a interface de linha de comandogfsh sejamalready set up, podemos iniciar um localizador chamadobasicLocatore um servidor chamadobasicServer.

Para fazer isso, vamos executar os seguintes comandos na CLIgfsh:

gfsh>start locator --name="basicLocator"

gfsh>start server --name="basicServer"

Quando o servidor começar a funcionar, podemos listar todos os membros:

gfsh>list members

A saída CLI degfsh deve listar o localizador e o servidor:

    Name     | Id
------------ | ------------------------------------------------------------------
basicLocator | 10.25.3.192(basicLocator:25461:locator):1024 [Coordinator]
basicServer  | 10.25.3.192(basicServer:25546):1025

Voila! Estamos prontos para executar nosso aplicativo cliente de cache usando o comando Maven:

mvn spring-boot:run

6. Configuração

Vamos configurar nosso aplicativo cliente de cache para acessar dados por meio do servidor Apache Geode.

6.1. Região

Primeiro, vamos criar uma entidade chamadaAuthor e, em seguida, defini-la como um Apache GeodeRegion. ARegion é semelhante a uma tabela no RDBMS:

@Region("Authors")
public class Author {
    @Id
    private Long id;

    private String firstName;
    private String lastName;
    private int age;
}

Vamos revisar as anotações do Spring Data Geode declaradas na entidadeAuthor.

Para começar,@Region criará a regiãoAuthors no servidor Apache Geode para persistir o objetoAuthor.

Então,@Id marcará a propriedade como uma chave primária.

6.2. Entidade

Podemos habilitar a entidadeAuthor adicionando@EnableEntityDefinedRegions.

Além disso, adicionaremos@EnableClusterConfiguration para permitir que o aplicativo crie as regiões no servidor Apache Geode:

@EnableEntityDefinedRegions(basePackageClasses = Author.class)
@EnableClusterConfiguration
// existing annotations
public class ClientCacheApp {
    // ...
}

Portanto, reiniciar o aplicativo criará as regiões automaticamente:

gfsh>list regions

List of regions
---------------
Authors

6.3. Repositório

A seguir, adicionaremos operações CRUD na entidadeAuthor.

Para fazer isso, vamos criar um repositório chamadoAuthorRepository, que estendeCrudRepository do Spring Data:

public interface AuthorRepository extends CrudRepository {
}

Então, vamos habilitarAuthorRepository adicionando@EnableGemfireRepositories:

@EnableGemfireRepositories(basePackageClasses = AuthorRepository.class)
// existing annotations
public class ClientCacheApp {
    // ...
}

Agora, estamos prontos para realizar operações CRUD na entidadeAuthor usando métodos comosaveefindById fornecidos porCrudRepository.

6.4. Índices

O Spring Data Geode fornece uma maneira fácil de criar e ativar os índices no servidor Apache Geode.

Primeiro, vamos adicionar@EnableIndexing à classeClientCacheApp:

@EnableIndexing
// existing annotations
public class ClientCacheApp {
    // ...
}

Então, vamos adicionar@Indexed a uma propriedade na classeAuthor:

public class Author {
    @Id
    private Long id;

    @Indexed
    private int age;

    // existing data members
}

Aqui, Spring Data Geode implementará automaticamente os índices com base nas anotações definidas na entidadeAuthor.

Portanto,@Id implementará o índice de chave primária paraid. Da mesma forma,@Indexed implementará o índice hash paraage.

Agora, vamos reiniciar o aplicativo e confirmar os índices criados no servidor Apache Geode:

gfsh> list indexes

Member Name | Region Path |       Name        | Type  | Indexed Expression | From Clause | Valid Index
----------- | ----------- | ----------------- | ----- | ------------------ | ----------- | -----------
basicServer | /Authors    | AuthorsAgeKeyIdx  | RANGE | age                | /Authors    | true
basicServer | /Authors    | AuthorsIdHashIdx  | RANGE | id                 | /Authors    | true

Da mesma forma, podemos usar@LuceneIndexed para criar um índice Apache Geode Lucene para as propriedades digitadas emString.

6.5. Consulta Contínua

A consulta contínua permite que o aplicativo receba notificações automáticas quando os dados forem alterados no servidor. Ele corresponde à consulta e depende do modelo de assinatura.

Para adicionar o recurso, vamos criar oAuthorServicee adicionar@ContinuousQuery com a consulta correspondente:

@Service
public class AuthorService {
    @ContinuousQuery(query = "SELECT * FROM /Authors a WHERE a.id = 1")
    public void process(CqEvent event) {
        System.out.println("Author #" + event.getKey() + " updated to " + event.getNewValue());
    }
}

Para usar as consultas contínuas, vamos habilitar assinaturas de servidor para cliente:

@ClientCacheApplication(subscriptionEnabled = true)
// existing annotations
public class ClientCacheApp {
    // ...
}

Portanto, nosso aplicativo receberá notificação automática no métodoprocess, sempre que modificarmos um objetoAuthor comid igual a 1.

7. Anotações adicionais

Vamos explorar algumas anotações úteis adicionalmente disponíveis na biblioteca Spring Data Geode.

7.1. @PeerCacheApplication

Até agora, examinamos um aplicativo Spring Boot como um cliente de cache Apache Geode. Às vezes, podemos exigir que nosso aplicativo seja um aplicativo de cache do Apache Geode.

Então, devemos anotar a classe principal com@PeerCacheApplication no lugar de@CacheClientApplication.

Além disso,@PeerCacheApplication criará automaticamente uma instância de cache de peer integrado para se conectar.

7.2. @CacheServerApplication

Da mesma forma, para ter nosso aplicativo Spring Boot como um membro de mesmo nível e um servidor, podemos anotar a classe principal com@CacheServerApplication.

7.3. @EnableHttpService

Podemos habilitar o servidor HTTP embutido do Apache Geode para@PeerCacheApplicatione@CacheServerApplication.

Para fazer isso, precisamos anotar a classe principal com@EnableHttpService. Por padrão, o serviço HTTP inicia na porta 7070.

7.4. @EnableLogging

Podemos habilitar o registro simplesmente adicionando@EnableLogging à classe principal. Ao mesmo tempo, podemos usar os atributoslogLevelelogFile para definir as propriedades correspondentes.

7.5. @EnablePdx

Além disso, podemos habilitar a técnica de serialização PDX do Apache Geode para todos os nossos domínios, simplesmente adicionando@EnablePdx à classe principal.

7.6. @EnableSsl e@EnableSecurity

Podemos usar@EnableSsl para ligar o TCP / IP Socket SSL do Apache Geode. Da mesma forma,@EnableSecurity pode ser usado para habilitar a segurança do Apache Geode para autenticação e autorização.

8. Conclusão

Neste tutorial, exploramos o Spring Data para Apache Geode.

Para começar, criamos um aplicativo Spring Boot para servir como o aplicativo cliente de cache Apache Geode.

Ao mesmo tempo, examinamos algumas anotações úteis fornecidas pelo Spring Data Geode para configurar e habilitar os recursos do Apache Geode.

Por último, exploramos algumas anotações adicionais como @PeerCacheApplicatione@CacheServerApplication para alterar o aplicativo para um par ou servidor na configuração de cluster.

Como de costume, todas as implementações de código estão disponíveisover on GitHub.

TOC

Introdução ao Spring Data Geode