JDBI con Spring Boot

JDBI es una librería de código abierto para Java que actúa como una capa de abstracción sobre JDBC (Java Database Connectivity).

Permite interactuar con bases de datos relacionales de forma más rápida y limpia, reduciendo el código repetitivo (boilerplate) sin ocultar el lenguaje SQL.

Creando un proyecto Spring Boot con JDBI

Iremos al sitio para crear nuestro proyecto: https://start.spring.io/

Agregaremos las dependencias de MariaDB y Spring Jdbc.

Una vez creado el proyecto agregaremos una más, la dependencia de JDBI:

pom.xml

        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-core</artifactId>
            <version>3.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-sqlobject</artifactId>
            <version>3.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-spring5</artifactId> 
            <version>3.2.5</version>
        </dependency>

El diseño de nuestra aplicación será modular:

• repository: para el acceso a los datos de la BD. 
• model: para el mapeo objeto-relacional. 
• service: contiene la lógica de negocio. 
• controller: el punto de entrada de las peticiones HTTP.
• config: para las configuraciones.

Base de datos de la aplicación

Usaremos MariaDB como BD. El nombre de la BD sera ``soporte_tecnico``. Nuestra tabla es la siguiente:

CREATE OR REPLACE TABLE usuarios(
id int PRIMARY KEY, password varchar(255),
nombre varchar(255), apellidos varchar(255),
correo varchar(255), cvesis varchar(255)
);

Esta entidad relacional describe los atributos de un usuario.

Capa de mapeo objeto-relacional

Crearemos nuestra clase tipo que mapee los atributos de la tabla usuarios.

Usuario.java

package com.codemonkey.demo_jdbi.model;

import org.jdbi.v3.core.mapper.reflect.ColumnName;
import org.jdbi.v3.core.mapper.reflect.JdbiConstructor;

public class Usuario {
    @ColumnName("id") private Long id;
    @ColumnName("nombre") private String nombre;
    @ColumnName("apellidos")private String apellidos;
    @ColumnName("correo") private String correo;
    @ColumnName("cvesis")private String cvesis;


   public Usuario(
    @ColumnName("id") Long id,
    @ColumnName("nombre") String nombre,
    @ColumnName("apellidos") String apellidos,
    @ColumnName("correo") String correo,
    @ColumnName("cvesis") String cvesis) {
    this.id = id;
    this.nombre = nombre;
    this.apellidos = apellidos;
    this.correo = correo;
    this.cvesis = cvesis;
	}


    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getApellidos() {
        return apellidos;
    }

    public void setApellidos(String apellidos) {
        this.apellidos = apellidos;
    }

    public String getCorreo() {
        return correo;
    }

    public void setCorreo(String correo) {
        this.correo = correo;
    }

    public String getCvesis() {
        return cvesis;
    }

    public void setCvesis(String cvesis) {
        this.cvesis = cvesis;
    }
}

No incluiremos el campo del password.

Capa de datos

Crearemos una interface para el repositorio de datos.

UsuarioRepository.java

package com.codemonkey.demo_jdbi.repository;

import com.codemonkey.demo_jdbi.model.Usuario;
import org.jdbi.v3.sqlobject.config.RegisterConstructorMapper;
import org.jdbi.v3.sqlobject.statement.SqlQuery;
import org.jdbi.v3.sqlobject.statement.SqlUpdate;
import java.util.List;

@RegisterConstructorMapper(Usuario.class) 
public interface UsuarioRepository {

    @SqlQuery("SELECT id, nombre, apellidos, correo, cvesis FROM usuarios")
    List<Usuario> listarUsuarios();

    @SqlUpdate("INSERT INTO usuarios(id, password, nombre, apellidos, correo, cvesis) VALUES (:id, :password, :nombre, :apellidos, :correo, :cvesis)")
    void insertar(Long id, String password,String nombre, String apellidos, String correo, String cvesis);
}

Esta interface tendrá dos métodos. Uno para consultar los datos con la instrucción SELECT y otro para insertar datos con INSERT.

Capa del servicio

Crearemos una clase tipo service para la lógica del negocio.

UsuarioService.java

package com.codemonkey.demo_jdbi.service;

import com.codemonkey.demo_jdbi.model.Usuario;
import com.codemonkey.demo_jdbi.repository.UsuarioRepository;
import org.jdbi.v3.core.Jdbi;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UsuarioService {

    private final UsuarioRepository usuarioRepository;

    public UsuarioService(Jdbi jdbi) {
        this.usuarioRepository = jdbi.onDemand(UsuarioRepository.class);
    }

    public List<Usuario> listarUsuarios() {
        return usuarioRepository.listarUsuarios();
    }

    public void insertarUsuario(Long id, String password, String nombre, String apellidos, String correo, String cvesis) {
        usuarioRepository.insertar(id, password, nombre, apellidos, correo, cvesis);
    }
}

Capa para el acceso a las peticiones HTTP

Crearemos una clase tipo controller.

UsuarioController.java

package com.codemonkey.demo_jdbi.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResquestBody;
import java.util.logging.Logger;
import java.util.logging.Level;
import com.codemonkey.demo_jdbi.service.UsuarioService;
import com.codemonkey.demo_jdbi.model.Usuario;
import java.util.List;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;


@RestController
@RequestMapping("/api/usuarios")
public class UsuarioController {

    private static final Logger LOGGER = Logger.getLogger(UsuarioController.class.getName());
	
	private UsuarioService usuarioService;

	@Autowired
    public UsuarioController(UsuarioService usuarioService) {
        this.usuarioService = usuarioService;
    }
	
    // http://localhost:8083/api/usuarios/hola
    @GetMapping("/hola")
    public String hola() {
        LOGGER.log(Level.INFO, "Entramos al primer servicio.");
        return "El servicio esta vivo.";
    }
	
	// http://localhost:8083/api/usuarios/all
	@GetMapping("/all")
	public ResponseEntity<List<Usuario>> getUsuarios() {
		LOGGER.info("\t ==== Obtenemos todos los usuarios. ====");
		List<Usuario> usuarios = usuarioService.listarUsuarios();
		
		if(usuarios.isEmpty()) {
			return ResponseEntity.noContent().build();
		}
		return ResponseEntity.ok(usuarios);
	}
	
	// http://localhost:8083/api/usuarios/insertar
    @PostMapping("/insertar")
    public ResponseEntity<String> insertarUsuario(@RequestBody Usuario usuario) {
    try {
        LOGGER.info("Insertando nuevo usuario: " + usuario.getNombre());
        usuarioService.insertarUsuario(
            usuario.getId(),
            "qwErt@3200$",
            usuario.getNombre(),
            usuario.getApellidos(),
            usuario.getCorreo(),
            usuario.getCvesis()
        );
        return ResponseEntity.status(HttpStatus.CREATED)
                             .body("Usuario insertado correctamente.");
    } catch (Exception e) {
        LOGGER.log(Level.SEVERE, "Error al insertar usuario", e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                             .body("Error al insertar usuario: " + e.getMessage());
    }
}


	
}

Esta clase expone tres apis:

• GET http://localhost:8083/api/usuarios/hola 
• GET http://localhost:8083/api/usuarios/all 
• POST http://localhost:8083/api/usuarios/insertar

La primera es para probar que la aplicación está activa. La segunda para consultar todos los datos de la tabla usuarios. La tercera para agregar un nuevo usuario.

Construimos la aplicación:

$ mvn clean install -X

Ejecutamos la aplicación:

$ mvn spring-boot:run

Hemos visto cómo crear una aplicación Spring Boot con Jdbi.

Enlaces:

https://jdbi.org/
https://codemonkeyjunior.blogspot.com/2016/02/jdbi-como-alternativa-jdbc.html
https://codemonkeyjunior.blogspot.com/2016/01/conociendo-jdbi.html
https://codemonkeyjunior.blogspot.com/2017/04/jdbi-con-groovy-2.html

JDBI como alternativa a JDBC

En el post anterior hablábamos de una librería que nos permite realizar operaciones con bases de datos de una manera más sencilla y similar a lo que se hace con JDBC.

JDBI promete, al menos en teoría, hacer que el manejo de información en bases de datos no sea tan complicada. Haremos un ejemplo práctico para ver si es tan fácil o no.

Supongamos que tenemos una base de datos llamada "test" y una tabla llamada "persona". Obtendremos la información contenida en la tabla persona creando los siguientes archivos (clases):

• ModeloPersona.java  que servirá como "entidad" en nuestra aplicación.
• ModeloPersonaMapper. java que servirá como "mapeador" de la entidad.
• PersonaDAO.java donde definiremos las operaciones de consulta.
• TestPersona.java que servirá como clase principal.

Nuestra tabla "persona" contiene los siguientes campos: id, nombre, apellidoP, apellidoM, edad,peso, talla. Por lo tanto, nuestra entidad ModeloPersona.java también debe cubrir esos campos.

ModeloPersona.java

package com.codemonekey.model;

public class  ModeloPersona implements java.io.Serializable{
 
private static final long serialVersionUID=1L;

private String id;
private String nombre;
private String apellidoP;
private String apellidoM;
private String edad;
private String peso;
private String talla;

public ModeloPersona(String id, String nombre,String apellidoP,String apellidoM,String edad,String peso,String talla){
    super();
    this.id=id;
    this.nombre=nombre;
    this.apellidoP=apellidoP;
    this.apellidoM=apellidoM;
    this.edad=edad;
    this.peso=peso;
    this.talla=talla;
}

//setters y getters
// Setters
public void setId(String id) {
    this.id = id;
}

public void setNombre(String nombre) {
    this.nombre = nombre;
}

public void setApellidoP(String apellidoP) {
    this.apellidoP = apellidoP;
}

public void setApellidoM(String apellidoM) {
    this.apellidoM = apellidoM;
}

public void setEdad(String edad) {
    this.edad = edad;
}

public void setPeso(String peso) {
    this.peso = peso;
}

public void setTalla(String talla) {
    this.talla = talla;
}

// Getters
public String getId() {
    return id;
}

public String getNombre() {
    return nombre;
}

public String getApellidoP() {
    return apellidoP;
}

public String getApellidoM() {
    return apellidoM;
}

public String getEdad() {
    return edad;
}

public String getPeso() {
    return peso;
}

public String getTalla() {
    return talla;
}


}

ModeloPersonaMapper.java

package com.codemonekey.datos;
 
public class ModeloPersonaMapper implements ResultSetMapper<ModeloPersona> {

    @Override
    public ModeloPersona map(int arg0, ResultSet r, StatementContext arg2) throws SQLException {
        ModeloPersona mpersona=new ModeloPersona();
        mpersona.setClave(r.getString("clave"));
        mpersona.setNombre(r.getString("nombre"));
        mpersona.setApellidoP(r.getString("apellidoP"));
        mpersona.setApellidoM(r.getString("apellidoM"));
        mpersona.setEdad(r.getString("edad"));
        mpersona.setPeso(r.getString("peso"));
        mpersona.setTalla(r.getString("talla"));
        return null;
    }

}

PersonaDAO.java

import org.codemonkey.model.ModeloPersona;
import org.skife.jdbi.v2.sqlobject.Bind;
import org.skife.jdbi.v2.sqlobject.SqlQuery;
import org.skife.jdbi.v2.sqlobject.customizers.RegisterMapper;

@RegisterMapper(ModeloPersonaMapper.class)
public interface PersonaDAO {
    @SqlQuery("SELECT test.persona.clave, test.persona.nombre, test.persona.apellidoP, test.persona.apellidoM, test.persona.edad, test.persona.peso, test.persona.talla FROM test.persona WHERE test.persona.clave = :id")
    ModeloPersona findById(@Bind("id") long id);
    @SqlQuery("SELECT test.persona.clave, test.persona.nombre, test.persona.apellidoP, test.persona.apellidoM, test.persona.edad, test.persona.peso, test.persona.talla FROM test.persona")
    List<ModeloPersona> verTodo();
    void close();
}

Finalmente la clase TestPersona.java

package org.codemonkey.test1;

import org.codemonkey.dao.PersonaDAO;
import org.codemonkey.model.ModeloPersona;
import org.skife.jdbi.v2.DBI;
import org.skife.jdbi.v2.Handle;
import static java.lang.System.out;

public class TestPersona {

    public static void main(String[] args) {
        DBI dbi = new DBI("jdbc:mysql://localhost:3306/test",
                "root",
                "5432");
        Handle h = dbi.open();
        if(!dbi.open().isInTransaction()){
            out.println("No esta realizando alguna transaccion");
        }
       
        PersonaDAO pers=null;
        try{
            pers=dbi.open(PersonaDAO.class);
            if(pers.verTodo().size() > 0){
                out.println("Lista de persona llena!!:"+pers.verTodo().size());
                out.println(""+pers.verTodo().toString());
                for(int i=0 ; i < pers.verTodo().size(); i++){
                    out.println("id:"+pers.verTodo().get(i).getClave());
                    out.println("nombre:"+pers.verTodo().get(i).getNombre());
                    out.println("apellido paterno:"+pers.verTodo().get(i).getApellidoP());
                    out.println("apellido materno:"+pers.verTodo().get(i).getApellidoM());
                    out.println("edad:"+pers.verTodo().get(i).getEdad());
                    out.println("peso:"+pers.verTodo().get(i).getPeso());
                    out.println("talla:"+pers.verTodo().get(i).getTalla());   
                   
                }
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }finally{
            pers.close();
        }
       
        h.close();
    }

}

Continuaremos en próximas entregas.

Enlaces:

https://jdbi.org/

JDBI con Groovy (3)

Siguiendo con el tema de JDBI está ocasión veremos una pequeña aplicación del tipo CRUD (altas, bajas, consultas y modificaciones).

Necesitamos crear una base de datos;

CREATE DATABASE test;

Una vez creada procedemos a seguir con estos pasos.

1. Crear un archivo *.sql llamado bien.sql para la creación de la tabla
2. Crear una BD en MySQL
3. Usar el archivo *.sql de la siguiente manera: $ mysql -u USUARIO -pCLAVE test  < bien.sql
4. Crear un archivo froovy llamado Dao2.groovy
5. Importar las librerías necesarias para manipular datos y crear un log: jdbi, slf4j, y mysql mediante @Grapes
6. Crear una interface llamada BienDAO; esta interface contendrá los métodos con las declaraciones necesarias para la gestión de los datos
7. Crear una clase serializable llamada ModeloBien
8. Crear una clase que implemente la interface ResultSetMapper
9. Crear una clase principal (en este caso tendrá el mismo nombre del archivo)

bien.sql
CREATE TABLE IF NOT EXISTS bien(id int auto_increment primary key,numero int, usuario varchar(45), password varchar(32), maquina ENUM('pc','macosx','laptop_pc','laptop_macosx','movil'), sistema ENUM('windows','macosx','linux','android'), area ENUM('direccion','sistemas','soporte','hemeroteca','evaluacion','investigacion'), ip varchar(15), no_bien varchar(45));
INSERT INTO bien (numero, usuario, password, maquina, sistema, area, ip, no_bien) VALUES ('39','Yuri Gagarin','5432','pc','windows','sistemas','148.215.24.39','7749'),('36','Maria Petrovska','009GT2b','pc','linux','hemeroteca','148.215.24.36','7767'),('90','Tulio Alvarez','$36@L77','laptop_macosx','macosx','investigacion','172.215.22.25','4343');
UPDATE bien SET area='investigacion' WHERE id=2;
UPDATE bien SET area='soporte' WHERE id=1;
DELETE FROM bien WHERE id=3;
SELECT * FROM bien;


$ mysql -u TUUSUARIO -pTUCLAVE test < bien.sql

 Esto nos permitirá cargar los datos contenidos en el archivo.

El programa consiste en un menú que te dará las opciones de insertar, consultar por id, consultar todos los registros, actualizar los datos por id y eliminar datos por id.


 compilar: groovyc Dao2.groovy
 ejecutar: groovy Dao2.groovy TUUSUARIO TUCLAVE


Ejemplo de uso y salida: 
$ mysql -u root -p5432 test < bien.sql

$ groovyc Dao2.groovy

$groovy Dao2.groovy root 5432

[main] INFO jdbi - Iniciando script ...
[main] INFO jdbi - usuario: root
[main] INFO jdbi - password: 5432
    ******* Menu *******
1. Insertar datos
2. Consultar datos por id
3. Consultar total de datos
4. Actualizar datos por id
5. Eliminar datos por id
6. Salir
*******************************
Escoge una opción:2
    [Consulta por id]

Escribe el id:
2
    >> Id: 2
    >> Número: 36
    >> Usuario: Maria
    >> Password: 009GT2b
    >> Máquina: pc
    >> Sistema: linux
    >> Área: investigacion
    >> Ip: 148.215.24.36
    >> No_bien: 7767
    Búsqueda realizada
    ******* Menu *******
1. Insertar datos
2. Consultar datos por id
3. Consultar total de datos
4. Actualizar datos por id
5. Eliminar datos por id
6. Salir
*******************************
Escoge una opción:

 Dao2.groovy

Conociendo JDBI

Usar JDBC implica el uso de clases y algunas configuraciones que nos permiten establecer conexión con bases de datos. Además tan solo necesitamos algún driver para cada tipo de bases (MySQL, Oracle, Sqlite, Firebird,etc.).

Sin embargo, hay cierta complejidad cuando necesitamos manejar gran cantidad de información. Los que han programado en Java saben lo molesto que puede ser el acceso a base de datos mediante los mecanismos que nos proporciona el JDBC (Java DataBase Connectivy).  No es que sean malos, pero cuando se trata de administrar la información de un  proyecto más o menos grande si causa algunos problemas.  

JDBI nace gracias a la necesidad de los programadores por acceder y administrar bases de datos de una manera más sencilla. Es una librería Java que promete ser una alternativa más adecuada al uso de JDBC.

JDBI nos ofrece dos estilos:

1. Estilo fluido: Donde se hace uso de Datasource similares a JDBC, pero de una manera mucho más sencilla.
2. Estilo Objetos SQL: Similar a lo que hacemos usando Hibernate o JPA nativo. donde tenemos nuestras "Entities" y las manipulamos mediante DAOs. 

 Más adelante haremos algunos ejemplos.

Links
http://jdbi.org/

JDBI con Groovy (2)

En esta ocasión veremos un ejemplo del uso de JDBI con Groovy.

1. Una clase principal llamada Dao.groovy
2. Una interface llamada MyDAO

 MyDAO contendrá los método necesarios para crear una tabla, insertar valores, buscar un registro mediante su id y ,por último un método para cerrar.

El código viene de la página oficial de JDBI. Espero les sirva.

JDBI con Groovy

En esta ocasión usaremos Groovy para crear una aplicación usando JDBI. Prácticamente es el mismo código usado la vez anterior que se dio un vistazo a JDBI. La diferencia radica en el uso de @Grapes y Grab para importar y cargar las librerías necesarias.

He aquí el código

JDBC

En este blog hemos hablado sobre alternativas a JDBC como JDBI, sin embargo conocer lo esencial siempre es importante.

JDBC fue ideada para crear una interface común entre distintos proveedores de bases de datos. Supongamos que requiero conectarme a una BD Oracle y/o SQL Server, con JDBC podemos crear una conexión sin la necesidad de crear decenas o centenas de clases y sus respectivos métodos, pues JDBC contiene lo esencial para ello.

Existen cuatro tipos de drivers JDBC:

1. DRIVER PUENTE JDBC-ODBC: Un ejemplo de su uso es cuando queremos conectarnos a una BD de Access o incluso Excel. Al parecer ya no está en uso.
2. DRIVER NATIVO: El inconveniente es que la máquina cliente debe tener instalador el driver,a unque es más recomendable que el driver JDBC-ODBC.
3. DRIVER INTERMEDIO (RED): no requiere ningún tipo de instalación den el equipo donde se ejecuta el programa.
4. DRIVER PURO(JAVA): no requiere ningún tipo de configuración en la máquina cliente.

 JDBC nos permite cargar el driver específico que necesitamos, crear la conexión a la BD, preparar y ejecutar sentencias SQL y visualizar los resultados de las consultas.

¿Cuáles son los pasos para usar JDBC?
Son cuatro pasos:

1. Conectarnos a la BD: requerimos cargar el driver y crear la conexión.
2. Ejecución de consultas: crear las sentencias SQL a ejecutar.
3. Manipulación de registros: lectura, inserción, actualización y eliminación mediante lenguaje SQL(DML).
4. Cerrar la conexión.

Cargar el driver

private static final String DRIVER_POSTGRES = "org.postgresql.Driver";
//...
Class.forName(DRIVER_POSTGRES);

Crear la conexión:

private static final String url = "jdbc:postgresql://localhost/BD";
private static final String user = "postgres";
private static final String password = "m1Cl4v3";

//Creamos la conexion
Connection conn;
//Postgres
conn = DriverManager.getConnection(url, user, password);
System.out.println("Conexion exitosa!!");

Ejecución y manipulación de datos (y cierre de la sentencia):

stm.execute(sql);
rs = stm.executeQuery(sql);
if(rs.next()) {
//...
rs.close();
}

Cerrar conexión:

conn.close();
//Comprobamos el cierre
if(conn.isClosed() == true) {   
   System.out.println("Conexion cerrada");
}

Ejemplo. Creamos una conexión a PostgreSQL.

• Clase Main.java
• Clase Contacto.java
• Clase ConexionPostgres.java

Contacto.java

package org.inforhomex.modelo;

/**
*@Author Fer Carraro
*
*/

public class Contacto {
 private int id;
 private String nombre;
 private String telefono;

 public Contacto() {
 }

 public Contacto(int id, String nombre, String telefono) {
  super();
  this.id = id;
  this.nombre = nombre;
  this.telefono = telefono;
 }

 public int getId() {
  return id;
 }

 public void setId(int id) {
  this.id = id;
 }

 public String getNombre() {
  return nombre;
 }

 public void setNombre(String nombre) {
  this.nombre = nombre;
 }

 public String getTelefono() {
  return telefono;
 }

 public void setTelefono(String telefono) {
  this.telefono = telefono;
 }

 @Override
 public String toString() {
  return "Contacto [id=" + id + ", nombre=" + nombre + ", telefono=" + telefono + "]";
 }

}

ConexionPostgres.java

package org.inforhomex.conexion;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import javax.swing.JOptionPane;
import java.sql.SQLException;
import java.sql.SQLSyntaxErrorException;
import org.postgresql.util.PSQLException;
import org.inforhomex.modelo.Contacto;


public class ConexionPostgres {
 
 
 private static final String DRIVER_POSTGRES = "org.postgresql.Driver";
 private static final String url = "jdbc:postgresql://localhost/curso";
 private static final String user = "postgres";
 private static final String password = "tuclave";
 

 public static void conexion() throws SQLException, SQLSyntaxErrorException,ClassNotFoundException,PSQLException; { 
  //Postgres
  Class.forName(DRIVER_POSTGRES);
  
  //Creamos la conexion
  Connection conn;
  //Postgres
  conn = DriverManager.getConnection(url, user, password);
  System.out.println("Conexion exitosa!!");
  String sql; 
  //Sentencia SQL Postgres
  sql = "select nombre, telefono from public.contactos limit 1";
  Statement stm;
  ResultSet rs;
  Contacto contacto;
  
  stm = conn.createStatement();
  
  if(stm != null) {
   //ejecutamos consulta
   System.out.println("Ejecutamos consulta...");
   stm.execute(sql);
   rs = stm.executeQuery(sql);
   if(rs.next()) {
    System.out.println("Nombre: "+rs.getString("nombre"));
    System.out.println("Telefono: "+rs.getString("telefono"));
    contacto = new Contacto();
    contacto.setId(1);
    contacto.setNombre(rs.getString("nombre"));
    contacto.setTelefono(rs.getString("telefono"));
    javax.swing.JOptionPane.showMessageDialog(null, contacto,"Contacto encontrado",JOptionPane.INFORMATION_MESSAGE);
   }
   //cerramos el ResultSet
   rs.close();
   //cerramos consulta
   System.out.println("Cerramos consulta...");
   stm.close();
  }
  
  
  //Cerramos la conexion
  conn.close();
  //Comprobamos el cierre
  if(conn.isClosed() == true) {
   System.out.println("Conexion cerrada");
  }
 }

}

Main.java

package org.inforhomex;

import org.inforhomex.conexion.ConexionPostgres;
import org.inforhomex.conexion.Conexion;
import java.sql.SQLException;
import java.sql.SQLSyntaxErrorException;
import javax.swing.JOptionPane;
import org.postgresql.util.PSQLException;
/**
*@Author Fer Carraro
*
*/

public class Main {

 public static void main(String[] args) {
  System.out.println("Inicio");
  try {
   //Nos conectamos a la BD
   ConexionPostgres.conexion();
  } catch(PSQLException ex0) {
   JOptionPane.showMessageDialog(null, ex0.toString(),"PSQLException",JOptionPane.ERROR_MESSAGE);
  }catch (SQLSyntaxErrorException ex1) {
   JOptionPane.showMessageDialog(null, ex1.toString(),"SQLSyntaxErrorException",JOptionPane.ERROR_MESSAGE);
  } catch (SQLException ex2) {
   JOptionPane.showMessageDialog(null, ex2.toString(),"SQLException",JOptionPane.ERROR_MESSAGE);
  } catch (Exception ex3) {
   JOptionPane.showMessageDialog(null, ex3.toString(),"Exception",JOptionPane.ERROR_MESSAGE);
  }finally {
   System.out.println("Hecho");
  }
 }

}

Ejemplo completo en github:

Links:
https://www.javatpoint.com/jdbc-driver 
http://codigoxules.org/conectar-mysql-utilizando-driver-jdbc-java-mysql-jdbc/