Java EE 8 and Angular : a practical guide to building modern single-page applications with Angular and Java EE / Prashant Padmanabhan.

Format:

Book

Author/Creator:

Padmanabhan, Prashant, author.

Language:

English

Subjects (All):

AngularJS (Software framework).

Java (Computer program language)--Handbooks, manuals, etc.

Java (Computer program language).

Physical Description:

1 online resource (348 pages)

Edition:

1st edition

Place of Publication:

Birmingham, England : Packt Publishing, 2018.

System Details:

text file

Summary:

Learn how to build high-performing enterprise applications using Java EE powered by Angular at the frontend About This Book Leverage Java EE 8 features to build robust back end for your enterprise applications Use Angular to build a single page frontend and combine it with the Java EE backend Practical guide filled with ample real-world examples Who This Book Is For This book is for Java EE developers who would like to build modern enterprise web applications using Angular. No prior knowledge of Angular is expected. What You Will Learn Write CDI-based code in Java EE 8 applications Build an understanding of Microservices and what they mean in Java EE context Use Docker to build and run a microservice application Use configuration options to work effectively with JSON documents Understand asynchronous task handling and writing REST API clients Explore the fundamentals of TypeScript, which sets the foundation for working on Angular projects Use Angular CLI to add and manage new features Use JSON Web tokens to secure Angular applications against malicious attacks In Detail The demand for modern and high performing web enterprise applications is growing rapidly. No more is a basic HTML front-end enough to meet customer demands. This book will be your one stop guide to build outstanding enterprise web applications with Java EE and Angular. It will teach you how to harness the power of Java EE to build sturdy back ends while applying Angular on the front end. Your journey to building excellent web enterprise applications starts here! The book starts with a brief introduction to the fundamentals of Java EE and all the new APIs offered in the latest release. Armed with the knowledge of Java EE 8, you will go over what it's like to build an end to end application, configure database connection for JPA, and build scalable microservice using RESTful APIs running in docker containers. Taking advantage of Payara Micro capabilities, you will build an Issue Management System, which will have various features exposed as services using Java EE backend. With a detailed coverage of Angular fundamentals, the book will expand the Issue Management System by building a modern single page application frontend. Moving forward you will learn to fit both the pieces together i.e. the frontend Angular application with the backend java EE microservices. As each unit in a microservice promotes high cohesion, you will learn different ways in which independent units can be te...

Contents:

Cover

Title Page

Copyright and Credits

Dedication

Packt Upsell

Contributors

Table of Contents

Preface

Chapter 1: 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

Chapter 2: 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

Chapter 3: 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

Chapter 4: 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

Chapter 5: 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

Chapter 6: 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

Chapter 7: 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

Chapter 8: 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

Chapter 9: 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

Components

Handling events

Data binding

One way

Two way

Services

Routes

routerLinkActive

Building a project

Setup and run sample

Introduction to PrimeNG

Chapter 10: 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

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

Chapter 11: 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

Issue comments

Chatting on an issue

Production-ready build

Chapter 12: 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

Chapter 13: 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

Chapter 14: 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

Other Books You May Enjoy

Index.

Notes:

Includes index.

Description based on online resource; title from PDF title page (EBC, viewed February 22, 2018).

ISBN:

9781788291200

1788291204

OCLC:

1022785970