Mastering Java EE Development with WildFly电子书

Title Page

Copyright

Credits

About the Author

About the Reviewers

www.PacktPub.com

Customer Feedback

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

Introducing Java EE and Configuring the Development Environment

JSON and HTML5

WebSockets

Simplified JMS 2.0 API

Groundwork for Cloud environments

Batch applications

Updated web profiles

Concurrency utilities

Context dependency injection

Java API for RESTful web services (JAX-RS) 2.0

Servlet 3.1

JNDI

Asynchronous invocation

Timers

EJB Lite

Development in WildFly

Operating system

Java

Application server

Build system

Structure of the exercises

Tests

IDE

Netbeans IDE

IntelliJ IDEA

Eclipse IDE

Importing exercises

Debug exercises

Summary

Working with Dependency Injection

Dependency injection 1.0 for Java

Context and dependency injection 1.1 for Java

Injection and contexts

Managed beans

Producer methods and fields

Bean types

The BeanManager object

CDI

Unmanaged

Enabled and disabled beans

The injection target

Scopes

Session beans

Service Provider Interfaces

Events

Event qualifiers

Observer methods

Container lifecycle events

Utilities

Decorators

Enabled decorators

And more...

Model

TransientReference

Interceptors 1.2

Interceptor classes

Associating an interceptor class with the target class

Default interceptors

Interceptors for lifecycle callbacks

Interceptor bindings

Common annotations for the Java platform 1.2

Common annotation

SQL utilities

Web console for monitoring beans

Summary

Persistence

Common JPA annotations

Named queries

Relationships

Cascade on one-to-one and one-to-many

Cascading the one-to-one persist operation

Cascading the one-to-one merge operation

Cascading the one-to-one delete operation

The one-to-one delete orphan cascading operation

Cascade on Many To Many

Cascade of the persist many to many operation

Dissociation of one side in the many to many association

Tricks for many to many CascadeType.REMOVE

Conclusion

News from Java EE 7

Result set

Stored procedures

Converters

Named entity graphs

JPQL improvements

API Criteria bulk operations

Unsynchronized persistence context

Indexes

Packages and entities

DataSources and connectors

Deployment of the DataSource

DS file

XA and non XA

Activating the deployer

XML configuration

Web console

Summary

Implementing Business Logic

Scopes in EJB

Singleton

Local and remote interfaces

Remote clients

EJB client library

Remote naming project

Combining the remote naming project and EJB client library

Local and remote homes

The session context

Transactions

Exceptions

Transaction management annotation

Transaction attributes

Security

EJB container configuration

Session beans

Stateless

Stateful

Singleton

Entity beans

Remote

Thread pools

IIOP

In VM remote interface invocations

Summary

Working with Distributed Transactions

Transaction overview

BMT and CMT

Descriptor configuration

Remote transaction

Transactions and resource managers

ACID properties

Enterprise concurrent API

Managed executor service

Set of threads

Transactional tasks

Levels and transaction isolation problems

Isolation violations

Dirty read

Non-repeatable read

Phantom read

Isolation levels

Read committed

Read uncommitted

Repeatable read

Serializable

Transaction models

Flat transactions

Savepoints

Nested transactions

Saga

Chained transactions

Distributed transactions and the JTA

Distributed transaction scenarios

Multiple databases

Message queue and database

Multiple application servers

Transaction started by the client

Two-phase commit

Emulating two-phase commit

Summary

Creating REST Services

Services

REST and HTTP

GET methods

POST methods

PUT methods

HEAD methods

OPTIONS method

DELETE method

Using RESTEasy directly

REST application and components

Container components

Container request filter

Container Response Filter

Name binding

Providers

Client components

Client Request Filter

Client Response Filter

Interceptors

Reader interceptors

Writer interceptors

Features

Contracts

Dynamic features

Forms and beans

Selenium and Drone

Summary

Implementing WebSockets

History of the web

Implementation engine

A first basic example

WebSocket container

WebSocket session

Security

HTTPS

Security realm

Custom HTTPS configuration

WebSocket HTTPS connection

Negotiated subprotocols

Configurators for requests and responses

Request informations and parameters

Path parameters

Request parameters

Other features

Container configuration

Runtime configuration

Client WebSockets

Basic client

Async client

Message handlers

Whole

Partial

Custom message handler registration

Ajax versus WebSockets

Summary

Working with Messaging

Queues and topics

Queues

Creating the queue from the web console

Creating the queue using CLI and Maven WildFly plugin

Creating the queue through an Arquillian test case

Create the Java client for the queue

Topics

Creating the topic from the web console

Creating the topic with the Maven WildFly plugin

Creating the topic through an Arquillian test case

Creating the Java client for the topic

Remote clients

Message listeners

The JMS context

Summary

Implementing a Mail Client

Mail client API

Java example

Creating a client with Java SE

Configuration of the mail server

SMTP local mail server

Summary

Asynchronous REST

Asynchronous resources

REST timeouts

REST server callbacks

Connection callbacks

Asynchronous clients

Asynchronous client callbacks

Summary

Asynchronous EJB

The asynchronous annotation

Timers and schedulers

Timer service

File configuration

Timer configuration

Access timeout

Old specs compliant

Stateful timeout

Schedulers

Transactions and timers

Message driven beans

Message driven bean context

Acknowledge mode

Summary

Batches and Workflows

Workflows and BPM

Batch models

Chunks

Chunk and ETL

Chunk Reader

Chunk processor

Chunk writer

Client

Batchlets

Decision

Mail example

Client

Job context and step context

Metrics and step execution

Listeners

Job listener

Step listener

Chunk listener

Batch property

Checkpoint Algorithm

Checkpoint timeout

Exceptions

Monitoring of the batches

Deploying the workflows

Summary

Working with Servlets and JSP

Undertow

Servlets and web components

Ports and security

Request and response

Cookies

JSP pages

EL Expressions

Cookies operations

Web session and other scopes

Creation of a cookie

Cookies and JavaScript

Tests with Selenium

Error mappings

File configuration

File upload

Filters

HTTP servlet response wrapper

Event listeners

Session listener

Session ID listener

Servlet request listener

Servlet request attribute listener

Session attribute listener

Session binding listener

Session activation listener

Servlet context listener

Servlet context attribute listener

Asynchronous servlet

Non blocking I/O

Protocol handler

Dynamic context registration

External resources and themes

Web fragments

Security

File descriptor security

Programmatic security

Form login

Create a custom JAAS module

Summary

Writing a JSF Application

MVC

Components

Use

Structure

Configuring and developing your application

Internationalization

Navigation

Navigation inside the page

Phases and listeners

Working with Facelets

Web templates

Custom functions

Custom tags

Security

ACL permissions and PicketBox

Summary

Sharing the Web Sessions

Clustering

Infinispan

Distributable applications

Cluster domains

Customize the domains

Summary

WildFly in Cloud

OpenShift

WildFly installation

Command-line tools

Exposed services

Summary

Share your Data

Infinispan and the cluster

LRU and LIRS

JGroups configuration

Singleton HA Services

Writing the Service

Writing the Activator

Client for the Service

Summary

Deployment

Deployment types

Enterprise packages

Web archive

Java archive

EJB

Client application

Simple Java library

Resource adapters

Extension packages

Datasources

Service archives

Deployment tools

Administrator tools

HA deploy

Development tools

Summary

Working with OSGi

Modules

OSGi in WildFly

Installation

Deployment of bundles

Maven bundle plugin

Summary