package com.cns.certservice.dao.impl;

import org.apache.log4j.Logger;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import com.cns.certservice.exception.DAOException;

public class HibernateTemplate {

    private HibernateTemplate() {

    }

    /**
     * static final session factory
     */
    private static SessionFactory sessionFactory = null;

    /**
     * local thread variable used for storing share session instance
     */
    private static final ThreadLocal localSession = new ThreadLocal();

    /**
     * log4j logger
     */
    private static final Logger logger = Logger
            .getLogger(HibernateTemplate.class);
    /**
     * use JTA transaction
     */
    /**
     * 该工具唯一实例。
     */
    private static HibernateTemplate instance = null;
    private static Transaction tx = null;
    private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
    private static final Configuration cfg = new Configuration();
    /** Holds a single instance of Session */
    private static final ThreadLocal threadLocal = new ThreadLocal();

    /**
     * 获取持久工具的唯一实例，以后不是使用单实例模式，而不是采用对象池支持。
     * @return　PersistentTool
     * @throws BaseException
     */
    public synchronized static HibernateTemplate getInstance() {
        if (instance == null) {
            instance = new HibernateTemplate();
            instance.initHibernate();
        }
        return instance;
    }

    /**
     * 实现Hibernate的初始化配置环境。
     */
    public void initHibernate() {
        try {
            //此处从系统路径中获取配置文件
            cfg.configure(CONFIG_FILE_LOCATION);
        } catch (HibernateException ex) {
            ex.printStackTrace();
        }
        try {
            // 装载配置，构造SessionFactory对象
            sessionFactory = cfg.buildSessionFactory();
        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }

    /**
     * Get the share session
     * @
     * @return Session share session
     */
    public  Session getSession() {
        logger.debug("Now enter into getSession method of DaoUtil");
        //obtain share session
        Session session = (Session) localSession.get();
        try {
            if (session == null||!session.isOpen()) {
                //get session by session factory
                session = sessionFactory.openSession();
                localSession.set(session);
            }
        } catch (HibernateException ex) {
            ex.printStackTrace();

        }
        return session;
    }

    /**
     * Close share session
     * @
     */
    public  void close() {
        logger.debug("Now enter into closeSessionl");
        //obtain share session
        Session session = (Session) localSession.get();
        localSession.set(null);
        if (session != null) {
            try {
                session.flush();
                session.close();
            } catch (HibernateException ex) {
                ex.printStackTrace();

            }
        }
    }

    /**
     * Begin JTA transaction
     * @
     */
    public  void beginTransaction() {
        logger.debug("Now enter into beginTransaction");
        try {
            Session session = (Session) localSession.get();
            tx = session.beginTransaction();
        } catch (Exception ex) {
            ex.printStackTrace();

        }
    }

    /**
     * Commit transaction
     * @
     */
    public  void commitTransaction() {
        try {
            tx.commit();
        } catch (Exception ex) {
            ex.printStackTrace();

        }
    }

    /**
     * Rollback transaction when breaching ACID operation
     * @
     */
    public  void rollbackTransaction() {
        try {
            tx.rollback();
        } catch (Exception ex) {
            ex.printStackTrace();

        }
    }

    /**
     * Insert a record into table
     * @param obj Object
     * @throws DAOException
     * @
     */
    public  int insertObject(Object obj) throws DAOException {
     int res = 0;
        logger.debug("Now enter into insertObject");
        //obtain current share session
        try {
            Session session = HibernateTemplate.getInstance().getSession();
            beginTransaction();
            Object robj = session.save(obj);
            if (robj instanceof Integer) {
    res = (Integer) robj;
   }
            if (robj instanceof String) {
    res =1;
   }
            session.flush();
        } catch (HibernateException ex) {
            rollbackTransaction();
            logger.error("insertObject error:", ex);
            throw new DAOException(ex);
        } finally {
            commitTransaction();
            close();
        }
        return res;
    }

    /**
     * Delete a record of database table by Hibernate po object
     * @param obj Object
     * @throws DAOException
     * @
     */
    public  boolean deleteObject(Object obj) throws DAOException {
     boolean res = false;
        logger.debug("Now enter into deleteObject method");
        //obtain current share session
        try {
            Session session = HibernateTemplate.getInstance().getSession();
            beginTransaction();
            session.delete(obj);
            session.flush();
            res = true;
        } catch (HibernateException ex) {
            rollbackTransaction();
            logger.error("deleteObject error:", ex);
            throw new DAOException(ex);
        } finally {
            commitTransaction();
            close();
        }
        return res;
    }

    /**
     * Update a record of database table
     * @param ob Object
     * @throws DAOException
     * @
     */
    public  boolean updateObject(Object ob) throws DAOException {
     boolean res = false;
        logger.debug("Now enter into updateObject");
        //obtain current share session
        try {
            Session session = HibernateTemplate.getInstance().getSession();
            beginTransaction();
            session.update(ob);
            session.flush();
            res= true;
        } catch (HibernateException ex) {
         rollbackTransaction();
          logger.error("updateObject error:", ex);
          throw new DAOException(ex);
        } finally {
            commitTransaction();
            close();
        }
        return res;
    }
}

Java之LinkedList集合结合listIterator的使用案例:
http://www.blogjava.net/wujun/archive/2009/05/18/65890.html      摘要:   阅读全文

------------------------==================--------------------------
这个过程只是在我做项目中的一个简单过程，给自己做个笔记！@_@

:我用的是tomcat和Jboss应用服务器。
      所以要将web工程和Ejb工程分开部署好，
web工程：tomcat/webapps/raweb/目录下通过dos命令打包（jar -cvf  raweb.jar *）最好是通过Ant工具这样比较方面些build.xml(自己试试写吧)！
Ejb工程：直接通过Myeclipse工具部署即可，Jboss目录--jboss/server/default/deploy/raejb.jar
     登陆进入使用的linux平台下：
1-web首先停止服务器，tomcat/bin目录下执行 ./shutdown.sh 如果以前发布过这些项目做些最好的方式做下备份，我是直接删除了tomcat/webapps/raweb（rm  -rf *）【删除某个目录下的所有文件】通过FTP工具上传本地打好的jar包到linux的tomcat/webapps/raweb下，然后执行该目录下解开jar命令：(jar -xvf raweb.jar ) ，删除该目录下的raweb.jar包OK！！启动服务，tomcat/bin目录下（./startup.sh）,然后查看日志命令(tail -f catalina.out)........ok
 2-ejb首先杀掉进程，查看信息命令(ps -ef|grep java), 找到你工程的进程号xxxx 执行(kill -9 xxxx)，jboss/server/default/deploy/下删除工程raejb.jar（rm -rf  raejb.jar），通过FTP上传本地jar包到该目录下，在jboss/bin/目录下启动命令(nohup ./run.sh) .查看日志(tail -f nohup.out) .....OK

顺便推荐大家一个个人感觉比putty和SSH Secure Shell还方便的shell工具 XManager3.0企业版的，网上找下，也有注册码。

WebLogic下:

应用路径
/app/weblogic/bea/domains/epay/applications/efb
日志路径
/app/weblogic/bea/domains/epay/logs/efb

tail -f /app/weblogic/bea/domains/epay/logs/efb/info.log

cd /app/weblogic/bea/domains/epay
netstat -lnap|grep 7005
kill -9 进程号
nohup ./startWebLogic.sh &

缓存目录
cd /app/weblogic/bea/domains/epay/servers/AdminServer/tmp/_WL_user

    只有注册用户登录后才能阅读该文。阅读全文 IN
确定给定的值是否与子查询或列表中的值相匹配。

EXISTS
指定一个子查询，检测行的存在。

比较使用 EXISTS 和 IN 的查询

这个例子比较了两个语义类似的查询。
第一个查询使用 EXISTS 而第二个查询使用 IN。注意两个查询返回相同的信息。
SELECT DISTINCT pub_name
FROM publishers
WHERE EXISTS
(SELECT *
FROM titles
WHERE pub_id = publishers.pub_id
AND type = 'business')

-- Or, using the IN clause:

SELECT distinct pub_name
FROM publishers
WHERE pub_id IN
(SELECT pub_id
FROM titles
WHERE type = 'business')

下面是任一查询的结果集：
pub_name
----------------------------------------
Algodata Infosystems
New Moon Books


exits 相当于存在量词：表示集合存在,也就是集合不为空只作用一个集合.
例如 exist P表示P不空时为真; not exist P表示p为空时为真in表示一个标量和一元关系的关系。
例如：s in P表示当s与P中的某个值相等时 为真; s not in P 表示s与P中的每一个值都不相等时 为真

在Oracle SQL中取数据时有时要用到in 和 exists 那么他们有什么区别呢？

1)性能上的比较
比如Select * from T1 where x in ( select y from T2 )
执行的过程相当于:
select *
  from t1, ( select distinct y from t2 ) t2
where t1.x = t2.y;

相对的

select * from t1 where exists ( select null from t2 where y = x )
执行的过程相当于:
for x in ( select * from t1 )
   loop
      if ( exists ( select null from t2 where y = x.x )
      then
         OUTPUT THE RECORD
      end if
end loop
表 T1 不可避免的要被完全扫描一遍

分别适用在什么情况?
以子查询 ( select y from T2 )为考虑方向
如果子查询的结果集很大需要消耗很多时间，但是T1比较小执行( select null from t2 where y = x.x )非常快，那么exists就比较适合用在这里
相对应得子查询的结果集比较小的时候就应该使用in.

in和exists
in 是把外表和内表作hash 连接，而exists是对外表作loop循环，每次loop循环再对内表进行查询。
一直以来认为exists比in效率高的说法是不准确的。
如果查询的两个表大小相当，那么用in和exists差别不大。

如果两个表中一个较小，一个是大表，则子查询表大的用exists，子查询表小的用in：
例如：表A（小表），表B（大表）
1：
select * from A where cc in (select cc from B)
效率低，用到了A表上cc列的索引；
select * from A where exists(select cc from B where cc=A.cc)
效率高，用到了B表上cc列的索引。

相反的
2：
select * from B where cc in (select cc from A)
效率高，用到了B表上cc列的索引；
select * from B where exists(select cc from A where cc=B.cc)
效率低，用到了A表上cc列的索引。

not in 和not exists
如果查询语句使用了not in 那么内外表都进行全表扫描，没有用到索引；
而not extsts 的子查询依然能用到表上的索引。
所以无论那个表大，用not exists都比not in要快。

in 与 =的区别
select name from student where name in ('zhang','wang','li','zhao');

与
select name from student where name='zhang' or name='li' or name='wang' or name='zhao'的结果是相同的。
创建过程的语法：     

简单的例子：

 

删除过程语法：

 

2、创建函数的语法：

 

简单函数的例子：

 

删除函数语法：

    只有注册用户登录后才能阅读该文。阅读全文      摘要:   使用的数据库是MSSQL，库名hibernate，预建立的表有3张。 分别是Student（学生）表，字段名：id、team_di、name、cardId、age。 team（班级）表，字段名：id、team_id。 Certificate（身份证）表，字段名：id、describe。 Student与Certificate是一对一的关系，team与Student是一对多的...  阅读全文