Código Fuente: Ejemplo JDBC - CRUD con MySQL

Antes que nada, es necesario tener instalado Eclipse, MySQL y Workbench. Acá dejo el enlace para instalarlo en el ambiente Linux distribución Ubuntu.

https://platzi.com/java-basico/tutoriales/instalar-mysql-y-workbench-en-linux-ubuntu-1404/

Posterior a esto, iniciamos MySQL Workbench, luego creamos una base de datos llamada “platzi_java” con la codificación utf8_general_ci.

También es posible crear nuestra base de datos o tablas a través de sentencias SQL.

Ya con esto podremos ejecutar la siguiente sentencia SQL

CREATE SCHEMA `platzi_java` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

CREATE TABLE `platzi_java`.`tipo_conductor` (
  `id` INT NOT NULL,
  `nombre` VARCHAR(255) NULL,
  PRIMARY KEY (`id`));

CREATE TABLE `platzi_java`.`tipo_vehiculo` (
  `id` INT NOT NULL,
  `nombre` VARCHAR(255) NULL,
  PRIMARY KEY (`id`));

CREATE TABLE `platzi_java`.`vehiculo` (
  `id` INT NOT NULL AUTO_INCREMENT,
  `marca` VARCHAR(255) NOT NULL,
  `modelo` VARCHAR(255) NOT NULL,
  `matricula` VARCHAR(255) NULL,
  `anio` INT NULL,
  `id_tipo_vehiculo` INT,
  PRIMARY KEY (`id`),
  CONSTRAINT `fk_vehiculo_tipo_vehiculo`
    FOREIGN KEY (`id_tipo_vehiculo`)
    REFERENCES `platzi_java`.`tipo_vehiculo` (`id`));

CREATE TABLE `platzi_java`.`conductor` (
  `id` INT NOT NULL AUTO_INCREMENT,
  `nombre` VARCHAR(255) NOT NULL,
  `tipo_licencia` VARCHAR(255) NOT NULL,
  `id_vehiculo` INT,
  `id_tipo_conductor` INT,
  PRIMARY KEY (`id`),
  CONSTRAINT `fk_conductor_vehiculo`
    FOREIGN KEY (`id_vehiculo`)
    REFERENCES `platzi_java`.`vehiculo` (`id`),
  CONSTRAINT `fk_conductor_tipo_conductor`
    FOREIGN KEY (`id_tipo_conductor`)
    REFERENCES `platzi_java`.`tipo_conductor` (`id`));

CREATE TABLE `platzi_java`.`contrato` (
  `id` INT NOT NULL AUTO_INCREMENT,
  `id_vehiculo` INT,
  `id_conductor` INT,
  PRIMARY KEY (`id`),
  CONSTRAINT `fk_contrato_vehiculo`
    FOREIGN KEY (`id_vehiculo`)
    REFERENCES `platzi_java`.`vehiculo` (`id`),
  CONSTRAINT `fk_contrato_conductor`
    FOREIGN KEY (`id_conductor`)
    REFERENCES `platzi_java`.`conductor` (`id`));

CREATE TABLE `platzi_java`.`ruta` (
  `id` INT NOT NULL AUTO_INCREMENT,
  `estacion` VARCHAR(255) NOT NULL,
  `id_vehiculo` INT,
  PRIMARY KEY (`id`),
  CONSTRAINT `fk_ruta_vehiculo`
    FOREIGN KEY (`id_vehiculo`)
    REFERENCES `platzi_java`.`vehiculo` (`id`));

INSERT INTO `platzi_java`.`tipo_vehiculo`(`id`,`nombre`) VALUES (1, "Taxi");
INSERT INTO `platzi_java`.`tipo_vehiculo`(`id`,`nombre`) VALUES (2, "Bus");

Después de esto creamos un usuario llamado “platzijava” con la contraseña “Platzi2016” con todos los privilegios en localhost.

Al ejecutar el query SQL podremos visualizar que se hayan creado correctamente nuestras tablas con los respectivos campos.

Ya para empezar a trabajar en nuestro proyecto, el primer paso es descargar el driver (JAR) que permite la conexión al motor de base de datos de MySQL en la siguiente página:

https://mvnrepository.com/artifact/mysql/mysql-connector-java/5.1.22

Al momento de descargar el JAR creamos una carpeta nueva en nuestro proyecto llamada “lib” y colocamos el archivo en este lugar.

Después nos dirigimos a las propiedades del proyecto, hacemos clic en “Add JARs…”, seleccionamos el archivo de la carpeta lib, visualizamos que se haya añadido correctamente y damos clic en “OK”.

Ya siguiente es la información principal de nuestras clases y su distribución:

Vehiculo.java

package com.revol.vehiculo;

publicclassVehiculo{
    /* Variables */
    privateint id;
    private String marca;
    private String modelo;
    private String matricula;
    privateint anio;

    /* Constructores */
    publicVehiculo(String marca, String modelo, String matricula, int anio){
        super();
        this.marca = marca;
        this.modelo = modelo;
        this.matricula = matricula;
        this.anio = anio;
    }

    /* Getters y Setters */
    publicintgetId(){
        return id;
    }

    publicvoidsetId(int id){
        this.id = id;
    }

    public String getMarca(){
        return marca;
    }

    publicvoidsetMarca(String marca){
        this.marca = marca;
    }

    public String getModelo(){
        return modelo;
    }

    publicvoidsetModelo(String modelo){
        this.modelo = modelo;
    }

    public String getMatricula(){
        return matricula;
    }

    publicvoidsetMatricula(String matricula){
        this.matricula = matricula;
    }

    publicintgetAnio(){
        return anio;
    }

    publicvoidsetAnio(int anio){
        this.anio = anio;
    }
}

Taxi.java

package com.revol.vehiculo;

public classTaxiextendsVehiculo{
    /* Constructores */
    public Taxi(String marca, String modelo, String matricula, int anio) {
        super(marca, modelo, matricula, anio);
    }
}

Bus.java

package com.revol.vehiculo;

import java.util.ArrayList;

publicclassBusextendsVehiculo{
    /* Variables */
    private ArrayList estaciones;

    /* Constructores */
    publicBus(String marca, String modelo, String matricula, int anio){
        super(marca, modelo, matricula, anio);
    }

    /* Getters y Setters */
    public ArrayList getEstaciones(){
        return estaciones;
    }

    publicvoidsetEstaciones(ArrayList estaciones){
        this.estaciones = estaciones;
    }
}

Taxi_CRUD.java

package com.revol.vehiculo;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import com.revol.basededatos.BaseDeDatos;

public class Taxi_CRUD {
    private final int tipo_vehiculo = 1; // 1: Taxi, Tabla: tipo_vehiculo

    public void agregar(Taxi taxi) throws SQLException {
        String query = "";
        BaseDeDatos bd = new BaseDeDatos();
        Statement sentencia = bd.conectar().createStatement();

        query = "INSERT INTO vehiculo(marca, " + "modelo, " + "matricula, " + "anio, "
                + "id_tipo_vehiculo" + ") VALUES ('" + taxi.getMarca() + "', " + "'" + taxi.getModelo()
                + "', " + "'" + taxi.getMatricula() + "', " + taxi.getAnio() + ", " + tipo_vehiculo + ");";

        if (sentencia.executeUpdate(query) > 0) {
            System.out.println("El registro se insertó exitosamente.");
        } else {
            System.out.println("No se pudo insertar el registro.");
        }

        System.out.println(query);
        sentencia.close();
        bd.conexion.close();
    }

    public void editar_modelo(Taxi taxi, String modelo) {
        String query = "";
        BaseDeDatos bd = new BaseDeDatos();
        try {
            query = "UPDATE vehiculo SET modelo = ? WHERE matricula = ?;";
            PreparedStatement sentenciaP = bd.conectar().prepareStatement(query);
            sentenciaP.setString(1, modelo);
            sentenciaP.setString(2, taxi.getMatricula());

            sentenciaP.executeUpdate();
            System.out.println("El registro se actualizó exitosamente.");
            sentenciaP.close();
            bd.conexion.close();
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }

    public void eliminar(Taxi taxi) {
        String query = "";
        BaseDeDatos bd = new BaseDeDatos();
        try {
            query = "DELETE FROM vehiculo WHERE matricula = ?;";
            PreparedStatement sentenciaP = bd.conectar().prepareStatement(query);
            sentenciaP.setString(1, taxi.getMatricula());

            sentenciaP.execute();
            System.out.println("El registro se eliminó exitosamente.");
            sentenciaP.close();
            bd.conexion.close();
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }

    public void obtener(Taxi taxi) {
        String query = "";
        BaseDeDatos bd = new BaseDeDatos();
        try {
            query = "SELECT * FROM vehiculo WHERE matricula = '" + taxi.getMatricula() + "';";
            Statement sentencia = bd.conectar().createStatement();
            ResultSet resultado = sentencia.executeQuery(query);

            while (resultado.next()) {
                int id = resultado.getInt("id");
                String marca = resultado.getString("marca");
                String modelo = resultado.getString("modelo");
                String matricula = resultado.getString("matricula");
                int anio = resultado.getInt("anio");
                int tipoVehiculo = resultado.getInt("id_tipo_vehiculo");

                // Imprimir los resultados.
                System.out.format("%d, %s, %s, %s, %d, %d\n", id, marca, modelo, matricula, anio, tipoVehiculo);
            }

            sentencia.close();
            bd.conexion.close();
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
}

Conductor.java

package com.revol.conductor;

publicclassConductor{
    /* Variables */
    privateint id;
    private String nombre;
    private String tipoLicencia;

    /* Constructores */
    publicConductor(String nombre, String tipoLicencia){
        super();
        this.nombre = nombre;
        this.tipoLicencia = tipoLicencia;
    }

    /* Getters y Setters */
    publicintgetId(){
        return id;
    }

    publicvoidsetId(int id){
        this.id = id;
    }

    public String getNombre(){
        return nombre;
    }

    publicvoidsetNombre(String nombre){
        this.nombre = nombre;
    }

    public String getTipoLicencia(){
        return tipoLicencia;
    }

    publicvoidsetTipoLicencia(String tipoLicencia){
        this.tipoLicencia = tipoLicencia;
    }

    /* Sobrecarda de métodos (Polimorfismo) */
    publicvoidmostrarVehiculo(){
        System.out.println("Datos Vehiculo");
    }
}

Taxista.java

package com.revol.conductor;

import com.revol.vehiculo.Taxi;

publicclassTaxistaextendsConductor{
    /* Variables */
    privateint id;
    privatestaticint idContador = 1;
    private Taxi taxi;

    /* Constructores */
    publicTaxista(String nombre, String tipoLicencia, Taxi taxi){
        super(nombre, tipoLicencia);
        this.taxi = taxi;
        this.id = idContador;
        idContador++;
        // System.out.println(this.id);
    }

    /* Getters y Setters */
    publicintgetId(){
        return id;
    }

    publicvoidsetId(int id){
        this.id = id;
    }

    public Taxi getTaxi(){
        return taxi;
    }

    publicvoidsetTaxi(Taxi taxi){
        this.taxi = taxi;
    }

    /* Sobrecarda de métodos (Polimorfismo) */
    @Override
    publicvoidmostrarVehiculo(){
        super.mostrarVehiculo();
        System.out.println("Datos del Taxi: " + getTaxi().getMarca() + " " + getTaxi().getModelo());
    }
}

ChoferBus.java

package com.revol.conductor;

import com.revol.vehiculo.Bus;

publicclassChoferBusextendsConductor{
    /* Variables */
    private Bus bus;

    /* Constructores */
    publicChoferBus(String nombre, String tipoLicencia, Bus bus){
        super(nombre, tipoLicencia);
        this.bus = bus;
    }

    /* Getters y Setters */
    public Bus getBus(){
        return bus;
    }

    publicvoidsetBus(Bus bus){
        this.bus = bus;
    }

    /* Sobrecarda de métodos (Polimorfismo) */
    @Override
    publicvoidmostrarVehiculo(){
        super.mostrarVehiculo();
        System.out.println("Datos del Bus: " + getBus().getMarca() + " " + getBus().getModelo());
    }
}

BasesDeDatos.java

package com.revol.basededatos;

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

public class BaseDeDatos {
    privatefinalString URL = "jdbc:mysql://localhost:3306/"; // Ubicación de la BD.
    privatefinalString BD = "platzi_java"; // Nombre de la BD.
    privatefinalString USER = "platzijava";
    privatefinalString PASSWORD = "Platzi2016";

    public Connection conexion = null;

    @SuppressWarnings("finally")
    public Connection conectar() throws SQLException {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conexion = DriverManager.getConnection(URL + BD, USER, PASSWORD);
            if (conexion != null) {
                System.out.println("¡Conexión Exitosa!");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            return conexion;
        }
    }
}

Principal.java

package com.revol.sistematransporte;

import java.sql.SQLException;

import com.revol.vehiculo.Taxi;
import com.revol.vehiculo.Taxi_CRUD;

public class Principal {
    public static void main(String args[]) throws SQLException {
        Taxi tx = new Taxi("Chevrolet", "Spark", "TQR876", 2016);
        Taxi_CRUD tx_crud = new Taxi_CRUD();
        tx_crud.agregar(tx);
        tx_crud.eliminar(tx);
        tx_crud.agregar(tx);
        tx_crud.editar_modelo(tx, "Aveo");
        tx_crud.obtener(tx);
    }
}

Resultado:

Listo! Con este ejemplo queda detallado cómo es la conexión a base de datos para manipular su información a través de código Java (JDBC) con un simple CRUD (Create, Read, Update, Delete).