Clases para acceso a datos ??

[chcma]

Buenos días foreros !!!

Bueno, pues eso, estoy buscando alguna clase que me permita el acceso a bases de datos, sin tener que programar la mia.

Busco algo al estilo de la clase adodb para php, la cual me permite un ahorro de código bastante amplio. Me imagino que para JAVA habrá alguna clase que sea la que más se utilice...

En fin, si me pueden comentar de alguna les agradecería.

Saludos.

[franju]

hola,

No se si sera esto lo que buscas pero puedes echarle un ojo al hibernate.

http://www.hibernate.org/

Un saludo

Frank

[gustavoh10]

Hola, podes usar un pool de conexiones, yo nunca probe pero se que existe. Podes mirar esta URL, se llama database connection pool. Podes optimizar todo lo
referente a conexiones a la db.
Página
http://commons.apache.org/dbcp/
Ejemplos
http://svn.apache.org/viewvc/commons...bcp/trunk/doc/

sino podes hacer una simple clase que obtenga una conexion a la db y retornarla para utilizarla cuando la necesites.

Código PHP:

   
public Connection getConexion(){ 
    try { 
       Class.forName("org.postgresql.Driver"); 
    } catch (ClassNotFoundException e) { 
       System.out.println("Problemas al cargar el driver: "+e.getMessage()); 
    } 
         
     try { 
        this.conexion_hogares =  
    DriverManager.getConnection(this.url, this.user, this.pass ); 
    System.out.println("Conexion Creada!!!!"); 
    } catch (SQLException e) { 
        System.out.println("Problemas al intentar obtener la conexión: "+e.getMessage()); 
        }     
   return conexion; 
}  
   

Espero que sea lo que estas necesitando.

[pyanqn]

Clase para acceso a datos? si lo que quieres es ahorrarte tener que escribir el codigo para acceder a la BBDD, puede usar Hibernate, TopLink, etc...

Pero no te vas a librar de tener que escribir el pojo!!!

Otra que puedes hacer es usar un framework que no sé si puede satisfacer tus necesidades, pero te ahorrara escribir los mapeos, Objeto-Relacional. es netMind (http://netmind.hu/) aunque yo no lo usaría, es una buena opcion si estas iniciando en lo que es persistenacia de objetos en java. Puede que te aclare el panorama. seguramente despues, te inclines por algun otro framework como Hibernate.

Saludos

[chcma]

Haber, ya sé que debo escribir código, no quiero nada que me lo de todo hecho, pero si una clase que me evite tener que reescribir mil veces el mismo código.

Conozco Hibernate (Más bien NHibernate, que soy de .NET, jejeje) y está muy bien, pero no me refiero exactamente a eso.

Me refiero a alguna clase, tipo al Application Block de SQL Server de Microsoft. Lo que hace esta clase es darte ya los métodos de acceso a datos hechos.

Es decir, en mi capa de negocio yo podría hacer algo similar a:

Código:

public class ClsUsuariosNegocio
{
         public bool InsertarUsuario(string txtNombre, string txtApellido)
         {
                  try
                  {
                  ClsAccesoDatosJava objDatos = new ClsAccesoDatosJava("driver-proveedor");
                  ClsAccesoDatosJavaParametros objParametros = new ClsAccesoDatosJavaParametros();

                  objParametros.Add("@nombre", txtNombre);
                  objParametros.Add("@apellidos", txtApellidos);
 
                  objDatos.EjecutaSP("nombreProcedimientoAlmacenado", objParametros);

                  return true;

                  }Catch(Exception ex)
                  {
                       return false;
                  }
         }
}

Como podeis ver, lo que busco es una clase que me de ya los métodos básicos de acceso a datos, como es el ejecutar una consulta SQL de inserccion/modificacion/eliminacion, ejecutar una SQL de resultado (y que devuelva por referencia, por ejemplo, un resultset), que tenga un metodo para llamar a un procedimiento almacenado de escritura, a otro de lectura (y que devuelva otro resultset por referencia), etc...

Algo asi busco, no sé si me he explicado...



Se que podría hacer yo una clase propia, de hecho ya lo hice en su día, pero... bueno, no sé bien cual es realmente la metodología para trabajar con datos en JAVA. Yo estoy demasiado familiarizado con .NET (DataTables, DataSets, etc..) y aqui en Java quiero empezar a familiarizarme con la forma de trabajar con datos.

[pyanqn]

Bien, entiendo. No quieres un framework de persistencia.
Creo que lo mas parecido a eso puede ser trabajar con el API JDBC. Es decir tu te encargarias de escribir el codigo para recuperar meta datos, y a partir de allí inseras eliminas, y actualizas.

De todas formas, en poo y mas precisamente en java, no puedes evitar el uso de pojos, esto es programación orientada a objetos!

Ademas, te aseguro que usar un framework para que te resulva estos problemas es lo mejor, tuve la suerte de trabajar con JDBC, y es muy tedioso tener que tener en cuenta tantos controles, excepciones, y otras yerbas.

Saludos

[chcma]

Si, si lo que quiero es trabajar con un Framework. Pero que me resuelva precisamente esos problemas.

Lo de Hibernate lo veo bien aun que le veo sus inconvenientes(No lo conozco mucho asi que igual hablo desde la ignorancia). Por ejemplo, esta bien que me cree una clase con los campos de las tablas que voy a recuperar. Pero si el día de mañana resulta que en vez de 5 campos, tengo que recuperar 7, ya tengo que volver a retocar el modelo de objetos creado en Hibernate. Y seamos sinceros, laborlamente, eso pasa mucho(por desgracia).

Lo que busco es una clase pues de acceso a base de datos Sql Server, Oracle, PostgreSQL o MySQL, me da igual que sea solo para SQL Server o que sea para varios.

Vamos, me imagino que aparte de Hibernate en los proyectos grandes de acceso a datos habrá más "metodologías" sobre la forma de acceder a datos, ¿No?

Como ves en el ejemplo, pyanqn, todo lo tedioso de JDBC es lo que espero que me haga la clase, en este caso la ficitcia "ClsAccesoDatosJava". Que me de ya unos metodos para llamar a procedimientos almacenados, metodos para ejecutar consultas sql a pelo y cosas asi.

[pyanqn]

bueno, entonces podrías ver de usar JDBC, el acceso a los datos deberias hacerlo por medio de metadatos, JDBC, te permitira resuperar estos metadatos, así me imagino podrias

generar tu consulta, digamos un select *; el resultado de la consulta estara dentro de un recordSet, es un objeto similar en concepto a un dataSet de visualBasic.

Con el resultado de la consulta deberias recuperar tambien los metadatos de la tabla e iterar por las columnas e ir recuperando a su vez el valor almacenado (que esta en el resultSet), finalmente construir un Map<nombre_columna,valor> y retornar este map al hacer una consulta cualquiera. O es mas valor puede ser un objeto que te informe ademas, el tipo del dato que contiene.

De esta forma podrias agregar mas columnas a tus tablas, y tu aplicación las reconoceria de inmediato.

[djagu_26]

Podrias utilizar EJB3 te lo aconsejo es muy sencillo y utilza JPA, yo he utilizado Hibernate es muy bueno como framework pero muy tedioso hacer los mapeos de xml, otro es Cayenne es muy sencillo usas el Cayenne Modeler te creas la bd y el te genera las clases el unico inconveniete que tiene es q es muy dificil de implementar la herencia y en otro caso si piensas en una bd orientada a objeto puedes utilzar db4o es super facil lo mas complicado son las consultas
salduos

[lfleon]

Saludos chcma ... Yo tambien estoy en la busqueda de una "metodologia" ... de una forma que conectar a mis bases de datos para manipularlas dentro de un proyecto.

Estoy iniciandome un poco en Java y probe con JDBC ... y todo me funciono bien, excepto al momento de crear consultar con varias tablas relacionadas y llevarlas a un ResultSet ... Como se haria en este caso para actualizar la Base de Datos ? El ResultSet creo que no me permite actualizar tablas en ese caso o si alguna manera ? ... En ese caso se deberia manejar con INSERT o UPDATE de sentencias SQL ? ...

Me gustaria saber un poco tus comentarios al respecto y que has podido concluir en tu busqueda de un metodo para acceso a datos ... Te agradeceria mucho la informacion que me puedas proporcionar.

Gracias ... Luis

[chcma]

Hola amigo,

Bueno, yo vengo de .NET, por lo que mi forma de pensar, por lo que he visto, es totalmente diferente a los de JAVA (En el tema de acceso a datos).

Mientras que en .NET tenemos las clases DataTable, DataSet, DataRow, etc... aqui en Java se carece de todo eso, que en mi opinión no estaría nada mal que tuvieran algo similar.

Te muestro el código de una clase que me hice para ir probando un poco el acceso a datos. Te voy a mostrar tres códigos. La capa de acceso a datos (Que es para mysql), la capa de negocio y la capa de presentacion.

Son pruebas que estoy haciendo, pero espero te oriente algo... cualquier cosa me comentas y seguimos hablando por aqui e intercambiando opiniones.


Clase de acceso a datos

Código:

import java.util.*;
import java.sql.*;

public class accesoBD {
	private String _cadenaCN, _usuarioBD, _claveBD;

	private Connection objCN;

	
//Constructores
	public accesoBD(){
		try{
			Class.forName("com.mysql.jdbc.Driver").newInstance();			
		}catch(Exception ex){
			System.out.println(ex);
		}
	}
	public accesoBD(String cadCn, String  usuarioBD, String claveBD){
		_cadenaCN = cadCn;
		_usuarioBD = usuarioBD;
		_claveBD = claveBD;
		try{
			Class.forName("com.mysql.jdbc.Driver").newInstance();
		}catch(Exception ex){
			System.out.println(ex);
		}
	}
	
	
	
// *** PROPIEDADES *** //
	public void set_cadenaCn(String cadCn){
		_cadenaCN = cadCn;
	}
	public String get_cadenaCn(){	
		return _cadenaCN;
	}
	
	public void set_usuarioBd(String usuarioBd){
		_usuarioBD = usuarioBd;
	}
	public String get_usuarioBd(){	
		return _usuarioBD;
	}
	
	public void set_claveBd(String claveBd){
		_claveBD = claveBd;
	}
	public String get_claveBd(){	
		return _claveBD;
	}
	
	
	// ******  FUNCIONES  ***//////
	public boolean realizarCN(){
		try{
			objCN = DriverManager.getConnection(_cadenaCN, _usuarioBD, _claveBD);
			return true;
		}catch(Exception Ex){
			System.out.println(Ex);
			return false;
		}		
	}
	public void cerrarCN(){
		try{
			objCN.close();
		}catch(Exception Ex){
			System.out.println(Ex);
		}
	}


	public boolean insertaSentencia(String tabla, Vector parametros){
		try{
			String cadCampos="", cadValores="";
			//Rellenar Cadenas
			int i=0;


			for(i=0; i < parametros.size(); i++){
				cadCampos += ((claseParametro)parametros.elementAt(i)).get_campo()+ ",";
				if(((claseParametro)parametros.elementAt(i)).get_tipo()=="string"){
					cadValores += "'" + ((claseParametro)parametros.elementAt(i)).get_valor()+ "',";	
				}else{
					//podria hacer +. comprobaciones, como si el dato está vacio.
					cadValores += ((claseParametro)parametros.elementAt(i)).get_valor()+ ",";
				}
			}
			//Quitamos la última ,
			cadCampos = cadCampos.substring(0, cadCampos.length()-1);
			cadValores = cadValores.substring(0, cadValores.length()-1);
			
			Statement s = objCN.createStatement();
			s.execute("insert into " + tabla + " (" + cadCampos + ") values(" + cadValores + ")");
			
			return true;
		}catch(Exception ex){
			System.out.println(ex);
			return false;			
		}
	}

	
	private ResultSet objRS;
	private Statement objSql;
	public String[][] devuelveSentencia(String sentenciaSQL){

		int contCampos, contRegistros;
		String datosSQL[][];
	
		try{
			objSql = objCN.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
                    							ResultSet.CONCUR_UPDATABLE);
			objRS =  objSql.executeQuery(sentenciaSQL);
			//Para Recuperar los datos de la estructura de la tabla.
			ResultSetMetaData objMD = objRS.getMetaData();
			contCampos = objMD.getColumnCount();
			
			
			contRegistros = 3;//objRS.getRow()+2; //+1 3
			datosSQL = new String[contRegistros][contCampos];
			
			
			try{
				//Meto los datos en el Array
				int j=0;
				while(objRS.next()){
					for(int i=1; i<contCampos; i++){
						datosSQL[j][i]=objRS.getString(i).toString();
					}
					j++;
				}				
			}catch(Exception exx){
				System.out.println("FALLA AQUI" + exx);
				return null;
			}
			
		
						
			cerrarCN();
			return datosSQL;
		}catch(Exception ex){
			return null;
		}
	}
	
}

CAPA DE NEGOCIO

Código:

import java.util.*;

public class claseNegocio {
	accesoBD objBD;
	Vector parametros;
	
	public boolean insertarEmpleado(String tabla, String nombre, String apellidos, 
					String dni, String nacimiento, String departamento,
					String sueldo){
			
		
		parametros = new Vector();
		parametros.add(new claseParametro("nombre", nombre, "string"));
		parametros.add(new claseParametro("apellidos", apellidos, "string"));
		parametros.add(new claseParametro("dni", dni, "string"));
		parametros.add(new claseParametro("nacimiento", nacimiento, "string"));
		parametros.add(new claseParametro("departamento", departamento, "int"));
		parametros.add(new claseParametro("sueldo", sueldo, "string"));
		
		
		if(objBD == null){
			objBD = new accesoBD("jdbc:mysql://localhost/bdempresa", "root", "1982norma");
		}
		if (!objBD.realizarCN()){
			return false;
		}
		if (!objBD.insertaSentencia(tabla, parametros)){
			return false;
		}
		
		return true;
	}
	
	
	public String[][] mostrarEmpleados(String sentenciaSQL){
		String tbDatos[][];
		
		if(objBD == null){
			objBD = new accesoBD("jdbc:mysql://localhost/bdempresa", "root", "1982norma");
		}
		if (!objBD.realizarCN()){
			return null;
		}
		
		tbDatos = objBD.devuelveSentencia(sentenciaSQL);
		return tbDatos;
	}
	
}

CAPA PRESENTACION

Código:

import java.util.*;
import java.sql.*;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Vector;

public class clasePresentacion {
	private static int opcion=9;
	private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	private static claseNegocio objNegocio = new claseNegocio();
	
	
	private static String nombre, apellidos, dni, nacimiento, sueldo, departamento;
	public static void main(String args[]){
		try{
			while( opcion!=0 ){
				muestraMenu();
				opcion = Integer.parseInt(br.readLine());
				System.out.println("\n\n\n");
				ejecutaOpcion();
				
			}	
		}catch(Exception ex){
			System.out.println(ex);
		}
	}
	
	
	private static void muestraMenu(){
		System.out.println("*********************************");
		System.out.println("*   1-. Insertar Empleado.      *");
		System.out.println("*   2-. Modificar Empleado.     *");
		System.out.println("*   4-. Mostrar Empleados BD.   *");
		System.out.println("*   0-. Salir                   *");
		System.out.println("*********************************");
		System.out.println("\n\nIntroducir Opción: ");
	}


	private static void ejecutaOpcion() throws Exception{
		switch(opcion){
			case 1:
				System.out.println("\nIntroduce Nombre:");
				nombre = br.readLine();
				System.out.println("\nIntroduce Apellidos:");
				apellidos = br.readLine();
				System.out.println("\nIntroduce Dni:");
				dni = br.readLine();
				System.out.println("\nIntroduce Nacimiento:");
				nacimiento = br.readLine();
				System.out.println("\nIntroduce Departamento:");
				departamento = br.readLine();
				System.out.println("\nIntroduce Sueldo:");
				sueldo = br.readLine();
				if (objNegocio.insertarEmpleado("templeados", nombre, apellidos, dni,
											 nacimiento, departamento, sueldo)){
					System.out.println("\n\n\n \" USUARIO INSERTADO \" \n\n\n");
				}
				break;
				
				
			case 4:
				String tbDatos[][];
				tbDatos = objNegocio.mostrarEmpleados("select * from templeados");
				int i, j;
				for(i=0; i<tbDatos.length-1; i++){
					for(j=1; j<tbDatos[i].length; j++){
						System.out.println(tbDatos[i][j]);
					}
					System.out.println("\n\n");
				}
				 
				//System.out.println(rs.getArray(1).toString());
		}
	}
}

CLASE ADICIONAL

Código:

public class claseParametro {	
	private String _campo, _valor, _tipo;
	
	
	public claseParametro(String campo, String valor, String tipo){
		_campo = campo;
		_valor = valor;	
		_tipo = tipo;
	}
	
	
	
	// ***  PROPIEDADES  ***
	public void set_campo(String campo){
		_campo = campo;
	}
	public String get_campo(){
		return _campo;
	}
	
	
	
	public void set_valor(String valor){
		_valor = valor;
	}
	public String get_valor(){
		return _valor;
	}
		
	
	
	public void set_tipo(String tipo){
		_valor = tipo;
	}
	public String get_tipo(){
		return _tipo;		
	}
}

Te explico:

La capa de acceso a datos, se supone que hará la conexión y ejecución primitiva a la base de datos.

La capa de negocio es donde implementamos los métodos de conseguir datos, o insertar datos para una tabla especifica, dejando la tarea de los INSERT a la capa de acceso a datos. De este metodo, si cambiamos de servidor de BD con cambiar la capa de acceso a datos lo tendriamos resuelto.

La capa de presentación es donde usamos la capa de negocio.

La clase adicional que meti, es una clase "sucia" en la cual sirve como contenedora de los parametros que se pasarán a los procedimientos almacenados o consultas de la clase de acceso a datos.

Hechale un ojo, estudialo y luego si te parece hablamos.

Un saludo.

[GreenEyed]

Lo de la separacion por capas/niveles está tambien muy presente en Java, lo único es que en la parte de Java se tiende más a tener detectados los errores en tiempo de compilacion, y por eso la mayor parte de las librerias de mapeo objeto-relacional hacen que declares una clase con sus campos etc. equivalente a la tabla.

Si realizas modificaciones en la tabla, hay que cambiar esa clase, cierto, pero si haces como yo o muchos otros que generamos automaticamente la clase a partir de la defincion de la BDD, pues no es tan traumatico .
Sería interesante un equivalente en Java, para tener las dos opciones, y parece que estan en camino de hacerlo parte de la especificacion JEE bajo el nombre de Service Data Object (SDO).

Otra opcion es usar algo mas dinamico estilo Groovy o JRuby que tienen cosas mas parecidas.
S!

[GreenEyed]

Buscando otra cosa, me acabo de encontrar con una libreria que parece intentar hacer eso, aunque no sea todavia estandar, que son los DynaBeans de l proyecto Jakarta Commons BeanUtils.

http://sujitpal.blogspot.com/2006/07...dynabeans.html

Por si te sirven.
S!