Address instance

Aggregate average response time (AART)

    Application assembler, deployment roles

    external requirements

        conflict and redundant

        dependencies

        references

    packaging

    Bean-Managed Transaction (BMT)

    stateful session beans

        OrderProcessorBMTBean.java

        OrderProcessorBMTBeanTxnInterceptor.java

        OrderProcessorBMTClient.java

    Business Process Execution Language (BPEL)

    Client applications

    application client container

    client application architecture

        business process

        using JPA entities

        Web service

    Java EE technologies

    JSF

    web-based application architecture

        using JPA entities

        with local invocation

    Client view

    development-Web service

        application running

        compile

        CreditServiceClient.java

        output

    Proxy classes

        creation

        stub sources

        Web service client wizard

        @WebServiceRef annotation

    session bean

    WSDL document

    Container-Managed Transaction (CMT)

    ACID test

        atomicity

        consistency

        durability

        isolation

    Application-managed EntityManager

    attribute definitions

    client and bean transaction states

    data filtering

        CartItem entity instances

        createCustomerOrder() method

        initialize() method

        persistEntity() method

    getRollbackOnly() method

    Java facade

    setRollbackOnly() method

    stateless session beans

        benefits

        Java facade

        limitations

        OrderProcessorCMTBean.java

        OrderProcessorCMTClient.java

    Contexts and Dependency Injection (CDI)

    alternatives

    application scope

    architecture

    beans and beans.xml

    beans.xml

    compilation process

        open project menu

        project build

        verification

    Context aspect

    conversation scope

    dependency injection

    dependent pseudo-scope

    deploying process

        alternatives

        any-qualifier client

        producers

        user-defined qualifier client

    EJB relationship

    features

    @Inject-dependency injection

        bean constructor

        client and class

        field injection

        initializer method

    interaction-session beans

        limitations

        mapping

        resolve

        scope

    Java EE architecture

    NetBeans project

    prerequisites

    producers

    RedWine class

    request scope

    resolution

        @Any

        @Default

        @Name

        @New

        qualifier type

        unsatisfied/ambiguous dependency

        WhiteWine class

    session scope

    specification

    structure

    Web Beans

    Customer entity

    Deployment. See Packaging and deployment processes

    Enterprise JavaBeans (EJB)

    client applications

    performance testing (see Performance testing, EJB)

    session beans

        BMT demarcation

        CMT demarcation

        implicit vs. explicit commit

    EJB architecture

    administration (Glassfish application server)

        administration console

        services tab

        testing page

    advanced persistence concepts

    CDI

    client application

    component model

    container

    development model

        configuration by exception

        declarative metadata

        location transparency

        multiuser security

        persistence

        portability

        reusability

        scalability

        transaction

    distributed computing model

    EJB 3 architecture

    EJB 3 simplified development model

        default behavior

        dependency injection

        interceptors (callback methods)

        POJO implementation

        XML and annotations

    Glassfish

    installing NetBeans IDE and integrated GlassFish server

    integrating session beans, entities, message-driven beans, and web services

    JCP as JSR

    JPA

    message-driven beans

    NetBeans IDE download

    packaging and deployment

    performance and testing

    progression (EJB Spec)

        EJB 1.0

        EJB 1.1

        EJB 2.0

        EJB 2.1

        EJB 3.0

        EJB 3.1

        EJB 3.2

    roles

        application assembler

        deployer

        enterprise bean provider

    runtime environments

    session beans

    software installation and configuration

    testing (NetBeans IDE and GlassFish Installation)

        creation

        new servlet wizard

        run (serlvet)

        sample project

        starting and shutting down

        test servlet creation

        Windows Firewall

    transaction service support

    troubleshooting

        errors

        GlassFish server’s test page

        “localhost” hostname

        No Compatible JDK was found

        “8080” port

        “wine order” mail

    web services

    EJB Lite

    EJB message-driven beans (MDBs) See also Message-Oriented Architecture

    asynchronous message consumer

    classes

        @MessageDriven annotation

        onMessage() method

        parameters

        requirements

        simple use case

        StatusMailerBean class

    client programs

        context menu

        setting

        StatusMailerClient servlet

    client view

    compile, deploy and test

        bulid menu option

        client programs

        IDEs

        JMS and JavaMail resources

        prerequisites

        sample directory

        session beans MDBs and clients

        verfication

    configuration properties

        @ActivationConfigProperty annotation

        destination

        EJB-JMS version

        message acknowledgment service

        @MessageDriven annotation

        selector

        subscription durability

    dependency injection

    exception handling

    interceptors

    lifecycle callback methods

    use of

    EJB stateless session beans

    bean classes

        CreditCheckEndpointBean.java

        validateCC method

        @WebMethod annotation

        @WebService annotation

    classes

    endpoint interface

    SEI

    Embeddable EJB Container

    Derby database

    JPA persistence unit

    unit test methods

        JNDI

        testCreateCustomerOrder() method

        testCreateIndividual() method

    Enterprise Archive (EAR) file

    Entities. See Java Persistence API (JPA)

    Entity class

    FetchType.EAGER

    FetchType.LAZY

    @GeneratedValue annotation

    Grinder

    agent process

    console

    definition

    properties

        grinder.consoleHost

        grinder.logDirectory

        grinder.logProcessStreams

        grinder.runs

        grinder.script

        grinder.threads

    report statistics

    TCP Proxy module

    test scripts

    URL execution

    wine store JSF application

        addWineToCart() method

        findAll() method

        getWineDisplayList() method

        JOINED inheritance strategy

        JPA entities

        processOrder() method

        SINGLE_TABLE entity inheritance strategy

    worker process

    Hyper Text Transfer Protocol (HTTP)

    Integrated development environment (IDE)

    Java API for RESTful Web Services (JAX-RS)

    Java API for XML Registries (JAXR)

    Java API for XML Web Services (JAX-WS)

    Java Architecture for XML Binding (JAXB)

    Java Archive (JAR) file

    Java Community Process (JCP)

    Java EE deployment process

    application

    containers

    library components

        bundled libraries

        install libraries

        library version

        shared classes

    module types

        application client module

        EJB module

        overview

        persistence unit

        resource adapters

        WAR file-EJBs

        web application module

    server

    Java EE platform

    EJB interacts

    JAXB

    JAXR

    JAX-RS

    JAX-WS

    JSR 181

    SAAJ

    specifications

    Java EE technologies

    evolution of

    Java Servlets

    MVC pattern

    scriplets

    JavaMail resources

    administrator console

    authentication

    creation

    GlassFish application server

    TopicConnectionFactor

    topics

    Java Message Service (JMS). See also JavaMail resources

    application architecture

        classes

        queues

        squeues

        topics

    architecture

    messaging system

    types

    Java Naming and Directory Interface (JNDI)

    Java Persistence API (JPA)

    coding requirements

        default and non-default constructor

        instance variables vs. JavaBean property accessors

        java io Serializable interface

    compiling, deploying, and testing

        Clean and Build menu option

        client programs

        database connection and a database schema

        Deploy menu option

        EJB façade

        PersistenceSamples project

        prerequisites

    composite keys

        @Embeddable class

        @EmbeddedId annotation

        embedded key (@EmbeddedId)

        fields (Id and relationship)

        @IdClass

        mapping relationships

        serializable Java class

    composite primary key

        @Embeddable annotation

        @EmbeddedId annotation

        @IdClass

    Customer.java

        additional field types

        @Basic annotation

        @Column annotation

        default configuration

        vs. EJB 2.x

        @Entity annotation

        entity with defaults

        @Id annotation

        simple JavaBean

        @Table annotation

    CustomerOrderManager

        addCustomerOrder() and removeCustomerOrder() methods

        Address.java

        CustomerOrder.java

        @OneToOne

        persistence.xml

        service methods

        Stateless session

    entities, services of

        application (sample)

        build, application

        client program, execution

        compile sources

        database connection

        Java class library

        SINGLE_TABLE inheritance execution

        testing

        in web environment

        WineApp DB and connection

    entity beans

    entity data access

    entity life cycle

        detached entity instance

        entity classes

        entity instance management

        new entity instance

        removed entity instance

    EntityManager

        definition

        Java SE service client

        JNDI

        persistence context

        session bean, container injection

        transaction support

    entity relationship

        cascading operations

        fields

        Lazy vs. Eager field bindings

        @ManyToMany annotation

        @ManyToOne

        @OneToMany

        @OneToOne

    field

    @GeneratedValue (autogenerated values)

        @SequenceGenerator

        @TableGenerator

    inheritance hierarchy

        abstract entity

        address, embedded

        collection fields

        @ElementCollection

        @Embeddable

        @Embedded

        JOINED, root entity

        mapped superclass

        non entity class, embeddable

        non entity, mapped superclass

        root entity extends superclass

        single-value, non entity

    instance variable annotation

        source code

        @Transient

    interceptors (callback method)

    JPQL

        binding query parameters

        bulk update and delete operations

        complex queries

        dynamic queries

        @NamedQuery

        queries

    mapping entity inheritance

        abstract entity

        address instances

        bidirectional relationship

        client code

        design time consideration

        design time, JOINED

        @DiscriminatorColumn annotation

        @DiscriminatorValue annotation

        entity instances

        entity type

        Façade

        @GeneralValue annotation

        initialisation

        intermediate entity, SINGLE_TABLE Inheritance Hierarchy

        intermediate entity, JOINED

        JavaServiceFacadeClient

        @JoinColumn annotation

        leaf entity, SINGLE_TABLE Inheritance Hierarchy

        leaf entity, JOINED

        ManyToOne field

        object/relational inheritance

        OneToMany field

        O/R implementation

        performance impact

        root entity, SINGLE_TABLE Inheritance Hierarchy

        root entity, JOINED

        sample hierarchy

        Single-Table-per-Class

        Single-Table-per-Outermost

        stand alone entity, JOINED

        TABLE_PER_CLASS, design considerations

        TABLE_PER_CLASS, intermediate entity

        TABLE_PER_CLASS, leaf entity

        TABLE_PER_CLASS, performance

        TABLE_PER_CLASS, root entity

        type enum

        type JOINED

        unidirectional relationship

    mapping entity inheritance; stand alone entity

    native SQL queries

    O/R mapping

        @Column annotation

        complex mappings

        persistence framework

        @Table annotation

    persistence archive

    persistence vs. adaption

    POJOs

    polymorphic relationships and mapping

    polymorphic JPQL queries

    primary and nested foreign key (see Java Persistence API (JPA), composite keys)

    primary key

        @GeneratedValue

        Java type

        single field

    property access or annotation

        access type

        getAddressId()

        setZipCode()

        side-effect code

    property name

    query criteria

    @Version (optimistic locking)

    Java persistence query language (JPQL)

    binding query parameters

    bulk update and delete operations

    complex queries

    dynamic queries

    @NamedQuery

    queries

    JavaServer Faces (JSF)

    architecture

        FacesServlet

        JSP pages/Facelets

        lifecycle phases

        managed beans

        Navigation model

    compiling

    deploy and testing

    EJB back-end applications

        addToCart() method

        cartItems page

        Links page

        login page

        newCustomer registration page

        notification page

        page flow

        search page

        wineList page

    tools and components

    wine store application

        details page

        home page

        list page

        login page

        notification page

        registration page

        run target

        search page

        shopping cart page

    Java Specification Request (JSR)

    Java Transaction API (JTA)

    @JoinColumn information

    JPA Entities

    container-managed vs. application-managed persistence context

    JTA vs. resource-local entity managers

    transaction-scoped persistence context vs. extended persistence context

    vs. transaction context

    JSP Standard Tag Library (JSTL)

    JSR 181 (Web Services Metadata for the Java Platform)

    JUnit

    build and test methods

        cascading MERGE operation

        prerequisites

        sample application

        source compilation

        return managed objects

        in WineAppServiceTest.java

    WineAppServiceTest

    LiCustomer

    Message-driven beans (MDBs)

    Message-Oriented Architecture See also Java Message Service (JMS)

    Model-View-Controller (MVC) pattern

    NetBeans

    OrderProcessFacadeBean

    performCreditCheck() method

    processOrder() method

    sendPOtoMDB() method

    Packaging and deployment processes See also Java EE deployment process

    application assembler

    application servers and platform independence

        deployment plan

        MBean

        performance and features

    assembler

        components

        defining module-level deployment descriptors

        EAR file

        JAR files-components

        specific tasks

        tasks and deliverables

    deployer

        application server

        containers

        external references

        module description

        overview

        specific tasks

        tasks and deliverables

        unpackaging

    deployment tools

    EJB JAR file

        arbitrary classes

        naming scope

    exercises

    Java EE module types

    Java EE role

    JPA

    persistence unit

        directories

        naming scope

        points

    provider

    roles

        application assembler

        deployer

    Performance, EJB

    application usage

        real think time

        sleep time

        zero think time

    Grinder toolkit (see Grinder)

    performance metrics

        AART

        response time

        throughput

        total transactional rate

    test metrics

        calibration

        quality of a sample

        sample size

        users, representative number

    Performance testing, EJB

    actual test runs

    calibration

    database connection

    GlassFish server

    Grinder

    Grinder console

    multiple-table

        AART comparison

        all-user results

        TTR comparison

        100-user results

    preliminary tests

    sample size analysis chart

    simulated users

    single-table

        AART comparison

        all-user results

        TTR comparison

        100-user results

    test environment

    test scripts

    Plain old Java objects (POJOs)

    REpresentational State Transfer (REST)

    constraints

    differences (RESTful vs. SOAP)

    HTTP

    RESTful Web services

    RESTful Web services

    CreditCheck

    differences (RESTful vs. SOAP)

    HTTP method-CRUD operation

    @Retention annotation

    Reverse engineering

    Service endpoint interface (SEI)

    Session bean

    Session beans. See also Stateless session beans

    3-tier architecture

        rich client

        web application

    client view

        local and remote clients

        SearchFacade

        SearchFacadeClient

        ShopperCountClient

        ShoppingCartClient

        types

    compile

        build application

        SessionSamples project

        verfication

    deploy

        GlassFish application

        menu option

    EJB JAR (.jar) files

    Java components

    models

    prerequisites

    run-client program

        execution

        SearchFacadeClient servlet-output

        servlet

    singleton session beans

        bean class

        bean-managed concurrency

        business interface

        business methods

        callback methods

        concurrency management

        container-managed concurrency

        error handling

    stateful beans

        bean class

        business interface

        business methods

        callback methods

        exception handling

        interceptors

    timer service

        calendar-based time expression

        examples (calendar-based time expression)

        LogShopperCount.java

        persistence

        real-time events

    types

    use of

    ShoppingCartBean

    addWineItem() method

    findCustomer() method

    getCartItems() method

    removeWineItem() method

    sendOrderToOPC() method

    Simple Object Access Protocol (SOAP)

    elements

    message

    SOAP with Attachments API for Java (SAAJ)

    Stateless session beans

    asynchronous methods

    bean class

    business interface

        annotations

        client application

        rich client-remote interfaces

        SearchFacadeLocal.java

        SearchFacade session bean

        web client-local interfaces

    business methods

        SearchFacadeBean.java

        wineSearch() method

    callback method

    dependency injection

    elements

    interceptors

        InvocationContext

        methods

        preceding code

        tasks

    Transaction

    ACID properties

    distributed transactions

    in EJB

        CMT support

        JTA transactions

        resource-local transactions

        transactional context

    with JPA Entities

    JTA

    two-phase commit protocol

    Universal Description, Discovery, and Integration (UDDI)

    Web Archive (WAR) file

    Web services. See also Java EE platform

    architecture

    client view

        Java client

        session beans

        WSDL document

    comile-session bean

        build application

        verification

        WebServiceSamples project

    definition

    deploy session bean

    EJB stateless session beans

        bean class

        classes

        endpoint interface

        SEI

    JAR

    prerequisites

    REST

        constraints

        differences (RESTful vs. SOAP)

        HTTP

        RESTful Web services

    service consumer

    SOAP

        elements

        message

    test-credit service

        CreditService

        harness page

        SOAP request and response messages

    UDDI

    uses

    WSDL

        <binding> element

        categories

        <definitions> element

        <message> element

        <portType> element

        <service> element

        <types> element

    Web Services Description Language (WSDL)

    <binding> element

    categories

    <definitions> element

    <message> element

    <portType> element

    <service> element

    <types> element

    WineApp database

    Wines Online application

    back-end components

        credit service

        customer facade component

        e-mail service

        order processing facade component

        order processing service

        persistence services

        search facade component

        shopping cart component

    business process

    component and service interaction

    components and services

        credit service

        customer facade component

        database schema

        e-mail service

        order processing facade component

        order processing service

        persistence services

        search facade component

        shopping cart component

    EJB

        database connection

        Deploy and Run

        prerequisites

        source compilation

        TransactionSamples project

    packaging, assembly and deployment aspects

        database connection

        EJB web service configuration

        JMS and JavaMail resources

        open sample application

        prerequisites

        servlet output

        [email protected] account