2.Hibernate 常用的Api

最新推荐文章于 2020-11-10 15:17:55 发布
最新推荐文章于 2020-11-10 15:17:55 发布
阅读量198 收藏
点赞数
分类专栏： Hibernate 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yun1996/article/details/107531693
版权

|-- Configuration       配置管理类对象

         config.configure();    加载主配置文件的方法(hibernate.cfg.xml)

                                                        默认加载src/hibernate.cfg.xml

         config.configure(“cn/config/hibernate.cfg.xml”);   加载指定路径下指定名称的主配置文件

         config.buildSessionFactory();   创建session的工厂对象

|-- SessionFactory     session的工厂（或者说代表了这个hibernate.cfg.xml配置文件）

         sf.openSession();   创建一个sesison对象

         sf.getCurrentSession();  创建session或取出session对象

|--Session       session对象维护了一个连接(Connection), 代表了与数据库连接的会话。

                               Hibernate最重要的对象： 只用使用hibernate与数据库操作，都用到这个对象

                   session.beginTransaction(); 开启一个事务； hibernate要求所有的与数据库的操作必须有事务的环境，否则报错！

更新：

     session.save(obj);   保存一个对象

     session.update(emp);  更新一个对象

     session.saveOrUpdate(emp);  保存或者更新的方法： 没有设置主键，执行保存；有设置主键，执行更新操作; 如果设置主键不存在报错！

主键查询：

      session.get(Employee.class, 1);    主键查询

      session.load(Employee.class, 1);   主键查询 (支持懒加载)

HQL查询：

         HQL查询与SQL查询区别：

                   SQL: (结构化查询语句)查询的是表以及字段;  不区分大小写。

                   HQL: hibernate  query  language 即hibernate提供的面向对象的查询语言

                            查询的是对象以及对象的属性。

                            区分大小写。

 

Criteria查询：

          完全面向对象的查询。

本地SQL查询：

         复杂的查询，就要使用原生态的sql查询，也可以，就是本地sql查询的支持！

         (缺点： 不能跨数据库平台！)

|-- Transaction    hibernate事务对象

public class App2 {
	
	private static SessionFactory sf;
	static  {
		/*
		//1. 创建配置管理类对象
		Configuration config = new Configuration();
		// 加载配置文件  (默认加载src/hibernate.cfg.xml)
		config.configure();
		//2. 根据加载的配置管理类对象，创建SessionFactory对象
		sf = config.buildSessionFactory();
		*/
		
		// 创建sf对象
		sf = new Configuration().configure().buildSessionFactory();
	}

	//1. 保存对象
	@Test
	public void testSave() throws Exception {
		// 对象
		Employee emp = new Employee();
		emp.setEmpName("张三123");
		emp.setWorkDate(new Date());
		
		//根据session的工厂，创建session对象
		Session session = sf.openSession();
		// 开启事务
		Transaction tx = session.beginTransaction();
		//-----执行操作-----
		session.save(emp);
		
		// 提交事务/ 关闭
		tx.commit();
		session.close();
	}
	
	
	//更新
	@Test
	public void testUpdate() throws Exception {
		// 对象
		Employee emp = new Employee();
		emp.setEmpId(1000000);
		emp.setEmpName("张三3");
		
		// 创建session
		Session session = sf.openSession();
		Transaction tx = session.beginTransaction();
		
		//-------执行操作-------
		// 没有设置主键，执行保存；有设置主键，执行更新操作; 如果设置主键不存在报错！
		session.saveOrUpdate(emp);
		
		tx.commit();
		session.close();
	}
}
public class App3 {
	
	private static SessionFactory sf;
	static  {
		
		// 创建sf对象
		sf = new Configuration().configure().buildSessionFactory();
	}

	//HQL查询  【适合有数据库基础的】
	@Test
	public void testQuery() throws Exception {
		
		Session session = sf.openSession();
		Transaction tx = session.beginTransaction();
		
		// 主键查询
		//Employee emp = (Employee) session.get(Employee.class, 1);
		
		// HQL查询，查询全部
		Query q = session.createQuery("from Employee where empId=1 or empId=2");
		List<Employee> list = q.list();
		
		System.out.println(list);
		
		tx.commit();
		session.close();
	}
	

	//QBC查询  , query by criteria  完全面向对象的查询
	@Test
	public void testQBC() throws Exception {
		Session session = sf.openSession();
		Transaction tx = session.beginTransaction();
		
		Criteria criteria = session.createCriteria(Employee.class);
		// 条件
		criteria.add(Restrictions.eq("empId", 1));
		// 查询全部
		List<Employee> list = criteria.list();
		
		System.out.println(list);
		
		tx.commit();
		session.close();
	}
	
	//sQL
	@Test
	public void testSQL() throws Exception {
		Session session = sf.openSession();
		Transaction tx = session.beginTransaction();
		
		// 把每一行记录封装为对象数组，再添加到list集合
//		SQLQuery sqlQuery = session.createSQLQuery("select * from employee");
		// 把每一行记录封装为 指定的对象类型
		SQLQuery sqlQuery = session.createSQLQuery("select * from employee").addEntity(Employee.class);
		List list = sqlQuery.list();
		
		System.out.println(list);
		
		tx.commit();
		session.close();
	}
}

一个综合的例子

//工具类

public class HibernateUtils {

    private static SessionFactory sf;
    static {
        // 加载主配置文件, 并创建Session的工厂
        sf = new Configuration().configure().buildSessionFactory();
    }
    
    // 创建Session对象
    public static Session getSession(){
        return sf.openSession();
    }
}

//sql执行的类

public class EmployeeDaoImpl implements IEmployeeDao{

    @Override
    public Employee findById(Serializable id) {
        Session session = null;
        Transaction tx = null;
        try {
            // 获取Session
            session = HibernateUtils.getSession();
            // 开启事务
            tx = session.beginTransaction();
            // 主键查询
            return (Employee) session.get(Employee.class, id);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            tx.commit();
            session.close();
        }
    }

    @Override
    public List<Employee> getAll() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            // HQL查询
            Query q = session.createQuery("from Employee");
            return q.list();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            tx.commit();
            session.close();
        }
    }

    @Override
    public List<Employee> getAll(String employeeName) {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            Query q =session.createQuery("from Employee where empName=?");
            // 注意：参数索引从0开始
            q.setParameter(0, employeeName);
            // 执行查询
            return q.list();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            tx.commit();
            session.close();
        }
    }

    @Override
    public List<Employee> getAll(int index, int count) {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            Query q = session.createQuery("from Employee");
            // 设置分页参数
            q.setFirstResult(index);  // 查询的其实行 
            q.setMaxResults(count);      // 查询返回的行数
            
            List<Employee> list = q.list();
            return list;
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            tx.commit();
            session.close();
        }
    }

    @Override
    public void save(Employee emp) {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            // 执行保存操作
            session.save(emp);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            tx.commit();
            session.close();
        }
        
    }

    @Override
    public void update(Employee emp) {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            session.update(emp);
            
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            tx.commit();
            session.close();
        }
        
    }

    @Override
    public void delete(Serializable id) {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            // 先根据id查询对象，再判断删除
            Object obj = session.get(Employee.class, id);
            if (obj != null) {
                session.delete(obj);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            tx.commit();
            session.close();
        }
    }
}

测试类

 

public class App {
    
    private EmployeeDaoImpl empDao = new EmployeeDaoImpl();

    @Test
    public void testFindById() {
        System.out.println(empDao.findById(1));
    }

    @Test
    public void testGetAll() {
        System.out.println(empDao.getAll());
    }

    @Test
    public void testGetAllString() {
        System.out.println(empDao.getAll("张三3"));
    }

    @Test
    public void testGetAllIntInt() {
        System.out.println(empDao.getAll(4, 2));
    }

    @Test
    public void testSave() {
        empDao.save(new Employee());
    }

    @Test
    public void testUpdate() {
        Employee emp = new Employee();
        emp.setEmpId(23);
        emp.setEmpName("new jack");
        
        empDao.update(emp);
    }

    @Test
    public void testDelete() {
        empDao.delete(23);
    }

}

 

                           

 

yun1996
关注
专栏目录
HibernateAPI
02-28
Hibernate3_2_API
Hibernate中文API大全
02-16
依赖对象（Dependent objects） 组件(Component)是一个被包含的对象，在持久化的过程中，它被当作值类型，而并非一个实体的引用。在这篇文档中，组件这一术语指的是面向对象的合成概念（而并不是系统构架层次上的组件的概念）。举个例子, 你对人(Person)这个概念可以像下面这样来建模： public class Person { private java.util.Date birthday; private Name name; private String key; public String getKey() { return key; } private void setKey(String key) { this.key=key; } public java.util.Date getBirthday() { return birthday; } public void setBirthday(java.util.Date birthday) { this.birthday = birthday; } public Name getName() { return name; } public void setName(Name name) { this.name = name; } ...... ...... } public class Name { char initial; String first; String last; public String getFirst() { return first; } void setFirst(String first) { this.first = first; } public String getLast() { return last; } void setLast(String last) { this.last = last; } public char getInitial() { return initial; } void setInitial(char initial) { this.initial = initial; } } 在持久化的过程中,姓名(Name)可以作为人(Person)的一个组件。需要注意的是:你应该为姓名的持久化属性定义getter和setter方法,但是你不需要实现任何的接口或申明标识符字段。 以下是这个例子的Hibernate映射文件: <!-- class attribute optional --> 人员(Person)表中将包括pid, birthday, initial, first和 last等字段。 就像所有的值类型一样, 组件不支持共享引用。 换句话说，两个人可能重名，但是两个Person对象应该包含两个独立的Name对象，只不过这两个Name对象具有“同样”的值。 组件的值可以为空，其定义如下。 每当Hibernate重新加载一个包含组件的对象,如果该组件的所有字段为空，Hibernate将假定整个组件为空。 在大多数情况下,这样假定应该是没有问题的。 组件的属性可以是任意一种Hibernate类型（包括集合, 多对多关联， 以及其它组件等等）。嵌套组件不应该被当作一种特殊的应用(Nested components should not be
hibernate Api
qq_37928045的博客
11-10 251
hibernate hibernate架构 重要对象 Transaction Object 瞬时对象（与数据库无关对象） persistent Object 持久对象 （与数据库有关系的对象，保存到数据的对象） session 数据库会话对象 sessionFactory 会话工程，进程级别的对象 Transaction 事物 TransactionFactory 事物工厂 ConnectionProvider 数据源例如c3p0,dbcp（链接） JND：提供资源目录
hibernate api
03-23
Hibernate (3.6.0.Final).chm
Hibernate 的重要API
qq_40435621的博客
02-18 181
Configuration 配置对象 用于Hibernate框架加载映射文件 // 加载配置文件 Configuration cfg = new Configuration().configure(); //默认到src下寻找hibernate.cfg.xml // 自定义加载配置文件 Configuration cfg = new Configuration().configure(&quot;文件...
hibernate-jpa-2.1-api-1.0.2.Final-API文档-中英对照版.zip
06-12
赠送jar包：hibernate-jpa-2.1-api-1.0.2.Final.jar； 赠送原API文档：hibernate-jpa-2.1-api-1.0.2.Final-javadoc.jar； 赠送源代码：hibernate-jpa-2.1-api-1.0.2.Final-sources.jar； 赠送Maven依赖信息文件：...
hibernate-jpa-2.1-api-1.0.2.Final-API文档-中文版.zip
06-25
赠送jar包：hibernate-jpa-2.1-api-1.0.2.Final.jar； 赠送原API文档：hibernate-jpa-2.1-api-1.0.2.Final-javadoc.jar； 赠送源代码：hibernate-jpa-2.1-api-1.0.2.Final-sources.jar； 赠送Maven依赖信息文件：...
Hibernate 中文api文档下载.zip_API_Hibernate API _hibernate api
09-24
六、 Criteria API的常用方法 - createCriteria()：创建Criteria对象，指定要查询的实体类。 - add()：添加查询条件，如EqRestriction等于条件，LtRestriction小于条件等。 - setProjection()：设置查询结果的投影，...
Hibernate_api.zip_hibernate api
09-14
本文将深入探讨Hibernate API，包括其核心概念、常用类和接口，以及在实际开发中的应用策略。 一、Hibernate概述 Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了轻量级封装，使得Java开发者能够以...
api.zip_hibernate api_hibernate api chm
09-22
"api.zip_hibernate api_hibernate api chm" 这个标题表明我们正在处理一个关于Hibernate的API文档，它被压缩在名为"api.zip"的文件中，并且是以chm（Compiled HTML Help）格式存储。chm文件是微软推出的一种帮助...
Hibernate api
08-13
Hibernate api Hibernate的api文档
HirbernateAPI
08-29
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装。
hibernate-api
03-27
hibernate-api
Hibernate 中文API文档
09-12
本章是面向Hibernate初学者的一个入门教程。我们从一个使用驻留内存式(in-memory)数据库的简单命令行应用程序开始, 用易于理解的方式逐步开发。 本章面向Hibernate初学者，但需要Java和SQL知识。它是在Michael Goegl所写的指南的基础上完成的。在这里，我们称第三方库文件是指JDK 1.4和5.0。若使用JDK1.3，你可能需要其它的库文件。
(转)hibernate常用API详解
05-25 5543
转自：http://blessht.iteye.com/blog/1327883 hibernate常用API详解 博客分类：  hibernate     根据个人使用Hibernate的经验，介绍一下Hibernate的多种不同的查询和CUD操作，这些东西在日常开发中非常常用，希望对大家有所帮助。     以下示例均以两张表为例：member和userinfo
Hibernate中API详解
weixin_41653442的博客
07-31 348
1.体系结构 PO：persistent object ，用于与数据库交互数据。–dao层 （JavaBean + hbm ） BO：Business object 业务数据对象。–service层 VO：Value Object 值对象。–web层 开发中：直接使用JavaBean 描述三个对象。 2.Configuration 配置对象 hibernate 核心配置文件种...
hibernate的核心API
java后端开发，目前就职于携程，随手记点东西。
06-13 245
1.Configuration 代码： Configuration cfg = new Configuration(); cfg.configure(); 功能： 创建对象（第一行代码）。到src下面找到名字为hibernate.cfg.xml的文件，并且将文件放入到对象中去（第二行代码）。也叫做加载核心配置文件 2.SessionFactory（重点） 使用configuration对象可以创...
Hibernate 常用API
weixin_43014205的博客
01-07 174
hibernate保存操作   记得开启事务 public void test1(){ Session session = HibernateUtil.openSession(); //获取session Transaction transaction = session.beginTransaction(); Customer ...
org.hibernate.hibernate-validator
最新发布
05-11
org.hibernate.validator是一个Java Bean验证框架，它提供了一种简单但功能强大的方法来验证Java Bean对象的约束。它可以用于验证任何Java对象，包括普通的POJO（普通的Java对象）、EJB（Enterprise Java Bean）和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值