Mensajes

si la uncia función es validar entonces solo de ves usar expresones regulares

lee el api de jdbc

busca como usar jdbc ese tema esta en cualquier todos los libros de programacion java solo tienes que leerlo

crear primero programas que te muestren los resultados sin gui sin nada para que sepas realmente como funciona jdbc

el ide no tiene nada que ver

antes de pedir algo primero averigua que son los requerimientos o que son las historias de usuarios y casos de aceptacion

en primer lugar tienes que decir que es exactamente lo que quieres si no lo sabes nisiquera puedes comensar

 
que yo sepa no
pero eso no tiene mucha importancia

Después de ese momento de catarsi explico mis puntos sobre cómo hacer cambios radicales

Primero que nada olvídate de crear una dependencia al sistema operativo no todos amamos la línea de comandos para todo(linuxeros) si estas obligado a tener una dependencia con algo ponla dentro de un archivo properties no el código que no se puede descompilar

Patrón adapter

Utiliza el patrón adapter cuando no quieras depender de algo digamos que quieres loguearte si quieres te puedes loguear contra un servidor ldp contra una base de datos relacional contra una base de datos no relacional usando el api de logueo de google o yo que se pero puedes usar la abstracción (pensar no hace daño) hacer algo como esto

Código (java) [Seleccionar] Expandir


public class AutentificacionLdap implements Auntenticable {

@Override
public boolean estaAutorisado(String usuario, String contraseña) {
//a qui pon el codigo con el que te autenticas

}

}


Código (java) [Seleccionar] Expandir

public class Main {

public static void main(String arg[]) {
Auntenticable auntenticable = new AutenticadorLdap();
FrmLogueo frmLogueo = new FrmLogueo(auntenticable);
//configura y muestra ventana
}

}


esoge bien los nombres

ahora eres capaz de hacer un cambio radical y cambiar de cualquier tipo de autentificación en vez de poner autenticadorLdap puedes poner cualquier tipo de autenticable como AutenticadorGoogle nota como e nombrado todo puedo hablar de las clases sin que suene raro eso y los nombre son auto explicativos obvios y lógicos es fácil de entender eso es porque la interfaz es adjetivo las clases son sustantivo nota otra ventaja ya no tengo que levantar el servidor en la nuve para correr el programa si fuera necesario puedo ponerle un autenticadle que siempre diga que si

no uses nombre complicados demasiado largos demasiado abstractos con abreviaturas o con tecnicismo pon los nombre lo mas obvios posibles


El método main no muerde

Crea toda la aplicación en único lugar centralizado el método main si es posible crea una clase que su nombre comience con aplicación como por ejemplo ApliacionVentasPlazaVea

Código (java) [Seleccionar] Expandir


public static void main(String arg[]) {
Auntenticable auntenticable = new AutenticadorLdap();
FuenteDeDatos fuenteDatos =new FuenteDeDatosJPA();
MensajeriDeErrores mensajeriDeErrores=new MensajeriaPorCorreo()

FuenteDeDatosTarjeta fuenteDeDatosTarjeta=new FuenteDatosTarjetaWebService()
ProcesadorDeTarjetasDeCredito= new ProcesadorDeTarjetasDeCredito(fuenteDeDatosTarjeta);


ForMularioPrincipal =new ForMularioPrincipal(auntenticable,mensajeriDeErrores,ProcesadorDeTarjetasDeCredito)

ApliacionDeVentas apliacionDeVentas  =new ApliacionDeVentas(ForMularioPrincipal ,arg);

apliacionDeVentas.lansar();

}


Eso si que es la panacea ahora puedo modificar la aplicación a mi gusto solo con ver el main ya sé que hace la aplicación y es mas ya se como lo hace

Programa orientado a objetos si ya se que me van a decir que es cuestión de fe pero es que tienes muchas ventajas

Donde estará el código que hace el cálculo de una factura pues en la clase factura donde estar el código que me calcula en el subtotal de una factura pues en el método subtotal de la clase factura donde estar el método que me diga cuánto vale una línea de un detalle una factura pues el método subtotal de la clase detalle factura si •"$%•$%•$ por el amor de dios pon todo en el lugar mas obvio con el nombre mas obvio

Crea tu propio manejo de errores pues si veo que hay un error pues envés de ver algo como un nullpointerexception pues veo algo como

servidorNoEncontradoEnUrlYPuerto

BaseDeDatosNoEncontrada

InposibleSacarItensDelCarritoVacio

ErrorPorFaltaDeFondos

Es tan fácil

   if(detallesCarrito.count()==0){
         throw new ExcepcionCarritoSinLineas();
      }
      detallesCarrito.remove(detalleCarrito);

Estoy harto de ver a gente que deja que el ide dicte su vida y pone cosas como

Código (java) [Seleccionar] Expandir


try {
cossasPeligrosas();
} catch (Exception e) {

}


Siempre que alguien me pide ayuda en lo que se refiere a programación me quedo asi      
veo el código y es imposible de entender y cuando digo que es difícil de entender digo que es casi imposible es en ese momento que sierro mi boca para no hacerle recordar a todo su familia por la frustración que me producen al tratar de entender lo que hacen una vez que les entiendo viene la parte mas difícil no es que quiera hablar de mi pensamiento filosófico ni dármela de genio ni nada tengo que aplicar algunas técnicas razonables casi científicas creo que la única forma de entender un problema y solucionarlo es cuestión de una abstracción y usar mi cerebro en forma lo mas razonablemente posible usar todo lo que me enseñaron en el colegio con lo que se refiere a la lógica, el método científico, el análisis es decir que es bueno desempolvar el hemisferio izquierdo
Luego me pongo a ver trato de dividir el problema en pequeñas partes independientes que se pueden probar en independientemente y comprobar pedacito por pedacito si esta bien trato de ver los síntomas pero o sorpresa eso es casi imposible

Miro el código y todo esta acoplado no puedo asegurarme de que una clase esta correcta porque ni siquiera se bajo que posible valores la clase murió

"•$"$"•$"•$   está demasiado acoplado
No puedo hacer absolutamente nada a menos que configure 3 ficheros properties 5 xml levantar un servidor web levantar una base de datos levantar un servidor ldap configurar el path de quien sabe qué y además el código solo funciona en linux por que se le ocurrió que ejecuta programas por la consola dependiente de linux con lo mucho que odio linux yo soy gek soy informático pero no lo suficiente gek para usar linux (que comience el flame)
Luego de levantar el servidor en la nube requerido para que corra el programa me doy cuenta de que si toco cualquier cosa el sistema explota y solo termino empeorando todo por tratar de "arreglarlo" "•$"•$•$%&& todo depende de todo que si hago un cambio en una clase se apaga la luz del vecino y se prende mi televisor nadie sabe porque   algunas veces me pregunto parase que usa magia negra nadie sabe cómo funciona
lo peor de todo es que el programa ni siquiera me avisa que fallo (la mayoría de bese miserablemente) y tengo que hacer una secuencia larga de pasos en el gui para reproducir el error y luego hacer otra serie de pasos largos para comprobar que hubo un error

finalmente código que veríamos en el cliente

Código (java) [Seleccionar] Expandir


package com.tiaveneno.ventas;

import javax.persistence.EntityManager;
import javax.persistence.Persistence;

import com.tiaveneno.ventas.compartido.modelo.DetalleOrden;
import com.tiaveneno.ventas.compartido.modelo.Orden;
import com.tiaveneno.ventas.compartido.modelo.Personal;
import com.tiaveneno.ventas.compartido.modelo.Plato;
import com.tiaveneno.ventas.compartido.servicio.OrderDao;
import com.tiaveneno.ventas.datos.jpa.JpaOrderDao;

public class Main {

public static void main(String[] args) {

EntityManager entityManager = Persistence. (
"jpa").createEntityManager();

OrderDao orderDao = new JpaOrderDao(entityManager);
DetalleOrden duno = new DetalleOrden((short) 1, new Plato(
"combinado fiedeos con chanfainita", 3.5));
DetalleOrden ddos = new DetalleOrden((short) 1, new Plato(
"combinado fiedeos con chanfainita", 3.5));

Orden orden = new Orden();
orden.setCajero(new Personal("cajero"));
orden.setMozo(new Personal("mozo"));

orden.detalles(duno, ddos);

orderDao.persist(orden);



}
}



Si está bien todo se guarda automáticamente en una sola transacción en caso de error hace rollback y muestra la pila por la salida estándar donde te dice la razón del error en que línea y de que clase es el error

Y me olvidaba tienes que poner un fichero de configuración en la carpeta META-INF al (costado de las clases) con el nombre de persistence.xml y agregar una librería de jipa en mi caso puse eclipse link nota no me pregunten cómo se hace eso en netbenas por que estoy enseñando a programar en java no en netbeans asi que si quieres saberlo pon el google por que poner siguiente siguiente en un wizar no es para hombres que tengan pelo en el pecho

Código (xml) [Seleccionar] Expandir


<?xml version="1.0" encoding="UTF-8" ?>
<persistence xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
version="2.0" xmlns="http://java.sun.com/xml/ns/persistence">
<persistence-unit name="jpa" transaction-type="RESOURCE_LOCAL">

<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>

<class>com.tiaveneno.ventas.compartido.modelo.Cuenta</class>
<class>com.tiaveneno.ventas.compartido.modelo.DetalleOrden</class>
<class>com.tiaveneno.ventas.compartido.modelo.Orden</class>
<class>com.tiaveneno.ventas.compartido.modelo.Personal</class>
<class>com.tiaveneno.ventas.compartido.modelo.Plato</class>

<properties>
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/test" />
<property name="javax.persistence.jdbc.user" value="root" />
<property name="javax.persistence.jdbc.password" value="root" />

<!-- EclipseLink should create the database schema automatically -->
<property name="eclipselink.ddl-generation" value="none" />
<property name="eclipselink.ddl-generation.output-mode"
value="database" />
</properties>

</persistence-unit>
</persistence>



El fichero xml es un caso particular para eclipselink la primera ves que corras el programa debes reemplazar

<property name="eclipselink.ddl-generation" value="none" />

por

<property name="eclipselink.ddl-generation" value="DROP_AND_CREATE" />

ademas en
<persistence-unit name="jpa" transaction-type="RESOURCE_LOCAL">
Tener en cuenta que lo que dice úntenme debe estar en tu código para ser creado dentro del createEntityManagerFactory

En mi caso como dice jpa yo pongo

EntityManager entityManager = Persistence. (
            "jpa").createEntityManager();

Notese que estoy creando toda la aplicación desde el main  asi que si quiero cambiar de proveedor de persistencia solo cambio en el main y no en 20 clases distintas

si no te equicas nunca mas vas a tener que corregir la vase de datos la sincronisacion te la hace jpa



Uploaded with ImageShack.us


http://www.mediafire.com/download.php?6ff5dxyb6pb2f6j

Finalmente pongo una implementación concreta de el proveedor de persistencia como en este caso jpa pero puedes poner el que mas te guste

Código (java) [Seleccionar] Expandir


package com.tiaveneno.ventas.datos.jpa;

import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.persistence.EntityManager;
import org.apache.commons.beanutils.BeanUtils;

import com.tiaveneno.ventas.compartido.servicio.dao;

public abstract class JpaDao<K, E> implements dao<K, E> {
private final Class<E> entityClass;

private final EntityManager entityManager;

@SuppressWarnings("unchecked")
public JpaDao(EntityManager entityManager) {
ParameterizedType genericSuperclass = (ParameterizedType) getClass()
.getGenericSuperclass();
this.entityClass = (Class<E>) genericSuperclass
.getActualTypeArguments()[1];
this.entityManager = entityManager;

}

@Override
public void persist(final E entity) {
try {
entityManager.getTransaction().begin();
entityManager.persist(entity);
entityManager.getTransaction().commit();
} catch (Exception e) {
entityManager.getTransaction().rollback();
throw new RuntimeException(e);
}

}

@Override
public void persist(final List<E> entities) {
try {
entityManager.getTransaction().begin();
for (E e : entities) {
entityManager.persist(e);
}
entityManager.getTransaction().commit();
} catch (Exception e) {
entityManager.getTransaction().rollback();
throw new RuntimeException(e);
}

}

@Override
public void persist(E... entities) {
List<E> es = new ArrayList<E>();
for (E e : entities) {
es.add(e);
}
persist(es);
}

@Override
public void remove(final E entity) {

try {
entityManager.getTransaction().begin();
entityManager.remove(entity);
entityManager.getTransaction().commit();
} catch (Exception e) {
entityManager.getTransaction().rollback();
}

}

@Override
public void remove(final List<E> entities) {

for (E e : entities) {
remove(e);
}

}

@Override
public void remove(E... entities) {
List<E> es = new ArrayList<E>();
for (E e : entities) {
es.add(e);
}
remove(es);
}

@Override
public E findById(final K id) {

return entityManager.find(entityClass, id);

}

@Override
public void update(final K key, final E entity) {
Map<K, E> map = new HashMap<K, E>();
map.put(key, entity);
update(map);
}

@Override
public void update(final Map<K, E> update) {

Iterator<Map.Entry<K, E>> iter = update.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<K, E> entry = iter.next();
K key = entry.getKey();
E entity = entry.getValue();
@SuppressWarnings("unchecked")
E origen = (E) entityManager.find(entity.getClass(), key);
try {
BeanUtils.copyProperties(origen, entity);
} catch (Throwable throwable) {
throw new RuntimeException(throwable);
}
}

}

@Override
public void update(final Map.Entry<K, E>... entries) {
Map<K, E> map = new HashMap<K, E>();
for (Entry<K, E> entry : entries) {
map.put(entry.getKey(), entry.getValue());
}
update(map);
};

@Override
public void close() {
if (entityManager != null) {
if (!entityManager.isOpen()) {
try {
entityManager.close();
} catch (Throwable e) {
throw new RuntimeException(e);
}
}

}
}

}


Un poquito de voilepart pero esta vez te vas a quedar asi  porque no es ni la desina parte de lo que sería con implementado con jbc

Código (java) [Seleccionar] Expandir


package com.tiaveneno.ventas.datos.jpa;

import javax.persistence.EntityManager;

import com.tiaveneno.ventas.compartido.modelo.Orden;
import com.tiaveneno.ventas.compartido.servicio.OrderDao;

public class JpaOrderDao extends JpaDao<Integer, Orden> implements OrderDao {
public JpaOrderDao(EntityManager entityManager) {
super(entityManager);
}

}


Si es solo eso no falta nada ahora puedes cerrar la boca

Luego creó una abstracción la base de datos para así poder cambiarme de proveedor de persistencia sin crear tanto problema por ejemplo es fácil cambiar de jpa ibatis o lo que sea

tener en cuenta que uso generics la k es la clase de la llave primaria y e es la clase de la entidad en concreto

Código (java) [Seleccionar] Expandir


package com.tiaveneno.ventas.compartido.servicio;

import java.util.List;
import java.util.Map;

public interface dao<K, E> {

public abstract void remove(E... entities);

public abstract void remove(final List<E> entities);

public abstract void remove(final E entity);

public abstract void persist(final E... entities);

public abstract void persist(final List<E> entities);

public abstract void persist(final E entity);

public abstract E findById(final K id);

public abstract void close();

public abstract void update(final K key, final E entity);

public abstract void update(final Map<K, E> update);

public abstract void update(final Map.Entry<K, E>... entries);
}



y una interfas comcreta para un dao cualquiera

Código (java) [Seleccionar] Expandir


package com.tiaveneno.ventas.compartido.servicio;

import com.tiaveneno.ventas.compartido.modelo.Orden;

public interface OrderDao extends dao<Integer, Orden> {
// aqui pon codigo que sea propio de las orden como busca orden con un plato x
}