Full stack development with JHipster : build full stack applications and microservices with Spring Boot and modern JavaScript frameworks

Cover
Title Page
Copyright and Credits
Dedication
About Packt
Foreword
Contributors
Table of Contents
Preface
Section 1: Getting Started with the JHipster Platform
Chapter 1: Introduction to Modern Web Application Development
	Modern full stack web development
	Web architecture patterns
		Monolithic web architecture
		Microservice architecture
	Choosing the right pattern
		When to choose a monolithic architecture
		When to choose a microservice architecture
	Summary
Chapter 2: Getting Started with JHipster
	Why JHipster?
	Goal and adoption of JHipster
	Introduction to available technologies 
		Client-side technologies
			HTML5 and CSS3
			SASS
			Bootstrap
			MVVM framework
				Angular
				React
				Vue.js
			Build tools – webpack and BrowserSync
			Testing tools – Jest and Protractor
			Internationalization
		Server-side technologies
			Spring Framework
				Spring Boot
				Spring Security
				Spring MVC
				Spring Data
			Security
				JWT
				Session
				OAuth2/OIDC
			Build tools – Maven and Gradle
			Hibernate
			Liquibase
			Caching
				Ehcache
				Hazelcast
				Infinispan
				Memcached
				Redis
			Swagger
			Thymeleaf
			Micrometer
			WebSocket
			Kafka
			Testing frameworks – JUnit, Gatling, and Cucumber
		Introduction to database options
			SQL databases
				H2
				MySQL
				MariaDB
				PostgreSQL
				MS SQL
				Oracle
			NoSQL databases
				MongoDB
				Cassandra
				Couchbase
				Elasticsearch
	Installing and setting up JHipster
		Prerequisites
			Tools required
				Java
				Git
				Node.js
				Docker
			IDE configuration
			System setup
		Installation of JHipster
	Summary
Section 2: Building and Customizing Web Applications with JHipster
Chapter 3: Building Monolithic Web Applications with JHipster
	Application generation
		Step 1 – preparing the workspace
		Step 2 – generating code using JHipster
			Server-side options
			Client-side options
			Internationalization options
			Testing
			Modules
	Code walkthrough
		File structure
		Server-side source code
			Java source
			Resources
		Client-side source code
	Starting the application
	Application modules
		Home and login modules
		Account modules
			Settings
			Password
			Registration
		Admin module
			User management
			Metrics
			Health
			Configuration
			Audits
			Logs
			API
	Running generated tests
		Server-side tests
		Client-side tests
	Summary
Chapter 4: Entity Modeling with JHipster Domain Language
	Introduction to JDL
		DSL grammar for JDL
			Entity modeling with JDL
			Relationship management
			DTO, service, and pagination options
		JDL-Studio
		Use case entity model
			Entities
			Relationships
			Options for entities
	Entity generation with JHipster
		Generated code walkthrough
			Server-side source code
				Domain class for the entity
				Repository interface for the entity
				Service class for the entity
				Resource class for the entity
			Client-side
				TypeScript model class for the entity
				Angular services for the entity
				Angular components of the entity
				Angular route for the entity
				Angular module for the entity
	Generated pages
	Running the generated tests
	Summary
Chapter 5: Customization and Further Development
	Live reload for development
		Spring Boot DevTools
		Webpack dev server and BrowserSync
		Setting up live reloads for an application
	Customizing the Angular frontend for an entity
		Bringing back the sorting functionality
		Adding a filtering functionality
	Editing an entity using the JHipster entity sub-generator
	Changing the look and feel of the application
	Adding a new i18n language
	Authorization with Spring Security
		Limiting access to entities
		Limiting access to create/edit/delete entities
		Limiting access to the data of other users
	Summary
Section 3: Continuous Integration and Testing
Chapter 6: Testing and Continuous Integration
	Fixing and running tests
	Briefing on CI
	CI/CD tools
		Jenkins
		Azure Pipelines
		Travis CI
		GitLab CI
		GitHub Actions
	Setting up Jenkins
	Creating a Jenkins pipeline using JHipster
		The Jenkinsfile and its stages
		Setting up the Jenkinsfile in a Jenkins server
	Summary
Chapter 7: Going into Production
	Introduction to Docker
		Docker containers
		Dockerfiles
		Docker Hub
		Docker Compose
	Starting the production database with Docker
	Introducing Spring profiles
	Packaging the application for local deployment
		Building and deploying using Docker
		Building and deploying an executable archive
	Upgrading to the newest version of JHipster
	Deployment options supported by JHipster
		Heroku
		Cloud Foundry
		Amazon Web Services
		Google App Engine
		Azure Spring Cloud
		Azure App Service
	Production deployment to the Heroku Cloud
	Summary
Section 4: Converting Monoliths to Microservice Architecture
Chapter 8: Microservice Server-Side Technologies
	Microservice applications versus monoliths
		Scalability
		Efficiency
		Time constraint 
	Building blocks of a microservices architecture
		Service registry
		Service discovery
			Client-side discovery pattern
			Server-side discovery pattern
		Health check
		Dynamic routing and resiliency
		Security
		Fault tolerance and failover
	Options supported by JHipster
		JHipster Registry
			Netflix Eureka
			Spring Cloud Config Server
		HashiCorp Consul
			Service discovery
			Health discovery
			Key/Value store
			Multiple data centers
		JHipster gateway
			Netflix Zuul
			Hystrix
		JHipster Console
			Elasticsearch
			Logstash
			Kibana
			Zipkin
		Prometheus
		JWT authentication
			How JWT works
		JHipster UAA server
	Summary
Chapter 9: Building Microservices with JHipster
	Application architecture
	Generating a microservice stack using JDL
		Application modeling using JDL
		Gateway application
			JDL specification for the gateway application
		Microservice invoice application
			JDL specification for the invoice application
		Microservice notification application
			JDL specification for the notification application
		Modeling microservice entities in JDL 
		Application generation with import-jdl
	Gateway application
		Gateway application entities
	Invoice microservice configuration
	Notification microservice configuration
	Summary
Chapter 10: Working with Microservices
	Setting up JHipster Registry locally
		Using a pre-packaged JAR file
			Docker mode
	Running a generated application locally
		Gateway application pages
		JHipster Registry pages
			Dashboard
				System status
				Instances registered
				General info and health
			Application listing page
			Metrics page
			Health page
			Configuration page
			Logs page
			Loggers
			Swagger API endpoints
		Running invoice and notification applications locally
		Explaining the generated entity pages
	Summary
Section 5: Deployment of Microservices
Chapter 11: Deploying with Docker Compose
	Introducing microservice deployment options
		A short introduction to Docker Compose
		Introduction to Kubernetes
		Introduction to OpenShift
	Generated Docker Compose files
		Walking through the generated files
		Building and deploying everything to Docker locally
	Generating Docker Compose files for microservices
		Features of the deployed application
		JHipster Console demo
		Scaling up with Docker
	Summary
Chapter 12: Deploying to the Cloud with Kubernetes
	Generating Kubernetes configuration files with JHipster
		Generating the Kubernetes manifests
	Walking through the generated files
	Deploying the application to Google Cloud with Kubernetes
	Using Istio service mesh
		What is Istio?
		Microservice with Istio service mesh
		Deploying Istio to a Kubernetes cluster
		Generating the application
		Deploying to Google Cloud
	Summary
Section 6: React and Vue.js for the Client Side
Chapter 13: Using React for the Client-Side
	Generating an application with React client-side
	Technical stack and source code
		Technical stacks
			Using TypeScript
			State management with Redux and friends
			Routing with React Router
			HTTP requests using Axios
			Bootstrap components using reactstrap
			Unit testing setup
		Generated source code
	Generating an entity with React client-side
	Summary
Chapter 14: Using Vue.js for the Client-Side
	Generating an application with Vue.js client-side
	Technical stack and source code
		Technical stack
			Using TypeScript
			State management with Vuex
			Routing with Vue Router
			HTTP requests using Axios
			Bootstrap components using BootstrapVue
			Unit testing setup
		Generated source code
	Generating an entity with VueJS client-side
	Summary
Chapter 15: Best Practices with JHipster
	The next steps to take
		Adding a shopping cart for the application
		Improving end-to-end tests
		Improving the CI/CD pipeline
		Create an e-commerce application with React or Vue.js
		Building a JHipster module
	The best practices to keep in mind
		Choosing a client-side framework
		Choosing a database option
		Architecture considerations
		Security considerations
		Deployment and maintenance
		General best practices
	Using JHipster modules
	Contributing to JHipster
	Summary
Other Books You May Enjoy
Index