Excepciones en Java: cómo reducen código repetido

Ommadawn:

Estoy usando un modelo de objetos de acceso a datos (DAO) en Java y tengo la misma pieza de código repite todo mis archivos. La cosa se somethimng como esto:

public User getById(int id) throws BDException {
    Session session = sessionFactory.getCurrentSession();
    Transaction tx = session.getTransaction();

    try {
        tx.begin();
        Query query = session.createQuery("SELECT u FROM User u WHERE u.id=:id");
        query.setString("id", id);
        User user = (User) query.uniqueResult();
        tx.commit();

        return user;
    }
    catch(javax.validation.ConstraintViolationException | org.hibernate.exception.ConstraintViolationException cve) {
        try {
            if(tx.getStatus() == TransactionStatus.ACTIVE) {
                tx.rollback();
            }
        }
        catch(Exception exc) {
            LOGGER.error("Error rollback in method='" + getMethodName() + "'");
        }
        throw new BDException(cve);
    }
    catch(RuntimeException ex) {
        try {
            if(tx.getStatus() == TransactionStatus.ACTIVE) {
                tx.rollback();
            }
        }
        catch(Exception exc) {
            LOGGER.error("Error rollback in method='" + getMethodName() + "'");
        }
        throw ex;
    }
    catch(Exception ex) {
        try {
            if(tx.getStatus() == TransactionStatus.ACTIVE) {
                tx.rollback();
            }
        }
        catch(Exception exc) {
            LOGGER.error("Error rollback in method='" + getMethodName() + "'");
        }
        throw new RuntimeException(ex);
    }
}

Bueno, quiero que mire parte de la captura. Tengo que repetir en cada método que tengo. Si se trataba de código simple, que podría crear un método, puesto que todo el interior de código y llamar al método en lugar de la repetición del código. El problema es que no es código normal, son excepciones.

Entonces, ¿hay alguna solución para la reutilización de código y no repetir (copiar y pegar) el código en cada método?

¡Gracias!

VoiceOfUnreason:

¿hay alguna solución a la reutilización de código y no repetir (copiar y pegar) el código en cada método?

Ahi esta.

La "carne" de su función es aquí

    Query query = session.createQuery("SELECT u FROM User u WHERE u.id=:id");
    query.setString("id", id);
    User user = (User) query.uniqueResult();

Si usted escudriña con mucho cuidado, es posible ver que esto es una "función" que acepta un Sessioncomo un argumento, y devuelve una User. Lo que luego se puede hacer es que esta función un argumento para lo que hace todo el manejo de excepciones.

En Java, que por lo general significa expresar la función como un "objeto"

User MyCrazyFunctionThing::uniqueResult(Session session) {
    Query query = session.createQuery(this.sql);
    query.setString("id", this.id);
    return query.uniqueResult();
}

User DatabaseGateway::execute(MyCrazyFunctionThing q) {
    Session session = sessionFactory.getCurrentSession();
    Transaction tx = session.getTransaction();

    try {
        tx.begin();
        User user = q.uniqueResult(session)
        tx.commit();

        return user;
    } catch (...) {
        // ...
    }
}

De inmediato, se puede convertir eso en la lógica que se puede ejecutar en cualquier momento que intenta buscar un usuario único de una sesión.

Usted puede hacer que incluso más general con los genéricos

interface MyCrazyGenericThing<T> {
    T uniqueResult(Session session);
}

class MyCrazyFunctionThing implements MyCrazyGenericThing<User> {
    User uniqueResult(Session session) {
        Query query = session.createQuery(this.sql);
        query.setString("id", this.id);
        return query.uniqueResult();
    }
}

<T> T DatabaseGateway::execute(MyCrazyGenericThing<T> q) {
    Session session = sessionFactory.getCurrentSession();
    Transaction tx = session.getTransaction();

    try {
        tx.begin();
        T result = q.uniqueResult(session)
        tx.commit();

        return result;
    } catch (...) {
        // ...
    }
}

Lo que está viendo aquí es el patrón de estrategia que se utiliza para especificar qué código debe funcionar dentro de la lógica de la transacción.