实体类编写规则：
1、实体类中属性私有化。
2、私有属性使用公开的set()和get()。
3、要求实体类中有属性作为唯一值。
4、实体类中属性建议不使用基本数据类型，而使用基本数据类型对应的包装类。
》八个基本数据类型对应的包装类：
int>>Integer、char>>Character、其他的都是首字符大写。
Hibernate主键生成策略：
1、hibernate要求实体类中有属性作为唯一值，对应表主键，主键可以不同生成策略。
2、hibernate主键生成策略有很多的值：<generator class="native"></tenerator>
》native:生成表id值就是主键自动增长。根据使用的数据库选择那个值。
》uuid：生成长度为32位的十六进制字符串。使用uuid时，实体类对应的uid必须是字符串类型。
》increment：每次增量为1依次增长。
》identity：条件是数据库支持自动增长数据类型。
》sequence：序列。条件是数据库支持序列。如：Oracle
//查询操作 SessionFactory factory=HibernateUtils.getSessionFactory(); Session session=factory.openSession(); Transaction tx=session.beginTransaction(); //get()方法：根据id查询 //第一个参数：实体类的class。第二个参数：id值 User user = session.get(User.class,1); tx.commit(); session.close(); factory.close(); //修改操作 SessionFactory factory=HibernateUtils.getSessionFactory(); Session session=factory.openSession(); Transaction tx=session.beginTransaction(); User user=session.get(User.class,1); user.setUsername("李四");//设置修改的值 session.update(user);或session.save(user); tx.commit(); session.close(); factory.close(); //删除操作 SessionFactory factory=HibernateUtils.getSessionFactory(); Session session=factory.openSession(); Transaction tx=session.beginTransaction(); //第一种方式： User user=session.get(User.class,1); session.delete(user); //第二种方式: User user=new User(); user.setUid(1); Session.delete(user); tx.commit(); session.close(); factory.close();
实体类的三种状态：
1、瞬时态：对象中没有id值，对象与Session没有关联。
2、持久态：对象中有id值，对象与Session关联。
3、托管态：对象中有id值，对象与Session没有关联。
saveOrUpdate()：添加或修改操作。
当实体类对象状态是瞬时态时，做添加操作。
当实体类对象状态是托管态时，做修改操作。
当实体类对象状态是持久态时，做修改操作。
Hibernate缓存：
1、Hibernate框架中提供了很多优化的方式。Hibernate的缓存就是一个优化的方式。
2、Hibernate缓存特点：
》hibernate的一级缓存：
> hibernate的一级缓存默认时打开的。
> hibernate的一级缓存使用范围，是Session的范围。从Session创建到Session关闭的范围。
> hibernate的一级缓存中，存储数据必须是持久态数据。
》hibernate的二级缓存：
> 目前已经不使用了，替代技术redis。
> 二级缓存默认没有打开，需要配置开启。
> 二级缓存使用范围，是SessionFactory的范围。
一级缓存特性：持久态会自动更新数据库。
Hibernate绑定Session：
多人开发项目时，为了保证Session的单线程对象的特性。将Session与本地线程绑定即可。
1、Session类似于jdbc的Connection连接。
2、与本地线程绑定Session。其实底层就是与ThreadLocal绑定。
3、获取与本地线程Session：
》在Hibernate核心配置文件中配置。在第二部分配置<property name="hibernate.current_session_context_class">thread</property>
》调用SessionFactory中的方法得到。SessionFactory.getCurrentSession();
4、获取与本地线程绑定Session时，关闭Session会报错，所以不需要手动来关闭Session。
public class HibernateUtils{ private static final Configuration cfg=null; private static final SessionFactory factory=null; static{ cfg=new Configuration(); cfg.configure(); factory=cfg.buildSessionFactory(); } //提供方法返回SessionFactory publc static SessionFactory getSessionFactory(){ return factory; } //提供返回与本地线程绑定的Session的方法 public static Session getSessionThread(){ return factory.getCurrentSession(); } }
Hibernate查询的API使用：
Query：
1、使用Query对象，不需要写sql语句，但要写hql语句。
》hql：hibernate query language。Hibernate提供的查询语言。hql语句与普通sql语句很相似。
》hql和sql语句区别：使用sql操作表和表字段。使用hql操作实体类和属性。
2、查询所有hql语句。from 实体类名称
3、Query对象使用：
》创建Query对象：Query query = session.createQuery("from User");
》调用Query对象中的方法得到结果：List<User> list = query.list();
Criteria：
1、使用该对象查询操作，但hi使用该对象时，不需要写语句，直接调用方法即可。
2、实现过程：
》创建Criteria对象：Criteria criteria = session.createCriteria(User.class);
》调用对象中的方法得到结果：List<User> list=criteria.list();
SQLQuery：
1、使用hibernate时，调用底层SQL实现。
2、实现过程：
》创建对象：SQLQuery query = session.createSQLQuery("sql语句");
》调用对象的方法得到结果：
> List<Object[]> list = query.list();返回list集合，默认里面的每部分是数组结构。
> query.addEntity(User.class);设置将数据放到实体类中。
List<User> list=query.list();返回list集合，每部分是对象的形式。
Hibernate的一对多映射：
一对多映射配置：
1、创建一和多的实体类。(暂用OnlyClass和MoreClass表示)
2、让俩个实体类之间相互表示。
》在Hibernate中要求使用set集合表示多的数据。
》在OnlyClass中定义自身属性后，还需要定义一个set集合来表示MoreClass的属性。
》在MoreClass中定义自身属性后，还需要定义一个表示OnlyClass的属性。
3、配置映射关系：
》一般一个实体类对应一个映射文件。
》完成映射最基本的配置。
》在映射文件中，配置一对多关系。配置OnlyClass.hbm.xml的一对多关系使用set标签表示。
set标签中的name属性：属性值写在OnlyClass实体类中表示MoreClass的set集合名称。
<class> <set name="setMoreClass"> <!--一对多的建表，需要使用外键来建立关系 Hibernate机制：双向维护外键， 在一和多的双方都配置外键 column的属性值：外键名称--> <key column="mcid"></key> <!--在一的一方需要使用one-to-many标签： class属性值：MoreClass实体类全路径--> <one-to-many class="cn.test.xx.MoreClass"/> </set> </class>
配置MoreClass.hbm.cml 表示所属的OnlyClass。name属性：在MoreClass实体类中的OnlyClass名称。class属性：OnlyClass全路路径。column属性：外键名称（和OnlyClass中配置的外键名称保持一致）。
<class> <many-to-one name="onlyClass" class="cn.test.xx.OnlyClass" column="mcid"></many-to-one> </class>
4、创建核心配置文件，把映射文件引入到核心配置文件中。
SessionFactory factory = HibernateUtils.getSessionFactory(); Session session=factory.openSession(); Transaction tx=session.beginTransaction(); //创建对象。 OnlyClass onlyClass=new OnlyClass(); onlyClass.setXXX("xxx"); onlyClass.setXXX("xxx"); ...... MoreClass moreClass=new MoreClass(); moreClass.setXXX("xxx"); moreClass.setXXX("xxx"); ...... //建立OnlyClass与MoreClass关系。 //把MoreClass对象放到OnlyClass对象的set集合中。 onlyClass.getSetMoreClass().add(moreClass); //把OnlyClass对象放到MoreClass对象的set集合中。 moreClass.setOnlyClass(onlyClass); //保存到数据库 session.save(onlyClass); session.save(moreClass); tx.commit(); session.close(); factory.close();
简化写法：
1、在一OnlyClass的映射文件OnlyClass.hbm.xml中进行配置。在set标签中添加属性cascade="save-update"
<set name="setMoreClass" cascade="save-update">
2、常见一和多的对象，只需要把多的对象放到一中。最终只需要保存一即可。
SessionFactory factory = HibernateUtils.getSessionFactory(); Session session=factory.openSession(); Transaction tx=session.beginTransaction(); //创建对象。 OnlyClass onlyClass=new OnlyClass(); onlyClass.setXXX("xxx"); onlyClass.setXXX("xxx"); ...... MoreClass moreClass=new MoreClass(); moreClass.setXXX("xxx"); moreClass.setXXX("xxx"); ...... //把MoreClass对象放到OnlyClass对象中。 onlyClass.getSetMoreClass().add(moreClass); //保存到数据库 session.save(onlyClass); tx.commit(); session.close(); factory.close();
级联删除：
在删除一中的数据时，需要先删除多里面的数据。
1、先在OnlyClass映射文件set标签，进行配置。使用属性cascade="delete"
<set name="setMoreClass" cascade="save-update,delete">
2、执行过程：根据id查询OnlyClass的内容；再根据外键查询MoreClass的内容；将MoreClass的外键设置为null值；删除MoreClass的数据；删除OnlyClass的数据。
3、代码实现：
SessionFactory factory = HibernateUtils.getSessionFactory();
Session session=factory.openSession();
Transaction tx=session.beginTransaction();
OnlyClass only=session.get(OnlyClass.class,11);
session.delete(only);
tx.commit();
session.close();
factory.close();
SessionFactory factory = HibernateUtils.getSessionFactory(); Session session=factory.openSession(); Transaction tx=session.beginTransaction(); //根据id查询MoreClass的一条数据 MoreClass more=session.get(MoreClass.class,2) //根据id查询OnlyClass的一条数据 OnlyClass only=session.get(OnlyClass.class,5); //设置持久态对象值：把MoreClass放到OnlyClass中 only.getSetMoreClass().add(more); //把OnlyClass放到MoreClass中。即可完成修改 more.setOnlyClass(only); tx.commit(); session.close(); factory.close();
inverse属性：因为Hibernate是双向维护外键，所以会修改俩次外键，从而性能不是很高，造成了效率问题。
解决方式：让其中的一方不维护外键。一对多中，让一OnlyClass放弃。
实现：在放弃关系维护的映射文件中，进行配置，在set标签上使用inverse属性。inverse的默认值为false(不放弃关系维护)。而true表示放弃关系维护。
<set name="setMoreClass" cascade="save-update,delete" inverse="true">
Hibernate多对多映射：
多对多映射配置：以用户(User)和角色(Role)为例。
1、创建实体类。
2、让俩个实体相互表示。
一个用户中表示所有角色，使用set集合。
private Set<Role> role=new HashSet<Role>(); public Set<Role> getRole() { return role; } public void setRole(Set<Role> role) { this.role = role; }
一个角色有多个用户，使用set集合。
private Set<User> user=new HashSet<User>(); public Set<User> getUser() { return user; } public void setUser(Set<User> user) { this.user = user; }
3、配置映射关系：基本配置和配置多对多关系<set>标签。
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="cn.test.entity.User" table="t_user"> <id name="u_id" column="u_id"> <generator class="native"></generator> </id> <property name="u_uname" column="u_uname"></property> <property name="u_pwd" column="u_pwd"></property> <property name="u_email" column="u_email"></property> <property name="u_address" column="u_address"></property> <!--t_user_role是t_user和t_role的关系表--> <set name="role" table="t_user_role" cascade="save-update,delete"> <!--key标签中配置当前映射文件第三张表外键名称--> <key column="uid"></key> <!--class:实体类全路径。column：角色在第三张表外键名称--> <many-to-many class="cn.test.entity.Role" column="rid"></many-to-many> </set> </class> </hibernate-mapping>
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="cn.test.entity.Role" table="t_role"> <id name="r_id" column="r_id"> <generator class="native"></generator> </id> <property name="r_rname" column="r_rname"></property> <property name="r_memo" column="r_memo"></property> <!--t_user_role是t_user和t_role的关系表--> <set name="user" table="t_user_role"> <!--key标签中配置当前映射文件第三张表外键名称--> <key column="rid"></key> <!--class:实体类全路径。column：角色在第三张表外键名称--> <many-to-many class="cn.test.entity.User" column="uid"></many-to-many> </set> </class> </hibernate-mapping>
4、在核心配置文件中引入映射文件。
<?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="connection.url">jdbc:mysql://localhost:3306/Test</property> <property name="connection.driver_class">com.mysql.jdbc.Driver</property> <property name="connection.username">root</property> <property name="connection.password">root123456</property> <property name="hibernate.show_sql">true</property> <property name="hibernate.format_sql">true</property> <property name="hibernate.hbm2ddl.auto">update</property> <!-- <property name="hbm2ddl.auto">update</property> --> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <mapping resource="cn/test/entity/User.hbm.xml"/> <mapping resource="cn/test/entity/Role.hbm.xml"/> </session-factory> </hibernate-configuration>
级联保存：
1、再User配置文件中set标签进行配置，cascade值save-update
2、实现：创建User、Role对象，把角色放到用户中，最终保存用户即可。
SessionFactory factory=HibernateUtils.getSessionFactory(); Session session=factory.openSession(); Transaction tx=session.beginTransaction(); User user1=new User(); user1.setUsername("zhangsan"); ..... User user2=new User(); user3.setUsername("lisi"); ..... Role role1=new Role(); role1.setR_rname("管理员"); ..... Role role2=new Role(); role2.setR_rname("普通用户"); ..... User1.getRole().add(role1); User1.getRole().add(role2); User2.getRole().add(role2); session.save(user1); session.save(user2); tx.commit;
级联删除：
User user=session.get(User.class,1); session.delete(user);
维护第三张表：
1、通过第三张表t_user_role来维护用户和角色多对多的关系。
2、让某用户有某角色：
》根据id查询用户和角色
User user=session.get(User.class,2); Role role=session.get(Role.class,1);
》把角色放到用户的set集合中：
user.getRole().add(role);
3、让某用户没有某角色：
User user=session.get(User.class,2); Role role=session.get(Role.class,1); user.getRole().remove(role);