Index

A

• --all-server-groups flag / Deploying to all server groups
• @ApplicationScoped scope / CDI scopes
• a4j$poll / Making your application rich
• acknowledgment mode / Transaction and acknowledgment modes
• ActiveMQ
  • and HornetQ integration / A real-world example – HornetQ and ActiveMQ integration
• ActiveMQ broker
  • URL / A real-world example – HornetQ and ActiveMQ integration
• ActiveMQ messages
  • consuming / Consuming ActiveMQ messages
• ActiveMQ plugin
  • URL / Consuming ActiveMQ messages
• ActiveMQ resource adapter
  • installing / Installing the ActiveMQ resource adapter
• Administration tab / Launching the web console
• administrative operations
  • auditing / Auditing administrative operations
• advanced languages
  • used, for creating powerful CLI scripts / Using advanced languages to create powerful CLI scripts
• angular-js plugin / Starting Forge
• Angular JS
  • URL / Adding AngularJS
• AngularJS
  • adding / Adding AngularJS
• Angular UI BootStrap package
  • URL / Adding AngularJS
• Apache CXF, features
  • URL / JBoss SOAP-based web services stack
• app-name element / Creating a remote EJB client
• application
  • running / Getting ready to run the application, Running the application
  • scheduler, combining into / Combining the scheduler into our application
  • persistence, adding to / Adding persistence to our application
  • queries, coding for / Coding queries for your application
  • services, adding to / Adding services to your application
  • message-driven beans, adding to / Adding message-driven beans to your application
  • compiling / Compiling and deploying the application
  • deploying / Compiling and deploying the application
  • deploying, to several WildFly nodes / Deploying an application to several WildFly nodes
  • Database login module, using / Using the Database login module in your application
• applications
  • deploying, command-line interface used / Deploying applications using the command-line interface
  • deploying, to domain / Deploying applications to a domain
  • deploying, CLI used / Deploying applications using the CLI
  • deploying, to WildFly domain / Deploying applications to a WildFly domain
  • deploying, to all server groups / Deploying to all server groups
  • deploying, to single server group / Deploying to a single server group
• application server
  • managing / Managing the application server
  • WildFly 8, managing with web interface / Managing WildFly 8 with the web interface
• application server nodes / WildFly 8 core concepts
• Arquillian
  • about / Instruments used for testing, Getting started with Arquillian
  • test, writing / Writing an Arquillian test
  • pom.xml file, configuring / Configuring the pom.xml file
  • first Arquillian test, writing / Writing your first Arquillian test
  • TicketTest, running / Running Arquillian TicketTest
  • tests running, Spock used / Running Arquillian tests using Spock
  • ShrinkWrap Resolver / ShrinkWrap Resolver
  • ShrinkWrap Descriptors / ShrinkWrap Descriptors
  • persistence, testing / Persistence testing
  • WebSockets, testing / WebSockets testing
  • test, enhancing / Enhancing your Arquillian test
  • URL / Additional information
• Arquillian Persistence Extension manual
  • URL / Persistence testing
• Arquillian Spock test runner
  • URL / Running Arquillian tests using Spock
• Arquillian Suite Extension
  • about / Additional information
• Arquillian test
  • writing / Writing an Arquillian test
  • enhancing / Enhancing your Arquillian test
• Arquillian tests
  • running, Spock used / Running Arquillian tests using Spock
• Arquillian TicketTest
  • running / Running Arquillian TicketTest
• Arquillian Warp / Arquillian Warp
  • URL / Arquillian Warp
• AssertJ / ShrinkWrap Resolver
• asymmetric encryption / Securing the transport layer
• asynchronously / A short introduction to JMS
• asynchronous methods
  • adding, to EJBs / Adding asynchronous methods to our EJBs
  • fire-and-forget asynchronous calls, using / Using fire-and-forget asynchronous calls
  • Future object, returning to client / Returning a Future object to the client
• audit-log configuration
  • about / Auditing administrative operations
  • Formatter / Auditing administrative operations
  • Handler / Auditing administrative operations
  • Logger / Auditing administrative operations
• authentication / Approaching the Java security API
  • versus authorization / Approaching the Java security API
• authorization / Approaching the Java security API
  • versus authentication / Approaching the Java security API
• Auto-deploy Exploded attribute / Changing the deployment scanner properties
• Auto-deploy Zipped attribute / Changing the deployment scanner properties
• autoApply attribute / Adding Bean Validation
• automatic timers / Using the EJB timer service
• AUTO_ACKNOWLEDGE / Transaction and acknowledgment modes

B

• Batch applications the Java Platform 1.0 (JSR 352) / Batch applications for the Java Platform 1.0 – JSR 352
• batching framework
  • about / The overview of the batching framework
  • Chunk steps / The overview of the batching framework
  • Task steps / The overview of the batching framework
  • first batch job / Our first batch job
  • concurrency utilities, using in Java EE / Using concurrency utilities in Java EE
• bean-discovery-mode attribute / WildFly CDI implementation
• bean-managed concurrency
  • using / Using bean-managed concurrency
• bean-name element / Creating a remote EJB client
• bean concurrency
  • controlling / Controlling bean concurrency
  • bean-managed concurrency, using / Using bean-managed concurrency
• beans
  • creating / Creating the beans
  • view, building / Building the view
  • application, running / Getting ready to run the application
  • scheduler, combining into application / Combining the scheduler into our application
• Bean Validation
  • adding / Adding Bean Validation
• Bean Validation (JSR-303) / Adding Bean Validation
• Bean validation 1.1 (JSR 349) / Bean Validation 1.1 – JSR 349
• Behavior-driven development (BDD) / Running Arquillian tests using Spock
• Bill of Materials (BOM) / Installing RichFaces
• bookSeat method / Adding services to your application
• bookTicket method / Adding AngularJS
• Bootstrap
  • about / Coding the JSF view
  • URL / Coding the JSF view
• bottom-up approach / Strategies to build SOAP-based web services
• browser support, WebSockets
  • URL / How do WebSockets work
• building blocks, JMS
  • connection factory / The building blocks of JMS
  • connection / The building blocks of JMS
  • session / The building blocks of JMS
  • message producer / The building blocks of JMS
  • message consumer / The building blocks of JMS
• built-in roles
  • about / Role-based security
  • Monitor / Role-based security
  • Operator / Role-based security
  • Maintainer / Role-based security
  • Deployer / Role-based security
  • Administrator / Role-based security
  • Auditor / Role-based security
  • Super User / Role-based security
• buyTicket method / Coding our EJB application

C

• @ConversationScoped scope / CDI scopes
• CDI
  • about / An overview of Java EE and WildFly, Contexts and Dependency Injection for Java EE 1.1 – JSR 346, Introducing Contexts and Dependency Injection
  • named beans / Named beans
  • scopes / CDI scopes
  • WildFly CDI implementation / WildFly CDI implementation
  • ticketing system, rethinking / Rethinking your ticketing system
  • beans, creating / Creating the beans
• CDI for Java EE 1.1 (JSR 346) / Contexts and Dependency Injection for Java EE 1.1 – JSR 346
• CDI Reference Implementation
  • URL / CDI scopes
• certificate-signing request (CSR) / Securing HTTP communication with a certificate signed by a CA
• certificate management tools / Certificate management tools
• Certification Authority (CA) / Securing the transport layer
• Chef
  • URL / Launching the CLI
• chunk-based batch step
  • creating / Creating a chunk-based batch step
• Chunk steps / The overview of the batching framework
• CLI commands
  • constructing / Constructing CLI commands
• CLI commands, constructing
  • resource address, determining / Determining the resource address
  • operations, performing on resources / Performing operations on resources
• client
  • Future object, returning to / Returning a Future object to the client
• client application
  • running / Running the client application
  • user authentication, adding / Adding user authentication
  • expanding / Expanding our client application
  • POJOs, transforming to JSON / Transforming POJOs to JSON
• client certificate
  • generating / Generating the server and client certificates
• client components
  • installing / Installing the server and client components
• CLIENT_ACKNOWLEDGES / Transaction and acknowledgment modes
• CLI execution
  • wrapping, scripting languages used / Using scripting languages to wrap CLI execution
• CLI scripts
  • creating / Creating CLI scripts
  • application, deploying to several WildFly nodes / Deploying an application to several WildFly nodes
  • servers, restarting in domain / Restarting servers in a domain
  • datasource, installing as module / Installing a data source as a module
  • JMS resources, adding / Adding JMS resources
  • creating, advanced languages used / Using advanced languages to create powerful CLI scripts
  • scripting languages, used for wrapping CLI execution / Using scripting languages to wrap CLI execution
• cluster-aware remote client
  • coding / Coding the cluster-aware remote client
• clustered applications
  • deploying / Deploying clustered applications
  • HA Stateful Session Bean (SFSB), creating / Creating HA Stateful Session Beans
• clustering
  • about / Clustering basics
  • benefits / Clustering basics
• clustering, benefits
  • horizontal scalability (scaling out) / Clustering basics
  • load balancing / Clustering basics
  • high availability / Clustering basics
• command-line interface
  • used, for deploying applications / Deploying applications using the command-line interface
  • used, for creating new data source / Using the command-line interface to create a new data source
• command-line interface (CLI)
  • used, for connecting to server / Connecting to the server with the command-line interface
  • about / Connecting to the server with the command-line interface
• concurrency utilities
  • used, in Java EE / Using concurrency utilities in Java EE
• concurrency utilities (JSR 236) / Concurrency utilities for Java EE 1.0 – JSR 236
• concurrency utilities, components
  • ManagedExecutorService / Using concurrency utilities in Java EE
  • ManagedScheduledExecutorService / Using concurrency utilities in Java EE
  • ContextService / Using concurrency utilities in Java EE
  • ManagedThreadFactory / Using concurrency utilities in Java EE
• connect command / Launching the CLI, Using scripting languages to wrap CLI execution
• connection / The building blocks of JMS
• connection factories
  • creating / Creating and using connection factories
  • using / Creating and using connection factories
• connection factory / The building blocks of JMS
• console
  • web service, inspecting from / Inspecting the web service from the console
• constraints
  • URL / Adding Bean Validation
• container, Java security API
  • declarative security / Approaching the Java security API
  • about / Approaching the Java security API
• container adapters
  • Embedded / Configuring the pom.xml file
  • Managed / Configuring the pom.xml file
  • Remote / Configuring the pom.xml file
• contextual / Introducing Contexts and Dependency Injection
• Continuous Integration (CI) / Launching the CLI
• controller
  • adding, for driving user requests / Adding a controller to drive user requests
• core-threads, executor service / Using concurrency utilities in Java EE
• createSeatType method / Adding services to your application
• Criteria API / Coding queries for your application

D

• @Dependent scope / CDI scopes
• database
  • setting up / Setting up the database
• Database login module
  • about / The WildFly security subsystem
  • creating / Creating a Database login module
  • passwords, encrypting / Encrypting passwords
  • using, in application / Using the Database login module in your application
• data persistence
  • about / Data persistence meets the standard
  • JPA, working with / Working with JPA
• datasource
  • installing, as module / Installing a data source as a module
• data source
  • creating, command-line interface used / Using the command-line interface to create a new data source
• declarative security / Approaching the Java security API
• demo application, Forge / Your Forge-demo application in action
• deploy command / Deploying applications using the CLI
• deployment scanner properties
  • changing / Changing the deployment scanner properties
• Deployment timeout attribute / Changing the deployment scanner properties
• deploy shell command / Deploying applications using the command-line interface
• detyped API
  • used, for creating resource watches / Creating your resource watches using the detyped API
• development environments
  • IntelliJ IDEA / Alternative development environments
  • NetBeans / Alternative development environments
• digital certificate / Securing the transport layer
• disallowed activities
  • URL / EJB 3.2 – an overview
• Dispatcher module / A brief look at the JAX WS architecture
• distinct-name element / Creating a remote EJB client
• doCleanUp method / Adding services to your application
• domain
  • controller / WildFly 8 core concepts
  • Host Controller / WildFly 8 core concepts
  • application server nodes / WildFly 8 core concepts
  • applications, deploying to / Deploying applications to a domain
  • servers, restarting in / Restarting servers in a domain
• domain cluster / WildFly clustering
• domain configuration
  • URL / Managing WildFly 8 with the web interface
• domain controller / WildFly 8 core concepts
• domain directory structure
  • about / The WildFly 8 directory layout
  • configuration / The WildFly 8 directory layout
  • data/content / The WildFly 8 directory layout
  • Log / The WildFly 8 directory layout
  • servers / The WildFly 8 directory layout
  • tmp / The WildFly 8 directory layout
• domain nodes cluster
  • initiating / Starting a cluster of domain nodes
  • domain controller configuration / The domain controller configuration
  • host configurations / Host configurations
• Domain Specific Language (DSL) / Running Arquillian tests using Spock
• Drone
  • about / Additional information
• drop-and-create value / Configuring persistence
• DUPS_OK_ACKNOWLEDGE / Transaction and acknowledgment modes
• durable subscription / A short introduction to JMS

E

• EAP
  • using, with WildFly / WildFly and Enterprise Application Platform
  • about / WildFly and Enterprise Application Platform
  • Alpha / WildFly and Enterprise Application Platform
  • Beta / WildFly and Enterprise Application Platform
  • Final / WildFly and Enterprise Application Platform
• Eclipse
  • URL / Installing the Eclipse environment
• Eclipse, with PyDev extension
  • URL / Using scripting languages to wrap CLI execution
• Eclipse deployment options
  • about / Advanced Eclipse deployment options
  • managing, with web console / Managing deployments with the web console
• Eclipse environment
  • installing / Installing the Eclipse environment
• Eclipse environment installation
  • about / Installing the Eclipse environment
  • JBoss Tools, installing / Installing JBoss Tools
• EJB
  • about / EJB 3.2 – an overview
• EJB3 Stateless Session Bean (SLSB) web services / EJB3 Stateless Session Bean (SLSB) web services
• EJB application
  • coding / Coding our EJB application
  • deploying / Deploying the EJB application
• EJB client
  • coding / Coding the EJB client
  • configuration, adding / Adding the EJB client configuration
• EJB communication
  • securing / Securing EJB communication
• EJB module / Developing singleton EJBs
• EJB project object module (pom.xml)
  • configuring / Configuring the EJB project object module (pom.xml)
• EJBs
  • asynchronous methods, adding to / Adding asynchronous methods to our EJBs
  • about / Are EJBs and JSF Managed Beans obsolete?
  • securing / Securing EJBs
  • web services, securing / Securing web services
• EJB timers
  • programmatic timers / Using the EJB timer service
  • automatic timers / Using the EJB timer service
• EJB timer service
  • using / Using the EJB timer service
  • timer, creating / Programmatic timer creation
  • timer events, scheduling / Scheduling timer events
• EJB types
  • session beans / EJB 3.2 – an overview
  • Message-driven beans (MDB) / EJB 3.2 – an overview
  • entity objects / EJB 3.2 – an overview
• Enabled attribute / Changing the deployment scanner properties
• encryption
  • symmetric encryption / Securing the transport layer
  • asymmetric encryption / Securing the transport layer
• endpoint
  • URL / Creating our first endpoint
• EndpointConfig parameter / Creating our first endpoint
• Enterprise Application Integration (EAI) / Using JMS to integrate with external systems
• Enterprise archive / Developing singleton EJBs
• enterprise beans
  • threads, introducing to / Introducing threads to enterprise beans
• Enterprise JavaBeans (EJB) / An overview of Java EE and WildFly, The domain controller configuration
• Enterprise JavaBeans 3.2 (JSR 345) / Enterprise JavaBeans 3.2 – JSR 345
• entities
  • adding / Cooking entities
• EntityManage / Adding producer classes
• entity objects / EJB 3.2 – an overview
• example
  • running / Running the example
• executor service, properties
  • core-threads / Using concurrency utilities in Java EE
  • max-threads / Using concurrency utilities in Java EE
  • keepalive-time / Using concurrency utilities in Java EE
  • hung-task-threshold / Using concurrency utilities in Java EE
• Expression Language (EL) / Creating the beans
• Expression Language (UEL) / Named beans
• external systems
  • JMS used, for integrating with / Using JMS to integrate with external systems

F

• FacesContext / Adding producer classes
• FacesFlow
  • about / Getting ready to run the application
• features, WildFly / New features in WildFly
• fetch attribute / Cooking entities
• filters
  • adding / Adding filters
• fire-and-forget asynchronous calls
  • using / Using fire-and-forget asynchronous calls
• first application
  • deploying, to WildFly 8 / Deploying your first application to WildFly 8
• first Arquillian test
  • writing / Writing your first Arquillian test
• first batch job
  • about / Our first batch job
  • chunk-based batch step, creating / Creating a chunk-based batch step
  • job-based batch step, creating / Creating a job-based batch step
• first endpoint
  • creating / Creating our first endpoint
• first login module
  • setting up / Setting up your first login module
• Forge
  • installing / Installing Forge
  • URL / Installing Forge, Starting Forge
  • initiating / Starting Forge
  • used, for creating Java EE 7 application / Creating your first Java EE 7 application with JBoss Forge
  • demo application / Your Forge-demo application in action
• FORM-based security
  • switching to / Switching to FORM-based security
• fully-qualified-classname-of-the-remote-interface element / Creating a remote EJB client
• Future object
  • returning, to client / Returning a Future object to the client

G

• @GeneratedValue annotation / Cooking entities
• @GET annotation / Accessing REST resources
• getPort method / Developing a web service consumer
• getSeat method / Coding our EJB application
• getSeatPrice method / Coding our EJB application
• getSeats method / EJB3 Stateless Session Bean (SLSB) web services
• given construction / Running Arquillian tests using Spock
• Google Guice
  • URL / Introducing Contexts and Dependency Injection
• Google Web Toolkit (GWT) / Managing WildFly 8 with the web interface
• Graphene
  • about / Additional information
• graphical mode
  • CLI, used in / Using a CLI in the graphical mode

H

• HA
  • achieving, programming considerations / Programming considerations to achieve HA
  • achieving, in JSF applications / Achieving HA in JSF applications
• hashing algorithms
  • URL / Encrypting passwords
• HA Stateful Session Bean (SFSB), creating
  • about / Creating HA Stateful Session Beans
  • Ticket example, clustering / Clustering the Ticket example
  • cache, converting to distributed cache / Turning your cache into a distributed cache
  • cluster-aware remote client, coding / Coding the cluster-aware remote client
  • high availability, deploying / Deploying and testing high availability
  • high availability, testing / Deploying and testing high availability
• hawt.io console
  • URL / Consuming ActiveMQ messages
• HornetQ
  • URL / The JBoss messaging subsystem
  • and ActiveMQ integration / A real-world example – HornetQ and ActiveMQ integration
• HornetQ documentation
  • URL / Specifying which message to receive using selectors
• Host Controller / WildFly 8 core concepts
• HTTP communication
  • securing, with self-signed certificate / Securing the HTTP communication with a self-signed certificate
  • securing, with certificate signed by CA / Securing HTTP communication with a certificate signed by a CA
• hung-task-threshold, executor service / Using concurrency utilities in Java EE

I

• Infinispan / WildFly clustering
• instruments
  • used, for testing / Instruments used for testing
• integration test / Test types
• IntelliJ IDEA
  • URL / Alternative development environments
  • about / Alternative development environments
• interceptors
  • creating / Creating interceptors
• InVmConnectionFactory / Creating and using connection factories
• IRC
  • URL / Additional information
• IronJacamar
  • URL / Installing the ActiveMQ resource adapter
• item-count attribute / Creating a chunk-based batch step
• ItemWriter class / Creating a chunk-based batch step

J

• @javax.annotation.security.DenyAll annotation / Securing EJBs
• @javax.annotation.security.PermitAll annotation / Securing EJBs
• @javax.annotation.security.RolesAllowed annotation / Securing EJBs
• @javax.annotation.security.RunAs annotation / Securing EJBs
• java.util.Logger / Adding producer classes
• Java API for JSON processing 1.0 (JSR 353) / Java API for JSON Processing 1.0 – JSR 353
• Java API for RESTful Web Services (JAX-RS) / An overview of Java EE and WildFly
• Java API for WebSocket 1.0 (JSR 356) / Java API for WebSocket 1.0 – JSR 356
• Java API for XML Web Services (JAX-WS) / An overview of Java EE and WildFly
• Java Connector Architecture (JCA) / Using JMS to integrate with external systems
• Java database connectivity (JDBC) / Creating your first Java EE 7 application with JBoss Forge
• Java EE
  • overview / An overview of Java EE and WildFly
  • CDI for Java EE 1.1 (JSR 346) / Contexts and Dependency Injection for Java EE 1.1 – JSR 346
  • Java Servlet API 3.1 (JSR 340) / Java Servlet API 3.1 – JSR 340
  • concurrency utilities, using in / Using concurrency utilities in Java EE
  • threads, introducing to enterprise beans / Introducing threads to enterprise beans
• Java EE 7
  • about / Welcome to Java EE 7
  • JavaServer Faces 2.2 ( JSR 344) / JavaServer Faces 2.2 – JSR 344
  • Enterprise JavaBeans 3.2 (JSR 345) / Enterprise JavaBeans 3.2 – JSR 345
  • Java Persistence API 2 (JSR 338) / Java Persistence API 2.1 – JSR 338
  • JAX-RS 2.0(JSR 339) / JAX-RS, the Java API for RESTful Web Services 2.0 – JSR 339
  • Java Message Service 2.0 (JSR 343) / Java Message Service 2.0 – JSR 343
  • Bean validation 1.1 (JSR 349) / Bean Validation 1.1 – JSR 349
  • concurrency utilities (JSR 236) / Concurrency utilities for Java EE 1.0 – JSR 236
  • Batch applications the Java Platform 1.0 (JSR 352) / Batch applications for the Java Platform 1.0 – JSR 352
  • Java API for JSON processing 1.0 (JSR 353) / Java API for JSON Processing 1.0 – JSR 353
  • Java API for WebSocket 1.0 (JSR 356) / Java API for WebSocket 1.0 – JSR 356
• Java EE 7 application
  • creating, with Forge / Creating your first Java EE 7 application with JBoss Forge
  • building / Building and deploying the application
  • deploying / Building and deploying the application
• Java Message Service 1.1 (JMS) / A real-world example – HornetQ and ActiveMQ integration
• Java Message Service 2.0 (JSR 343) / Java Message Service 2.0 – JSR 343
• Java Messaging Service (JMS) / An overview of Java EE and WildFly
• Java Naming and Directory Interface (JNDI) / Creating HA Stateful Session Beans, Creating your first Java EE 7 application with JBoss Forge
• Java Naming Directory Index (JNDI) / Creating and using connection factories
• Java Persistence API (JPA) / An overview of Java EE and WildFly, Data persistence meets the standard, Creating your first Java EE 7 application with JBoss Forge
• Java Persistence API 2.1 (JSR 338) / Java Persistence API 2.1 – JSR 338
• Java Persistence Query Language (JPQL) / Data persistence meets the standard
• Java SE
  • installing / Installing Java SE
• Java Secure Socket Extension (JSSE) / Enabling the Secure Socket Layer on WildFly
• Java security API
  • about / Approaching the Java security API
  • authentication / Approaching the Java security API
  • authorization / Approaching the Java security API
  • programmatic security / Approaching the Java security API
  • WildFly security subsystem / The WildFly security subsystem
  • first login module, setting up / Setting up your first login module
  • login module, using in Ticket web application / Using the login module in the Ticket web application
  • FORM-based security, switching to / Switching to FORM-based security
  • Database login module, creating / Creating a Database login module
  • EJBs, securing / Securing EJBs
• Java SE installation
  • URL / Installing Java SE
  • testing / Testing the installation
  • WildFly, installing / Installing WildFly
  • WildFly, initializing / Starting WildFly
  • server, connecting with command-line interface / Connecting to the server with the command-line interface
  • WildFly, terminating / Stopping WildFly
  • WildFly, restarting / Restarting WildFly
• Java Server Faces (JSFs) / An overview of Java EE and WildFly
• JavaServer Faces 2.2 - JSR 344 / JavaServer Faces 2.2 – JSR 344
• JavaServer Pages (JSP)
  • about / Building the view
• Java Server Pages (JSPs) / An overview of Java EE and WildFly
• Java Servlet API 3.1 (JSR 340) / Java Servlet API 3.1 – JSR 340
• JAX-RS
  • activating / Activating JAX-RS
• JAX-RS 2.0
  • about / Developing REST-based web services
• JAX-RS 2.0(JSR 339) / JAX-RS, the Java API for RESTful Web Services 2.0 – JSR 339
• JAX-RS Client Framework / JBoss REST web services
• JAX WS architecture / A brief look at the JAX WS architecture
• JBeret
  • URL / Our first batch job
• JBoss EJB Client / Creating HA Stateful Session Beans
• JBoss JIRA
  • URL / Additional information
• JBoss messaging subsystem / The JBoss messaging subsystem
• JBoss REST web services
  • about / JBoss REST web services
  • JAX-RS, activating / Activating JAX-RS
  • REST, adding to ticket example / Adding REST to our ticket example
  • filters, adding / Adding filters
  • REST service, consuming / Consuming our REST service
  • ticket example, compiling / Compiling our ticket example
  • AngularJS, adding / Adding AngularJS
• JBoss SOAP-based web services stack / JBoss SOAP-based web services stack
• JBoss Tools
  • installing / Installing JBoss Tools
  • URL / Installing JBoss Tools
• JDBC driver
  • installing, in WildFly / Installing the JDBC driver in WildFly
  • command-line interface used, for creating new data source / Using the command-line interface to create a new data source
• JEE
  • URL / EJB 3.2 – an overview
• JGroups library / WildFly clustering
• JMS
  • about / A short introduction to JMS
  • building blocks / The building blocks of JMS
  • JBoss messaging subsystem / The JBoss messaging subsystem
  • connection factories, creating / Creating and using connection factories
  • connection factories, using / Creating and using connection factories
  • destinations, using / Using JMS destinations
  • message-driven beans, adding to application / Adding message-driven beans to your application
  • transaction mode / Transaction and acknowledgment modes
  • acknowledgment mode / Transaction and acknowledgment modes
  • used, for integrating with external systems / Using JMS to integrate with external systems
  • HornetQ and ActiveMQ, integration / A real-world example – HornetQ and ActiveMQ integration
• JMS API
  • about / A short introduction to JMS
  • persistent delivery mode / A short introduction to JMS
  • nonpersistent delivery mode / A short introduction to JMS
• JMS destination
  • Durable option / Using JMS destinations
  • Selector option / Using JMS destinations
• JMS destinations
  • using / Using JMS destinations
• JMS producer
  • adding / Adding the JMS producer
• JMS resources
  • adding / Adding JMS resources
• JMS specification, messages
  • synchronously / A short introduction to JMS
  • asynchronously / A short introduction to JMS
• job-based batch step
  • creating / Creating a job-based batch step
• JobOperator start method / Creating a chunk-based batch step
• Jolokia
  • URL / Creating your resource watches using the detyped API
• JPA
  • working with / Working with JPA
  • Native SQL / Coding queries for your application
  • Java Persistence Query Language (JPQL) / Coding queries for your application
  • Criteria API / Coding queries for your application
• JPA Query Language (JPQL) / Java Persistence API 2.1 – JSR 338
• JSF 2 facet suggestions / JSF 2 facet suggestions
• JSF Managed Beans
  • about / Are EJBs and JSF Managed Beans obsolete?
• JSF view
  • coding / Coding the JSF view
• JSON
  • URL / Adding REST to our ticket example
  • POJOs, transforming to / Transforming POJOs to JSON
• JSR-107 / WildFly clustering
• JSR-339
  • URL / Developing REST-based web services
• JUnit
  • URL / Writing an Arquillian test
• Jython installer
  • URL / Using scripting languages to wrap CLI execution

K

• keepalive-time, executor service / Using concurrency utilities in Java EE
• keytool / Certificate management tools
• Kryo
  • URL / Transforming POJOs to JSON

L

• local business interface / EJB 3.2 – an overview
• login module
  • used, in Ticket web application / Using the login module in the Ticket web application

M

• @Model stereotype / Making your application rich
• managed executor services
  • advantages, over standard ones / Using concurrency utilities in Java EE
• ManagedTask interface / Introducing threads to enterprise beans
• management model descriptions
  • reading, via raw management API / Reading management model descriptions via the raw management API
• mappedBy attribute / Cooking entities
• Maven
  • installing / Installing Maven
• Maven build command / Building and deploying the application
• Maven configuration
  • adding / Adding the Maven configuration
• Maven installation
  • about / Installing Maven
  • URL / Installing Maven
  • references / Installing Maven
  • testing / Testing the installation
• Maven project
  • creating / Rethinking your ticketing system, Creating the Maven project
  • Maven configuration, adding / Adding the Maven configuration
  • entities, adding / Cooking entities
  • Bean Validation, adding / Adding Bean Validation
• Maven projects
  • benefits / Developing singleton EJBs
• Maven repository
  • URL / A real-world example – HornetQ and ActiveMQ integration
• max-threads, executor service / Using concurrency utilities in Java EE
• MDB instance life cycle, states
  • Does not Exist / Adding message-driven beans to your application
  • Method ready Pool / Adding message-driven beans to your application
• message-driven beans
  • adding, to application / Adding message-driven beans to your application
  • advantages / Adding message-driven beans to your application
  • implementing / Cooking message-driven beans
  • JMS producer, adding / Adding the JMS producer
  • application, deploying / Compiling and deploying the application
  • application, compiling / Compiling and deploying the application
  • message selectors, specifying / Specifying which message to receive using selectors
• Message-driven beans (MDB) / EJB 3.2 – an overview
• Message-driven beans (MDBs)
  • about / Adding message-driven beans to your application
• message consumer / The building blocks of JMS
• message producer / The building blocks of JMS
• message selectors
  • specifying / Specifying which message to receive using selectors
• module-name element / Creating a remote EJB client
• multicast / WildFly clustering

N

• name attribute / Changing the deployment scanner properties, Configuring persistence
• named beans / Named beans
• Native SQL / Coding queries for your application
• NetBeans
  • URL / Alternative development environments
• New Input-Output (NIO) / The JBoss messaging subsystem
• new user
  • creating, details / Managing WildFly 8 with the web interface
• No-interface view / EJB 3.2 – an overview
• nondurable subscription / A short introduction to JMS
• nonpersistent delivery mode / A short introduction to JMS
• notations, resource address
  • node-type / Determining the resource address
  • node-name / Determining the resource address

O

• @OnClose annotation / Creating our first endpoint
• @OnError annotation / Creating our first endpoint
• @OneToMany annotation / Cooking entities
• @OnMessage annotation / Creating our first endpoint
• @OnOpen annotation / Creating our first endpoint
• @org.jboss.ejb3.annotation.SecurityDomain annotation / Securing EJBs
• observer
  • about / Creating the beans
• operations
  • performing, on resources / Performing operations on resources
• overriding pools, beans
  • URL / Adding message-driven beans to your application

P

• @Producer annotation
  • advantages / Creating the beans
• Page Object
  • about / Additional information
• passwords
  • encrypting / Encrypting passwords
• path attribute / Changing the deployment scanner properties
• Path Relative to attribute / Changing the deployment scanner properties
• persistence
  • adding, to application / Adding persistence to our application
  • database, setting up / Setting up the database
  • JDBC driver, installing in WildFly / Installing the JDBC driver in WildFly
  • configuring / Configuring persistence
  • producer classes, adding / Adding producer classes
  • queries, coding for application / Coding queries for your application
  • services, adding to application / Adding services to your application
  • controller, adding to drive user requests / Adding a controller to drive user requests
  • JSF view, coding / Coding the JSF view
  • example, running / Running the example
  • testing / Persistence testing
• persistent delivery mode / A short introduction to JMS
• Plain Old Java Object (POJO) / Data persistence meets the standard, Creating our first endpoint
• Plain Old Java Objects (POJOs) / The JBoss messaging subsystem
• plugin, for JBoss
  • URL / Creating your resource watches using the detyped API
• point-to-point (PTP) / The building blocks of JMS
• POJOs
  • transforming, to JSON / Transforming POJOs to JSON
• POJO web service
  • developing / Developing a POJO web service
• pom.xml file
  • configuring / Configuring the pom.xml file
• PostgreSQL database
  • URL / Adding persistence to our application
• PostgreSQL JDBC driver
  • URL / Installing the JDBC driver in WildFly
• producer classes
  • adding / Adding producer classes
• profiles, WildFly domain
  • default / The domain controller configuration
  • full / The domain controller configuration
  • ha / The domain controller configuration
  • full-ha / The domain controller configuration
• programmatic security / Approaching the Java security API
• programmatic timers / Using the EJB timer service
• project object module, client
  • configuring / Configuring the client's project object module
• public-key cryptography / Securing the transport layer
• publish/subscribe (pub/sub) / The building blocks of JMS
• Puppet
  • URL / Launching the CLI

Q

• queries
  • coding, for application / Coding queries for your application
• queues
  • about / The building blocks of JMS

R

• @RequestScoped scope / CDI scopes
• ra.xml file / Installing the ActiveMQ resource adapter
• rar-info command shell / Installing the ActiveMQ resource adapter
• raw management API
  • used, for managing application server / Using the raw management API to manage the application server
  • management model descriptions, reading via / Reading management model descriptions via the raw management API
  • resource watches creating, detyped API used / Creating your resource watches using the detyped API
• read-resource command / Performing operations on resources
• readItem method / Creating a chunk-based batch step
• RealmDirect login module / The WildFly security subsystem
• receive() method / A short introduction to JMS
• remote.connections property / Adding the EJB client configuration
• remote business interface / EJB 3.2 – an overview
• RemoteConnectionFactory / Creating and using connection factories
• remote EJB client
  • creating / Creating a remote EJB client
  • project object module, configuring / Configuring the client's project object module
  • EJB client, coding / Coding the EJB client
  • client application, running / Running the client application
  • EJB timer service, using / Using the EJB timer service
  • asynchronous methods, adding to EJBs / Adding asynchronous methods to our EJBs
• remote hosts
  • connecting from / Connecting from remote hosts
• Remote Procedure Call / Developing a POJO web service
• required dependencies
  • adding / Adding the required dependencies
• resource adapter module / Developing singleton EJBs
• resource address
  • determining / Determining the resource address
• resources
  • operations, performing on / Performing operations on resources
  • tab completion helper, using / Using the tab completion helper
• resource watches
  • creating, detyped API used / Creating your resource watches using the detyped API
• REST
  • adding, to ticket example / Adding REST to our ticket example
• REST-based web services
  • developing / Developing REST-based web services
  • REST resources, accessing / Accessing REST resources
  • JBoss REST web services / JBoss REST web services
• REST resources
  • accessing / Accessing REST resources
• REST service
  • consuming / Consuming our REST service
  • and SOAP service, selecting between / Choosing between SOAP and REST services
• retrieveAllSeatTypes method / Adding producer classes
• RFC 6455
  • URL / An overview of WebSockets
• RichFaces
  • URL / Combining the scheduler into our application
  • installing / Installing RichFaces
  • implementing / Making your application rich
• Role-based security
  • about / Role-based security
  • administrative operations, auditing / Auditing administrative operations
• Role Based Access Control (RBAC) / New features in WildFly
• root folder, JBOSS_HOME
  • bin / The WildFly 8 directory layout
  • bin/client / The WildFly 8 directory layout
  • bin/init.d / The WildFly 8 directory layout
  • bin/service / The WildFly 8 directory layout
  • docs/examples / The WildFly 8 directory layout
  • docs/schema / The WildFly 8 directory layout
  • domain / The WildFly 8 directory layout
  • modules / The WildFly 8 directory layout
  • standalone / The WildFly 8 directory layout
  • appclient / The WildFly 8 directory layout
  • welcome-content / The WildFly 8 directory layout
• run() method / Coding the EJB client
• running instance
  • patching / Patching a running instance
• Runtime tab / Launching the web console

S

• @Schedule annotation / Scheduling timer events
• @SessionScoped scope / CDI scopes
• sample content, of XML file
  • URL / WildFly CDI implementation
• SASL_POLICY_NOANONYMOUS option / Connecting to an SSL-aware security realm
• Scan Interval attribute / Changing the deployment scanner properties
• scheduler
  • combining, into application / Combining the scheduler into our application
• scheduler, into application
  • RichFaces, installing / Installing RichFaces
  • RichFaces, implementing / Making your application rich
  • application, running / Running the application
  • interceptors, creating / Creating interceptors
• scopes, CDI
  • @RequestScoped / CDI scopes
  • @ConversationScoped / CDI scopes
  • @SessionScoped / CDI scopes
  • @ApplicationScoped / CDI scopes
  • @Dependent / CDI scopes
• scripting languages
  • used, for wrapping CLI execution / Using scripting languages to wrap CLI execution
• Seam 3 project
  • URL / WildFly CDI implementation
• SeatType object / Adding a controller to drive user requests
• Secure Socket Layer
  • enabling, on WildFly / Enabling the Secure Socket Layer on WildFly
• Secure Socket Layer, on WildFly
  • certificate management tools / Certificate management tools
  • HTTP communication, securing with self-signed certificate / Securing the HTTP communication with a self-signed certificate
  • server certificate, generating / Generating the server and client certificates
  • client certificate, generating / Generating the server and client certificates
  • SSL-aware security realm, creating / Creating an SSL-aware security realm
  • HTTP communication, securing with certificate signed by CA / Securing HTTP communication with a certificate signed by a CA
  • EJB communication, securing / Securing EJB communication
  • SSL-aware security realm, connecting to / Connecting to an SSL-aware security realm
• self-signed certificate
  • HTTP communication, securing with / Securing the HTTP communication with a self-signed certificate
• send method / Expanding our client application
• sendText method / Transforming POJOs to JSON
• serialization / Programming considerations to achieve HA
• Server-Sent Events (SSE)
  • about / An alternative to WebSockets
• server certificate
  • generating / Generating the server and client certificates
• server components
  • installing / Installing the server and client components
  • Java SE, installing / Installing Java SE
  • Eclipse environment, installing / Installing the Eclipse environment
  • development environments / Alternative development environments
  • Maven, installing / Installing Maven
• server endpoint listener / A brief look at the JAX WS architecture
• server groups
  • deploying to / Deploying to all server groups
• servers
  • data / The WildFly 8 directory layout
  • log / The WildFly 8 directory layout
  • tmp / The WildFly 8 directory layout
  • restarting, in domain / Restarting servers in a domain
• Service Endpoint Interface (SEI) / EJB3 Stateless Session Bean (SLSB) web services
• services
  • adding, to application / Adding services to your application
• session / The building blocks of JMS
• session beans
  • about / EJB 3.2 – an overview
  • Stateless session beans (SLSB) / EJB 3.2 – an overview
  • Stateful session beans (SFSB) / EJB 3.2 – an overview
  • singleton EJB / EJB 3.2 – an overview
  • local business interface / EJB 3.2 – an overview
  • remote business interface / EJB 3.2 – an overview
  • No-interface view / EJB 3.2 – an overview
  • cooking / Cooking session beans
• Session parameter / Creating our first endpoint
• shell command / Launching the CLI
• ShinkWrap Resolver
  • URL / ShrinkWrap Resolver
• ShrinkWrap
  • URL / Writing your first Arquillian test
• ShrinkWrap Descriptors / ShrinkWrap Descriptors
• ShrinkWrap Resolver / ShrinkWrap Resolver
• Simple Authentication and Security Layer (SASL) / Connecting to an SSL-aware security realm
• single server group
  • deploying to / Deploying to a single server group
• singleton EJB / EJB 3.2 – an overview
• singleton EJBs
  • developing / Developing singleton EJBs
  • EJB module / Developing singleton EJBs
  • web module / Developing singleton EJBs
  • resource adapter module / Developing singleton EJBs
  • Enterprise archive / Developing singleton EJBs
  • EJB project object module (pom.xml), configuring / Configuring the EJB project object module (pom.xml)
  • EJB application, coding / Coding our EJB application
  • bean concurrency, controlling / Controlling bean concurrency
  • session beans, cooking / Cooking session beans
  • stateless bean, adding / Adding a stateless bean
  • stateful bean, adding / Adding a stateful bean
• SOAP-based web services
  • developing / Developing SOAP-based web services
  • building, strategies / Strategies to build SOAP-based web services
  • JBoss SOAP-based web services stack / JBoss SOAP-based web services stack
  • JAX WS architecture / A brief look at the JAX WS architecture
  • coding, with WildFly / Coding SOAP web services with WildFly
• SOAP service
  • and REST service, selecting between / Choosing between SOAP and REST services
• SoapUI
  • about / Testing our simple web service
• SOAP web services, approaches
  • top-down approach / Strategies to build SOAP-based web services
  • bottom-up approach / Strategies to build SOAP-based web services
• SOAP web services, with WildFly
  • POJO web service, developing / Developing a POJO web service
  • inspecting, from console / Inspecting the web service from the console
  • testing / Testing our simple web service
  • EJB3 Stateless Session Bean (SLSB) web services / EJB3 Stateless Session Bean (SLSB) web services
  • web service consumer, developing / Developing a web service consumer
• Spock
  • used, for running Arquillian tests / Running Arquillian tests using Spock
  • about / Running Arquillian tests using Spock
  • URL / Running Arquillian tests using Spock
• src folder, Arquillian
  • main/java/ / Getting started with Arquillian
  • main/resources/ / Getting started with Arquillian
  • test/java/ / Getting started with Arquillian
  • test/resources/ / Getting started with Arquillian
• SSL-aware security realm
  • creating / Creating an SSL-aware security realm
  • connecting to / Connecting to an SSL-aware security realm
• SSL_ENABLED option / Connecting to an SSL-aware security realm
• standalone cluster / WildFly clustering
• standalone mode tree
  • configuration / The WildFly 8 directory layout
  • data / The WildFly 8 directory layout
  • deployments / The WildFly 8 directory layout
  • lib/ext / The WildFly 8 directory layout
  • log / The WildFly 8 directory layout
  • tmp / The WildFly 8 directory layout
• STARTTLS option / Connecting to an SSL-aware security realm
• stateful bean
  • adding / Adding a stateful bean
• Stateful Session Bean (SFSB) / Creating HA Stateful Session Beans
• Stateful session beans (SFSB) / EJB 3.2 – an overview
• stateless bean
  • adding / Adding a stateless bean
• Stateless Session Bean (SLSB) / Deploying clustered applications
• Stateless session beans (SLSB) / EJB 3.2 – an overview
• stereotypes / Creating the beans
• sticky web sessions / Achieving HA in JSF applications
• String parameter / Creating our first endpoint
• subscription
  • durable / A short introduction to JMS
  • nondurable / A short introduction to JMS
• symmetric encryption / Securing the transport layer
• synchronously / A short introduction to JMS

T

• @Transactional annotation / Are EJBs and JSF Managed Beans obsolete?
• tab completion helper
  • using / Using the tab completion helper
• Task steps / The overview of the batching framework
• testing
  • instruments, used for / Instruments used for testing
• test types
  • about / Test types
  • instruments, used for testing / Instruments used for testing
• then construction / Running Arquillian tests using Spock
• threads
  • introducing, to enterprise beans / Introducing threads to enterprise beans
• ticket example
  • REST, adding to / Adding REST to our ticket example
  • compiling / Compiling our ticket example
• ticketing system
  • rethinking / Rethinking your ticketing system
  • required dependencies, adding / Adding the required dependencies
• Ticket web application
  • login module, using / Using the login module in the Ticket web application
• timeout method / Programmatic timer creation
• timer
  • creating / Programmatic timer creation
• timer events
  • scheduling / Scheduling timer events
• top-down approach / Strategies to build SOAP-based web services
• transaction mode / Transaction and acknowledgment modes
• transport layer
  • securing / Securing the transport layer
  • Secure Socket Layer, enabling on WildFly / Enabling the Secure Socket Layer on WildFly
• transport layer security
  • URL / Securing the transport layer
• Tunneled Transport Layer Security (TTLS) / Connecting to an SSL-aware security realm
• Tyrus
  • URL / Transforming POJOs to JSON
  • about / WebSockets testing

U

• ui$composition element
  • about / Building the view
• undeploy command / Deploying applications using the command-line interface, Deploying to all server groups
• unit tests / Test types
• user authentication
  • adding / Adding user authentication
• user requests
  • driving, via controller addition / Adding a controller to drive user requests

V

• view
  • building / Building the view
  • JSF 2 facet suggestions / JSF 2 facet suggestions
• view scope
  • about / Are EJBs and JSF Managed Beans obsolete?
• Vim, with python-mode
  • URL / Using scripting languages to wrap CLI execution

W

• @WebMethod attribute / Developing a POJO web service
• @WebParam annotation / Developing a POJO web service
• @WebResult annotation / Developing a POJO web service
• web application
  • load balancing / Load balancing your web applications
• web application, clustering
  • about / Web application clustering, Clustering your web applications
  • programming considerations, for achieving HA / Programming considerations to achieve HA
  • HA, achieving in JSF applications / Achieving HA in JSF applications
• web application, load balancing
  • about / Load balancing your web applications
  • mod_cluster, installing / Installing mod_cluster
• web console
  • launching / Launching the web console
  • Configuration tab / Launching the web console
  • Runtime tab / Launching the web console
  • Administration tab / Launching the web console
  • deployments, managing with / Managing deployments with the web console
  • deployment scanner properties, changing / Changing the deployment scanner properties
• WebDriver
  • about / Additional information
• web interface
  • WildFly 8, managing with / Managing WildFly 8 with the web interface
• WebJars
  • URL / Coding the JSF view
• web module / Developing singleton EJBs
• web service consumer
  • developing / Developing a web service consumer
• web services
  • securing / Securing web services
• WebSockets
  • overview / An overview of WebSockets
  • advantages / An overview of WebSockets
  • working / How do WebSockets work
  • alternative to / An alternative to WebSockets
  • testing / WebSockets testing
• when construction / Running Arquillian tests using Spock
• WildFly
  • overview / An overview of Java EE and WildFly
  • using, with EAP / WildFly and Enterprise Application Platform
  • features / New features in WildFly
  • URL / Installing WildFly, Clustering the Ticket example
  • installing / Installing WildFly
  • initializing / Starting WildFly
  • terminating / Stopping WildFly
  • shutdown script, locating / Locating the shutdown script
  • terminating, on remote machine / Stopping WildFly on a remote machine
  • restarting / Restarting WildFly
  • JDBC driver, installing in / Installing the JDBC driver in WildFly
  • SOAP web services, coding with / Coding SOAP web services with WildFly
  • access control strategies / Role-based security
  • Secure Socket Layer, enabling on / Enabling the Secure Socket Layer on WildFly
• WildFly 8
  • core concepts / WildFly 8 core concepts
  • advantages / WildFly 8 core concepts
  • directory layout / The WildFly 8 directory layout
  • managing, with web interface / Managing WildFly 8 with the web interface
  • first application, deploying to / Deploying your first application to WildFly 8
  • advanced Eclipse deployment, options / Advanced Eclipse deployment options
  • applications deploying, command-line interface used / Deploying applications using the command-line interface
• WildFly built-in memory H2 database
  • URL / Configuring persistence
• WildFly CDI implementation / WildFly CDI implementation
• WildFly CLI
  • about / Entering the WildFly CLI
  • launching / Launching the CLI
  • remote hosts, connecting from / Connecting from remote hosts
  • used, in graphical mode / Using a CLI in the graphical mode
  • CLI commands, constructing / Constructing CLI commands
  • used, for deploying applications / Deploying applications using the CLI
  • CLI scripts, creating / Creating CLI scripts
• WildFly clustering
  • about / WildFly clustering
  • standalone nodes cluster, initiating / Starting a cluster of standalone nodes
  • domain nodes cluster, initiating / Starting a cluster of domain nodes
• WildFly documentation
  • URL / Auditing administrative operations, The WildFly security subsystem
• WildFly domain
  • applications, deploying to / Deploying applications to a WildFly domain
• WildFly modules
  • categories / WildFly CDI implementation
• WildFly nodes
  • application, deploying to / Deploying an application to several WildFly nodes
• WildFly security subsystem / The WildFly security subsystem
• WSDL
  • URL / Developing SOAP-based web services