I. Tema :Connection
1.CONTENIDO:
* DEFINICIÓN:
como conectar una base de datos MySql con el lenguaje de programación Java y el IDE Netbeans de la manera mas fácil.
Paso 1
Primero necesitamos tener instalado en nuestra PC el Netbeans, java y MySQL por supuesto.
Paso 2
Descargar el MySQL Java Conector, descomprimirlo y ubicarlo en una carpeta de fácil acceso.
Paso 3
Ahora vamos al Netbeans y creamos un nuevo proyecto, le ponemos un nombre y seleccionamos para crear la clase principal por defecto.
Paso 4
En el menú de la derecha del Netbeans buscamos en el arbol de proyectos, seleccionamos el proyecto actual y vamos a la carpeta de librerías, le damos click derecho y buscamos el MySQL Java Conector de donde lo guardamos en el paso 2, seleccionamos el archivo .
Paso 5
Ahora vamos a escribir el código de nuestra función de conexión a la base de datos:
public static void connect(){
String url = "jdbc:mysql://localhost:3306/myjavaapp1";
String user = "root";
String pass = "";
System.out.println("Conectando...");
try(Connection connection = DriverManager.getConnection(url, user,pass)){
System.out.println("Conectado!!");
}catch(SQLException e){
System.out.println(e.getMessage());
}
}
En tu caso debes modificar el valor de las variables url, user y password.
La variable url equivale a la ubicacion del servidor de la base de datos, en este caso en localhost
en el puerto 3306 y despues una diagonal separando el nombre de la base de datos.
Paso 6
Crear la base de datos.
Para ello debemos recurrir a una consola de comandos o algun gestor visual como MySQLWordBench o el mismisimo PHPMyAdmin.
El código SQL de la base de datos en cuestión es el siguiente.
create database myjavaapp1;
use myjavaapp1;
create table user(
id int not null auto_increment primary key,
username varchar(125) unique,
password varchar(125),
created_at datetime
);
Paso 7
Ahora que ya hemos cubierto los pasos necesarios vamos a ejecutar el proyecto.
Por cierto recuerden agregar una llamada a la función connect() dentro de la función main() …
mysql1
Paso 8
Después de la linea donde mandamos a imprimir el texto “Conectado!” podemos usar el
código siguiente para agregar un usuario:
System.out.println("Insertando ...");
Statement s = connection.createStatement();
String query1 = "insert into user (username,password,created_at) value (\"user1\",\"mypassword\",NOW())";
s.executeUpdate(query1);
Y seguido de ese podemos usar el siguiente para mostrar o hacer un recorrido de todos los registros de la tabla user.
// vamos a recorrer
String query2 = "select * from user";
ResultSet r = s.executeQuery(query2);
* PROPIEDADES:
Con lo cual se mostrará la ventana en la que ingresaremos la configuración del servidor, que por defecto es como se muestra a continuación (realmente no hat que modificar nada).
Ahora configuraremos la funcionalidad del servidor MySQL (OJO: Debe de estar activo el Servidor para que esto funcione bien). En la pestaña Propiedades de administración (Admin Properties) deberemos especificar la ruta o path de las herramientas que utilizamos para administrar el servidor.
Ahora solo da clic en el botón OK. y observa la pestaña de Prestaciones (Services) en el IDE de NetBeans, debió aparecer el DataSet a MySQL Server, aunque está desconectado.
Para conectar a nuestro servidor sobre MySQL Server, haz clic derecho del mouse y presiona Start.
Una vez que hemos hecho esto, podemos observar las bases de datos de nuestro servidor.
Una vez que se dio clic en Connect (Conectar), aparecerá la siguiente ventana, solicitando el usuario y la contraseña de conexion a la Base de datos de MySQL.
En nuestro caso solo colocaremos el nombre de usuario el cual es “root” y no tenemos una contraseña configurada. Justo después de esto daremos clic en el botón Aceptar (OK) y observaremos lo siguiente.
La base de datos negocio, está activa, por medio del driver de MySQL.
*EJEMPLOS:
La base de datos que usaremos para este ejemplo es la siguiente:
BD: prueba.
tabla: usuarios.
campos: id(autoinc), nombre, contraseña.
Diagrama de clases:
Bueno, primero que nada, empezaremos con nuestra clase que contendrá los métodos de las acciones que vamos a realizar.
import java.sql.*;
import java.util.Hashtable;
public class SQLconnection {
private String user;
private String password;
private String db;
private String host;
private String url;
private Connection conn = null;
private Statement stm;
private ResultSet rs;
public SQLconnection()
{
this.url = “jdbc:mysql://” + this.host + “/” + this.db;
}
public SQLconnection (String server, String usuario, String contraseña, String bd)
{
this.user = usuario;
this.password = contraseña;
this.db = bd;
this.host = server;
this.url = “jdbc:mysql://” + this.host + “/” + this.db;
}
public void connectar()
{
try {
Class.forName(“org.gjt.mm.mysql.Driver”);
conn = DriverManager.getConnection(url, user, password);
if (conn != null)
{
System.out.println(“Conexión a base de datos “+url+” … Ok”);
stm = conn.createStatement();
}
}
catch(SQLException ex) {
System.out.println(“Hubo un problema al intentar conectarse con la base de datos “+url);
}
catch(ClassNotFoundException ex) {
System.out.println(ex);
}
}
public String getDb() {
return db;
}
public void setDb(String db) {
this.db = db;
}
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public ResultSet consultar(String tabla) throws SQLException
{
rs = stm.executeQuery(“SELECT * FROM ” + tabla);
return rs;
}
public String buscarNombre(String tabla, String nombre) throws SQLException
{
String name = null;
try{
rs = stm.executeQuery(“SELECT * FROM ” + tabla + ” WHERE nombre = ‘”+ nombre +”‘ LIMIT 1″);
rs.next();
name = rs.getString(2);
}catch(SQLException ex){System.out.println(ex);}
return name;
}
public void insertar(Hashtable usuario)
{
try {
stm.execute(“INSERT INTO usuarios (nombre, contraseña) VALUES (‘” +usuario.get(“nombre”) + “‘,'” + usuario.get(“contraseña”) + “‘)”);
} catch (SQLException ex) {
System.out.println(ex);
}
}
public void actualizar(String tabla, Hashtable usuario, String nombre)
{
try {
stm.execute(“UPDATE ” + tabla + ” SET nombre='” + usuario.get(“nombre”) + “‘ WHERE nombre='” + nombre + “‘”);
} catch (SQLException ex) {
System.out.println(ex);
}
}
public void eliminar(String tabla, String nombre)
{
try {
stm.execute(“DELETE FROM ” + tabla + ” WHERE nombre='” + nombre + “‘”);
} catch (SQLException ex) {
System.out.println(ex);
}
}
}
Como podemos observar, esta clase cuenta con sobrecarga de constructores lo cual nos permite conectarnos de 2 maneras distintas a la base de datos. La primera es utilizar el constructor que no recibe ningún parámetro y definirlos mediante los métodos set y get para después llamar al método conectar. La segunda es enviarle directamente los valores al constructor y, al igual que en la forma anterior, ejecutar el método conectar, y esta será la forma que usaremos para nuestro ejemplo.
Primero que nada vamos a conectarnos a nuestra base de datos y realizaremos unaconsulta de todos los registros:
SQLconnection con = new SQLconnection(“localhost”, “usuario”, “contraseña”, “prueba”);
con.connectar();
ResultSet rs;
rs = con.consultar(“usuarios”);
while(rs.next()){
System.out.println(rs.getString(1));
System.out.println(rs.getString(2));
System.out.println(rs.getString(3));
}
En esta clase también implementamos una opción que nos permite realizarbúsquedas por medio de nombres(es el campo de la base de datos que elegí para este ejemplo); ha este método le mandamos 2 parámetros, que son la base de datos y el nombre:
System.out.println(con.buscarNombre(“usuarios”, “frago”));
Para insertar un nuevo registro vamos a hacer uso del Hastable para enviarle los valores que queremos agregar:
Hashtable usuario = new Hashtable();
usuario.put(“nombre”, “frago”);
usuario.put(“contraseña”, “xxx”);
con.insertar(usuario);
Para eliminar un registro simplemente le ejecutamos el método correspondiente y le pasamos como parametros la tabla y el nomrbe del usuario a eliminar:
con.eliminar(tabla, “frago”);
Para actualizar un registro le tenemos que pasar 3 parámetros al método. EL primero es el nombre de la tabla; el segundo es un Hastable en el que se incluya la modificación que se quiere realizar y el tercer es, en este caso, el nombre de la persona a la que se le va realizar la modificación:
Hashtable usuario = new Hashtable();
usuario.put(“nombre”, “frago1”);
con.actualizar(tabla, usuario, “frago”);
2.RESUMEN:
Crear el proyecto de NetBeans:
En lo particular utilizo la que a la fecha de publicación de este artículo es la versión más reciente del NetBeans: la 7.1.1. Para crear el proyecto basta con dar clic en el botón de'Nuevo Proyecto' o ir al menú Archivo -> Nuevo Proyecto.
Al proyecto le titularemos MySQLBD, aunque solo es un nombre sugerido ya que no afecta en lo más mínimo con el comportamiento del programa. Una vez creado el proyecto el IDE nos posicionará en la clase principal del mismo y creará por sí solo el método main desde el cual ejecutaremos todos nuestros procedimientos.
Establecer la conexión a la base de datos
Lo primero que vamos a hacer es importar las clases y/o paquetes que vamos a utilizar (los llamados import’s), en este caso solamente será el que se muestra a continuación:
import java.sql.*;
Posteriormente dentro de la clase declararemos una variable privada de tipo Connection que será la que contendrá la conexión con la base de datos:
public class MySQLBD {
private Connection conexion;
.
.
Para organizar el código crearemos el get y set de conexion además del método llamadoconectar() el cual se encargará de establecer a la conexión con la base de datos para que posteriormente podamos realizar los procedimientos que necesitamos. Dentro del método encerraremos la mayor parte del código dentro de un try-catch con el fin de capturar las excepciones que se puedan originar tras la ejecución del mismo.
public Connection getConexion() {
return conexion;
}
public void setConexion(Connection conexion) {
this.conexion = conexion;
}
public MySQLBD conectar() {
try {
.
.
.
} catch (Exception e) {
e.printStackTrace();
}
return this;
}
Como puedes ver, el método devuelve una instancia de la clase MySQLBD (es decir, la misma que lo contiene), esto con el fin de poder encadenar los siguientes métodos que necesitaremos y ahorrarnos una línea de código.
Ahora bien, dentro del try-catch lo primero que realizaremos será cargar el driver en la memoria y posteriormente crear una cadena con la URL de conexión a la base de datos como se muestra en el siguiente código:
Class.forName("com.mysql.jdbc.Driver");
String BaseDeDatos = "jdbc:mysql://localhost/test?user=usuario&password=123";
En la URL de la conexión debes tomar en cuenta que:
localhost indica el host o la IP del servidor Oracle.
test es la base de datos.
user es el usuario con el que te vas a conectar.
password es la contraseña.
En este momento lo único que nos falta para crear la conexión es llamar al métodogetConnection() del driver de la siguiente manera:
setConexion(DriverManager.getConnection(BaseDeDatos));
Puedes validar si la conexión se realizó correctamente verificando si la variable es nula:
if (conexion != null) {
System.out.println("Conexion exitosa!");
} else {
System.out.println("Conexion fallida!");
}
El método completo entonces quedaría de la siguiente manera:
public MySQLBD conectar() {
try {
Class.forName("com.mysql.jdbc.Driver");
String BaseDeDatos = "jdbc:mysql://localhost/test?user=usuario&password=123";
setConexion(DriverManager.getConnection(BaseDeDatos));
if(getConexion() != null){
System.out.println("Conexion Exitosa!");
}else{
System.out.println("Conexion Fallida!");
}
} catch (Exception e) {
e.printStackTrace();
}
return this;
}
Ejecutar sentencias en la base de datos
Ya que hemos realizado la conexión a la base de datos podemos trabajar con ella por lo cual crearemos un método a partir del cual ejecutaremos las sentencias más comunes que no nos devuelven resultados como INSERT, UPDATE, DELETE, etc.
Vamos a definir el método para que sea público y nos devuelva un valor booleano, true si se ejecuta la consulta correctamente, false si no. A su vez recibirá una cadena que contendrá la consulta SQL a ejecutar.
public boolean ejecutar(String sql) {
.
.
.
}
Posteriormente, igual como lo hicimos en el método anterior, vamos a encerrar prácticamente todo el comportamiento dentro de try-catch.
public boolean ejecutar(String sql) {
try {
.
.
.
} catch (SQLException e) {
e.printStackTrace();
return false;
}
return true;
}
Ahora definimos un objeto tipo Statement que nos ayudará a ejecutar la consulta de la siguiente manera:
Statement sentencia = getConexion().createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
sentencia.executeUpdate(sql);
Por último cerramos la sentencia para liberar recursos:
sentencia.close();
En el caso de que se presente una excepción daremos por hecho que no se realizó la ejecución correctamente, por lo tanto, sólo en ese caso retornaremos false.
El método completo luce de la siguiente manera:
public boolean ejecutar(String sql) {
try {
Statement sentencia = getConexion().createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
sentencia.executeUpdate(sql);
sentencia.close();
} catch (SQLException e) {
e.printStackTrace();
return false;
} return true;
}
Realizar consultas a la base de datos
Lo único que nos falta es consultar a la base de datos (SELECT) lo cual haremos igualmente mediante un método público que nos devuelva un objeto de tipo ResultSet e igualmente recibirá una cadena que contendrá una consulta SQL a realizar.
public ResultSet consultar(String sql) {
.
.
.
}
Lo primero que vamos a agregar es una declaración del objeto de tipo ResultSet y posteriormente encerraremos la ejecución dentro de un try-catch para capturar las excepciones que se puedan generar.
public ResultSet consultar(String sql) {
ResultSet resultado = null;
try {
} catch (SQLException e) {
e.printStackTrace();
return null;
}
return resultado;<
}
De igual manera nos apoyaremos de un objeto de tipo Statement para poder realizar la consulta.
Statement sentencia = getConexion().createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
Obtenemos el mapa de resultados a través del método executeQuery() del objeto Statementy posteriormente llamamos al método commit() de la conexión para asegurarnos que la consulta se está realizando.
resultado = sentencia.executeQuery(sql);
getConexion().commit();
En el caso de que se presente una excepción daremos por hecho que no se realizó la consulta correctamente, por lo tanto, sólo en ese caso retornaremos null.
El método completo se ve de la siguiente manera:
public ResultSet consultar(String sql) {
ResultSet resultado;
try {
Statement sentencia = getConexion().createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
resultado = sentencia.executeQuery(sql);
} catch (SQLException e) {
e.printStackTrace();
return null;
} return resultado;
}
Con esto tenemos completa nuestra clase que se encargará de realizar la conexión, consulta y ejecución de sentencias en la base de datos Oracle.
Probar el funcionamiento
Para verificar que todo funciona bien podemos crear una tabla en la base de datos de nombreTEST con 2 campos, IDENTIFICADOR de tipo INTEGER y DESCRIPCION de tipo VARCHAR y ejecutar lo siguiente dentro del método main:
public static void main(String[] args) {
MySQLBD baseDatos = new MySQLBD().conectar();
if (baseDatos.ejecutar("INSERT INTO TEST(IDENTIFICADOR,DESCRIPCION) VALUES(3,'TRES')")) {
System.out.println("Ejecución correcta!");
} else {
System.out.println("Ocurrió un problema al ejecutar!");
} ResultSet resultados = baseDatos.consultar("SELECT * FROM TEST"); if (resultados != null) {
try {
System.out.println("IDENTIFICADOR DESCRIPCION");
System.out.println("--------------------------------");
while (resultados.next()) {
System.out.println(""+resultados.getBigDecimal("IDENTIFICADOR")+" "+resultados.getString("DESCRIPCION"));
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
3.- SUMARY
Creating the NetBeans project:
In particular I use to date of publication of this article is the latest version of NetBeans: 7.1.1. To create the project simply click on the de'Nuevo Project 'button or go to File -> New Project.
The project will entitle him MySQLBD, although it is only a suggested name because it does not in the least affect the behavior of the program. Once you create the IDE project will position us in the main class of the same and will create itself from the main method which will execute all our procedures.
Establish the connection to the database
The first thing we do is import the classes and / or packages that we use (the so-called import's), in this case only will be shown below:
import java.sql. *;
Later in the class we declare a private variable of type Connection that will be containing the connection to the database:
{public class MySQLBD
private Connection connection;
.
.
To organize your code will create the get and set Connection and the method llamadoconectar () which will establish the connection to the database so that we can then perform the procedures we need. Within the method we lock you most of the code inside a try-catch in order to catch exceptions that may arise after the execution.
getConexion public Connection () {
return connection;
}
public void setConexion (Connection connection) {
this.conexion = connection;
}
MySQLBD public connect () {
try {
.
.
.
} Catch (Exception e) {
e.printStackTrace ();
}
return this;
}
As you can see, the method returns an instance of the class MySQLBD (ie, the same that contains it), this in order to chain the following methods that you need and save a line of code.
Now, within the try-catch first thing we will do is to load the driver into memory and then create a string with the connection URL to the database as shown in the following code:
Class.forName ( "com.mysql.jdbc.Driver");
String Database = "jdbc: mysql: // localhost / test user = user & password = 123";
In the URL of the connection you should note that:
localhost indicates the host or IP of the Oracle server.
test is the database.
user is the user that you are connecting.
password is the password.
Right now the only thing we lack is to create the connection métodogetConnection call () driver as follows:
setConexion (DriverManager.getConnection (database_name));
You can validate if the connection was successful by checking if the variable is null:
if (connection! = null) {
System.out.println ( "Connection succeeded!");
} Else {
System.out.println ( "Connection failed!");
}
The complete method then would be as follows:
MySQLBD public connect () {
try {
Class.forName ( "com.mysql.jdbc.Driver");
String Database = "jdbc: mysql: // localhost / test user = user & password = 123";
setConexion (DriverManager.getConnection (database_name));
if (getConexion ()! = null) {
System.out.println ( "Connection Successful!");
} Else {
System.out.println ( "Connection failed!");
}
} Catch (Exception e) {
e.printStackTrace ();
}
return this;
}
Execute statements in the database
Since we have made the connection to the database we can work with it so we will create a method from which we will execute the most common statements that do not return results as INSERT, UPDATE, DELETE, etc.
Let's define the method to be public and we return a Boolean value, true if the query is successful, false if not. In turn you will receive a string containing the SQL query to execute.
public boolean execute (String sql) {
.
.
.
}
Later, just as we did in the previous method, we will enclose virtually all behavior in try-catch.
public boolean execute (String sql) {
try {
.
.
.
} Catch (SQLException e) {
e.printStackTrace ();
return false;
}
return true;
}
Now we define an object type Statement that will help us run the query as follows:
Statement statement = getConexion () createStatement (ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY).;
sentencia.executeUpdate (sql);
Finally we close the statement to release resources:
sentencia.close ();
In the event that this exception we will assume that the execution was unsuccessful, therefore, only then we will return false.
The complete method looks as follows:
public boolean execute (String sql) {
try {
Statement statement = getConexion () createStatement (ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY).;
sentencia.executeUpdate (sql);
sentencia.close ();
} Catch (SQLException e) {
e.printStackTrace ();
return false;
} Return true;
}
Querying the database
The only thing missing is consulting the database (SELECT) which will equally by a public method that returns a ResultSet object type and also receive a string containing an SQL query to perform.
ResultSet public consultation (String sql) {
.
.
.
}
The first thing we will add is a statement ResultSet object and then lock you type execution within a try-catch to catch exceptions that may be generated.
ResultSet public consultation (String sql) {
ResultSet result = null;
try {
} Catch (SQLException e) {
e.printStackTrace ();
return null;
}
return result; <
}
Similarly we will build a Statement object type to perform the query.
Statement statement = getConexion () createStatement (ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY).;
Obtain the map of results through the executeQuery () method of the object Statementy then we call commit () method of the connection to ensure that consultation is underway.
result = sentencia.executeQuery (sql);
getConexion () commit ().;
In the event that this exception we will assume that the query was not successful, therefore, only then we will return null.
The entire method is as follows:
ResultSet public consultation (String sql) {
ResultSet result;
try {
Statement statement = getConexion () createStatement (ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY).;
result = sentencia.executeQuery (sql);
} Catch (SQLException e) {
e.printStackTrace ();
return null;
} Return result;
}
With this we complete our class that will handle the connection, consultation and enforcement of judgments in the Oracle database.
Test operation
To verify that everything works well we can create a table in the database nombreTEST with 2 fields, ID type and description INTEGER VARCHAR and execute the following in the main method:
public static void main (String [] args) {
MySQLBD yourdb = new MySQLBD () connect ().;
if (baseDatos.ejecutar ( "INSERT INTO TEST (IDENTIFIER, description) VALUES (3, 'THREE')")) {
System.out.println ( "Successful execution!");
} Else {
System.out.println ( "There was a problem running!");
} ResultSet results = baseDatos.consultar ( "SELECT * FROM TEST"); if (result! = null) {
try {
System.out.println ( "IDENTIFIER DESCRIPTION");
System.out.println ( "--------------------------------");
while (resultados.next ()) {
System.out.println ( "" + resultados.getBigDecimal ( "identifier") + "" + resultados.getString ( "Description"));
}
} Catch (Exception e) {
e.printStackTrace ();
}
}
}
No hay comentarios:
Publicar un comentario