El siguiente objetivo es conectarse a la base de datos, para lo cual básicamente hay que realizar dos pasos:

1. Registrar (cargar en memoria) el controlador. Esto se puede hacer de dos formas:
   
   
   • De forma dinámica, por medio del método Class.forName( String de driver ). Esta es la forma más usual y la que usaremos en la mayor parte de los ejemplos.

     Ejemplos de carga dinámica:

     • En MySQL local: Class.forName("com.mysql.jdbc.Driver");
     • En Oracle: Class.forName("oracle.jdbc.Driver.OracleDriver");
     
     
     
   • De manera estática, usando System.setProperties("jdbc.drivers", String de driver).
   
   
   
2. Establecer la conexión por medio del método DriverManager.getConnection( String de la URL de base de datos, String de login, String de password ). Este método es static, por ello no necesitaremos instanciar un objeto de tipo DriverManager para hacer la llamada.

   La conexión usa una sintaxis semejante a la de una URL. La sintaxis de la URL (los corchetes indican elementos opcionales) es la siguiente:

   
   	jdbc:Controlador://[host][,failoverhost...][:port]/[database][?propertyName1][=propertyValue1][&propertyName2][=propertyValue2]...
     

   Notas a la sintaxis de la URL:

   • Controlador: controlador de base de datos, en nuestro ejemplo es mysql.
   • Host: servidor de base de datos (por defecto es localhost).
   • Failoverhost: servidor de respaldo, en caso de que falle el primero
   • Port: si no se indica puerto, se toma el valor por defecto. En el caso de MySQL es 3306.
   • Database:nombre de la base de datos. Si no se indica base de datos, asume la base de datos actual. Por medio del método setCatalog de la clase Connection se puede determinar la base de datos actual.
   • Una curiosidad para los que vayan a aprender a crear servlets: los símbolos '?', '=' y '&' tienen la misma función que en las llamadas de tipo GET a los servlets, respectivamente: la interrogación señala que a continuación tenemos la primera propiedad (propertyName1), el 'igual' separa el nombre de la propiedad de su valor (propertyValue) y, por último, el '&' antecede a las siguientes propiedades.

   Ejemplos de conexión:

   • En MySQL local: Connection con = DriverManager.getConnection( "jdbc:mysql://localhost/prueba", "log", "pwd" );
   • En Oracle: Connection con = DriverManager.getConnection( "jdbc:oracle:thin:servidor:1521:prueba", "log", "pwd" );

A continuación el primer ejemplo (es una sencilla aplicación en modo texto) con registro dinámico del controlador (driver) y la conexión mediante DriverManager.getConnection, en la llamada a este método el segundo y tercer argumento son el login y el password. Contiene comentarios detallados:

	package jdbc01;

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

	public class jdbc01_conexion2 {
		public static void main(String[] args) {
			try {

				/**** Cargamos el driver ****/
				Class.forName("com.mysql.jdbc.Driver");

				/**** Realizamos la conexión ****/
				Connection con = DriverManager.getConnection( "jdbc:mysql://localhost/prueba", "root", "palabra" );

				/**** Ok: avisamos ****/
				System.out.println( "Si he llegado hasta aquí es que se ha producido la conexión");
				System.out.println( "Si no se hubiera producido, se habría disparado SQLException");

				/**** Una buena costumbre: cerramos la conexión ****/
				con.close();
			}
			/**** Excepción que se dispara si falla la carga del driver ****/
			catch( ClassNotFoundException e ) { e.printStackTrace();  }

			/**** Excepción que se dispara si falla la conexión *****/
			catch ( SQLException e) { e.printStackTrace();  }

		}
	}

Aunque el código del ejemplo anterior está documentado, vamos a repasar algunos conceptos:

• Class.forName: si esta llamada falla (normalmente porque no se encuentra el archivo del controlador), entonces se dispara una excepción ClassNotFoundException.
• De manera semejante, si el intento de conexión mediante DriverManager.getConnection ha fallado se dispara la excepción SQLException. La gestión de esta excepción verás que no sólo es necesaria en la conexión a la base de datos, sino en otras circunstancias: definición de datos, manipulación de datos, consulta, etc.
• Un aspecto que ya hemos comentado: puesto que getConnection() es static no resulta necesario instanciar la clase DriverManager.
• Por último, no olvidar la higiene: cerramos la conexión. Ahora puede perecer algo paranoico (no lo es). Pero además, a medida que las aplicaciones sean más complejas la disciplina de cierre de conexiones es más necesaria.

Si he llegado hasta aquí es que se ha producido la conexión
Si no se hubiera producido, se habría disparado SQLException

En el segundo ejemplo podemos observar:

• Los datos de registro del controlador (driver) y de la conexión (base de datos, usuario y password) se encuentran en el archivo "database.properties", cuyo contenido es:

  
  		jdbc.drivers=com.mysql.jdbc.Driver
  		jdbc.url=jdbc:mysql://localhost/prueba
  		jdbc.username=root
  		jdbc.password=palabra
    

  Para cargar en memoria esta información el proceso es muy simple, tanto que se puede hacer todo en tres líneas:

  1. Instanciamos la clase Properties: Properties props = new Properties();
  2. Creamos un flujo de entrada para el archivo: FileInputStream in = new FileInputStream("database.properties");
  3. Cargamos el contenido en props: props.load(in);
  
  
  
• Obtener una propiedad en concreto del objeto props es muy simple, por ejemplo: String url = props.getProperty("jdbc.url");
  
  
• El registro se realiza de manera estática, por medio de System.setProperties("jdbc.drivers", String de driver).
  
  
• La conexión se realiza, al igual que en el ejemplo anterior, por medio de DriverManager.getConnection(...).

	import java.sql.DriverManager;
	import java.sql.Connection;
	import java.sql.SQLException;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.util.Properties;

	public class jdbc01_conexion3 {
		public static void main(String[] args) {
			try {
			   	/*** Abrimos flujo de entrada y cargamos el contenido en props ****/
				Properties props = new Properties();
				FileInputStream in = new FileInputStream("database.properties");
				props.load(in); // Cargamos el contenido del flujo en props
				in.close();

				/**** Obtenemos las propiedades del objeto props ***/
				/*** Para registrar de manera estática (setProperty) el driver ***/
				String drivers = props.getProperty("jdbc.drivers");
				if (drivers != null)
					System.setProperty("jdbc.drivers", drivers);  // Cargamos driver
				/*** Para la conexión ***/
				String url = props.getProperty("jdbc.url");
				String username = props.getProperty("jdbc.username");
				String password = props.getProperty("jdbc.password");

				/*** Conexión ****/
				Connection con = DriverManager.getConnection( url, username, password );
			}
			catch (SQLException e) { e.printStackTrace();  }
			catch (SecurityException e) { e.printStackTrace();  }
			catch (IOException e) { e.printStackTrace();  }
		}
	}

En el siguiente ejemplo utilizamos un registro dinámico y además utilizamos un archivo .log para ver los eventos que suceden en la conexión JDBC, para lo cual utilizamos la función setLogWriter():

	import java.sql.DriverManager;
	import java.sql.Connection;
	import java.lang.ClassNotFoundException;
	import java.sql.SQLException;
	import java.io.FileOutputStream;
	import java.io.File;
	import java.io.IOException;
	import java.io.PrintWriter;

	public class jdbc01_conexion4 {
		public static void main(String[] args) {
			try {
				Class.forName("com.mysql.jdbc.Driver");
				activar_log( "ejemplo.log" );
				Connection con = DriverManager.getConnection( "jdbc:mysql://localhost/prueba", "root", "palabra" );
			}
			catch( ClassNotFoundException e ) { e.printStackTrace();  }
			catch (SQLException e) { e.printStackTrace();  }
		}

		public static void activar_log( String archivo ) {
			try {
				FileOutputStream fs = new FileOutputStream(new File(archivo));
				PrintWriter p = new PrintWriter(fs, true);
				DriverManager.setLogWriter(p);
			}
			catch (IOException e) { e.printStackTrace();  }
		}
	}

En el archivo log aparece la carga de controlador y la conexión:

DriverManager.getConnection("jdbc:mysql://localhost/prueba")
	trying driver[className=com.mysql.jdbc.Driver,com.mysql.jdbc.Driver@5224ee]
getConnection returning driver[className=com.mysql.jdbc.Driver,com.mysql.jdbc.Driver@5224ee]

Si tienes curiosidad, puedes provocar un error de conexión y verás que aparece descrito en el archivo log.