Developing Java Applications with Spring and Spring Boot

Book Image

Developing Java Applications with Spring and Spring Boot

By : Claudio Eduardo de Oliveira, Greg L. Turnquist, Alex Antonov

Book Image

Developing Java Applications with Spring and Spring Boot

By: Claudio Eduardo de Oliveira, Greg L. Turnquist, Alex Antonov

Overview of this book

Spring Framework has become the most popular framework for Java development. It not only simplifies software development but also improves developer productivity. This book covers effective ways to develop robust applications in Java using Spring. The course is up made of three modules, each one having a take-away relating to building end-to-end java applications. The first module takes the approach of learning Spring frameworks by building applications.You will learn to build APIs and integrate them with popular fraemworks suh as AngularJS, Spring WebFlux, and Spring Data. You will also learn to build microservices using Spring's support for Kotlin. You will learn about the Reactive paradigm in the Spring architecture using Project Reactor. In the second module, after getting hands-on with Spring, you will learn about the most popular tool in the Spring ecosystem-Spring Boot. You will learn to build applications with Spring Boot, bundle them, and deploy them on the cloud. After learning to build applications with Spring Boot, you will be able to use various tests that are an important part of application development. We also cover the important developer tools such as AMQP messaging, websockets, security, and more. This will give you a good functional understanding of scalable development in the Spring ecosystem with Spring Boot. In the third and final module, you will tackle the most important challenges in Java application development with Spring Boot using practical recipes. Including recipes for testing, deployment, monitoring, and securing your applications. This module will also address the functional and technical requirements for building enterprise applications. By the end of the course you will be comfortable with using Spring and Spring Boot to develop Java applications and will have mastered the intricacies of production-grade applications.

Title Page - Courses

Title Page - Courses

Copyright and Credits - Courses

Copyright and Credits - Courses

Packt Upsell - Courses

Packt Upsell - Courses

Preface

Free Chapter

Journey to the Spring World

Journey to the Spring World

Spring modularity

Setting up our development environment

Starting in the Spring World – the CMS Application

Starting in the Spring World – the CMS Application

Creating the CMS application structure

Running the application

Creating the REST resources

Adding service layer

Integrate with AngularJS

Persistence with Spring Data and Reactive Fashion

Persistence with Spring Data and Reactive Fashion

Learning the basics of Docker

Spring Data project

Creating the final data access layer

Creating the Docker image for CMS

Putting in Reactive fashion

Kotlin Basics and Spring Data Redis

Kotlin Basics and Spring Data Redis

Learning Kotlin basics

Creating the project

Running the Redis instance

Understanding Redis

Spring Data Reactive Redis

Creating a Twitter application

Reactive Web Clients

Reactive Web Clients

Creating the Twitter Gathering project

Starting the RabbitMQ server with Docker

Spring Messaging AMQP

Enabling Twitter in our application

Spring reactive web clients

Changing the Tracked Hashtag Service

Testing the microservice's integrations

Spring Actuator

Playing with Server-Sent Events

Playing with Server-Sent Events

Creating the Tweet Dispatcher project

Server-Sent Events

Reactor RabbitMQ

Filtering streams

Dockerizing the whole solution

Running the containerized solution

The docker-compose tool

Airline Ticket System

Airline Ticket System

The Airline Ticket System

Spring Cloud Config Server

Spring Cloud service discovery

Spring Cloud Zipkin server and Sleuth

Spring Cloud Gateway

Putting the infrastructure on Docker

Circuit Breakers and Security

Circuit Breakers and Security

Understanding the service discovery power

Flights microservice

When the services fail, hello Hystrix

Spring Boot Admin

Spring Cloud Zuul

Putting It All Together

Putting It All Together

The airline Bookings microservice

The airline Payments microservice

Learning about the Turbine server

Hystrix Dashboard

Creating the Mail microservice

Creating the Authentication microservice

Monitoring the microservices

Dockerizing the microservices

Running the system

Quick Start with Java

Quick Start with Java

Getting started

Spring Boot starters

Running a Spring Boot application

Delving into Spring Boot's property support

Bundling up the application as a runnable JAR file

Deploying to Cloud Foundry

Adding production-ready support

Reactive Web with Spring Boot

Reactive Web with Spring Boot

Creating a reactive web application with Spring Initializr

Learning the tenets of reactive programming

Introducing Reactor types

Switching from Embedded Netty to Apache Tomcat

Comparing reactive Spring WebFlux against classic Spring MVC

Showing some Mono/Flux-based endpoints

Creating a reactive ImageService

Creating a reactive file controller

Why use reactive programming?

Interacting with a Thymeleaf template

Illustrating how going from async to sync can be easy, but the opposite is not

Reactive Data Access with Spring Boot

Reactive Data Access with Spring Boot

Getting underway with a reactive data store

Solving a problem

Creating a reactive repository

Pulling data through a Mono/Flux and chain of operations

Creating custom finders

Querying by example

Querying with MongoOperations

Logging reactive operations

Testing with Spring Boot

Testing with Spring Boot

Test dependencies

Slice-based testing

Testing WebFlux controllers

Fully embedded Spring Boot app tests

Testing your custom Spring Boot autoconfiguration

Developer Tools for Spring Boot Apps

Developer Tools for Spring Boot Apps

Using Spring Boot's DevTools for hot code reloading

Using Spring Boot's autoconfiguration report

Making local changes and seeing them on the target system

Writing a custom health check

Adding build data to /application/info

Creating custom metrics

Working with additional Actuator endpoints

AMQP Messaging with Spring Boot

AMQP Messaging with Spring Boot

Getting started with RabbitMQ

Adding messaging as a new component to an existing application

Creating a message producer/message consumer

Adding customized metrics to track message flow

Peeking at Spring Cloud Stream (with RabbitMQ)

Microservices with Spring Boot

Microservices with Spring Boot

A quick primer on microservices

Dynamically registering and finding services with Eureka

Introducing @SpringCloudApplication

Calling one microservice from another with client-side load balancing

Implementing microservice circuit breakers

Monitoring circuits

Offloading microservice settings to a configuration server

WebSockets with Spring Boot

WebSockets with Spring Boot

Publishing saved comments to a chat service

Creating a chat service to handle WebSocket traffic

Consuming WebSocket messages from the web page

Moving to a fully asynchronous web client

Handling AJAX calls on the server

Introducing user chatting

Sending user-specific messages

Checking out the final product

JSR 356 versus Spring WebFlux messaging

Securing Your App with Spring Boot

Securing Your App with Spring Boot

Securing a Spring Boot application

Using Spring Session

Securing the chat microservice

Sharing session details with other microservices

Securing the images microservice

Wiring in image ownership

Tailoring the UI with authorization checks

Securing WebSockets

Securing the Config Server

Securing the Eureka Server

Taking Your App to Production with Spring Boot

Taking Your App to Production with Spring Boot

Profile-based sets of beans

Creating configuration property beans

Overriding property settings in production

Pushing app to Cloud Foundry and adjusting the settings

Getting Started with Spring Boot

Getting Started with Spring Boot

Using a Spring Boot template and starter

Creating a simple application

Launching an application using Gradle

Using the command-line runners

Setting up a database connection

Setting up a data repository service

Scheduling executors

Configuring Web Applications

Configuring Web Applications

Creating a basic RESTful application

Creating Spring Data REST service

Configuring custom servlet filters

Configuring custom interceptors

Configuring custom HttpMessageConverters

Configuring custom PropertyEditors

Configuring custom type formatters

Web Framework Behavior Tuning

Web Framework Behavior Tuning

Configuring route matching patterns

Configuring custom static path mappings

Tuning Tomcat via ServletWebServerFactory

Choosing embedded servlet containers

Adding custom connectors

Writing Custom Spring Boot Starters

Writing Custom Spring Boot Starters

Understanding Spring Boot autoconfiguration

Creating a custom Spring Boot autoconfiguration starter

Configuring custom conditional bean instantiations

Using custom @Enable annotations to toggle configuration

Application Testing

Application Testing

Creating tests for MVC controllers

Configuring a database schema and populating it

Creating tests using an in-memory database

Creating tests using mock objects

Creating a JPA component test

Creating a WebMvc component test

Writing tests using Cucumber

Writing tests using Spock

Application Packaging and Deployment

Application Packaging and Deployment

Creating a Spring Boot executable JAR

Creating Docker images

Building self-executing binaries

Spring Boot environment configuration, hierarchy, and precedence

Adding a custom PropertySource to the environment using EnvironmentPostProcessor

Externalizing an environmental configuration using property files

Externalizing an environmental configuration using environment variables

Externalizing an environmental configuration using Java system properties

Externalizing an environmental config using JSON

Setting up Consul

Externalizing an environmental config using Consul and envconsul

Health Monitoring and Data Visualization

Health Monitoring and Data Visualization

Writing custom health indicators

Configuring management context

Emitting metrics

Monitoring Spring Boot via JMX

Managing Spring Boot via SSHd Shell and writing custom remote Shell commands

Integrating Micrometer metrics with Graphite

Integrating Micrometer metrics with Dashing

Spring Boot DevTools

Spring Boot DevTools

Adding Spring Boot DevTools to a project

Configuring LiveReload

Configuring dynamic application restart triggers

Using Remote Update

Spring Cloud

Getting started with Spring Cloud

Service discovery using Spring Cloud Consul

Using Spring Cloud Netflix – Feign

Service discovery using Spring Cloud Netflix – Eureka

Using Spring Cloud Netflix – Hystrix

Bibliography

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Creating a Spring Boot executable JAR

The Spring Boot magic would not be complete without providing a nice way to package the entire application including all of its dependencies, resources, and so on in one composite, executable JAR file. After the JAR file is created, it can simply be launched by running a java -jar <name>.jar command.

We will continue with the application code that we built in the previous chapters and will add the necessary functionalities to package it. Let's go ahead and take a look at how to create the Spring Boot Uber JAR.

Note

The Uber JAR is typically known as an application bundle encapsulated in a single composite JAR file that internally contains a /lib directory with all the dependent inner jars and optionally a /bin directory with the executables.

How to do it...

Let's go to our code directory from Chapter 24, Application Testing, and execute ./gradlew clean build
With the Uber JAR built, let's launch the application by executing java -jar build/libs/ch6-0...