Log In
Or create an account ->
Imperial Library
Home
About
News
Upload
Forum
Help
Login/SignUp
Index
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
What's in Java EE 8?
Improvements in EE 8
Overview of Java SE 8
Lambdas, streams, and default methods
CDI 2.0
JSON Processing 1.1
Working with JSON documents
JSON Processing API
JSON Binding 1.0
JAXRS 2.1
Servlet 4.0
Server Push
JSF 2.3
Bean Validation 2.0
Java EE Security API 1.0
Summary
The CDI Advantage Combined with JPA
Introduction to context and dependency injection
CDI programming model
CDI for Java SE 8
RequestContext Activation
Enhancing events
Asynchronous events
Ordered events
Annotation literals
Java Persistence API (JPA)
Entities
Performing CRUD operations with entities
Entity listeners
Validations the entity
Summary
Understanding Microservices
Traditional monoliths
Need for delivering new features quicker
Team size and dependency
Multiple small units of work
Smaller code base
Coding practices
Follow domain-driven design
Document it
Build for failure
Infrastructure tooling as part of code
Single responsibility
The need for REST
Scale only what needs to scale
The bad parts, yes, there are a few
Summary
Building and Deploying Microservices
Fat JAR
Fat JAR approach
Skinny WAR
Examples using Payara Micro
Building our services
Running our services
MicroProfile
Java EE already has support
WildFly Swarm
Spring Cloud
Docker containers
Working with distributed teams
Building custom images
Running multiple containers
Fat JAR or Skinny WAR with Docker
The choice
Summary
Java EE Becomes JSON Friendly
REST prefers JSON
JSON, a first-class citizen
JSON in databases
No more third-party libraries
JSON processing
JSON-P 1.1
JSON Pointer and JSON Patch
JSON merge patch
JSON Collectors
JSON binding
Similar to JAXB with default mappings
Standardizes current solutions (Jackson, Gson, and so on)
Mapping between classes and JSON
Customisation APIs
Few tips in practice
Summary
Power Your APIs with JAXRS and CDI
Resources
URI templates
Matching requests to resource methods
Providers
Entity providers
Exception mapping
Client API
Targets
Reactive clients
Filters and interceptors
Validation
Asynchronous processing
Server-Sent Events
WebSockets
Context
Swagger
API
Maven plugin
Summary
Putting It All Together with Payara
Building an Issue Management System (IMS) backend
Using Java EE 8 technologies
Defining the data model
Building microservices using REST
Swagger documentation
Using JPA for persistence
Deploying on Payara
Uber JAR and Skinny WARs
Running multiple microservices in Docker
Learning to use the new features of Payara Micro
Extras
CDI event bus
Tips and tricks
Summary
Basic TypeScript
Getting started with TypeScript
Why use it?
Features
Visual Studio Code
IntelliSense
Debugging
SCM support
Terminal
Hello World example
Using variables, types, and functions
Type inference
Using const
Using let
Using functions
Arrow functions
Working with classes and interfaces
Interface
Classes
Inheritance
Working with arrays
Summary
Angular in a Nutshell
Understanding Angular
Anatomy of a component
Components live and die
Component in code
Pipes
Modules
Bootstrapping process
Angular 2 and beyond
Angular CLI
Project structure
Rapid development
Managing packages
Dependencies
Bootstrap dependency
A better Hello World
Modules
Components
Handling events
Data binding
One way
Two way
Services
Routes
routerLinkActive
Building a project
Setup and run sample
Introduction to PrimeNG
Summary
Angular Forms
Two approaches to forms
Template-driven forms
Reactive forms
Understanding forms with an example
Building custom forms with validations
Checking the state of a form
Forms with NgModel
Reactive forms
Setting up forms with FormBuilder
Adding validations
Creating a custom validator
Grouping controls
Setting and patching values
Handling forms in Angular
Gaining more control with reactive forms
Summary
Building a Real-World Application
Building an Issue Management System frontend
Setup
Structuring the project
Working independently of the backend
Data models
Securing the application
Issue lists and details
Rendering data with templates
Injectable service
Issue creation and updates
Reactive forms
Validation
Issue comments
Chatting on an issue
Production-ready build
Summary
Connecting Angular to Java EE Microservices
Integration with microservices
Docker – focusing made easy
Verifying the running services
Cross Origin Resource Sharing (CORS)
JSON communication
Observables in Angular
Dynamic updates using Observables
Going to production
Deploying on the cloud using AWS
Launching the Amazon EC2 instance
Installing Docker on Amazon EC2
Docker release
Summary
Testing Java EE Services
Testing strategies for microservices
Understanding the testing pyramid
Unit testing
Integration testing
End-End testing
Microservice testing challenges
Contract testing
Balancing act of tests
Testing in practice
Integration testing with Arquillian
Acceptance testing with Cucumber
Feature file
Step definitions
Summary
Securing the Application
Securing the application
JSON Web Tokens
Token structure
Generating the token
IMS Security
Verifying the token
Consuming token in Angular
Route Guards
Exchanging tokens
Injecting an authorization header
Neither in Java EE nor MicroProfile
General tips
Summary
Other Books You May Enjoy
Leave a review - let other readers know what you think
← Prev
Back
Next →
← Prev
Back
Next →