Log In
Or create an account ->
Imperial Library
Home
About
News
Upload
Forum
Help
Login/SignUp
Index
Title Page
Copyright and Credits
Full Stack Development with JHipster Second Edition
Dedication
About Packt
Why subscribe?
Foreword
Contributors
About the authors
About the reviewer
Packt is searching for authors like you
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Reviews
Section 1: Getting Started with the JHipster Platform
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
Leave a review - let other readers know what you think
← Prev
Back
Next →
← Prev
Back
Next →