Introdução

Neste tutorial, abordaremos a criação de um simulador de processos de negócios utilizando o framework Camunda BPM, integrado a uma aplicação Spring Boot e uma interface em React. O Camunda BPM é uma plataforma poderosa que permite a modelagem, execução e monitoramento de processos de negócios utilizando BPMN, enquanto o Spring Boot fornecerá a estrutura para nossa aplicação de backend. Usaremos o React para construir uma interface de usuário reativa e intuitiva que se comunicará com nossa API RESTful. Este guia é ideal para desenvolvedores interessados em processos de negócios e automação, proporcionando uma visão prática e abrangente sobre como integrar essas tecnologias de forma eficiente.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Verifique se você possui o JDK e o Maven instalados em sua máquina para iniciar o projeto. Você pode instalar o Camunda BPM Modeler para modelar nossos processos. Use os comandos `java -version` e `mvn -version` para verificar as versões instaladas.

    commands
    # Verificando as versões instaladas
    java -version
    mvn -version

  2. Criação do Projeto Spring Boot

    Utilize o Spring Initializr para gerar um novo projeto Spring Boot. Selecione as dependências ‘Spring Web’, ‘Spring Data JPA’, ‘Camunda BPM Starter’ e ‘H2 Database’. Download o projeto e descompacte-o.

    pom.xml
    <?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>
  <groupId>com.example</groupId>
  <artifactId>business-process-simulator</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>business-process-simulator</name>
  <description>Simulador de Processos de Negócios com Camunda</description>
  <properties>
    <java.version>11</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>org.camunda.bpm.springboot</groupId>
      <artifactId>camunda-bpm-spring-boot-starter</artifactId>
      <version>7.15.0</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

  3. Configuração do Banco de Dados H2

    Edite o arquivo `application.properties` para definir as configurações do banco de dados H2 para ajudar no armazenamento temporário de dados durante os processos de simulação.

    application.properties
    spring.h2.console.enabled=true
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update

  4. Modelagem do Processo de Negócio com Camunda

    Utilize o Camunda BPM Modeler para criar um modelo BPMN que represente o processo de negócios que você deseja simular. Exporte o modelo em formato .bpmn e coloque na pasta `src/main/resources/` do seu projeto.

    bpmn_file
    process.bpmn

  5. Criação da Classe do Cliente para Processo

    Implemente uma classe de serviço para interagir com o processo de negócios, iniciando instâncias do processo definido no BPMN.

    ProcessService.java
    package com.example.businessprocesssimulator.service;

import org.camunda.bpm.engine.RuntimeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ProcessService {

    @Autowired
    private RuntimeService runtimeService;

    public void startProcess() {
        runtimeService.startProcessInstanceByKey("processKey"); // Substitua processKey pelo ID do seu processo no BPMN
    }
}

  6. Implementação do Controlador para Iniciar o Processo

    Crie um controlador REST que permita ao cliente iniciar o processo através de um endpoint.

    ProcessController.java
    package com.example.businessprocesssimulator.controller;

import com.example.businessprocesssimulator.service.ProcessService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/process")
public class ProcessController {

    @Autowired
    private ProcessService processService;

    @PostMapping("/start")
    @ResponseStatus(HttpStatus.CREATED)
    public void startProcess() {
        processService.startProcess();
    }
}

  7. Execução Controller e Testes Unitários

    Implemente testes unitários para o controlador e o serviço usando JUnit e Mockito. Certifique-se de que os processos são iniciados e o comportamento é conforme esperado.

    ProcessServiceTest.java
    package com.example.businessprocesssimulator.service;

import static org.mockito.Mockito.*;
import org.camunda.bpm.engine.RuntimeService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

public class ProcessServiceTest {

    @InjectMocks
    private ProcessService processService;

    @Mock
    private RuntimeService runtimeService;

    @BeforeEach
    public void init() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void testStartProcess() {
        processService.startProcess();
        verify(runtimeService, times(1)).startProcessInstanceByKey("processKey");
    }
}

  8. Executando a Aplicação e Testes

    Compile e execute a aplicação com Maven. Utilize ferramentas como Postman para verificar se o endpoint de iniciar o processo está funcionando corretamente.

    commands
    # Compilar e executar a aplicação
    mvn spring-boot:run
    # Executar os testes unitários
    mvn test

    curl_examples
    # Iniciar um novo processo
    curl -X POST http://localhost:8080/api/process/start

Conclusão

Neste tutorial, você aprendeu a configurar um simulador de processos de negócios usando Camunda BPM com Spring Boot, incluindo a modelagem em BPMN e integração de componentes. Você descobriu a importância de cada parte do processo, desde a configuração do ambiente até a construção de APIs RESTful e a aplicação de testes. A compreensão e o domínio dessa abordagem ajudarão a expandir suas habilidades em automação de processos e desenvolvimento de software, capacitando você a criar soluções mais complexas para projetos futuros.

Hashtags

#Camunda #BPMN #SpringBoot #React #DesenvolvimentoDeSoftware #SimulaçãoDeProcessos