Designing Applications with Spring Boot 2.2 and React JS: Step-by-step guide to design and develop intuitive full stack web applications

Length: 368 pages
Edition: 1
Language: English
Publisher: BPB Publications
Publication Date: 2019-06-10
ISBN-10: 9388511646
ISBN-13: 9789388511643
Sales Rank: #2490877 (See Top 100 Books)

Let us full stack development with Spring Boot and React JS.

Key Features

This book has a very specific goal to make developing REST applications easier and focusing on common challenges of the design of the application with best practices.
This book is providing practical code examples from real-world experiences.
This book is not only about Spring Boot 2.2 and React JS overview but also has an in-depth discussion about adopted REST Architectural pattern and its constraints to create the REST APIs.
The book can act as a tool for learning Spring Boot 2.2 and React JS for the first time as well as a guide and reference for those wanting to dig deeper into specific features.
This book is also providing deeper information about the Spring Security and JWT token-based authentication for your REST applications.
This book is also providing deeper information about the Spring Security and JWT token-based authentication for your REST applications.
Containerization using Docker is another key feature of this book, how to create a Docker image and how to run it.

Description
Designing Applications with Spring Boot 2 & React JS is divided into three parts. The first part introduces you to the essentials of the Spring Boot 2.2 Framework and you will learn how to create REST APIs and how to secure REST APIs. Part 2 steps behind the front end application development with React JS and discuss React features and its advantages toward the frontend application development. Part 3 expands on that by showing how to deploy backend and frontend application the PaaS platform and also will discuss how to deploy application container technologies such as Docker.

What Will You Learn

Exploring Spring Boot 2.2 new features and essential key components such as Starters, Autoconfiguration, CLI, Actuator.
Develop a REST application using Spring Boot 2.2 and DevTools.
Exploring Spring Boot Auto Configuration and Customization.
Creating application profiles based on the environments.
Learn to configure backend data using JDBC and Spring Data JPA.
Learn to configure a DataSource for H2 DB, and also for Maria DB.
Learn best practices for designing a REST architecture based application.
Creating a REST application using HATEOAS.
Consuming REST APIs endpoints with RestTemplate, Traverson, and WebClient.
Exploring JWT web token for the RESTful APIs and explores how to secure REST APIs using OAuth2 and Spring security.
Creating TESTING module of the Spring Boot application and Unit & Integration testing.

Who This Book Is For
For all Java developers who want to learn Spring Boot 2.2 and React JS as in the enterprise application. Therefore, enterprise Java developers will find it particularly useful in the understanding of Spring Boot 2.2 and React JS and how to develop a backend RESTful application using the Spring Boot 2.2 and frontend application using React JS framework. They will most fully appreciate the examples presented in this book. Before reading this book, readers should have basic knowledge of core java, spring, servlet, filter, XML, and JavaScript.

Cover
Designing Application with Spring Boot 2.2 and React JS
Copyright
Dedication
About the Author
Acknowledgements
Preface
Downloading the Code  Bundle and Colored Images
Table of Contents
Chapter 1 : Getting Started with Spring Boot 2.2
    Introduction to Spring Boot 2.2
    Essential key components of Spring Boot
    Spring Boot Starters
    The Spring Boot auto-configuration
    The Spring Boot CLI
    Spring Boot Actuator
    System requirements and setting up a workspace
    Setting up the Spring Boot workspace
    Using the Maven installation for Spring Boot
    Using the Gradle installation
    Creating a Spring Boot application
    Initializing a Spring project with a web interface
    Initializing a Spring project with the STS IDE
    The Spring Boot application launcher file
    Testing the application file
    The build specification file
    Implementing a REST controller
    Writing a test for the controller
    Introducing Spring Boot DevTools
    Conclusion
    Questions
Chapter 2 : Customizing Auto-configuration
    Understanding auto-configuration
    Enabling Spring Boot auto-configuration
    Disabling the Spring Boot auto-configuration
    How the Spring Boot auto-configuration works?
    Auto-configuration classes
    Order of evaluation for overridden properties
    Customizing the name of the application properties file
    Application configuration using a properties file
    Application configuration using a YAML file
    Configuring an embedded server
    Configuring a data source
    Configuring Logging
    Multi-profile YAML documents
    Creating your own configuration properties
    Defining your own configuration properties in the application
    Declaring the configuration property and metadata
    Profiling
    Activating profiles
    Profile-specific application configuration properties files
    Conclusion
    Questions
Chapter 3 : Configuring Data and CRUD operations
    Using JDBC with the Spring application
    Adding a domain class
    Working with JdbcTemplate
    Creating table schema and loading data
    Configuring a DataSource
    In-memory embedded database support
    Production database support
    A JNDI DataSource support 
    Working with Spring Data JPA
    A quick introduction to ORM with JPA 
    Creating the entity class
    Creating and dropping JPA databases
    Introduction to Spring Data
    Configuring Spring Data JPA to the project
    Creating Spring Data JPA repositories  80
    Creating ProductRepository using the Repository marker interface
    Creating ProductRepository using the CrudRepository interface
    Using CommandLineRunner
    Using the data.sql file
    Customizing Spring Data JPA repositories
    Using the @Query annotation
    Using pagination and sorting
    Configuring the H2 Database
    Configuring the MariaDB database 
    Conclusion
    Question 
Chapter 4 : Creating REST APIs with Spring Boot 2.2
    An introduction to the REST architectural style
    REST architectural constraints
    Client-server 
    Stateless
    Cacheable
    Layered system
    Code-on-demand 
    A uniform interface
    The uniform interface principle 
    Identifying the resources
    Resource representation
    Self-descriptive messages
    Hypermedia as the Engine of Application State (HATEOAS)  100
    Create a RESTful web service with Spring Boot 102
    Using the @RestController annotation 
    Retrieving data from the server 
    Sending data to the server 
    Updating data on the server
    Deleting data from the server
    Adding Hypermedia to the RESTful APIs
    Using Spring HATEOAS
    Using the Resource and Resources classes 
    Implementing the resource assemblers
    Changing the embedded relationship name
    Create a RESTful web service using Spring Data REST 
    Consuming REST endpoints
    Consuming REST endpoints with RestTemplate
    Retrieving resources using the GET method
    Creating resource data using the POST method 
    Updating resources using the PUT method
    Deleting resources using the DELETE method
    Consuming REST endpoints with Traverson 
    Consuming REST endpoints with WebClient
    Conclusion
Chapter 5 : Securing REST APIs
    Spring Security
    Adding the Spring Security module 
    Implementing and configuring Spring Security
    An in-memory user configuration
    A JDBC-based user configuration 
    An LDAP-backed user configuration 
    A custom user details configuration
    Password encoding with Spring Security
    Securing your REST APIs using Spring Security and JWT 
    Securing your REST APIs with Spring Security and OAuth2
    Key components for the OAuth2 architecture
    An authorization server
    Resource server 
    OAuth2 
    OAuth2 tokens 
    The OAuth2 authorization flow diagram
    Implementing the OAuth2 Server with Spring Boot Security
    Authorization server configuration 
    Implementing the resource server with Spring Boot Security
    Resource server configuration
    Implementing the client-server application
    Conclusion
    Questions
Chapter 6 : Testing a Spring Boot Application
    Testing in Spring Boot
    Creating unit tests
    Creating integration tests
    Testing the controllers
    Testing auto-configured data JPA repository
    Loading test configurations
    Activating profiles for a test class
    Conclusion
    Questions
Chapter 7 : Getting Started with React JS
    Introducing React
    Features of React JS
    Declarative behaviour
    Virtual DOM object
    Event handling model
    JSX
    Component-based approach
    React native
    Advantages of React JS
    Apps performance
    Code reusability
    Code readability
    Across platforms
    Limitations of React JS
    Setting up the environment for React JS
    Installing Node.js and NPM
    Installing the Visual Studio Code Editor
    Creating a React application
    Using webpack and babel
    Using the create-react-app command
    Conclusion
    Questions
Chapter 8 : Creating React JS Components
    React JSX
    Using the container for nested elements
    HTML tags in lowercase
    Using the custom attribute in an HTML tag
    Using Style in the JSX code
    Adding JavaScript expressions in JSX
    React components
    Data flow in the React components
    Event flow in the React components
    Creating React components for the PRODOS front-end application
    Using multiple React components
    Using properties (props) in React components
    Using state in React components
    Creating Header and Footer components to the Prodos front-end application
    Handling lists with React and creating a table React component for our Prodos React application
    Handling events with React
    Handling forms with React
    Using input text fields in form with React component
    Adding multiple input text fields in the form
    The React component lifecycle
    Conclusion
    Questions
Chapter 9 : Consuming REST API with React
    Using REST services in a React application
    Using the REST services with the Fetch API
    Fetching data using the Fetch API
    Posting data using the Fetch API
    Editing data using the Fetch API
    Deleting data using the Fetch API
    Using third-party React components in our application
    Using the ReactTable
    Using React Skylight
    Using the Toast message React component
    Using the react-confirm-alert Component
    Conclusion
    Questions
Chapter 10 : Deploying and Containerizing Applications
    Deploying applications to the Cloud platform
    Deploying the Spring Boot backend application
    Deploying the React JS front-end application
    Introducing containers
    Understanding how a container works
    An implementation of the container
    Benefits of a container-oriented approach
    Consistent
    Faster processing
    Portable
    Light weight
    Efficient
    Dependencies
    Getting started with Docker
    Installing Docker
    Installing Docker on Linux
    Installing Docker on Windows
    Deploy using the Docker container
    Writing Dockerfile
    Creating a Docker image using the Maven plugin
    Creating a Docker image using the Docker command
    Conclusion
    Questions
Index