Implementando un Singleton Manager de Conexión

En aplicaciones cliente/servidor se acostumbra a tener una conexión a BD única por usuario, para poder hacerlo vamos a implementar un manager de conexión.

1.- Este es el código del manager:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author Carlos Rojas
*/
public class ConnectionManager {

private static String driver = "com.mysql.jdbc.Driver";
private static String url = "jdbc:mysql://localhost:3306/Prueba";
private static String user = "prueba";
private static String password = "prueba";
private static Connection con;

/**
* Inicializa una nueva conexión con parámetros nuevos
* @param driver
* @param url
* @param user
* @param password
*/
private ConnectionManager(String driver, String url, String user, String password) {
ConnectionManager.driver = driver;
ConnectionManager.url = url;
ConnectionManager.user = user;
ConnectionManager.password = password;
}

/**
* Retorna una conexión por defecto
* @return
*/
public static Connection getConnection() {
if (con == null) {
try {
Class.forName(driver);
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
con = DriverManager.getConnection(url, user, password);
} catch (SQLException ex) {
Logger.getLogger(ConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println("Se genero una nueva instancia de Connection");
}
System.out.println("Se retorno una instancia de Connection");
return con;
}

/**
* Retorna una conexión unica a partir de los parametros de conexion, en caso que la instancia de la conexión
* no sera nula, retornara la instancia
* @param driver
* @param url
* @param user
* @param password
* @return
*/
public static Connection getConnection(String driver, String url, String user, String password) {
if (con == null) {
new ConnectionManager(driver, url, user, password);
try {
Class.forName(ConnectionManager.driver);
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
con = DriverManager.getConnection(ConnectionManager.url, ConnectionManager.user, ConnectionManager.password);
} catch (SQLException ex) {
Logger.getLogger(ConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
}
return con;
}

public static void closeConnection() {
if (con != null) {
try {
con.close();
} catch (SQLException ex) {
Logger.getLogger(ConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}

2.- Ahora vamos a utilizar la clase TestConnectionManager de prueba para usar el manager:

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.logging.Level;
import java.util.logging.Logger;


/**
*
* @author Carlos Rojas
*/
public class TestConnectionManager {
public TestConnectionManager(int x){
Connection con = ConnectionManager.getConnection();
try {
Statement st = con.createStatement();
ResultSet rs = st.executeQuery("select "+x);
while(rs.next()){
System.out.println(rs.getObject(1));
}
} catch (SQLException ex) {
Logger.getLogger(TestConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
}

public static void main(String[] args) {
new TestConnectionManager(1);
new TestConnectionManager(2);
new TestConnectionManager(3);
new TestConnectionManager(4);
}
}

3.- La salida del programa será la siguiente:

Se genero una nueva instancia de Connection
Se retorno una instancia de Connection
1
Se retorno una instancia de Connection
2
Se retorno una instancia de Connection
3
Se retorno una instancia de Connection
4

4. La primera vez que se ejecuta el método getConnection() la instancia de la variable "con" es nula, por lo tanto se inicializa el singleton. Las llamadas posteriores solo devuelve la instancia ya previamente creado.

Singleton Connection Manager

En algunos casos para aplicaciones cliente/servidor se acostumbra a mantener una conexión a BD activa por usuario, para hacer esto es necesario crear una conexión que funcione como un singleton. Así de esta manera:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author carlos
*/
public class ConnectionManager {

private static String driver = "com.mysql.jdbc.Driver";
private static String url = "jdbc:mysql://localhost:3306/Prueba";
private static String user = "prueba";
private static String password = "prueba";
private static Connection con;

/**
* Inicializa una nueva conexión con parámetros nuevos
* @param driver
* @param url
* @param user
* @param password
*/
private ConnectionManager(String driver, String url, String user, String password) {
ConnectionManager.driver = driver;
ConnectionManager.url = url;
ConnectionManager.user = user;
ConnectionManager.password = password;
}

/**
* Retorna una conexión por defecto
* @return
*/
public static Connection getConnection() {
if (con == null) {
try {
Class.forName(driver);
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
con = DriverManager.getConnection(url, user, password);
} catch (SQLException ex) {
Logger.getLogger(ConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
}
return con;
}

/**
* Retorna una conexión unica a partir de los parametros de conexion, en caso que la instancia de la conexión
* no sera nula, retornara la instancia
* @param driver
* @param url
* @param user
* @param password
* @return
*/
public static Connection getConnection(String driver, String url, String user, String password) {
if (con == null) {
new ConnectionManager(driver, url, user, password);
try {
Class.forName(ConnectionManager.driver);
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
con = DriverManager.getConnection(ConnectionManager.url, ConnectionManager.user, ConnectionManager.password);
} catch (SQLException ex) {
Logger.getLogger(ConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
}
return con;
}

public static void closeConnection() {
if (con != null) {
try {
con.close();
} catch (SQLException ex) {
Logger.getLogger(ConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}

Ejecutando sentencias SQL JDBC!!! 3 Parte

En la segunda parte del tutorial Ejecutando sentencias SQL JDBC!!!, probamos con éxito la ejecución de una sentencia SELECT. Ahora vamos a actualizar un registro específico en la tabla persona.

package hellojdbc;

import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Calendar;

/**
*
* @author carlos
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// Cargar controlador mysql de la base de datos
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
// Crear conexión a la Base de Datos
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/Prueba", "prueba", "prueba");
// Crear un Objeto Statement para ejecutar la consulta a la BD
Statement st = con.createStatement();
// Creamos una sentencia SQL para actualizar el registro con id_persona = 1
String UPDATE_SQL = "update persona set nombre_persona = 'Luke Actualizado', apellido_persona = 'Sky Actualizado', fecha_nac_persona = '2010-03-25' where id_persona = 1";
// Ejecutamos la actualización del regist
st.executeUpdate(UPDATE_SQL);
ro

// Realizamos la consulta de la persona con el id_persona = 1
String SQL_SELECT = "select * from persona where id_persona = 1";
rs = st.executeQuery(SQL_SELECT);
while (rs.next()) {
System.out.println("Resultado del Select:");
System.out.println("id_persona: " + rs.getString("id_persona"));
System.out.println("nombre_persona: " + rs.getString("nombre_persona"));
System.out.println("apellido_persona: " + rs.getString("apellido_persona"));
System.out.println("fecha_nac_persona: " + rs.getString("fecha_nac_persona"));
}
} catch (SQLException ex) {
ex.printStackTrace();
}
}
}

La salida del programa debería ser como esta:

Resultado del Select:
id_persona: 1
nombre_persona: Luke Actualizado
apellido_persona: Sky Actualizado
fecha_nac_persona: 2010-03-25

Ejecutando sentencias SQL JDBC!!! 2 Parte

En la primera parte del tutorial Ejecutando sentencias SQL JDBC!!!, insertamos un registro con éxito. Al ejecutar por segunda vez el tutorial tenemos que nos dará el siguiente error:

com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException: Duplicate entry '1' for key 1

Este error dá porque la columna "id_persona" es la clave primaria de la tabla y está no acepta duplicados.

Lo que vamos hacer ahora es ejecutar una consulta en la tabla antes de insertar algun registro, a continuación agregamos las senténcias que ejecutará las acciones:

// Crear un Objeto Statement para ejecutar la consulta a la BD
Statement st = con.createStatement();
// Se selecciona el máximo id de la persona
ResultSet rs = st.executeQuery("select max(id_persona) from persona");
int idPersona;
// Se comprueba que el ResultSet tenga resultados
if (rs.next()) {
// Se obtiene el unico y se incrmenta en 1 su valor
idPersona = rs.getInt(1);
idPersona++;
} else {
// si no hay resultado es el primer registro a insertar
idPersona = 1;
}

Luego en pstm.setInt(1, 1); del código anterior los sustituimos por: pstm.setInt(1, idPersona); para que cada vez que se ejecute el programa se genere un id_persona diferente.

Aqui anexo el código completo:

package hellojdbc;

import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Calendar;

/**
*
* @author carlos
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// Cargar controlador mysql de la base de datos
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
// Crear conexión a la Base de Datos
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/Prueba", "prueba", "prueba");
// Crear un Objeto Statement para ejecutar la consulta a la BD
Statement st = con.createStatement();
// Se selecciona el máximo id de la persona
ResultSet rs = st.executeQuery("select max(id_persona) from persona");
int idPersona;
// Se comprueba que el ResultSet tenga resultados
if (rs.next()) {
// Se obtiene el unico y se incrmenta en 1 su valor
idPersona = rs.getInt(1);
idPersona++;
} else {
// si no hay resultado es el primer registro a insertar
idPersona = 1;
}

String SQL = "insert into persona(id_persona,nombre_persona,apellido_persona,fecha_nac_persona) values(?,?,?,?)";
PreparedStatement pstm = con.prepareStatement(SQL);
// Ejecutar sentencia SQL para insertar datos
pstm.setInt(1, idPersona);
pstm.setString(2, "Luke " + idPersona);
pstm.setString(3, "Sky " + idPersona);
pstm.setDate(4, new Date(Calendar.getInstance().getTimeInMillis()));
pstm.executeUpdate();
} catch (SQLException ex) {
ex.printStackTrace();
}
}
}

Ejecutando sentencias SQL JDBC!!!

En el tutorial Hola Mundo JDBC!!!, estudiamos como abrir una conexión a la base de datos y como ejecutar una sentencia SQL sencilla. Ahora utilizando el proyecto HelloJDBC de Hola Mundo JDBC!!! vamos a insertar registros en una Base de Datos.

Importante:

Para realizar el tutorial:

• Crear una Base de Datos en Mysql que llamada "Prueba" con el usuario "prueba" y clave "prueba".
• Crear tabla prueba con el siguiente script SQL.
  

1.- Modificamos la Clase Main con el siguiente código:

public static void main(String[] args) {
// Cargar controlador mysql de la base de datos
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
// Crear conexión a la Base de Datos
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/Prueba", "prueba", "prueba");

String SQL = "insert into persona(id_persona,nombre_persona,apellido_persona,fecha_nac_persona) values(?,?,?,?)"; PreparedStatement pstm = con.prepareStatement(SQL); // Ejecutar sentencia SQnombre_personaL para insertar datos pstm.setInt(1, 1); pstm.setString(2, "Luke"); pstm.setString(3, "Sky"); pstm.setDate(4, new java.sql.Date(Calendar.getInstance().getTimeInMillis())); pstm.executeUpdate();
} catch (SQLException ex) {
ex.printStackTrace();
}
}
}

Importamos las referéncias con el menu Source > Fix imports o Ctrl+ Mayúscula+I

Tenemos la variable SQL que es la sentencia a ejecutar en la Base de Datos, los símbolos "?" son los datos a insertar que luego se rellenaran con datos. Para ejecutar la sencencia creamos un objeto PreparedStament con la siguiente línea de código:

PreparedStatement pstm = con.prepareStatement(SQL);

Para ingresar los valores a la sentencia SQL utilizamos los método setInt para los del tipo Integer y setString para los tipo String. Se setean los valores por el numero orden, el primer simbolo "?" representa el indice 0, Por ejemplo:

pstm.setString(2, "Luke");
insert into persona(id_persona,nombre_persona,apellido_persona,fecha_nac_persona) values(?,?,?,?)

El primer párametro 2 significa el lugar donde pondrá el valor, la segunda "?" de izquierda a derecha, el segundo párametro "Luke" es el valor que pondrá en la sentencia.

Para ingresar fechas estas tienen que ser del tipo java.sql.Date, pues es el valor que soporta. normalmente en Java se manejan fechas con el tipo java.util.Date ó java.util.Calendar. En este ejemplo hacemos la conversión de esta manera.

new java.sql.Date(Calendar.getInstance().getTimeInMillis())

Por último ejecutamos la sentencia SQL con pstm.executeUpdate();

2.- Ejecutar el proyecto F6 o ir al menu Run > Run Project.

3.- Consultar la tabla y verificar que los datos fueron registrados, para esto agregamos la conexión en Services > Databases, hacemos clic derecho y seleccionamos New Connection.

4.- Si aparecen los datos en la tabla hemos insertado los datos correctamente.

Hola Mundo JDBC!!!!

En el siguiente tutorial vamos a realizar un Hola Mundo con Java DataBase Connectivity, JDBC es un API de Java para acceder a Base de Datos Relacionales. Para efecto del tutorial nos conectaremos a una Base de Datos Mysql y ejecutaremos una simple sentencia SQL .

Importante:

Para realizar el tutorial, debe crear una Base de Datos en Mysql que llamada "Prueba" con el usuario "prueba" y clave "prueba".

1.- Iniciar Netbeans, y ir a la opción de menu File --> New Project. Elegimos en Categories Java y en Projects Seleccionamos Java Application. Hacemos clic en Next.


2.- En Project Name colocamos "HelloJDBC", la opción Create main Class la chequeamos para que cree una clase principal. hacemos clic en Finish.


4.- Debemos agregar al proyecto el driver para la conexión a Mysql, expandimos el Nodo de proyecto y hacemos clic derecho en Libraries > Add Library y seleccionamos MySQL JDBC Driver - mysql-connector-java-5.1.6.jar.

3.- Para conectarnos a nuestra Base de Datos Mysql, lo primero que debemos hacer es cargar la clase controladora. Así que en la Clase Main, en el método principal agregamos las siguientes sentencias:

try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}

4.- Ahora agregamos las sentencias para abrir una conexión e interactuar con la Base de Datos.

try {

// Abrir Conexión a la Base de Datos
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/Prueba", "prueba", "prueba");
// Ejecutar sentencia SQL
Statement stm = con.createStatement();
ResultSet rs = stm.executeQuery("select 'Hola JDBC!!!!!'");
// Navegar resultados
rs.next();
System.out.println(rs.getObject(1));
} catch (SQLException ex) {
ex.printStackTrace();
}

Para abrir la conexión lo hacemos con la clase DriverManager.getConnection(url,usuario,clave)
que nos devuelve una conexión del tipo Connection que recibe los siguientes parametros:

String url : Es la cadena de conexión a la base de datos
String usuario: Nombre de usuario para conexión
String clave: Clave del usuario para conexión

Para enviar sentencias SQL al servidor de Base de Datos creamos una instancia de Statement en la siguiente sentencia del código:


Statement stm = con.createStatement();

Y ejecutamos la sentencia con el siguiente método

ResultSet rs = stm.executeQuery("select 'Hola JDBC!!!!!'");
rs.next(); // Avanzamos a la primera fila de resultados

Por último enviamos a la consola el único valor por medio de la siguiente sentencia:

System.out.println(rs.getObject(1));

5.- Código completo de la clase:

package hellojdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
*
* @author carlos
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/Prueba", "prueba", "prueba");
Statement stm = con.createStatement();
ResultSet rs = stm.executeQuery("select 'Hola JDBC!!!!!'");
rs.next();
System.out.println(rs.getObject(1));
} catch (SQLException ex) {
ex.printStackTrace();
}
}
}

6.- Si la salida es "Hola JDBC!!!!!" Listo hemos creado con éxito nuestro Hola Mundo JDBC!!!!