Hiberate 学习1 基本使用

最新推荐文章于 2024-08-24 17:58:01 发布
转载 最新推荐文章于 2024-08-24 17:58:01 发布 · 509 阅读 · 1
本文详细介绍Hibernate框架的基本使用方法，包括环境搭建、实体类映射、预定义类型的使用等，并通过实战案例展示如何使用Hibernate进行数据库操作。
Top

JAVA Hibernate DAY01

  1. Hibernate基本使用
  2. Hibernate映射类型
  3. 在NETCTOSS中引入Hibernate
  4. 使用Hibernate重构资费DAO

1 Hibernate基本使用

1.1 问题

使用Hibernate实现对员工表的增、删、改、查。

1.2 方案

Hibernate使用步骤：

  1. 导入Hibernate包，以及数据库驱动包。
  2. 引入Hibernate主配置文件hibernate.cfg.xml。
  3. 创建实体类。
  4. 创建映射关系文件。
  5. 使用Hibernate常用API执行增删改查操作。

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：准备工作

创建员工表EMP，建表语句如下：


   
  1. CREATE TABLE EMP(
  2.   ID            NUMBER(4) CONSTRAINT EMP_ID_PK PRIMARY KEY,
  3.   NAME        VARCHAR(50)  NOT NULL,
  4.   AGE        NUMBER(11),
  5.   SALARY        NUMBER(7,2),
  6.   MARRY         CHAR(1),
  7.   BIRTHDAY     DATE,
  8.   LAST_LOGIN_TIME    DATE
  9.   );
  11. CREATE SEQUENCE emp_seq;

创建一个WEB项目，名为HibernateDay01。

步骤二：导包

导入Hibernate开发包，以及数据库驱动包，完成后项目的包结构如下图：

图-1

步骤三：引入Hibernate主配置文件

将Hibernate主配置文件hibernate.cfg.xml复制到项目中，放在src根路径下。并在主配置文件中配置好数据库连接信息，以及Hibernate框架参数，代码如下：


   
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3.         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4.         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6.     <session-factory>
  7.         <!--数据库连接信息，根据自己的数据库进行配置 -->
  8.         <property name="connection.url">
  9.             jdbc:oracle:thin:@localhost:1521:xe
  10.         </property>
  11.         <property name="connection.username">lhh</property>
  12.         <property name="connection.password">123456</property>
  13.         <property name="connection.driver_class">
  14.             oracle.jdbc.OracleDriver
  15.         </property>
  16.         
  17.         <!-- Hibernate配置信息 -->
  18.         <!-- dialect方言，用于配置生成针对哪个数据库的SQL语句 -->
  19.         <property name="dialect">
  20.             <!--方言类，Hibernate提供的，用于封装某种特定数据库的方言 -->
  21.             org.hibernate.dialect.OracleDialect
  22.         </property>
  23.         <!-- Hibernate生成的SQL是否输出到控制台 -->
  24.         <property name="show_sql">true</property>
  25.         <!--将SQL输出时是否格式化 -->
  26.         <property name="format_sql">true</property>
  27.         
  28.     </session-factory>
  29. </hibernate-configuration>

步骤四：创建实体类

创建包com.tarena.entity，并在该包下创建员工表对应的实体类Emp.java，用于封装员工表的数据，代码如下：


   
  1. packagecom.tarena.entity;
  3. importjava.sql.Date;
  4. importjava.sql.Timestamp;
  6. public class Emp {
  8.     private Integer id;
  9.     private String name;
  10.     private Integer age;
  11.     private Double salary;
  12.     private Boolean marry;
  13.     private Date birthday;
  14.     private Timestamp lastLoginTime;
  16.     public Integer getId() {
  17.         return id;
  18.     }
  20.     public void setId(Integer id) {
  21.         this.id = id;
  22.     }
  24.     public String getName() {
  25.         return name;
  26.     }
  28.     public void setName(String name) {
  29.         this.name = name;
  30.     }
  32.     public Integer getAge() {
  33.         return age;
  34.     }
  36.     public void setAge(Integer age) {
  37.         this.age = age;
  38.     }
  40.     public Double getSalary() {
  41.         return salary;
  42.     }
  44.     public void setSalary(Double salary) {
  45.         this.salary = salary;
  46.     }
  48.     public Boolean getMarry() {
  49.         return marry;
  50.     }
  52.     public void setMarry(Boolean marry) {
  53.         this.marry = marry;
  54.     }
  56.     public Date getBirthday() {
  57.         return birthday;
  58.     }
  60.     public void setBirthday(Date birthday) {
  61.         this.birthday = birthday;
  62.     }
  64.     public Timestamp getLastLoginTime() {
  65.         returnlastLoginTime;
  66.     }
  68.     public void setLastLoginTime(Timestamp lastLoginTime) {
  69.         this.lastLoginTime = lastLoginTime;
  70.     }
  72. }

步骤五：创建映射关系文件

在com.tarena.entity包下，创建员工实体类的映射关系文件，名为Emp.hbm.xml，并在该文件中配置实体类和表的关系，以及类中属性和表中字段的关系，代码如下：


   
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6.     <!--配置实体类和表的关系 -->
  7.     <class name="com.tarena.entity.Emp" table="emp">
  8.         <!--配置主键属性和字段的关系 -->
  9.         <id name="id" type="java.lang.Integer" column="id">
  10.             <!--用来指明主键的生成方式 -->
  11.             <generator class="sequence">
  12.                 <!--指定用于生成主键的sequence -->
  13.                 <param name="sequence">emp_seq</param>
  14.             </generator>
  15.         </id>
  16.         
  17.         <!--配置实体类中属性与表中字段的关系 -->
  18.         <property name="name" 
  19.             type="java.lang.String" column="name"/>
  20.         <property name="age" 
  21.             type="java.lang.Integer" column="age"/>
  22.         <property name="salary" 
  23.             type="java.lang.Double" column="salary"/>
  24.         <property name="birthday" 
  25.             type="java.sql.Date" column="birthday"/>
  26.         <property name="lastLoginTime" 
  27.             type="java.sql.Timestamp" column="last_login_time"/>
  28.     </class>
  29. </hibernate-mapping>

注意，先不要配置布尔型属性marry，后面会单独讲解布尔型属性的配置及使用。

步骤六：声明映射关系文件

在主配置文件hibernate.cfg.xml中，声明映射关系文件Emp.hbm.xml，代码如下：


   
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3.         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4.         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6.     <session-factory>
  7.         <!--数据库连接信息，根据自己的数据库进行配置 -->
  8.         <property name="connection.url">
  9.             jdbc:oracle:thin:@localhost:1521:xe
  10.         </property>
  11.         <property name="connection.username">lhh</property>
  12.         <property name="connection.password">123456</property>
  13.         <property name="connection.driver_class">
  14.             oracle.jdbc.OracleDriver
  15.         </property>
  16.         
  17.         <!-- Hibernate配置信息 -->
  18.         <!-- dialect方言，用于配置生成针对哪个数据库的SQL语句 -->
  19.         <property name="dialect">
  20.             <!--方言类，Hibernate提供的，用于封装某种特定数据库的方言 -->
  21.             org.hibernate.dialect.OracleDialect
  22.         </property>
  23.         <!-- Hibernate生成的SQL是否输出到控制台 -->
  24.         <property name="show_sql">true</property>
  25.         <!--将SQL输出时是否格式化 -->
  26.         <property name="format_sql">true</property>
  27.         
  28.         <!--声明映射关系文件 -->
  29.         <mapping resource="com/tarena/entity/Emp.hbm.xml" />
  30.     </session-factory>
  31. </hibernate-configuration>

步骤七：创建Session工具类

创建HibernateUtil工具类，用于创建Session对象，代码如下：


   
  1. packagecom.tarena.util;
  3. importorg.hibernate.Session;
  4. importorg.hibernate.SessionFactory;
  5. importorg.hibernate.cfg.Configuration;
  7. public class HibernateUtil {
  9.     private static SessionFactorysessionFactory;
  10.     
  11.     static {
  12.         // 加载Hibernate主配置文件
  13.         Configuration conf = new Configuration();
  14.         conf.configure("/hibernate.cfg.xml");
  15.         sessionFactory = conf.buildSessionFactory();
  16.     }
  18.     /**
  19.      * 创建session
  20.      */
  21.     public static Session getSession() {
  22.         returnsessionFactory.openSession();
  23.     }
  24.     
  25.     public static void main(String[] args) {
  26.         System.out.println(getSession());
  27.     }
  29. }

步骤八：练习使用Hibernate对员工表进行增删改查

创建包com.tarena.test，并在该包下创建一个JUNIT测试类，并在类中使用Hibernate写出对EMP表的增删改查的方法，代码如下：


   
  1. packagecom.tarena.test;
  3. importjava.sql.Date;
  4. importjava.sql.Timestamp;
  5. importjava.util.List;
  6. importorg.hibernate.HibernateException;
  7. importorg.hibernate.Query;
  8. importorg.hibernate.Session;
  9. importorg.hibernate.Transaction;
  10. importorg.junit.Test;
  11. importcom.tarena.entity.Emp;
  12. importcom.tarena.util.HibernateUtil;
  14. /**
  15.  *    演示Hibernate的基本使用
  16.  */
  17. public class TestEmp {
  19.     /**
  20.      * 新增emp
  21.      */
  22.     @Test
  23.     public void add() {
  24.         // 模拟要新增的emp
  25.         Emp e = new Emp();
  26.         e.setName("ggg");
  27.         e.setAge(29);
  28.         e.setMarry(false);
  29.         e.setSalary(8000.00);
  30.         e.setBirthday(Date.valueOf("1983-10-20"));
  31.         e.setLastLoginTime(
  32.             new Timestamp(System.currentTimeMillis()));
  34.         // 获取session
  35.         Session session = HibernateUtil.getSession();
  36.         // 开启事务
  37.         Transaction ts = session.beginTransaction();
  38.         try {
  39.             // 执行新增
  40.             session.save(e);
  41.             // 提交事务
  42.             ts.commit();
  43.         } catch (HibernateException e1) {
  44.             e1.printStackTrace();
  45.             // 回滚事务
  46.             ts.rollback();
  47.         } finally {
  48.             session.close();
  49.         }
  50.     }
  52.     /**
  53.      * 根据ID查询emp
  54.      */
  55.     @Test
  56.     public void findById() {
  57.         Session session = HibernateUtil.getSession();
  58.         Empemp = (Emp) session.get(Emp.class, 201);
  59.         System.out.println(emp.getName());
  60.         System.out.println(emp.getBirthday());
  61.         System.out.println(emp.getLastLoginTime());
  62.         session.close();
  63.     }
  65.     /**
  66.      * 修改emp
  67.      */
  68.     @Test
  69.     public void update() {
  70.         Session session = HibernateUtil.getSession();
  71.         // 查询要修改的数据
  72.         Empemp = (Emp) session.get(Emp.class, 42);
  73.         // 开启事务
  74.         Transaction ts = session.beginTransaction();
  75.         try {
  76.             // 模拟修改数据
  77.             emp.setName("ee");
  78.             emp.setAge(20);
  79.             // 执行修改
  80.             session.update(emp);
  81.             // 提交事务
  82.             ts.commit();
  83.         } catch (HibernateException e) {
  84.             e.printStackTrace();
  85.             // 回滚事务
  86.             ts.rollback();
  87.         } finally {
  88.             // 关闭连接
  89.             session.close();
  90.         }
  91.     }
  93.     /**
  94.      * 删除emp
  95.      */
  96.     @Test
  97.     public void delete() {
  98.         Session session = HibernateUtil.getSession();
  99.         Empemp = (Emp) session.get(Emp.class, 148);
  100.         Transaction ts = session.beginTransaction();
  101.         try {
  102.             session.delete(emp);
  103.             ts.commit();
  104.         } catch (HibernateException e) {
  105.             e.printStackTrace();
  106.             ts.rollback();
  107.         } finally {
  108.             session.close();
  109.         }
  110.     }
  112.     /**
  113.      * 查询全部emp
  114.      */
  115.     @Test
  116.     public void findAll() {
  117.         String hql = "from Emp";
  118.         Session session = HibernateUtil.getSession();
  119.         Query query = session.createQuery(hql);
  120.         List<Emp>emps = query.list();
  121.         for (Emp e : emps) {
  122.             System.out.println(e.getName());
  123.         }
  124.         session.close();
  125.     }
  127. }

步骤九：测试

以JUNIT方式运行上面的每一个测试方法，并观察控制台输出的SQL。

1.4 完整代码

以下是本案例的完整代码。

其中建表语句完整代码如下：

代码

主配置文件hibernate.cfg.xml完整代码如下：

代码

实体类Emp.java完整代码如下：

代码

映射关系文件Emp.hbm.xml完整代码如下：

代码

HibernateUtil完整代码如下：

代码

JUNIT测试类代码如下：

代码

2 Hibernate映射类型

2.1 问题

使用Hibernate预定义类型配置属性和字段的映射关系。

2.2 方案

将项目HibernateDay01中，Emp.hbm.xml里面每个属性的配置，其type用Hibernate预定义类型来重构。由于Hibernate预定义类型支持布尔值，因此在该配置文件中追加marry属性的配置。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：重构Emp.hbm.xml

重构Emp.hbm.xml，将各个属性的type由Java类型改为Hibernate预定义类型，同时追加marry属性，并使用布尔型来配置该属性，代码如下：


   
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6.     <!--配置实体类和表的关系 -->
  7.     <class name="com.tarena.entity.Emp" table="emp">
  8.         <!--配置主键属性和字段的关系 -->
  9.         <id name="id" type="integer" column="id">
  10.             <!--用来指明主键的生成方式 -->
  11.             <generator class="sequence">
  12.                 <!--指定用于生成主键的sequence -->
  13.                 <param name="sequence">emp_seq</param>
  14.             </generator>
  15.         </id>
  16.         
  17.         <!--配置实体类中属性与表中字段的关系 -->
  18.         <property name="name" 
  19.             type="string" column="name"/>
  20.         <property name="age" 
  21.             type="integer" column="age"/>
  22.         <property name="salary" 
  23.             type="double" column="salary"/>
  24.         <property name="birthday" 
  25.             type="date" column="birthday"/>
  26.         <property name="lastLoginTime" 
  27.             type="timestamp" column="last_login_time"/>
  28.         <property name="marry"
  29.             type="yes_no" column="marry"/>
  30.     </class>
  31. </hibernate-mapping>

步骤二：测试

再次以JUNIT方式执行测试代码中的每个方法，看控制台输出结果是否正确。

2.4 完整代码

以下是本案例的完整代码。

其中Emp.hbm.xml完整代码如下：

代码

其他代码不变，此处不再重复。

3 在NETCTOSS中引入Hibernate

3.1 问题

将Hibernate框架引入到NETCTOSS。

3.2 方案

将Hibernate框架引入到NETCTOSS，以保证在项目中可以使用Hibernate来进行数据库访问。根据Hibernate的使用步骤，我们需要在项目中引入Hibernate开发包、主配置文件，并创建HibernateUtil工具类。

3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：导包

在NETCTOSS项目中，导入Hibernate开发包，导入后项目的包结构如下图：

图-2

步骤二：引入主配置文件

将Hibernate主配置文件引入到项目中，放于src根路径下，该文件可以从HibernateDay01项目中直接复制过来，并将声明映射关系文件部分代码去掉，代码如下：


   
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3.         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4.         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6.     <session-factory>
  7.         <!--数据库连接信息，根据自己的数据库进行配置 -->
  8.         <property name="connection.url">
  9.             jdbc:oracle:thin:@localhost:1521:xe
  10.         </property>
  11.         <property name="connection.username">lhh</property>
  12.         <property name="connection.password">123456</property>
  13.         <property name="connection.driver_class">
  14.             oracle.jdbc.OracleDriver
  15.         </property>
  16.         
  17.         <!-- Hibernate配置信息 -->
  18.         <!-- dialect方言，用于配置生成针对哪个数据库的SQL语句 -->
  19.         <property name="dialect">
  20.             <!--方言类，Hibernate提供的，用于封装某种特定数据库的方言 -->
  21.             org.hibernate.dialect.OracleDialect
  22.         </property>
  23.         <!-- Hibernate生成的SQL是否输出到控制台 -->
  24.         <property name="show_sql">true</property>
  25.         <!--将SQL输出时是否格式化 -->
  26.         <property name="format_sql">true</property>
  27.         
  28.     </session-factory>
  29. </hibernate-configuration>

步骤三：创建HibernateUtil工具类

在com.netctoss.util包下，创建HibernateUtil工具类，该类可以直接从HibernateDay01项目中复制过来，代码如下：


   
  1. packagecom.netctoss.util;
  3. importorg.hibernate.Session;
  4. importorg.hibernate.SessionFactory;
  5. importorg.hibernate.cfg.Configuration;
  7. public class HibernateUtil {
  9.     private static SessionFactorysessionFactory;
  10.     
  11.     static {
  12.         // 加载Hibernate主配置文件
  13.         Configuration conf = new Configuration();
  14.         conf.configure("/hibernate.cfg.xml");
  15.         sessionFactory = conf.buildSessionFactory();
  16.     }
  18.     /**
  19.      * 创建session
  20.      */
  21.     public static Session getSession() {
  22.         returnsessionFactory.openSession();
  23.     }
  24.     
  25.     public static void main(String[] args) {
  26.         System.out.println(getSession());
  27.     }
  29. }

3.4 完整代码

下面是本案例的完整代码。

其中主配置文件完整代码如下：

代码

HibernateUtil工具类完整代码如下：

代码

4 使用Hibernate重构资费DAO

4.1 问题

使用Hibernate重构资费DAO的实现类。

4.2 方案

使用Hibernate的增删改查API，重构资费DAO的实现类。

4.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：创建资费的映射关系文件

在com.netctoss.entity包下，创建资费的映射关系文件，名为Cost.hbm.xml，代码如下：


   
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6.     <class name="com.netctoss.entity.Cost" table="cost">
  7.         <id name="id" type="integer" column="id">
  8.             <!--用来指明主键的生成方式 -->
  9.             <generator class="sequence">
  10.                 <param name="sequence">cost_seq</param>
  11.             </generator>
  12.         </id>
  13.         
  14.         <property name="name" 
  15.             type="string" column="name" />
  16.         <property name="baseDuration" 
  17.             type="integer" column="base_duration" />
  18.         <property name="baseCost" 
  19.             type="double" column="base_cost" />
  20.         <property name="unitCost" 
  21.             type="double" column="unit_cost" />
  22.         <property name="status" 
  23.             type="string" column="status" />
  24.         <property name="descr" 
  25.             type="string" column="descr" />
  26.         <property name="createTime" 
  27.             type="date" column="creatime" />
  28.         <property name="startTime" 
  29.             type="date" column="startime" />
  30.         <property name="costType" 
  31.             type="string" column="cost_type" />
  32.     </class>
  33. </hibernate-mapping>

步骤二：声明映射关系文件

在hibernate.cfg.xml中声明映射关系文件，代码如下：


   
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3.         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4.         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6.     <session-factory>
  7.         <!--数据库连接信息，根据自己的数据库进行配置 -->
  8.         <property name="connection.url">
  9.             jdbc:oracle:thin:@localhost:1521:xe
  10.         </property>
  11.         <property name="connection.username">lhh</property>
  12.         <property name="connection.password">123456</property>
  13.         <property name="connection.driver_class">
  14.             oracle.jdbc.OracleDriver
  15.         </property>
  16.         
  17.         <!-- Hibernate配置信息 -->
  18.         <!-- dialect方言，用于配置生成针对哪个数据库的SQL语句 -->
  19.         <property name="dialect">
  20.             <!--方言类，Hibernate提供的，用于封装某种特定数据库的方言 -->
  21.             org.hibernate.dialect.OracleDialect
  22.         </property>
  23.         <!-- Hibernate生成的SQL是否输出到控制台 -->
  24.         <property name="show_sql">true</property>
  25.         <!--将SQL输出时是否格式化 -->
  26.         <property name="format_sql">true</property>
  27.         
  28.         <!--在配置文件中关联映射文件 -->
  29.         <mapping resource="com/netctoss/entity/Cost.hbm.xml" />
  30.     </session-factory>
  31. </hibernate-configuration>

步骤三：使用Hibernate重构CostDaoImpl

使用HibernateUtil的增删改查API，来重构CostDaoImpl，代码如下：


   
  1. packagecom.netctoss.dao;
  3. importjava.util.List;
  4. importorg.hibernate.HibernateException;
  5. importorg.hibernate.Query;
  6. importorg.hibernate.Session;
  7. importorg.hibernate.Transaction;
  8. importcom.netctoss.entity.Cost;
  9. importcom.netctoss.util.HibernateUtil;
  11. /**
  12.  *    当前阶段学习重点是Struts2，对于DAO的实现就模拟实现了。
  13.  *    同学们可以使用JDBC/MyBatis自行实现该DAO。
  14.  */
  15. public class CostDaoImpl implements ICostDao {
  17.     @Override
  18.     public List<Cost>findAll() {
  19.         String hql = "from Cost";
  20.         Session session = HibernateUtil.getSession();
  21.         Query query = session.createQuery(hql);
  22.         List<Cost> list = query.list();
  23.         session.close();
  24.         return list;
  25.     }
  27.     @Override
  28.     public void delete(int id) {
  29.         Cost cost = new Cost();
  30.         cost.setId(id);
  32.         Session session = HibernateUtil.getSession();
  33.         Transaction ts = session.beginTransaction();
  34.         try {
  35.             session.delete(cost);
  36.             ts.commit();
  37.         } catch (HibernateException e) {
  38.             e.printStackTrace();
  39.             ts.rollback();
  40.         } finally {
  41.             session.close();
  42.         }
  43.     }
  45.     @Override
  46.     public Cost findByName(String name) {
  47.         // 模拟根据名称查询资费数据，假设资费表中只有一条名为tarena的数据
  48.         if("tarena".equals(name)) {
  49.             Cost c = new Cost();
  50.             c.setId(97);
  51.             c.setName("tarena");
  52.             c.setBaseDuration(99);
  53.             c.setBaseCost(9.9);
  54.             c.setUnitCost(0.9);
  55.             c.setDescr("tarena套餐");
  56.             c.setStatus("0");
  57.             c.setCostType("2");
  58.             return c;
  59.         }
  60.         return null;
  61.     }
  63.     @Override
  64.     public Cost findById(int id) {
  65.         Session session = HibernateUtil.getSession();
  66.         Cost cost = (Cost) session.get(Cost.class, id);
  67.         session.close();
  68.         return cost;
  69.     }
  71. }

注：目前我们还没学习有条件的查询，因此先不重构findByName方法。

步骤四：测试

重新部署项目，并重启tomcat，访问资费模块，对其各功能进行测试。

4.4 完整代码

下面是本案例的完整代码。

其中映射关系文件完整代码如下：

代码

主配置文件完整代码如下：

代码

CostDaoImpl完整代码如下：http://pdf7.tarena.com.cn/tts8_source/ttsPage/JAVA/JSD_V04/HIBERNATE/DAY01/CASE/01/index.html

代码
csq123
关注
hibernate方言
06-05
hibernate方言，详细介绍hibernate，初学者的好工具
Hibernate使用规范
weixin_44861399的博客
05-02 685
文章目录实体类编写规则hibernate主键生成策略实体类操作CRUD操作实体类对象状态hibernate一级缓存hibernate的事务操作事务代码规范写法hibernate的其他API 实体类编写规则 实体类的属性都是私有的 私有属性都有公开的get，set方法来操作 要求实体类有属性作为唯一值（一般使用id值） 实体类属性建议不使用基本数据类型，使用基本数据类型对应的包装类 八个基本数...
Hibernate5教程之一基本使用详解
程序员Feri
07-18 1万+
Hello,大家好，本篇文章描述Hibernate5的基本使用。 使用环境： 1、Hibernate5.2.10 2、Eclipse neon3 3、jdk1.8 4、MySQL5.7 总所周知，在开发中我们会使用一些持久层框架，而Hibernate则是相当不错一个。在使用Hibernate之前，我们应该知道ORM框架，那么什么是ORM呢？ ORM:对象关系映射(Object Rela
简单的Hibernate使用入门
u014341567的博客
06-17 5059
hibernate所需要的jardao层User.hbm.xml&lt;!DOCTYPE hibernate-mapping PUBLIC     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"&gt;   &lt;!-- 配置表与实体对...
hibernate使用方法
Daydream Mr.的博客
12-26 7031
第一步： 导包：required下的所有包，jpa下的所有包，所连接的sql驱动包，其他日志包（日志包不在该框架中） 第二步： 创建于数据库表对应的实体类。并在该实体类所在包下创建后缀名为.hbm.xml的配置文件，该文件为映射配置文件 第三步：在配置文件中配置映射关系     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"     "
Hiberate的基本使用
goodmentc的专栏
07-18 562
Hiberate的基本使用
mybatis和hiberate使用对比说明
最新发布
日常笔记 | 干货分享 | 毕设源码 | 毕设指导 | 答辩指导
08-24 1239
在实际开发中，MyBatis和Hibernate的使用方式和开发流程有所不同。以下是两者在使用过程中的对比，包括配置、CRUD 操作、以及查询等方面。MyBatis更加灵活，适合那些需要细粒度SQL控制和复杂查询的场景。开发者需要手动编写SQL并配置映射文件。Hibernate提供了更高层次的抽象，减少了手动编写SQL的工作量，适合标准CRUD操作和需要快速开发的企业级应用。选择MyBatis或Hibernate取决于项目的复杂性、团队对SQL的熟悉程度、以及项目的具体需求。
hiberate单独开发的基本配置
gyfmp5
08-31 87
目录结构：－src    -test..java    -User.java－hibernate.cfg.xml－User.hbm.xmlUser.java:public class User {     private int id;     private String username;     private String password;   public int getId() { ...
Hiberate HelloWorld入门
weixin_30387339的博客
07-26 90
通过两种方式来创建项目，一种是用xml方式来描述映射关系，一种是用Annation方式来进行描述1 建立新java 项目,名为hibernate_0100_HelloWorld 2 学习建User-library-hibernate,并加入相应的jar包 　　a) 项目右键-buildpath-configure build path-add library— 　　b) 选择User-l...
Hibernate使用记录_1
易水寒的博客
06-02 244
Hibernate使用记录 异常原因记录 threw exception [Request processing failed; nested exception is org.hibernate.type.SerializationException: could not deserialize] with root cause java.io.StreamCorruptedExc...
Hibernate框架使用详细步骤
qq_45384482的博客
07-26 7693
文章目录Hibernate简介Hibernate 的优缺点Hibernate 的工作原理使用步骤1.引入框架依赖2.主配置文件hibernate.cfg.xml子配置文件实体类案例 Hibernate简介 ORM框架/持久层框架（Object Relational Mapping） 它是是一个轻量级开放源代码的对象关系映射框架， hibernate可以自动生成SQL语句，自动执行，可以使用面向对象思想来操作数据库。 Hibernate 的优缺点 优点： 封装了访问数据库的jdbc的代码简化了重复性代码和访
Hibernate使用
李章勇的博客
04-13 492
Hibernate使用 　　hibernate是一个ORM框架。 　　ORM的全拼是Object Relational Mapping，译为“对象关系映射”，是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上来说，它其实是创建了一个可以在编程语言里使用的“虚拟对象数据库”。 　　使用较多的ORM框架有：　　 JPA-...
hibernate的使用
thunder-1
03-25 3578
一、Hibernate定义 是一个ORM对象关系映射框架，对JDBC进行了封装，将java实体类映射到数据库表中，将java实体类成员变量数据类型映射到数据库表字段数据类型中，开发人员直接操作对象，避免大量数据编程（SQL编写），提升了开发效率。 二、Hibernate使用过程 1、根据配置信息，创建配置对象. 2、通过配置对象创建sessionFactory 对象，来配置hibernate。 3、通过sessionFactory 对象用来创建Session 对象，进行数据库物理连接，与数据库进行交互。
hibernate中Query的用法
热门推荐
zzrshuiwuhen的专栏
01-18 2万+
hibernate中Query的用法   通过SessionFactory获得了session对象后，除了可以通过get(类名.class, id)方法得到相应的对象，还可以通过获得Query对象来取得需要的对象   Query query = session.createQuery("查询语句如from UserBean");   List list = query.list();//
如何在IDEA中使用Hibernate框架
SmallSweets的博客
03-03 4988
在eclipse和idea中使用hibernate框架是有所不同的，记录一下如何在idea中使用hibernate框架 在eclipse中使用hibernate框架请参考：如何在Eclipse中使用Hibernate框架 在idea中使用hibernate框架的步骤： 1.创建数据库和表 2.创建项目 3.连接数据库 4.自动生成核心配置文件，实体类以及实体类映射文件 5.访问数据库 1.创建数据库和表 创建数据库hibernate，在数据库中创建表User，表结构如下： 2.创建项目 为了方便导入hib
什么是Hibernate，好处是什么？
dengit_w的博客
09-19 1万+
1.Hibernate是一个操作数据库的框架，实现了对JDBC的封装；2.Hibernate是一个ORM（对象关系映射）框架，我们在写程序时 ，用的时面向对象的方法，但是在关系型数据库里，存的是一条条的数据，为了用纯面向对象的思想解决问题，所有需要将程序中的对象和数据库的记录建立起映射关系，ORM就是这样的技术，而Hibernate就是这样一个框架，以操作对象的方式操作数据库。3.Hibernate
hibernate查询某一个表所有数据
ithouse的专栏
08-29 1万+
public List findAll() { Session session = sessionFactory.getCurrentSession(); String hql = "from Role"; Query query = session.createQuery(hql); List roles = query.list(
hibernate 查询全部数据的三种方法
weixin_33951761的博客
03-30 3194
1、Query对象 使用Query对象需要写hql语句，使用hql语句操作的是实体类和属性。 用于查询全部的hql语句：from 实体类名称   例：String hql = "from UsersEntity";//准备hql语句         Query query = session.createQuery(hql);//创建Query对象         List&lt;UsersEnt...
Hibernate中使用select count(*) 或者sum(filed_name)!
weixin_34138056的博客
12-03 309
在hibernate中使用SQLQuery查询select count()或者使用 select sum(filed_name) 返回的结果会是BigInteger等类型。 而这些是不能够强制转换为Object或者是Integer类型。 真的是很麻烦！ 但是BigInteger中有invalue()方法。 可以自己转换为int类型。 所有已会有了下面的代码！ long...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值