SSH单元测试代码收拾

SSH单元测试代码整理

package test;

import java.util.List;

import org.junit.Test;

import com.etone.service.ICacheService;
import com.etone.service.ITaskService;
import com.etone.service.OtSystemServicePortType;
import org.apache.log4j.Logger;

public class UnitTestTools extends JdbcHibernateSupport {
	private static final Logger log = Logger.getLogger(UnitTestTools.class);

	@Test
	public void testJdbc() {
		String sql = "select tal.fdiActionNo,tal.fddStartTime"
				+ " from TestActionLog tal where 1=1"
				+ " and tal.fdiTestItemId=" + 20005099
				+ " and tal.fddStartTime>'"
				+ "2011-11-3 10:10:38' order by tal.fdiActionNo asc";
		log.info("########"+this.getJdbcTemplate());
		List list = this.getJdbcTemplate().queryForList(sql);
		log.info("################ list.size =" + list.size());
	}

	public void testCache() {
		ICacheService cs = (ICacheService) context.getBean("cacheService");
		cs.createBussinessCacheData();
	}

	public void testTask() {
		ITaskService ts = (ITaskService) context.getBean("taskService");
		String str = ts.getTestActionLogContent("20005099",
				"2011-11-3 10:10:38");
		log.info("##########" + str);
	}

	public void testWs() {
		OtSystemServicePortType cs = (OtSystemServicePortType) context
				.getBean("wsOtSystemTarget");
		cs.getAreaBusinessVoList("1");

	}

}

 

 

package test;

import javax.sql.DataSource;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.hibernate.FlushMode;
import org.hibernate.HibernateException;
import org.hibernate.JDBCException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.dao.CleanupFailureDataAccessException;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.hibernate3.SessionFactoryUtils;
import org.springframework.orm.hibernate3.SessionHolder;
import org.springframework.transaction.support.TransactionSynchronizationManager;

public class JdbcHibernateSupport {
	private static final Logger log = Logger
			.getLogger(JdbcHibernateSupport.class);

	private HibernateTemplate hibernateTemplate;

	private DataSource dataSource;

	private SessionFactory sessionFactory;

	private static final String path = "WebRoot/WEB-INF/";

	private static final String files[] = { "applicationContext-hibernate.xml",
			"log4j.properties" };

	protected static ApplicationContext context;

	public JdbcHibernateSupport() {
		context = new FileSystemXmlApplicationContext(path + files[0]);// 加载spring配置文件
		PropertyConfigurator.configure(path + files[1]);// 加载log4j配置文件
		dataSource = (DataSource) context.getBean("dataSource");// 用于创建JdbcTemplate
		sessionFactory = (SessionFactory) context.getBean("sessionFactory");// 用于创建HibernateTemplate

	}

	public HibernateTemplate getHibernateTemplate() {
		return new HibernateTemplate(sessionFactory);
	}

	public JdbcTemplate getJdbcTemplate() {
		return new JdbcTemplate(dataSource);
	}

	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	public DataSource getDataSource() {

		return dataSource;
	}

	public void flushHibernate() {
		HibernateCallback hibernateCallback = new HibernateCallback() {
			public Object doInHibernate(Session session) {
				try {
					session.flush();
				} catch (HibernateException ex) {
					log.error(ex.getMessage(), ex);
				}
				return null;
			}
		};
		hibernateTemplate.execute(hibernateCallback);
	}

	protected Session getSession(SessionFactory sessionFactory,
			boolean isAllowCreate) throws DataAccessResourceFailureException {
		Session session = SessionFactoryUtils.getSession(sessionFactory,
				isAllowCreate);
		session.setFlushMode(FlushMode.NEVER);
		return session;

	}

	protected void bindResource(Session session, SessionFactory sessionFactory) {
		TransactionSynchronizationManager.bindResource(sessionFactory,
				new SessionHolder(session));
	}

	protected void unBindResource(Session session, SessionFactory sessionFactory) {
		TransactionSynchronizationManager.unbindResource(sessionFactory);
		closeSessionIfNecessary(session, sessionFactory);
	}

	public void closeSessionIfNecessary(Session session,
			SessionFactory sessionFactory)
			throws CleanupFailureDataAccessException {

		if (session == null
				|| TransactionSynchronizationManager
						.hasResource(sessionFactory)) {
			return;
		}
		System.out.println("Closing Hibernate session");
		try {
			session.close();

		} catch (JDBCException ex) {
			throw new CleanupFailureDataAccessException(
					"Could not close Hibernate session", ex.getSQLException());
		} catch (HibernateException ex) {
			throw new CleanupFailureDataAccessException(
					"Could not close Hibernate session", ex);
		}
	}

}