Building Applications with Spring 5 and Vue.js 2

Book Image

Building Applications with Spring 5 and Vue.js 2

By : James J. Ye

Book Image

Building Applications with Spring 5 and Vue.js 2

By: James J. Ye

Overview of this book

Building Applications with Spring 5 and Vue.js 2, with its practical approach, helps you become a full-stack web developer. As well as knowing how to write frontend and backend code, a developer has to tackle all problems encountered in the application development life cycle – starting from the simple idea of an application, to the UI and technical designs, and all the way to implementation, testing, production deployment, and monitoring. With the help of this book, you'll get to grips with Spring 5 and Vue.js 2 as you learn how to develop a web application. From the initial structuring to full deployment, you’ll be guided at every step of developing a web application from scratch with Vue.js 2 and Spring 5. You’ll learn how to create different components of your application as you progress through each chapter, followed by exploring different tools in these frameworks to expedite your development cycle. By the end of this book, you’ll have gained a complete understanding of the key design patterns and best practices that underpin professional full-stack web development.

Title Page

Copyright and Credits

Copyright and Credits

Dedication

About Packt

Contributors

Preface

Free Chapter

Modern Web Application Development - This Is a New Era

Modern Web Application Development - This Is a New Era

JavaScript from a Java developer's viewpoint

Vue.js 2 - It Works in the Way You Expected

Vue.js 2 - It Works in the Way You Expected

Fundamental concepts

Behind the scene

Spring 5 - The Right Stack for the Job at Hand

Spring 5 - The Right Stack for the Job at Hand

Spring IoC and dependency injection

Spring JDBC and JPA

Spring transaction management

Put it together

TaskAgile - A Trello-like Task Management Tool

TaskAgile - A Trello-like Task Management Tool

Managing requirements in an Agile way

Writing effective user stories

Creating wireframes

Understanding Agile

Full-stack developer skillsets

Data Modeling - Designing the Foundation of the Application

Data Modeling - Designing the Foundation of the Application

Introduction to data modeling

Goals of data modeling

Conceptual data modeling with ER diagrams

Logical data modeling

Physical data modeling for RDBMS

Physical data modeling for MongoDB

Code Design - Designing for Stability and Extensibility

Code Design - Designing for Stability and Extensibility

Agile code design

Design principles and design patterns

TaskAgile code design

RESTful API Design - Building Language Between Frontend and Backend

RESTful API Design - Building Language Between Frontend and Backend

RESTful API characteristics

RESTful API design procedure

RESTful API implementation in Spring MVC

RESTful API consuming

RESTful API testing

Creating the Application Scaffold - Taking off Like a Rocket

Creating the Application Scaffold - Taking off Like a Rocket

Setting up the development environment

Creating the backend scaffold with Spring Initializr

Creating the frontend scaffold

Putting two ends together

Introducing vue-router

Fixes at the end

Forms and Validation - Starting with the Register Page

Forms and Validation - Starting with the Register Page

Building a UI with Bootstrap 4

Build registration forms with Vue.js

Validation on the frontend

Validation on the backend

Implement registration in domain model

Fixes at the end

Spring Security - Making Our Application Secure

Spring Security - Making Our Application Secure

How to secure a web application

Introducing Spring Security

Spring Security deep dive

Building the login page

Sending emails using JavaMail

Performing end-to-end integration tests

Fixes at the end

State Management and i18n - Building a Home Page

State Management and i18n - Building a Home Page

State management with Vuex

Building home page frontend

Building the home page backend

Adding i18n support with Vue-i18n

Logging SQL queries and performance tuning

Fixes at the end

Flexbox Layout and Real-Time Updates with WebSocket - Creating Boards

Flexbox Layout and Real-Time Updates with WebSocket - Creating Boards

Building the frontend of the board page

Building the backend of the board page

Implementing real-time updates with WebSocket

Fixes at the end

File Processing and Scalability - Playing with Cards

File Processing and Scalability - Playing with Cards

Building the frontend of the card modal

Building the backend of the card modal

Tracking activity asynchronously with AMQP

Fixes at the end

Health Checking, System Monitoring - Getting Ready for Production

Health Checking, System Monitoring - Getting Ready for Production

Installing as a service

Spring Boot Actuator

Monitoring with Icinga 2

Fixes at the end

Deploying to the Cloud with Jenkins - Ship It Continuously

Deploying to the Cloud with Jenkins - Ship It Continuously

Continuous delivery

Last fix before rolling out

Further reading

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Physical data modeling for RDBMS

In this stage, we will convert the logical data model into the physical data model of the target RDBMS. As mentioned, we will use MySQL and will create the physical data model using MySQL Workbench.

Here is what we are going to do:

Create a table for each entity.
Create a column for each attribute. Besides the name, we will define columns type, length, nullability, and default value.
Make primary keys auto increment.
Create indexes.

The naming convention

The naming convention of the physical data model has some differences with the naming convention of the logical data model:

We will use lowercase for tables, columns, and indexes, for example, the user table. And we will use underscore to connect multiple words, for example, the card_list table.
For foreign key definition, the key's name starts with fk_. The naming convention of the foreign keys is fk_<referencing table name>_<referenced table name>_<referencing field name>. For example, the foreign...