Hibernate框架简介(二)基本使用增、删、改、查

逃离我推掉我的手 2022-03-31 14:08 163阅读 0赞

### 一、Hibernate框架简介 ###

Hibernate是一个优秀的Java持久化层解决方案，是当今主流的对象-关系映射（ORM，ObjectRelationalMapping)工具

#### 1.1、理解持久化 ####

*  **瞬时状态：在程序运行的时候，有些程序数据是保存在内存中，当程序退出后，这些数据就不复存在了，所以称这些数据的状态为瞬时状态**
 *  **持久状态：在使用一此软件的时候，有些数据，在程序退出后，还以文件等形式保存在硬盘或者数据库中，称这些数据的状态是持久状态**
 *  **持久化：持久化就是将程序中的数据在瞬时状态和持久状态之间转换的机制。（如：JDBC)**

#### 1.2、对象-关系映射（ORM） ####

Java是一种面象对象的设计语言。在程序运行时的数据是以对象形式存在内存中，而保存数据时，又要以对象的形式存在关系型数据库中。

**ORM简单讲：就是能在对象和关系型数据库两者之间进行数据转换的机制。Hibernate就是这样一个中间的解决方案。关系如下图**

**![101442409499720.png][]**

#### 1.3、ORM框架综述 ####

ORM:对象关系映射（Object Relation Mapping)

Hibernate框架：能够实现ORM框架

Hibernate是一个优秀的Java持久化层解决方案，是当今主流的对象-关系映射（ORM，ObjectRelationalMap

Hibernate框架对JDBC时行和封装，简化了数据访问层。可应用在任何使用JDBC的场合如：Servlet、JSP的WEB应用，JAVA客户端等。

![101946466675390.png][]

### 二、Hibernate下载 ###

官网：[http://sourceforge.net/projects/hibernate/files/hibernate3/][http_sourceforge.net_projects_hibernate_files_hibernate3]

这里下载的是3.3.2GA，

解压后，将根目录下的hibernate3.jar和将lib目录下全部的jar导入项目中

同时将数据库驱动也导入这里使用Oracle 11g

![101506539954901.png][]其中加入了一些其它的jar包如：JSTL包

当然也可以用MyEclipse完全集成，不用下载

### 三、Hibernate配置 ###

#### 3.1、创建hibernate.cfg.xml文件. ####

这是配置文件默认名.一般放在src目录下:作用指定数据库连接的信息及映射文件路径

获取配置文件进行修改。当然如果记得了就全写也可以。在下载的Hibernate解压目录下就有配置文件模板

hibernate-distribution-3.3.2.GA-dist\\hibernate-distribution-3.3.2.GA\\project\\tutorials\\web\\src\\main\\resources此目录下就有，将其复制到src目录下进行修改

<?xml version='1.0' encoding='utf-8'?>
    <!DOCTYPE hibernate-configuration PUBLIC
            "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
            "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
    
    <hibernate-configuration>
    
        <session-factory>
    
            
            
            <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
            
            <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
            
            <property name="connection.username">sa</property>
            
            <property name="connection.password"></property>
    
            
            
            <property name="connection.pool_size">2</property>
    
            
            
            <property name="dialect">org.hibernate.dialect.HSQLDialect</property>
    
            
            
            <property name="current_session_context_class">org.hibernate.context.ManagedSessionContext</property>
    
            
            
            <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
    
            
            
            <property name="show_sql">true</property>
    
            
            
            <property name="hbm2ddl.auto">create</property>
            
            <mapping resource="org/hibernate/tutorial/domain/Event.hbm.xml"/>
            <mapping resource="org/hibernate/tutorial/domain/Person.hbm.xml"/>
    
        </session-factory>
    
    </hibernate-configuration>

这里暂时只做数据库的连接配置Oracle的

#### 3.2、创建持久化类和映射文件 ####

也就是创建实体类的配置文件如：Login.hbm.xml(Login为类名)，并在hibernate.cfg.xml文件下方</session-factory>前面中添加映射文件路径

**1、在数据库中创建一张表**

create table login
    (
           username   varchar2(20)  primary key,
           password   varchar2(20)
    );

**2、创建Login实体类**

package com.pb.entity;
    /*
     * 登录实体类
     */
    public class Login {
            private String username;
            private String password;
            
            
            public String getUsername() {
                return username;
            }
            public void setUsername(String username) {
                this.username = username;
            }
            public String getPassword() {
                return password;
            }
            public void setPassword(String password) {
                this.password = password;
            }
            
            
            
    }

**3、在实体类的同一个包下创建实体类的配置文件**

<?xml version='1.0' encoding='utf-8'?>
     
    <!DOCTYPE hibernate-mapping PUBLIC    
            "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
            "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
    
    
    <hibernate-mapping>
     
        <class name="com.pb.entity.Login" table="LOGIN" schema="accp">
          
            
            <id name="username" type="java.lang.String">
             
                <column name="USERNAME" length="20" />
                
            
                <generator class="assigned" />
            </id>
            
            
            <property name="password" type="java.lang.String">
            
                <column name="PASSWORD" length="20" not-null="true"/>
            </property>
            
        </class>
    </hibernate-mapping>

在src下的配置文件中添加映射

#### 3.3、创建Hibernate连接工具类 ####

**Hibernater主要接口和类:**

**Configuration**

**SessionFactory:DriverManager**

**Session:Connection**

**Transaction**

**Query:Statement和PreparedStatement**

在下载的包中有提供好的一个比较简单的工具类

package com.pb.until;
    
    import org.hibernate.SessionFactory;
    import org.hibernate.cfg.Configuration;
    
    public class HibernateUtil {
    
        private static final SessionFactory sessionFactory;
    
        static {
            try {
                // Create the SessionFactory from hibernate.cfg.xml
                sessionFactory = new Configuration().configure().buildSessionFactory();
            } catch (Throwable ex) {
                // Make sure you log the exception, as it might be swallowed
                System.err.println("Initial SessionFactory creation failed." + ex);
                throw new ExceptionInInitializerError(ex);
            }
        }
    
        public static SessionFactory getSessionFactory() {
            return sessionFactory;
        }
    
    }

这个比较，也可以增加一功能

相比较MyEclipse提供的一个比较完美

package com.pb.until;
    
    import org.hibernate.HibernateException;
    import org.hibernate.Session;
    import org.hibernate.cfg.Configuration;
    
    /**
     * Configures and provides access to Hibernate sessions, tied to the
     * current thread of execution.  Follows the Thread Local Session
     * pattern, see {
         @link http://hibernate.org/42.html }.
     */
    public class HibernateSessionFactory {
    
        /** 
         * Location of hibernate.cfg.xml file.
         * Location should be on the classpath as Hibernate uses  
         * #resourceAsStream style lookup for its configuration file. 
         * The default classpath location of the hibernate config file is 
         * in the default package. Use #setConfigFile() to update 
         * the location of the configuration file for the current session.   
         */
        private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
        private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
        private  static Configuration configuration = new Configuration();    
        private static org.hibernate.SessionFactory sessionFactory;
        private static String configFile = CONFIG_FILE_LOCATION;
    
        static {
            try {
                configuration.configure(configFile);
                sessionFactory = configuration.buildSessionFactory();
            } catch (Exception e) {
                System.err
                        .println("%%%% Error Creating SessionFactory %%%%");
                e.printStackTrace();
            }
        }
        private HibernateSessionFactory() {
        }
        
        /**
         * Returns the ThreadLocal Session instance.  Lazy initialize
         * the <code>SessionFactory</code> if needed.
         *
         *  @return Session
         *  @throws HibernateException
         */
        public static Session getSession() throws HibernateException {
            Session session = (Session) threadLocal.get();
    
            if (session == null || !session.isOpen()) {
                if (sessionFactory == null) {
                    rebuildSessionFactory();
                }
                session = (sessionFactory != null) ? sessionFactory.openSession()
                        : null;
                threadLocal.set(session);
            }
    
            return session;
        }
    
        /**
         *  Rebuild hibernate session factory
         *
         */
        public static void rebuildSessionFactory() {
            try {
                configuration.configure(configFile);
                sessionFactory = configuration.buildSessionFactory();
            } catch (Exception e) {
                System.err
                        .println("%%%% Error Creating SessionFactory %%%%");
                e.printStackTrace();
            }
        }
    
        /**
         *  Close the single hibernate session instance.
         *
         *  @throws HibernateException
         */
        public static void closeSession() throws HibernateException {
            Session session = (Session) threadLocal.get();
            threadLocal.set(null);
    
            if (session != null) {
                session.close();
            }
        }
    
        /**
         *  return session factory
         *
         */
        public static org.hibernate.SessionFactory getSessionFactory() {
            return sessionFactory;
        }
    
        /**
         *  return session factory
         *
         *    session factory will be rebuilded in the next call
         */
        public static void setConfigFile(String configFile) {
            HibernateSessionFactory.configFile = configFile;
            sessionFactory = null;
        }
    
        /**
         *  return hibernate configuration
         *
         */
        public static Configuration getConfiguration() {
            return configuration;
        }
    
    }

根据需要选择

### 四、Hibernate的持久化操作的步骤 ###

#### 4.1、读取并散板配置文件 ####

Configuration config=new Configuration().configure();

#### 4.2、读取并解析映射信息，创建SessionFactory ####

SessionFactory factory=config.buildSessionFactory();

#### 4.3、打开session ####

Session session=factory.openSessin();

#### 4.4、开始一个事务（增、删、改操作必须，查询操作可选） ####

Transaction tran=session.beginTransaction();

#### 4.5、操作化操作 ####

session.save(对象);
    session.update(对象);
    session.delete(对象);
    session.get(主键之类的);

#### 4.6、提交事务 ####

tran.commit();

#### 4.7、关闭session ####

session.close();

### 五、Hibernate使用 ###

实现增、删、改、查的类

package com.pb.LoginDao;
    
    import java.util.List;
    
    import org.hibernate.HibernateException;
    import org.hibernate.Query;
    import org.hibernate.Session;
    import org.hibernate.Transaction;
    
    import com.pb.entity.Login;
    import com.pb.until.HibernateSessionFactory;
    import com.pb.until.HibernateUtil;
    
    public class LoginDao {
    
        /*
         * 增加
         */
        public void save(Login login) {
            // 得到Session
            Session session = HibernateUtil.getSessionFactory().openSession();
            Transaction tran = null;
            // 也可以
            // Session session=new
            // Configuration().configure().buildSessionFactory().openSession();
            try {
                // 打开事务
                tran = session.beginTransaction();
                // 执行数据添加
                session.save(login);
                // 提交事务
                tran.commit();
                System.out.println("用户信息添加成功");
            } catch (HibernateException e) {
                // 事务回滚
                tran.rollback();
                e.printStackTrace();
                System.out.println("用户信息添加失败");
            } finally {
                // 关闭session
                session.close();
            }
    
        }
    
        /*
         * 修改根据用户名
         */
        public void update(Login login) {
            // 得到Session
            Session session = HibernateUtil.getSessionFactory().openSession();
            Transaction tran = null;
            // 也可以
            // Session session=new
            // Configuration().configure().buildSessionFactory().openSession();
            try {
                // 打开事务
                tran = session.beginTransaction();
                // 执行数据添加
                session.update(login);
                // 提交事务
                tran.commit();
                System.out.println("用户信息修改成功");
            } catch (HibernateException e) {
                // 事务回滚
                tran.rollback();
                e.printStackTrace();
                System.out.println("用户信息修改失败");
            } finally {
                // 关闭session
                session.close();
            }
        }
    
        /*
         * 修改根据用户名修改密码
         */
        public void delte(Login login) {
            // 得到Session
            Session session = HibernateUtil.getSessionFactory().openSession();
            Transaction tran = null;
            // 也可以
            // Session session=new
            // Configuration().configure().buildSessionFactory().openSession();
            try {
                // 打开事务
                tran = session.beginTransaction();
                // 执行数据添加
                session.delete(login);
                // 提交事务
                tran.commit();
                System.out.println("用户信息删除成功");
            } catch (HibernateException e) {
                // 事务回滚
                tran.rollback();
                e.printStackTrace();
                System.out.println("用户信息删除失败");
            } finally {
                // 关闭session
                session.close();
            }
        }
    
        /*
         * 查询一查询全部用户
         */
        public List<Login> QueryALL() {
            // 使用myeclipse提供的工具类来得到session
            Session session = HibernateSessionFactory.getSession();
            // 建立查询
            Query query = session.createQuery("from Login");
            // 查询重到List集合
            List<Login> list = query.list();
            // 关闭session
            session.close();
            // 返回结果集合
            return list;
        }
    
        /*
         * 查询二 查询指定的用户名的
         */
        public Login QueryByName(String username) {
            // 使用myeclipse提供的工具类来得到session
            Session session = HibernateSessionFactory.getSession();
            // 建立查询
            Query query = session.createQuery("from Login l where l.username=?");
            // 占位
            query.setString(0, username);
    
            // 查询返回唯一
            Login login = (Login) query.uniqueResult();
            // 关闭session
            session.close();
            // 返回结果集合
            return login;
        }
    
        /*
         * 查询三，模糊查询
         */
        public List<Login> QueryLikeName(String username) {
            // 使用myeclipse提供的工具类来得到session
            Session session = HibernateSessionFactory.getSession();
            // 建立查询
            Query query = session
                    .createQuery("from Login l where l.username like ?");
            // 占位
            query.setString(0, "%" + username + "%");
            // 查询重到List集合
            List<Login> list = query.list();
            // 关闭session
            session.close();
            // 返回结果集合
            return list;
        }
    
    }

测试类:

package com.pb.test;
    
    import java.util.List;
    
    import com.pb.LoginDao.LoginDao;
    import com.pb.entity.Login;
    
    public class Test {
    
        public static void main(String[] args) {
            //声明LoginDao对象
            LoginDao loginDao=new LoginDao();
    //声明对象并赋初始值
            Login login=new Login();
            login.setUsername("Jack");
            login.setPassword("blue");
            //执行添加
            loginDao.save(login);
            //执行修改
            login.setUsername("Jack");
            login.setPassword("while");
            loginDao.update(login);
            //执行删除
            loginDao.delte(login);
            
            System.out.println("=========查询全部========");
            //查询全部
            List<Login> list=loginDao.QueryALL();
            for (Login log : list) {
                System.out.println("用户名:"+log.getUsername()+"    密码："+log.getPassword());
            }
            
            System.out.println("=========精确查询========");
            //查询一个用户
            Login lg=loginDao.QueryByName("ffff");
            if(lg!=null){
                System.out.println("用户名："+lg.getUsername()+"   密码:"+lg.getPassword());
            }else{
                System.out.println("没有此用户");
            }
            System.out.println("=========模糊查询========");
            //模糊查询
            List<Login> likelist=loginDao.QueryLikeName("t");
            for (Login lo : likelist) {
                System.out.println("用户名:"+ lo.getUsername()+"    密码："+ lo.getPassword());
            }
        }
    
    }

[101442409499720.png]: /images/20220331/9021b55846fb4f779013717160218208.png
[101946466675390.png]: /images/20220331/ddb7c01de31f4b1da7e4222276c78621.png
[http_sourceforge.net_projects_hibernate_files_hibernate3]: http://sourceforge.net/projects/hibernate/files/hibernate3/
[101506539954901.png]: /images/20220331/5fb70d23e01e4f6995fe7f5b9030827c.png