Hibernate

Hibernate九阴真经

一、导入jar包。

二、创建实体类（javabean）

*hibernate 要求实体类中必须有一个属性是唯一的

*使用hibernate不需要我们自己手动创建数据库表，hibernate会帮我们把表创建

三、配置实体类与数据库表的对应关系（ORM映射）

1、创建xml格式的配置文件

映射配置文件和名称没有固定要求，建议：实体类所在包里面创建，实体类名称.xml

2、配置是xml格式，在配置文件中首先引入xml约束

学过约束dtd/schema,在hibernate中都是用dtd;

3、配置映射关系

<hibernate-mapping>

<class name=”实体类全路径” table=”数据库表名称”>配置表与对象的对应关系

<generator class=”native”></generator>配置自增长属性

</id>

<property name=”实体类属性” column=”数据库表列名”></property>注意属性名与列名要一一对应，必须相同名，column可以省略默认与属性名一样；type=”表中字段类型varchar等不写默认与属性类型相同”；

……

</class>

</hibernate-mapping>

四、创建hibernate核心配置文件

1、位置：必须在src下

名称：固定hibernate.cfg.xml

2、引入约束

3、hibernate操作过程中，只会加载核心配置文件，其他配置文件不会加载

（1）配置数据库信息

（2）配置hibernate信息

（3）把映射文件放到核心配置文件中

<hibernate-configuration>

<session-factory>

配置数据库信息（必须）

<property name=”hibernate.connection.diver.class”>com.mysql.jdbc.Driver</property>

<property name=”hibernate.connection.url”>jdbc:mysql:///hibernate_01</property>

……(配置数据库四大参数)

配置hibernate信息(可选)

<property name=”hibernate.show_sql”>true</property> 输出底层sql语句

<property name=”hibernate.formate_sql”>true</property>输出sql语句格式

<property name=”hibernate.hbm2ddl.auto”>update</property>自动创建表，update：有则更新，无则创建；

<property name=”hibernate.dialect”>org.hibernate.dialect.MySQLDialect</property>配置数据库方言，例如在mysql中使用limit/oracle中使用rownum进行分页

把映射文件放到核心配置文件中（必须）

</session-factory>

</hibernate-configuration>

五、代码逻辑

1、加载配置文件

Configuration conf = new Configuration();

conf.configure();

调用方法后src下hibernate核心配置文件就被加载完成

2、创建SessionFactory(重点)

SessionFactory sf = conf.buildSessionFactory();

根据核心配置文件，有数据库配置，有映射文件部分，到数据库里面根据映射关系创建表

创建过程特别耗损资源，建议一个项目一般创建一个SessionFactory对象，（静态代码块实现）；

private static Confiuration conf =null;

private static SessionFactory sf =null;

static{

new Configuration();

conf.confiure();

sf = conf.buildSessionFactory();

}

3、得到Session

Session session = sf.openSession();

理解：类似于jsbc中的connection

调用session里面不同的方法实现crud操作:

（1）添加save();

(2)修改update();

（3）删除delete();

(4)按照id查询get(id);

……

session是单线程对象，每个人只能用自己的（ThreadLocal）；

4、Transaction 事物

Transaction tx = session.beginTransaction();

主要方法：tx.commit(); tx.rollback();

？解决配置文件没有提示的问题：

1、可以上网,会自动引入提示；

2、把约束文件引入到eclipse中，window-preferences 搜索xml Catalog 点击add 将配置文件路径复制到 URI（要选）下，点击file System 寻找到本地约束文件，点击OK结束；重启eclipse；

六、hibernate主键生成策略：

native:代理主键，自动增长；

uuid:hibernate会自动帮我们生成一个32位16进制字符串；

例：实体类中定义唯一属性 private String uid;

映射配置文件给uid设置uuid <generator class=”uuid”></ generator>

七、对实体类的增删改查操作

添加操作：User.setUsername(“xiaoma”); user.setAge(10); session.save();

根据id查询：

1、调用session中的get方法实现；

2、代码如下：

SessionFactory sf = HibernateUtils.getSessionFactory();

Session session = sessionFactory.openSession();

Transaction tx = session beginTransaction();

User user = session.get(User.class,id值);

tx.commit();

session.close();

sf.close();

修改操作：

1、首先查询；

User user = session.get(User.class,2);

2、修改；

user.setUsername(“李连杰”);

session.update(user); 底层是到对象中找到id 然后根据id进行修改

删除操作

1调用delete方法实现一；

User user = session.get(User.class,1);

session.delete(user);

2、调用delete方式实现二：

User user = new User();

user.setUid(1); session.delete(user);

八、实体类对象状态（概念）

1瞬时态：对象里面没有id值，跟session没有关联

2持久态：对象里面有di值并且与session有关联

3托管态：对象里面有id值但是对象跟session没有关联

saveOrUpdate方法：

可以实现添加也能实现修改；瞬时态进行添加，托管态进行修改；持久态进行修改；（有id值就行修改，没id就执行添加）

User user = new User();

user.setUsername(“jack”);

user.setUid(4);

session.saveOrUpdate(user);

九、hibernate的一级缓存

什么是缓存？

数据存到数据库里面，数据库本身就是文件系统，java中使用流来操作文件，效率不高。

（1）把数据存到内存里面，不需要使用流方式，可以直接读取内存中数据

（2）把数据放到内存中，提高读取效率；

hibernate缓存

1hibernate框架中提供很多优化方式，hibernate的缓存就是一个优化方式

2hibernate缓存特点：

（1）hibernate的一级缓存

hibernate的一级缓存默认打开的

hibernate的一级缓存使用范围，是session范围

（2）hibernate的二级缓存

目前不使用，替代技术redis;

默认不打开

范围sessionFactory

验证一级缓存存在

1验证方式

（1）首先根据uid=1查询，返回对象，发送sql语句；

（2）再次根据uid查询，直接返回对象，不执行sql语句；

一级缓存特性：

持久态自动更新数据库，

User user = session.get(User.class,1);

user.setUsername(“hansan”); 不调用update方法也会修改数据库

十、hibernate事物代码规范

事物概念：

1什么是事物？一组操作有一个失败都失败

2事物特性：原子性、一致性、隔离性、持久性

3不考虑隔离性的问题？脏读、不可重复读、虚读

解决办法: 设置事物隔离级别 repeatable read(mysql默认)

事物代码结构：

Transaction tx=null;

try{

tx.beginTransaction();

….操作数据库代码

tx.commit();

}catch(Exception e){

tx.rollBack();

}

十一、Hibernate绑定Session

获取与本地线程绑定的session

1、在hibernate核心配置文件中进行配置：

<property name=”hibernate.current_session_context_class”>thread</property>

2、调用SessionFactory.getCurrentSession();得到与当前线程绑定的session(底层依然是threadlocal)。

3、获取本地线程绑定session，关闭session报错，不需要手动关闭；

十二、查询（所有内容）

api:

Query 对象：

Query q = session.createQuery(“from User”); from+实体类名

List<User> users = q.list();

for(User u:users)(syout(u));

Criteria 对象：

Criteria c =session.createCriteria(User.class);

List<User>users = c.list();

SQLQuery 对象：

1使用hibernate时候，也可以来调用底层sql来实现，而SQLQuery就能编写sql语句；

SQLQuery sql = session.createSQLQuery(“select * from user”);

List<Object[]> users = sql.list();返回的list每个元素是一个数组；

for(Object[] array : users){Arrays.toString(array)}

修改返回数据中每部分是对象而不是数组；

sql.addEntity(User.class);

List<User> users = sql.list();

for(User user : users){sysout(user)}

十三、Hibernate 一对多操作

一对多映射配置：

第一步创建实体类（例如商品与分类就是一对多关系）

第二步让两个实体类之间互相关联（分类是一的一方，商品是多的一方）

在分类中创建一个set集合,无序、可重复；（Hibernate规定set）

Set<Book> books = new HashSet<Book>();

在商品实体类中添加

private Category category; 属性以及get /set方法；

第三步配置映射文件

1、配置好两张表基本的映射关系；

2、映射文件中，配置一对多关系

分类实体类的配置：（分类中表示商品）

<one-to-many class=”被关联实体类的全路径”/>

</set>

商品实体类的配置：（商品中表示所属分类）

<many-to-one name=”category” class=”被关联实体类全路径” column=”外键”></ many-to-one>

第四步创建核心配置文件，把映射文件引入到核心配置文件

要将两个映射文件都引入到核心配置文件中；

一对多级联操作：

简化写法：

第一步

在映射文件中的set标签中添加cascade=”save-update”

示例代码：

一个公司有多个联系人，一个联系人只属于一个公司

实现方式一：没有配置映射文件cascade=”save-update”

Company comp = new Company();

comp.setCname(“百度”);

comp.setCphone(“13314445555”);

LinkedMan lman = new LinkedMan();

lman.setLname(“李彦宏”);

lman.setLphone(“18845888888”);

comp.getLinkedManSet().add(lman);

lman.setCompany(comp);

session.save(comp);

session.save(lman);

实现方式二：配置完映射文件

Company comp = new Company();

comp.setCname(“百度”);

comp.setCphone(“13314445555”);

LinkedMan lman = new LinkedMan();

lman.setLname(“李彦宏”);

lman.setLphone(“18845888888”);

comp.getLinkedManSet().add(lman);

session.save(comp);

一对多修改外键操作：

Company comp =session.get(Compant.class,1); //id查询

LinkedMan lm = session.get(LinkedMan.class,1);

comp.getLinkedManSet().add(lm);

lm.setCompany(comp);

因为是持久态对象，所以不用保存，也会执行；

inverse属性：因为hibernate双向维护外键，所以会update两次外键，降低了效率，解决办法，让其中的一方（多方维护外键）不维护外键；

在一方的映射文件中添加inverse=”true” ,表示放弃关系维护；

十四、Hibernate多对多操作

多对多映射配置

第一步创建实体类(Role /user)

第二步让两个实体类互相表示（在实体类中分别创建一个set集合表示多对多关系）

Role{Set<User> setUser = new HashSet<User>();}

User{Set<Role> setRole=new hashSet<Role>();}

第三步配置映射文件

(1)基本配置()

cn.wyx.User 实体类的配置文件

</id>

……

<set cascade=”save-update” name=”setRole” table=”user-role” >第三张表的名字

<key colum=”userid”></key>当前实体类在第三张表中的外键

<many-to-many class=”cn.wyx.Role” colum=”roleid”></many-yo-many>关联的哪个实体类，以及该类在第三张表中的外键

</set>

</class>

cn.wyx.Role 实体类的配置文件

</id>

……

<set name=”setUser” table=”user-role”>第三张表的名字

<key colum=”rid”></key>当前实体类在第三张表中的外键

<many-to-many class=”cn.wyx.User” colum=”uid”></many-yo-many>关联的哪个实体类，以及该类在第三张表中的外键

</set>

</class>

（2）配置多对多映射（创建第三张表）

第四步配置核心配置文件

级联添加、删除（操作第三张表）

根据用户保存角色

第一步在用户配置文件中set标签进行配置，cascade = “save-update”

第二步代码实现

User user1 = new User();

user1.setUserName(“lucy”);

user1.setPassword(“123”);

User user2 = new User();

user2.setUserName(“lucy”);

user2.setPassword(“123”);

Role r1 = new Role();

r1.setRname(“总经理”);

Role r2 = new Role();

r2.setRname(“CEO”);

Role r3 = new Role();

r3.setRname(“技术总监”);

user1.getSetRole().add(r1);

user1.getSetRole().add(r2);

user2.getSetRole().add(r1);

user2.getSetRole().add(r3);

session.save(user1);

session.save(user2);

级联删除配置：(不参考使用)

set 标签中添加cascade=”delete”

User user=session.get(User.class,1);

session.delete(user);

维护第三张表：(重点)

1、让某个用户有某个角色

第一步：根据id查询出用户和角色

User user = session.get(User.class,1);

Role role = session.get(Role.class,1);

第二步：把角色放到用户里面

user.getSetRole().add(role);

2、让用户没有某个角色

第一步：根据id查询角色和用户

User user = session.get(User.class,1);

Role role = session.get(Role.class,1);

第二步：从setRole集合中删除这个角色

user.getSetRole().remove(role);

十五、查询

对象导航查询：

public void test(){

SessionFactory sf=null;

Session session=null;

Transaction tx=null;

try{

sf = HibernateUtils.getSessionFactory();

session = sf.openSessioin();

tx = session.beginTransaction();

Category category = session.get(Category.class,1);

Category <Book> cset = category.getSetCategory();

sysout(cset.size());

tx.commit();

}catch(Exception e){

tx.rollback();

}

OID查询

Category category = session.get(Category.class,1); //就是根据id查询

HQL查询

第一步：使用query对象，写hql语句；

第二步：调用query方法得到结果；

例1：查询客户表中所有数据？(查询所有)

Query query = session.createQuery(“from 实体类名称”);

List<Customer> list = query.list();

for(Customer cut : list){sysout(cut.getName()+cut.getPassword())}

例2：从customer表中查询 cid=1 cusName=”百度”的数据？（where条件查询）

hql语句格式：

from 实体类名 where 实体类属性名 =？ and 实体类属性名=？；

from 实体类名 where 实体类属性名 like？ and 实体类属性名 like？；（用法同上传递参数可以加%参数名%）

Query query = session.createQuery(“from Customer where cid=? and custName=?”);

query.setParameter(0,1); //参数位置从0开始，第0个参数的cid值为1;

query.setParameter(1,”百度”);

Set<Customer> set = query.llist();

例3：根据cid排序？(排序查询)

hql格式：from 类名 order by 实体类属性名 desc/asc

例4：查询所有数据，从0开始显示3行？(分页查询)

在hql中没有limit，而是用Hibernate中的方法来代替；

Query query = session.createQuery(“from Customer”);

query.setFirstResult(0);//设置开始位置

query.setMaxResult(3);//设置每页记录数

list<Customer>list=query.list();

例5：查询表中指定某一列的值？(投影查询)

hql格式：select 实体类属性名 from 实体类名

Query query = session.createQuery(“select custName from Customer”);

List<Object> list = query.lislt();

例6：查询表中指定某一列的值？(聚合函数查询)

1、常用聚合函数：count/sum/avg/max/min

hql格式：select count(*) from 实体类名

Query query = session.createQuery(“select count(*) from Customer”);

Object obj = query.uniqueResult();

//注意不能直接把obj强转成int，要先转换成Long类型，再转成int;

obj = (Long)obj.intValue();

sysout(obj);

例7：客户与联系人为例(多表查询)

1、内连接

hql格式: from 实体类名别名 inner join 别名.实体类set集合名

Query query = session.createQuery(“from Customer c inner join c.ManLinkedSet”);

List<Customer> list = query.list(); //集合中每个元素都是一个数组

2、左外连接

hql格式：from Customer c left outer join c.LinkedManSet(返回list元素数组)

3、右外连接

hql格式：from Customer c inner join c.ManLinkedSet（没有迫切连接只能返回数组元素）

4、迫切内连接

与内连接的实现一样，区别在于返回list的每部分是对象；

hql格式： from Customer c inner join fetch c.ManLinkedSet

5、迫切左外连接

hql格式：from Customer c left outer join fetch c.LinkedManSet（返回list元素对象）