conectar una base de datos en mysql con netbeans
DESCRIPTION
todo el proceso para la conexión de Mysql con java ( con el ide Netbeans )TRANSCRIPT
Conectar una base de datos en MySQL con NetBeans
NetBeans es una plataforma para el desarrollo de aplicaciones de escritorio usando Java y a
un Entorno integrado de desarrollo (IDE) desarrollado usando la Plataforma NetBeans.
Si eres un programador y desarrollas tus aplicaciones en Java seguramente necesitarás
conectar una base de datos tipo MySQL a este entorno algún día, bueno, si lo necesitas
ahora, he aquí una explicación paso a paso de cómo conectar ambas herramientas.
Obtener lo necesario::
Primero que nada necesitas tener un servidor MySQL instalado en tu equipo o en su
defecto en la máquina que actuará como servidor de bases de datos. Recuerda que
MySQL es gratuito y puedes obtenerlo desde aquí.
El proceso de instalación es algo en lo que no entraré en detalle, para cualquier duda
puedes consultar la documentación oficial que se encuentra en su sitio web.
Asimismo, debes de tener el NetBeans instalado, de preferencia su última versión
estable (al momento de esta publicación es la 5.5.1) que viene con el Java
Development Kit (JDK) 1.6, lo anterior puedes obtenerlo desde aquí.
Una vez que tengas ambas herramientas instaladas necesitaras el driver o conector a
la base de datos de MySQL que puedes obtener desde aquí.
Copiar lo necesario::
Una vez que tengas el NetBeans y el MySQL Server instalado lo que vas a necesitar es copiar
el driver que descargaste, en mi caso el mysql-connector-java-3.1.11-bin.jar dentro de la
carpeta del JDK, en mi caso es la siguiente ruta:
C:\Archivos de programa\Java\jdk1.6.0_01\jre\lib\ext
*NOTA: Debes tener el conector dentro de la carpeta anterior antes de ejecutar el NetBeans,
en caso de que esté abierto ciérralo y vuélvelo a abrir.
Ya que lo hayas copiado ahora sí abre el NetBeans y espera a que cargue.
Configurar NetBeans::
Una vez que hayas abierto el NetBeans localiza la sección de Runtime o Tiempo de
ejecución que se localiza en el lado izquierdo de la pantalla, como se muestra a continuación:
Al expandir la sección de Databases o Bases de datos debe de aparecer el MySQL
(Connector/J driver), en caso contrario debes de agregarlo manualmente como se describe a
continuación:
1. Da un clic derecho sobre Drivers y selecciona New Driver.
2. En la ventana que aparece da clic en el botón de Add o Agregar y busca el
archivo .jar que descargaste anteriormente, el mismo que copiaste dentro de la
carpeta del JDK.
3. Una vez hecho lo anterior da clic en el botón de Ok o Aceptar.
Cuando realices los pasos anteriores debe de aparecer un elemento nuevo en la sección de
Drivers dentro de Databases de nombre MySQL (Connector/J driver).
Crear y probar una conexión::
Dentro de la sección de Runtime o Tiempo de ejecución > Databases o Bases de
datos >Drivers da un clic derecho sobre MySQL (Connector/J driver) y selecciona Connect
Usingo Conectar usando... para que aparezca la pantalla de configuración de la conexión
como se muestra a continuación:
En la sección de Name o Nombre selecciona MySQL (Connector/J driver), en la sección
Database URL cambia la parte indicada por por la dirección del servidor de bases de datos, si
es la misma computadora escribe localhost, en la parte de establece el puerto que definiste al
instalar el servidor MySQL , por defecto es el 3306, en la sección de escribe el nombre de la
base de datos a la cual te quieres conectar. Un ejemplo completo
seríajdbc:mysql://localhost:3306/base_de_datos.
Posteriormente escribe el nombre de usuario para accesar a la base de datos y la contraseña
respectivamente.
Da un clic en el checkbox inferior para que NetBeans recuerde la contraseña durante la
conexión.
Si todo se realizó correctamente podrás ver un nuevo elemento debajo del Driver con las
especificaciones de la conexión actual, si das un clic en el símbolo '+' que aparece de lado
izquierdo del mismo podrás ver las tablas de la base de datos y realizar consultas hacia la
misma.
Implementar el código::
Hasta aquí ya hemos establecido la conexión a la base de datos y probado su funcionamiento
desde el NetBeans, sin embargo, nos hace falta implementar el código directamente en una
aplicación. Para este ejemplo crearemos una clase de nombre Conexion que se podrá
reutilizar las veces que sea necesario en cualquier tipo de aplicación Java que requiera
conectarse y realizar consultas a una base de datos en MySQL.
Empecemos por el principio...
1. Da un clic en el menú de File o Archivo que se localiza en la esquina superior
izquierda de la ventana de NetBeans.
2. Selecciona la opción de Nuevo Proyecto o New Project, posteriormente en la sección
de Categories o Categorías selecciona General y
en Projects o Proyectos seleccionaJava Application o Aplicación Java y da un clic
en Siguiente.
*NOTA: La clase que crearemos funciona con cualquier tipo de proyecto, para fines de
este ejemplo utilizamos una aplicación java convencional.
3. Posteriormente damos un nombre a la aplicación y definimos su ubicación, una vez
hecho esto damos clic en el botón de Finish o Finalizar.
4. En este momento aparece del lado izquierdo en la pestaña
de Projects o Proyectosuna especie de árbol jerárquico en el cual tenemos 4
carpetas, al dar clic en el símbolo '+' de la carpeta Source Packages o Paquetes
Fuente nos desplegará el único paquete con el cual cuenta nuestra aplicación hasta
este punto, dentro de él se crea la clase Main.
5. Ahora debemos de dar un clic derecho sobre Source Packages o Paquetes Fuente y
dar un nombre al paquete, en mi caso es database. Este paquete contendrá la clase
desde la cual estaremos realizando todas las consultas a la base de datos.
6. Posteriormente damos un clic derecho sobre el paquete recién creado y
seleccionamosNueva o New > Java Class. Posteriormente le damos el nombre
de Conexion y damos clic en el botón de Finalizar o Finish.
7. Dentro de la clase Conexion importamos algunas librerías con el siguiente código:
?
12345
import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;
8.[1.] Una vez que tenemos las librerías creamos los métodos a utilizar descritos a
continuación:
?
123456789101112
/*** Método utilizado para recuperar el valor del atributo conexion* @return conexion contiene el estado de la conexión**/public Connection getConexion(){ return conexion;}
/*** Método utilizado para establecer la conexión con la base de datos* @return estado regresa el estado de la conexión, true si se estableció la conexión,* falso en caso contrario
1314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
*/public boolean crearConexion(){ try { Class.forName("com.mysql.jdbc.Driver"); conexion = DriverManager.getConnection("jdbc:mysql://host:puerto/baseDatos","usuario","contraseña"); } catch (SQLException ex) { ex.printStackTrace(); return false; } catch (ClassNotFoundException ex) { ex.printStackTrace(); return false; }
return true;}
/****Método utilizado para realizar las instrucciones: INSERT, DELETE y UPDATE*@param sql Cadena que contiene la instrucción SQL a ejecutar*@return estado regresa el estado de la ejecución, true(éxito) o false(error)**/public boolean ejecutarSQL(String sql){ try { Statement sentencia = conexion.createStatement(); sentencia.executeUpdate(sql); } catch (SQLException ex) { ex.printStackTrace(); return false; }
return true;}
/****Método utilizado para realizar la instrucción SELECT*@param sql Cadena que contiene la instrucción SQL a ejecutar*@return resultado regresa los registros generados por la consulta**/public ResultSet ejecutarSQLSelect(String sql){ ResultSet resultado; try { Statement sentencia = conexion.createStatement(); resultado = sentencia.executeQuery(sql); } catch (SQLException ex) { ex.printStackTrace(); return null; }
606162636465666768697071
return resultado;}
9. Finalmente compilamos el archivo localizándolo en el árbol jerárquico del lado izquierdo dando un clic
derecho sobre él y seleccionando la opción de Compilar o Compile. Podrás utilizar la clase en
cualquier parte de tu proyecto creando una instancia de la misma en el momento que sea necesario.
*TIP: Crea únicamente una vez la conexión con el método crearConexion() desde la clase Main y
pasa tu conexión como parámetro a todas las ventanas y módulos de la aplicación que la utilicen.
Una vez realizado lo anterior estarás listo para conectarte a bases de datos en MySQL desde
NetBeans, la clase Conexión y el driver para MySQL puedes descargarlos este vínculo en un
archivo comprimido tipo rar, este manual se encuentra en formato PDF desde este vínculo.
¿Como conectar Mysql con Java?julio 9, 2014 James Revelo
Conectar tus aplicaciones Java a un servidor de bases de datos es
imprescindible para la funcionalidad de una solución de Software. Al
igual que Sql server y C# , Mysqly Java necesitan de una interfaz que
proporcione las clases necesarias para gestionar una conexión.
Para comprender el funcionamiento de este enlace comenzaremos explicando
como adherir el API de conexión a nuestros IDEs ( en este caso veremos
como hacerlo con Netbeans y Eclipse), luego implementaremos el código
para abrir la conexión. En seguida veremos como ejecutar comandos y al
finalizar estudiaremos la ejecución de procedimientos almacenados.
¿Que es el API de conexión?Es un conjunto de interfaces relacionadas que permiten realizar una
conexión de un servidor de bases de datos a una aplicación Java.
Normalmente se le denomina JDBC (Java Database Connectivity).La
idea es usar un Driver que gestione el acceso a un servidor Mysql, y así
abrir la conexión con la intención de ejecutar comandos en la base de
datos. Este Driver puedes descargarlo desde aquí o ir al sitio
original de descargas:
http://www.mysql.com/downloads/
¿Como incluyo el Driver en NetBeans?Es sencillo! Primero extraes el Driver en un lugar especifico que te parezca
cómodo, por ejemplo a la ruta C:mysqlDriver. Luego entra a Netbeans y
sitúate en la barra de herramientas “Projects“.
Explorador de proyectos en Netbeans
Ahora haz clic derecho en la carpeta “Libraries” y presiona la opción
“Add JAR/FOLDER…” .
Añadiendo un nuevo JAR al proyecto
Ahora busca el archivo “mysql-connector-java-5.1.31-bin.jar” en la
carpeta descomprimida.
Seleccionando el conector
Cuando hayas incluido el archivo, el explorador de proyectos mostrará
una nueva dependencia hacia el conector. Ahora ya puedes conectar tu
aplicación Java y una base de datos en Mysql.
Nueva dependencia en nuestro proyecto
¿Como instalo el Driver en Eclipse?La instalación en este IDE es muy similar a Netbeans. Recuerda que el
primer paso es extraer el archivo del conector en un lugar conveniente
para ti. Ahora enfocate en la barra de herramientas llamada “Package
Explorer“:
Explorador de paquetes en Eclipse
Ahora agregaremos la dependencia de nuestro archivo .jar. Para ello
haremos clic derecho en el proyecto y seguiremos la ruta Build
Path>Add External Archives…
Añadir el arhivo JAR de conexión
Busca el archivo “mysql-connector-java-5.1.31-bin.jar” en donde
extrajiste el conector y selecciónalo.
Seleccion del conector MySQL
Si todo salió bien, tendrás una nueva librería externa con el nombre de
nuestro conector. Con eso ya podrás ejecutar acciones sobre las base de
datos del servidor Mysql.
Dependencia adicional a nuestro Conector
¿Como realizo la conexión a mi base de datos?Primero incluiremos todas las clases JDBC desde el paquete sql:
import java.sql.*;
En este paquete se encuentran las clases para registrar la conexión a
nuestra base de datos, crear un comando, crear instancias para ejecutar
procedimientos y mucho mas.
Luego inicializamos el Driver con el método
estático Class.forName(). Este método le dice a lamáquina virtual
de Java que busque en tiempo real la clase en el directorio de variables
(PATH,CLASSPATH, etc) .En el caso de Netbeans y Eclipse también
buscará en las directivas del proyecto adicionales.
try {
Class.forName("com.mysql.jdbc.Driver").newInstance();
System.out.println("Registro exitoso");
} catch (Exception e) {
System.out.println(e.toString());
}
Ahora para abrir la conexión usamos la interfaz Connection, la cual
recibe la referencia del servidorde bases de datos a través del
método getConnection() de la interfaz DriverManager:
Connection con = null;
//...
try {
con = DriverManager.getConnection(
"jdbc:mysql://localhost/TuBaseDeDatos?"
+ "user=TuUsuario&password=TuPass");
// Otros y operaciones sobre la base de datos...
} catch (SQLException ex) {
// Mantener el control sobre el tipo de error
System.out.println("SQLException: " + ex.getMessage());
}
El String que recibe getConnection() se refiere a al cadena de
conexión para acceder a nuestra base de datos. Debemos indicar
el nombre del servidor, el nombre de la base de
datos, usuario ypassword. Hay otros parámetros adicionales, pero
estos son básicamente los que permiten un acceso rápido y corriente a
la base de datos.
Veamos la sintaxis:
jdbc:mysql://[host:puerto],[host:puerto].../[base_de_datos][?propiedad1][=valor1]
[&propiedad2][=valor2]...
Aquellas partes que se encuentran en corchetes son opcionales.
Finalmente usa el método close()para cerrar la conexión de forma
segura.
con.close();
¿Que hago para ejecutar un comando?Usaremos la clase Statement (sentencia, esp.) para realizar
operaciones sobre nuestra base de datos. Crearemos una instancia de la
clase con el método createStatement() de la clase Connection:
Statement cmd = con.createStatement();
Recuerda que una consulta (SELECT) retorna en una o mas filas de una
tabla. En cambio la inserción, modificación y eliminación cambian la
base de datos, pero no retornan en una estructura tabular.
Teniendo en cuenta esto, usaremos dos métodos distintos de la
clase Statement dependiendo deltipo de comando. Si vas a
implementar un comando INSERT, DELETE, UPDATE, SET, etc., usas el
método executeUpdate():
try {
cmd = con.createStatement();
cmd.executeUpdate("DELETE FROM HERRAMIENTA WHERE NOMBRE = 'Serrucho'");
// ...
}
Como ves, executeUpdate() recibe como parámetro la cadena que
representa al comando. En el caso de usar SELECT, emplearemos el
método executeQuery(), cuyo resultado es de tipo ResultSet. Esta
clase hace parte del paquete sql que importamos, y sirve para manejar
las filas retornadas de una consulta.
Por ejemplo…
ResultSet rs = null;
Statement cmd = null;
// ...
try {
cmd = con.createStatement();
rs = cmd.executeQuery("SELECT NOMBRE, EDAD FROM CIUDADANO");
// ...
}
Ahora, si queremos ver en pantalla los resultados o simplemente
acceder a cada fila, usaremos el método next() de la clase ResulSet.
Este método nos permitirá mover un puntero de lectura a la siguiente
fila del resultado en forma secuencial, hasta que se haya recorrido la
tabla completa. Usaremos un while que lea todo el resultado.
while (rs.next()) {
String nombre = rs.getString("NOMBRE");
int edad = rs.getInt(2);
System.out.println(nombre + "-" + edad);
}
rs.close();
El código anterior implementa los
métodos getString() y getInt() de ResultSet. Ambos métodos
obtienen el valor de la columna retornada, especificando el nombre de
la columna o su posición. Es importante cerrar el
objeto ResultSet con close() para desreferenciar el puntero que
estaba recorriendo la tabla.
Quisiera saber como generalizar mis comandos!Es justamente lo que quería explicarte!, ya que hacer genérico un
comando es esencial para combinarlo con los datos proporcionados por
los controles Swing de Java.
Supón que un usuario va a eliminar un cliente de la base de datos a
través del código. ¿Como hacer para embeber este código en
el String de comando?
La respuesta esta en la clase PreparedStatement. Esta clase
permite ejecutar varias veces un comando con tan solo
una definición genérica. Para ello usaremos el carácter ‘?‘, el cual
otorgacapacidad polimorfa al parámetro incluido en el comando.
Esta es la respuesta a la pregunta inicial:
PreparedStatement pCmd = con.prepareStatement("DELETE FROM CLIENTE" + " WHERE ID
= ? ");
// ...
int valor = Integer.parseInt(jTextField1.getText());
pCmd.setInt(1, valor);
pCmd.executeUpdate();
Como ves, usamos ‘?‘ para indicar que el código del cliente será
variable. Luego usamos el métodosetInt() para especificar que en el
primer ‘?‘ vamos a poner el valor de la variable extraído del Text Field.
¿Como hago con los procedimientos almacenados?Empleamos la clase CallableStatement. Esta clase permite especificar
el tipo de parámetros que tiene el procedimiento, ya
sea IN, OUT o INOUT. Ademas permite gestionar los resultados en
forma tabular que arroje el procedimiento, si es que los arroja, u obtener
el valor de los parámetros tipo OUT.
Para crear un comando ejecutable usaremos el
método prepareCall() de la clase Connection, veamos:
CallableStatement cmdC = con.prepareCall(ejecución_procedimiento);
Para hacer la llamada del procedimiento se deben usar llaves ‘{}‘ en la
elaboración de la cadena para el comando. Recuerda que cuando
vimos procedimientos en Mysql usábamos la clausula CALLpara
ejecutarlo. Aquí también usaremos CALL para ejecutar el comando y
además añadiremos el carácter ‘?‘ para indicar el polimorfismo de los
parámetros.
CallableStatement cmdC = con.prepareCallable("{CALL proc_dos_parametros(?,?)}");
Por defecto los parámetros son de entrada, pero si en algún momento
deseas establecer que alguno es de salida, debes registrarlo mediante el
método registerOutParameter().
cmdC.registerOutParameter(2,Types.INTEGER);
Este método recibe dos parámetros, el primero es la posición del
parámetro y el segundo es el tipodel parámetro. El tipo lo indicamos
mediante los atributos de la clase Types, la cual contiene todos los tipos
de datos empleados en Mysql. En este caso en particular registramos al
segundo parámetro como OUT y de tipo INTEGER.
Ahora para alimentar los parámetros de entrada volvemos a usar los
métodos set. Dependiendo del tipo de dato existen las
alternativas setInt(), setString(), setDate(), setFloat(), etc. Todo
depende de las necesidades.
¿Y como ejecuto un procedimiento almacenado?Primero usaremos el método execute(), cuyo valor de retorno
es booleano. Si retorna en truesignifica que el procedimiento
devuelve una o mas filas, por lo que usaremos luego el
métodogetResultSet(). Si el valor es false, entonces el procedimiento
se ejecuta con el métodoexecuteUpdate() ya que solo modifica la base
de datos:
if (cmdC.execute()) {
ResultSet rs = cmdC.getResultSet();
//Otras acciones...
} else {
System.out.println("No se retornaron resultados");
}
Igual que con los comandos normales usaremos los métodos get para
obtener los resultados de los parámetros tipo OUT.
System.out.println("Parametro OUT:"+cmdC.getInt(1));
Amigo, ¿puedes mostrar un ejemplo completo?Claro que si!, fíjate en la siguiente situación:
Suponga que le ha vendido un proyecto de Software a
la aseguradora ProtectYAPA para gestionar los clientes y la
información sobre los seguros que se ofrecen. Usted y su equipo se dan
cuenta que necesitan invocar un procedimiento almacenado en el
servidor Mysql, cuya función es encontrar los clientes mayores a una
edad pasada como parámetro. A través de la interfaz, el usuario final
digitará el valor mediante un JTextField , que está contenido en
unJFrame de reglas.
Para solucionar el anterior problema implementaremos el siguiente
código:
try {
con = DriverManager.getConnection(
"jdbc:mysql://PROTECTYAPA-SERVER/aseguradora?"
+ "user=admin&password=admin");
CallableStatement cmd = con.prepareCall("{CALL sp_clientes_edad( ?)} ");
cmd.setString(1, jTextField1.getText());
// Ejecutamos el comando
if (cmd.execute()) {
// Obtenemos la tabla retornada
ResultSet rs = cmd.getResultSet();
// Obtenemos cada fila del resultado
while (rs.next()) {
addFila(new Object[]{rs.getString("NOMBRE"), rs.getString("APELLIDO")});
}
}
else{
System.out.println("No se retornaron filas");
}
} catch (SQLException ex) {
// Mantener el control sobre el tipo de error
System.out.println("SQLException: " + ex.getMessage());
}
El método addFila() que invocamos es la implementación modular de la
agregación de filas a unJTable. Su definición es la siguiente:
public void addFila (Object fila[]){
DefaultTableModel modelo = new DefaultTableModel();
modelo = (DefaultTableModel) jTable1.getModel();
modelo.addRow(fila);
}
¿Algún ejemplo con un parámetro OUT?Por supuesto!, miremos otro requerimiento en el Sofware de
la empresa de seguros:
Se desea llamar a un procedimiento almacenado en la base de datos
llamadosp_mejor_vendedor. Este procedimiento posee
dos parámetros de salida que reciben el código del mejor vendedor
de seguros y la cantidad acumulada de ventas que realizó en el mes.
La solución propuesta por el equipo es la siguiente:
try {
con = DriverManager.getConnection(
"jdbc:mysql://PROTECTYAPA-SERVER/aseguradora?"
+ "user=admin&password=admin");
CallableStatement cmd = con.prepareCall("{CALL sp_mejor_vendedor( ?, ?)} ");
// Registramos los dos parámetros de salida
cmd.registerOutParameter(1, Types.INTEGER);
cmd.registerOutParameter(2, Types.INTEGER);
// Ejecutamos el procedimiento
cmd.executeUpdate();
// Obtenemos el valor de ambos parametros
int idVendedor = cmd.getInt(1);
int monto = cmd.getInt(2);
// Imprimimos los resultados del procedimiento
System.out.println(idVendedor + "-" + monto);
} catch (SQLException ex) {
// Mantener el control sobre el tipo de error
System.out.println("SQLException:" + ex.getMessage());
}
Estos pequeños ejemplos que acabo de mostrarte han sido construidos
de forma secuencial yexplicativa, pero seria conveniente que uses el
poder de la Programación Orientada a Objetoscuando desees
conectar tu aplicación Java a Mysql.
Puedes definir una clase Conexion y atribuirle métodos para ejecutar
comandos que devuelvan filas, ejecutar comandos que solo modifiquen
la base de datos, abrir la conexión, cambiar de base de datos, etc.
Este enfoque te permitirá generalizar tus acciones sobre la base de
datos en tu aplicación, lo que otorgaría flexibilidad en el desarrollo si
trabajas con un equipo.
Conectar Java con MySQL en Netbeans11 marzo, 2015 Ferchu Java, MySQL Sin comentarios
Bueno, sinceramente llevo poco tiempo trabajando con Java, aunque de a poco
estoy tomándole aprecio a este excelente lenguaje de programación. Sí en
cambio llevo muchos años trabajando en web, más precisamente con PHP y
MySQL. En esta ocasión voy a explicar de forma muy resumida, los pasos a
seguir para conectar Java con MySQL.
Java puede conectarse a múltiples bases de datos, con la que mejor se lleva es
con Oracle, sin embargo en ocasiones puede ser que los que venimos de la
web, al tener la necesidad de hacer una aplicación de escritorio, nos sintamos
más acostumbrados con MySQL.
En primer lugar, para realizar este ejemplo debemos tener instalado tres cosas
en nuestro sistema:
La máquina virtual de Java (Para ejecutar Java, claro está)
MySQL (en mi caso yo tengo instalado Xampp que viene con Apache y
MySQL, entre otros servicios
Netbeans (Con Java instalado)
¡Comencemos!
MySQL
En primer lugar vamos a crear una base de datos, a la cual yo
llamaré: java_mysql. La mista tendrá una sola tabla llamada tareas con el
siguiente código:
CREATE TABLE tareas(
id_tarea int(10) unsigned not null auto_increment primary key,
titulo varchar (50) not null,
descripcion varchar(255) not null,
nivel_de_prioridad tinyint(1) not null
);
Java
Vamos a abrir Netbeans y vamos a crear un nuevo proyecto, yendo a File ->
New Project -> Java -> Java Application.
Vamos a ponerle un nombre y vamos a guardarlo en alguna parte de nuestra
máquina.
Vamos a borrar todo lo que esté dentro de la carpeta source (o src) y dentro
vamos a crear dos paquetes, uno al que yo llamaré modelos y otro al que
llamaré servicios.
Ahora, para conectar Java a MySQL tenemos que agregar un librería que se
encargará de hacer esa magia. Así que dentro que pulsando botón derecho
sobre la carpeta Libraries, vamos a ir a Add Library
Y agregamos la librería MySQL JDBC Driver, primero seleccionándola y luego
pulsando Add Library.
Bueno, ya tenemos todo, no nos falta nada. Ya podemos empezar a escribir
código Java.
Dentro del paquete modelos, vamos a crear una clase, a la que yo
llamaré Tarea.java, con el siguiente código:
package modelos;
public class Tarea {
private final Integer id_tarea;
private String titulo;
private String descripcion;
private Integer nivel_de_prioridad;
public Tarea() {
this.id_tarea = null;
this.titulo = null;
this.descripcion = null;
this.nivel_de_prioridad = null;
}
public Tarea(Integer id_tarea, String titulo, String descripcion,
Integer nivel_de_prioridad) {
this.id_tarea = id_tarea;
this.titulo = titulo;
this.descripcion = descripcion;
this.nivel_de_prioridad = nivel_de_prioridad;
}
public Integer getId_tarea() {
return id_tarea;
}
public String getTitulo() {
return titulo;
}
public String getDescripcion() {
return descripcion;
}
public Integer getNivel_de_prioridad() {
return nivel_de_prioridad;
}
public void setTitulo(String titulo) {
this.titulo = titulo;
}
public void setDescripcion(String descripcion) {
this.descripcion = descripcion;
}
public void setNivel_de_prioridad(Integer nivel_de_prioridad) {
this.nivel_de_prioridad = nivel_de_prioridad;
}
@Override
public String toString() {
return "Tarea{" + "id_tarea=" + id_tarea + ", titulo=" + titulo +
", descripcion=" + descripcion + ", nivel_de_prioridad=" +
nivel_de_prioridad + '}';
}
}
Una clase, nada nuevo, que va a representar el modelo de una tarea.
Conectando JAVA con MySQL
Bien, ahora creamos la clase que va a conectar nuestra aplicación con MySQL,
yendo al paquete servicios, vamos a crear una nueva clase
llamada Conexion.java con el siguiente código:
package servicios;
import java.sql.*;
public class Conexion {
private static Connection cnx = null;
public static Connection obtener() throws SQLException,
ClassNotFoundException {
if (cnx == null) {
try {
Class.forName("com.mysql.jdbc.Driver");
cnx =
DriverManager.getConnection("jdbc:mysql://localhost/java_mysql", "root",
"");
} catch (SQLException ex) {
throw new SQLException(ex);
} catch (ClassNotFoundException ex) {
throw new ClassCastException(ex.getMessage());
}
}
return cnx;
}
public static void cerrar() throws SQLException {
if (cnx != null) {
cnx.close();
}
}
}
Esta clase tendrá un método estático llamado obtener(), el cual va a
devolvernos una instancia de conexión y de no haber una previa va crear una:
cnx = DriverManager.getConnection("jdbc:mysql://localhost/java_mysql",
"root", "");
Esto gracias al método getConnection(), el cuál recibirá como primer
parámetro el tipo de base de datos (MySQL) y la ubicación de la base de datos,
en mi caso, como estoy trabajando en un entorno local, será localhost. El
segundo parámetro es el usuario y el tercero la contraseña.
A su vez este método puede disparar dos excepciones, SQLException, si
surge algún error, por ejemplo que no se pueda conectar a la base de datos,
y ClassNotFoundException, en caso de que no encuentre la librería.
Y por último el método, también estático, cerrar(), que como su nombre lo
indica, cerrará la conexión, en caso de que haya alguna abierta.
Consultas
Para hacer las consultas con la base de datos, dentro del paquete servicios,
creamos una clase con el nombre: Tareas_servicio.java con el siguiente
código:
package servicios;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import modelos.Tarea;
public class Tareas_servicio {
private final String tabla = "tareas";
public void guardar(Connection conexion, Tarea tarea) throws
SQLException{
try{
PreparedStatement consulta;
if(tarea.getId_tarea() == null){
consulta = conexion.prepareStatement("INSERT INTO " +
this.tabla + "(titulo, descripcion, nivel_de_prioridad)
VALUES(?, ?, ?)");
consulta.setString(1, tarea.getTitulo());
consulta.setString(2, tarea.getDescripcion());
consulta.setInt(3, tarea.getNivel_de_prioridad());
}else{
consulta = conexion.prepareStatement("UPDATE " + this.tabla +
" SET titulo = ?, descripcion = ?, nivel_de_prioridad = ? WHERE id_tarea
= ?");
consulta.setString(1, tarea.getTitulo());
consulta.setString(2, tarea.getDescripcion());
consulta.setInt(3, tarea.getNivel_de_prioridad());
consulta.setInt(4, tarea.getId_tarea());
}
consulta.executeUpdate();
}catch(SQLException ex){
throw new SQLException(ex);
}
}
public Tarea recuperarPorId(Connection conexion, int id_tarea) throws
SQLException {
Tarea tarea = null;
try{
PreparedStatement consulta = conexion.prepareStatement("SELECT
titulo, descripcion, nivel_de_prioridad FROM " + this.tabla + " WHERE
id_tarea = ?" );
consulta.setInt(1, id_tarea);
ResultSet resultado = consulta.executeQuery();
while(resultado.next()){
tarea = new Tarea(id_tarea, resultado.getString("titulo"),
resultado.getString("descripcion"),
resultado.getInt("nivel_de_prioridad"));
}
}catch(SQLException ex){
throw new SQLException(ex);
}
return tarea;
}
public void eliminar(Connection conexion, Tarea tarea) throws
SQLException{
try{
PreparedStatement consulta = conexion.prepareStatement("DELETE
FROM " + this.tabla + " WHERE id_tarea = ?");
consulta.setInt(1, tarea.getId_tarea());
consulta.executeUpdate();
}catch(SQLException ex){
throw new SQLException(ex);
}
}
public List<Tarea> recuperarTodas(Connection conexion) throws
SQLException{
List<Tarea> tareas = new ArrayList<>();
try{
PreparedStatement consulta = conexion.prepareStatement("SELECT
id_tarea, titulo, descripcion, nivel_de_prioridad FROM " + this.tabla + "
ORDER BY nivel_de_prioridad");
ResultSet resultado = consulta.executeQuery();
while(resultado.next()){
tareas.add(new Tarea(resultado.getInt("id_tarea"),
resultado.getString("titulo"), resultado.getString("descripcion"),
resultado.getInt("nivel_de_prioridad")));
}
}catch(SQLException ex){
throw new SQLException(ex);
}
return tareas;
}
}
Esta clase cuenta con los métodos capaces de realizar las distintas operaciones
en una tabla.
El método guardar(), que recibirá como parámetro una instancia de conexión
y un objetoTarea. Si el objeto tiene el valor de id nulo, va a hacer un insert,
de lo contrario un updateen el registro con dicho id.
El método recuperarPorId(), recibirá la conexión y un id, y nos devolverá un
objeto Tareacorrespondiente a ese id, de lo contrario nos devolverá un valor
null, en caso de que no encuentre ningún registro con ese id.
El método eliminar() recibirá un una instancia de conexión y el objeto Tarea
que debe eliminar.
Y finalmente recuperarTodas() también recibirá una instancia de conexión y
nos devolverá una lista con todas las tareas.
Bueno a continuación dejo un ejemplo muy sencillo con interfaz gráfica, para
verificar cómo queda.
Saludos!
Instalación del conector J de MySQL en Netbeans 6.9LICENCIA
@include Apache 2 Apache HTTP avi AWT Componentes Conector/J Conector J - MySQL Crystal Report Curso JSP Ejemplo Expresiones PHP FileZilla FTP Server Format HM NIS Edit Hola
Mundo IDE J2EE Java JButton JCheckBox JComboBox JDBC JDK 6 update 11 JDK 6 update 14 JDK 6 update 20 JDK 6 update 20
(Linux) jFrame JLabel JPanel JRadioButton JSP/SERVLETS JTextField JvDBSearchComb
oBox KENAI Linux Mercury Mail Transport System MySQL MySQL 5.1 Netbeans Netbeans 6.5 NetBeans
6.7 NetBeans 6.8 Netbeans 6.9 Netbeans 6.9 (Linux) Netbeans 7.0 NetBenas 6.8 NSIS Palabras
reservadas PHP PHP5 phpMYAdmin POO servlet StringToWideChar StrToCrr StrToDate StrToDateTime StrToInt
StrToInt64 StrToInt64Def StrToIntDef StrToTime Sun
Microsystem swing TButton TComboBox TDBNavigator TEdit TJvDateEdit TPageControl TTabSheet Workbench
XAMPP XDEBUG
BLOGROLL
IES Gonzalo Nazareno
DELPHI
About.com Club delphi Delphi Resource Center Dr.Bob's Delphi Clinic
IDE
Eclipse IDE NetBeans IDE
JAVA
GUJ (Mexico) GUJ (Uruguay) Java Hispano Java User Groups(JUGs) java.net Univ. Navarra – Aprenda Java desde 1º
JSP/SERVLETS
Eclipse + JSP Recursos JSP Univ. Huelva – JSP v2.0 / Servlets v2.4 Univ. Navarra – Aprenda Servlets de Java
PHP
Manual PHP PHP Classes Repository Recursos PHP
PYTHON
Python – Official Website
SGBD
MySQL Oracle Corporation (Java) PostgreSQL
VISITAS:
566,182 hits
META
Registrarse Acceder RSS de las entradas RSS de los comentarios WordPress.com
buscar
6 Votes
En una entrada de los últimos días hemos descargado el conector J para MySQL con la
finalizad de utilizar JDBC (Java Database Connectivity), es decir mysql-connector-java-
5.1.12.zip (3.8 M). En mi caso, he descomprimido el archivo en la carpeta de Netbeans 6.9 y
como resultado de la descompresión se obtenienen una serie de carpetas y archivos.
El más significativo de todos los ficheros se corresponde con la librería denominada mysql-
connector-java-5.1.12-bin.jar. Ahora tenemos que dar de alta a esta librería en el IDE de
Netbeans para poder utilizar las diversas funciones de acceso y manipulación de datos y
metadatos en MySQL.
Para ello, iniciamos una sesión de Netbeans 6.9 y seleccionamos del menú principal
“Herramientas” y “Bibliotecas”, aparecerá
Hacemos click en “Nueva Biblioteca” y
pantalla o cuadro de diálogo en el hemos dado nombre a la biblioteca que vamos a incorporar.
Hemos llamado a esta biblioteca ConectorMySQL, si ahora hacemos “Aceptar”
Ahora con ayuda del botón “Agregar archivo jar/Carpeta” localizamos el archivo previamente
descargado y una vez descomprimido denominado
mysql-connector-java-5.1.12-bin.jar
Para finalizar hacemos click en “Aceptar”.
Para poder incorporar esta librería a un proyecto supongamos que el árbol de
capetas/archivos de un proyecto es tal como el que sigue:
Hacemos botón derecho en el nodo ” Libraries” y aparecerá una caja con tres opciones
Seleccionamos y aparecerá el cuadro de
diálogo
Como vemos la libreria/biblioteca denominada “ConectorMySQL” aparece en la relación de
bibliotecas, pulsamos “Añadir biblioteca” y ésta se incorporará a nuestro proyecto. Si
desplegamos el nodo “Libraries” ahora tendremos la librería incorporada
y ya podemos hacer uso de dicha
librería.
Configuración de MySQL con NetBeans Web Application Development 7CM5 Ortiz Ramírez Diana 26/03/2012 Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 2 Desarrollo. I. Configurar las propiedades del Servidor MySQL. 1. Se asume que se encuentra instalado MySQL, que en este caso se realiza con XAMPP. 2. Abrir el IDE NetBeans. En el repositorio seleccionar la pestaña de Services y digitar clic derecho en Databases > Register MySQL Server para mostrar el cuadro de diálogo de MySQL Server Properties. 3. En la ventana mostrada MySQL Server Properties, la pestaña inicial es Basic Properties. Verificar los datos predeterminados. Por ejemplo, confirmar el nombre del servidor y del puerto. El nombre de usuario y la contraseña se pueden
cambiar, pero se sugiere conservar los valores sugeridos para las pruebas. Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 3 4. En la misma ventana, seleccionar la pestaña Admin Properties. Ingresar o navegar en el administrador del sistema para localizar la ruta de las aplicaciones solicitadas. La ruta puede variar según la plataforma y la instalación particular. II. Inicio del servidor MySQL. Antes de la conexión al servidor de bases de datos MySQL, se debe asegurar que se encuentra activa la ejecución de este servidor. Si no hay conexión, se indicará MySQL Server at localhost: 3306 (not connected). Si la conexión existe se muestra una imagen como la siguiente. Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 4 III. Creación y conexión de la base de datos. 1. Seleccionar con clic derecho en MySQL Server y digitar en Create Database. 2. En la ventana mostrada, ingresar el nombre de la base de datos, por ejemplo mynewdatabase. Clic en OK. 3. Al digitar OK, Se actualiza el repositorio en la pestaña de Services con la base de datos mynewdatabase recién creada. Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 5 IV. Creación de las tablas. 1. Creación de las tablas con el editor SQL. En el repositorio, expandir el árbol de carpetas de la base de datos mynewdatabase y seleccionar mynewdatabase > Tables > Execute Command. a. En la sección central se muestra el área de trabajo SQL Command 1 del editor SQL. Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 6 b. En el editor SQL, se ingresa la siguiente consulta, en la cual se define la creación de la tabla counselor. CREATE TABLE Counselor ( id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT, firstName VARCHAR (50), nickName VARCHAR (50), lastName VARCHAR (50), telephone VARCHAR (25), email VARCHAR (50), memberSince DATE DEFAULT '0000-00-00', PRIMARY KEY (id) ); c. Para ejecutar la instrucción SQL, seleccionar la opción Run SQL o digitar clic derecho en el área de trabajo del editor y seleccionar la opción Run Statement. Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 7 d. En el repositorio se muestra la tabla counselor creada y sus campos predeterminados. En la ventana Output se muestra el mensaje de éxito. Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 8 2. Creación de las tablas en la ventana de diálogo de Create Table. a. En el explorador de la base de datos, seleccionar mynewdatabase > Tables > Create Table. b. En la ventana mostrada, ingresar el nombre de la tabla, por ejemplo subject. Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 9 c. Digitar el botón Add column. En la ventana mostrada ingresar los datos indicados. Clic en OK. Se actualiza el contenido de la ventana anterior. d. Repetir el inciso anterior para generar los campos restantes. e. La tabla debe mostrar una apariencia similar a la siguiente. Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 10 f. Observar la actualización de la tabla en la base de datos. V. Uso de la base de datos. a. En la base datos mynewdatabase se selecciona Tables>Execute Command. Al centro se muestra el editor de comandos SQL. b. Ingresar en el editor SQL la siguiente instrucción. INSERT INTO Counselor VALUES (1, 'Ricky', '"The Dragon"', 'Steamboat','334 612-5678', '[email protected]', '1996-01-01') Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 11 c. Para ejecutar la consulta SQL, clic derecho sobre el editor y seleccionar Run Statement. En la ventana Output se muestra el resultado de éxito. d. Para visualizar los datos de la tabla, seleccionar counselor > View Data. Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 12 e. Los datos de la tabla se muestran en la ventana de ejecución de la consulta. f. Las tablas se pueden borrar, seleccionándolas y digitando en Delete.
Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 13 VI. Ejecución de un script SQL. 1. Ejercicio. a. Borrar las dos tablas counselor y subject, creadas en el desarrollo anterior. b. Crear un archivo script SQL que contenga la estructura de las tablas mencionadas. Guardarlo con el nombre y extensión ifpwafcad.sql. c. Para la ejecución del script SQL, en el menú principal del IDE, seleccionar File > Open File. En la ventana de archivos mostrada, localizar y abrir el archivo script el cual se abrirá automáticamente en el editor SQL. Se debe asegurar que existe conexión con la base de datos mynewdatabase, seleccionando la lista desplegable de Connection. d. Para ejecutar el script, se procede como se indica en el paso IV. e. Una vez ejecutado el script, verificar la construcción de las tablas y la actualización de la base de datos. Configuración de MySQL con NetBeans Ortiz Ramírez Diana 26/03/2012 14 Conclusiones En esta práctica se observo cómo poder conectar netbeans con mysql para poder hacer tablas de forma segura y mejorar el rendimiento de la aplicación de mysql.