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.

Related Content you might be interested in

Current Title:

Small book image
Developing Java Applications with Spring and Spring Boot
Claudio Eduardo de Oliveira | Greg L. Turnquist | Alex Antonov
Oct, 2018 | 16 hours 22 minutes
No titles found
Table of Contents (34 chapters)
Title Page - Courses
Title Page - Courses
Copyright and Credits - Courses
Copyright and Credits - Courses
Packt Upsell - Courses
Packt Upsell - Courses
Preface
Preface
Free Chapter
1
Journey to the Spring World
Journey to the Spring World
Spring modularity
Setting up our development environment
Summary
2
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
Summary
3
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
Summary
4
Kotlin Basics and Spring Data Redis
Kotlin Basics and Spring Data Redis
Learning Kotlin basics
Wrapping it up
Creating the project
Running the Redis instance
Understanding Redis
Spring Data Reactive Redis
Creating a Twitter application
Testing APIs
Summary
5
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
Summary
6
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
Summary
7
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
Summary
8
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
Summary
9
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
Summary
10
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
Summary
11
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
Summary
12
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
Summary
13
Testing with Spring Boot
Testing with Spring Boot
Test dependencies
Unit testing
Slice-based testing
Testing WebFlux controllers
Fully embedded Spring Boot app tests
Testing your custom Spring Boot autoconfiguration
Summary
14
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
Summary
15
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)
Summary
16
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
Summary
17
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
Summary
18
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
Tracing calls
Securing the Config Server
Securing the Eureka Server
Summary
19
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
Summary
20
Getting Started with Spring Boot
Getting Started with Spring Boot
Introduction
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
21
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
22
Web Framework Behavior Tuning
Web Framework Behavior Tuning
Introduction
Configuring route matching patterns
Configuring custom static path mappings
Tuning Tomcat via ServletWebServerFactory
Choosing embedded servlet containers
Adding custom connectors
23
Writing Custom Spring Boot Starters
Writing Custom Spring Boot Starters
Introduction
Understanding Spring Boot autoconfiguration
Creating a custom Spring Boot autoconfiguration starter
Configuring custom conditional bean instantiations
Using custom @Enable annotations to toggle configuration
24
Application Testing
Application Testing
Introduction
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
25
Application Packaging and Deployment
Application Packaging and Deployment
Introduction
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
26
Health Monitoring and Data Visualization
Health Monitoring and Data Visualization
Introduction
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
27
Spring Boot DevTools
Spring Boot DevTools
Introduction
Adding Spring Boot DevTools to a project
Configuring LiveReload
Configuring dynamic application restart triggers
Using Remote Update
28
Spring Cloud
Spring Cloud
Introduction
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
Bibliography
Index
Index

Configuring custom static path mappings

In the previous recipe, we looked at how to tune the URL path mapping for requests and translate them into controller methods. It is also possible to control how our web application deals with static assets and the files that exist on the filesystem or are bundled in the deployable archive.

Let's say that we want to expose our internal application.properties file via the static web URL of http://localhost:8080/internal/application.properties from our application. To get started with this, proceed with the steps in the next section.

How to do it...

  1. Let's add a new method, addResourceHandlers, to the WebConfiguration class with the following content:
@Override 
public void addResourceHandlers(ResourceHandlerRegistry registry) { 
    registry.addResourceHandler("/internal/**")
            .addResourceLocations("classpath:/"); 
}
  1. Start the application by running ./gradlew clean bootRun
  2. Let's open http://localhost:8080/internal/application.properties in the browser...
Previous Section
End of Section 4
Next Section