recruiterdao.java

一个关于物流的管理系统

package com.shunshi.ssh.dao;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.context.ApplicationContext;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.shunshi.ssh.entity.Recruiter;
import com.shunshi.ssh.entity.Resume;


/**
 * A data access object (DAO) providing persistence and search support for
 * Recruiter 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.shunshi.ssh.entity.Recruiter
 * @author MyEclipse Persistence Tools
 */

public class RecruiterDAO extends HibernateDaoSupport implements IRecruiterDao {
	private static final Log log = LogFactory.getLog(RecruiterDAO.class);
	private static final int MAX_ROW_NUM=8;
	protected void initDao() {
		// do nothing
	}

	public void save(Recruiter transientInstance) {
		log.debug("saving Recruiter instance");
		try {
			getHibernateTemplate().save(transientInstance);
			log.debug("save successful");
		} catch (RuntimeException re) {
			log.error("save failed", re);
			throw re;
		}
	}

	public void delete(Recruiter persistentInstance) {
		log.debug("deleting Recruiter instance");
		try {
			getHibernateTemplate().delete(persistentInstance);
			log.debug("delete successful");
		} catch (RuntimeException re) {
			log.error("delete failed", re);
			throw re;
		}
	}
	public void update(Recruiter instance) {
		log.debug("updateing Recruiter instance");
		try {
			getHibernateTemplate().update(instance);
			log.debug("update successful");
		} catch (RuntimeException re) {
			log.error("update failed", re);
			throw re;
		}
	}
	public Recruiter findById(java.lang.Long id) {
		log.debug("getting Recruiter instance with id: " + id);
		try {
			Recruiter instance = (Recruiter) getHibernateTemplate().get(
					"com.shunshi.ssh.entity.Recruiter", id);
			return instance;
		} catch (RuntimeException re) {
			log.error("get failed", re);
			throw re;
		}
	}

	public List findAll() {
		log.debug("finding all Recruiter instances");
		try {
			String queryString = "from Recruiter";
			return getHibernateTemplate().find(queryString);
		} catch (RuntimeException re) {
			log.error("find all failed", re);
			throw re;
		}
	}

	public List findByUserId(Long uid) {
		log.debug("finding Recruiter instances by userId");
		try {
			String queryString = "from Recruiter r where userId=?";
			return getHibernateTemplate().find(queryString,uid);
		} catch (RuntimeException re) {
			log.error("find failed", re);
			throw re;
		}
	}

	public List findByState(final int state,final int startRow,final int maxRowNum) {
		List recruitersInfos=(List)getHibernateTemplate().execute(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query query=session.createQuery("from Recruiter recruiters where recruiters.state=?");
				query.setInteger(0, state);
				query.setMaxResults(maxRowNum);
				query.setFirstResult(startRow);
				List recruitersInfos=new ArrayList();
				List recruiters=query.list();
				for(int i=0;i<recruiters.size();i++){
					Recruiter recruitersInfo=(Recruiter)recruiters.get(i);
					Map recruitersMap=new HashMap();
					recruitersMap.put("name",recruitersInfo.getJobName());
					recruitersMap.put("publishDate", recruitersInfo.getPublishDate());
					recruitersMap.put("userId", recruitersInfo.getUserId());
					recruitersMap.put("state",recruitersInfo.getState());
					recruitersMap.put("id",recruitersInfo.getId());
					recruitersInfos.add(recruitersMap);
				}
				return recruitersInfos;
			}
		});
		return recruitersInfos;
	}
	public Long getTotalRowsByState(int state) {
		log.debug("finding rows");
		try {
			String queryString = "select count(*) from Recruiter recruiter where recruiter.state=?";
			return (Long)getHibernateTemplate().find(queryString,state).get(0);
		} catch (RuntimeException re) {
			log.error("find  failed", re);
			throw re;
		}
	}

	public List findMorePublishInfo(final int startRow, final int maxRowNum) {
		List recruitersInfos=(List)getHibernateTemplate().execute(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query query=session.createQuery("from Recruiter recruiters where recruiters.state=?");
				query.setInteger(0, 2);
				query.setMaxResults(maxRowNum);
				query.setFirstResult(startRow);
				List recruitersInfos=new ArrayList();
				List recruiters=query.list();
				for(int i=0;i<recruiters.size();i++){
					Recruiter recruitersInfo=(Recruiter)recruiters.get(i);
					Map recruitersMap=new HashMap();
					recruitersMap.put("com", recruitersInfo.getAddress());
					recruitersMap.put("name",recruitersInfo.getJobName());
					recruitersMap.put("publishDate", recruitersInfo.getPublishDate());
					recruitersMap.put("id",recruitersInfo.getId());
					recruitersInfos.add(recruitersMap);
				}
				return recruitersInfos;
			}
		});
		return recruitersInfos;
	}

	public List findSomePublishInfo() {
		List recruitersInfos=(List)getHibernateTemplate().execute(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query query=session.createQuery("from Recruiter recruiters where recruiters.state=? order by recruiters.publishDate desc");
				query.setInteger(0, 2);
				query.setMaxResults(MAX_ROW_NUM);
				query.setFirstResult(0);
				List recruitersInfos=new ArrayList();
				List recruiters=query.list();
				for(int i=0;i<recruiters.size();i++){
					Recruiter recruitersInfo=(Recruiter)recruiters.get(i);
					Map recruitersMap=new HashMap();
					recruitersMap.put("name",recruitersInfo.getJobName());
					recruitersMap.put("publishDate", recruitersInfo.getPublishDate());
					recruitersInfos.add(recruitersMap);
				}
				return recruitersInfos;
			}
		});
		return recruitersInfos;
	}

	public Recruiter findRecruiterByMaxId() {
		String hql="select Max(id) from Goods goods";
		Long id=(Long)getHibernateTemplate().find(hql).get(0);
		return findById(id.longValue());
	}


}