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

by Alexandre Aquiles

Overview

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.

Product Details

ISBN-13:	9788555193101
Publisher:	Casa do Código
Publication date:	08/02/2022
Sold by:	Bookwire
Format:	eBook
Pages:	444
File size:	2 MB
Language:	Portuguese

About the Author

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.

Table of Contents

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