Desarrollo de Aplicaciones con Java EE 8

Java Enterprise Edition 8 (Java EE8), es la ultima versión de la especificación de Java EE, agrega varias características nuevas a la especificación anterior. Varias APIs que ya existían han sido mejoradas en esta versión, y otras APIs nuevas han sido agregadas. Este curso cubre la ultima versión de la especificación de Java EE, el cual es la más popular, incluye JavaServer Faces (JSF), Java Persistence API (JPA), Enterprise JavaBeans (EJB), Contexts and Dependency Injection (CDI), JSON Processing JSON-P, JSON Binding (JSON-B), WebSocket, Java Messaging Service JMS, JAX-WS, JAX-RS. También cubre aspectos de seguridad en las aplicaciones Java EE con la nueva de seguridad para Java EE.

Si deseas conocer la lista completa de los cambios y APIs agregadas puedes consultar la entrada Qué hay de nuevo en Java EE 8

Tabla de Contenidos

Capitulo 1: Introducción a Java EE

Capitulo 2: JavaServer Faces
Capitulo 3: Persistencia de datos con JPA
Capitulo 4: Enterprise Java Beans
Capitulo 5: Contexto e Inyección de Dependencias
Capitulo 6: 

Crear servicios REST en Java en 10 minutos

Esta es una guía practica para crear un par de servicios RESTful, si deseas conocer los conceptos teóricos de este estilo de arquitectura te recomiendo leer los siguientes enlaces.

API Rest ¿Que es? y sus ventajas

Aspectos básicos de RESTful

Introduccion a RESTful

Por allá en el 2013 tuve un tímido acercamiento a la plataforma Java EE, todavía era una plataforma compleja. Para implementar unos servicios REST era necesario implementar interfaces, extender clases abstractas y configurar archivos XML. La plataforma ha evolucionado con el tiempo para bien, haciendo más facil el desarrollo de los servicios REST gracias a las anotaciones las cuales reemplazan las configuraciones de archivos XML. Gracias a estas mejoras podemos crear un par de servicios REST en 10 minutos o menos. Vamos a por ello!!

Requerimientos

Java 8

Wildfly 12

Netbeans 8.2 con Maven y soporte para Java EE

Presentación de los servicios a crear

Vamos a crear dos servicios, uno para persistir la información de una persona y otro para consultar la información de una persona. En ambos servicios usaremos JSon para representar los datos de una persona.

1.- Crear el proyecto web demo-rest

Nuevo Projecto → Maven → Web Application

En project name ingresar demo-rest

En package ingresar demo.rest

2.- Creamos la clase Persona para encapsular los datos de un objeto persona

/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package demo.rest.domain; import java.io.Serializable; /** * * @author Roberto Lopez */ public class Persona implements Serializable { private String name; private String lastname; private int age; public Persona(){ name = ""; lastname = ""; age = 0; } /** * @return the name */ public String getName() { return name; } /** * @param name the name to set */ public void setName(String name) { this.name = name; } /** * @return the lastname */ public String getLastname() { return lastname; } /** * @param lastname the lastname to set */ public void setLastname(String lastname) { this.lastname = lastname; } /** * @return the age */ public int getAge() { return age; } /** * @param age the age to set */ public void setAge(int age) { this.age = age; } @Override public String toString(){ return "[name=" + name + ", lastname=" + lastname+ "]"; } }

1. La clase Persona implementa a la interface Serializable
2. La clase Persona tiene un constructor sin parametros

3.- Creamos la clase de los servicios POST y GET para el recurso Persona

/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package demo.rest.domain; import java.net.URI; import java.util.HashMap; import java.util.Map; import javax.ws.rs.Consumes; import javax.ws.rs.GET; import javax.ws.rs.POST; import javax.ws.rs.Path; import javax.ws.rs.PathParam; import javax.ws.rs.Produces; import javax.ws.rs.core.Context; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import javax.ws.rs.core.UriInfo; /** * * @author Roberto Lopez */ @Path("/persona") public class PersonaRestService { private static final Map<Integer, Persona> personasMap = new HashMap<>(); @Context private UriInfo uriInfo; public PersonaRestService(){ System.out.println("creando una instancia de PersonaRestService"); } @POST @Consumes(MediaType.APPLICATION_JSON) public Response addPersona(Persona persona) { System.out.println("addPersona(" + persona +")"); Integer id = (personasMap.size() + 1); personasMap.put(id, persona); URI uri = uriInfo.getAbsolutePathBuilder().path(id.toString()).build(); return Response.created(uri).build(); } @GET @Path("/{id}") @Produces(MediaType.APPLICATION_JSON) public Persona getPersona(@PathParam("id") Integer id){ if(!personasMap.containsKey(id)){ return null; } return personasMap.get(id); } }

Como podrás observar, esta es una clase común y corriente pero que tiene algunas anotaciones propias para el soporte de REST javax.ws.rs.*, las cuales serán reconocidas por el servidor de aplicaciones para finalmente exponer el servicio, analicemos para que esta cada una de ellas.

La anotación @Path indica la URL en la cual responderá este servicio, cabe mencionar que esta anotación se puede poner a nivel de clase y método, en este caso, al estar a nivel de clase, afecta a todos los servicios que definamos.

La anotación @Context permite inyectar un objeto de la clase UriInfo
Las anotaciones @Consumes y @Produces son para indicar que tipo de mensaje esperamos como entrada (consumes) y que tipo de mensaje vamos a responder (produces). En este caso, estamos indicando que esperamos JSON como entrada y que vamos a responder igualmente con JSON. La plataforma REST se encargar de parsear el mensaje JSon a objeto y viceversa.

La anotación @POST indica que nuestro método addPersona va a procesar las peticiones POST y la anotación @GET inicia que nuestro método getPersona va a procesar las peticiones GET.
El método getPersona devuelve la información de una persona en formato JSon
La anotación @Path("/{id}") y @PathParam("id") están relacionadas, nos permite obtener el id de la URL como un parámetro para nuestro método getPersona

4.- Extendemos la clase Abstracta ApplicationInfo

/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package demo.rest.domain; import java.util.Set; import javax.ws.rs.core.Application; /** * * @author Roberto Lopez */ @javax.ws.rs.ApplicationPath("rest") public class ApplicationConfig extends Application { @Override public Set<Class<?>> getClasses() { Set<Class<?>> resources = new java.util.HashSet<>(); resources.add(demo.rest.domain.PersonaRestService.class); return resources; } }

Debemos extender la clase javax.ws.rs.core.Application para registrar nuestra clase que implementa nuestros servicios REST.
Observar que esta clase también tiene la anotación @javax.ws.rs.ApplicationPath("rest") donde rest formará parte de la URL http://localhost:8080/demo-rest-1.0-SNAPSHOT/rest/persona de nuestro servicio.

5.- Clean and Build
Hacemos un Clean Build y Ejecutamos. Netbeans se encarga de desplegar nuestra aplicación web e iniciar el servidor WildFly

6.- Probar los servicios
Para probar nuestros servicios yo utilizo RestClient https://github.com/wiztools/rest-client/releases la versión GUI, restclient-ui-fat-3.7.1.jar
Las URL de nuestro servicio es http://localhost:8080/demo-rest-1.0-SNAPSHOT/rest/persona/ el cual se construye a partir de http://localhost:8080/{nombre_aplicacion}/rest/persona/

Observar que he seleccionado String body como tipo de contenido y application/json como formato y UTF-8 como codificación.

Puedes descargar el código fuente desde mi repositorio en GitHub 

El protocolo HTTP

¿Por qué debo conocer el protocolo el HTTP?

En Java es muy común usar la tecnología Servlets y RESTful para crear aplicaciones Cliente-Servidor, estas tecnologías usan el protocolo HTTP, para nosotros es transparente y podríamos pasar por alto este protocolo. Sin embargo, tener conocimientos del protocolo HTTP no está de más, y si eres curioso como yo, estarás deseoso de saber como funciona este protocolo.

El protocolo HTTP (Hypertext Transfer Protocol) es un estandard que define como un cliente web se comunica con un servidor y como la información es transferida desde el servidor hacía el cliente. Aunque HTTP es usualmente usado para transferir documentos HTML e imágenes embebidos en el documento HTML, HTTP es agnóstico al formato de los datos. HTTP puede ser usado para transferir imágenes, documentos Word, programas .exe, o cualquier cosa que pueda ser representado en bytes. Para escribir programas que usen HTTP, tu necesitas entender HTPP a un nivel de profundidad mucho mayor que el de un diseñador de paginas web. Escribiré una serie de entradas con el fin de mostrarte lo que pasa detrás del telón cuando tu ingresas un dirección web en la barra de tu navegador web.

HTTP es el protocolo estandard para la comunicación entre navegadores web y servidores web. HTTP especifica como un cliente y un servidor establecen una conexión, como el cliente solicita datos al servidor, como el servidor responde a esta petición, y finalmente, como la conexión es cerrada. 

Curso de Java Server Faces

Este año me he metido de fondo en el desarrollo de aplicaciones Web, usando las tecnologías de Java EE. He investigado y practicado mucho, y para mi practica profesional he desarrollado una aplicación Web.

No quiero que todo el esfuerzo que he realizado se desaproveche, lograr mi proyecto terminal fue todo un reto por desconocer la tecnología Java EE, así que estaré documentando todo lo aprendido en este curso de Java Server Faces. Disfrútalo.

¿Como subir una aplicacion Java EE a un servidor gratuito?

En la Universidad para mi proyecto de practica me han pedido subir mi prototipo a un servidor en Internet. No tenía idea de como hacerlo, el proceso me tomo al menos un día. Como siempre, me gusta documentar estos procesos que en un principio parecen complicados, documentación que me sirve para reforzar lo aprendido y al mismo tiempo que les sea útil al resto.

He descartado opciones como Google Cloud y Amazon Cloud, ya que mis cuentas de pruebas gratuitas están expiradas. La opción mas practica que encontré fue Servnet Telecomunicaciones  https://app.jl.serv.net.mx/

Desafiando a la plataforma JEE

Son alrededor de las 23:00 horas, he tenido una día agotador, actualmente me encuentro desarrollando una API RESTFul. Para ello estoy usando JAX-RS, EJB, CDI,  JPA y JAXB. Ha sido desafiante porque las cosas no me salen a la primera, o me funciona pero a medida que voy incorporando más componentes deja de funcionar. La complejidad de Java EE está en la integración, hay muchos componentes involucrados y cada uno de ellos cuentan con reglas especificas que debemos conocer para asegurar el buen funcionamiento.

Mi estrategia ante una nueva plataforma o tecnología, es empezar paso a paso, si algo dejó de funcionar, volver atrás, observar mucho los logs, poner atención a cada detalle, como dice la frase "el diablo está en los detalles". Hay que ser muy astuto, tener olfato, tener colmillo, usar el sentido común, la lógica, la intuición. Si no, la frustración te consumirá.

Pero bueno, paso a paso estoy logrando los objetivos, así que... ahora sí voy enserio con JEE

Tutorial Basico PrimeFaces

Esta guía contiene los siguientes puntos

• ¿Que es PrimeFaces?
• Prerrequisitos
• Crear el proyecto en Netbeans
• Agregar la dependencia PrimeFaces a nuestro archivo pom.xml
• Crear nuestra página index.xhtml
• Agregar nuestro descriptor de despliege

¿Que es PrimeFaces?

PrimeFaces es una suite de componentes gráficos (botones, menús, listas, listas desplegables, tablas, paneles, dialogos y otros) para crear interfaces gráficas de usuarios para aplicaciones web. Prime Faces es una extensión de JSF(Java Server Faces). He usado esta suite para desarrollar aplicaciones JEE, existe una extensa documentación pero solo en ingles, es por ello que me nació la iniciativa de escribir un guía básica, la verdad es que PrimeFaces no es muy complejo, si has trabajado con JSF te adaptarás muy rapido.

Algunas características de PrimeFaces

• Se compone de un amplio catalogo de componentes, editores Html, dialogos, cuadros de textos que se autocompletan, graficas y mucho más.
• Se basa en APIs de Ajax y en el estandard JSF
• Ligero, un solo jar, no requiere dependencias y cero configuraciones
• Cuenta con un kit para desarrollo mobile
• Cuenta con 35 temas y herramienta para diseñar mas temas
• Extensa documentación pero solo en ingles
• Tiene una comunidad grande y activa
• Desarrollado con pasión, de desarrolladores de aplicaciones para desarrolladores de aplicaciones.

En esta guía básica solo mostraremos un popup con el mensaje "Hola Mundo desde PrimeFaces"

Prerrequisitos
Java JDK 6 o Java JDK 7
JBoss AS 7.1.1 Final
Netbeans 8.1 con Maven y Soporte para Java Web y JEE

Si tienes dudas con la instalación y configuración de JBoss, te recomiendo revisar mi entrada anterior Instalar jbossas7 en windows

JBoss AS 7, viene con Mojarra, el cual es una implementación de Java Server Faces versión 2.0

1.- Crear el proyecto en Netbeans
Crearemos un proyecto en Netbeans, File, New Project. En categories seleccionamos Maven y en projects seleccionamos Web Application, Next.

Ingresamos los siguientes datos, Next.

Seleccionamos el servidor JBoss as 7, Finish.

2.- Agregar la dependencia PrimeFaces a nuestro archivo pom.xml
Vamos a usar la version 5.3 de PrimeFaces, lo podemos hacer de dos formas, la primera es editando  el archivo pom.xml y agregar el siguiente extracto de xml

        <dependency>
            <groupId>org.primefaces</groupId>
            <artifactId>primefaces</artifactId>
            <version>5.3</version>
        </dependency>

La segunda opción es agregarlo de forma gráfica, en el navegador del proyecto, seleccionar Dependencies, click derecho Add Dependency

Add

3.- Crear nuestra página index.xhtml
En el navegador del proyecto, seleccionamos el directorio Web Pages, click derecho, New,  Other, en Categories seleccionamos Web y en Files Type seleccionamos XHTML, Next.
En el siguiente Dialogo, ingresar el nombre index

Editamos la página, lo más relevante de nuestra página

El namespace de primefaces
xmlns:p="http://primefaces.org/ui"

El tag contenedor de Java Faces
<f:view contentType="text/html">

El resto son los componentes gráficos, aquí tienes la página completa.

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html" xmlns:f="http://java.sun.com/jsf/core" xmlns:p="http://primefaces.org/ui"> <f:view contentType="text/html"> <h:head> <title>PrimeFaces Demo</title> </h:head> <body> <h2> PrimeFaces Demo</h2> <h:form> <h:panelGrid columns="1" cellpadding="5"> <p:commandButton value="Abrir Dialogo" type="button" onclick="PF('dlg1').show();" /> </h:panelGrid> <p:dialog header="Basic Dialog" widgetVar="dlg1" minHeight="40"> <h:outputText value="Hola Mundo desde PrimeFaces!" /> </p:dialog> </h:form> </body> </f:view> </html>

4.- Agregar nuestro descriptor de despliege
En el navegador de proyecto, seleccionamos el directorio Web Pages, click derecho, New, Other, en Categories seleccionamos Web y en Files Type seleccionamos Standard Deployment Descriptor (web.xml)

<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"> <servlet> <servlet-name>Faces Servlet</servlet-name> <servlet-class>javax.faces.webapp.FacesServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>Faces Servlet</servlet-name> <url-pattern>*.jsf</url-pattern> </servlet-mapping> <servlet-mapping> <servlet-name>Faces Servlet</servlet-name> <url-pattern>*.xhtml</url-pattern> </servlet-mapping> <context-param> <param-name>javax.faces.PROJECT_STAGE</param-name> <param-value>Development</param-value> </context-param> <session-config> <session-timeout>60</session-timeout> </session-config> <welcome-file-list> <welcome-file>index.xhtml</welcome-file> </welcome-file-list> </web-app>

Algunos tutoriales te dirán que debes tener el archivo de configuración faces-config.xml, para este ejemplo simple no es necesario.

Aquí puedes descargar el proyecto para Netbeans

Ejecutar
Siempre recomiendo primero hacer un Clean and Build y luego Run, la aplicación se desplegará en el navegador por defecto.

Conclusión

Java Server Faces ha evolucionado mucho, ahora es más simple sin tantos archivos de configuraciones como lo era en un inicio. PrimeFaces es una suite de componentes enriquecidos, facil de usar y que no requiere de dependencias ni configuraciones.

Referencia
https://www.primefaces.org/documentation/

Deployar Petstore en Java EE 6 con JBoss AS 7 mas Netbeans 8.1

Sun llegó a crear una aplicación web llamada Java Petstore, esta aplicación fue diseñada para mostrar como la tecnología J2EE(Java Enterprise Edition 2) podía ser empleada para desarrollar una aplicación web eCommerce. Sí, el objetivo de Petstore es vender mascotas en linea.

La aplicación Petstore llegó a ser tan popular, pero en esos tiempos, la versión J2EE era muy compleja, muchos archivos de configuración, muchas interfaces por implementar y usaba muchos patrones de diseños que hoy están obsoletos.

En 2013 cuando quise aprender Java JEE 5 encontré una adaptación de la aplicación Petstore para Java EE 5, YAPS Petstore, desarrollado por un arquitecto Francés de nombre Antonio Goncalves, traté de estudiar el código de la aplicación pero habían tantas tecnologías involucradas y lo complejo que eran termino por decantarme.

Este año retomé mi curso de Java EE 6, y buscando libros me entero que Antonio Goncalves ha escrito varios libros entre ellos uno para Java EE 6, y como era de suponer, ha realizado una actualización de la aplicación Petstore, en donde podemos observar el uso de nuevos patrones y APIs. Las tecnologías incluidas en la aplicación YAPS Petstore son: CDI, EJB Lite, REST interface, Bean Validation.

El objetivo de esta aplicación es:

• Usar Java EE 6 y sólo Java EE: Ningún framework externo o dependencia, incluso usa la API java.util.logging
• Mantenerlo simple: Ningún algoritmo de negocio complejo, aun así usa la mayoría de las APIs de Java EE 6, el punto es llevar la tecnología Java EE 6 en una aplicación web eCommerce.

Prerrequisitos
Java EE 6 o Java EE 7
JBoss AS 7.1.1 Final
Netbeans 8.1

Si tienes dudas con la instalación y configuración de JBoss, te recomiendo revisar mi entrada anterior

http://marcosrobertos.blogspot.com/2017/08/instalar-jboss-as-7-en-windows.html

Obteniendo y configurando el proyecto

Lo primero que haremos es obtener el código fuente desde github, lo podemos clonar o descargar, yo preferí clonarlo.

https://github.com/agoncal/agoncal-application-petstore-ee6

Abrimos el IDE Netbeans y abrimos el proyecto

Agregamos el servidor JBoss AS 7 a los servidores de Netbeans

Configurando el Data Source con MySQL

Lo primero es crear la base de datos en MySQL, yo he creado la base de datos con el nombre agoncal_petstore

Luego debemos configurar nuestro datasource en el archivo standalone.xml de JBoss,  localizado en  $JBOSS_HOME\standalone\configuration

Para definir un DataSource agregar el siguiente fragmento de xml

                
   <datasource jndi-name="java:jboss/datasources/PetStoreDS" pool-name="PetStoreDS">
      <connection-url>jdbc:mysql://localhost:3306/agoncal_petstore</connection-url>
      <driver>mysql</driver>
            <security>
               <user-name>root</user-name>
               <password>XXXXXXXXX</password>
            </security>
   </datasource>

Configurando el archivo persistence.xml
La aplicación YAPS Petstore viene configurado para una base de datos Derby, modificaremos nuestra configuración que se encuentra en el archivo persistence.xml
Agregar la siguiente linea

<jta-data-source>java:jboss/datasources/PetStoreDS</jta-data-source>

Comentamos las lineas

<!--<jta-data-source>java:global/jdbc/applicationPetstoreDS</jta-data-source> -->

<!--<property name="hibernate.dialect" value="org.hibernate.dialect.DerbyTenSevenDialect"/>-->

Nota: Guarda los cambios

Por último, editar la clase org.agoncal.application.petstore.service.DBPopulator y comentar la definición del DataSource

//@DataSourceDefinition(
//        className = "org.apache.derby.jdbc.EmbeddedDataSource",
//        name = "java:global/jdbc/applicationPetstoreDS",
//        user = "app",
//        password = "app",
//        databaseName = "applicationPetstoreDB",
//        properties = {"connectionAttributes=;create=true"}
//)


Ahora sí, ejecutamos el proyecto (Run), nos pedirá elegir el servidor. 

Instalar JBoss AS 7 en Windows

Esta entrada contiene los siguientes puntos:

• Servidor de Aplicaciones JBoss versión 7.1.1 Final
• Descargando
• Requerimientos
• Instalando
• Iniciando JBoss AS 7
• Gestionando tu servidor de aplicaciones
• Instalar el Driver JDBC para MySQL como un modulo
• Agregar servidor JBoss as 7 a Netbeans8

Servidor de Aplicaciones JBoss versión 7.1.1 Final

JBoss AS 7, es un servidor, completo y eficiente que implementa la especificación de la plataforma Java Enterprise Edition 6, está versión se caracteriza por ser un servidor completamente modular, habilitando los servicios a demanda conforme tu aplicación lo va requiriendo. La versión JBoss AS 7.1.1.Final es una versión completamente certificada de la especificación de la plataforma empresarial de Java 6. El cuadro de abajo en lista las tecnologías de la plataforma empresarial de Java 6 y cuales de ellas están soportadas en el servidor JBoss versión 7.1.1 Final

Descargando

Para descargar el servidor JBoss AS 7.1.1 Final, ingresamos al enlace

http://jbossas.jboss.org/downloads

Descargamos la versión JBoss AS 7.1.1.Final en formato .zip, la página nos muestra un popup con el  mensaje "Community projects represent the latest development releases and are not supported.", elegimos la opción "Continue Download" 

Requerimientos

Tener instalado correctamente Java SE 6 o Java SE 7, de preferencia la última actualización disponible de Java SE 6, para descargarlo puedes ir al enlace

http://www.oracle.com/technetwork/java/archive-139210.html

Instalando

Simplemente descomprimimos el archivo zip en un directorio que elijamos, en mi caso, en el directorio C:\devel\tools

Iniciando JBoss AS 7

Para inicial JBoss AS 7 usando un perfil completo en modo "standalone", en la consola de comandos windows ir al directorio $JBOSS_HOME/bin, en mi caso C:\devel\tools\jboss-as-7.1.1.Final\bin, y ejecutar.

standalone.bat

También puedes ir al directorio desde el explorar de archivos y ejecutar el archivo standalone.bat

Si todo ha ido bien, ver lo último que se mostrará en la consola.

Ahora desde el navegador web ingresar a  http://localhost:8080

Si intentas ingresar a la opción "Administration Console", se te solicitará agregar un usuario.

Gestionando tu servidor de aplicaciones 

JBoss AS7 ofrece dos mecanismos administrativos para administrar tu servidor

• Consola de administración web
• Interface de linea de comandos CLI

Por defecto JBoss AS7 es distribuido con seguridad habilitada para la administración de interfaces, esto significa que antes de conectarte usando la consola web de administración o la linea de comandos necesitarás agregar un nuevo usuario, para ello ejecutaermos el script add-user.bat que se encuentra en el directorio bin. Nos preguntará que tipo de usuario deseamos agregar. "What type of user do you wish to add?". Elegiremos la opcion a, Usuario administrador. Cuando nos solicite el Realm lo dejaremos en blanco ya que por ahora no importa, enter para continuar. Posteriormente ingresamos el nombre de usuario, la contraseña (password) y la confirmación de la contraseña.

Ingresemos nuevamente a la consola web en la opción "Administration Console", se nos pide ingresar el usuario y contraseña del usuario agregado. Si todo ha ido bien ingresaremos a la Consola de Administración.

Instalar el Driver JDBC para MySQL como un modulo
El driver JDBC para MySQL nos permitirá crear DataSources, conexiones a Base de datos, para ello necesitamos definir el driver como un modulo.
Creamos el directorio donde colocaremos los componentes de nuestro modulo. Crear el directorio mysql dentro de $JBOSS_HOME\modules\com. En mi caso el directorio C:\devel\tools\jboss-as-7.1.1.Final\modules\com.

Dentro de mysql crear otro directorio llamado main

Crear un archivo xml llamado module.xml con el siguiente contenido

<module xmlns="urn:jboss:module:1.0" name="com.mysql">
   <resources>
     <resource-root path="mysql-connector-java-5.1.9.jar"/>
   </resources>
   <dependencies>
      <module name="javax.api"/>
      <module name="javax.transaction.api"/>
    </dependencies>
</module>

Descargar el driver jdbc de mysql y colocar el jar dentro del directorio main

Tu directorio debe ser similar a la siguiente imagen

Por último agregamos el driver al archivo de configuración standalone.xml

<driver name="mysql" module="com.mysql"/>

Ahora ya podemos crear DataSources si los necesitamos

Agregar servidor JBoss as 7 a Netbeans 8
Nos ubicamos en la pestaña Services, si no está visible la activamos en opción Window(barra de herramientas), Services

Buscamos la opción Server, Add Server

En el popup, seleccionamos JBoss Application Server, Next.

Selecionamos la Ubicación del servidor, Next.

En las propiedades dejamos los valores por defecto, Finish.

Esta entrada se actualizará conforme vaya aprendiendo más sobre JBoss

Entradas Relacionadas
Deployar PetStore

Referencia

https://docs.jboss.org/author/display/AS71/Getting+Started+Guide

http://www.elarraydejota.com/habilitar-la-consola-web-de-administracion-en-jboss-as-7-y-eap-6/