第六次作业基于Hibernate的增删改查操作

最新推荐文章于 2021-10-09 14:13:22 发布

qq_37754785

最新推荐文章于 2021-10-09 14:13:22 发布

阅读量118

点赞数

本文链接：https://blog.csdn.net/qq_37754785/article/details/80714816

版权

1.Session的save()方法

Session是Hibernate所有接口中最重要的接口，提供了对数据保存，更新，查询和删除的方法。

Session的save()方法可以使临时态或游离态转换为持久态。例如，保存一个Customer对象：

 
   [java]  
   view plaincopy
<span style="color:#000000;">SessionFactory sessionFactory;  
Configuration configuration = new Configuration().configure();  
sessionFactory = configuration.buildSessionFactory();  
Session session = sessionFactory.openSession();  
Transaction tr = session.beginTransaction();  
//1.创建Customer对象  
Customer c1 = new Customer();  
c1.setId(new Long(1));  
c1.setName("test");  
c1.setEmail("123456789@qq.com");  
c1.setPassword("123456");  
c1.setAddress("世外桃源");  
//2.调用Session的save()方法，将Customer对象持久化  
session.save(c1);  
tr.commit();  
session.close();  
</span>  

Save()方法主要做了以下三件事：

（1）将new创建的临时态的Customer对象放入缓存，使其持久化。

（2）同时根据对象关系映射文件中设置的OID生成器，即主键生成方式给该对象生成一个唯一的OID。

<id name="id" column="ID" type="long">
               
               <generator class="increment"/>
           </id>

在这个地方有一个疑问，创建对象时setId()方法是否是为该对象持久化生成主键，其实不是，setId并没有按照我们设定的那样生成主键，而是靠

对象关系映射文件配置的主键生成方式生成主键，可以多运行几次，主键自增长，从数据库可以看到多条数据，主键从1开始，所以可以知道setId()

没有设置主键，否则数据库主键唯一性校验都过不去。

我们也可以手动设置主键值，必须重载save()方法，使用重载方法save(c1,new Long(1)),每次手动设置。

（3）计划执行insert语句。注意，insert语句并没有立刻执行，只有当Session清理缓存时，才会执行insert语句。tr.commit()事务提交。

2.Session的update()方法

使游离态对象变成持久态对象。例如：

 
   [java]  
   view plaincopy
SessionFactory sessionFactory;  
Configuration configuration = new Configuration().configure();  
sessionFactory = configuration.buildSessionFactory();  
Session session1 = sessionFactory.openSession();  
Transaction tr1 = session1.beginTransaction();  
//1.创建Customer对象  
Customer c1 = new Customer();  
c1.setId(new Long(1));  
c1.setName("test");  
c1.setEmail("123456789@qq.com");  
c1.setPassword("123456");  
c1.setAddress("世外桃源");  
//2.调用Session的save()方法，将Customer对象持久化  
session1.save(c1);  
tr1.commit();  
session1.close();  
//3.将游离态的对象更新，发现改变，执行update语句  
Session session2 = sessionFactory.openSession();  
Transaction tr2 = session2.beginTransaction();  
c1.setAddress("测试update");  
session2.update(c1);  
tr2.commit();  
session2.close();</span>  

Session的update()注意做以下事：

（1）把游离态的Customer对象从新加入Session缓存中，使其变成持久化对象。

（2）执行update语句。跟save()执行insert语句一样，并不是立刻执行update语句，需要等缓存清空时，把Customer对象组装成update语句，

然后再执行。

注意，即使Customer没有改变，默认情况下，缓存清除时也会组装Update语句，如果需要设置成改变成才执行update语句，需要设置对象关系映射文件。

3.Session的saveOrUpdate()方法

saveOrUpdate()方法包含save()和update()方法的功能，根据传入参数状态，调用不同方法。传入临时态对象调用save()方法，如果传入游离态对象调用

update()方法。传入持久态对象返回。所以，每次我们只需传入对象，saveOrUpdate()方法，自动判断传入对象状态的状态，动态调用处理方法。

该方法如何判断传入对象的状态？当满足以下任意一个条件时，就是临时态：

（1）java对象的OID为null,说明该对象没有别实例化，即使被实例化，也是游离态被删除后变成临时态的对象，这种情况下的对象为临时态。

（2）如果java对象具有版本控制(version),版本号为null的，也就是没有该对象的版本号。

（3）自定义拦截器，调用isUnsaved()返回值为true。

4.Session的load()和get()方法

这两个方法都是根据OID,从数据库中加载一个持久化对象。持久化对象放在Session缓存中，可以根据不同的需要操作该持久化对象。

两者区别：

当数据库中OID没有对应记录时，load()抛异常，get()返回null。

5.Session的delete()方法

delete()顾名思义删除，用于从数据库中删除java对象对应的记录。

delete()如果传入持久化对象，组装delete语句，执行删除；如果传入游离态对象，hibernate先把游离态关联到session,变成持久态，再生成delete语句，

执行删除。

都是只有当session缓存清空时，才执行。

以上执行都是一个对象，对应一条记录。

可以用session.delete("from Customer where ....");后面加上条件删除多条数据。

 
   [java]  
   view plaincopy
SessionFactory sessionFactory;  
Configuration configuration = new Configuration().configure();  
sessionFactory = configuration.buildSessionFactory();  
Session session1 = sessionFactory.openSession();  
Transaction tr1 = session1.beginTransaction();  
//1.创建Customer对象  
Customer c1 = new Customer();  
c1.setId(new Long(1));  
c1.setName("test");  
c1.setEmail("123456789@qq.com");  
c1.setPassword("123456");  
c1.setAddress("世外桃源");  
//2.调用Session的save()方法，将Customer对象持久化  
session1.save(c1);  
tr1.commit();  
session1.close();  
//3.将游离态的对象关联到session，持久化后清除缓存，执行delete语句；放入持久态的直接删除；  
Session session2 = sessionFactory.openSession();  
Transaction tr2 = session2.beginTransaction();  
session2.delete(c1);  
tr2.commit();  
session2.close();  

User对象

 
   [java]  
   view plaincopy
public class User {  
  
    private Integer id;  
    private String userName;  
    private String password;  
  
    /*以下省略getter与setter*/  
}  

配置User.hbm.xml文件。

 
   [html]  
   view plaincopy
<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE hibernate-mapping PUBLIC     
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">    
<!-- 该文件用于配置，domain跟表的映射关系 -->   
<hibernate-mapping package="com.mahaochen.hibernate.domain">  
    <class name="User" table="mhc_user">  
        <!-- id元素用于指定主键属性 -->    
        <id name="id" column="id" type="integer">  
            <!-- 用于指定主键生成策略 -->    
            <generator class="increment"></generator>  
        </id>  
          
        <!-- 对其他属性进行配置 -->   
        <property name="userName" type="string">  
            <column name="username" not-null="false" ></column>  
        </property>  
        <property name="password" type="string">  
            <column name="password" not-null="false"></column>  
        </property>  
    </class>  
      
</hibernate-mapping>  

Hibernate映射文件配置完成，以下将具体实现增删改查的操作。
增加操作

 
   [java]  
   view plaincopy
/** 
     * insert 插入操作 
     */  
    public static void insert() {  
        Session session = Hibernate4Util.getCurrentSession();  
        User user = new User();  
        user.setUserName("Insert");  
        user.setPassword(new Date().getTime() + "");  
        Transaction transaction = session.beginTransaction();  
        session.save(user);  
        transaction.commit();  
        Hibernate4Util.closeSession(session);  
    }  

删除操作

 
   [java]  
   view plaincopy
/** 
     * delete 删除操作 
     */  
    public static void delete() {  
        Session session = Hibernate4Util.getCurrentSession();  
        User user = new User();  
        user.setId(8); // ID值  
        user.setUserName("Insert");  
        user.setPassword(new Date().getTime() + "");  
        Transaction transaction = session.beginTransaction();  
        session.delete(user);  
        transaction.commit();  
        Hibernate4Util.closeSession(session);  
    }  

修改操作

 
   [java]  
   view plaincopy
/** 
     * update 更新操作 
     */  
    public static void update() {  
        Session session = Hibernate4Util.getCurrentSession();  
        Transaction transaction = session.beginTransaction();  
        User user = new User();  
        user = (User) session.get(User.class, 8);  
        if (null != user) {  
            user.setUserName("Insert0000");  
            user.setPassword(new Date().getTime() + "");  
            session.update(user);  
        }  
        transaction.commit();  
        Hibernate4Util.closeSession(session);  
    }  

查询操作

 
   [java]  
   view plaincopy
/** 
     * select 查询操作 
     */  
    public static void select() {  
        Session session = Hibernate4Util.getCurrentSession();  
        User user = new User();  
        Transaction transaction = session.beginTransaction();  
        user = (User) session.get(User.class, 1);  
        System.out.println(user.toString());  
        transaction.commit();  
  
        Hibernate4Util.closeSession(session);  
    }  

以下是参考别人的博客

1、加入junit.jar

2、新建一个工具类HibernateUtils.Java把一些对session的公共操作封装起来

 
   [java]  
   view plaincopy
import org.hibernate.Session;  
import org.hibernate.SessionFactory;  
import org.hibernate.cfg.Configuration;  
  
public class HibernateUtils {  
/* 
  *读取Hibernate.cfg.xml文件 
*/  
    private static SessionFactory factory;  
      
    static {  
        try {  
            //读取hibernate.cfg.xml文件  
            Configuration cfg = new Configuration().configure();  
              
            //建立SessionFactory  
            factory = cfg.buildSessionFactory();  
        }catch(Exception e) {  
            e.printStackTrace();  
        }  
    }  
    /* 
      *打开Session 
    */  
      
    public static Session getSession() {  
        return factory.openSession();  
    }   
    /* 
      *关闭Session 
    */  
      
    public static void closeSession(Session session) {  
        if (session != null) {  
            if (session.isOpen()) {  
                session.close();  
            }  
        }  
    }  
      
    public static SessionFactory getSessionFactory() {  
        return factory;  
    }  
}  

3、新建一个test类继承TestCase（Junit包里面的）然后下面就利用test类对User对象的增、删、改、查。

 
   [java]  
   view plaincopy
import java.util.Date;  
  
import org.hibernate.Session;  
  
import com.bjpowernode.hibernate.HibernateUtils;  
  
import com.bjpowernode.hibernate.User;  
  
import junit.framework.TestCase;  
  
public class test extends TestCase {  
/* 
 * 增加User 
 */  
    public void testSave() {  
          
        Session session = null;  
        try {  
            session = HibernateUtils.getSession();  
            session.beginTransaction();  
              
            User user = new User();  
            user.setName("李四");  
            user.setPassword("123");  
            user.setCreateTime(new Date());  
            user.setExpireTime(new Date());  
            session.save(user);  
            session.getTransaction().commit();  
        }catch(Exception e) {  
            e.printStackTrace();  
            session.getTransaction().rollback();  
        }finally {  
            HibernateUtils.closeSession(session);  
        }  
    }  
    /** 
     * 删除 
     */  
    public void testDel(){  
        Session session = null;  
        try {  
            session = HibernateUtils.getSession();  
            session.beginTransaction();  
              
            User user=(User)session.load(User.class, "4028989545a244640145a24466300001");  
              
            session.delete(user);  
            session.getTransaction().commit();  
        }catch(Exception e) {  
            e.printStackTrace();  
            session.getTransaction().rollback();  
        }finally {  
            HibernateUtils.closeSession(session);  
        }  
    }  
      
    /** 
     * 修改 
     */  
    public void testUpdate(){  
        Session session = null;  
        try {  
            session = HibernateUtils.getSession();  
            session.beginTransaction();  
              
            User user=(User)session.load(User.class, "4028989545a243ca0145a243cbf80001");  
            user.setName("王五");  
            session.update(user);  
            session.getTransaction().commit();  
        }catch(Exception e) {  
            e.printStackTrace();  
            session.getTransaction().rollback();  
        }finally {  
            HibernateUtils.closeSession(session);  
        }  
    }  
      
    /** 
     * 查询 
     */  
    public void testLoad(){  
        Session session = null;  
        try {  
            session = HibernateUtils.getSession();  
            session.beginTransaction();  
              
            User user=(User)session.load(User.class, "4028989545a243ca0145a243cbf80001");  
            System.out.println(user.getName());  
            System.out.println(user.getId());  
            System.out.println(user.getPassword());  
            System.out.println(user.getClass());  
            System.out.println(user.getCreateTime());  
            System.out.println(user.getExpireTime());  
            session.getTransaction().commit();  
        }catch(Exception e) {  
            e.printStackTrace();  
            session.getTransaction().rollback();  
        }finally {  
            HibernateUtils.closeSession(session);  
        }  
    }  
}  