Struts2+ Spring+ Jpa 配置测试

package jpa; import java.util.List; import javax.persistence.EntityManager; import javax.persistence.PersistenceException; import javax.persistence.Query; import org.springframework.context.ApplicationContext; import org.springframework.orm.jpa.JpaCallback; import org.springframework.orm.jpa.support.JpaDaoSupport; /** * A data access object (DAO) providing persistence and search support for User * entities. Transaction control of the save(), update() and delete() operations * can directly support Spring container-managed transactions or they can be * augmented to handle user-managed Spring transactions. Each of these methods * provides additional information for how to configure it for the desired type * of transaction control. * * @see jpa.User * @author MyEclipse Persistence Tools */ public class UserDAO extends JpaDaoSupport implements IUserDAO { // property constants public static final String NAME = "name"; public static final String PASSWORD = "password"; public static final String EMAIL = "email"; /** * Perform an initial save of a previously unsaved User entity. All * subsequent persist actions of this entity should use the #update() * method. This operation must be performed within the a database * transaction context for the entity's data to be permanently saved to the * persistence store, i.e., database. This method uses the * {@link javax.persistence.EntityManager#persist(Object) EntityManager#persist} * operation. * <p> * User-managed Spring transaction example: * * <pre> * TransactionStatus txn = txManager * .getTransaction(new DefaultTransactionDefinition()); * UserDAO.save(entity); * txManager.commit(txn); * </pre> * * @see <a href = * "http://www.myeclipseide.com/documentation/quickstarts/jpaspring#containermanaged">Spring * container-managed transaction examples</a> * @param entity * User entity to persist * @throws RuntimeException * when the operation fails */ public void save(User entity) { logger.info("saving User instance"); try { getJpaTemplate().persist(entity); logger.info("save successful"); } catch (RuntimeException re) { logger.error("save failed", re); throw re; } } /** * Delete a persistent User entity. This operation must be performed within * the a database transaction context for the entity's data to be * permanently deleted from the persistence store, i.e., database. This * method uses the * {@link javax.persistence.EntityManager#remove(Object) EntityManager#delete} * operation. * <p> * User-managed Spring transaction example: * * <pre> * TransactionStatus txn = txManager * .getTransaction(new DefaultTransactionDefinition()); * UserDAO.delete(entity); * txManager.commit(txn); * entity = null; * </pre> * * @see <a href = * "http://www.myeclipseide.com/documentation/quickstarts/jpaspring#containermanaged">Spring * container-managed transaction examples</a> * @param entity * User entity to delete * @throws RuntimeException * when the operation fails */ public void delete(User entity) { logger.info("deleting User instance"); try { entity = getJpaTemplate().getReference(User.class, entity.getId()); getJpaTemplate().remove(entity); logger.info("delete successful"); } catch (RuntimeException re) { logger.error("delete failed", re); throw re; } } /** * Persist a previously saved User entity and return it or a copy of it to * the sender. A copy of the User entity parameter is returned when the JPA * persistence mechanism has not previously been tracking the updated * entity. This operation must be performed within the a database * transaction context for the entity's data to be permanently saved to the * persistence store, i.e., database. This method uses the * {@link javax.persistence.EntityManager#merge(Object) EntityManager#merge} * operation. * <p> * User-managed Spring transaction example: * * <pre> * TransactionStatus txn = txManager * .getTransaction(new DefaultTransactionDefinition()); * entity = UserDAO.update(entity); * txManager.commit(txn); * </pre> * * @see <a href = * "http://www.myeclipseide.com/documentation/quickstarts/jpaspring#containermanaged">Spring * container-managed transaction examples</a> * @param entity * User entity to update * @returns User the persisted User entity instance, may not be the same * @throws RuntimeException * if the operation fails */ public User update(User entity) { logger.info("updating User instance"); try { User result = getJpaTemplate().merge(entity); logger.info("update successful"); return result; } catch (RuntimeException re) { logger.error("update failed", re); throw re; } } public User findById(Integer id) { logger.info("finding User instance with id: " + id); try { User instance = getJpaTemplate().find(User.class, id); return instance; } catch (RuntimeException re) { logger.error("find failed", re); throw re; } } /** * Find all User entities with a specific property value. * * @param propertyName * the name of the User property to query * @param value * the property value to match * @return List<User> found by query */ @SuppressWarnings("unchecked") public List<User> findByProperty(String propertyName, final Object value) { logger.info("finding User instance with property: " + propertyName + ", value: " + value); try { final String queryString = "select model from User model where model." + propertyName + "= :propertyValue"; return getJpaTemplate().executeFind(new JpaCallback() { public Object doInJpa(EntityManager em) throws PersistenceException { Query query = em.createQuery(queryString); query.setParameter("propertyValue", value); return query.getResultList(); } }); } catch (RuntimeException re) { logger.error("find by property name failed", re); throw re; } } public List<User> findByName(Object name) { return findByProperty(NAME, name); } public List<User> findByPassword(Object password) { return findByProperty(PASSWORD, password); } public List<User> findByEmail(Object email) { return findByProperty(EMAIL, email); } /** * Find all User entities. * * @return List<User> all User entities */ @SuppressWarnings("unchecked") public List<User> findAll() { logger.info("finding all User instances"); try { final String queryString = "select model from User model"; return getJpaTemplate().executeFind(new JpaCallback() { public Object doInJpa(EntityManager em) throws PersistenceException { Query query = em.createQuery(queryString); return query.getResultList(); } }); } catch (RuntimeException re) { logger.error("find all failed", re); throw re; } } public static IUserDAO getFromApplicationContext(ApplicationContext ctx) { return (IUserDAO) ctx.getBean("UserDAO"); } }