JPAAccountDAO.java

package ejava.examples.ejbsessionbank.jpa;

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

import javax.persistence.EntityManager;
import javax.persistence.Query;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import ejava.examples.ejbsessionbank.bo.Account;
import ejava.examples.ejbsessionbank.bo.Ledger;
import ejava.examples.ejbsessionbank.dao.AccountDAO;
import ejava.examples.ejbsessionbank.dao.DAOException;

public class JPAAccountDAO implements AccountDAO {
    private static Logger log = LoggerFactory.getLogger(JPAAccountDAO.class); 
    public static final String ACCOUNT_BY_NUM = "getAccountsByAccountNumber"; 
    public static final String ACCOUNT_NUM_PARAM = "accountNumber"; 
    public static final String GET_LEDGER = "getLedger"; 
    public static final String GET_LEDGER_AVE = "getLedgerAveBalance"; 
    public static final String GET_LEDGER_CNT = "getLedgerCount"; 
    public static final String GET_LEDGER_SUM = "getLedgerSum"; 
    
    private EntityManager em;
    
    public void setEntityManager(EntityManager em) {
        this.em = em;
    }

    public Account createAccount(Account account) throws DAOException {
        try {
            em.persist(account);
            return account;
        }
        catch (Throwable ex) {
            log.error("error in createAccount", ex);
            throw new DAOException(
                    "error creating account:" + account,ex);
        }
    }

    @SuppressWarnings("unchecked")
    public List<Account> findAccounts(String queryName,
            Map<String, Object> params, int index, int count)
            throws DAOException {
        try {
            Query query = 
                em.createNamedQuery(queryName)
                   .setFirstResult(index)
                   .setMaxResults(count);
            if (params != null && params.size() != 0) {
                for(String key: params.keySet()) {
                    query.setParameter(key, params.get(key));
                }
            }
            log.debug("named query:" + queryName + ", params=" + params);
            return query.getResultList();
        }
        catch (Throwable ex) {
            log.error("error in findAccounts", ex);
            throw new DAOException(
                    "error executing named query:" + queryName,ex);
        }
    }

    public Account getAccountById(long id) throws DAOException {
        try {
            return em.find(Account.class, id);
        }
        catch (Throwable ex) {
            log.error("error in getAccountById", ex);
            throw new DAOException(
                    "error finding account:" + id,ex);
        }
    }

    public Account getAccountByNum(String acctNum) throws DAOException {
        Map<String, Object> params = new HashMap<String, Object>();
        params.put(ACCOUNT_NUM_PARAM, acctNum);
        List<Account> accounts = findAccounts(ACCOUNT_BY_NUM, params, 0, 1);
        return (accounts.size() == 1) ? accounts.get(0) : null;
    }

    public Account removeAccount(Account account) throws DAOException {
        try {
            if (!em.contains(account)) {
                account = em.find(Account.class, account.getId());
            }
            if (account != null) {
                em.remove(account);
            }
            return account;
        }
        catch (Throwable ex) {
            log.error("error in removeAccount", ex);
            throw new DAOException(
                    "error removing account:" + account,ex);
        }
    }

    public Account updateAccount(Account account) throws DAOException {
        try {
            return em.merge(account);
        }
        catch (Throwable ex) {
            log.error("error in updateAccount", ex);
            throw new DAOException(
                    "error removing account:" + account,ex);
        }
    }

    public Ledger getLedger() throws DAOException {
        try {
            return (Ledger) em.createNamedQuery(GET_LEDGER)
                                  .getSingleResult();
        }
        catch (Throwable ex) {
            log.error("error in getLedger", ex);
            throw new DAOException(
                    "error getting ledger",ex);
        }
    }

    public double getLedgerAveBalance() throws DAOException {
        try {
            return (Double) em.createNamedQuery(GET_LEDGER_AVE)
                               .getSingleResult();
        }
        catch (Throwable ex) {
            log.error("error in getLedgerBalance", ex);
            throw new DAOException(
                    "error getting ledger ave balance",ex);
        }
    }

    public long getLedgerCount() throws DAOException {
        try {
            Object count =  em.createNamedQuery(GET_LEDGER_CNT)
                              .getSingleResult();
            log.error("getLedgerCount data type=" + count.getClass());            
            return ((Long)count).longValue();
        }
        catch (Throwable ex) {
            log.error("error in getLedgerCount", ex);
            throw new DAOException(
                    "error getting ledger count",ex);
        }
    }

    public double getLedgerSum() throws DAOException {
        try {
            return (Double) em.createNamedQuery(GET_LEDGER_SUM)
                               .getSingleResult();
        }
        catch (Throwable ex) {
            log.error("error in getLedgerSum", ex);
            throw new DAOException(
                    "error getting ledger sum",ex);
        }
    }
}