Abstract Window Toolkit (AWT)

AgeCalculationListener.calculateAge() method

Applet containers

Application client container (ACC)

Application programming interface (API)

@AroundConstruct method

@AroundInvoke method

Aspect-oriented programming (AOP)

Asynchronous JavaScript and XML (Ajax)

    definition

    JSF

    Plain HTTP calls vs. Ajax HTTP calls

    XMLHttpRequest

Atomicity, consistency, isolation, durability (ACID) properties

Attributes

    @Basic Annotation

    @Column annotation

    @Enumerated

    Java type

    @Temporal

    @Transient

Authorization

    declarative authorization

        @DeclareRoles annotation

        InventoryEJB.addItem() method

        ItemEJB

        @PermitAll and @DenyAll annotations

        @RolesAllowed annotation

        security annotations

        stateless bean declaring roles

    programmatic authorization

Backing beans process

    application scope

    BookController

    client’s session

    definition

    flash scope

    flow scope

    handling exceptions and messages

    @javax.enterprise.inject.Model

    JSF and EJBs

    life cycle and callback annotations

    programming model

    renaming

    requests

    requirements

    views

Bean-managed concurrency (BMC)

Bean-managed transactions (BMT)

Bean validation

    address bean

    AddressIT integration test

    application of

    client

    compile and test

    constraints

        anatomy of

        built-in

        calculateTotalAmount method

        class-level constraint

        composition

        ConstraintValidator context

        deployment descriptor

        design decision

        element types

        error messages

        groups

        implementation

        inheritance

        method-level constraint

        multiple constraint

        NotNull annotation

        URL constraint annotation

        URL constraint implementation

        validation algorithm

    customer bean

    CustomerIT integration test

    database

    @Email constraint

    interoperability

    layers validation

    Maven directory structure

    specification

        features

        history of

        implementation

        packages

    validation APIs

        buildDefaultValidatorFactory method

        ConstraintViolation interface

        ExecutableValidator interface

        groups

        methods

        property

        validator interface

        Validator.validate() method

        values

    @ZipCode constraint

Binary large objects (BLOBs)

book.buy() method

BookController backing bean

BookEJBIT integration test

Book entity

    CDI DatabaseProducer

    DatabasePopulator and data source

    GlassFish

    Main class

    maven-compiler-plugin

    Maven conventions

    named query and bean validation constraints

    persistence unit

    stateless session bean

    tx.begin() and tx.commit() transactional demarcation

book.isbn

BookIT Integration Test

Business-to-business (B2B) integration

calculateAge() method

calculateTotalAmount method

CanonicalModelProcessor

Cascading Style Sheets (CSS)

<c:catch>

<c:choose>

CD-BookStore

    Book POJO

    BookService

    BookServiceIT class

    compile, run, and test

    IsbnGenerator

    logger

    main class

    MockGenerator

    NumberGenerator interface

    qualifiers

    trigger

<c:forEach>

<c:if>

clear() method

Client.target() method

closeConnection method

commandButton

Command tags

Common Gateway Interface (CGI)

Compatibility Test Kit

<composite:actionSource>

<composite:attribute>

<composite:clientBehavior>

<composite:editableValueHolder>

<composite:extension>x

<composite:facet>

<composite:implementation>

<composite:insertChildren>

<composite:insertFacet>

<composite:interface>

<composite:renderFacet>

<composite:valueHolder>

Container-managed concurrency (CMC)

Container-managed transaction (CMT)

    application exceptions

    createBook() method

    demarcation policy

    @javax.ejb.TransactionAttribute annotation

    MANDATORY attribute

    NEVER attribute

    NOT_SUPPORTED attribuute

    REQUIRED attribute

    REQUIRES_NEW attribute

    rollback operations

    stateless bean

    SUPPORTS attribute

    system exceptions

Context and dependency injection (CDI)

    aim of

    bean

        alternatives

        anatomy

        BookService

        constructor

        default injection

        @Default qualifier

        disposers

        @EightDigits qualifier

        expression language

        @Inject

        injection point

        ISBN implementation

        LegacyBookService

        multiple qualifiers

        non-ambiguous injection

        NumberGenerator interface

        @NumberOfDigits

        producer methods

        scopes

        @ThirteenDigits qualifier

    BookServiceIT integration test

    CD-BookStore

        Book POJO

        BookService

        BookServiceIT class

        compile, run, and test

        IsbnGenerator

        logger

        main class

        MockGenerator

        NumberGenerator interface

        qualifiers

        trigger

    decorator

    events

        addBook method

        bookAddedEvent

        book removed event method

        BookService

        fire() method

    features

    interceptors

        binding

        chaining

        class interceptor

        life cycle

        priority value

        target class

    main class

    managed bean

        components

        definition

        deployment descriptor

        interceptors

        life cycle

        loose coupling/strong typing

        scopes

        services

    packages

    reference implementation

    standard Maven directory structure

Converters

    custom converters

    standard converters

CORBA

<c:otherwise>

createCd() method

createConnection() method

createCustomer() method

createNewBook() method

Create, read, update, delete (CRUD)

createSession() method

<c:set>

cURL

<c:when>

Data definition language (DDL)

DataValidationListener class

DataValidationListener.validate() method

DebugListener class

Declarative programming

deleteBook()method

Derby

    Cloudscape

    customer table

    database creation

    dblook output

    embedded and network server

    installation

    SQL select statement

Derby process

detach(Object entity) method

Development environment

    Derby

        Cloudscape

        customer table

        database creation

        dblook output

        embedded and network server

        installation

        SQL select statement

    GlassFish

        admin console

        administration

        application server

        architecture

        asadmin CLI

        history

        installation

        subprojects

        update

    JDK

    JUnit

        assert methods

        calculateAge() method

        customer class

        features

        fixtures

        history

        integration

        launching

        test methods

    Maven

        artifacts

        history

        installation

        Java EE application

        plug-ins and life cycle

        project descriptor

        project modularity

        usage

doCreateBook() method

Document Object Model (DOM)

document type definition (DTD)

EJB container

em.flush() method

em.persist() method

Enterprise application integration (EAI)

Enterprise JavaBeans (EJBs)

    anatomy

        bean class

        business interfaces

        elements

        JNDI name

        @Local and @Remote annotations

        local/remote interface

        no-interface view

        stateless

        web services interface

    architecture layering

    asynchronous

    CDI

    dependency injection

    deployment descriptor

    @EJB annotation

    EJBContainer

    EJB Lite

    embedded container

    features

    JNDI

    layering

    @LocalBean annotation

    naming context

    package

    paradigm

    SessionContext interface

    singleton

        BMC

        caching system

        chaining

        client access

        CMC

        @ConcurrencyManagement annotation

        concurrent access

        implementation

        initialization

        Java Class

        @Stateless annotation

    specification

        entity beans

        features

        GlassFish

        packages

        RMI and JTA

        SOAP/HTTP

    stateful beans

        checkout() method

        customer logs

        interaction

        one-to-one correlation

        passivation and activation

        shopping cart

    stateless beans

        Book object

        clients

        ItemEJB bean

        name parameter

        object modeling

        persistence context

        service architecture

        @Stateless annotation

    types

@EntityListeners annotation

EntityManager.clear() method

EntityManager.contains()method

EntityManager.createNamedQuery() method

EntityManager.createNativeQuery() method

EntityManager.createQuery() method

EntityManager.detach(customer) method

EntityManagerFactory.getCache().contains() method

EntityManager.find() method

EntityManager.flush() method

EntityManager.merge() method

EntityManager.persist() method

EntityManager.remove() method

Entity relationships

    bidirectional association

    cardinality

    database mapping

    fetching

    JPA

    many-to-many bidirectional

    mappedBy element

    one-to-many unidirectional

        database structure

        foreign keys

        join table

        @JoinTable annotation

        JPA annotations

        Order entity

        OrderLine

    one-to-one unidirectional

        Address entity

        ADDRESS table

        Customer attribute

        Foreign Key

        @JoinColumn

        JPA

    ordering

        @OrderBy annotation

        @OrderColumn

    unidirectional relationship

@ExcludeDefaultListeners

executeUpdate() method

Executive committee (EC)

Expression language (EL)

    book.buy()

    #{book.isbn}

    #{empty book}

    #{expr}

EXtensible HyperText Markup Language (XHTML)

    valid XML Structure

    XHTML 1.0 frameset

    XHTML 1.0 strict

    XHTML 1.0 transitional

Extensible Markup Language (XML)

    CreditCard class

    CreditCardXMLTest class

    definition

    document

    DOM

    JAXB. see Java Architecture for XML Binding (JAXB)

    JAXP

        abstraction layer

        API architecture

        configuration

        DOM

        packages

        SAX

        XSLT

    SAX

    specification

        development

        DOM

        Java

        reference implementation

        SAX

        W3C

        XPath 1.0

        XQuery 1.0

        XSD

        XSLT

    XPath

    XSD

        definition

        elements and attributes

        JAXB

        purchase order

        terminology

    XSLT

Extensible Stylesheet Language Transformations (XSLT)

Facelets

FacesServlet

fetch element

findCDs() method

<fmt:bundle>

<fmt:formatDate>

<fmt:formatNumber>

<fmt:message>

<fmt:param>

<fmt:parseDate>

<fmt:parseNumber>

<fmt:requestEncoding>

<fmt:setLocale>

<fmt:setTimeZone>

<fmt:timeZone>

(font-style: italic;)

@GeneratedValue annotation

generateNumber() method

getAllBooks() method

getAsHtml() method

getAttributes() method

getBooks method

getBookTitle() method

getReference() method

getResultList() method

getSingleResult() method

GlassFish

    admin console

    administration

    application server

    architecture

    asadmin CLI

    history

    installation

    subprojects

    update

Google Web Toolkit (GWT)

Graphical user interface (GUI)

Grizzly framework

h:body>

<h:column>

<h:dataTable>

<h:doctype>

<h:form>

<h:head>

Hibernate

<h:inputFile>

<h:inputHidden>

<h:inputSecret>

<h:inputTextarea>

<h:inputText>

<h:outputFormat>

<h:outputLabel>

<h:outputLink>

<h:outputScript>

<h:outputStylesheet>

<h:outputText>

<h:panelGrid>

<h:panelGrid> tag

<h:panelGroup>

<h:selectBooleanCheckbox>

<h:selectManyCheckbox>

<h:selectManyListbox>

<h:selectManyMenu>

<h:selectOneListbox>

<h:selectOneMenu>

<h:selectOneRadio>

HyperText Markup Language (HTML)

Image Packaging System (IPS)

Imperative programming

Inheritance

    CD, book, item entity

    class types

        abstract entity

        mapped superclass

        nonentity

    definition

    joined-subclass strategy

    JPA

    overriding attributes

    single-table-per-class

        Book entity

        @DiscriminatorColumn annotation

        fragment

        ISBN

        Item entity

        ITEM table structure

        root entity

    table-per-class

init() method

@Inject annotation

Input tags

<input type=submit value=Create>

Integrated development environment (IDE)

Interface definition language (IDL)

Internet Engineering Task Force (IETF)

Internet InterOrb Protocol (IIOP)

InvocationContext object

InvocationContext.proceed() method

isValid method

J2EE Connector Architecture (JCA)

Java Architecture for XML Binding (JAXB)

    annotations

    architecture

    CreditCard Class

    marshalling/unmarshalling

    namespaces

    packages

    reference implementation

    schema

    specification

    @XmlRootElement annotation

    XSD

Java Architecture for XML Processing (JAXP)

    abstraction layer

    API architecture

    configuration

    DOM

    packages

    SAX

    XSLT

Java Authentication and Authorization Service (JAAS)

JavaBeans Activation Framework

Java Community Process (JCP)

Java Development Kit (JDK)

Java EE Application Deployment (JSR 88)

Java EE Connector Architecture

Java Enterprise Edition 7

    annotations and deployment descriptions

    application client module

    application programming interface

    CD-BookStore application

    components

    containers

    CORBA

    dependency injection

    deployment specification

    EJB 2.x Entity Beans CMP

    EJB module

    enterprise module

    enterprise specifications

    Java Community Process

    JavaMail

    Java Management Extensions

    Java Message Service

    Java Naming and Directory Interface

    Java Transaction API

    JAXR (JSR 93)

    JAX-RPC (JSR 101)

    JCP

    JSON process

    JSR 17

    network protocols

    portable configuration properties

    programming modelx

        JSF backing bean

        RESTful web services

        Stateless EJB

    related enterprise technologies

    security services

    standards

    validation

    web application module

    web profile 7 specifications

    web services

    web services specifications

    web specifications

    XML process

Java interface description language (IDL)

JavaMail

Java Management Extensions (JMX)

Java Messaging Service (JMS)

    administered objects

    API

        body of message

        connection

        ConnectionFactory interface

        destination

        header

        interfaces

        JMSConsumer

        JMSContext

        JMSProducer

        messaging system

        properties

        sending and receiving message

        session

        simplification

        structure

    creation

    interfaces

    JDBC

    OrderConsumer

    OrderDTO class

    OrderProducer

Java Naming and Directory Interface (JNDI)

Java persistence API (JPA)

    Book entity

    BookIT integration test

    compile and test

    Derby process

    entity

        anatomy of

        definition

        integration

        life cyle

        ORM (see Object-relational mapping (ORM))

        query (see Query entity)

    main class persistence

    Maven directory structure

    persistence unit

    schema database generation

    specification

        components of

        features

        history of

        implementation

        packages

    SQL script

Java Persistence Query Language (JPQL)

    book entity

    bulk delete operation

    bulk updates

    definition

    FROM clause

    GROUP BY/HAVING clause

    mapping mechanism

    ORDER BY

    SELECT clause

    syntax

    WHERE clause

Java Remote Method Protocol (JRMP)

JavaScript

    getElementById(“price”) method

    priceError

    priceRequired()

JavaScript library (jsf.js)

JavaScript Object Notation (JSON)

    CreditCardJSonTest class

    definition

    document

    JavaScript code

    processing

        building

        JsonGenerator

        JSR 353

        parses

        programming models

    purchase order

    specifications

JavaServer Faces (JSF)

    Ajax support

    backing beans and navigation

    composite components

    converters

    expression language

        book.buy()

        #{book.isbn}

        #{empty book}

        #{expr}

    Facelets

    faces-config.xml

    FacesServlet

    history of

    HTML components tags

        basic attributes

        command tag

        error messages

        graphics

        grid and table tags

        input tags

        miscellaneous tags

        output tags

        selections

        target tags

    implicit objects

    JSF 2.2

        CDI

        faces flow

        HTML-friendly markup

        id attribute

        injection in

        packages

        queue control

    JSF core tags

    JSF life cycle

        invoke application

        model values

        process validations

        render response

        request values

        restore view

    JSF page

        body

        header

        life cycle

        tag library and components

        XML component tree

    JSTL tags

        core actions

        formatting actions

    pages and components

    reference implementation

    renderers

    resource management

    standard JSF UI components

    templating tags

    validators

Java Standard Edition 7

    diamond

    Input/Output Streams

    multicatch exception

    NIO.2

    String Case

Java transaction service (JTA) local transactions

javax.jms.ConnectionFactory interface

@javax.jws.WebMethod annotation

@javax.jws.WebParam annotation

@javax.jws.WebResult annotation

@javax.jws.WebService annotation

javax.persistence.metamodel

@javax.xml.ws.WebServiceRef annotation

Jersey

JSON process

JSP Standard Tag Library (JSTL) tags

    core actions

    formatting actions

JSR 24

JUnit

    assert methods

    calculateAge() method

    customer class

    features

    fixtures

    history

    integration

    launching

    test methods

layout.xhtml Template

logMethod()

Managing persistent objects

    Cache API

        @Cacheable annotation

        cache.evict(Customer.class) method

        javax.persistence.Cache

        persistence.xml file

        second-level cache

        UPDATE statement

    callback

        annotations

        customer entity

        entity life cycle

        life-cycle methods

    concurrency

        EntityManager methods

        locking mechanisms

        LockModeType

        optimistic locking

        pessimistic locking

        query method

        transactions

        versioning

    entity life cycle

    entity manager

        ADDRESS_FK column

        anSQL statement

        CascadeType.ALL type

        clear() method

        customer entity

        customer ID

        detach(Object entity) method

        (em.clear())

        em.persist(address)

        em.persist(customer)

        em.persist() method

        EntityManager.contains()method

        EntityManager.flush() method

        EntityManager.merge()

        EntityManager.persist() method

        EntityManager.remove() method

        interface

        manipulation methods

        one-way/one-to-one address

        orphan removal

        persistence class

        persistence context

        refresh() method

        rollback() method

        setFirstName() method

        stateless EJB

        tx.begin()

    JPQL

        book entity

        bulk delete operation

        bulk updates

        definition

        FROM clause

        GROUP BY/HAVING clause

        mapping mechanism

        ORDER BY

        SELECT clause

        syntax

        WHERE clause

    listeners

        AgeCalculationListener

        callback methods

        DataValidationListener

        debug listener

        @ExcludeDefaultListeners

    query

        dynamic

        EntityManager methods

        flush mode settings

        getResultList() method

        getSingleResult() method

        named query

        native query

        object oriented query

        query API

        stored procedure

        types

Marshaller.marshal() method

Maven

    artifacts

    history

    installation

    Java EE application

    plug-ins and life cycle

    project descriptor

    project modularity

    usage

Maven pom.xml File

Message-driven beans (MDB)

    anatomy

        @ActivationConfigProperty

        context

        dependency injection

        ejb-jar.xml file

        life cycle and callback

        @MessageDriven

        requirements

    compile and package

    consumer

    EJB specification

    exception handling

    ExpensiveOrderMDB class

    GlassFish

    onMessage() method

    producers

    simple consumer

    transactions

Message-oriented middleware (MOM)

Messaging

    administered objects

    architecture

    components

    JMS. see Java Messaging Service (JMS)

    MDB. see Message-driven beans (MDB)

    message consumers

        asynchronous delivery

        creation

        synchronous delivery

        types

    message producers

        administered objects

        CDI

        dependency injection

        JMSProducer

        ProducerEJB runs

        @Resource annotation

    MOM architecture

    P2P model

    pub-sub model

    reliability mechanisms

        acknowledgment

        durable subscription

        filter

        JMS features

        persistence

        priority

        time-to-live

    specifications

Metro

Model-View-Controller (MVC) design pattern

    Faces Config

    FacesContext

    FacesServlet

        configuration parameters

        web.xml

Mojarra

Navigation

    bookmarking pages

    explicit navigation

    rules

newBook.xhtml Page

numberGenerator.generateNumber() method

Object-relational mapping (ORM)

    annotation

    BOOK table structure

    configuration-by-exception approach

    data synchronization

    domain model

    embeddables

        Address class

        Customer and Order entity

        CUSTOMER Table

        explicit access

        field access

        Overriding Attributes

        owning entity

        property access

    @GeneratedValue annotation

    inheritance. see Inheritance

    mapping

        attributes. see Attributes

        collection

        explicit access

        field-based access

        getId() method

        Java objects

        phoneNumber attribute

        primary key (see Primary key)

        property-based access

        @SecondaryTable

        @Table annotation

        types

    relationship

        bidirectional association

        cardinality

        entity (see Entity relationships)

        multiplicity

        ownership

        relational database

        UML

        unidirectional association

    XML descriptors

        <attributes> tag

        Book entity

        book_mapping.xml file

        hibernate

        metadata

        persistence.xml

        table structure

        <table> tag

@OneWay annotation

Open Message Queue (OpenMQ)

OpenMQ

OptimisticLockException

Output tags

persistence.xml file

PessimisticLockException

Plain old java object (POJO)

@PrePersist method

@PreRemove method

Primary key

    composite key

        class definition

        @EmbeddedId

        @IdClass annotation

        string

    @Id and @GeneratedValue

    JPA

Project Object Model (POM)

Query entity

    EntityManager interface

    @NamedQuery annotation

    snippet of code

    SQL queries/JDBC calls

    steps

query.getResultList() method

Random() method

Reference implementation (RI)

refresh() method

Remote Method Invocation (RMI)

ResponseBuilder.build() method

RESTful web services

    addressability

    anatomy of

    binding URI

    book entity

    BookRestService

        book deletion

        by ID

        getBooks method

        header class

        new book creation

    BookRestServiceIT integration test

    books JAXB bean

    client API

        bootstrapping

        consuming responses

        javax.ws.rs.client package

        targets/invocations

    compile and package

    consuming/producing content types

    contextual information

    CRUD actions

    CRUD operations

    entity provider

    extracting parameter

    GlassFish

    graph theory

    handling exceptions

    HTTP

        annotations

        caching/conditional requests

        CONNECT method

        content negotiation

        content types

        DELETE method

        GET method

        headers

        HEAD method

        OPTION method

        Post method

        POST method

        PUT method

        request and response

        status codes

        TRACE method

        UriBuilder

    human-readable representation

    hypermedia principle

    JAX-RS configuration

    life cycle

    machine-processable representation

    Maven directory structure and packages

    packaging

    resources and URI

    REST consumer anatomy

    returned type

    specification

        history of

        implementation

        Java API

        JAX-RS 2.0

    statelessness

    uniform interface

    URI definition

    WADL

    web-browsing

rollback() method

Selection tags

Service endpoint interfaces (SEI)

Service Provider Interface (SPI)

Session beans life cycle

    callback annotations

    creation and destruction

    dependency injection

    JNDI lookup

    new operator

    passivation and activation phases

    stateful session beans

    stateless and singleton

setFirstName() method

setFirstResult() method

setLockMode(LockModeType) method

setMaxResults() method

setParameter method

setTimeToLive() method

shopping-cart

Simple API for XML (SAX)

Simple object access protocol web services

    anatomy of

    application

    B2B integration

    bottom-up approach

    CardValidator

    CardValidator implementation

    CardValidatorIT integration test

    CardValidatorTest unit test

    CDI

    compile, test and package

    consumer

    consumer discover

    CreditCard class

    deployment descriptor

    design

    elements and attributes

    GlassFish

    handling exceptions

    injection

    jar file

    JAXB annotation

    life cycle

    Maven command

    Maven project

    packages

    pom.xml file

    programmatically

    proxy method

    publish method

    SEI

    specifications

        history of

        implementation

        JAXR

        JAX-WS 2.2a

        OASIS

        stand body

        Web Services 1.3

        WS-Metadata 2.3

    structure of

    top-down approach

    transport protocol

    UDDI

    WebServiceConsumer class

    WebServiceContext

    WSDL

        consumer vs. web service

        credit card validation service

        data types

        elements and attributes

        IDL

        mapping annotation (see WSDL mapping annotation)

        role of

    WSDL-to-Java utility tool

    wsimport tool

    XML

SOAP. See Simple object access protocol web services

@SOAPBinding annotation

sp_archive_books

Standard Generalized Markup Language (SGML)

StoredProcedureQuery

Struts

Swing component model

Target tags

Timer service

    calendar-based expression

    calendar-based schedule

    container service

    declarative timer creation

    long-lived business processes

    programmatic timer creation

    @Schedule annotation

    scheduling facility

    session bean

    @Timeout annotation

Transactions

    ACID properties

    banking and e-commerce applications

    bean-managed transactions (BMT)

    business-to-business interactions, partners

    container-managed transaction (CMT)

        application exceptions

        createBook() method

        demarcation policy

        @javax.ejb.TransactionAttribute annotation

        MANDATORY attribute

        NEVER attribute

        NOT_SUPPORTED attribuute

        REQUIRED attribute

        REQUIRES_NEW attribute

        rollback operations

        stateless bean

        SUPPORTS attribute

        system exceptions

    dirty reads

    distributed XA transactions

    EJB container

    isolation levels

    JTA local transactions

    Managed Beans

    phantom reads

    repeatable reads

    specifications

    unit of work

UIColumn

UICommand

<ui:component>

UIComponent

UIComponentBase

<ui:composition>

UIData

ui:debug>

<ui:decorate>

<ui:define>

UIForm

<ui:fragment>

UIGraphic

<ui:include>

UIInput

<ui:insert>

UIMessage

UIOutcomeTarget

UIOutput

UIPanel

<ui:param>

UIParameter

<ui:remove>

<ui:repeat>

UISelectBoolean

UISelectItem

UISelectOne

UIViewAction

UIViewParameter

UIViewRoot

Unified Modeling Language (UML)

Uniform resource identifiers (URIs)

Universal description discovery and integration (UDDI)

Universal Message Service (UMS)

Unmarshaller.unmarshal() method

updateCustomer() method

validate() method

Validators

    Bean Validation

    custom validators

    standard validators

Validator.validate() method

Validator.validateProperty() method

Validator.validateValue() method

viewBook.xhtml Page

wav attribute

Web application description language (WADL)

Web container

Web pages

    CSS

    DOM

    history of

    HTML

    JavaScript

    XHTML

@WebService annotation

@WebServiceRef annotation

Web services

Web Services Description Language (WSDL)

World Wide Web Consortium (W3C)

WSDL mapping annotation

    CardValidator web service

    @OneWay

    RPC/Literal web services

    @SOAPBinding

    ValidateCreditCard

    @WebMethod

    @WebParam

    @WebResult

    @WebService

    WSDL document

    XML schema

XmlAccessorType annotation (JAXB)

XML process

XML Schema Definition (XSD)