Index
A
abandonAllChanges()
ABS JP QL function
AbstractQuery
@Access annotation
accrueEmployeeVacation()
ACID transaction
Activation process
addEmployee()
addItems()
addKeySubgraph()
addNamedEntityGraph()
addNamedQuery()
Advanced ORM
additional elements
optionality
read-only mappings
compound primary keys
SeeCompound primary keys
converting entity state
SeeConverting entity state
derived identifiers
SeeDerived identifiers
embedded objects
bidirectional relationships
ContactInfo
Phone class
relationship override
inheritance
SeeInheritance)
multiple tables
embedded type
meet-in-the-middle variety
multiple secondary tables
@PrimaryKeyJoinColumn annotation
@SecondaryTable annotation
@Table annotation
table structure
two tables entity
relationships
SeeAdvanced relationships)
table and column names
Advanced relationships
join columns
EMPLOYEE table
with join table
many-to-one/one-to-one relationships
self-referencing
join tables
many-to-one mapping
one-to-many relationship
unidirectional/bidirectional
mapping relationship state
association class
intermediate entity
with join table
orphanRemoval element
Aggregate queries
AVG
COUNT
Department entity
GROUP BY clause
HAVING clause
MAX
MIN
SELECT, FROM and WHERE clauses
SUM
syntax of
alias()
ALL JP QL expression
AND JP QL operator
ANY JP QL expression
Application component models
Application-managed entity manager
Application-managed persistence contexts
archiveConversations()
Arquillian framework
assignEmployeeToProject()
@AssociationOverride annotation
@AttributeOverride annotation
AuditService bean
AVG function
AVG JP QL aggregate function
B
Backus-Naur form (BNF)
@Basic annotation
Bean-managed transactions (BMT)
beans.xml descriptor
BETWEEN JP QL operator
Bidirectional one-to-one relationship
Building and deployment
deployment classpath
packaging options
EJB JAR
persistence archive
web archive
persistence unit scope
Bulk update and delete queries
C
@Cacheable annotation
CacheStoreMode.USE option
Caching
cache interface
cache mode properties
JPA
layers
shared cache
dynamic cache management
static configuration
Callback methods
definition
enterprise contexts
entity listeners
SeeEntity listeners)
cancel() method
Canonical metamodel
Case expressions
CASE JP QL expression
CDI and contextual injection
beans
injection and resolution
producer methods
entity managers references
producer code and qualifier annotation definitions
@Secure annotation
qualified injection
scopes and contexts
CDI beans
ClassLoader.getResource()
CleaningFeeManagement
clear() method
COALESCE expression
COALESCE JP QL expression
coalesce() method
Collection mapping
DEPT_EMP join table
duplicates
embeddable type
EMPLOYEE and DEPARTMENT entity tables
EMP_PHONE collection table
entity attribute
EntityType
enumerated types
keys and values
List
order by entity/element attribute
persistently ordered lists
PrintQueue to PrintJob
many-to-many relationship
null values
one-to-many mapping
relationships and element collections
embeddables and basic types
EMPLOYEE entity table
Overriding collection table columns
VacationEntry embeddable class
rules
sets
String keys
Collection-valued association
join tables
many-to-many mappings
one-to-many mappings
unidirectional collection mappings
@Column annotation
columnDefinition element
Column mappings
@ColumnResult annotation
commit() method
Compound identifier
Compound primary keys
embedded Id class
EMPLOYEE entity
Id class
CONCAT JP QL function
Concurrency
entity access
entity operations
Constraint annotation
Constraint implementation class
Constructor injection
Container-managed
Container-managed entity managers
Container-Managed Transactions (CMTs)
EJB
transactional interceptor, CDI Bean
transaction attributes
Contexts and Dependency Injection (CDI)
@Convert annotation
@Converter annotation
Converting entity state
attribute conversion
element collections
embedded attributes
limitations
automatic conversion
converter creation
AttributeConverter interface
Boolean-to-Integer converter
converters and queries
COUNT DISTINCT JP QL aggregate function
COUNT function
COUNT JP QL aggregate function
createCriteriaUpdate()
createEmployee()
createEntityGraph()
createEntityManagerFactory()
createNamedQuery()
createNativeQuery()
createQuery()
Criteria API
building expressions
case expressions
downcasting
in expressions
function expressions
JP QL to CriteriaBuilder aggregate function mapping
JP QL to CriteriaBuilder function mapping
JP QL to CriteriaBuilder predicate mapping
JP QL to CriteriaBuilder scalar expression mapping
literals
outer join criteria
parameter expressions
predicates
subqueries
bulk update and delete
canonical metamodel
generation tools
metamodel class for employee
@StaticMetamodel annotation
strongly typed approach
CriteriaBuilder interface
CriteriaQuery and Subquery objects
dynamic queries
FROM clause
fetch joins
inner and outer joins
GROUP BY and HAVING clauses
metamodel API
objects and mutability
ORDER BY clause
parameterized types
path expressions
query definition, creation
query roots
SELECT clause
selecting multiple expressions
selecting single expressions
using aliases
select query clause methods
string-based API
syntax and usage
WHERE clause
CriteriaBuilder interface
CriteriaQuery object
CriteriaUpdate object
CURRENT_DATE JP QL function
CURRENT_TIME JP QL function
CURRENT_TIMESTAMP JP QL function
D
Data access object (DAO)
Data Definition Language (DDL)
Data mappers
DataSource interface
Declarative container services
Delete queries
delimited-identifiers element
Dependency lookup
EJBContext lookup()
EJB dependency
Dependency management and CDI
declaring dependencies
persistence context referencing
persistence unit referencing
server resources referencing
dependency injection
field injection
setter injection
dependency lookup
resource reference annotations
Dependent entity
Derived identifiers
alternative
compound identifier
dependent entity
dept attribute
embeddable id class
DeptId class
ProjectId class
@JoinColumn annotation
parent entity
ProjectId and DeptId Id classes
relationship attribute
rules
shared mappings
simple integer identifier
single attribute
trivial mapping
Derived identifiers, alternative
Detached entity
detach() operation
eager loading configuration
EmployeeService bean
entity manager per request
JSP page
lazy-loading attributes
listEmployees.jsp
merge strategy
beginning session
completing session
conversation pattern
HttpSessionBindingListener callback
save() method
session façade
stateful session bean
web application frameworks
web tier
merging
addr object
cascade setting
entity state prior
IllegalArgumentException exception
managed instance
persistence context
persist() method
phone/department entity
MVC architecture
parkingSpace attribute
persistence context
phones relationship
transaction view
triggering lazy loading
detach() operation
dot operator (.)
Downcasting
E
Embeddable contactInfo class
@Embedded annotation
@EmbeddedId annotation
Embedded mappings
emp-classes.jar
EmployeeDebugListener class
EmployeeDebugListener.prePersist() method
EMPLOYEE entity table
EmployeeId Id class
EmployeeService class in Java EE
persistence unit
servlet
session bean
emp-persistence.jar
Enterprise application archive (EAR)
Enterprise application testing
acceptance tests
functional test
integration test
Java SE clients
JUnit test framework
outside components
server deployment
server environment
test-driven development
unit test
SeeUnit test)
Enterprise JavaBean (EJB)
container-managed transactions
JAR
model
Enterprise JavaBeans query language (EJB QL)
Entity
creation
granularity
identity
persistability
transactionality
Entity graphs
accessing named entity graphs
addNamedEntityGraph() method
annotation
attribute graphs
definition
inheritance
map key subgraphs
@NamedEntityGraph
subgraphs
API
addAttributeNodes()
addSubgraph()
creation
inheritance
map key subgraph
root entity class
createEntityGraph()
default fetch graph
domain model subset
fetch graphs
load graph
state
types
Entity listeners
CDI beans
default
element
multiple entity listeners
Entity manager
application-managed entity manager
container-managed entity manager
extended entity manager
transaction-scoped
createEntityManagerFactory()
createQuery()
detached entity
SeeDetached entity)
dynamic query
EmployeeService
EntityManagerFactory
find()method
flexible transaction propagation
javax.persistence.EntityManager
javax.persistence.EntityManagerFactory
lifecycle of
named query
objects and concepts
operations
cascade persist
cascade remove()
clear() method
employee/address entities
find() method
logical relationship annotations
persist() method
remove() method
persistence context
persistence units
queries
remove() method
size and complexity
synchronization
cascade settings
components
emp object
flush() operation
IllegalStateException exception
phone objects
ps object
remove() operation
unmanaged entity
transaction management
SeeTransaction management)
transactions
updation
EntityManagerFactory()
EntityManagerFactory addNamedQuery()
EntityManager.find()
EntityManager instance
EntityManager.lock()
EntityManager.persist()
EntityManager.refresh()
EntityManager.remove()
Entity metadata
annotations
configuration
XML
Entity read-only
@EntityResult annotation
Entity state
field access
mixed access
property access
EntityTransaction interface
@Enumerated annotation
Enumerated types
@Even constraint annotation
exclude-unlisted-classes
executeUpdate()
EXISTS JP QL operator
Extended entity manager
Extended persistence contexts
addEmployee()
EmployeeService
logging department changes
logTransaction()
persistence context collision
persistence context inheritance
UserTransaction.begin()
F
fetch() method
Field injection
@FieldResult annotation
findAll() method
find() method
Floating point column types
flush() operation
Foreign key constraint
FROM clause
definition
fetch joins
identification variables
inner and outer joins
joins
SeeJoins)
Functional tests
Function expressions
function() method
G
@GeneratedValue annotation
Generation processor
getDepartment() call
getEntityGraph() method
getEntityManagerFactory() call
getIdentifier()
get() method
getOutputParameterValue()
getPersistenceUnitUtil()
getPersistenceUtil()
getProperties()
getResultList()
getResultStream()
GROUP BY clause
H
HAVING clause
I
@Id annotation
@IdClass annotation
Identifier generation
automatic Id generation
database identity
database sequence
@GeneratedValue annotation
strategies
table
Address entities
allocationSize element
columns
id storage
initialValue element
name element
SQL
table element
INCREMENT BY clause
Inheritance
class hierarchies
abstract and concrete classes
java object model
mapped superclass
non-entity classes
transient classes
mixed inheritance
models
SeeInheritance models)
Inheritance models
joined strategy
single-table strategy
ContractEmployee entity
data sample
discriminator column
discriminator value
EMPLOYEE entity class
persistence classes
polymorphic queries
table-per-concrete-class strategy
Inheritance relationships
initialize() method
init() method
IN JP QL operator
in() method
Integration test
components and persistence
container-managed entity managers
embedded EJB container
lifecycle methods
transaction management
SeeTransaction management)
entity manager
database connection minimization
persistence class
query execution
switching configurations
tearDown()
test setup and teardown
UserService bean
vs
. unit test
frameworks
Arquillian framework
JPA-unit
Spring TestContext
IS EMPTY JP QL operator
isLoaded()
isLoaded(Object)
IS NOT EMPTY JP QL
IS NOT NULL JP QL
IS NULL JP QL
J, K
jar-file element
Java Application Components model
JavaBean
Java Connector Architecture (JCA)
Java Database Connectivity (JDBC)
Java Data Objects (JDO)
Java Development Kit (JDK)
Java EE 8
components
stack
Java EE default resources
Java 2 Enterprise Edition (J2EE)
Java Naming and Directory Interface (JNDI)
Java persistence API (JPA)
configuration
EJB 3.0/JPA 1.0
entity
creation and transaction management
CRUD operation
granularity
identity
implementation
manager
SeeEntity manager)
metadata
persistability
persistence archive
persistence unit
transactionality
history of
integration/testability
Java support persistence
data mappers
EJB
java data objects (JDO)
JDBC
proprietary solutions
JPA 2.0
JPA 2.1
JPA 2.2 and EJB 3.2
mobile entity
nonintrusiveness
object query
ORM
benefits of
class representation
definition
inheritance
relationship
OSS project
POJO persistence
relational databases
Java Persistence Query Language (JP QL)
aggregate queries
application
bulk update/delete statement
application
bulk removal of
entities A/B
find() operation
issues
operation sequences
relationship maintenance
REQUIRES_NEW transaction
transaction-scoped persistence contexts
Criteria API
delete queries
description
domain model
dynamic named query
EntityManagerFactory addNamedQuery()
getEntityManagerFactory()
dynamic query definition
createQuery() method
GET/POST request
malicious attack
named parameters
OR condition
query engine
salary information
security threat
string value
EJB QL
Employee instance
entities joins
@Entity annotation
filtering
named query
definition
Employee.findAll
EntityManager interface
execution
multiple Entities
@NamedQuery annotations
positional parameters
string concatenation
object model
parameter types
binding
date/calendar
department entity
dept parameters
named query definition
setParameter() method
TemporalType enumeration
WHERE clause
performance and responsiveness
bulk update and delete operations
named queries
persistence provider
report queries
stateless session bean
vendor hints
query execution
getResultList()
getSingleResult()
grouping expressions/multiple functions
iteration
NonUniqueResultException exception
NoResultException exception
optimization
pagination
query timeout
result type
SELECT query
setLockMode() method
unassignedQuery object
uncommitted changes
Untyped result
query hints
query parameters
select query
SeeSelect queries)
single entity type
terminology
update queries
JavaServer Faces (JSF)
JavaServer Pages (JSP)
JavaServer Pages Standard Tag Library (JSTL)
Java support persistence
data mappers
enterprise JavaBeans
Java data objects
JDBC
proprietary solutions
Java Transaction API (JTA)
javax.persistence.EntityManager
javax.persistence package
javax.persistence.query.timeout property
@JoinColumn annotation
Joined strategy
joinMap()
join() method
Joins
conditions
fetch
inner
JOIN operator and collection association fields
JOIN operator and single-valued association fields
multiple joins
WHERE clause
map
outer
@JoinTable annotation
joinTransaction() call
JPA ORM architecture
JPA-Unit framework
JP QL
SeeJava Persistence Query Language (JP QL)
JTA transactions
JUnit test framework
L
Lazy fetching
Lazy relationships
LENGTH JP QL function
Lifecycle callbacks
callback methods
definition
enterprise contexts
inheritance
entity listeners
CDI beans
default
inheritance
multiple entity listeners
lifecycle events
inheritance
invocation order
PostLoad
PrePersist and PostPersist
PreRemove and PostRemove
PreUpdate and PostUpdate
Lifecycle events
PostLoad
PrePersist and PostPersist
PreRemove and PostRemove
PreUpdate and PostUpdate
validation
Lifecycle management
LIKE JP QL operator
Literal values
loadEmployee()
@Lob annotation
LOCATE JP QL function
Locking
optimistic locking
advanced modes
optimistic failures
read locking
versioning system
write locking
pessimistic locking
modes
pessimistic failures
pessimistic forced increment locking
pessimistic scope
pessimistic timeouts
read locking
write locking
Logical annotation
logTransaction()
Loose coupling
LOWER JP QL function
M
Managed classes and mapping
attribute element
embedded object mappings
association-override
attribute-override
embedded element
entity listeners
exclude-default-listeners
exclude-superclass-listeners
identifier mappings
embedded-id element
id element
id-class
inheritance mappings
association-override
attribute-override
discriminator-column element
discriminator-value element
inheritance element
lifecycle events
named entity graphs
relationship and collection mappings
element-collection
many-to-many mapping
many-to-one mapping
one-to-many mapping
one-to-one mapping
simple mappings
basic mappings
transient element
version element
tables
@ManyToMany annotation
Many-to-many relationship
@ManyToOne annotation
MAX function
MAX JP QL aggregate function
MEMBER OF JP QL operator
merge() operation
Metamodel API
MIN function
MIN JP QL aggregate function
Mixed inheritance
Mixed strategies
Mocking
Model-View-Controller (MVC)
MOD JP QL function
multiselect()
N
Named entity graphs
@NamedNativeQuery annotation
@NamedQuery annotation
Named stored procedure query
NameValidator class
NameValidator.validateName()
NOT EXISTS JP QL operator
NOT IN JP QL operator
NOT JP QL operator
NOT LIKE JP QL operator
NOT MEMBER OF JP QL operator
Null constraints
NULLIF JP QL expression
O
Object Database Connectivity (ODBC)
Object-oriented database (OODB)
Object-relational mapping (ORM)
benefits of
class representation
definition
embedded object
Address embedded type definition
address information
address shared by two entities
@AttributeOverride annotation
description
in multiple entities
entity state
field access
mixed access
property access
impedance mismatch
inheritance
mapping primary key
identifier generation
SeeIdentifier generation)
overriding primary key column
primary key types
mapping simple types
@Basic annotation
column mapping
enumerated types
large objects
lazy fetching
persistable types list
temporal types
transient state
mapping to table
persistence annotation
relationships
cardinality
collection-valued associations
SeeCollection-valued association)
directionality
lazy relationships
ordinality
roles
single-valued associations
SeeSingle-valued association)
on() method
@OneToMany annotation
One-to-many relationship
@OneToOne annotation
Open source software (OSS)
OptimisticLockException
Optimistic locking
advanced modes
optimistic failures
read locking
versioning system
write locking
Optimistic read locking
Optimistic write locking
Optional mappings
ORDER BY clause
OR JP QL operator
Orphan removal
P
Page Controller
Parameter expressions
Parent entity
PartTimeEmployee.checkVacation()
Passivation method
persist() operation
Persistence annotation
Persistence archive
@PersistenceContext annotation
Persistence context collision
Persistence context inheritance
Persistence unit
@PersistenceUnit
Persistence unit configuration
class element
command-line persistence properties
data source
EmployeeService
managed classes
explicitly listed classes
jar-file element
local classes
mapping files
mapping files
persistence provider
properties element
provider element
shared cache mode
system classpath
transaction type
validation mode
Persistence unit scope
PersistenceUnitUtil
PersistenceUtil
Pessimistic forced increment locking
Pessimistic locking
modes
pessimistic failures
pessimistic forced increment locking
pessimistic scope
pessimistic timeouts
read locking
write locking
Pessimistic read locking
Pessimistic write locking
Physical annotation
Plain Old Java Object (POJO)
PostActivate method
@PostConstruct
PostLoad callback
PostPersist events
PostUpdate callback
Predicates
PrePassivate method
PrePersist event
PreUpdate events
@PrimaryKeyJoinColumn annotation
Primary key types
PrintJob entity
processAllChanges()
Producer fields
Producer method
public void foo() {}
public void foo(Object o) {}
Q
Qualifier annotation
Query
entity graphs
SeeEntity graphs)
SQL
SeeSQL queries)
@QueryHint annotations
Query Language
SeeJava Persistence Query Language (JP QL)
Query.setHint()
Query.setLockMode()
R
Range variable declarations
Read-only mappings
Refresh() method
entity state
Relational databases
resetSyncTime()
@Resource annotation
Resource reference annotations
@Retention policy
Runtime schema generation property differences
S
save() method
saveChangesToEmployee()
Scalar expressions
CASE expressions
description
function
literals
native database functions
Schema generation
columnDefinition element
definition
deployment properties
generation input
generation output
floating point columns
foreign key constraints
generation process
indexes element
mapping annotations
null constraints
string-based columns
unique constraints
@SecondaryTable annotation
selectCase() method
SELECT clause
constructor expressions
definition
entities and objects
multiple expressions
path expressions
single expressions selection
using aliase
select() method
Select queries
FROM clause
getResultList()
identification variables
inheritance and polymorphism
downcasting
QualityProject and DesignProject
subclass discrimination
ORDER BY clause
scalar expressions
SeeScalar expressions)
SELECT clause
SQL statement
WHERE clause
SeeWHERE clause)
@SequenceGenerator annotation
Sequence-generator element
Service Provider Interface (SPI)
Servlets
conversational state maintaining
definition
HTTP session
Session beans
definition
singleton session beans
definition
lifecycle callbacks
stateful session beans
checkout()
definition
lifecycle callbacks
@Remove annotation
shopping cart implementation
stateless session beans
business interface
definition
HelloService interface
lifecycle callbacks
without interface
SessionContext instance
setFirstResult()
setFlushMode()
setLockMode()
setMaxResults()
setParameter()
Setter injection
setUp() method
Shared cache
cache interface
dynamic cache management
EntityManagerFactory.getCache()
mode
static configuration
Single-table strategy
Singleton session beans
Single-valued association
bidirectional one-to-one mappings
join columns
many-to-one mapping
one-to-one mappings
SIZE JP QL function
SOME JP QL expression
Spring TestContext
SQL queries
advantage
definition
execution
INSERT and DELETE statements
JDBC queries
JPA
JP QL
parameter binding
result set mapping
column aliases
compound keys
definition
foreign keys
inheritance
multiple result mapping
non-entity types
scalar result columns
@SqlResultSetMapping annotation
stored procedures
definitions
JPA 2.1
mapping
result set parameter types
scalar parameter types
@SqlResultSetMapping annotation
SQRT JP QL function
Stateful session beans
Stateless session beans
SeeSession beans
String-based API
subquery() method
SUBSTRING JP QL function
SUM function
SUM JP QL aggregate function
T
@Table annotation
@TableGenerator annotation
Table-per-concrete-class strategy
Target foreign key
@Temporal annotation
Temporal types
testAuthenticateInvalidUser()
testAuthenticateValidUser()
Test-driven development (TDD)
@Transactional annotation
Transactional interceptors
Transaction association
@TransactionAttribute annotation
Transaction demarcation
Transaction management
ACID transactions
bean-managed transactions
stubbed usertransaction
test execution
UserTransaction interface
BMT
container-managed transactions
benefits
business method
EJB transactions
transactional interceptors
transaction attributes
enterprise transactions
CMTs,
SeeContainer-Managed Transactions (CMTs)
transaction demarcation
JTA
application-managed persistence context
persistence context collision
persistence context inheritance
transaction-scoped persistence context
unsynchronized
local transactions
properties
resource-local transactions
begin()method
EntityTransaction interface
getRollbackOnly() method
getTransaction() method
Java EE environment
rollback/entity state
session beans and persistence operations
Transaction propagation
Transaction rollback
Transaction-scoped
Transaction-scoped entity managers
Transaction-scoped persistence contexts
Transaction synchronization
@Transient annotation
Transient superclass
TRIM JP QL function
U
Unidirectional One-to-Many Relationship
Unified Modeling Language (UML)
Unit tests
entities
business methods
in components
data validation and transformation
property methods
setId() method
entity manager
authenticate() method
MockEntityManager class
standard interfaces
UserService class
Unsynchronized persistence contexts
Untyped maps
Update queries
UPPER JP QL function
URL-to-String converter
UserTransaction interface
Utility classes
PersistenceUnitUtil
PersistenceUtil
V
Validation
constraints
constraint annotations
creation
groups
implementation classes
enabling validation
entity
groups
invoking validation
javax.persistence.validation.mode
JPA
lifecycle validation groups
multiple groups
validation-mode element
Validation-mode
@Version annotation
Version-locking fields
W
Web archive (WAR)
WHERE clause
ANY, ALL and SOME expressions
basic expression form
BETWEEN expressions
collection expressions
definition
EXISTS expressions
IN expressions
input parameters
LIKE expressions
subqueries
X, Y, Z
XML mapping files
converter element
disabling annotation
metadata-complete attribute
xml-mapping-metadata-complete element
entity-mappings
generator and query element
named-native-query
named-query
named-stored-procedure-query
sequence-generator
sql-result-set-mapping
table-generator element
header file
managed classes and mapping
SeeManaged classes and mapping)
mapping file defaults element
access
catalog element
package element
schema element
metadata
persistence unit defaults element
access element
cascade-persist element
catalog element
delimited-identifiers
entity-listeners element
schema element
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.