APLICACIONES

MULTICAPA 3
USANDO JDBC PARA
CONECTARSE A UNA BASE DE
DATOS
Ing.Esp. DOUGLAS ACOSTA CONTRERAS
Objetivo:
En este ejercicio ud. creará una aplicación empresarial con dos módulos: Un módulo EJB
donde estará contenida la lógica del negocio y un módulo web donde estará la presentación.
Usando estas dos capas realizará la gestión de la tabla usuario (inserción, actualización y
modificación) en una base de datos
Creando la aplicación Empresarial:
1. En primer lugar se creará una aplicación empresarial que contenga dos
módulos: uno ejb y otro web. Para realizar seleccione File -> New proyect -> Java EE ->
Enterprise Application, en el campo Project Name digite taller9_1 y en Project Location
asegúrese que se encuentre el directorio donde está almacenando los talleres. Luego
de clic en next y en el listado.

Server seleccione el Glassfish v 4.x y en Java EE Versión asegúrese que

se encuentra seleccionado Java EE 7. De clic en finish y verifique que se
hayan creado tres proyectos.
Creando la base de datos:
2. En la pestaña servicios seleccione Databases y de click derecho sobre Java DB y seleccione Star
Server y luego Create DataBase. Use los siguientes datos :
Database name: tallerjee
User Name :tallerjee
Password :tallerjee

3. Verifique que se haya creado la conexión llamada

jdbc:derby://localhost:1527/tallerjee , de click derecho sobre ella y seleccione connect. Ejecute
las siguientes sentencias SQL para crear la tabla
/* Crear tabla usuario */
create table "USUARIO" (
"NOMBRES" VARCHAR(100) NOT NULL,
"APELLIDOS" VARCHAR(100) NOT NULL,
"IDENTIFICACION" VARCHAR(20) NOT NULL,
"ID" INTEGER GENERATED always AS IDENTITY
);
/* adicionar llave primaria */
alter table "USUARIO" add constraint usuarioPK PRIMARY KEY ("ID");
/* adicionar constraint de unicidad */
alter table "USUARIO" add constraint identificacionU UNIQUE ("IDENTIFICACION");
/* insertar datos */
INSERT INTO TALLERJEE.USUARIO (NOMBRES, APELLIDOS, IDENTIFICACION)
VALUES ('Rosalba', 'Hernandez', '7988888');
INSERT INTO TALLERJEE.USUARIO (NOMBRES, APELLIDOS, IDENTIFICACION)
VALUES ('Marina', 'Casas', '666666');
Creando el modelo del negocio en el módulo ejb (taller9_1-ejb):
Los objetos del negocio van a estar representados por clases java que implementan el patrón
Data Transfer Object.
4. Cree la siguiente clase java UsuarioDTO con sus correspondientes
atributos en el paquete taller9_1.modelo.dto. Use la imagen previa para
crear los atributos.

5. Cree la clase UsuarioDAO que representa el patrón DAO en el paquete

taller9_1.modelo usando como referencia la imagen anterior.
a. De clic derecho sobre el directorio “Source Package” del proyecto taller9_1-ejb y seleccione
New -> “Session Bean”. En el campo EJB Name digite UsuarioDAO y en Package digite
taller9_1.modelo y de clic en finish.

b. Cree el atributo con de tipo Connection que contendrá la conexión

a la base de datos:

private List<UsuarioDTO> listaUsuarios;

c. Implemente el constructor que inicialice la conexión a la base de datos:
public UsuarioDAO() {
try {
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
con =
DriverManager.getConnection("jdbc:derby://localhost:1527/tallerjee", "tallerjee",
"tallerjee");
} catch (Exception e) {
e.printStackTrace();
}
}
d. Implemente el método actualizar. En este método ejecute las
siguientes sentencias:

public void actualizar(UsuarioDTO usuario) {

try {
PreparedStatement ps = con.prepareStatement("update usuario set "
+ "nombres = ?, apellidos = ? where identificacion = ?");
ps.setString(1, usuario.getNombres());
ps.setString(2, usuario.getApellidos());
ps.setString(3, usuario.getIdentificacion());
ps.executeUpdate();
ps.close();
} catch (SQLException ex) {
Logger.getLogger(UsuarioDAO.class.getName()).log(Level.SEVERE, null,
ex);
}
}
e. Implemente el método eliminar. Use la misma lógica del método
actualizar.
f. Implemente el método insertar usando la misma lógica del método
actualizar.

g. Implementa el método listar, retornando el listado de usuarios que se

encuentra en el atributo de clase listarUsuarios.
public List<UsuarioDTO> listarUsuarios() {
List<UsuarioDTO> lista = new ArrayList<UsuarioDTO>();
PreparedStatement ps;
try {
ps = con.prepareStatement("select * from USUARIO");
ResultSet rs = ps.executeQuery();
while (rs.next()) {
UsuarioDTO usuario = new UsuarioDTO();
usuario.setIdentificacion(rs.getString("IDENTIFICACION"));
usuario.setApellidos(rs.getString("APELLIDOS"));
usuario.setNombres(rs.getString("NOMBRES"));
lista.add(usuario);
}
rs.close();
ps.close();
} catch (SQLException ex) {
Logger.getLogger(UsuarioDAO.class.getName()).log(Level.SEVERE, null,
ex);
}
return lista;
}
6. Cree la clase UsuarioService en el paquete taller9_1.modelo usando
como referencia la imagen anterior.

a. De clic derecho sobre el package taller9_1.modelo del proyecto

taller9_1-ejb y seleccione New -> “Session Bean”. En el campo
EJB Name digite UsuarioService y en Package digite taller9_1.modelo y de clic en
finish.

b. Cree el atributo de clase UsuarioDAO con alcance private usando

la siguiente sentencia:

@EJB
private UsuarioDAO usuarioDAO;

c. Implemente los métodos actualizar, eliminar, insertar y listar

haciendo un llamado a su correspondiente método en el DAO.
Note que para este ejercicio no existe lógica de negocio diferente
al llamado al objeto de persistencia. Ejemplo:
public void insertar(UsuarioDTO usuario){
this.usuarioDAO.insertar(usuario);
}
d. Implemente el método cerrar con las siguientes sentencias:
@PreDestroy
public void cerrar(){
try {
if(con != null && !con.isClosed()){
con.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
7. Cree la clase FachadaUsuario en el paquete taller9_1.modelo usando
como referencia la imagen anterior.

a. De clic derecho sobre el package taller9_1.modelo del proyecto

taller9_1-ejb y seleccione New -> “Session Bean”. En el campo EJB Name digite
FachadaUsuario, en Package digite taller9_1.modelo y en Session Type seleccione
Singleton y de clic en finish.

b. Cree el atributo de clase UsuarioService con alcance private

usando la siguiente sentencia:

@EJB
private UsuarioService usuarioService;
c. Implemente los métodos actualizarUsuario, eliminarUsuario, insertarUsuario y listarUsuarios
haciendo un llamado a su correspondiente método en el Servicio. Dado en la fachada no
tiene lógica de negocio cada método debe invocar a su correspondiente método en el objeto
UsuarioService. Ejemplo:

public void insertarUsuario(UsuarioDTO usuario){

this.usuarioService.insertar(usuario);
}
Usando PrimeFaces en el módulo web:
8. El módulo web creado automáticamente debe ser configurado para el uso de JSF
PrimeFaces. Para realizar esto de clic derecho sobre el módulo web llamado taller9_1-war y
seleccione “properties”. Posteriormente ingrese a la sección “Frameworks” y de clic en el botón
Add. Luego seleccione JavaServer Faces y en la pestaña “components” seleccione
PrimeFaces, espere un momento a que netbeans cargue correctamente
las dependencias necesarias y de clic en “ok”.
Creando el bean manejado (UsuarioMBean):
9. Cree el bean manejado UsuarioMBean en el paquete taller9_1.vista de
alcance de sesión.
10. Importe el objeto UsuarioDTO y la interfaz List incluyendo las siguientes
líneas:
import taller9_1.modelo.dto.UsuarioDTO;
import taller9_1.modelo.*;
import java.util.List;
import java.util.ArrayList;
11. Adicione atributos que permitan manejar la referencia a un objeto
UsuarioDTO (llamado usuario).
private UsuarioDTO usuario;
 12. Cree un atributo que referencie el objeto FachadaUsuario que
representa la fachada de la lógica de negocio.
@EJB
private FachadaUsuario fachadaUsuario;

13. Cree un método void init() donde inicialice los dos atributos creados e
instancie objetos de tipo UsuarioDTO y adiciónelos a la lista.
@PostConstruct
public void init(){
usuario = new UsuarioDTO();
}

14. Cree un método para adicionar nuevos usuarios a la lista:

public String adicionarUsuario() {
System.out.println("Adicionando usuario con identificación = " + usuario.getIdentificacion());
this.fachadaUsuario.adicionarUsuario(usuario);
this.usuario = new UsuarioDTO();
return "usuario";
}
15. Cree un método que reciba el objeto UsuarioDTO que se desea editar, se lo asigne al
atributo usuario:
public String seleccionarUsuario(UsuarioDTO u) {
System.out.println("Seleccionardo el usuario con identificación = " +
u.getIdentificacion());
usuario = u;
return "usuario";
}
16. Cree un método que actualice el usuario seleccionado
public String actualizarUsuario() {
this.fachadaUsuario.actualizarUsuario(usuario);
this.usuario = new UsuarioDTO();
return "usuario";
}

17. Cree el método getListaUsuarios

public List<UsuarioDTO> getListaUsuarios() {
return this.fachadaUsuario.listarUsuarios();
}
18. Cree el método eliminar usuario
public String eliminarUsuario(UsuarioDTO usuario) {
this.fachadaUsuario.eliminarUsuario(usuario.getIdentificacion());
this.usuario = new UsuarioDTO();
return "usuario";
}
Creando la plantilla (template.xhtml):
19. Cree una plantilla JSF llamada template.xhtml en el directorio WEBINF/
template. Para hacer esto de clic derecho en Source Package y luego
selecione New > Other > JavaServer Faces > Facelets Template.
Diligencie los campos File Name con template y folder con WEBINF\
template y luego de clic en finish.

20. En la etiqueta raíz del template (html) Incluya el schema para el uso de
los componentes PrimeFaces
xmlns:p="http://primefaces.org/ui"
21. Remplace el contenido de la etiqueta body con el siguiente código
<p:layout fullPage="true">
<p:layoutUnit position="north" size="100" resizable="true" closable="true"
collapsible="true">
Gestión de usuarios
</p:layoutUnit>
<p:layoutUnit position="south" size="100" closable="true" collapsible="true">
2019
</p:layoutUnit>
<p:layoutUnit position="west" resizable="true" closable="true"
collapsible="true">
<h:form>
<p:menu>
<p:submenu label="Menú">
<p:menuitem value="Gestionar Usuarios" outcome="usuario" />
</p:submenu>
</p:menu>
</h:form>
</p:layoutUnit>
<p:layoutUnit position="center">
<ui:insert name="content">Bienvenido a la Gestión de usuarios</ui:insert>
</p:layoutUnit> </p:layout>
Creando el componente para capturar los datos del usuario
(usuariocomp.xhtml):
1. Debido a que el formulario de creación también va a ser usado para la actualización de
personas se sugiere crear un componente que pueda ser reusado en ambos casos. Para esto
cree un componente compuesto en la ruta /resources/usercomp con el nombre
usuariocomp.xthml. Puede usar el wizard de creación de composite components que ofrece
netbeans dando clic derecho en el directorio resource y seleccionando New > Other
> JavaServer Faces > JSF Composite Components y diligencie los
campos File Name y Folder.

2. En la etiqueta raíz del componente (html) Incluya el schema para el uso

de los componentes PrimeFaces
xmlns:p="http://primefaces.org/ui"
3. El componente debe tener un atributo que referencie al DTO que
almacena los datos del usuario.
<cc:interface>
<cc:attribute name="usuarioDTO" type="taller9_1.modelo.dto.UsuarioDTO" />
</cc:interface>
4. En este componente cree una tabla donde solicite los datos que hacen
parte del objeto UsuarioDTO con la ayuda de las siguientes etiquetas:
p:outputLabel : Etiquetas
p:inputText : Cajas para la captura de texto
<cc:implementation>
<p:outputLabel id="lbIdentificacion" for="inputIdentificacion"
value="Identificacion"></p:outputLabel>
<p:inputText id="inputIdentificacion" value="#{cc.attrs.usuarioDTO.identificacion}"
required="true"></p:inputText>
<br/>
<p:outputLabel id="lbNombres" for="inputNombres" value="Nombres"></p:outputLabel>
<p:inputText id="inputNombres" value="#{cc.attrs.usuarioDTO.nombres}"
required="true"></p:inputText>
<br/>
<p:outputLabel id="lbApellidos" for="inputApellidos" value="Apellidos"></p:outputLabel>
<p:inputText id="inputApellidos" value="#{cc.attrs.usuarioDTO.apellidos}"
required="true"></p:inputText>
<br/>
</cc:implementation>
Creando la página de gestión de usuarios(usuario.xhtml) :
5. Cree una página JSF llamada usuario.xhtml y aplíquele la plantilla creada.
Para esto puede usar la opción de Netbeans dando clic derecho sobre el
directorio web pages y seleccionando New > Other > JavaServer Faces >
Facelets Template Client. En file Name use usuario, en template navegue
hasta encontrar le template creado. En generate root tag selecciones
ui:composition y finalmente seleccione la sección content de la plantilla.
Luego de clic en finish.
6. En la etiqueta raíz de la página usuario.xhtml incluya los esquemas para
hacer uso de las etiquetas del componente creado, faces y primefaces:
xmlns:uc="http://xmlns.jcp.org/jsf/composite/usercomp"
xmlns:h="http://xmlns.jcp.org/jsf/html"
xmlns:f="http://xmlns.jcp.org/jsf/core"
xmlns:p="http://primefaces.org/ui"
7. Cree una etiqueta form dentro la etiqueta content así:
<ui:define name="content">
<h:form id="addUser">
….
</h:form>
</ui:define>
8. Invoque el componente creado (usercomp) en la sección content dentro
de una etiqueta form.
<uc:usuariocomp usuarioDTO="#{usuarioMBean.usuario}" />
9. Cree un botón que invoque el método para incluir un nuevo usuario
<p:commandButton value="Crear" action="#{usuarioMBean.adicionarUsuario}"
process="@form" update="@form" />
10. Incluya una etiqueta para mostrar los mensajes de error:
<p:messages />

11. Cree una tabla que presente el listado de usuarios

<p:dataTable id="usuarios" var="usuario" value="#{usuarioMBean.listaUsuarios}">
<p:column id="identificacion" >
<f:facet name="header">
<h:outputText value="Identificación" />
</f:facet>
<h:outputText value="#{usuario.identificacion}" />
</p:column>
<p:column id="nombres" >
<f:facet name="header">
<h:outputText value="Nombres" />
</f:facet>
<h:outputText value="#{usuario.nombres}" />
</p:column>
<p:column id="Apellidos" >
<f:facet name="header">
<h:outputText value="Apellidos" />
</f:facet>
<h:outputText value="#{usuario.apellidos}" />
</p:column>
<p:column id="actualizar" >
<p:commandButton action="#{usuarioMBean.seleccionarUsuario(usuario)}"
id="cbActualizar" oncomplete="PF('editUser').show()"
process="@this" update=":fEditUser"
icon="ui-icon-pencil" title="Actualizar" />
<p:commandButton action="#{usuarioMBean.eliminarUsuario(usuario)}"
id="cbEliminar"
process="@this" update="@form"
icon="ui-icon-trash" title="Eliminar" />
</p:column>
</p:dataTable>
12. Para editar los usuarios desde la tabla se debe crear una ventana de
dialogo usando PrimeFaces. Este dialogo debe crearse en un formulario
diferente así:
<h:form id="fEditUser">
<p:dialog header="Detail" widgetVar="editUser" id="dEditUser" >
<uc:usuariocomp id="editUserComp" usuarioDTO="#{usuarioMBean.usuario}"
/>
<p:commandButton value="Actualizar"
action="#{usuarioMBean.actualizarUsuario()}" onclick="PF('editUser').hide();"
process="@form" update=":addUser" />
</p:dialog>
</h:form>
13. Para ejecutar la aplicación de clic derecho sobre el proyecto taller9_1 y
seleccione Run. Luego en el navegador abra la siguiente URL:
http://localhost:8080/taller9_1-war/faces/usuario.xhtml