Java EE 8 and Angular

图书信息

作者	Prashant Padmanabhan
出版社	Packt Publishing
ISBN	9781788299381
出版时间	2018-01-11
字数	45.7万
分类	进口书,外文原版书,电脑,网络

读书简介

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 tested efficiently. Finishing off with concepts on securing your enterprise applications, this book is a hands on guide to building Modern Web Applications. Style and approach This is a step-by-step tutorial that explains to building modern web enterprise applications.

目录

Title Page

Copyright and Credits

Java EE 8 and Angular

Dedication

Packt Upsell

Why subscribe?

PacktPub.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

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