JavaSSH做的精品课程系统

package com.qualityCourse.dao; 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; import org.springframework.transaction.annotation.Transactional; import com.qualityCourse.Idao.IReplyDAO; import com.qualityCourse.model.Reply; import com.qualityCourse.model.Talkingarea; /** * A data access object (DAO) providing persistence and search support for Reply * 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 com.qualityCourse.model.Reply * @author MyEclipse Persistence Tools */ public class ReplyDAO extends JpaDaoSupport implements IReplyDAO { // property constants public static final String REPLY_CONTENT = "replyContent"; /** * Perform an initial save of a previously unsaved Reply 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()); * ReplyDAO.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 * Reply entity to persist * @throws RuntimeException * when the operation fails */ public void save(Reply entity) { logger.info("saving Reply instance"); try { getJpaTemplate().persist(entity); Talkingarea t= getJpaTemplate().getReference(Talkingarea.class, entity.getTalkingarea().getId());; Integer st=t.getSize(); if(null==st||st<0) st=0; else st++; t.setSize(st); getJpaTemplate().persist(t); logger.info("save successful"); } catch (RuntimeException re) { logger.error("save failed", re); throw re; } } /** * Delete a persistent Reply 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()); * ReplyDAO.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 * Reply entity to delete * @throws RuntimeException * when the operation fails */ public void delete(Reply entity) { logger.info("deleting Reply instance"); try { entity = getJpaTemplate().getReference(Reply.class, entity.getId()); Talkingarea t=entity.getTalkingarea(); Integer st=t.getSize(); if(null==st||st<0) st=0; else st--; t.setSize(st); getJpaTemplate().persist(t); getJpaTemplate().remove(entity); logger.info("delete successful"); } catch (RuntimeException re) { logger.error("delete failed", re); throw re; } } /** * Persist a previously saved Reply entity and return it or a copy of it to * the sender. A copy of the Reply 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 = ReplyDAO.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 * Reply entity to update * @return Reply the persisted Reply entity instance, may not be the same * @throws RuntimeException * if the operation fails */ public Reply update(Reply entity) { logger.info("updating Reply instance"); try { Reply result = getJpaTemplate().merge(entity); logger.info("update successful"); return result; } catch (RuntimeException re) { logger.error("update failed", re); throw re; } } public Reply findById(Integer id) { logger.info("finding Reply instance with id: " + id); try { Reply instance = getJpaTemplate().find(Reply.class, id); return instance; } catch (RuntimeException re) { logger.error("find failed", re); throw re; } } /** * Find all Reply entities with a specific property value. * * @param propertyName * the name of the Reply property to query * @param value * the property value to match * @param rowStartIdxAndCount * Optional int varargs. rowStartIdxAndCount[0] specifies the the * row index in the query result-set to begin collecting the * results. rowStartIdxAndCount[1] specifies the the maximum * number of results to return. * @return List<Reply> found by query */ @SuppressWarnings("unchecked") public List<Reply> findByProperty(String propertyName, final Object value, final int... rowStartIdxAndCount) { logger.info("finding Reply instance with property: " + propertyName + ", value: " + value); try { final String queryString = "select model from Reply 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); if (rowStartIdxAndCount != null && rowStartIdxAndCount.length > 0) { int rowStartIdx = Math.max(0, rowStartIdxAndCount[0]); if (rowStartIdx > 0) { query.setFirstResult(rowStartIdx); } if (rowStartIdxAndCount.length > 1) { int rowCount = Math.max(0, rowStartIdxAndCount[1]); if (rowCount > 0) { query.setMaxResults(rowCount); } } } return query.getResultList(); } }); } catch (RuntimeException re) { logger.error("find by property name failed", re); throw re; } } public List<Reply> findByReplyContent(Object replyContent, int... rowStartIdxAndCount) { return findByProperty(REPLY_CONTENT, replyContent, rowStartIdxAndCount); } /** * Find all Reply entities. * * @param rowStartIdxAndCount * Optional int varargs. rowStartIdx