34,79 €
Mehr erfahren.
- Herausgeber: Packt Publishing
- Kategorie: Fachliteratur
- Sprache: Englisch
JHipster is a development platform to generate, develop, and deploy Spring Boot and Angular/React applications and Spring microservices. It provides you with a variety of tools that will help you quickly build modern web applications. This book will be your guide to building full stack applications with Spring and Angular using the JHipster tool set.
You will begin by understanding what JHipster is and the various tools and technologies associated with it. You will learn the essentials of a full stack developer before getting hands-on and building a monolithic web application with JHipster. From here you will learn the JHipster Domain Language with entity modeling and entity creation using JDL and JDL studio. Moving on, you will be introduced to client side technologies such as Angular and Bootstrap and will delve into technologies such as Spring Security, Spring MVC, and Spring Data. You will learn to build and package apps for production with various deployment options such as Heroku and more. During the course of the book, you will be introduced to microservice server-side technologies and how to break your monolithic application with a database of your choice. Next, the book takes you through cloud deployment with microservices on Docker and Kubernetes. Going forward, you will learn to build your client side with React and master JHipster best practices.
By the end of the book, you will be able to leverage the power of the best tools available to build modern web applications.
Das E-Book können Sie in Legimi-Apps oder einer beliebigen App lesen, die das folgende Format unterstützen:
Seitenzahl: 344
Veröffentlichungsjahr: 2018
Ähnliche
Full Stack Development with JHipster
Copyright © 2018 Packt Publishing
All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the authors, nor Packt Publishing or its dealers and distributors, will be held liable for any damages caused or alleged to have been caused directly or indirectly by this book.
Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.
Commissioning Editor: Merint MathewAcquisition Editor: Alok DhuriContent Development Editor:Akshada IyerTechnical Editor: Mehul SinghCopy Editor:Safis EditingProject Coordinator: Prajakta NaikProofreader: Safis EditingIndexer: Rekha NairGraphics: Jisha ChirayilProduction Coordinator: Arvindkumar Gupta
First published: March 2018
Production reference: 1200318
Published by Packt Publishing Ltd. Livery Place 35 Livery Street Birmingham B3 2PB, UK.
ISBN 978-1-78847-631-7
www.packtpub.com
To Nellaiyapen, Amutha, Sakthi, and Sahana for their advice, patience, and faith. To my amigos and all the awesome full-stack developers out there.
Mapt is an online digital library that gives you full access to over 5,000 books and videos, as well as industry leading tools to help you plan your personal development and advance your career. For more information, please visit our website.
Why subscribe?
Spend less time learning and more time coding with practical eBooks and Videos from over 4,000 industry professionals
Improve your learning with Skill Plans built especially for you
Get a free eBook or video every month
Mapt is fully searchable
Copy and paste, print, and bookmark content
PacktPub.com
Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.PacktPub.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at [email protected] for more details.
At www.PacktPub.com, you can also read a collection of free technical articles, sign up for a range of free newsletters, and receive exclusive discounts and offers on Packt books and eBooks.
Foreword
The first time I used JHipster was in 2013. I was an independent consultant at the time, and I used JHipster to demonstrate to my client that you could quickly generate an AngularJS and Spring Boot application. I liked the project so much that I decided to write a mini-book about JHipster for InfoQ. As part of my writing process, I developed a sample application and found bugs in JHipster. I reported these bugs to the project, sometimes with fixes.
JHipster is an incredible project. It gives Java developers the opportunity to generate applications that use modern JavaScript frameworks for their UI, while also using the Spring frameworks they know and love on the backend. The project started as an application generator and has gradually morphed into a development platform that makes it possible to create, build, and deploy both monoliths and microservices. Not only that, but it follows many of its dependent project's best practices. Simply put, it creates code for you, allows you to concentrate on your business logic, and makes your development experience fantastic.
Deepu has been a joy to work with ever since I started reporting issues to JHipster. Not only does he know Angular and React exceptionally well, but he also knows the internals of Yeoman and Node, which helps the project keep its momentum. Whenever there's a new major version of JHipster, Deepu is the one who seems to work the hardest and commit the most code.
I met Sendil Kumar N through the JHipster project as well. Sendil was an instrumental figure in migrating from AngularJS to Angular (initially called Angular 2) in 2016 and optimizing our webpack configuration. He's also been crucial to JHipster's React support and is also a fun guy to be around. I recall fondly meeting him for the first time at Devoxx Belgium 2017.
Deepu and Sendil are staples in the JHipster community, and I'm sure this book will not disappoint you. Both of them always go the extra mile to deliver exceptional code, and I expect the same from their writing.
Become a hip Java Developer and build awesome apps with JHipster!
Matt Raible
Web Developer, Java Champion, and Developer Advocate at Okta Denver, Colorado, USA
Contributors
About the authors
Deepu K Sasidharan is the co-lead of JHipster. He has been part of the core JHipster team from its inception and is an active contributor to the project. He currently works for XebiaLabs, a DevOps software company, as a senior full-stack product developer. Before that, he worked at TCS as a technical consultant, focusing on innovative solutions for Airlines. He has over 8 years of experience in the architecture, design, and implementation of enterprise web applications and pre-sales. He is also a JavaScript and Web technology expert. When not coding, he likes to read about astronomy and science.
Sendil Kumar N is a part of the JHipster and Webpack team. He is a vivid open source enthusiast and a contributor to many open source projects. He loves to explore and experiment new technologies and frameworks. He is passionate about (re)learning. He currently works at XebiaLabs as a senior full-stack product developer, where he develops the solution for enterprises to design and orchestrate their releases. Before that, he developed ideas for enterprise products and successfully set up a complete DevOps, agile, and cloud team in a more traditional environment.
About the reviewers
Julien Dubois is the creator and lead developer of JHipster. He has more than 20 years of experience as a software developer, mainly in Java and Web technologies. He has a strong knowledge of the Spring Framework, having coauthored a best-selling book on the subject, and has managed SpringSource’s France subsidiary.
Today, Julien works as the Chief Innovation Officer at Ippon Technologies, an IT consulting company that has delivered many JHipster-based applications to its clients worldwide.
Antonio Goncalves is a senior Java developer expert on distributed systems. Despite being a consultant, he loves to build bonds with the community, so he created the Paris Java User Group and Devoxx France. As a JCP expert member on various JSRs, Antonio uses this expertise to write books on Java EE and to talk at international conferences. For his expertise and all of his work for the Java community, Antonio has been elected Java Champion. Follow him on Twitter at @agoncal.
Packt is searching for authors like you
If you're interested in becoming an author for Packt, please visit authors.packtpub.com and apply today. We have worked with thousands of developers and tech professionals, just like you, to help them share their insight with the global tech community. You can make a general application, apply for a specific hot topic that we are recruiting an author for, or submit your own idea.
Table of Contents
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
Preface
This book, Full Stack development with JHipster, aims to address the following challenges faced by full-stack developers today:
There are multitudes of technologies and options out there to learn
Customer demands have increased and hence time to market has become more stringent
Client-side frameworks have become complicated and difficult to integrate
There is so much integration between technologies and concepts that it overwhelms most novice and even proficient developers
JHipster provides a platform for developers to easily create web applications and microservices from scratch, without having to spend a lot of time wiring everything together and integrating technologies together. This frees up time immensely for developers to actually focus on their solution rather than spending time learning and writing boilerplate code. JHipster will help novice and experienced developers to be more productive from day one. It's like pair programming with an entire community.
This book will take you on a journey from zero to hero in full stack development. You will learn to create complex production-ready Spring Boot and Angular web applications from scratch using JHipster and will go on to develop and deploy features and business logic on cloud services. You will also learn about microservices and how to convert a monolithic application into the microservice architecture as it evolves using JHipster. Additionally, you will learn how to make use of the new React support being introduced in JHipster and about various best practices and suggestions from the JHipster community and the core development team.
Who this book is for
Anyone with a basic understanding of building Java web applications and basic exposure to Spring and Angular/React can benefit from using this book to learn how to use JHipster for cutting-edge full-stack development or to improve their productivity by cutting down boilerplate and learning new techniques. The audience can be broadly classified as follows:
Full stack web app developers who want to reduce the amount of boilerplate they write and save time, especially for greenfield projects.
Backend developers who want to learn full stack development with Angular or React
Full-stack developers who want to learn microservice development
Developers who want to jump-start their full stack web application or microservice development
Developers who want to quickly prototype web applications or
microservices
What this book covers
Chapter 1, Introduction to Modern Web Application Development, introduces two widely used full-stack web application development architectures. It also lays out commonly faced challenges in full stack web application development.
Chapter 2, Getting Started with JHipster, introduces the JHipster platform. It will also give the reader a brief overview of different server-side, client-side, and DB technology options offered by JHipster. This chapter will also provide instructions to install and use JHipster and various tools and options supported by it.
Chapter 3, Building Monolithic Web Applications with JHipster, guides the user through the creation of a production-ready Spring boot and Angular web applications from scratch using JHipster and will take the reader through the generated code, screens, and concepts.
Chapter 4, Entity Modeling with JHipster Domain Language, introduces the reader to JHipster domain language (JDL) and will teach build business logic with entity modeling and entity creation using JDL and JDL studio.
Chapter 5, Customization and Further Development, guides the reader through further development of the generated application. It will also teach how to the reader more about using technologies such as Angular, Bootstrap, Spring Security, Spring MVC REST, and Spring Data.
Chapter 6, Testing and Continuous Integration, guides the reader through testing and setting up a continuous integration pipeline using Jenkins.
Chapter 7, Going into Production, shows the reader how to use Docker and how to build and package the app for production. It will also introduce the reader to some of the production cloud deployment options supported by JHipster.
Chapter 8, Introduction to Microservice Server-Side Technologies, gives an overview of different options available in the JHipster microservice stack.
Chapter 9, Building Microservices with JHipster, guides the reader through converting a JHipster monolith web application into a full-fledged microservice architecture with a Gateway, Registry, monitoring console, and multiple microservices. It will also guide the reader through the generated code and components such as JHipster registry, JHipster console, API gateway, and JWT.
Chapter 10, Working with Microservices, guides the reader through running the generated applications locally and creating domain entities for the microservice architecture using JHipster domain language.
Chapter 11, Deploying with Docker Compose, introduces the reader to advanced local and cloud deployment options for microservices. It will also guide the user through local deployment and testing of the generated microservice stack using Docker Compose and JHipster.
Chapter 12, Deploying to the Cloud with Kubernetes, guides the user through the Google cloud deployment of the generated microservice stack using Kubernetes and JHipster.
Chapter 13, Using React for the Client-Side, takes the user through generating an application with React on the client side instead of Angular using JHipster.
Chapter 14, Best Practices with JHipster, summarizes what the reader has learned so far and will suggest best practices and next steps to utilize the skills learned.
To get the most out of this book
To get the most out of this book, you will need to know basics of the following technologies:
Web technologies (HTML, JavaScript, and CSS)
Java 8
Basics of the Spring Framework
Basic understanding of SQL databases
Build tools (Maven or Gradle)
npm or Yarn
It will also be easier if you are familiar with using technologies such as Docker and Kubernetes, as it will help you grasp some of the chapters easily.
You will also need JDK8, Git, Docker, and NodeJS installed; your favorite web browser; a terminal application; and your favorite code editor/IDE.
Download the example code files
You can download the example code files for this book from your account at www.packtpub.com. If you purchased this book elsewhere, you can visit www.packtpub.com/support and register to have the files emailed directly to you.
You can download the code files by following these steps:
Log in or register at
www.packtpub.com
.
Select the
SUPPORT
tab.
Click on
Code Downloads & Errata
.
Enter the name of the book in the
Search
box and follow the onscreen instructions.
Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:
WinRAR/7-Zip for Windows
Zipeg/iZip/UnRarX for Mac
7-Zip/PeaZip for Linux
The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Full-Stack-Development-with-JHipster. In case there's an update to the code, it will be updated on the existing GitHub repository.
We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!
Conventions used
There are a number of text conventions used throughout this book.
CodeInText: Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles. Here is an example: "At the backend, modify the save method of ProductOrderService.java to create an Invoice and Shipment for the ProductOrder and save them all."
A block of code is set as follows:
entity Product { name String required description String price BigDecimal required min(0) size Size required image ImageBlob}enum Size { S, M, L, XL, XXL}entity ProductCategory { name String required description String}
When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:
entity ProductOrder { placedDate Instant required status OrderStatus required
invoiceId Long
code String required}
Any command-line input or output is written as follows:
> cd invoice
> ./gradlew
Bold: Indicates a new term, an important word, or words that you see onscreen. For example, words in menus or dialog boxes appear in the text like this. Here is an example: "You can alternatively test this via your Gateway application. Log in to our Gateway application and then navigate to Administration | Gateway."
Get in touch
Feedback from our readers is always welcome.
General feedback: Email [email protected] and mention the book title in the subject of your message. If you have questions about any aspect of this book, please email us at [email protected].
Errata: Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you have found a mistake in this book, we would be grateful if you would report this to us. Please visit www.packtpub.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details.
Piracy: If you come across any illegal copies of our works in any form on the Internet, we would be grateful if you would provide us with the location address or website name. Please contact us at [email protected] with a link to the material.
If you are interested in becoming an author: If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, please visit authors.packtpub.com.
Reviews
Please leave a review. Once you have read and used this book, why not leave a review on the site that you purchased it from? Potential readers can then see and use your unbiased opinion to make purchase decisions, we at Packt can understand what you think about our products, and our authors can see your feedback on their book. Thank you!
For more information about Packt, please visit packtpub.com.
Introduction to Modern Web Application Development
According to the Stack Overflow developer survey 2017 (https://insights.stackoverflow.com/survey/2017#developer-profile-specific-developer-types), full-stack web developer is the most popular developer title. The software industry defines a full-stack developer as someone who can work on different areas of an application stack. The term stack refers to different components and tools that make up an application.
In terms of web application development, the stack can be broadly classified into two areas—frontend and backend stack or client-side and server-side stack. Frontend generally refers to the part that is responsible for rendering the user interface, and backend refers to the part that is responsible for the business logic, database interactions, user authentication, server configuration, and so on. A full-stack Java web application developer is expected to work on both frontend and backend technologies, ranging from writing HTML/JavaScript for the user interface to writing Java class files for business logic and SQL queries for database operations as required.
With an ever-evolving software architecture landscape, the scope of technologies that a full-stack web developer is expected to work has increased tremendously. It is no longer enough that we can write HTML and JavaScript to build a user interface, we are expected to know client-side frameworks such as Angular, React, VueJS, and so on. It is also not enough that we are proficient in enterprise Java and SQL, we are expected to know server-side frameworks such as Spring, Hibernate, Play, and so on.
In this chapter, we will introduce the following topics:
Modern full-stack web development
Web architecture patterns
Choosing the right pattern
Modern full-stack web development
If we were to even begin discussing the life of a full-stack developer, it would be worthy of a whole book by itself – so let's leave that for another day.
Let's look at a user story about a full-stack Java web application and see what is involved.
Let's use an example of developing a user management module for a typical Java web application. Let's assume that you would be writing unit test cases for the all the code hence we won't detail them out here:
You would start by designing the architecture for the feature. You would decide on the plugins and frameworks to use, patterns to follow, and so on.
You will be modeling the domain model for the feature depending on the database technology used.
Then, you would create server-side code and database queries to persist and fetch data from the database.
Once the data is ready you would implement server-side code for any business logic.
Then, you would implement an API that can be used to provide data for the presentation over an HTTP connection.
You would write integration tests for the API.
Now, since the backend is ready, you would start writing frontend code in JavaScript or a similar technology.
You would write client-side services to fetch data from the backend API.
You would write client-side components to display the data on a web page.
You would build the page and style it as per the design provided.
You would
write
automated end to end tests for the web page.
It is not done yet. Once you have tested everything works locally you would create pull requests or check-in the code to the version control system used.
You would wait for the continuous integration process to verify everything, and fix anything that is broken.
Once everything is green and the code is accepted, typically you would start the deployment of this feature to a staging or acceptance environment, either on-premises or to a cloud provider. If it is the latter you would be expected to be familiar with the cloud technologies used as well. You would also be upgrading the database schema as necessary and writing migration scripts when required.
Once the feature is accepted you might be responsible for deploying it into the production environment in a similar way, and troubleshoot issues where necessary. In some teams, you might swap the steps with other team members so that you would be deploying a feature developed by your co-worker while s/he deploys yours.
You might also be responsible, along with your co-workers, to make sure the production environment is up and running including the database, virtual machines, and so on.
As you can see it is no easy task. The range of responsibilities spawns across making stylesheet updates on the client side to running database migration scripts on a virtual machine in the production cloud service. If you are not familiar enough, this would be a herculean task and you would soon be lost in the vast ocean of frameworks, technologies, and design patterns out there.
Full stack development is not for the faint-hearted. It takes a lot of time and effort in keeping yourself up to date with various technologies and patterns in multiple disciplines of software development. Following are some of the common problems you might face as a full-stack Java developer:
Client-side development is not just about writing plain HTML and JavaScript anymore. It is becoming as complex as
server-side development with build tools, transpilers, frameworks, and patterns.
There is a new framework almost every week in the JavaScript world and if you are coming from a Java background it could be very overwhelming for you.
Container technologies such as Docker revolutionalized the software industry but they also introduced a lot of new stuff to learn and keep track of, such as orchestration tools, container management tools, and so on.
Cloud services are growing day by day. To stay on track you would have to familiarize yourself with their API and related orchestration tools.
Java server-side technologies have also undergone a major shift in recent times with the introduction of JVM languages such as Scala, Groovy, Kotlin, and so on, forcing you to keep yourself up to date with them. On the other side, server-side frameworks are becoming more feature rich and hence more complex.
The most important thing of all is the pain of making sure all of these work together well when required. It will need a lot of configuration, some glue code, and endless cups of coffee.
It's very easy to get lost here and this is where technologies such as JHipster and Spring Boot step in to help. We will see the details in later chapters but in short, they help by providing the wiring between moving parts so that you only need to concentrate on writing business code. JHipster also helps by providing the abstractions to deploy and manage the application to various cloud providers.
Web architecture patterns
The full-stack landscape is further complicated by the different web architecture patterns commonly used these days. The widely used web application architecture patterns today can be broadly classified into two—monolithic architecture and microservice architecture, the latter being the new kid on the block.
Let's take a look at the following in detail:
Monolithic architecture
Microservice architecture
Monolithic web architecture
A monolithic architecture is the most used pattern for web applications due to its simplicity in development and deployment. Though the actual moving parts will differ from application to application, the general pattern remains the same. In general, a monolithic web application may do the following:
It can support different clients such as desktop/mobile browsers and native desktop/mobile applications
It can expose APIs for third-party consumption
It can integrate with other applications over REST/SOAP web services or message queues
It can handle HTTP requests, execute business logic, access a database, and can exchange data with other systems
It can run on web application containers such as Tomcat, JBoss, and so on
It can be scaled vertically by increasing the power of the machines it runs on or scaled horizontally by adding additional instances behind load balancers
An example of a typical monolithic web application architecture would be as follows:
Let's imagine an online hotel reservation system that takes reservation orders online from customers, verifies the room availability, verifies the payment option, makes the reservation, and notifies the hotel. The application consists of several layers and components including a client-side app, which builds a nice rich user interface, and several other backend components responsible for managing the reservations, verifying payment, notifying customers/hotels, and so on.
The application will be deployed as a single monolithic Web Application Archive (WAR) file that runs on a web application container such as Tomcat and will be scaled horizontally by adding multiple instances behind an Apache web server acting as a loadbalancer. Take a look at the following diagram:
The advantages of a monolithic web application architecture are as detailed here:
Simpler to develop as the technology stack is uniform throughout all layers.
Simpler to test as the entire application is bundled in a single package making it easier to run integration and end-to-end tests.
Simpler and faster to deploy, as you only have one package to worry about.
Simpler to scale as you can multiply the number of instances behind a load balancer to scale out.
Requires a smaller team to maintain the application.
Team members share more or less the same skill set.
The technical stack is simpler and most of the times easier to learn.
Initial development is faster hence making time to market faster.
Requires simpler infrastructure. Even a simple application container or JVM will be sufficient to run the application.
The disadvantages of a monolithic web application architecture are as detailed here:
Components are tightly coupled together resulting in unwanted side effects such as changes to one component causing a regression in another and so on.
Becomes complex and huge over time resulting in slow development turnaround. New features will take more time to develop and refactoring of existing features will be more difficult due to tight coupling.
The entire application needs to be redeployed for any changes.
Is less reliable due to tightly coupled modules. A small issue in a service might break the entire application.
Newer technology adoption is difficult as entire application needs to be migrated. Incremental migration is not possible most of the time. Hence many monolithic applications end up having an outdated technology stack.
Critical services cannot be scaled individually resulting in increased resource usage as the entire application will need to be scaled.
Huge monolith applications will have a higher start-up time and high resource usage in terms of CPU and memory.
Teams will be more interdependent and it will be challenging to scale the teams.
Microservice architecture
The microservice architecture has gained momentum in recent years, and is gaining popularity in web application development due to its modularity and scalability. Microservice architecture can offer almost all the features of a monolith that we saw in the earlier section. Additionally, it offers many more features and flexibility, and hence is often considered a superior choice for complex applications. Unlike the monolithic architecture, it's quite difficult to generalize the microservice architecture as it could vary heavily depending on the use case and implementation. But they do share some common traits and they are, in general, the following:
Microservice components are loosely coupled. Components can be developed, tested, deployed, and scaled independently without disrupting other components.
Components need not be developed using the same technology stack. This means a single component can choose its own technology stack and programming language.
They often utilize advanced features such as service discovery, circuit breaking, load balancing, and so on.
Microservice components are mostly lightweight and they do a specific functionality. For example, an authentication service will only care about authenticating a user into the system.
Often has an extensive monitoring and troubleshooting setup.
An example of a microservice web application architecture would be as follows:
Let's imagine a huge online e-commerce system where customers can go through categories of merchandise, maintain favorites, add items to a shopping cart, make and track orders, and so on. The system has inventory management, customer management, multiple payment modes, order management, and so on. The application consists of several modules and components including a UI gateway application, which builds a nice rich user interface and also handles user authentication and load balancing, and several other backend applications responsible for managing the inventory, verifying payment, and managing orders. It also has performance monitoring and automatic failover for services.
The application will be deployed as multiple executable WAR files in Docker containers hosted by a cloud provider. Take a look at the following diagram:
The advantages of a microservice web application architecture are as detailed here:
Loosely coupled components resulting in better isolation, easier to test and faster to startup.
Faster development turnaround and better time to market. New features can be built faster and existing features can be easily refactored.
Services can be deployed independently making the application more reliable and make patching easier.
Issues, such as a memory leak in one of the services, are isolated and hence will not bring down the entire application.
Technology adoption is easier, components can be independently upgraded in incremental migration making it possible to have a different stack for each component.
More complex and efficient scaling models can be established. Critical services can be scaled more effectively. Infrastructure is used more efficiently.
Individual components will start up faster making it possible to parallelize and improve overall start-up.
Teams will be less dependent on each other. Best suited for agile teams.
The disadvantages of a microservice web application architecture are as detailed here:
More complex in terms of the overall stack as different components might have different technology stacks forcing the team to invest more time in keeping up with them.
Difficult to perform end-to-end tests and integration tests as there are more moving parts in the stack.
The entire application is more complex to deploy as there are complexities with containers and virtualization involved.
Scaling is more efficient but setting upscaling is more complex as it would require advanced features such as service discovery, DNS routing, and so on.
Requires a larger team to maintain the application as there are more components and more technologies involved.
