Programa que se conecta a una base de datos ya creada usando este mismo IDE.Para empezar, debe tener instalado NetBeans 5.0 y haber descargado el conector Java.
1. Primer
o crearemos un proyecto normal (Java application)2. Abrimos el manejador de bibliotecas. Menu Tools -> Library Manager
3. Nos aparecera el cuadro de dialogo Library Manager. Ahora debemos dar de alta una nueva biblioteca dando click en New Library...
4. En el cuadro que nos aparece, debemos llenarlo de la siguiente forma: Library Name: MySQL (no puede tener espacios)Library Type: Class LibrariesClick en el boton OK
5. Ahora debemos agregar unos detalles a la biblioteca. Asegurece que la nueva biblioteca creada este seleccionada (izquierda).
6. Seleccionamos la pestaña Class Path y damos clic en el botón Add JAR/Folder...
7. Se abre un dialogo llamado Browse JAR/Folder que permite seleccionar archivos. Buscamos el jar descargado para conectarnos a MySQL (mysql-3.1.11.jar) los seleccionamos y damos click en el boton Add JAR/Folder
8. Aparecera en la sección Class Path el archivo que acabamos de agregar, damos clic en Ok del cuadro de dialogo Library Manager.
9. Ahora debemos agregar la librería al proyecto. Dentro del proyecto (explorador del proyecto) seleccionar el nodo Libraries. Dar click derecho para mostrar el menu contextual
o Seleccionar opción Add Library
o Seleccionar de la lista, la biblioteca recien creada con el nombre MySQL
Debe aparecer como una nueva entrada dentro del nodo Libraries
Podemos escribir el siguiente programa para verificar que todo funciona.
import java.sql.*;
public class TestConnection{
static String bd = "tu_BD";
static String login = "usuario";
static String password = "contraseña";
static String url = "jdbc:mysql://localhost/"+bd;
public static void main(String[] args) throws Exception{
Connection conn = null;
try{
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection(url,login,password);
if (conn != null){
System.out.println("Conexión a base de datos "+url+" ... Ok");conn.close();}}
catch(SQLException ex){System.out.println("Hubo un problema al intentar conectarse con la base de datos "+url);
}catch(ClassNotFoundException ex){
System.out.println(ex);
}
}
}
Deberá aparecer onexión a base de datos "+url+" ... Ok
http://diario-de-un-programador.blogspot.com/2006/10/conectar-java-con-mysql-en-netbeans.html
JAVA CON ACCES
JDBC y ODBC
La capacidad para acceder a bases de datos desde Java la ofrece la API JDBC (Java DataBase Conectivity).
JDBC es un estándar para manejar bases de datos en Java. ODBC es un estándar de Windows para manejar bases de datos, de forma que cualquier programa en Windows que desee acceder a bases de datos genéricas debe usar este estándar.
La necesidad de crear un estándar propio para acceder a bases de datos desde Java se explica porque el estándar ODBC está programado en C y un programa que use este estándar, por lo tanto, depende de la plataforma.
Controladores JDBC-ODBC
Necesitamos acceder a un origren de datos ODBC pero contamos con una API que usa el estándar JDBC. Para solventar este problema las empresas realizan drivers que traducen el ODBC a JDBC. Hay varios tipos de Driver, pero para nuestro ejemplo usaremos los llamados puentes JDBC-ODBC. JDK de Windows incorpora el driver necesario para conectar bases de datos Access.
Crear un nuevo DSN (Data Source Name)Para realizar la conexión a una base de datos ODBC necesitaremos crear un perfil DSN desde el panel de control y posteriormente accederemos a la base de datos a partir del nombre del perfil. En el perfil DSN lo que se hace es indicar el driver a utilizar, así como el archivo o archivos del origen de datos. Estos son los pasos a llevar a cabo para configurar un perfil DSN.
1.- Iremos a Panel de Control. Ello se hace desde Inicio->Configuración o desde MiPC.
2.- Ahora hacemos doble-click en el icono de Fuentes de datos ODBC (32 bits).
3.- En nuestra pantalla aparecerá ahora la pestaña DSN usuario seleccionada. Para crear un nuevo perfil haremos click en Agregar...
4.- A continuación se nos pide que ingresemos el controlador que vamos a usar en el nuevo perfil. En nuestro caso será Microsoft Access Driver (*.mdb).
5.- Una vez aquí sólo nos queda dar un nombre al origen de datos y especificar el archivo .mdb de origen. Tras aceptar la ventana ya tenemos creado un perfil con lo que ya podemos comenzar a programar.
Clases, objetos y métodos básicos. Lo que necesitamos para hacer nuestro programa es la API JDBC incluida en la última versión del JDK.
El paquete a utilizar y el cual deberemos importar es el paquete java.sql Las primeras líneas de código suelen ser rutinarias ya que siempre serán muy similares. Cargar el DriverLo primero es hacer una llamada al Driver JDBC-ODBC para cargarlo.
Eso se consigue con las siguientes líneas de código:
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}
catch(Exception e){
System.out.println("No se ha podido cargar el Driver JDBC-ODBC");
}
Con esto ya tenemos cargado el Driver. Ahora básicamente trabajaremos con tres objetos. Estos objetos son: Connection, Statement y ResultSet. El objeto Connection se obtiene al realizar la conexión a la base de datos. El objeto Statement se crea a partir del anterior y nos permite ejecutar SQL para hacer consultas o modificaciones en la base de datos. En caso de hacer una consulta (SELECT ... FROM ...) se nos devolverá un objeto que representa los datos que deseamos consultar; este objeto es un objeto ResultSet (Hoja de resultados). El objeto ConnectionDebemos realizar la conexión a nuestro origen de datos. Para ello debemos crear un objeto Connection de la siguiente forma:
Connection con = DriverManager.getConnection("jdbc:odbc:Nombre_Perfil_DSN", "Nombre_Usuario", "Contraseña");
Los dos últimos parámetros pueden ser cadenas vacías "" a no ser que la base de datos las requiera.
Con esto ya hemos realizado una conexión a nuestra base de datos. Pero esto todavía no es suficiente. Ahora vamos a crear un objeto Statement con el que podremos ejecutar y hacer consultas SQL. Si hasta ahora todo ha sido rutinario a partir de ahora vamos a poder crear código más adaptado a las necesidades de nuestro programa. El objeto StatementComo se ha dicho, un objeto Statement se crea a partir del objeto Connection antes obtenido. También como se ha dicho un objeto Statement nos permite hacer consultas SQL que nos devuelven una hoja de resultados. Pues bien, según como deseamos que sea esa hoja de resultados (modificable, o no, sensible a las modificaciones o no,...) deberemos crear de una forma u otra el objeto Statement. Más adelante se explican las diferencias entre crearlos de una u otra forma. De momento nos limitaremos ha hacerlo de la forma más sencilla. Statement stat = con.createStatement(); De esta forma muy simple hemos creado un objeto Statement.
Ahora podemos usar este objeto Statement para hacer modificaciones en la base de datos a través del lenguaje SQL. Para realizar modificaciones, es decir, instrucciones INSERT, UPDATE o DELETE, se usa el método executeUpdate pasando como parámetro una cadena de texto String que contenga la instrucción SQL.
Para hacer una consulta, es decir, una instrucción SELECT debemos usar otro método: el método executeQuery que como el anterior se le ha de pasar un String que contenga la instrucción. Este método nos devuelve un objeto ResultSet que contiene los datos obtenidos. Este objeto será diferente según como hayamos creado el objeto Statement. En el ejemplo anterior hemos usado un método muy simple de Connection para crear el objeto Statement, pero hay otras formas de crearlo. Estas son y estas son las características que aportan a la hoja de resultados de una consulta: El método anteriormente utilizado es el siguiente:
createStatement(), pero existe el mismo método al que le podemos pasar dos parámetros. En la documentación se expresa así: createStatement(int resultSetType, int resultSetConcurrency). Los posibles valores a pasar son campos de la clase ResultSet. Por ejemplo para el parámetro resultSetType podemos elegir que el objeto ResultSet se pueda mover (entre registros) sólo hacia delante (ResultSet.TYPE_FORWARD_ONLY), que se pueda mover pero que cuando se actualice, aunque los cambios ya hayan sido reflejados en la base de datos, el ResultSet no los 'sienta' (ResultSet.TYPE_SCROLL_INSENSITIVE) o que se pueda mover y que los cambios si que se reflejen también en él (ResultSet.TYPE_SCROLL_SENSITIVE). Para el parámetro resultSetConcurrency podemos establecer dos valores diferentes:
ResultSet.CONCUR_READ_ONLY si queremos que los datos se puedan leer pero no actualizar, y ResultSet.CONCUR_UPDATABLE si queremos permitir que la base de datos sea actualizable mediante el objeto ResultSet. Si no se usa el método sin parámetros el objeto será TYPE_FORWARD_ONLY y CONCUR_READ_ONLY. El objeto ResultSet: Hoja de resultadosMoverse por la hoja de resultados Al hablar de posición del cursor nos referimos a la posición dentro de los datos del objeto ResultSet. Lo primero que hay que saber es que el cursor tiene tantas posiciones como filas tenga la consulta y dos más que se sitúan antes de la primera fila y después de la última. Nada más crear un objeto ResultSet, la posición del cursor es la anterior a la primera fila. Para mover el cursor a la posición siguiente usaremos el método next() que nos devuelve una variable booleana: sí, si se ha podido mover; no, si no ha sido posible el desplazamiento.
Nos devolverá false si estamos en el útimo registro (el posterior al último). Para movernos hacia atrás tenemos un método muy similar: el método previous() que al igual que el anterior nos devuelve un valor booleano que será false si estamos en el registro anterior al primero. Estos métodos nos permiten movernos de forma relativa por la hoja de resultados; si deseamos movernos a un registro determinado usaremos el método absolute(int numero_fila), que también nos devuelve un valor boolean. Además tenemos otros métodos que son: afterLast(), que mueve el cursor a la fila posterior a la última; beforeFirst() que mueve el cursor a la fila anterior a la primera; last() que mueve el cursor a la última fila; first() que mueve el cursor a la primera fila. Todos ellos devuelven un valor booleano. Obtener datos de la hoja de resultados Para acceder a los datos de la hoja de resultados usamos los métodos get...(int numeroColumna) o get...(String nombreColumna). Estos métodos nos devuelven el valor que indica el nombre del método (por ejemplo tenemos: getString, getInt, getDate, ...) indicando el número o el nombre de la columna. Hay que tener en cuenta que el número de columna es el número de columna en la hoja de resultados y por tanto se establece con el orden en el que se han incluido las columnas en la instrucción SELECT. Por ejemplo si hemos hecho la consulta de la siguiente forma:
SELECT Nombre, Apellidos ... la columna Nombre será la primera y la columna Apellidos será la segunda independientemente de cómo estén situadas en la base de datos.
Si hacemos un SELECT * FROM ..., en ese caso las columnas estarán en el orden en el que están en la base de datos. Modificar la base de datos con el objeto ResultSet Hemos dicho que mediante el objeto Statement podemos ejecutar sentencias SQL para modificar la base de datos y hacer consultas, por lo que podemos usar el lenguaje SQL para hacer cualquier operación en la base de datos; pero además tenemos métodos especializados que nos permiten hacer estas mismas tareas sin usar el lenguaje SQL.
Para ello se usan los métodos especializados del objeto ResultSet. Por tanto si deseamos modificar la base de datos a través de Java, sin utilizar SQL, lo primero que deberemos hacer es realizar una consulta SQL para obtener el objeto ResultSet (parece un poco paradógico). Ahora sólo nos queda usar los métodos especializados de este objeto. Por ejemplo podemos usar deleteRow() para borrar una fila. Para actualizar una fila se usan los métodos update...(NombreColumna, valor) o update...(NumeroColumna, valor), así podemos encontrar updateFloat, updateString, ... Para que los cambios se reflejen en la base de datos se debe llamar al método updateRow() o cancelRowUpdates() si queremos cancelar la actualización. resultset.updateString("Nombre", "PEPE");resultset.updateRow(); Para insertar una fila nos hemos de mover a un lugar del cursor especial con el método toInsertRow(), una vez allí usaremos los métodos update... explicados antes y para reflejar esta actualización llamar al método insertRow().
http://www.mygnet.net/articulos/java/298/
ORACLE CON JAVA
¿Que es JDBC y para que se utiliza?
JDBC es la interfaz que proporciona Java para la conexión a bases de datos. Son un conjunto de clases e interfaces que permiten a Java ejecutar consultas y ordenes en una bases de datos.
Para poder conectar a Java con ORACLE lo primero que necesitamos es la implementación de JDBC para ORACLE. Esta implementación se encuentra en el archivo Classes12.jar que podemos encontrar en el siguiente directorio del servidor de Oracle.
%ORACLE_HOME%\jdbc\lib
ORACLE_HOME es una variable de entorno que se crea durante la instalación del servidor ORACLE, y que indica donde está instalado fisicamente ORACLE dentro del sistema de archivos, normalmente C:\oracle\ora92 para servidores Windows y ORACLE 9i. Esta misma nomenclatura se aplica al hablar de la instalación cliente.
Debemos configurar correctamente nuestra variable CLASSPATH para incluir en ella el archivo Classes12.jar.
Oracle proporciona los siguientes drivers en su implementacion JDBC:
· JDBC Thin Driver: No requiere de la instalación cliente de ORACLE. Ideal para Applets.
· JDBC OCI :API nativa de ORACLE, para aplicaciones J2EE.
· JDBC KPRB driver: (default connection) para Java Stored Procedures y Database JSP's.
Todos los drivers soportan la misma sintaxis y funcionalidad, por lo que nuestro código variará únicamente en la forma de crear la conexion.
Conectar a ORACLE con JDBC Thin Driver
El driver JDBC Thin se conecta y comunica con ORACLE a nivel de sockets. Proporciona su propia versión del protocolo Net8 (SQL*Net) sobre TCP/IP, por lo que no es necesario que exista una instalación de la parte cliente de ORACLE. Dado que este driver es código 100% Java es completamente independiente de la plataforma de ejecución, y como implementa su propia versión del protocolo es ideal para aplicaciones que se ejecutan sobre un navegador Web (applets)
import java.sql.*;
class dbAccess {
public static void main (String args []) throws SQLException {
DriverManager.registerDriver (new oracle.jdbc.driver.OracleDriver());
Connection conn = DriverManager.getConnection ("jdbc:oracle:thin:@WIN01:1521:oracleBD", "user", "passw");
// driver@machineName:port:SID , userid, password
Statement stmt = conn.createStatement();
ResultSet rset = stmt.executeQuery("select BANNER from SYS.V_$VERSION");
while (rset.next()) System.out.println (rset.getString(1));
// Print col 1 stmt.close();
}
}
Conectar a ORACLE con JDBC OCI Driver
El driver JDBC OCI usa el API ORACLE OCI (Oracle Call Interface) para interactuar con ORACLE, por lo que es necesaria la instalación y configuración de la parte cliente de ORACLE. El driver OCI trabaja con SQL*Net o Net8, por lo que tamdebemos haber creado un alias en el archivo TNS names (%ORACLE_HOME%\network\ADMIN):
ORACLEBD =
(DESCRIPTION =
(ADDRESS_LIST = (ADDRESS = (PROTOCOL = TCP)(HOST = WIN01)(PORT = 1521))
)
(CONNECT_DATA = (SERVICE_NAME = ORACLEBD)
)
)
El driver JDBC OCI permite realizar llamadas a ORACLE OCI directamente desde Java proporcionandoun alto grado de compatibilidad con una versión específica de ORACLE utilizando métodos nativos, pero específicos de la plataforma.
import java.sql.*;
class dbAccess {
public static void main (String args []) throws SQLException {
try {
Class.forName ("oracle.jdbc.driver.OracleDriver");
}
catch (ClassNotFoundException e) {
e.printStackTrace();
}
Connection conn = DriverManager.getConnection
("jdbc:oracle:oci:@ORACLEBD", "user", "passw");
// @TNSNames_Entry, userid, password
Statement stmt = conn.createStatement();
ResultSet rset = stmt.executeQuery("select BANNER from SYS.V_$VERSION");
while (rset.next()) System.out.println (rset.getString(1));
// Print col 1 stmt.close();
}
}
Conectar a ORACLE con JDBC KPRB Driver
Por último el driver ORACLE JDBC KPRB es utilizado para escribir en Java procedimientos almacenados, funciones, triggers ... Ofrece acceso a la conexion activa por lo que no es necesario crear ninguna conexión adicional.
El driver JDBC KPRB de ORACLE permite obtener un handle de la conexion actual del contexto a través del método OracleDriver.defaultConenction(). Como hemos dicho, se utiliza para procedimientos almacenados, triggers .... Para ejecutar un procedimiento almacenado debemos estar conectados a ORACLE a través de una herramienta cliente como SQL*Plus., lo que hacemos con defaultConenction() es acceder a está conexion.
CREATE OR REPLACE AND COMPILE JAVA SOURCE NAMED BANNER AS
import java.sql.*;
class dbAccess{
public static String showBanner() throws SQLException {
String banner="";
Connection conn = (new oracle.jdbc.driver.OracleDriver()).defaultConnection();
Statement stmt = conn.createStatement();
ResultSet rset = stmt.executeQuery("select BANNER from SYS.V_$VERSION");
while (rset.next()) banner += rset.getString(1);
//stmt.close();
NO CERRAR LA CONEXION return banner;
}
}
Es necesario crear un "wrapper" para poder ejecutar el programa desde PL/SQL o SQL.
CREATE OR REPLACE FUNCTION ShowBanner
RETURN VARCHAR2
IS
LANGUAGE JAVA NAME 'dbAccess.showBanner() return java.lang.String';
Una vez hecho esto, podemos ejecutar la función como si se tratase de una función PL/SQL.
SELECT ShowBanner FROM DUAL;
http://www.devjoker.com/asp/ver_contenidos.aspx?co_contenido=132
JAVA CON SQL SERVER
Usar el controlador JDBC
En esta sección se proporciona una serie de instrucciones rápidas para establecer una conexión sencilla a una base de datos de SQL Server con el controlador JDBC de Microsoft SQL Server 2005. Antes de establecer la conexión a una base de datos de SQL Server, SQL Server se debe instalar en el equipo local o en un servidor y el controlador JDBC se debe instalar en el equipo local.
Establecer ruta de clase:
El controlador JDBC no forma parte del SDK de Java. Por consiguiente, debe establecer la ruta de clase para que incluya el archivo sqljdbc.jar si desea usarlo. Si en la ruta de clase falta una entrada para sqljdbc.jar, la aplicación genera la excepción común "Clase no encontrada".
El archivo sqljdbc.jar se instala en la siguiente ubicación:
<directorio de instalación>\sqljdbc_<version>\<language>\sqljdbc.jar
CLASSPATH =.;C:\Program Files\Microsoft SQL Server 2005
JDBC Driver\sqljdbc_1.2\enu\sqljdbc.jar
El siguiente es un ejemplo de la instrucción CLASSPATH usada para una aplicación de Unix/Linux:
CLASSPATH =.:/home/usr1/mssqlserver2005
jdbc/Driver/sqljdbc_1.2/enu/sqljdbc.jar
Aplicaciones que se ejecutan directamente en el símbolo del sistema:
La ruta de clase se configura en el sistema operativo. Anexe sqljdbc.jar a la ruta de clase del sistema. Además, puede especificar la ruta de clase en la línea de comandos de Java que ejecuta la aplicación con la opción java -classpath .
Aplicaciones que se ejecutan en un IDE:
Cada proveedor de IDE ofrece un método distinto para establecer la ruta de clase en el IDE. Establecer sin más la ruta de clase en el sistema operativo no funciona. Debe agregar sqljdbc.jar a la ruta de clase del IDE.
Servlets y JSP:
Los servlets y JSP se ejecutan en un motor de servlet/JSP como Tomcat. La ruta de clase se debe establecer de acuerdo con la documentación del motor de servlet/JSP. Establecer sin más la ruta de clase en el sistema operativo no funciona. Algunos motores de servlet/JSP incluyen pantallas de configuración que puede utilizar para establecer la ruta de clase del motor. En este caso, debe adjuntar el archivo JAR del controlador JDBC correcto a la ruta de clase del motor y reiniciar el motor. En otras situaciones, puede configurar el controlador copiando sqljdbc.jar en un directorio específico, con extensión lib, durante la instalación del motor. La ruta de clase del controlador del motor también se puede especificar en un archivo de configuración específico del motor.
Enterprise Java Beans:
Enterprise Java Beans (EJB) se ejecuta en un contenedor EJB. Los contenedores EJB son distribuidos por varios proveedores. Los subprogramas Java se ejecutan en un explorador, pero se descargan desde un servidor web. Copie sqljdbc.jar en la raíz del servidor web y especifique el nombre del archivo JAR en la ficha de archivo HTML del subprograma.
Establecer una conexión sencilla con una base de datos:
Para establecer una conexión a una base de datos con la clase DriverManager, debe registrar primero el controlador como en el ejemplo siguiente:
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
Una vez cargado el controlador, puede establecer una conexión con una URL de conexión:
String connectionUrl = "jdbc:sqlserver://localhost:1433;" +
"databaseName=AdventureWorks;user=MyUserName;password=*****;";
Connection con = DriverManager.getConnection(connectionUrl);
Para obtener más información sobre la conexión con orígenes de datos y el uso de una URL de conexión, consulte Generar URL de conexion y Establecer las propiedades de conexion.
http://msdn2.microsoft.com/es-es/library/ms378526.aspx
JAVA CON POSTGRES
PostGres, que es un sistema de base de datos relacional que une las estructuras clásicas con los conceptos de programación orientada a objetos.
http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte21/cap21-3.html
En este mini tutorial intentaré explicar la manera en conectar nuestra aplicación hecha en JAVA con la Base de Datos de PostgreSQL.
Primero, es necesario descargarse el JDBC Driver para PostgreSQL. Este se encuentra en la página http://jdbc.postgresql.org/index.html Obviamente, será necesario contar con nuestra Base de Datos funcionando para realizar las consultas necesarias.
Posteriormente hay que determinar la manera de agregar este Driver a nuestro proyecto. NetBeans ofrece una manera mas que sencilla. Conociendo la ubicación de nuestro Driver y con el proyecto abierto, en el Panel de Proyectos, ubicamos en el Árbol de Proyecto la opción Libraries, clic Derecho en ella y seleccionamos Add JAR / Folder..., de esta manera estaremos agregando ej .JAR del Driver que descargamos. Esto nos crea en nuestro proyecto una carpeta llamada "dist" y en ella otra de nombre "lib" donde esta nuestro Driver.
Ahora, teniendo lo necesario, podemos probar nuestra conexión con PostgreSQL y realizar lo que nos concierne, Altas, Bajas y Modificaciones a nuestras tablas.
Para empezar, debemos de importar lo siguiente:
import java.sql.*;
Cabe mencionar que hay una gran diferencia entre Select y Update, Insert o Delete, ya que no se aplican de igual manera. A continuación muestro el proceso para realizar un Select (en idioma geek, vamos a selectear)
public class Main{
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/moo";
try{
//Acceso al Driver Class.forName("org.postgresql.Driver");
//La conexión con los parámetros necesarios
Connection con = DriverManager.getConnection( url,"postgres","postgres");
//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 id as ID from moo.usuarios";
//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("ID") + "\t" + rs.getString("ID"));
}
//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();
}
}
}
Para realizar todo aquello diferente a un Select, utilzaremos lo siguiente:
/*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/moo";
try{
//Acceso al Driver
Class.forName("org.postgresql.Driver");
//La conexión con los parámetros necesarios
Connection con = DriverManager.getConnection( url,"postgres","postgres");
//Abrimos la conexión y la iniciamos
Statement stmt = con.createStatement();
//Una variable String para almacenar la sentencia SQL
String query = "update moo.usuarios set nombre = 'Mauricio' where id = '1'";
//Ejecutamos la consulta SQL
stmt.executeQuery(query);
//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();
Es muy importante tener en cuenta que si este método lo utilizas en una función para hacerla llamar cuando lo necesites, y quieras enviarle tanto argumentos como retornar resultados, en la función de Select las líneas siguientes NO deben de estar presentes:
stmt.execute("END");
stmt.close();
Y en la parte de Update, Insert o Delete, solo la siguiente línea:
stmt.execute("END");
http://www.mygnet.net/articulos/java/conectando_postgresql_con_java.1162
