Software Architecture with Spring 5.0: Design and architect highly scalable, robust, and high-performance Java applications

✍ Scribed by Rene Enriquez, Alberto Salazar

• Publisher: Packt Publishing
• Year: 2018
• Tongue: English
• Leaves: 362
• Category: Library

✦ Synopsis

Discover how different software architectural models can help you solve problems, and learn best practices for the software development cycle

Key Features

• Learn concepts related to software architecture and embrace them using the latest features of Spring 5
• Discover architectural models and learn when to apply them
• Gain knowledge of architectural principles and how they can be used to provide accountability and rationale for architectural decisions

Book Description

Spring 5 and its ecosystem can be used to build robust architectures effectively. Software architecture is the underlying piece that helps us accomplish our business goals whilst supporting the features that a product demands. This book explains in detail how to choose the right architecture and apply best practices during your software development cycle to avoid technical debt and support every business requirement. Choosing the right architecture model to support your business requirements is one of the key decisions you need to take when a new product is being created from scratch or is being refactored to support new business demands. This book gives you insights into the most common architectural models and guides you when and where they can be used. During this journey, you’ll see cutting-edge technologies surrounding the Spring products, and understand how to use agile techniques such as DevOps and continuous delivery to take your software to production effectively. By the end of this book, you’ll not only know the ins and outs of Spring, but also be able to make critical design decisions that surpass your clients’ expectations.

What you will learn

• Understand the key principles of software architecture
• Uncover the most common architectural models available
• Analyze scenarios where an architecture model should be used
• Implement agile techniques to take your software to production
• Secure the products you are working on
• Master tricks that will help you build high-performant applications
• Use cutting-edge technologies to build products

Who this book is for

If you’re an experienced Spring developer aspiring to become an architect of enterprise-grade applications, this book is for you. It’s also ideal for software architects who want to leverage Spring to create effective application blueprints.

Table of Contents

1. Software Architecture Today
2. Software Architecture Dimensions
3. Spring Projects
4. Client-Server Architectures
5. MVC Architectures
6. Reactive Event-Driven Architectures
7. Pipe-and-Filter Architectures
8. Microservices Architectures
9. Serverless Architectures
10. Containerizing your Applications
11. DevOps and Release Management
12. Monitoring
13. Security
14. High Performance

✦ Table of Contents

Cover
Title Page
Copyright and Credits
Packt Upsell
Contributors
Table of Contents
Preface
Chapter 1: Software Architecture Today
Defining software architecture
I know my land
I want to stay ahead
Predicting the future
Architecture and architects
Software architecture principles
Components
Low coupling
High cohesion
SOLID principles
The single responsibility principle (SRP)
The Open–Closed Principle (OCP)
The Liskov substitution principle 
The interface segregation principle (ISP)
The dependency inversion (DI) principle
Conway's law
Choosing the right technology for you
New trends 
Summary
Chapter 2: Software Architecture Dimensions
Dimensions
The business dimension
Managing user requirements
Identifying and tracking business metrics
The data dimension
The technical dimension
The operations dimension
How to deploy an application
How interaction occurs among your components
Dealing with infrastructure
Understanding the infrastructure
Versioning
Testing
Cloud versus on-premise
Deploying your application
The C4 model
Context diagram
Container diagram
Components diagram
Class diagram
Summary
Chapter 3: Spring Projects
Why Spring appeared
Spring projects
Spring Initializr
Spring Boot in a Nutshell
Servlet container integration
Autoconfiguration
Dependency management
mvnw and mvnw.cmd
pom.xml
DemoApplication.java
The application.properties file
DemoApplicationTests.java
Avoiding redeployment with developer tools
Spring Data
Supporting EIPs with Spring Integration
Spring Batch
The read step
The process step
The write step
Securing applications with Spring Security
Embracing (Spring) HATEOAS
Spring Cloud and the microservices world
Configuration server
Service registry
Edge services
Microproxy
API gateway
Circuit breaker
Reactive and Spring
Publisher
Subscriber
Subscription
Processor
Project reactor
Mono
Flux
Back pressure
Reactive Spring Data
Reactive REST services
Summary
Chapter 4: Client-Server Architectures
Understanding client-server architectures
Server
Scaling 
Request
Client
Network
Where to apply client-server architectures
Implementing client-server architectures with Spring
The server
SOAP web services
RESTful web services
CORBA
Sockets
AMQP
Implementing the server
Banking-domain
Banking-api
Boundaries
Domain
Persistence
Service
Monitoring the server
Testing
Banking-client
Authentication endpoint client
Account balance endpoint client
The clients
JavaFX client
Android client
Thin client
Summary
Chapter 5: Model-View-Controller Architectures
MVC
The Model (M)
The View (V)
The Controller (C)
Benefits of using MVC 
Common pitfalls
Implementing applications using MVC
Spring MVC
Testing
Test coverage
UI frameworks
Thymeleaf
Securing an MVC application
Basic authentication
Implementing basic authentication
Summary
Chapter 6: Event-Driven Architectures
Underlying concepts and key aspects
Command
Event
Patterns of event-driven architectures
Event notification
Event-carried state transfer
Improving application performance
Reducing the load on the source application
Increasing the availability of the system
Event sourcing
CQRS
Complex domain models
Distinct paths to query and persist information
Independent scaling
Summary
Chapter 7: Pipe-and-Filter Architectures
Introducing Pipe-and-Filter concepts
Filters
Pipes
Boarding Pipe-and-Filter architectures
Use cases for Pipe-and-Filter architecture
Spring Batch
Implementing pipes with Spring Batch
Summary
Chapter 8: Microservices
Principles of microservices
Size
Autonomous
Working well together
Advantages
Alignment to the single responsibility principle
Continuous releases
Independent scalability
Increased adoption of new technologies
Drawbacks
Too many options
Slow at the beginning
Monitoring
Transactions and eventual consistency
Modeling microservices
Speeding up
Accelerating the development process
Embracing tests
Going to production
Implementing microservices
Dynamic configuration
Implementing a configuration server
Implementing a configuration client
Service discovery and registration
Introducing Eureka
Implementing a Netflix Eureka service registry
Implementing a service registry client
Netflix Ribbon
Edge services
Introducing Zuul
CAP theorem
Consistency
High availability
Partition tolerance
Circuit breaker
Hystrix
Summary
Chapter 9: Serverless Architectures
An introduction to serverless architecture
Infrastructure and file storage
Benefits and pitfalls
Backend as a service
Function as a service
Concerns about serverless architectures
Vendor lock-in
Security
Framework support
Troubleshooting
Examples and common use cases
Adopting serverless architectures for SPA 
Implementing FaaS with Spring Cloud Functions
Functions with Spring
Coding the example
Adapters
AWS Lambda adapter
Azure adapter
Summary
Chapter 10: Containerizing Your Applications
Containers
Basic concepts
Containers and images
Basic commands
Running containers
Working with containers
Working with images
Building your own images
FROM command
MAINTAINER command
RUN command
ENV command
EXPOSE command
CMD command
Containerizing applications
Docker Gradle plugin
Registries
Publishing images
Provisioning multiple-container environments
Docker Compose
Linking containers
links
depends_on
Container orchestration with Kubernetes
Pod
Labels
Replication controllers
Services
Summary
Chapter 11: DevOps and Release Management
Silos
How to break silos
DevOps culture
Motivations
DevOps adoption
Embracing automation
Infrastructure as code
Spring application and DevOps practices
Supporting different environments
Selecting profiles
Vagrant
Working with Vagrant
Release management
pipelines
Continuous integration
Continuous delivery and continuous deployment
Automating pipelines
Jenkins
Summary
Chapter 12: Monitoring
Monitoring
Monitoring Spring applications
Application Performance Management (APM) tools
New Relic
Summary
Chapter 13: Security
Why security is important as a part of an application's architecture
Key security recommendations
Authentication and authorization
Cryptography
Data input validation
Sensitive data
Social engineering
OWASP Top 10
Penetration testing
Authentication and authorization as a service
Summary
Chapter 14: High Performance
Why performance matters
Scalability
Horizontal scalability
Vertical scalability
High availability
Performance
The key recommendation to avoid performance issues
Identifying bottlenecks
Profiling applications 
Visual VM
SQL query optimizations
A load test example
Summary
Other Books You May Enjoy
Index