El documento explica cómo conectar Java a una base de datos PostgreSQL. Primero se debe instalar el driver JDBC de PostgreSQL y cargarlo en el proyecto Java. Luego, se crea una conexión a la base de datos especificando la URL, usuario y contraseña. Finalmente, se ejecutan consultas SQL sobre la base de datos y se procesan los resultados con un ResultSet. El código muestra cómo realizar estas tareas para establecer la conexión y consultar datos de una tabla de la base de datos.

1. Conexión a postgres desde Java
Published julio 22, 2008 Programación 12 Comments
Etiquetas: Java
Hace tiempo tuve la necesidad de conectarme a Postgres desde Java. En esa ocasión tuve
algunos problemas para hacerlo, por lo que hago esta pequeña guía para todos aquellos que se
inicien en JDBC. El código mas o menos puede funcionar con cualquier base de datos.
1 package prueba;
2
3 import java.sql.*;
4
5 public class ConexionPostgres {
6
7 public void consultar() {
8 String cc = "jdbc:postgresql://127.0.0.1/prueba?" +
9 "user=postgres&password=eureka";
10 try {
11 Class.forName("org.postgresql.Driver");
12 Connection conexion =
DriverManager.getConnection(cc);
13 Statement comando = conexion.createStatement();
14 String sql =
15 "SELECT nombre, apellido FROM clientes ORDER BY
apellido";
16 ResultSet resultado = comando.executeQuery(sql);
17 while(resultado.next()) {
18 String n = resultado.getString("nombre");
19 String a = resultado.getString("apellido");
20 System.out.println(n + " " + a);
21 }
22 resultado.close();
23 comando.close();
24 conexion.close();
25 } catch(Exception e) {
26 System.out.println(e.getMessage());
27 }
28 }
29
30 public static void main(String[] args) {

2. 31 ConexionPostgres cp = new ConexionPostgres();
32 cp.consultar();
33 }
34 }
La línea 7 define un método llamado consultar. Dentro de esta función está el código para
realizar la conexión a la tabla dentro de una base de datos Postgres.
La línea 8 define la cadena de conexión a la base de datos llamada prueba.
En la línea 11 se carga el controlador JDBC para postgres. Lo puedes descargar aquí.
La línea 12 inicia la conexión a la base de datos “prueba” del servidor postgres.
En la línea 13 se crea un objeto llamado conexion, el cual modela una conexión a un origen de
datos. En la siguiente línea se crea un objeto String con la consulta a realizar.
La línea 16 ejecuta la consulta y almacena el resultado en un objeto de tipo ResultSet. Los
objetos de este tipo, son unas estructuras dinámicas para almacenar resultados de consultas. En
la siguiente línea se define un while que evalúa el resultado de la llamada al método “next” del
objeto resultado. Los objetos de tipo ResultSet cuentan con una especie de cursor para
seleccionar una fila del resultado de una consulta. Al realizar una llamada a “next”, el cursor se
mueve a un registro. De esa manera se va accediendo uno a uno de los registros retornados. El
método “next” retornará falso en caso de no haber un registro siguiente al cual apuntar. Por
defecto, el cursor de registros apunta a ningún registro, por lo que por lo menos hay que
ejecutar una vez el método “next” para obtener si quiera 1 registro. De esta manera, el while se
encarga de ir moviendo el cursor de registros de manera automática. Dentro del while
simplemente se accede a cada campo de la fila del registro seleccionado y se imprime en
pantalla.
Las líneas 22, 23 y 24 liberan los recursos utilizados por los objetos Connection, Statement y
ResultSet.
Para compilar, crear un directorio llamado prueba y almacenar dentro de él el
archivo ConexionPostgres.java.
$ javac prueba/*.java
Para ejecutar, configurar el classpath de acuerdo a la ubicación del driver JDBC de postgres. En
mi caso, he creado un directorio llamado lib dentro del directorio de mi aplicación. Dentro del
directorio lib he puesto el archivo jar que contiene el controlador de jdbc. Ejemplo:
$ java -classpath ./prueba/lib/postgresql-8.2.jdbc4.jar:.
prueba.ConexionPostgres

3. JDBC: Conectar Java con PostgreSQL
Posted by oftc007 en 23 mayo 2008
JDBC (Java Data Base Connectivity), es el API para la conexión a bases de datos desde el lenguaje Java, lo
que nos permite ejecutar operaciones sobre bases de datos, realizando estas operaciones con lenguaje SQL
de la base de datos.
Para realizar esta conexion aparte de conocer el lenguaje Java y tener todo lo necesario para compilar y
ejecutar programas en este lenguaje, necesitamos tener instalado del driver JDBC en nuestra PC, para eso
vamos al gestor de paquetes synaptic y descargamos el paquete
libpg-java
Luego que tenemos el driver instalado, creamos un archivo con nuestro editor de texto preferido y pegamos
el siguiente codigo:
import java.sql.*;
class conexion{
public static void main(String[] args)
{
String driver = “org.postgresql.Driver”;
String connectString = “jdbc:postgresql://localhost:5432/Taller”;
String user = “of”;
String password = “1234”;
try{
Class.forName(driver);
Connection con = DriverManager.getConnection(connectString, user , password);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(“SELECT * FROM cabecera_trabajo”);
while (rs.next()){
System.out.println(“CEDULA ” + rs.getString(“cedula_cliente”));
}
stmt.close();
con.close();

4. }
catch ( Exception e ){
System.out.println(e.getMessage());
}
}
}
Luego de eso guardamos el archivo con el nombre de “conexion.java”, o el nombre que quieran, pero
siempre poniendo al final “.java”.
Pasemos a explicar las partes mas resaltantes del codigo para entender que estamos haciendo.
Lo primero que hacemos es darle un nombre a nuestra clase, que debe coincidir con el nombre del archivo,
luego de eso agregamos el codigo en el main.
String driver = "org.postgresql.Driver";
String connectString = "jdbc:postgresql://localhost:5432/Taller";
String user = "of";
String password = "1234";
En esta parte del codigo estamos declarando e inicializando variables del tipo string con toda la informacion
necesaria para la conexion a la base de datos, primero tenemos el nombre del driver que es
“org.postgresql.Driver”, luego un string donde colocamos la base de datos donde nos queremos conectar,
siguiendo el formato:
jdbc:postgreslq://ubicacion_de_BD:puerto/nombre_BD
Luego tenemos el string con el username y password necesarios para conectarnos a la base de datos.
Class.forName(driver);
Connection con = DriverManager.getConnection(connectString, user ,
password);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM cabecera_trabajo");
Cargamos el driver en memoria con la funcion “Class.forName”, pasandole como parametro el string donde
asignamos el nombre del driver que queremos usar.

5. Luego de eso definimos un objeto del tipo “connection” para realizar la conexion con la base de datos, la
funcion encargada de hacer la conexion es “DriverManager.getConnection”, que recibe como parametros el
string con la informacion de la base de datos, y los string de username y password.
Luego de eso definimos un objeto del tipo Statement, el cual nos permitira realizar las diferentes
operaciones sobre nuestra base de datos mediante sentencias SQL.
Posteriormente definimos un objeto del tipo “ResultSet” (hoja de resultados), donde almacenaremos el
resultado del query que ejecutemos. Para ejecutar el query usamos la funcion “executeQuery”, que recibe
como parametros un string que contenga la setencia del query que queremos ejecutar.
while (rs.next()){
System.out.println("CEDULA " + rs.getString("cedula_cliente"));
}
Ya que tenemos el resultado que arrojo el query en nuestro objeto del tipo “ResultSet”, debemos mover el
apuntador, para recorrer todas las tuplas que devolvio el query. Para mover el apuntador usamos la funcion
“next()”, la cual colocamos como condicion de un while (mientras existan tuplas que mostrar), y vamos
imprimiendo en pantalla el campo o campos que queremos mostrar.
La funcion para obtener los datos de la hoja de resultados es “getString”, que recibe como parametro un
string con el nombre del campo que queremos mostrar, este nombre debe ser identico (respetando
mayusculas y minisculas) a como esta definido en nuestra base de datos.
stmt.close();
con.close();
Por ultimo cerramos el “Statement” y la conexion a la base de datos.
catch ( Exception e ){
System.out.println(e.getMessage());
}
Como un ultimo detalle, observamos en el codigo que tenemos un try, el cual captura una excepcion (error)
que suceda tanto al momento de hacer la conexion o ejecutar el query, la cual la capturamos en la
variable e, que se imprimira en pantalla.
Ya que tenemos guardado nuestro archivo, desde un terminal vamos al directorio donde lo guardamos y lo
compilamos.

6. javac conexion.java
Para ejecutarlo, debemos especificarle al classpath que queremos usar el driver jdbc por lo que le diremos la
ubicacion la cual es: /usr/share/java.
java -cp .:/usr/share/java/postgresql.jar conexion
Conectar postgreSQL con JAVA desde Netbeans
Hola despues de buscar con Google como conectar una base de datos posgreSQL con java en
netbeans, encontre un enlace que dio la solucion precisa para conectar mi base de datos con
java, debo poner en claro que el codigo solo es para hacer consultas (SELECT * FROM tabla) para
hacer inserciones, actualizar o eliminar recomiendo visitar el siguiente
enlace:http://mygnet.net/articulos/java/conectando_postgresql_con_java.1162.
Pongo a continuacion el script para la creacion de la tabla
CREATE TABLE alumnos
(
matricula text NOT NULL,
nombre text NOT NULL,
semestre text NOT NULL,
carrera text NOT NULL,
CONSTRAINT matricula PRIMARY KEY (matricula)
)
WITH (OIDS=FALSE);
ALTER TABLE alumnos OWNER TO "admin";
Script para insertar dos filas de datos dentro de las comillas sencillas pongan los valores de su
agrado:
insert into alumnos values ('','','','');
insert into alumnos values ('','','','')
Y este es el codigo:
import java.sql.*;
public class conexion {
public static void main(String[] args){
/*Variable para almacenar la URL de conexión a nuestra Base de Datos,
si esta estuviera en otra máquina, necesitariamos estar registrados
en ella y contar con su IP*/
String url = "jdbc:postgresql://localhost:5432/postgres";
try{
//Acceso al Driver

7. Class.forName("org.postgresql.Driver");
//La conexión con los parámetros necesarios
Connection con = DriverManager.getConnection( url,"admin","b6wwUFnc");
//Abrimos la conexión y la iniciamos
Statement stmt = con.createStatement();
/*Un ResultSet es como en .NET un DataSet, un arreglo temporal donde se
almacenará el resultado de la consulta SQL*/
ResultSet rs;
//Una variable String para almacenar la sentencia SQL
String query = "select * from alumnos";
//En el ResultSet guardamos el resultado de ejecutar la consulta
rs = stmt.executeQuery(query);
//En un ciclo while recorremos cada fila del resultado de nuestro Select
while ( rs.next()){
/*Aqui practicamente podemos hacer lo que deseemos con el resultado,
en mi caso solo lo mande a imprimir*/
System.out.println(rs.getString("matricula") + " " + rs.getString("nombre") + " " +
rs.getString("semestre") + " " + rs.getString("carrera"));
}
//Cerramos la conexión
stmt.execute("END");
stmt.close();
con.close();
}
catch( Exception e ){
//Por si ocurre un error
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}
Videotutorial Conectar postgreSQL con JAVA desde Netbeans
Publicado por Administrador en 15:00
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con
FacebookCompartir en Pinterest
4 comentarios:
1.
Zecioner Lovezz22 de marzo de 2014, 18:31
donde puedo descargar el driver me super urge porfa
Responder

8. Respuestas
1.
Juan Lazo16 de agosto de 2014, 0:11