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.

Conteúdo

Você já aprendeu a programar e certamente já ouviu falar em Orientação a Objetos e seus conceitos como classes, objetos, métodos, interfaces, herança, polimorfismo. Mas você sabe, efetivamente, quando e como aplicar tudo isso? Ao trabalhar com programação, é clara a necessidade de organizar nosso código para que ele seja fácil de entender e manter, otimizando sua leitura e minimizando o impacto de eventuais mudanças.

Neste livro, Alexandre Aquiles mostra práticas de design e arquitetura para você organizar seu código através dos princípios SOLID. Você verá tópicos avançados da Orientação a Objetos, com bons e maus exemplos de aplicação dos conceitos, para aprender como realmente tirar o melhor proveito das técnicas e saber tomar decisões para cada contexto. Através de plugins e módulos Maven e JPMS, chegaremos a uma Arquitetura Hexagonal. Tudo isso, demonstrado em uma aplicação real e com acesso a vídeos com o passo a passo dos códigos.

Saiba o que você vai aprender

 

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

Autor

Alexandre Aquiles

Alexandre Aquiles é Engenheiro de Computação pela Unicamp. Desenvolve software há mais de 15 anos, tendo trabalhado nas áreas de logística, governo, mineração e seguros. Há mais de 8 anos, ajuda as pessoas a prosperarem através da Educação em Tecnologia. É especialista em Java e Design de código, mas se aventura por outras áreas.

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