Now, let's look at how to customize the preceding exception and return the proper response status with a customized message.
The following steps are involved:
- Defining the structure of exception response.
- Defining global exception handling advice.
- Title Page
- Copyright and Credits
- About Packt
- Contributors
- Preface
- Section 1: Getting Started with Spring and Spring Boot
- Spring Landscape - Framework, Modules, and Projects
- Exploring Spring and its evolution
- Learning about Spring Modules
- Beginning with Spring Projects
- New features in Spring Framework 5.0 and 5.1
- Learning about new features in Spring Boot 2.0 and 2.1 
- Summary
- Further reading
- Dependency Injection and Unit Testing
- Technical requirements
- Understanding a dependency
- What is DI?
- What does the Spring Framework do?
- Understanding the Spring Framework in depth
- Exploring CDI
- Unit testing the Spring application context
- Summary
- Further reading
- Building Web Applications with Spring MVC
- Technical requirements
- Understanding the architectures of Java servlet web applications
- Learning Spring MVC with six basic flow examples
- Setting up a Spring MVC application
- Flow 1 – simple controller flow without View
- Flow 2 – creating a simple controller flow with a View – JSP
- Flow 3 – controller redirecting to a View with a model
- Flow 4 – controller redirecting to a View with ModelAndView
- Flow 5 – controller redirecting to a View with a form
- Flow 6 – adding validation to the previous flow
- An overview of Spring MVC
- Important concepts behind Spring MVC
- A quick look at Spring MVC advanced features
- Unit testing Spring MVC applications – basic flows
- Flow 1 – simple controller flow without View
- Flow 2 – simple controller flow with a View
- Flow 3 – controller redirecting to a View with Model
- Flow 4 – controller redirecting to a View with ModelAndView
- Flow 5 – controller redirecting to a View with a form
- Flow 6 – adding validation to the previous flow
- Writing integration tests for Spring MVC controllers
- Spring Security
- Summary
- Further reading
- Getting Started with Spring Boot
- Technical requirements
- What is Spring Boot?
- Building a Hello World application with Spring Boot
- Getting started with SPRING INITIALIZR
- A quick peek into AutoConfiguration
- Externalizing application configuration
- Understanding embedded servers
- Using developer tools to improve productivity
- Using Spring Boot Actuator for application monitoring
- Summary
- Digging Deeper into the Spring Framework
- Section 2: Building a REST API and Full Stack Applications with Spring
- Building REST APIs with Spring Boot
- Understanding REST
- Designing your first REST API
- Creating a Hello World API with Spring Boot
- Creating a todo REST API
- Implementing exception handling for REST APIs
- Exploring HATEOAS
- Implementing validation for REST APIs
- Documenting REST services using the OpenAPI Specification
- Implementing internationalization for REST APIs
- Implementing caching for REST APIs
- Deploying Spring Boot applications to the cloud
- Summary
- Unit Testing REST API with Spring Boot
- Technical requirements
- Unit testing REST API with Spring Boot
- Adding dependency on Spring Boot Starter Test
- Unit tests for the BasicController API
- Unit tests for the TodoController API
- Setting up unit tests for the TodoController API
- Writing a unit test to retrieve all todos – the GET method
- Writing a unit test for retrieving a specific todo – the GET method
- Writing a unit test for creating a todo – the POST method
- Writing a unit test for creating a todo with validation errors
- Writing a unit test for updating a todo – the PUT method
- Writing a unit test for deleting a todo – the DELETE method
- Integration testing REST API with Spring Boot
- Writing integration tests for BasicController
- Integration tests for the TodoController API
- Todo API integration testing setup
- Writing an integration test to retrieve all todos – the GET method
- Writing an integration test for creating a todo – the POST method
- Writing an integration test for updating a todo – the PUT method
- Writing an integration test for deleting a todo – the DELETE method
- Unit and integration testing best practices
- Summary
- Further reading
- Securing REST API with Spring Security
- Technical requirements
- Security REST API with Spring Security
- Understanding Spring Security
- Reviewing the log
- Understanding Spring Security filters
- Understanding authentication in Spring Security
- Understanding authentication extension points in Spring Security
- Understanding authorization in Spring Security
- Understanding authentication extension points in Spring Security
- Providing secured annotations on service methods
- Providing JSR-250 annotations on service methods
- Using Spring Security pre and post annotations
- Implementing security best practices with Spring Security
- Exploring OAuth2 authentication
- Authentication with JWT
- Summary
- Further reading
- Full Stack App with React and Spring Boot
- Technical requirements
- Understanding full stack architecture
- Introducing React
- Building your first React application
- Summary
- Further reading
- Managing Data with Spring Data
- Technical requirements
- Challenges with a variety of data stores
- Communicating with relational databases
- Introducing Spring Data
- Connecting to relational databases using Spring Data JPA
- Understanding Spring Data JPA with an example
- Create a new project with a starter data JPA
- Defining entities
- Creating the SpringBootApplication class
- Populating some data
- Creating a simple repository
- Create a repository extending the CrudRepository interface
- Creating a repository extending the PagingAndSortingRepository interface
- Writing custom query methods
- Writing custom JPQL queries
- Getting started with transaction management
- Understanding Spring Data JPA with an example
- Interacting with MongoDB using Spring Data
- Using Spring Data REST to create REST APIs
- Summary
- Section 3: Cloud, Microservices, and Best Practices with Spring
- Getting Started with Microservices
- Understanding the goals of application development
- Developing applications quickly – speed
- Building dependable applications – safety
- Reliability – does the application behave as expected?
- Availability – is your application available all the time?
- Security – is your application secure?
- Performance – is your application quick enough?
- High resilience – does your application react well to failures?
- Scalability – what is needed to support a drastic increase in application load?
- Challenges with monolithic applications
- Getting started with microservices
- What is a microservice?
- Understanding the big idea of microservice architecture
- Understanding microservice characteristics
- Small and lightweight microservices
- Interoperability with message-based communication
- Capability-aligned microservices
- Independently deployable microservices
- Stateless microservices
- Completely automated build and release process
- Adherence to event-driven architectures
- Independent teams developing and supporting microservices – DevOps
- Understanding the advantages of microservice architectures
- Exploring microservice challenges
- Understanding cloud-native applications
- What is the Twelve-Factor App?
- Maintain one code base
- Explicit declaration of dependencies
- Application configuration stored in an environment
- All dependencies are treated as backing services
- Clear separation between build, release, and run phases
- Applications do not store states – stateless
- All the services are exposed with port binding
- Possibility to scale horizontally – concurrency
- Each application instance is disposable
- Achieving environmental parity – all environments are the same
- Treating all logs as event streams
- No distinction for admin processes
- What is the Twelve-Factor App?
- Exploring Spring projects for microservices
- Summary
- Further reading
- Understanding the goals of application development
- Building Microservices with Spring Boot and Spring Cloud
- Technical requirements
- Understanding the microservices we will build
- Using recommended versions for Spring Boot and Spring Cloud
- Exploring centralized microservice configuration
- Problem statement
- Solution
- Options
- Spring Cloud Config
- Implementing Spring Cloud Config Server
- Setting up Spring Cloud Config Server
- Creating a service in Microservice A to return a message from the application configuration
- Connecting Spring Cloud Config Server to a local Git repository
- Creating a development environment-specific configuration for Microservice A
- Enhancing Microservice A to make it a Spring Cloud Config Client
- Implementing Spring Cloud Config Server
- Getting an overview of event-driven approaches
- Getting started with Spring Cloud Bus
- Declarative REST client – Feign
- Implementing load balancing for microservices
- Understanding the need for a naming server
- The working of a naming server
- Understanding API gateways
- Understanding distributed tracing
- Implementing fault tolerance with Hystrix
- Summary
- Further reading
- Reactive Programming
- Technical requirements
- The reactive manifesto
- Reactive use case – a stock price page
- Implementing reactive programming in Java
- Understanding Reactive Streams
- Exploring the Reactor framework
- Creating Reactive web applications with Spring Web Reactive
- Integrating with reactive databases
- Integrating the Spring Boot Reactive MongoDB starter
- Creating a model object – a stock document
- Creating ReactiveCrudRepository
- Initializing stock data using CommandLineRunner
- Creating reactive methods in the REST controller
- Updating the view to subscribe to the event stream
- Launching SpringReactiveExampleApplication
- Summary
- Spring Best Practices
- Adhering to Maven's standard directory layout
- Building applications using a layered architecture
- Having separate context files for different layers
- Separating api and impl for important layers
- Understanding exception handling best practices
- Keeping your Spring configuration light
- Using the basePackageClasses attribute in ComponentScan
- Not using version numbers in schema references
- Preferring constructor injection for mandatory dependencies
- Managing dependency versions for Spring projects
- Exploring unit testing best practices
- Exploring integration testing best practices
- Exploring caching best practices
- Understanding best practices for logging
- Summary
- Working with Kotlin in Spring
- Other Books You May Enjoy
Customizing the exception response
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.