Desbravando SOLID Práticas avançadas para códigos de qualidade em Java moderno

Alexandre Aquiles

*Você terá acesso às futuras atualizações do livro.

Prefácio por João Júnior

Este livro é único, essencial e prático!

Toda leitura é um diálogo entre o leitor e o autor do livro. Quando o livro é sobre um assunto técnico, além do diálogo, eu acredito que devemos fazer um debate com o autor. Para quem tem o privilégio de conhecer o Alexandre, a leitura deste livro é exatamente como um debate com ele. Não apenas respostas simplórias são dadas, mas o contexto de cada decisão, além dos contrapontos, quando necessário, são apresentados pelo autor.

Logo após aprendermos a programar, nos primeiros anos de nossa carreira, emerge a necessidade de organizar o nosso código para ser fácil de entender, ler e manter. Este livro visa ensinar formas e conceitos de como fazer isso, através de Orientação a Objetos e SOLID.

Se você é um desenvolvedor ou uma desenvolvedora sem muita experiência, você verá os fundamentos de Orientação a Objetos: encapsulamento, polimorfismo, herança e composição. Além disso, você será exposto(a) a bons e maus exemplos de uso desses conceitos. Isso será um grande diferencial na sua carreira, e é muito difícil encontrar materiais sobre esses conceitos tão bem descritos e aplicados em exemplos reais.

Por outro lado, se você é experiente, você vai aprender como usar Orientação a Objetos e diversas técnicas e conceitos para simplificar o código do seu projeto. Você vai não apenas aprender conceitos de forma isolada, mas também será guiado(a) a como tomar decisões sobre como e quando usar esses conceitos. Você também vai aprender sobre quando não deve usar muitos dos conceitos e técnicas apresentados aqui.

Embora os exemplos apresentados sejam na linguagem Java, este livro é essencial para desenvolvedores de todas as linguagens. Se você programa em Java, poderá aplicar os exemplos diretamente em seus códigos. E se você utiliza outra linguagem de programação, não será muito difícil adaptar o que aprendeu aqui.

Além de todo o conhecimento apresentado, um grande diferencial é que ele usa todos os conceitos e técnicas apresentados em uma aplicação real. Então, você vai começar com um código que já está em produção e, à medida que passar pelos capítulos, vai refatorar o código para torná-lo mais legível e extensível. Essa é uma das características que torna este livro único, essencial e prático. O autor também nos presenteia com inúmeras referências para continuarmos nossos estudos.

Então, tenha um excelente debate!

João Júnior, Tech Lead na Shopify

Sobre o livro

Este livro é a adaptação do curso "Práticas de Design e Arquitetura de Código" da Caelum, criado pelo autor em 2018 e ministrado para centenas de alunos e alunas desde então.

No decorrer do livro, vamos melhorar o código do Cotuba, uma aplicação que gera e-books nos formatos PDF e EPUB a partir de arquivos Markdown, e também adicionaremos algumas funcionalidades à aplicação.

À medida que formos refatorando e adicionando funcionalidades ao Cotuba, estudaremos assuntos avançados de Orientação a Objetos.

O capítulo 1 apresenta uma contextualização dos princípios SOLID em relação a outras técnicas.

No capítulo 2, conheceremos o código inicial do Cotuba, que será refatorado nos capítulos posteriores.

No capítulo 3, estudaremos o Single Responsibility Principle (Princípio da Responsabilidade Única), aplicando-o ao Cotuba.

No capítulo 4, abordaremos o Dependency Inversion Principle (Princípio da Inversão das Dependências) e o design pattern Factory.

No capítulo 5, é a vez de estudarmos o Open/Closed Principle (Princípio do Aberto/Fechado) e os design patterns Command e Strategy.

No capítulo 6, criaremos plugins com a Service Loader API, estudando um caso extremo do Open/Closed Principle.

No capítulo 7, corrigiremos violações do Liskov Substitution Principle (Princípio de Substituição de Liskov) no Cotuba.

No capítulo 8, vamos explorar o Interface Segregation Principle (Princípio da Segregação de Interfaces).

O capítulo 9 trata de assuntos importantes em Orientação a Objetos como imutabilidade e encapsulamento, além de implementar os design patterns Builder e Iterator.

No capítulo 10, discutiremos sobre modularização, abordando os princípios de Coesão e Acoplamento de módulos e implementando módulos Maven.

No capítulo 11, verificaremos a flexibilidade do design de código do Cotuba, utilizando-o em uma aplicação Web e ajustando alguns detalhes.

No capítulo 12, veremos como usar o Java Platform Module System (JPMS), disponível a partir do Java 9, para reforçar o encapsulamento dos módulos do Cotuba.

No capítulo 13, definiremos o que é uma Arquitetura Hexagonal e como o código refatorado do Cotuba se encaixa nesse estilo arquitetural.

Ao final de cada capítulo, haverá um QR Code de um vídeo que demonstra o passo a passo de código. Além disso, teremos um apêndice com o código inicial do Cotuba e outro com as referências bibliográficas.

Para quem é o livro

Este livro é focado em desenvolvedores e desenvolvedoras familiarizados com a linguagem Java e com os fundamentos da Orientação de Objetos, como classes, objetos, atributos, métodos, herança, polimorfismo, interfaces e que desejam estudar técnicas avançadas de design de código.

Neste livro, vamos utilizar recursos do Java 17. É recomendada a utilização de uma IDE, como IntelliJ ou Eclipse, para seguir os exemplos do livro. Além disso, utilizaremos a ferramenta Maven, na versão 3.8 ou posterior.

Nos exemplos de linha de comando, utilizaremos comandos disponíveis em um Unix como qualquer distribuição Linux ou MacOS. Para executá-los em uma máquina Windows, utilize ferramentas como WSL, Cygwin ou Git Bash. Além disso, não deixe de instalar programas leitores de PDFs e EPUBs!

Sobre o autor

Alexandre Aquiles é Engenheiro de Software desde 2005, tendo desenvolvido software para indústrias como Logística, Governo, Mineração, Seguros e Educação. Acredita que softwares devem ser desenvolvidos de forma iterativa e incremental, entregando continuamente código de valor e com qualidade. Especializado na plataforma Java, tem mais de 6500 horas como instrutor de cursos sobre Orientação a Objetos, Arquitetura de Software, Testes Automatizados e TDD, Integração de Sistemas e Microsserviços. É coautor do livro Controlando versões com Git e GitHub publicado em 2014 pela Casa do Código.

Sumário

  • 1 Para que serve Orientação a Objetos?
    • 1.1 Modelagem e dependências
    • 1.2 Os princípios SOLID
    • 1.3 Os princípios de coesão e acoplamento de módulos
  • 2 Conhecendo o Cotuba
    • 2.1 Usando o Cotuba
    • 2.2 Um pouco sobre a implementação do Cotuba
    • 2.3 Gerando um ebook
    • 2.4 O código do Cotuba
  • 3 Princípio da Responsabilidade Única (SRP): classes coesas
    • 3.1 O Princípio da Responsabilidade Única (SRP)
    • 3.2 SRP e classes coesas
    • 3.3 Responsabilidades e SRP no Cotuba
    • 3.4 Não se repita
    • 3.5 Um domain model simples
    • 3.6 MVC, entidades e casos de uso
    • 3.7 Responsabilidades em pacotes e métodos
    • 3.8 Contraponto: críticas ao SRP
    • 3.9 O que aprendemos?
  • 4 Princípio da Inversão de Dependências (DIP): dependências estáveis
    • 4.1 Acoplamento, estabilidade e volatilidade
    • 4.2 Abstrações e inversão das dependências
    • 4.3 Regras de negócio x detalhes
    • 4.4 Código de alto nível e baixo nível
    • 4.5 O Princípio da Inversão de Dependências (DIP)
    • 4.6 DIP no Cotuba
    • 4.7 Design Pattern: Factory
    • 4.8 Melhorando o nome das implementações
    • 4.9 Abstrações mais perto de quem as utiliza
    • 4.10 Uma classe para os parâmetros
    • 4.11 Contraponto: críticas ao DIP
    • 4.12 O que aprendemos?
  • 5 Princípio Aberto/Fechado (OCP): objetos flexíveis
    • 5.1 Em busca da abstração perfeita
    • 5.2 Design Pattern: Command
    • 5.3 O Princípio Aberto/Fechado (OCP)
    • 5.4 Design Pattern: Strategy
    • 5.5 Revisitando abstrações
    • 5.6 Uma Factory inteligente
    • 5.7 Das condicionais ao polimorfismo
    • 5.8 Pondo a flexibilidade do Cotuba à prova
    • 5.9 Contraponto: críticas ao OCP
    • 5.10 O que aprendemos?
  • 6 OCP potencializado: plugins
    • 6.1 Um plugin no Cotuba
    • 6.2 Aplicando temas CSS nos capítulos
    • 6.3 Ligando os pontos (de extensão) com a Service Loader API
    • 6.4 Alguns usos da Service Loader API na plataforma Java
    • 6.5 Um plugin para calcular estatísticas do ebook
    • 6.6 O que aprendemos?
  • 7 Princípio de Substituição de Liskov (LSP): herança do jeito certo
    • 7.1 Continuando a implementação das estatísticas
    • 7.2 Contando palavras
    • 7.3 Herdando inutilidades
    • 7.4 O Princípio da Substituição de Liskov (LSP)
    • 7.5 Favorecendo composição à herança
    • 7.6 Qual a necessidade de um método se não há nada para ser feito?
    • 7.7 Contraponto: críticas ao LSP
    • 7.8 O que aprendemos?
  • 8 Princípio da Segregação de Interfaces (ISP): clientes separados, interfaces separadas
    • 8.1 O Princípio da Segregação de Interfaces (ISP)
    • 8.2 Separando classes, não apenas interfaces
    • 8.3 Interfaces específicas para o cliente no Cotuba
    • 8.4 Contraponto: críticas ao ISP
    • 8.5 O que aprendemos?
  • 9 Um pouco de imutabilidade e encapsulamento
    • 9.1 Em direção à imutabilidade
    • 9.2 Um domain model imutável
    • 9.3 Design Pattern: Builder
    • 9.4 Voltando atrás na segregação de interfaces
    • 9.5 Favorecendo imutabilidade com Records
    • 9.6 Encapsulamento
    • 9.7 Design Pattern: Iterator
    • 9.8 O que aprendemos?
  • 10 Princípios de Coesão e Acoplamento de Módulos
    • 10.1 O que são módulos?
    • 10.2 Princípios de coesão de módulos
    • 10.3 Modularizando o Cotuba
    • 10.4 Módulos Maven
    • 10.5 Princípios de acoplamento de módulos
    • 10.6 Quebrando ciclos no Cotuba
    • 10.7 O que aprendemos?
  • 11 Além da linha de comando: o Cotuba Web
    • 11.1 Gerando ebooks pela Web
    • 11.2 Quando nosso design não antecipa as mudanças
    • 11.3 O que aprendemos?
  • 12 Módulos com o Java Platform Module System (JPMS)
    • 12.1 Encapsulamento de módulos e o Classpath
    • 12.2 JPMS, um sistema de módulos para o Java
    • 12.3 Módulos JPMS no Cotuba
    • 12.4 Módulos automáticos do JPMS
    • 12.5 Service Loader API com JPMS
    • 12.6 O Modulepath
    • 12.7 JPMS e o Spring Boot
    • 12.8 O que aprendemos?
  • 13 Arquitetura Hexagonal: uma arquitetura centrada no domínio
    • 13.1 Hexágonos (ou Conectores & Adaptadores)
    • 13.2 Arquitetura Hexagonal no Cotuba
    • 13.3 Arquitetura de Plugins
    • 13.4 Barreiras arquiteturais
    • 13.5 Clean Architecture
    • 13.6 Contraponto
    • 13.7 Conclusão
  • 14 Apêndice: O código inicial do Cotuba
  • 15 Apêndice: Referências

Dados do produto

Número de páginas:
444
ISBN:
978-85-5519-309-5
Data publicação:
08/2022

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter

*Você terá acesso às futuras atualizações do livro.