Upload
matias-carrasco-flores
View
229
Download
7
Embed Size (px)
Citation preview
Base de Datos + Netbeans + MySQL
Fuente: JCMouse
Modificado: Ing. Hernán Medina
Nuestro proyecto de Base de Datos se llamará "DBContactos", el código contiene las funciones básicas que debe tener
un proyecto de Base de Datos, añade nuevos registros, los elimina y también puede modificar esos registros.
Esta compuesto de los siguientes capitulos.
1. Mysql: creación de base de datos y tabla 2. Clase conexion Base de Datos 3. Probando la clase "conectate.java" 4. Sentencias SQL en netbeans 5. Leer base de datos en Netbeans 6. Borrar/delete registros de la base de datos en Netbeans 7. Actualizar / Update registros de la base de datos en Netbeans 8. Parte Gráfica - SWING
Parte 1 : Mysql: creación de base de datos y tabla
1. CREA UNA BASE DE DATOS CON NOMBRE "dbcontactos"
2. Crear la tabla persona:
a. Seleccionar la conexión “dbcontactos”
b. Boton derecho sobre tabla y elegir “Execute Command”
c. En la venta de comandos que se abre, digitar lo siguiente:
create table persona( id bigint(10) NOT NULL auto_increment, Nombre varchar(32) not null, appPaterno varchar(32) not null, appMaterno varchar(32), mail varchar(32) default '@hotmail.com', PRIMARY KEY (ID) );
d. Ejecutar presionando el botón
3. Insertar datos en la tabla. Ejecutar los siguientes querys:
insert into persona(Nombre, appPaterno, appMaterno, mail) values("Anita","Quiere","Problemas","[email protected]"); insert into persona(Nombre, appPaterno, appMaterno, mail) values("Pablito","Saco","Unclavito","[email protected]"); insert into persona(Nombre, appPaterno, appMaterno, mail) values("Paola","Nomequire","Hablar","[email protected]"); insert into persona(Nombre, appPaterno, appMaterno, mail)
values("Mirtha","Hornea","Pasteles","[email protected]"); insert into persona(Nombre, appPaterno, appMaterno, mail) values("Luis","Mamani","Mamani","[email protected]"); insert into persona(Nombre, appPaterno, appMaterno, mail) values("Hilarion","Daza","McDonald","[email protected]"); insert into persona(Nombre, appPaterno, appMaterno, mail) values("Juan Carlos","Quinata","yQue","[email protected]"); insert into persona(Nombre, appPaterno, appMaterno, mail) values("Yamevoy","Aburriendo","","[email protected]"); insert into persona(Nombre, appPaterno, appMaterno, mail) values("Ysigo","Escribiendo","Summadre","[email protected]"); insert into persona(Nombre, appPaterno, appMaterno, mail) values("Ultimo","seran","Primeros","[email protected]");
Parte 2: Clase Conexion a Base de Datos
Cuando se trabaja con base de datos en java, lo mejor para tener un trabajo controlado, limpio y que sea fácil de
mantener, es hacer uso de una clase exclusiva para la conexión.
Esta "clase java" se llama "conectate.java", y el uso es bastante sencillo. Si trabajas con mysql, lo unico que debes
modificar es el "paquete" donde lo usaras, el nombre de la base de datos, usuario y password
package PAQUETE_QUE_USARA_ESTA_CLASE ; import java.sql.*; public class conectate { static String bd = "NOMBRE_BASE_DE_DATOS"; static String login = "USUARIO"; static String password = "PASSWORD"; static String url = "jdbc:mysql://localhost/"+bd; Connection conn = null; public conectate() { try{ Class.forName("com.mysql.jdbc.Driver"); conn = DriverManager.getConnection(url,login,password); if (conn!=null){ System.out.println("Conección a base de datos "+bd+". listo"); } }catch(SQLException e){ System.out.println(e); }catch(ClassNotFoundException e){ System.out.println(e); } } public Connection getConnection(){ return conn; } public void desconectar(){ conn = null; } }
Parte 3: Probando la clase "conectate.java"
1. Crear un proyecto en NetBeans, llamado DBContactos. Marcar la casilla “Create main class”
2. Agregar el archivo “conectate.java” (pueden hacer drag & drop desde el explorador de Windows)
3. Modificar los siguientes datos:
package PAQUETE_QUE_USARA_ESTA_CLASE ; dbcontactos import java.sql.*; public class conectate { static String bd = "NOMBRE_BASE_DE_DATOS"; dbcontactos static String login = "USUARIO"; static String password = "PASSWORD"; static String url = "jdbc:mysql://localhost/"+bd;
4. Crear una clase llamada “Persona.java”. En esta clase colocar el siguiente código:
package dbcontactos;
public class Persona {
conectate con;
public Persona (){
con = new conectate();
}
}
5. Editar la clase llamada “DBcontactos.java. Dentro del método main colocar el siguiente código:
package dbcontactos;
public class Main {
public static void main(String[] args) {
Persona p = new Persona ();
p.con.desconectar();
}
}
6. Explicación: se crea un objeto “p” de la clase Persona. El constructor de la clase Persona ejecutará la
conexión.
7. Agregar la librería de clases de mysql:
a. En el proyecto, seleccionar la carpera “Libraries”, botón derecho, add Library
b. En la ventana que aparece, seleccionar “MySql JDBC Driver”. Presionar “Add Library”
c. Debe quedar así:
8. Ejecutar el proyecto.
Parte 4: Sentencia SQL en netbeans
1. Modificaremos la clase "Persona.java" , agregar el método “nuevaPersona”
package dbcontactos;
import java.sql.*;
public class Persona {
conectate con;
public Persona (){
con = new conectate();
}
/*Añade un nuevo registro*/
public void nuevaPersona(String name, String ap, String am, String mail){
try {
String sSql = "INSERT INTO " +
"persona(Nombre, appPaterno, appMaterno, mail) " +
" VALUES(?,?,?,?)";
PreparedStatement pstm = con.getConnection().prepareStatement(sSql);
pstm.setString(1, name);
pstm.setString(2, ap);
pstm.setString(3, am);
pstm.setString(4, mail);
pstm.execute();
pstm.close();
}catch(SQLException e){
System.out.println(e);
}
}
}
2. Añadir nuevo código al método main:
public class Main {
public static void main(String[] args) {
Persona p = new Persona();
p.nuevaPersona("Fulanito", "Menganito", "Zutanito", "[email protected]");
p.con.desconectar();
}
}
3. Se ejecuta el proyecto y tenemos el nuevo registro añadido en nuestra tabla:
5. Leer base de datos en Netbeans
1. Utilizaremos la sentencia SQL SELECT
2. Modificar la clase “Persona.java” y añadir el método “getDatos()”:
/*obtenemos todos los datos de la tabla*/
public Object [][] getDatos(){
String sSql;
int registros = 0;
//obtenemos la cantidad de registros existentes en la tabla
try{
sSql = "SELECT count(1) as total FROM persona ";
PreparedStatement pstm = con.getConnection().prepareStatement(sSql);
ResultSet res = pstm.executeQuery();
res.next();
registros = res.getInt("total");
res.close();
}catch(SQLException e){
System.out.println(e);
}
String estCodigo;
String estNombre;
Object[][] s = new String[x][2];
//realizamos la consulta sql y llenamos los datos en "Object"
try{
sSql = "SELECT id, Nombre FROM persona ORDER BY id ";
PreparedStatement pstm = con.getConnection().prepareStatement(sSql);
ResultSet res = pstm.executeQuery();
int i = 0;
while(res.next()){
estCodigo = res.getString("id");
estNombre = res.getString("nombre");
s[i][0] = estCodigo;
s[i][1] = estNombre;
i++;
}
res.close();
}catch(SQLException e){
System.out.println(e);
}
return s;
}
3. Explicación: La nueva funcion GetDatos() esta definida como Object [][], tambien podemos definirla
como String[][], la funcion esta dividida en dos partes, la primera encargada de realizar una consulta para conocer
el numero de registros existentes y gurdarla en la variable "registros", la segunda parte de la funcion utilizando la
variable "registros" crea un objeto con esas dimensiones y realiza la consulta para extraer los datos y colocarlas en
la variable "data[][]" que es la que retorna
4. Modificar el método main, debe quedar así:
public static void main(String[] args) {
Persona p = new Persona();
Object [][] sc ;
sc = p.getDatos();
for(int i=0;i<sc.length ;i++){
System.out.println("> " + sc[i][0] + " - " + sc[i][1]);
}
p.con.desconectar();
}
5. Ejecutar el programa:
6. Borrar/delete registros de la base de datos en Netbeans
1. Para poder eliminar un registro de la base de datos realizaremos una instruccion SQL con el comando DELETE, para ello
debemos tener muy en cuenta la estructura de nuestra tabla "Persona".
2. En la clase persona.java, añadiremos el nuevo método deletePersona(), dentro la cual colocaremos la instrucción SQL,
ejecutaremos la sentencia y cerramos.
public void deletePersona(String cod){
String sSql = "DELETE FROM persona where id = ?";
try {
PreparedStatement pstm = con.getConnection().prepareStatement(sSql);
pstm.setString(1, cod);
pstm.execute();
pstm.close();
}catch(SQLException e){
System.out.println(e);
}
}
3. El método main de la clase DBContactos.java quedará así:
public static void main(String[] args) {
Persona p = new Persona();
Object [][] sc ;
//Borra registro de la tabla persona, id = 1
p.deletePersona("1");
//Muestra tabla persona
sc = p.getDatos();
for(int i=0;i<sc.length ;i++){
System.out.println("> " + sc[i][0] + " - " + sc[i][1]);
}
p.con.desconectar();
}
4. Ejecutar el proyecto. Como se observa, ha sido eliminado el registro con id = 1
7. Actualizar / Update registros de la base de datos en Netbeans
1. Una última funcionalidad es poder "modificar" los datos leídos de la base de datos, para después poder guardar esos
cambios, para ello:
2. Modificamos la clase Persona.java y agregamos el siguiente método:
public void updatePersona(String id, String name, String paterno, String materno, String mail){
String sSql = "UPDATE persona " +
"SET Nombre = ? ," +
"appPaterno = ? ," +
"appMaterno = ? ," +
"mail = ? " +
"WHERE id = ? ";
try {
PreparedStatement pstm = con.getConnection().prepareStatement(sSql);
pstm.setString(1, name);
pstm.setString(2, paterno);
pstm.setString(3, materno);
pstm.setString(4, mail);
pstm.setString(5, String.valueOf(id));
pstm.execute();
pstm.close();
} catch(SQLException e){
System.out.println(e);
}
}
3. Explicación: este nuevo método, recibe como parámetros el "id" código del registro que se modificara, además
de los datos necesarios para realizar la consulta, como el nombre, apellido paterno , materno y el mail de la
persona. Luego se realiza una consulta SQL pasando esos datos.
4. Modificar el método main, para actualizar registros:
public static void main(String[] args) {
Persona p = new Persona();
Object [][] sc ;
//Borrar registros de la tabla persona, id=1
//p.deletePersona("1");
//actualizar registros
p.updatePersona("2", "Periquito", "Los Palotes", "No tiene", "[email protected]");
//Muestra tabla persona
sc = p.getDatos();
for(int i=0;i<sc.length ;i++){
System.out.println("> " + sc[i][0] + " - " + sc[i][1]);
}
p.con.desconectar();
}
5. Ejecutar el proyecto: se ha modificado el nombre del id=2
8. Parte Gráfica - SWING
1. Crea un jFrame "ContactosForma" y coloca los siguientes controles, renómbralos como se ve en la imagen
de abajo. ¡cuidado con las mayúsculas y minúsculas!
2. Vamos a la pestaña source e ingresamos lo siguiente: (en la parte superior)
public class ContactosForma extends javax.swing.JFrame {
Persona p= new Persona();
Object[][] dtPer;
int fila = -1;
3. Añade estos dos métodos, el primero actualizaTabla(), actualiza el objeto tblPersona cada vez que se lo
invoca, el método limpia(), su función es la de limpiar los jTextFields para añadir nuevos datos.
private void actualizaTabla(){
String[] columNames = {"id","Nombre","ap. Paterno","ap. Materno", "E-Mail"};
// se utiliza la funcion
dtPer = p.getDatos();
// se colocan los datos en la tabla
DefaultTableModel datos = new DefaultTableModel(dtPer,columNames);
tblPersona.setModel(datos);
}
private void limpia(){
txtNombre.setText("");
txtPaterno.setText("");
txtMaterno.setText("");
txtEMail.setText("tu_correo@hotmail");
}
4. Desde el constructor llamar a los métodos actualizaTabla() y limpia():
public ContactosForma() {
initComponents();
actualizaTabla();
limpia();
}
5. Agregar el evento ActionPerformed al objeto btnLimpiar:
private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) {
limpia();
}
6. Agregar el evento ActionPerformed al objeto btnNuevo:
private void btnNuevoActionPerformed(java.awt.event.ActionEvent evt) {
String nombre = txtNombre.getText();
String paterno = txtPaterno.getText();
String materno = txtMaterno.getText();
String email = txtEMail.getText();
p.nuevaPersona(nombre, paterno, materno, email);
actualizaTabla();
}
7. Agregar el evento MouseClicked al objeto tblPersona:
private void tblPersonaMouseClicked(java.awt.event.MouseEvent evt) {
fila = tblPersona.rowAtPoint(evt.getPoint());
if (fila > -1){
txtNombre.setText(String.valueOf(tblPersona.getValueAt(fila, 1)));
txtPaterno.setText(String.valueOf(tblPersona.getValueAt(fila, 2)));
txtMaterno.setText(String.valueOf(tblPersona.getValueAt(fila, 3)));
txtEMail.setText(String.valueOf(tblPersona.getValueAt(fila, 4)));
}
}
8. Modificar el método main, de manera que solo quede el siguiente código:
public static void main(String[] args) {
ContactosForma cf = new ContactosForma();
cf.setVisible(true);
}
9. Modificar el método getDatos(), para que capture todos los datos de la consulta, de manera que quede de la
siguiente forma:
public Object [][] getDatos(){
String sSql;
int registros = 0;
//obtenemos la cantidad de registros existentes en la tabla
try{
sSql = "SELECT count(1) as total FROM persona ";
PreparedStatement pstm = con.getConnection().prepareStatement(sSql);
ResultSet res = pstm.executeQuery();
res.next();
registros = res.getInt("total");
res.close();
}catch(SQLException e){
System.out.println(e);
}
String estCodigo;
String estNombre;
String estPaterno;
String estMaterno;
String estMail;
Object[][] data = new String[registros][5];
//realizamos la consulta sql y llenamos los datos en "Object"
try{
sSql = "SELECT " +
" id, Nombre, appPaterno, appMaterno, mail " +
" FROM persona" +
" ORDER BY id ";
PreparedStatement pstm = con.getConnection().prepareStatement(sSql);
ResultSet res = pstm.executeQuery();
int i = 0;
while(res.next()){
estCodigo = res.getString("id");
estNombre = res.getString("nombre");
estPaterno = res.getString("appPaterno");
estMaterno = res.getString("appMaterno");
estMail = res.getString("mail");
data[i][0] = estCodigo;
data[i][1] = estNombre;
data[i][2] = estPaterno;
data[i][3] = estMaterno;
data[i][4] = estMail;
i++;
}
res.close();
}catch(SQLException e){
System.out.println(e);
}
return data;
}
10. Compilar y ejecutar el proyecto.
Boton Eliminar Registro
11. Agregar el jButton “Eliminar”, la interfaz deberá quedar así:
12. Para poder eliminar un registro de la base de datos, utilizaremos el método deletePersona(), ya creado
anteriormente.
13. Al boton que creamos "btnEliminar", le añadimos el evento ActionPerformded, copias el siguiente codigo.
private void btnEliminarActionPerformed(java.awt.event.ActionEvent evt) {
if (fila > -1){
String codigo = String.valueOf(tblPersona.getValueAt(fila, 0));
p.deletePersona(codigo);
actualizaTabla();
fila=-1;
}
}
14. Explicación: Este código lo que hace es revisar si la variable "fila" contiene un valor diferente a "-1",esto
sucede cuando se realiza un clic sobre el objeto "tblPersona", si esto es cierto, quiere decir que tenemos una
fila seleccionada, por lo tanto procederá a extraer el código correspondiente y con este código hara un
llamado a deletePersona(codigo), elimina el registro y reinicia el valor de fila a -1 para evitar inconvenientes.
Boton Actualizar registro
15. Añadimos un nuevo botón: btnActualizar, nuestra pantalla quedará así:
16. Para poder actualizar un registro de la base de datos, utilizaremos el método updatePersona(), ya creado
anteriormente.
17. Explicacion: Este nuevo método, recibe como parámetros el "id" código del registro que se modificara,
además de los datos necesarios para realizar la consulta, como el nombre, apellido paterno , materno y el
mail de la persona. Luego se realiza una consulta SQL pasando esos datos
18. En la ventana gráfica, al botón btnActualizar, le agregamos el siguiente evento:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
if (fila > -1){
String codigo = String.valueOf(tblPersona.getValueAt(fila, 0));
String name = txtNombre.getText();
String pat = txtPaterno.getText();
String mat = txtMaterno.getText();
String mail = txtEMail.getText();
p.updatePersona(codigo, name, pat, mat, mail);
actualizaTabla();
}
}
19. Lo único que hace es capturar los datos del JTable, asignarlas a variables y llamar al método actualizaTabla ().