Centro de estudios científicos y Tecnológicos
no°9
“Juan de dios Bátiz”
Bases de Datos
Torres Morales Emilio Manuel
Prof. Rubén Enain Pérez Montes
Programación Intermedia
13/04/25
¿Como conectar una base de datos a un archivo java?
Primero quisiera definir que es una API en java para poder entender la explicación
siguiente
Una API (Interfaz de programación de aplicaciones ) en java es un conjunto de reglas
que permite a los desarrolladores crear aplicaciones. Las API son un componente de
software que facilita la comunicación entre aplicaciones.
Características de las API
● Son un conjunto de de especificaciones predifinidas
● Permiten a los desarrolladores interactuar con dos sistemas diferentes
● Facilitan el intercambio de datos y comunicación
Usos de las API
● Permiten crear aplicaciones que añadan , actualicen y supriman objetos de
modelo
● Permiten consultar objetos de modelo por nombre de clase o número de ID de
objeto
● Permiten gestionar relaciones entre objetos
● Permiten realizar comparaciones
● Permiten examinar el historial de cambios en la base de datos
Beneficios de las API
● Simplifican el diseño, la administración y el uso de las aplicaciones
● Permiten ahorrar tiempo y dinero
● Permiten la colaboración entre el equipo comercial y el de TI
● Permiten crear nuevos canales de ingresos o ampliar los existentes
Ahora que definimos lo que es una API y sus beneficios, usos y características
podemos proseguir con el tema que nos concierne este siendo la conexión de una base
de datos a un programa de java utilizando apis.
Conexión a base de datos en Java
Cuando queremos conectar a la base de datos desde un servicio Java tenemos que
utilizar la API JDBC (Java database Connectivity) de Java.
En general, el código para conectar a una base de datos en Java es el siguiente:
1. Class.forname("org.postgresql.Driver");
2. Connection connection = drivermanager.getconnection(
3. "jdbc:postgresql://hostname:port/dbname","username", "password");
4. Connection.close();
En el código anterior estamos conectando a una base de datos postgresql, para lo cual
instanciamos el driver org.postgresql.Driver y conectamos usando la URL propia de
postgresql jdbc:postgresql://hostname:port. Estos dos aspectos cambiarán en función
del tipo de base de datos a la que estemos conectando.
Primero, instanciamos el driver para que se autoregistre en el drivermanager y poder
invocar después el método getconnection para obtener la conexión. Por último, es
necesario cerrar la conexión.
Por medio del objeto de tipo Connection podremos obtener instancias de Statement,
con las que se pueden enviar instrucciones SQL al servidor de base de datos.
Conexión a base de datos desde una aplicación web.
Partimos de un servicio configurado de esta manera en el descriptor de despliegue:
1. <!-- database example -->
2. <servlet>
3. <servlet-name>example-db</servlet-name>
4. <servlet-class>org.fao.unredd.portal.exampledbservlet</servlet-class>
5. </servlet>
6. <servlet-mapping>
7. <servlet-name>example-db</servlet-name>
8. <url-pattern>/example-db</url-pattern>
9. </servlet-mapping>
10.
Y que implementará su funcionalidad en el método GET:
1. Package org.fao.unredd.portal;
2.
3. Import java.io.ioexception;
4.
5. Import javax.servlet.servletexception;
6. Import javax.servlet.http.httpservlet;
7. Import javax.servlet.http.httpservletrequest;
8. Import javax.servlet.http.httpservletresponse;
9.
10. Public class exampledbservlet extends httpservlet {
11. Private static final long serialversionuid = 1L;
12.
13. @Override
14. Protected void doget(httpservletrequest req, httpservletresponse resp)
15. Throws servletexception, ioexception {
16. //...
17. }
18.
19. }
Aunque sería posible poner el código anterior en el método doget, no es recomendable
debido a que la creación de una conexión es siempre un proceso costoso.
Configuración conexión en el descriptor de despliegue
Para evitar crear una conexión cada vez, tendremos que configurar el contenedor de
aplicaciones, Tomcat en este ejemplo, para que gestione las conexiones por nosotros.
Para ello, tenemos que darle a Tomcat la información necesaria para conectar
modificando dos ficheros.
El primero es el fichero context.xml que existe en el directorio de configuración del
servidor conf. Ahí declararemos un recurso llamado “jdbc/mis-conexiones” que incluirá
todos los datos necesarios para conectar: url, usuario, etc.:
1. <Resource name="jdbc/mis-conexiones" auth="Container" type="javax.sql.datasource"
2. Driverclassname="org.postgresql.Driver" url="jdbc:postgresql://192.168.0.18:5432/geoserverdata"
3. Username="nfms" password="unr3dd" maxactive="20" maxidle="10"
4. Maxwait="-1" />
5.
El otro fichero a modificar es el descriptor de despliegue web-fragment.xml del plugin
que estamos desarrollando (ver Estructura proyectos plugin), donde añadiremos una
referencia al recurso anterior, “jdbc/mis-conexiones”:
1. <resource-ref>
2. <description>Application database</description>
3. <res-ref-name>jdbc/mis-conexiones</res-ref-name>
4. <res-type>javax.sql.datasource</res-type>
5. <res-auth>Container</res-auth>
6. </resource-ref>
7.
Note
Al ejecutar una aplicación en Tomcat desde Eclipse se crea un proyecto “Servers”, que
contiene una entrada para el servidor que estamos utilizando y que en el caso de
Tomcat incluye los ficheros de configuración, entre otros el fichero context.xml donde
configuramos el recurso. La manera más sencilla de acceder al fichero context del
servidor es a través de dicho proyecto.
Una vez estos ficheros han sido modificados ya no tenemos que preocuparnos de
realizar la conexión porque Tomcat las gestiona por nosotros. Pero, ¿cómo podemos
obtener una de estas conexiones gestionadas por Tomcat?
El código Java cambia ligeramente, ya que ahora se obtiene un objeto de
tipo java.sql.datasource que es el que nos proporciona las conexiones:
1. Initialcontext context;
2. Datasource datasource;
3. Try {
4. Context = new initialcontext();
5.
1. Datasource = (datasource) context
2. .lookup("java:/comp/env/jdbc/mis-conexiones");
3. } catch (namingexception e) {
4. Throw new servletexception("Problema en la configuración");
5. }
6. Try {
7. Connection connection = datasource.getconnection();
8. // ...
9. Connection.close();
10. } catch (sqlexception e) {
11. Throw new servletexception("No se pudo obtener una conexión");
12. }
13.
Try {
Context.close();
} catch (namingexception e) {
// ignore
}
Si sutituímos la línea que contiene los puntos suspensivos por código que haga algo
más interesante con la conexión, podemos devolver un JSON con el array de nombres
que haya en una tabla:
Package org.fao.unredd.portal;
Import java.io.ioexception;
Import java.sql.Connection;
Import java.sql.resultset;
Import java.sql.sqlexception;
Import java.sql.Statement;
Import java.util.arraylist;
Import javax.naming.initialcontext;
Import javax.naming.namingexception;
Import javax.servlet.servletexception;
Import javax.servlet.http.httpservlet;
Import javax.servlet.http.httpservletrequest;
Import javax.servlet.http.httpservletresponse;
Import javax.sql.datasource;
Import net.sf.json.jsonserializer;
Public class exampledbservlet extends httpservlet {
Private static final long serialversionuid = 1L;
@Override
Protected void doget(httpservletrequest req, httpservletresponse resp)
Throws servletexception, ioexception {
Initialcontext context;
Datasource datasource;
Try {
Context = new initialcontext();
Datasource = (datasource) context
.lookup("java:/comp/env/jdbc/mis-conexiones");
} catch (namingexception e) {
Throw new servletexception("Problema en la configuración");
}
Arraylist<String> provincias = new arraylist<String>();
Try {
Connection connection = datasource.getconnection();
Statement statement = connection.createstatement();
Resultset result = statement
.executequery("SELECT name_1 FROM gis.arg_adm1");
While (result.next()) {
Provincias.add(result.getstring("name_1"));
}
Resp.setcontenttype("application/json");
Jsonserializer.tojson(provincias).write(resp.getwriter());
Connection.close();
} catch (sqlexception e) {
Throw new servletexception("No se pudo obtener una conexión", e);
}
Try {
Context.close();
} catch (namingexception e) {
Throw new servletexception("No se pudo liberar el recurso");
}
}
}
Para conectar Java con MySQL es fácil, solo tienes que seguir unos sencillos pasos.
Paso 1. Necesitas el JDBC driver de MySQL. Puedes descargarlo en el siguiente
enlace aquí. Si estás usando Windows, asegúrate de descargar la versión que está en
ZIP.
Paso 2. Debes agregar el JDBC que es un archivo .jar a tu proyecto, es decir, al
Build-Path de tu proyecto. Si estás usando Eclipse, puedes agregar el archivo haciendo
clic con el botón derecho en el nombre de tu Proyecto > Build Path > Configure Build
Path. En la pestaña Libraries, haces clic en Add Jars si el archivo lo copiaste a la
carpeta de tu proyecto o en Add External JARs si tienes el archivo en otro directorio de
tu computadora. Luego, haces clic en el botón inferior que dice Apply and Close.
Paso 3. Debes crear una clase con un nombre distintivo, ejemplo ConexionMySQL.
Esta clase se verá de la siguiente manera (he comentado cada línea para que
entiendas):
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConexionMySQL {
// Librería de MySQL
public String driver = "com.mysql.jdbc.Driver";
// Nombre de la base de datos
public String database = "databasemovies";
// Host
public String hostname = "localhost";
// Puerto
public String port = "3306";
// Ruta de nuestra base de datos (desactivamos el uso de SSL con "?useSSL=false")
public String url = "jdbc:mysql://" + hostname + ":" + port + "/" + database + "?useSSL=false";
// Nombre de usuario
public String username = "root";
// Clave de usuario
public String password = "123456789";
public Connection conectarMySQL() {
Connection conn = null;
try {
Class.forName(driver);
conn = DriverManager.getConnection(url, username, password);
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
return conn;
}
}
Paso 4. Otra clase donde harás INSERT, UPDATE, DELETE, etc...
Por ejemplo, tenemos una clase llamada Insertar, en ella tendrás lo siguiente:
// Instancias la clase que hemos creado anteriormente
private ConexionMySQL SQL = new ConexionMySQL();
// Llamas al método que tiene la clase y te devuelve una conexión
private Connection conn = SQL.conectarMySQL();
// Query que usarás para hacer lo que necesites
private String sSQL = "";
Ejemplo, cómo hago INSERT?. Debes hacer uso de esto:
// Query
sSQL = "INSERT INTO USERS (first_name, last_name) VALUES (?, ?)";
// PreparedStatement
PreparedStatement pstm = conn.prepareStatement(sSQL);
Referencias
https://es.stackoverflow.com/questions/138638/conectar-java-con-mysql
https://www.ibm.com/docs/es/product-master/12.0.0?topic=code-java-api
https://clasesdeinformaticaweb.com/cursos/programacion-informatica/java/java-con-bas
es-de-datos/
https://decodigo.com/java-conexion-a-base-de-datos-con-jdbc
https://www.youtube.com/watch?v=wpQjmEZjdiY
https://www.youtube.com/watch?v=CYIctabCNbw
https://snmb-desarrollo.readthedocs.io/en/develop/howtos/database-connection.html
https://clasesdeinformaticaweb.com/cursos/programacion-informatica/java/java-con-bas
es-de-datos/
