Home Page Icon
Home Page
Table of Contents for
Cover
Close
Cover
by Peter A. Pilgrim
Java EE 7 Developer Handbook
Java EE 7 Developer Handbook
Table of Contents
Java EE 7 Developer Handbook
Credits
About the Author
Acknowledgment
About the Reviewers
www.PacktPub.com
Support files, eBooks, discount offers and more
Why Subscribe?
Free Access for Packt account holders
Instant Updates on New Packt Books
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
1. Java EE 7 HTML5 Productivity
Java EE 7
Enhanced HTML5 support
Java EE 7 architecture
Standard platform components and APIs
New productivity themes
Refinements
Java EE Platform
Java EE Profiles
Web Profile
Enterprise Profile
A working example
Entities
Business logic
The service endpoints
A WebSocket endpoint
A RESTful endpoint
The Entity Control Boundary pattern
Summary
2. Context and Dependency Injection
Software engineering definitions
The Context and Dependency Injection service
Beans and bean types
Basic injection
Field injection
Setter injection
Constructor injection
Qualifiers
Built-in qualifiers
The CDI classpath scanning
Factory production
Generating new instances every time
Bean names and presentation views
Bean scopes
CDI initialization and destruction
The @PostConstruct annotation
The @PreDestroy annotation
Programmatic Lookup of the CDI Beans
Configuring a CDI application
Standalone CDI application
Building the standalone project with Gradle
Using the DeltaSpike CDI container tests
Injecting arbitrary objects using Producers
Advanced CDI
The lifecycle component example
Alternatives
The Arquillian test framework
A new kind of Java EE testing framework
Setting up of Arquillian
The disposable methods
CDI and crosscutting concerns
Interceptors
Decorators
Observers and events
Stereotypes
Summary
3. Enterprise Java Beans
EJB protocols
Criticism of EJB
Simplification of EJB
Features of EJB components
Session beans
Stateless session beans
Concurrency and stateless session EJBs
Stateful session beans
Singleton session beans
The lifecycle of session EJBs
Lifecycle of stateless EJBs
Lifecycle of stateful session beans
Lifecycle of singleton session beans
Business interfaces
Local access
Remote access
Access summary
No interface views
EJB references
Asynchronous invocations
The relationship between EJB and CDI containers
Lightweight scope of EJBs
Summary
4. Essential Java Persistence API 3.2
Entities
Defining Entity bean
An entity bean example
A Plain Old Java Object
A simple entity bean
Expanded entity bean definition
The @Table annotation
The @Entity annotation
The @Basic annotation
The @Column annotation
Annotating entity beans
Annotating entities with the instance variables
Annotating entities with property accessors
Comparing annotating styles
Running a simple entity bean test
The Gradle build file for the entity bean test
A stateful session bean
An entity bean integration test
A persistence context XML configuration
Arquillian configuration for the embedded GlassFish server
Running an integration test
The lifecycle of an entity bean
The new entity state
The managed entity state
The detached entity state
The removed entity state
EntityManager
Persistence context
The EntityManager methods
Persisting new instances
Removing the existing instances
Refreshing the entity bean instances
Detaching the entity bean instances
Flushing the pending instances to the database
Transactional support
Application managed transactions
Retrieving an EntityManager by injection
Retrieving an EntityManager by factory
Retrieving an EntityManager by the JNDI lookup
Moving further along with entity beans
Controlling the mapping of entities to the database table
Expanding the @Table annotation
Mapping the primary keys
The single primary key
Composite primary keys
Using the @IdClass annotation
Using the @Embeddable annotation
Using the @EmbeddedId annotation
JPQL
The dynamic queries
The named queries
The query parameters
The positional query arguments
The entity bean relationships
Mapping with the @OneToOne annotation
Mapping with the @OneToMany annotation
Mapping with the @ManyToOne annotation
Mapping with the @ManyToMany annotation
Configuration of persistence and the entity beans
The structure of the persistence unit configuration
The object-relational mapping files
Standard property configurations for the persistence units
Summary
5. Object-Relational Mapping with JPA
Adding finesse to entity beans
Field binding
Binding eagerly
Binding lazily
The trade-off between eager and lazy
Cascades onto dependent entities
Cascade operations
Removal of orphans in relationships
Generated values and primary keys
Table auto increment
Sequence auto increment
Identity auto increment
Entity relationships revisited
One-to-one mapping
Persisting one-to-one unidirectional entities
Bidirectional one-to-one-entities
Persisting one-to-one bidirectional entities
Composite foreign keys in a one-to-one relationship
One-to-many mapping
One-to-many relationship with a join column
Bidirectional one-to-many relationship
One-to-many using an explicit join table
Many-to-one mapping
Many-to-one relationship with a join column
Bidirectional many-to-one relationship
Many-to-many mapping
Bidirectional many-to-many relationship
Unidirectional many-to-many relationship
Mapping entity inheritance hierarchy
Hierarchy in a single database table
An example user story
Benefits and drawbacks of the single table strategy
Common base table hierarchy
An example user story
Benefits and drawbacks of joined Inheritance
Table-per-class hierarchy
An example user story
Benefits and drawbacks of table-per-class hierarchy
Extended entities
Mapped super-classes
Troubleshooting entity persistence
Fetch performance
Prefer lazily binding for maximum performance
Entity Relationship
Prefer orphan removal
Excessive queries
Object corruption
Summary
6. Java Servlets and Asynchronous Request-Response
What are Java Servlets?
Web containers
The lifecycle of Java Servlets
Loading Servlets
The Java Servlet initialization
The Java Servlet destruction
The Servlet request and response
HTTP Servlets
The deployment model
Getting started with Java Servlets
A simple Servlet
The URL path mapping
The Gradle build project
The containerless Java web application
Request and response
The request parameters
Headers
The request attributes
The session attributes
The Servlet context attributes
Redirecting the response
The web deployment descriptor
Mapping Java Servlets
Configuring a session timeout
Configuring MIME types
Configuring the welcome page
Configuring the error-handler pages
Annotations and the web deployment descriptor
The Servlet filters
The Servlet filter annotation attributes
The Servlet filter XML configuration
The Servlet context listener
Pluggable Servlet fragments
Ordering multiple web fragments
Asynchronous Java Servlets
The asynchronous input and output
A synchronous reader example
An asynchronous reader example
An asynchronous writer
Alignment to the containers
Aligning Servlets to the CDI container
Miscellaneous features
Mapping the URL patterns
Rules for the URL path mapping
Single thread model
Summary
7. Java API for HTML5WebSocket
The rise of WebSockets
Early web technology
Enter HTML5 and WebSockets
WebSocket Java definitions
The WebSocket protocol
Server-side Java WebSockets
@ServerEndpoint
@ServerEndpoint
@OnMessage
Invoking Java WebSocket
Running WebSocket examples
Java WebSocket API
Native formats communication
Annotated WebSockets on the server side
Lifecycle WebSocket endpoint annotations
WebSocket sessions
A Java WebSocket chat server
The server side
The web client
Asynchronous operations
Client-side Java WebSockets
@ClientEndpoint
Annotated client example
Remote endpoints
Programmatic Java WebSocket
Encoders and decoders
Summary
8. RESTful Services JAX-RS 2.0
Representational State Transfer
JAX-RS 2.0 features
Architectural style
REST style for collections of entities
REST style for single entities
Servlet mapping
Mapping JAX-RS resources
Test-Driven Development with JAX-RS
JAX-RS server-side endpoints
JAX-RS common server annotation
Defining JAX-RS resources
Testing JAX-RS resources
Path URI variables
JAX-RS annotations for extracting field and bean properties
Extracting query parameters
Extracting matrix parameters
Using default values
Extracting form parameters
Field and bean properties
JAX-RS subresources
Resolution by a subresource location
Resolution by a subresource method
Generating a JAX-RS generic response
Response builder
Response status
Generic entities
Return types
Hypermedia linking
JAX-RS client API
Synchronous invocation
Asynchronous invocation
Asynchronous JAX-RS server side endpoints
JAX-RS providers
Filters
JAX-RS filters
Server-side filters
Client-side filters
JAX-RS interceptors
Binding filter and interceptors
Dynamic binding
Summary
9. Java Message Service 2.0
What is JMS?
Messaging systems
Point-to-point messaging
Publish-subscribe messaging
JMS definitions
JMS classic API
JMS simplified API
JMS message types
A quick JMS 2.0 example
Establishing a JMS connection
Connecting to a JMS provider
Connection factories
Default connection factory
Message destinations
JMSContext
Retrieving a JMSContext
Sending JMS messages
Upgrading message producers from JMS 1.1
Sending messages synchronously
Sending messages asynchronously
JMS message headers
Setting message properties
Setting a message delivery delay
Receiving JMS messages
Upgrade from JMS 1.1
Receiving messages synchronously
Receiving messages asynchronously
Non-shared subscriptions
Shared subscriptions
Durable topic consumers
Starting and stopping connections
Redelivery of messages
Other JMS-defined properties
Message-driven Beans (MDBs)
Activation configuration property
Message selectors
JMS exception handling
Upgrading JMS 1.1 code
Establish a JMS 1.1 connection
JMS and dependency injection
Injecting CDI beans
Injection of JMSContext resources
Injecting EJB beans
Definition of JMS resources in Java EE
Summary
10. Bean Validation
Introduction to Bean Validation
New features in 1.1
A quick example
Constraint declarations
Elements of a constraint
Message property
Message property
Groups property
Payload property
List of built-in constraints
Hibernate Validator built-in constraints
Constraint violations
Applying constraint definitions
Custom validators
Groups of constraints
Class-level constraints
Partial validation
Constraint inheritance
Ordering groups of constraints
Method-level constraints
Method validation rules
Integration with Java EE
Default access to validator and validator factory
JAX-RS 2.0 integration
Summary
11. Advanced Topics in Persistence
Persistence of map collections
The MapKey relationship
The MapKey join column relationship
Calling stored procedures
Stored procedure query
MySQL remote server example
Dynamic result set retrieval
Retrieving outbound parameter values
Stored procedure query annotations
Understanding the criteria API
Criteria queries
CriteriaUpdate
CriteriaDelete
Entity graphs
Worked example of a fetch plan
Miscellaneous features
Custom JPQL functions
Down-casting entities
Synchronization of persistence contexts
Entity listeners with CDI
Native query constructor mapping
Summary
A. Java EE 7 Platform
Platform containers
Global JNDI naming
Packaging
Bean XML configuration location
Persistence XML configuration location
Upgrading to Java EE 7 from J2EE versions
Legacy application programming interfaces
GlassFish 4 reference implementation
Installing basic GlassFish
Configuring MySQL database access
Configuring command line
Default resources
B. Java EE 7 Persistence
Persistence unit
XML schema documents for Java EE 7
Properties
XML representation of object-relational mapping
JPA miscellaneous features
Converters
Native constructor results
Transactions and concurrency
Entity managers
Transactions, entity managers, and session EJBs
Stateful session beans
Concurrency access locks
Optimistic locking
Pessimistic locking
C. Java EE 7 Transactions
Transactions
Java Transaction API
Two-phase commit transactions
Heuristic failures
Local transactions
Distributed transactions
Transaction services
Container-Managed Transactions (CMT)
Bean-Managed Transactions (BMT)
Isolation levels
JNDI lookup
D. Java EE 7 Assorted Topics
Concurrency utilities
Environment reference
Application container context
Contextual tasks
JSON-P
Streaming
Parsing JSON with Streaming API
Generating JSON with Streaming API
Object model
Parsing JSON with the object model
Generating JSON with the object model
Recommended reading
Index
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Next
Next Chapter
Table of Contents
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset