Full Stack Development with JHipster电子书

Title Page

Copyright and Credits

Full Stack Development with JHipster

Dedication

Packt Upsell

Why subscribe?

PacktPub.com

Foreword

Contributors

About the authors

About the reviewers

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

Conventions used

Get in touch

Reviews

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 technologies available

Client-side technologies

HTML5 and CSS3

HTML5

CSS3

Sass

Bootstrap

MVVM framework

Angular

React

Build tools

Webpack

BrowserSync

Testing tools

Karma

Protractor

Internationalization

Server-side technologies

Spring Framework

Spring Boot

Spring Security

Spring MVC

Spring data

Security

JWT

Session

OAuth2

Build tools

Maven

Gradle

Hibernate

Liquibase

Caching

Ehcache

Hazelcast

Infinispan

Swagger

Thymeleaf

Dropwizard metrics

WebSocket

Kafka

Testing frameworks

JUnit

Gatling

Cucumber

Introduction to database options

SQL databases

H2

MySQL

MariaDB

PostgreSQL

MS SQL

Oracle

NoSQL databases

MongoDB

Cassandra

Elasticsearch

Installation and setup

Prerequisites

Tools required

Installation procedure

Java 8

Git

Node.js

Yarn

Docker

IDE configuration

System setup

Installation of JHipster

Summary

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 with explanation

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 generated tests

Summary

Customization and Further Development

Live reload for development

Spring Boot DevTools

Webpack dev server and BrowserSync

Setting up live reload for an application

Customizing the Angular frontend for an entity

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 data of other users

Summary

Testing and Continuous Integration

Fixing and running tests

Continuous integration

CI/CD tools

Jenkins

Travis CI

GitLab CI

CircleCI

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

An Introduction to Docker

Docker containers

The Dockerfile

The Docker Hub

Docker compose

Starting the production database with Docker

An introduction to 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

An introduction to deployment options supported by JHipster

Heroku

Cloud Foundry

Amazon Web Services

Production deployment to Heroku cloud

Summary

Introduction to Microservice Server-Side Technologies

Microservice applications versus monoliths

Building blocks of a microservice architecture

Service registry

Service discovery

Health check

Dynamic routing and resiliency

Security

Fault tolerance and failover

JHipster Registry

Netflix Eureka server

Spring cloud config server

HashiCorp Consul

Service discovery

Health discovery

K/V store

Multiple data centers

JHipster Gateway

Netflix Zuul

Hystrix

JHipster Console

Elasticsearch

Logstash

Kibana

Zipkin

Prometheus

JHipster UAA server

Summary

Building Microservices with JHipster

Application architecture

Gateway application generation

Converting a monolithic application to a microservice gateway

Application generation

Generating a new Gateway

Gateway configuration

JWT authentication

How JWT works

Microservice application - Invoice Service with MySQL database

Application generation

Microservice configuration

Microservice application - notification service with NoSQL database

Application generation

Microservice configuration

Summary

Working with Microservices

Setting up JHipster Registry locally

Using a pre-packaged WAR file

Building from source

Docker mode

Running a generated application locally

Gateway application pages

JHipster Registry pages

System status

Below renew threshold

Instances registered

General info and health

Application listing page

Metrics page

Health page

Configuration page

Logs page

Swagger API endpoints

Running invoice and notification applications locally

Modeling entities in JDL

Entity generation on microservices

Explaining the generated code

Gateway application

Explaining the generated pages

Summary

Deploying with Docker Compose

Introducing microservice deployment options

A short introduction to Docker Compose

Kickstarting Kubernetes

Introducing OpenShift

Explaining Rancher

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 Swarm

Summary

Deploying to the Cloud with Kubernetes

Generating Kubernetes configuration files with JHipster

Walking through the generated files

Deploying the application to Google Cloud with Kubernetes

Summary

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

Generating source code

Generating an entity with React client side

Summary

Best Practices with JHipster

The next steps to pursue

Adding a shopping cart for the application

Improving end-to-end tests

Improving the CI/CD pipeline

Building a JHipster module

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