Building Applications with Spring 5 and Vue.js 2
更新时间：2021-06-24 18:18:00
最新章节：Leave a review - let other readers know what you thinkcoverpage
Title Page
Dedication
About Packt
Why subscribe?
Packt.com
Contributors
About the author
About the reviewer
Packt is searching for authors like you
Preface
Who this book is for
What this book covers
Download the example code files
Download the color images
Conventions used
Get in touch
Reviews
Modern Web Application Development - This Is a New Era
Introduction
JavaScript from a Java developer's viewpoint
Functions and methods
Objects and classes
Objects properties and property attributes
Prototype and inheritance
Scope and closure
The this keyword
Hoisting
ES6 basics
Block scoping let and const
Classes
Enhanced object literals
Arrow functions
No lexical this
No prototype object
Default parameter value
Rest parameters
Spread syntax
Destructuring assignment
Object destructuring
Array destructuring
Nested destructuring
Rest elements
Function parameters destructuring
Template literals
Modules
Export
Import
Promises
Summary
Vue.js 2 - It Works in the Way You Expected
Fundamental concepts
Vue instance
Components
Vue instance life cycle
Directives
Filters
Mixins
Plugins
Behind the scene
Reactivity system
Summary
Spring 5 - The Right Stack for the Job at Hand
Spring IoC and dependency injection
Spin up the Spring container
Annotation-based configuration
Bean declaration
Dependency injection
Constructor-based injection
Setter-based/method-based injection
Field-based injection
Best practices of dependency injection
Spring MVC
Java EE Servlet
DispatcherServlet
Views
Filters
Spring JDBC and JPA
JDBC driver
Spring JDBC
Hibernate
Spring AOP
Concerns
Aspects
Join points
Advices
Pointcuts
AOP proxy
Weaving
@SecurityCheck
AOP execution flow
Spring transaction management
PlatformTransactionManager
Declarative transaction management
Spring Boot
Starters
Autoconfiguration
Put it together
Place code together
Add APIs
HTTP client – axios
Package app.messages
Summary
TaskAgile - A Trello-like Task Management Tool
Managing requirements in an Agile way
Levels of requirements
Writing a requirement in an Agile project
Writing effective user stories
Tips on writing user stories
TaskAgile user stories
Users
Teams
Boards
Card Lists
Cards
Creating wireframes
Understanding Agile
The Agile manifesto
Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan
Full-stack developer skillsets
Requirement analyzing
Communication
Wireframes creating
Data modeling
API designing
Frontend coding
Backend coding
Unit tests and automation tests
Continuous integration
Server monitoring and architecture awareness
Summary
Data Modeling - Designing the Foundation of the Application
Introduction to data modeling
Data modeling stages and deliverables
Conceptual data modeling
Logical data modeling
Physical data modeling
Terminologies used in data modeling
Entities
Attributes
Relationships
Primary keys
Foreign keys
Goals of data modeling
Completeness
Minimal redundancy
Extensibility
Consistency
Conceptual data modeling with ER diagrams
Crow's foot notation
The naming convention
TaskAgile conceptual data models
Subtypes and supertypes
Logical data modeling
Physical data modeling for RDBMS
The naming convention
Physical data modeling for MongoDB
Summary
Code Design - Designing for Stability and Extensibility
Agile code design
What is code design?
Traditional angle
A second angle
Differences between the two angles
Levels of code design
Architecture level
Abstraction level
Implementation level
Devil in the details
Symptoms of bad design
Rigidity
Fragility
Opacity
Immobility
Viscosity
Agile code design practices
Architecture level
Abstraction level
Implementation level
Design principles and design patterns
SOLID design principles
The Single Responsibility Principle (SRP)
The Open-Closed Principle (OCP)
The Liskov Substitution Principle (LSP)
The Interface Segregation Principle (ISP)
The Dependency Inversion Principle (DIP)
TaskAgile code design
Layered architecture
Hexagonal architecture
Summary
RESTful API Design - Building Language Between Frontend and Backend
RESTful API characteristics
REST architectural constraints
Client-server
Stateless
Cache
Uniform interface
Layered system
Code-on-demand (optional)
RESTful interface constraints
Identifications of resources
Manipulation of resources through representations
Self-descriptive messages
Hypermedia as the engine of the application state
Opinionated RESTful API
Richardson Maturity Model
Level zero
Level one
Level two
Level three
HATEOAS or not?
What is HATEOAS?
Why you won't need HATEOAS?
Opinionated RESTful API characteristics
Resource-centric
Identifiable through URIs
Defining operations via HTTP methods
Use of HTTP status codes
Versioning
Stateless
Pagination
Searching and sorting
Security
RESTful API design procedure
Finding out the requirements
Identifying resources
Fleshing out API details
RESTful API implementation in Spring MVC
MVC annotations
Spring HATEOAS
Spring REST Docs
RESTful API consuming
HTTP client
Server-side consuming
RESTful API testing
Unit testing of the Messages App
Summary
Creating the Application Scaffold - Taking off Like a Rocket
Setting up the development environment
Creating the backend scaffold with Spring Initializr
File structure
Committing and pushing
Running the application
Creating the frontend scaffold
File structure
Cleaning up and reorganizing
Didn't we miss something?
Putting two ends together
Building with a single command
Bridging the communication
Introducing vue-router
Spring MVC request mapping
Fixes at the end
Summary
Forms and Validation - Starting with the Register Page
Building a UI with Bootstrap 4
Install and use Bootstrap
Implement the UI of the register page
Create layout diagram
TDD of the register page
Implement the UI
Build registration forms with Vue.js
Write test code for the form
Implement the form bindings
Handle form submit
Test the submitForm() method
Implement the submitForm() method
Communicate with the backend
Test the register() method
Implement the register() method
Validation on the frontend
Test the data validation
Validate form data with Vuelidate
Improve the tests
Validation on the backend
Creating RegistrationPayload
Create RegistrationPayloadTests
Create RegistrationPayload
Create RegistrationApiController
Create RegistrationApiControllerTests
Implement RegistrationApiController and its dependencies
Implement registration in domain model
Implement the UserService application service
Create UserServiceImplTests
Create MailManager
Build domain events
Implement the UserServiceImpl class
Implement RegistrationManagement
Create RegistrationManagementTests
Implement the RegistrationManagement class
Implement RegistrationManagement dependencies
Implement UserRepository
Create HibernateUserRepositoryTests
Implement HibernateUserRepository
Fixes at the end
Summary
Spring Security - Making Our Application Secure
How to secure a web application
Authenticating users
Single Sign-On
OAuth 2.0
Authorizing users
Preventing attacks
Introducing Spring Security
Spring Security core concepts
Spring Security deep dive
Setting up Spring Security
Spring Security filter chain
Spring Security in action
Unauthenticated request on public resource
Unauthenticated request on protected resource
Spring Security authentication in depth
SecurityContextPersistenceFilter
UsernamePasswordAuthenticationFilter
Spring Security authorization in depth
FilterSecurityInterceptor
Method security
Building the login page
Implementing the login page UI
Implementing PasswordEncryptorDelegate
Implementing authentication in the backend
Implementing AuthenticationFilter
Implementing UserDetailsService
Implementing UserDetails
Updating SecurityConfiguration
Sending emails using JavaMail
MailManager and its dependencies
Testing DefaultMailManager
Implementing DefaultMailManager
Implementing AsyncMailer
Application properties
Performing end-to-end integration tests
Correcting the port
Using Page Objects
Autogenerating user test data
Testing in specific order
Fixes at the end
Summary
State Management and i18n - Building a Home Page
State management with Vuex
Drawbacks of traditional state management
Modern state management
Vuex in a nutshell
Building home page frontend
UI of the home page
Home page layout and components
Data structure and state management
Backend APIs
Creating a personal board API
Creating the team API
Creating team board API
A combined API to get the user's name boards and teams
Implementing home page frontend
Implementing the services and Vuex store
Implementing popup windows with Bootstrap modal
Building the home page backend
Domain models
API handlers
Application services
Repositories and the generic save() method
Adding i18n support with Vue-i18n
Logging SQL queries and performance tuning
Fixes at the end
Summary
Flexbox Layout and Real-Time Updates with WebSocket - Creating Boards
Building the frontend of the board page
The UI of the board page
The layout of the board page
Designing the overall layout
Implementing drag and drop
Building the backend of the board page
APIs for the board page
Changing positions in batch
Implementing real-time updates with WebSocket
Introduction to SockJS
Introduction to Spring WebSocket
The channel-based communication pattern
Frontend implementation of the real-time client
Authenticating a real-time client with JWT
Server implementation of channel handlers
Fixes at the end
Summary
File Processing and Scalability - Playing with Cards
Building the frontend of the card modal
The UI of the card modal window
The layout of the card modal window
Router for board URL and card URL
Implement auto-resize of card title editing
Implementing support of the Markdown format
Implementing file uploads
Building the backend of the card modal
APIs for the card modal
Get card API
Change card title API
Change card description API
Add comment API
Get activities API
Add attachment API
Get attachments API
Saving the uploaded file
Generating thumbnails for images
Storing files to S3
Tracking activity asynchronously with AMQP
Adding card cover images and activity tracking
Fixes at the end
Summary
Health Checking System Monitoring - Getting Ready for Production
Installing as a service
Spring Profile
The dev profile
The test profile
The end-to-end test profile
The staging and production profile
Spring Boot Actuator
The health endpoint
The info endpoint
The metrics endpoint
The environment endpoint
Endpoint security
Using a different port and firewall
Using the same port and Spring Security
Using a custom filter
Monitoring with Icinga 2
Fixes at the end
Summary
Deploying to the Cloud with Jenkins - Ship It Continuously
Continuous delivery
Registration API integration test
Maturity and cost
Refactoring E2E tests
Running E2E tests during the writing
Running E2E tests before pushing the code to VCS
Run E2E tests after deploying to staging
Last fix before rolling out
Let's ship it
Preparing a Dockerfile
Preparing a Jenkinsfile
Server preparation
Installing MySQL
Installing RabbitMQ
Installing NGINX and the SSL certificate
Building with Jenkins
Summary
Further reading
Other Books You May Enjoy
Leave a review - let other readers know what you think
更新时间：2021-06-24 18:18:00