Analista Desenvolvedor 1.0

Aqui vai algumas dicas do que você precisa para entrar bem no mercado de Analise e desenvolvimento de sistemas:

Cursos basico

Java basico (Loiane Training)
Java intermediário (Loiane Training)
Estrutura de dados (Loiane.training)

Springboot “Bota de mola”

A “bota de mola” em Java é uma expressão usada para descrever o Spring Boot. SpringBoot é um framework de código aberto criado pela equipe da Pivotal, que facilita a criação de microserviços em Java. Ele é chamado de “bota de mola” porque é projetado para ser autoconfigurável e autônomo, ou seja, ele cuida de muitas configurações e dependências automaticamente, permitindo que os desenvolvedores se concentrem na lógica do aplicativo.

Com o Spring Boot, você pode criar aplicativos Java que são prontos para serem executados com um mínimo de configuração, o que é ótimo para acelerar o desenvolvimento e a entrega de software.

H2

É um banco de dados em memória chamado H2. Ele é útil para desenvolvimento e testes, pois não requer instalação e é fácil de configurar. Você pode usá-lo como uma alternativa leve e rápida para outros bancos de dados mais robustos, como o MySQL ou PostgreSQL.

Validação do Hibernate

Hibernate Validator é a implementação de referência do Bean Validation (JSR 380), que fornece um mecanismo para garantir que as propriedades dos seus beans atendam a certos critérios. É útil para garantir que os dados recebidos pela sua aplicação estejam em um formato esperado e válido.

Exemplo Prático

Vamos considerar uma classe simples Usuario, onde queremos validar o email e a idade do usuário.

Dependências do Maven

Primeiro, adicione as dependências no seu pom.xml:

<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.1.6.Final</version>
</dependency>
<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>2.0.1.Final</version>
</dependency>

Classe `Usuario`

Vamos criar a classe Usuario com anotações de validação:

import javax.validation.constraints.Email;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

public class Usuario {
    
    @NotNull(message = "O nome não pode ser nulo")
    @Size(min = 2, max = 30, message = "O nome deve ter entre 2 e 30 caracteres")
    private String nome;
    
    @NotNull(message = "O email não pode ser nulo")
    @Email(message = "O email deve ser válido")
    private String email;
    
    @Min(value = 18, message = "A idade deve ser no mínimo 18")
    private int idade;

    // Getters e setters
}

Validação

Agora, para validar um objeto Usuario, utilizamos o Validator:

import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import javax.validation.ConstraintViolation;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Usuario usuario = new Usuario();
        usuario.setNome("Harum");
        usuario.setEmail("dev@markusharum.com.br");
        usuario.setIdade(16);
        
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();
        
        Set<ConstraintViolation<Usuario>> violations = validator.validate(usuario);
        
        if (!violations.isEmpty()) {
            for (ConstraintViolation<Usuario> violation : violations) {
                System.out.println(violation.getMessage());
            }
        } else {
            System.out.println("Tudo válido!");
        }
    }
}

Explicação

Dependências: Essas são as bibliotecas necessárias para a validação.
Anotações: Usamos anotações como @NotNull, @Size, @Email, e @Min para definir as regras de validação.
Validação: O Validator é usado para verificar se as propriedades do objeto Usuario atendem às regras definidas.

Isso deve dar uma visão clara de como aplicar validação com Hibernate em uma aplicação Java.Mas não deixe de se aprofundar

Openfeign

OpenFeign é uma ferramenta poderosa para simplificar a comunicação entre serviços RESTful em aplicações Java. Ele permite que você crie clientes HTTP declarativos de maneira muito intuitiva, apenas com anotações. Vamos explorar isso com um exemplo prático:

Dependências do Maven

Primeiro, adicione as dependências necessárias no seu pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Configuração do OpenFeign

Para habilitar o OpenFeign na sua aplicação Spring Boot, adicione a anotação @EnableFeignClients na classe principal:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

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

Interface Feign Client

Crie uma interface para definir os endpoints do serviço que você deseja consumir. Vamos supor que queremos consumir um serviço que retorna informações de usuários:

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "user-service", url = "http://localhost:8080")
public interface UserServiceClient {

    @GetMapping("/users/{id}")
    User getUserById(@PathVariable("id") Long id);
}

Modelo de Dados

Crie uma classe modelo para mapear os dados recebidos do serviço:

public class User {
    private Long id;
    private String name;
    private String email;

    // Getters e setters
}

Consumindo o Serviço Feign

Agora, você pode injetar o Feign client em qualquer classe e consumir o serviço:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @Autowired
    private UserServiceClient userServiceClient;

    @GetMapping("/fetch-user/{id}")
    public User fetchUser(@PathVariable Long id) {
        return userServiceClient.getUserById(id);
    }
}

Explicação

Dependências: Incluímos spring-cloud-starter-openfeign para habilitar o suporte ao OpenFeign.
Configuração: @EnableFeignClients na classe principal ativa o Feign.
Interface Feign Client: Definimos uma interface com anotações que indicam os endpoints do serviço.
Modelo de Dados: Classe User mapeia a estrutura dos dados retornados pelo serviço.
Consumo do Serviço: UserController injeta o cliente Feign e usa ele para obter os dados do usuário.

Isso facilita a comunicação entre serviços, tornando o código mais limpo e fácil de manter

Flyway

Flyway é uma ferramenta essencial para a migração e versionamento de banco de dados em Java. Ele permite que você gerencie e rastreie mudanças no seu esquema de banco de dados de forma automatizada e consistente.

Por que usar Flyway?

Controle de Versão: Assim como o Git controla as versões do código, o Flyway controla as versões do seu banco de dados.
Automação de Migrações: Automatiza a aplicação de scripts de migração, garantindo que todos os ambientes (desenvolvimento, testes, produção) estejam sincronizados.
Facilidade de Uso: Flyway é fácil de configurar e usar, integrando-se bem com ferramentas de build como Maven e Gradle.

Exemplo Prático

Vamos passar por um exemplo de como configurar e usar o Flyway em um projeto Java com Maven.

Dependências do Maven

Primeiro, adicione as dependências do Flyway no seu pom.xml:

<dependency>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-core</artifactId>
    <version>7.10.0</version>
</dependency>

Estrutura do Projeto

Crie uma pasta chamada db/migration no diretório src/main/resources. É aqui que você colocará seus scripts SQL de migração.

Script de Migração

Vamos criar um script SQL de exemplo chamado V1__Create_pessoa_table.sql:

CREATE TABLE pessoa(
id SERIAL PRIMARY KEY,
first_name VARCHAR(50),
last_name VARCHAR(50),
email VARCHAR(100)
);

Configuração do Flyway

Em seu arquivo application.properties (ou application.yml se você usar YAML), adicione as configurações do Flyway:

spring.datasource.url=jdbc:postgresql://localhost:5432/seu_banco_de_dados
spring.datasource.username=seu_usuario
spring.datasource.password=sua_senha

flyway.locations=classpath:db/migration

Executando Flyway

Para executar o Flyway com Maven, adicione o plugin no seu pom.xml:

<build>
    <plugins>
        <plugin>
            <groupId>org.flywaydb</groupId>
            <artifactId>flyway-maven-plugin</artifactId>
            <version>7.10.0</version>
            <configuration>
                <url>jdbc:postgresql://localhost:5432/seu_banco_de_dados</url>
                <user>seu_usuario</user>
                <password>sua_senha</password>
            </configuration>
        </plugin>
    </plugins>
</build>

Agora você pode rodar o Flyway diretamente com Maven:

mvn flyway:migrate

Explicação

Dependências: Incluímos a biblioteca core do Flyway.
Estrutura: Scripts de migração são colocados na pasta db/migration e seguem um padrão de nomenclatura (V1__, V2__, etc.).
Script: Um exemplo simples de criação de tabela.
Configuração: Conexão com o banco de dados e localização dos scripts de migração.
Execução: Usamos o plugin do Flyway para aplicar as migrações.

Conclusão

O Flyway é uma ferramenta poderosa para gerenciar mudanças no esquema do banco de dados, garantindo consistência e automação em todos os ambientes de desenvolvimento. Perfeito para desenvolvedores que buscam eficiência e precisão na gestão de bancos de dados.

Não deixe de olhar tambem: liquibase muito utilizado em grandes players do mercado.

JPA (@Onetomany,@manytoone,@OnetoOne)

Essas anotações (@OneToMany, @ManyToOne, @OneToOne) são cruciais em Java para mapear corretamente os relacionamentos entre entidades em um banco de dados relacional. Elas ajudam a estabelecer as relações de forma clara e organizada, facilitando a manipulação de dados, a integridade referencial e a performance das operações de banco de dados.

Por exemplo:

@OneToMany: Quando uma entidade A está relacionada com múltiplas entidades B. Imagine uma aplicação de blog onde um autor (entidade A) pode ter muitos posts (entidade B).
@ManyToOne: O inverso de OneToMany; usado do lado da entidade B para mostrar que muitos posts pertencem a um autor.
@OneToOne: Quando uma entidade A está relacionada com uma única entidade B. Por exemplo, um usuário pode ter um único perfil de usuário associado.

Sem esses mapeamentos, a gestão das relações entre entidades se torna confusa e propensa a erros.

Lombok

Lombok é uma biblioteca extremamente útil para desenvolvedores Java, pois reduz a quantidade de código boilerplate. Ele faz isso gerando automaticamente métodos comuns como getters, setters, construtores, toString, equals e hashCode. Vamos ver como funciona na prática.

Dependências do Maven

Primeiro, adicione a dependência Lombok ao seu pom.xml:

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.20</version>
    <scope>provided</scope>
</dependency>

Exemplo Prático

Vamos criar uma classe Pessoa sem Lombok e depois refatorá-la para usar Lombok.

Sem Lombok

public class Pessoa {
    private String nome;
    private int idade;

    public Pessoa() {}

    public Pessoa(String nome, int idade) {
        this.nome = nome;
        this.idade = idade;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public int getIdade() {
        return idade;
    }

    public void setIdade(int idade) {
        this.idade = idade;
    }

    @Override
    public String toString() {
        return "Pessoa{" +
                "nome='" + nome + '\'' +
                ", idade=" + idade +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Pessoa pessoa = (Pessoa) o;
        return idade == pessoa.idade && Objects.equals(nome, pessoa.nome);
    }

    @Override
    public int hashCode() {
        return Objects.hash(nome, idade);
    }
}

Com Lombok

Agora, vamos refatorar a classe Pessoa para usar Lombok:

import lombok.Data;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Pessoa {
    private String nome;
    private int idade;
}

Explicação

@Data: Esta anotação gera automaticamente getters, setters, toString, equals e hashCode.
@AllArgsConstructor: Gera um construtor com todos os campos da classe.
@NoArgsConstructor: Gera um construtor sem parâmetros.

Benefícios do Lombok

Redução de Código: Como você viu, com Lombok, a quantidade de código é drasticamente reduzida.
Manutenção: Menos código significa menos lugares para bugs se esconderem e menos código para manter.
Legibilidade: O código se torna mais limpo e fácil de ler.

Lombok é uma ferramenta que, quando usada corretamente, pode tornar o desenvolvimento Java muito mais eficiente.

Postgres

O curso está contido em mais de 50 aulas, em texto e vídeo, listadas abaixo, e ministradas por Fábio dos Reis. Para acompanhar o curso, basta clicar nos links das aulas, que já estão na ordem sequencial mais indicada para o aprendizado do PostgreSQL, ou simplesmente acompanhar cada lição escrita e se deleitar com este que é, sem dúvida, um dos sistemas de bancos de dados mais importantes da atualidade.

Aulas:

Mongodb

MongoDB é um banco de dados NoSQL orientado a documentos. Diferente dos bancos de dados relacionais tradicionais, como PostgreSQL ou MySQL, o MongoDB armazena dados em documentos JSON-like, o que oferece uma flexibilidade incrível.

Diferenciais do MongoDB

Flexibilidade de Schema: Com MongoDB, você não precisa definir um esquema fixo para suas coleções (equivalente a tabelas). Isso permite que você itere rapidamente sobre o design do banco de dados e ajuste suas estruturas de dados conforme necessário.
Escalabilidade Horizontal: MongoDB é projetado para escalar horizontalmente. Isso significa que você pode distribuir seus dados através de múltiplos servidores, facilitando a gestão de grandes volumes de dados e cargas de trabalho.
Consultas Flexíveis: MongoDB oferece uma linguagem de consulta rica que permite buscas complexas, incluindo filtros, projeções, junções, e agregações.
Performance: Para muitas aplicações, especialmente aquelas que lidam com grandes volumes de dados ou que requerem alta disponibilidade e performance, MongoDB pode ser mais eficiente do que bancos de dados relacionais.

Exemplo Prático

Vamos criar um exemplo básico de como usar MongoDB em uma aplicação Java usando o driver oficial do MongoDB.

Dependências do Maven

Primeiro, adicione a dependência do MongoDB no seu pom.xml:

<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver-sync</artifactId>
    <version>4.4.1</version>
</dependency>

Classe de Modelo

Vamos criar uma classe Usuario:

import org.bson.codecs.pojo.annotations.BsonProperty;
import org.bson.types.ObjectId;

public class Usuario {
    private ObjectId id;
    
    @BsonProperty("nome")
    private String nome;
    
    @BsonProperty("email")
    private String email;

    // Construtores, getters e setters
}

Conexão com MongoDB

Agora, vamos conectar ao MongoDB e realizar algumas operações básicas:

import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.result.InsertOneResult;
import org.bson.Document;

public class MongoDBExample {
    public static void main(String[] args) {
        // Conectar ao MongoDB
        MongoClient mongoClient = MongoClients.create("mongodb://localhost:27017");
        MongoDatabase database = mongoClient.getDatabase("meuBancoDeDados");
        MongoCollection<Document> collection = database.getCollection("usuarios");

        // Criar um novo documento
        Document usuario = new Document("nome", "João Silva")
                .append("email", "dev@markusharum.com.br");

        // Inserir o documento na coleção
        InsertOneResult result = collection.insertOne(usuario);
        System.out.println("Documento inserido com ID: " + result.getInsertedId());
        
        mongoClient.close();
    }
}

Explicação

Dependências: Incluímos a dependência do driver MongoDB.
Modelo: A classe Usuario mapeia os dados do usuário que serão armazenados no MongoDB.
Conexão: Criamos uma conexão com o MongoDB, selecionamos a base de dados e a coleção, e inserimos um documento.

Conclusão

O MongoDB oferece uma flexibilidade e escalabilidade que são valiosas para muitas aplicações modernas. É ideal para casos onde a estrutura dos dados pode evoluir rapidamente ou onde grandes volumes de dados precisam ser manejados eficientemente.

Docker(docker-compose,dockerfile)

Vamos arregaçar as mangas! Veremos como criar uma configuração do Docker com o Docker Compose, incluindo um serviço de mensagens (RabbitMQ), um banco de dados PostgreSQL e um servidor JBoss. Isso dará um exemplo completo, perfeito para entender tanto a teoria quanto a prática.

Dockerfile for JBoss Server

Primeiro, vamos criar um Dockerfile para um servidor JBoss:

# Use the JBoss base image
FROM jboss/wildfly:latest

# Set the maintainer label
LABEL maintainer="dev@markusharum.com.br"

# Copy your application to the deployments directory
COPY your-app.war /opt/jboss/wildfly/standalone/deployments/

# Expose the port WildFly will run on
EXPOSE 8080

# Start the WildFly server
CMD ["/opt/jboss/wildfly/bin/standalone.sh", "-b", "0.0.0.0"]

Docker Compose File

Agora, vamos criar uma docker-compose.yml para unir tudo:

version: '3.8'

services:
  postgres:
    image: postgres:13
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: example
      POSTGRES_DB: mydatabase
    volumes:
      - pgdata:/var/lib/postgresql/data

  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "5672:5672"
      - "15672:15672"

  jboss:
    build: .
    environment:
      - DB_HOST=postgres
      - DB_PORT=5432
      - DB_USER=postgres
      - DB_PASSWORD=example
      - DB_NAME=mydatabase
    depends_on:
      - postgres
      - rabbitmq
    ports:
      - "8080:8080"

volumes:
  pgdata:

Explicação

Serviço PostgreSQL: configura um banco de dados PostgreSQL com um usuário, senha e nome de banco de dados. Ele também usa um volume do Docker para persistir dados.
Serviço RabbitMQ: Um serviço RabbitMQ com o console de gerenciamento exposto na porta 15672.
Serviço JBoss: esse serviço cria o servidor JBoss a partir do Dockerfile e garante que ele seja iniciado após a ativação dos serviços PostgreSQL e RabbitMQ. Ele também passa as variáveis de ambiente necessárias para se conectar ao banco de dados.

Running the Setup

Para criar e executar esses contêineres, basta navegar até o diretório com seu docker-compose.yml e executar:

docker-compose up --build

Essa configuração fornece um exemplo robusto que combina gerenciamento de banco de dados, mensagens e serviços Web, tudo em um ambiente Dockerizado. Perfeito para obter um forte controle sobre a teoria e a prática do Docker e da orquestração de contêineres. Mergulhe!

UML

Vamos começar com um exemplo simples de um diagrama de classes para um sistema de gerenciamento de biblioteca. Vou criar uma classe Livro e uma classe Autor, mostrando o relacionamento entre elas.

Aqui está um exemplo de um diagrama de classes UML:

Agora, vamos implementar isso em Java usando JPA:

@Entity
public class Livro {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String titulo;
    private String isbn;
    
    @ManyToOne
    @JoinColumn(name = "autor_id")
    private Autor autor;
    
    // Getters e setters
}

@Entity
public class Autor {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String nome;
    private String email;
    private LocalDate dataNascimento;
    
    @OneToMany(mappedBy = "autor")
    private List<Livro> livros;
    
    // Getters e setters
}

Espero que tenham gostado do conteudo e se possivel não deixe de comentar e compartilhar.

Analista Desenvolvedor 1.0

Publicado por harum em 10 de outubro de 202410 de outubro de 2024

Cursos basico

Springboot “Bota de mola”

H2

Validação do Hibernate

Exemplo Prático

Dependências do Maven

Classe Usuario

Validação

Explicação

Openfeign

Dependências do Maven

Configuração do OpenFeign

Interface Feign Client

Modelo de Dados

Consumindo o Serviço Feign

Explicação

Flyway

Por que usar Flyway?

Exemplo Prático

Dependências do Maven

Estrutura do Projeto

Script de Migração

Configuração do Flyway

Executando Flyway

Explicação

Conclusão

JPA (@Onetomany,@manytoone,@OnetoOne)

Lombok

Dependências do Maven

Exemplo Prático

Sem Lombok

Com Lombok

Explicação

Benefícios do Lombok

Postgres

Aulas:

Mongodb

Diferenciais do MongoDB

Exemplo Prático

Dependências do Maven

Classe de Modelo

Conexão com MongoDB

Explicação

Conclusão

Docker(docker-compose,dockerfile)

Dockerfile for JBoss Server

Docker Compose File

Explicação

Running the Setup

UML

Compartilhe isso:

Curtir isso:

<< mais >>

0 comentário

Deixe uma respostaCancelar resposta

Posts relacionados

Guia Definitivo: Instalando Docker no WSL 2 sem Docker Desktop 🎯

O que pode ser registrado como marca no INPI

MultiCloud, DevOps & IA – Dica 5 – MultiCloud (GCP & Azure)

Classe `Usuario`