operatordao.java

来自「spring+hibernate+struts开发的校务oa系统」· Java 代码 · 共 303 行

package com.yondor.oa.db.operator.dao;

import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Criteria;
import org.hibernate.LockMode;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Expression;
import org.jaxen.expr.Expr;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.dao.DataAccessException;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.yondor.oa.db.message.dao.Message;
import com.yondor.oa.db.message.dao.MessageVO;
import com.yondor.oa.db.operator.iface.IOperator;
import com.yondor.oa.db.popedom.dao.Popedom;
import com.yondor.oa.db.popedom.dao.PopedomDAO;
import com.yondor.oa.db.usergroup.dao.Usergroup;
import com.yondor.oa.db.usergroup.dao.UsergroupDAO;
import com.yondor.oa.db.userinfo.dao.Userinfo;
import com.yondor.oa.db.userinfo.dao.UserinfoDAO;

/**
 * Data access object (DAO) for domain model class Operator.
 * @see com.yondor.oa.db.pojo.Operator
 * @author MyEclipse - Hibernate Tools
 */
public class OperatorDAO extends HibernateDaoSupport implements IOperator {

    private static final Log log = LogFactory.getLog(OperatorDAO.class);

	protected void initDao() {
		//do nothing
	}
    
   /**
    * 保存一个Operator
    * @param transientInstance
    */
    public void save(Operator transientInstance) {
        log.debug("saving Operator instance");
        try {
            getHibernateTemplate().save(transientInstance);
            log.debug("save successful");
        } catch (RuntimeException re) {
            log.error("save failed", re);
            throw re;
        }
    }
    
	/**
	 * 删除一个Operator
	 * @param persistentInstance
	 */
	public void delete(Operator persistentInstance) {
        log.debug("deleting Operator instance");
        try {
            getHibernateTemplate().delete(persistentInstance);
            log.debug("delete successful");
        } catch (RuntimeException re) {
            log.error("delete failed", re);
            throw re;
        }
    }
    	
	public void update(Operator persistentInstance) {
        log.debug("updateing Operator instance");
        try {
            getHibernateTemplate().update(persistentInstance);
            log.debug("update successful");
        } catch (RuntimeException re) {
            log.error("update failed", re);
            throw re;
        }
    }
    
	public List findByHql(StringBuffer hql){
		return getHibernateTemplate().find(hql.toString());
	}
	
	
	
	public List findByCriteria(DetachedCriteria dc){
		return getHibernateTemplate().findByCriteria(dc);
	}
	public List findByCriteria(DetachedCriteria dc,int firstResult,int maxResult){
		return getHibernateTemplate().findByCriteria(dc,firstResult,maxResult);
	}
	
	public List query(OperatorVO paramVO){
		DetachedCriteria dc = DetachedCriteria.forClass(Operator.class);
		
		if(null!=paramVO.getUserinfo()){
			dc.createAlias(IOperator.USERINFO, "userinfo").add(
					Expression.eq("userinfo.userinfoid", 
					  			  paramVO.getUserinfo().getUserinfoid()));
		}
		if(null!=paramVO.getPopedom()){
			dc.createAlias(IOperator.POPEDOM, "popedom").add(
					Expression.eq("popedom.popedomid",
								  paramVO.getPopedom().getParentid()));
		}
		if(null!=paramVO.getState()){
			dc.createAlias(IOperator.STATE, "state").add(
					Expression.eq("state.greensysparamid", 
							      paramVO.getState().getGreensysparamid()));
		}
		if(null!=paramVO.getUsername()){
			dc.add(Expression.eq("username", paramVO.getUsername()));
		}
		if(null!=paramVO.getPassword()){
			dc.add(Expression.eq("password", paramVO.getPassword()));
		}
		if(null!=paramVO.getRgistertime()){
			dc.add(Expression.eq("rgistertime", paramVO.getRgistertime()));
		}
		if(null!=paramVO.getStoptime()){
			dc.add(Expression.eq("stoptime", paramVO.getStoptime()));
		}
		if(null!=paramVO.getLogincount()){
			dc.add(Expression.eq("logincount", paramVO.getLogincount()));
		}
		return findByCriteria(dc);
	}
	
	public List query(OperatorVO paramVO,int firstResult,int maxResult){
		DetachedCriteria dc = DetachedCriteria.forClass(Operator.class);
		if(null!=paramVO.getUserinfo()){
			dc.createAlias(IOperator.USERINFO, "userinfo").add(
					Expression.eq("userinfo.userinfoid", 
					  			  paramVO.getUserinfo().getUserinfoid()));
		}
		if(null!=paramVO.getPopedom()){
			dc.createAlias(IOperator.POPEDOM, "popedom").add(
					Expression.eq("popedom.popedomid",
								  paramVO.getPopedom().getParentid()));
			
		}
		if(null!=paramVO.getState()){
			dc.createAlias(IOperator.STATE, "state").add(
					Expression.eq("state.greensysparamid", 
							      paramVO.getState().getGreensysparamid()));
		}
		if(null!=paramVO.getUsername()){
			dc.add(Expression.eq("username", paramVO.getUsername()));
		}
		if(null!=paramVO.getPassword()){
			dc.add(Expression.eq("password", paramVO.getPassword()));
		}
		if(null!=paramVO.getRgistertime()){
			dc.add(Expression.eq("rgistertime", paramVO.getRgistertime()));
		}
		if(null!=paramVO.getStoptime()){
			dc.add(Expression.eq("stoptime", paramVO.getStoptime()));
		}
		if(null!=paramVO.getLogincount()){
			dc.add(Expression.eq("logincount", paramVO.getLogincount()));
		}
		
		
		return findByCriteria(dc,firstResult,maxResult);
		
	}
	
	/**
	 * 按照id获取一个Operator
	 * @param 	id
	 * @return	Operator
	 */
    public Operator findById( java.lang.Long id) {
        log.debug("getting Operator instance with id: " + id);
        try {
            Operator instance = (Operator) getHibernateTemplate()
                    .get(Operator.class, id);
            return instance;
        } catch (DataAccessException re) {
            log.error("get failed", re);
            throw re;
        }
    }
    
    
    /* (non-Javadoc)
	 * @see com.yondor.oa.db.operator.dao.IOperator#findByExample(com.yondor.oa.db.operator.dao.Operator)
	 */
    public List findByExample(Operator instance) {
        log.debug("finding Operator instance by example");
        try {
            List results = getHibernateTemplate().findByExample(instance);
            log.debug("find by example successful, result size: " + results.size());
            return results;
        } catch (RuntimeException re) {
            log.error("find by example failed", re);
            throw re;
        }
    } 
    
    
    
    /* (non-Javadoc)
	 * @see com.yondor.oa.db.operator.dao.IOperator#findByProperty(java.lang.String, java.lang.Object)
	 */
    public List findByProperty(String propertyName, Object value) {
      log.debug("finding Operator instance with property: " + propertyName
            + ", value: " + value);
      try {
         String queryString = "from Operator as model where model." 
         						+ propertyName + "= ?";
		 return getHibernateTemplate().find(queryString, value);
      } catch (RuntimeException re) {
         log.error("find by property name failed", re);
         throw re;
      }
	}
    
    

	/* (non-Javadoc)
	 * @see com.yondor.oa.db.operator.dao.IOperator#findByUsername(java.lang.Object)
	 */
	public List findByUsername(Object username) {
		return findByProperty(USERNAME, username);
	}
	
	/* (non-Javadoc)
	 * @see com.yondor.oa.db.operator.dao.IOperator#findByPassword(java.lang.Object)
	 */
	public List findByPassword(Object password) {
		return findByProperty(PASSWORD, password);
	}
	
	/* (non-Javadoc)
	 * @see com.yondor.oa.db.operator.dao.IOperator#findByState(java.lang.Object)
	 */
	public List findByState(Object state) {
		return findByProperty(STATE, state);
	}
	
	/* (non-Javadoc)
	 * @see com.yondor.oa.db.operator.dao.IOperator#findByLogincount(java.lang.Object)
	 */
	public List findByLogincount(Object logincount) {
		return findByProperty(LOGINCOUNT, logincount);
	}
	
    /**
     * 如果id不存在则进行插入操作，
     * 如果id存在则进行更新操作
     * @param detachedInstance
     * @return	Operator
     */
    public Operator merge(Operator detachedInstance) {
        log.debug("merging Operator instance");
        try {
            Operator result = (Operator) getHibernateTemplate()
                    .merge(detachedInstance);
            log.debug("merge successful");
            return result;
        } catch (RuntimeException re) {
            log.error("merge failed", re);
            throw re;
        }
    }

    /* (non-Javadoc)
	 * @see com.yondor.oa.db.operator.dao.IOperator#attachDirty(com.yondor.oa.db.operator.dao.Operator)
	 */
    public void attachDirty(Operator instance) {
        log.debug("attaching dirty Operator instance");
        try {
            getHibernateTemplate().saveOrUpdate(instance);
            log.debug("attach successful");
        } catch (RuntimeException re) {
            log.error("attach failed", re);
            throw re;
        }
    }
    
    /* (non-Javadoc)
	 * @see com.yondor.oa.db.operator.dao.IOperator#attachClean(com.yondor.oa.db.operator.dao.Operator)
	 */
    public void attachClean(Operator instance) {
        log.debug("attaching clean Operator instance");
        try {
            getHibernateTemplate().lock(instance, LockMode.NONE);
            log.debug("attach successful");
        } catch (RuntimeException re) {
            log.error("attach failed", re);
            throw re;
        }
    }

	public static OperatorDAO getFromApplicationContext(ApplicationContext ctx) {
    	return (OperatorDAO) ctx.getBean("OperatorDAO");
	}
	
	
	
}