publicfunction.java

这是本人以前在学校时

/*
 * Created on 2006-6-23
 * 公共方法类
 */
package com.funddeal.base;

import java.util.ArrayList;
import java.util.Calendar;

import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Query;
import net.sf.hibernate.QueryException;
import net.sf.hibernate.Session;

import com.funddeal.model.pojo.config_bring_number.ConfigBringNumber;
import com.funddeal.model.pojo.custom_entity.BringNumParamEntity;
import com.funddeal.model.pojo.custom_entity.PaginactionParamEntity;
import com.funddeal.model.pojo.custom_entity.SearchParamEntity;

/**
 * @author <b>zhangxianxin</b>
 * @version
 * 公共方法类：<br>
 * <b>方法－：</b>[String dtNumber()]<br>
 * 		产生一个17位的日期时间字符串，精确到毫秒<br>
 * <b>方法二：</b>[String bringNumber(String)]<br>
 * 		编号自动生成函数1，生成一个21的字符编号。<br>
 * 		组合规则：前四位是根据用户在数据库编号配置表中的配置，加上日期时间字符串生成函数（方法一）生成的数字字符组合而成。<br>
 * <b>方法三：</b>[String bringNumber(BringNumParameterEntity)]<br>
 * 		编号自动生成函数2（方法重载），在方法二上再加一重唯一保障！但相应的代价则是牺牲了效率<br>
 * <b>方法四：</b>[exist(String,String,String)]<br>
 * 		查找数据库中的某一个字段是否存在某一个值。<br>
 * 
 * <b>方法五：</b>[String calendarFormatDate(Calendar)]<br>
 * 		格式化日历对象以获得字符串型式的日期（年－月－日）<br>
 * <b>方法六：</b>[String calendarFormatTime(Calendar)]<br>
 * 		格式化日历对象以获得字符串型式的一个时间（小时：分钟：秒）<br>
 * <b>方法七：</b>[String calendarFormatMillisecond(Calendar)]<br>
 * 		格式化日历对象以获得字符串型式的一个毫秒数（长度为3位）<br>
 * <b>方法八：</b>[String getDate()]<br>
 * 		提供当前系统日期<br>
 * <b>方法九：</b>[String getTime()]<br>
 * 		提供当前系统时间<br>
 * <b>方法十：</b>[String getLongTime()]<br>
 * 		提供当前系统时间（包括毫秒）<br>
 * <b>方法十－：</b>[String getDateTime()]<br>
 * 		提供当前系统日期时间<br>
 * 
 * 方法十二：[Query search(SearchParameterEntity)]		
 * 		查找与某个值相匹配的结果集
 */
public class PublicFunction {
	public static String errorMsg="";
	/**
	 * 产生一个17位的日期时间字符串
	 * 其组成为：年＋月＋日＋小时＋分钟＋秒＋毫秒
	 * @return 日期时间字符串
	 */
	public String dtNumber()
	{
		String dtNum="";
		Calendar dtN=Calendar.getInstance();
		String dateNum=this.calendarFormatDate(dtN);
		dateNum = dateNum.replaceAll("-","");
		String timeNum=this.calendarFormatTime(dtN);
		timeNum = timeNum.replaceAll(":","");
		String msecondNum=this.calendarFormatMillisecond(dtN);
		dtNum=dateNum+timeNum+msecondNum;
		return dtNum;
	}
	
	/**
	 * 格式化日历对象以获得日期（年－月－日）
	 * @param calendar：要格式化的日历对象
	 * @return 日历对象的日期部分
	 */
	public String calendarFormatDate(Calendar calendar)
	{
		String dtNum="";
		Calendar dtN=calendar;
		String yearStr=String.valueOf(dtN.get(Calendar.YEAR));
		int moth= dtN.get(Calendar.MONTH)+1;
		String mothStr;
		if(moth<10)
			mothStr="-0" + String.valueOf(moth);
		else
			mothStr="-" + String.valueOf(moth);
		int day= dtN.get(Calendar.DATE);
		String dayStr;
		if(day<10)
			dayStr="-0" + String.valueOf(day);
		else
			dayStr="-" + String.valueOf(day);
		dtNum=yearStr+mothStr+dayStr;
		return dtNum;
	}
	
	/**
	 * 格式化日历对象以获得一个时间（小时：分钟：秒）
	 * @param calendar：要格式化的日历对象
	 * @return 日历对象的时间部分
	 */
	public String calendarFormatTime(Calendar calendar)
	{
		String dtNum="";
		Calendar dtN=calendar;
		int hour=dtN.get(Calendar.HOUR);
		String hourStr;
		if(hour<10)
			hourStr="0" + String.valueOf(hour);
		else
			hourStr=String.valueOf(hour);
		int minute=dtN.get(Calendar.MINUTE);
		String minuteStr;
		if(minute<10)
			minuteStr=":0" + String.valueOf(minute);
		else
			minuteStr=":" + String.valueOf(minute);
		int second =dtN.get(Calendar.SECOND);
		String secondStr;
		if(second<10)
			secondStr=":0" + String.valueOf(second);
		else
			secondStr=":" + String.valueOf(second);
		dtNum=hourStr+minuteStr+secondStr;
		return dtNum;
	}
	
	/**
	 * 格式化日历对象以获得一个毫秒数
	 * @param calendar：要格式化的日历对象
	 * @return 日历对象的毫秒数
	 */
	public String calendarFormatMillisecond(Calendar calendar)
	{
		Calendar dtN=calendar;
		String millisecondStr;
		int millisecond=dtN.get(Calendar.MILLISECOND);
		if(millisecond<10)
			millisecondStr="00"+String.valueOf(millisecond);
		else 
			if(millisecond<100)
				millisecondStr="0" + String.valueOf(millisecond);
			else
				millisecondStr=String.valueOf(millisecond);
		return millisecondStr;
	}
	
	/**
	 * 提供当前系统日期
	 * @return String类型的日期（年-月-日）
	 */
	public String getDate()
	{
		Calendar calendar=Calendar.getInstance(); 
		return this.calendarFormatDate(calendar);
	}
	
	/**
	 * 提供当前系统时间
	 * @return String类型时间（小时:分钟:秒）
	 */
	public String getTime()
	{
		Calendar calendar=Calendar.getInstance(); 
		return this.calendarFormatTime(calendar);
	}
	
	/**
	 * 提供当前系统时间包括毫秒
	 * @return String类型时间（小时:分钟:秒.毫秒）
	 */
	public String getLongTime()
	{
		Calendar calendar=Calendar.getInstance();
		String longTime;
		longTime= this.calendarFormatTime(calendar);
		longTime=longTime + "." + this.calendarFormatMillisecond(calendar);
		return longTime;
	}
	
	/**
	 * 提供当前系统日期时间（不包括毫秒）
	 * @return String类型日期时间（年-月-日 小时:分钟:秒）
	 */
	public String getDateTime()
	{
		Calendar calendar=Calendar.getInstance();
		String dateTime;
		dateTime= this.calendarFormatDate(calendar);
		dateTime=dateTime + " " + this.calendarFormatTime(calendar);
		return dateTime;
	}
	
	/**
	 * 产生自动编号（根据数据库自动编号配置信息来产生，如果用户未配置数据库中相应的配置则按默认方式生成！）
	 * 不能保证一定是唯一的，但唯一的机率达到99.99999％ 。
	 * @param tableName：数据库中的表名（为哪张表产生一个自动编号）
	 * @return 一个21位的自动编号（前四位是用户为其配置的，后17位是日期时间编号）
	 */
	public String bringNumber(String tableName)
	{
		String number="Numb";
		SessionCommit sessionCommit;
		try {
			sessionCommit = new SessionCommit();
			Session session=sessionCommit.getSession();
			Query query=session.createQuery
			("from ConfigBringNumber as cbn where cbn.tableName=:tableName");
			query.setParameter("tableName",tableName);
			if(query.list().size()>0)
			{
				ConfigBringNumber cbn=(ConfigBringNumber)query.list().get(0);
				number=cbn.getNumberChar();
			}
			number+=this.dtNumber();
			session.close();
		}catch(QueryException ex){
			errorMsg=ex.getMessage();
			System.out.println(errorMsg);
		} catch (HibernateException e) {
			e.printStackTrace();   
			errorMsg=e.getMessage();
		}
		return number;
	}

	/**
	 * 产生自动编号（根据数据库自动编号配置信息来产生）
	 * 此重载函数的对所产生的编号的唯一性得到了保障，但相应的效率就相应降低了
	 * @param SearchParameterEntity类型的 spe :封装有以下三个值的参数实体<br>
	 * <ul> tableName：数据库中的表名（为哪张表产生一个自动编号）</ul>
	 * <ul> pojoName：数据库表所对应的实体类名</ul>
	 * <ul> propertyId：实体中要产生自动编号的私有属性名</ul>
	 * @return 一个21位的自动编号（前四位是用户为其配置的，后17位是日期时间编号）
	 */
	public String bringNumber(BringNumParamEntity bNPE) 
	{
		int cut=0;
		String pojoName=bNPE.getPojoName();
		String tableName=bNPE.getTableName();
		String propertyId=bNPE.getPropertyId();
		String number= this.bringNumber(tableName);
		
		SearchParamEntity sPE=new SearchParamEntity();
		sPE.setPojoName(pojoName);
		sPE.setPropertyName(propertyId);
		sPE.setValue(number);
		if(this.exist(sPE))
			if(cut++>3)
				number = this.bringNumber(bNPE);
		return number;
	}
	
	/**
	 * 检查某一个数据或值在数据库中是否存在
	 * @param SearchParameterEntity类型的 spe :封装有以下三个值的参数实体<br>
	 * 		<ul>pojoName：要查找的值所在的实体的名字</ul>
	 * 		<ul>propertyName：实体中要查找的值所对应的私有成员属性名</ul>
	 * 		<ul>value 要查找的值</ul>
	 * @return True|False（存在|不存在）
	 */
	public boolean exist(SearchParamEntity spe)
	{
		errorMsg="";
		boolean flag=false;
		String pojoName=spe.getPojoName();
		String propertyName=spe.getPropertyName();
		String value=spe.getValue();
		SessionCommit sessionCommit;
		try {
			sessionCommit = new SessionCommit();
			Session session=sessionCommit.getSession();
			Query query=session.createQuery
			("from "+ pojoName +" as pojo where pojo."+ propertyName +"='"+ value +"'");
			if(query.list().size()>0)
				flag=true;
			session.close();
		}catch(QueryException ex){
			errorMsg=ex.getMessage();
			System.out.println(errorMsg);
		}catch(HibernateException e){
			e.printStackTrace();
			errorMsg=e.getMessage();
		}
		return flag;
	}
	
	/**
	 * 查找与某个值相匹配的结果集
	 * @param SearchParameterEntity类型的 spe :封装有以下三个值的参数实体<br>
	 * 		<ul>pojoName：要查找的值所在的实体的名字</ul>
	 * 		<ul>propertyName：实体中要查找的值所对应的私有成员属性名</ul>
	 * 		<ul>value 要查找的值</ul>
	 * @return 返回一个Query对象
	 * @version
	 * 		在正确调用该方法之后，得到一个Query对象，首先对该对象进行判断，Query.list().size()>0
	 * 		表示有数据，则可调用Query.list().size()方法获得其大小即记录的条数，然后循环编历Query
	 * 		对象，编历时通过Query.list().get(i)的方法(注意：i为循环时的控制变量)依次将其中的数据
	 * 		（记录）赋给相应的实体对象，然后再将相应的实体放入集合对象之中。得到一个存有数据集的集
	 * 		合对象。注意：在循环编历时要先实例化一个集合对象，在每一循环时都要再实例化一个持久层对
	 * 		象,即数据库表通过Hibernate映射在Java中的实体。
	 */
	public Query search(SearchParamEntity spe)
	{
		errorMsg="";
		Query query=null;
		String pojoName=spe.getPojoName();
		String propertyName=spe.getPropertyName();
		String value=spe.getValue();
		SessionCommit sessionCommit;
		try {
			sessionCommit = new SessionCommit();
			Session session=sessionCommit.getSession();
			query=session.createQuery
			("from "+ pojoName +" as pojo where pojo."+ propertyName +"='"+ value +"'");
			session.close();
		}catch(QueryException ex){
			errorMsg=ex.getMessage();
			System.out.println(errorMsg);
		}catch (HibernateException e){
			e.printStackTrace();
			errorMsg=e.getMessage();
		}
		return query;
	}
	
	/**
	 * 重载方法：查找与某个值相匹配的结果集
	 * @param hql hql语句
	 * @return Query对象
	 */
	public Query search(String hql)
	{
		errorMsg="";
		Query query=null;
		SessionCommit sessionCommit;
		try {
			sessionCommit = new SessionCommit();
			Session session=sessionCommit.getSession();
			query=session.createQuery(hql);
			session.close();
		}catch(QueryException ex){
			errorMsg=ex.getMessage();
			System.out.println(errorMsg);
			return query;
		}catch (HibernateException e){
			errorMsg=e.getMessage();
			e.printStackTrace();
			return query;
		}
		return query;
	}
	
	/**
	 * 重载方法：查找与某个值相匹配的结果集,并可实现分页
	 * @param ppe 封装有hql和pageIndex和pageSize的参数实体
	 * @return Query对象
	 */
	public Query search(PaginactionParamEntity ppe)
	{
		errorMsg="";
		Query query=null;
		String hql= ppe.getHql();
		int pageIndex=ppe.getPageIndex();
		int pageSize=ppe.getPageSize();
		SessionCommit sessionCommit;
		try {
			sessionCommit = new SessionCommit();
			Session session=sessionCommit.getSession();
			query=session.createQuery(hql);
//			从哪条记录开始
			query.setFirstResult((pageIndex - 1) * pageSize);
//			最多取多少条记录
			query.setMaxResults(pageSize);
			session.close();
		}catch(QueryException ex){
			errorMsg=ex.getMessage();
			System.out.println(errorMsg);
		}catch (HibernateException e){
			errorMsg=e.getMessage();
			e.printStackTrace();
		}
		return query;
	}
	
	/**
	 * 获得记录的条数
	 * @param pojoName:实体名
	 * @return
	 */
	public int resultNum(String pojoName)
	{
		errorMsg="";
		int resultInt=0;
		SessionCommit sessionCommit;
		try {
			sessionCommit = new SessionCommit();
			Session session=sessionCommit.getSession();
			String hql="select count(*) from " + pojoName;
			ArrayList al= (ArrayList)session.find(hql);
			if(al != null)
				resultInt = (int)((Integer)al.get(0)).longValue();
			session.close();
		}catch(QueryException ex){
			errorMsg=ex.getMessage();
			System.out.println(errorMsg);
		}catch (HibernateException e){
			errorMsg=e.getMessage();
			e.printStackTrace();
		}
		return resultInt;
	}
	
}