jdbc
Creando una conexión de base de datos

Sintaxis

• DB_URL = "jdbc: DBMS: // DB_HOST: DB_PORT / DB_NAME"

• DBMS: Data Base Driver Manager, puede ser cualquier DBMS (mysql, oracle, postgresql, sqlite, ...), ejemplo de mysql: "com.mysql.jdbc.Driver"

• DB_HOST: el host base de su base de datos, la dirección IP de su ejemplo de base de datos: 10.6.0.1, el valor predeterminado es localhost o 127.0.0.1

• DB_PORT: puerto de la base de datos, cada DBMS tiene un puerto de ejemplo eximple mysql = 3306, postegesql = 5432

• DB_NAME: el nombre de tu base de datos

• Para conectarse debe obtener una referencia al objeto de clase,

• Class.forName (DRIVER);

• Y para conectarse a la base de datos, necesita crear una conexión

• java.sql.Connection con = DriverManager.getConnection (DB_URL, DB_USER_NAME, DB_PASSWORD);

• DB_USER_NAME: el nombre de usuario de tu base de datos

• DB_PASSWORD: la contraseña de su base de datos

Introducción (SQL)

Desde Java 6, la forma recomendada de acceder a una base de datos basada en SQL en Java es a través de la API JDBC (Java DataBase Connectivity).

Esta API viene en dos paquetes: java.sql y javax.sql .

JDBC define las interacciones de la base de datos en términos de Connections y Drivers .

Un Driver interactúa con la base de datos y proporciona una interfaz simplificada para abrir y administrar conexiones. La mayoría de las variedades de servidores de base de datos (PostgreSQL, MySQl, etc.) tienen sus propios Drivers , que manejan la configuración, el desmontaje y la traducción específicos de ese servidor. Drivers generalmente no son accedidos directamente; más bien, la interfaz proporcionada por el objeto DriverManager se utiliza en su lugar.

El objeto DriverManager es esencialmente el núcleo de JDBC. Proporciona una interfaz (en su mayoría) independiente de la base de datos para crear Connections . Para versiones anteriores de la API de JDBC, los Drivers específicos de la base de datos tenían que cargarse antes de que DeviceManager pudiera crear una conexión con ese tipo de base de datos.

Una Connection es, como su nombre lo indica, una representación de una conexión abierta a la base de datos. Connections son independientes de la base de datos, y son creadas y proporcionadas por el DriverManager . Proporcionan varios métodos de acceso directo para los tipos de consulta comunes, así como una interfaz de SQL sin formato.

Uso de la conexión (y declaraciones)

Una vez que hayamos obtenido la Connection , la usaremos principalmente para crear objetos de Statement . Statements representan una sola transacción SQL; se utilizan para ejecutar una consulta y recuperar los resultados (si los hay). Veamos algunos ejemplos:

public void useConnection() throws SQLException{


    Connection conn = getConnection();

    //We can use our Connection to create Statements
    Statement state = conn.getStatement();

    //Statements are most useful for static, "one-off" queries
    
    String query = "SELECT * FROM mainTable";
    boolean sucess = state.execute(query);
    
    //The execute method does exactly that; it executes the provided SQL statement, and returns true if the execution provided results (i.e. was a SELECT) and false otherwise.

    ResultSet results = state.getResultSet();
    
    //The ResultSet object represents the results, if any, of an SQL statement.
    //In this case, the ResultSet contains the return value from our query statement.
    //A later example will examine ResultSets in more detail.

    ResultSet newResults = state.executeQuery(query)
    
    //The executeQuery method is a 'shortcut' method. It combines the execute and getResultSet methods into a single step.
    //Note that the provided SQL query must be able to return results; typically, it is a single static SELECT statement.
    //There are a number of similar 'shortcut' methods provided by the Statement interface, including executeUpdate and executeBatch

    //Statements, while useful, are not always the best choice. 
    
    String newQuery = "SELECT * FROM mainTable WHERE id=?";
    PreparedStatement prepStatement = conn.prepareStatement(newQuery);

    //PreparedStatements are the prefed alternative for variable statements, especially ones that are going to be executed multiple times

    for(int id:this.ids){

        prepStatement.setInt(1,id);
        //PreparedStatements allow you to set bind variables with a wide variety of set methods.
        //The first argument to any of the various set methods is the index of the bind variable you want to set. Note that this starts from 1, not 0. 

        ResultSet tempResults = prepStatement.executeQuery()
        //Just like Statements, PreparedStatements have a couple of shortcut methods. 
        //Unlike Statements, PreparedStatements do not not take a query string as an argument to any of their execute methods.
        //The statement that is executed is always the one passed to the Connector.prepareStatement call that created the PreparedStatement
    }

}

Creando una conexión usando java.sql.DriverManager

Para conectarse utilizando java.sql.DriverManager necesita un url de JDBC para conectarse a su base de datos. Las URL de JDBC son específicas de la base de datos, pero todas tienen la forma

jdbc:<subprotocol>:<subname>

Donde <subprotocol> identifica el controlador o la base de datos (por ejemplo, postgresql , mysql , firebirdsql , etc.), y <subname> es específico de subprotocolo.

Debe revisar la documentación de su base de datos y el controlador JDBC para el subprotocolo url específico y el formato para su controlador.

Un ejemplo simple para crear una conexión a una base de datos con la url jdbc:somedb://localhost/foobar :

try (Connection connection = DriverManager.getConnection(
        "jdbc:somedb://localhost/foobar", "anna", "supersecretpassword")) {
    // do something with connection
}

Aquí utilizamos un try-with-resources para que la conexión se cierre automáticamente cuando hayamos terminado con ella, incluso si se producen excepciones.

Connection connection = DriverManager.getConnection(
        "jdbc:somedb://localhost/foobar", "anna", "supersecretpassword");
try {
    // do something with connection
} finally {
    // explicitly close connection
    connection.close();
}

Class.forName("org.example.somedb.jdbc.Driver");

Alternativamente, también puede proporcionar un objeto de Properties para conectarse:

Properties props = new Properties();
props.setProperty("user", "anna");
props.setProperty("password", "supersecretpassword");
// other, database specific, properties
try (Connection connection = DriverManager.getConnection(
        "jdbc:somedb://localhost/foobar", props)) {
    // do something with connection
}

O incluso sin propiedades, por ejemplo, si la base de datos no necesita nombre de usuario y contraseña:

try (Connection connection = DriverManager.getConnection(
        "jdbc:somedb://localhost/foobar")) {
    // do something with connection
}

Creando una conexión a MySQL

Para conectarse a MySQL debe usar el controlador MySQL Connector / J. Puede descargarlo desde http://dev.mysql.com/downloads/connector/j/ o puede usar Maven:

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.39</version>
</dependency>

La URL básica de JDBC para MySQL es:

jdbc:mysql://<hostname>[:<port>]/<database>[?<propertyName>=<propertyValue>[&<propertyName>=<propertyValue>]...]

Dónde:

La URL admitida es más compleja de lo que se muestra arriba, pero esto es suficiente para la mayoría de las necesidades "normales".

Para conectar el uso:

try (Connection connection = DriverManager.getConnection(
        "jdbc:mysql://localhost/foobardb", "peter", "nicepassword")) {
    // do something with connection
}

// Load the MySQL Connector/J driver
Class.forName("com.mysql.jdbc.Driver");

Connection connection = DriverManager.getConnection(
        "jdbc:mysql://localhost/foobardb", "peter", "nicepassword");
try {
    // do something with connection
} finally {
  // explicitly close connection
  connection.close();
}

Conexión a una base de datos de Microsoft Access con UCanAccess

UCanAccess es un controlador Java JDBC puro que nos permite leer y escribir en bases de datos de Access sin usar ODBC . Utiliza otros dos paquetes, Jackcess y HSQLDB , para realizar estas tareas.

Una vez que se ha configurado ^* , podemos trabajar con datos en archivos .accdb y .mdb usando un código como este:

import java.sql.*;

Connection conn=DriverManager.getConnection("jdbc:ucanaccess://C:/__tmp/test/zzz.accdb");
Statement s = conn.createStatement();
ResultSet rs = s.executeQuery("SELECT [LastName] FROM [Clients]");
while (rs.next()) {
    System.out.println(rs.getString(1));
}

^* Para más detalles vea la siguiente pregunta:

Manipulando una base de datos de Access desde Java sin ODBC

Conexión JDBC de Oracle

Conductor:

• 12c R1
• 11g R2

( Nota: el controlador no está incluido en Maven Central!)

Inicialización de clase de controlador:

    Class.forName("oracle.jdbc.driver.OracleDriver");

URL de conexión

Formato anterior, con SID

"jdbc:oracle:thin:@<hostname>:<port>:<SID>"

Formato más nuevo, con nombre de servicio

"jdbc:oracle:thin:@//<hostname>:<port>/<servicename>"

Tnsnames como entrada

"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS)(HOST=<hostname>)(PORT=<port>))"
    +"(CONNECT_DATA=(SERVICE_NAME=<servicename>)))"

Cadena de conexión del cluster RAC para failover

"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS_LIST=(LOAD_BALANCE=OFF)(FAILOVER=ON)"
    +"(ADDRESS=(PROTOCOL=TCP)(HOST=<hostname1>)(PORT=<port1>))"
    +"(ADDRESS=(PROTOCOL=TCP)(HOST=<hostname2>)(PORT=<port2>)))"
    +"(CONNECT_DATA=SERVICE_NAME=<servicename>)(SERVER=DEDICATED)))"

Ejemplo

connection = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "HR", "HRPASS");