使用hibernate之前:
1.准备所需要的架包
2.完成hibernate配置文件(在hibernate.cfg.xml中配置):
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">
com.microsoft.jdbc.sqlserver.SqlServerDriver
</property>
<property name="connection.url">
jdbc:microsoft://localhost:1433;DataBase=" "
</property>
<property name="connection.username">
sa
</property>
<property name="connection.password">
123
</property>
<property name="dialect">
org.hibernate.dialect.MySqlDialect
</property>
<mapping resource=" .......hbm.xml">
</session-factory>
</hibernate-configuration>
3.确定实体类实现了serializable接口,
并添加了默认构造方法
使用hibernate:
1.读取配置文件:
Configuration conf = new Configuration().configure();
2.创建SessionFactory
SessionFactory sf = conf.buildSessionFactory();
3.打开Session
Session session = sf.openSession();
4.开始一个事物
Transaction ts = session.beginTranscation();
5.持久化操作
除查询外的其它三种操作
6.提交或回滚事物
ts.commit()---ts.rollBack();
7.关闭session
session.close();
<% @ page language="" import="" contentType="" %>
<property name="connection.driver_class">...</property>
<property name="connection.url">...</property>
<property name="connection.username">...</property>
<property name="connection.password">...</property>
<property name="connection.dialect">...</property>
<property name="connection.show_sql">...</property>
<property name="connection.hbm2ddl.auto">...</property> hibernate mapping to database data language
hbm2ddl:hibernate mapping to database language--- hibernate映射到数据库的语言
hql语句:
Configuration conf = new Configuration().configure();
SessionFactory sf = conf.buildSessionFactory();
Session session = sf.openSession();
Transaction tx = null;
...
Session session = super.gerSession();
String hql = ";;;";
Query query = session.createQuery(hql);
List list = query.list();
Session session = this.getSession();
String hql = "from fwxx fw where fw.zj >=:zj1 and fw.zj <=: zj2";
Query query = session.createQuery(hql);
query.setInteger("zj1",100);
query.setInteger("zj2",200);
二级缓存怎么配置?
1.把hibernate中相应的缓存架包导入项目中,一般用OSCache
2.将oscache的oscache.properties放入classpatch的类路径下面,他的位置和默认的myeclipse自动生成的hibernate.cfg.xml的位置是一样的。
在该文件中可以修改oscache的缓存大小,默认的是1000:
cache.capacity=1000
3.在hibernate的配置文件hibernate.cfg.xml中写入相应的二级缓存
<property name=”cache.provider_class”>
org.hibernate.cache.OSCacheProvider
</property>
3.在hibernate的配置文件hibernate.cfg.xml中写入要应用二级缓存的类及缓存策略
<class-cache class = “cn.itcast..dao.entity.User” usage=”read-only”/>
如果该类以后不需要修改则用readonly,修改则用read-write
4.若不用步骤3在hibernate.cfg.xml中指定缓存可以在实体类的相应配置文件中指定,如在User.hbm.xml中,在id属性的上一行指定:
...
<cache usage=”readonly”>
<id name=”id”><generator class=”native”/></id>
...
5.在hibernate的配置文件中启动缓存查询命令
<property name=”cache.use_query_cache”>true</property>
6.get,load和iterator方法可以按以上配置直接从缓存中读取数据
7.query与criteria由于查询命中率低,所以对他们默认的查询缓存是不支持的。
它们必须在hibernate.cfg.xml中设置查询对象是支持缓存的。
比如query查询要设置Query的对象query支持缓存:query.setCacheable(true)
缓存命中率:比如查询100次数据,有几次数据是从缓存中找到的。
一级缓存可以用evict或clear方法清掉(eict是清理一条缓存,clear是清理全部)
二级缓存可以用evict方法清理
二级缓存配置在hibernate的sessionFactory中
因此当ssh整合时,二级缓存要配置在spring的配置文件中。
ql/sql语句中:
em.getReference(Person.class,personid) 得到的是一个代理的对象,多用在删除时候.
当不存在该对象时会出现一个异常
em.gerfind(Person.class,personid) 得到的是一个实体对象,多用在查询时候.
当不存在该对象时返回null
hibernate:???????????????
因为一对多(查询两张表)效率比多对一(查询一张表??)低,实际中并不使用一对多(除非是很少量的数据),而使用多对一关系。
hibernate 主键生成策略:
<id name="id" type="interger">
<column name="id"> <generator class="identity"/>
</id>
1.identity:
使用数据库提供的主键生成机制,自动为主键赋值,不便于数据库的迁移
2.native
hibernate根据不同的数据库方言自动选择不同的主键生成方式,便于不同数据库之间的移植
3.sequence
oracle数据库使用sequence生成主键
4.uuid
支持大部分数据库,但是占用较大的存储空间
5.increase:
多线程对数据库进行写入时可能会出现相同主键而发生主键冲突。
1.set:
<set name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
</set>
2.list:
<list name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
<list-index column="order_id"/>
</list>
or
<bag name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
</bag>
3.map:
<map name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
<map-key type="String" class="name"/>
</map>
4.数组集合:
hibernate中inverse:
hibernate 中关系维护中默认由多的一方维护关系(inverse=”false”),一得一方不维护(inverse=”true”)。这样减少了update语句也就减少了垃圾sql执行代码,提高了性能。
hibernate配置文件中hibernate.hbm2ddl.auto的值:
create: 先drop表再create (默认)
create-drop:也表示创建,不过在系统关闭之前执行一下drop;
update: 加载hibernate时自动更新数据库结构
validate: 加载hibernate时候自动检查数据库表结构是否发生改变,如果改变就抛出异常,不会更新。
hibernate配置中cascade的值:
none:对任何关系不进行级联(默认)
all: 对所有关系进行级联(即:save-update和delete)
save-update: 在进行save和update操作时进行级联
delete:在进行delete时进行级联
all-delete-orphan:当一个对象在关系图中成为孤儿时,删除该节点
lazy(什么时候抓取数据)的值:
proxy:使用代理(3.0之后有的,默认)
true:是用懒加载
false:不使用懒加载
fetch(什么方式抓取数据)的值:
select:对相关的每张表进行select查询(默认)
join: 对关联的字段查询,效率较高
一对一的时候查主对象不能懒加载(hibernate无法判断相关联的从对象是否存在,若是存在才可以把主对象的外键构造出来,若不存在设为空),查从对象的时候可以懒加载。
openSessionInView是线程级别session,在线程开启期间保持打开状态,在页面渲染的时候session也是打开的。它会把session和transaction的会话周期延长。造成内存长时间被占用。
hibernate大批量数据的处理:容易造成缓存溢出问题
hibernate3.0之前:是一条记录移交记录的处理:
Session s = null;
try{
s = HibernateUtil.getSession();
Transaction t = s.beginTransaction();
Query q = s.createQuery(“from myUsers”);
List<User> users = q.list();
for(User u:users){
u.setBirthday(new Date());
}……
上面的方法可以这样写:每更新20条记录就将缓存数据写入数据库,同时清空缓存
for(int i=0;i<10000000;i++){
s.save(user);
if(i%20 == 0 ){
s.flush();
s.clear();
}
hibernate3.0之后:通过q.executeUpdate()批量执行,并且每更新一条记录就清空缓存。
Query q1 = s.createQuery(“update myUsers set birthday := ….”);
q1.executeUpdate();
t.commit();
hibernate的联合主键:
在联合主键类中必须实现serializable接口并重写equal()方法和hashCode()方法
映射文件中用<composite-id 标签:
<class name="Person">
<composite-id name="unitedKey">
<key-property name="firstName" column="first_name" length="12"/>
<key-property name="lastName" column="last_name" length="12"/>
</composite-id>
<property name="ss" length="12"/>
</class>
枚举:通过<param name="type">12</param>来指定枚举的类型是String,默认是int:
<hibernate-mapping package="com.cn">
<class name="Person" table="[right]" schema="dbo" catalog="crmDatabase">
<id name="id">
<generator class="native" />
</id>
<property name="name" type="java.lang.String"/>
<property name="gender" not-null="true">
<type name="org.hibernate.type.EnumType"><!-- 将type的name是枚举类型 -->
<param name="enumClass">com.cn.Gender</param><!-- 指定映射的Gender类路径 -->
<param name="type">12</param><!-- 12表示指定映射到数据库的类型是String,默认是int类型。此处的值根据枚举类的属性类型来决定 -->
</type>
</property>
</class>
</hibernate-mapping>
继承关系:
1、映射到同一张表:discriminator-value与subclass。sql语句执行效率高(因为执行的sql是在同一张表上),但是映射有点乱,且子类会出现空的属性。
<hibernate-mapping package="com.cn1">
<class name="Employee" discriminator-value="0">
<id name="id">
<generator class="native" />
</id>
<properties name="name" unique="true"/>
<discriminator column="type" type="String"/>
<subclass name="Seller" discriminator-value="1">
<property name="sell"/>
</subclass>
<subclass name="Skiller" discriminator-value="2">
<property name="skill"/>
</subclass>
</class>
</hibernate-mapping>
2、映射到不同的表:用joined-subclass。子类单独映射到各自的一张表中,然后利用joined-subclass连接起来。sql语句执行效率低,但是各表映射清晰。
<hibernate-mapping package="com.cn2">
<class name="Employee">
<id name="id">
<generator class="native" />
</id>
<properties name="name" unique="true"/>
<joined-subclass name="Seller" table="seller">
<key column="emp_id"/>
<property name="sell"/>
</joined-subclass>
<joined-subclass name="Skiller" table="skiller">
<key column="emp_id"/>
<property name="skill"/>
</joined-subclass>
</class>
</hibernate-mapping>
3、映射到同一张和另外表的结合:结合了第一种和第二种继承映射的优点。执行较快,结构换算清晰。
<hibernate-mapping package="com.cn3">
<class name="Employee" discriminator-value="0">
<id name="id">
<generator class="native" />
</id>
<properties name="name" unique="true"/>
<discriminator column="type" type="String"/>
<subclass name="Seller" discriminator-value="1">
<property name="sell"/>
</subclass>
<subclass name="Skiller">
<join table="skiller">
<key column="emp_id">
<property name="skill"/>
</join>
</subclass>
</class>
</hibernate-mapping>
编写一个hibernate的映射文件内容:
<hibernate-mapping package=”com.cn”>
<class name=”Employee” >
<id name=”id”>
<generator class=”native”>
</id>
<property name=”name”/>
<many-to-one name=”depart” column=”dapart_id”/>
</class>
</hibernate-mapping>
1.准备所需要的架包
2.完成hibernate配置文件(在hibernate.cfg.xml中配置):
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">
com.microsoft.jdbc.sqlserver.SqlServerDriver
</property>
<property name="connection.url">
jdbc:microsoft://localhost:1433;DataBase=" "
</property>
<property name="connection.username">
sa
</property>
<property name="connection.password">
123
</property>
<property name="dialect">
org.hibernate.dialect.MySqlDialect
</property>
<mapping resource=" .......hbm.xml">
</session-factory>
</hibernate-configuration>
3.确定实体类实现了serializable接口,
并添加了默认构造方法
使用hibernate:
1.读取配置文件:
Configuration conf = new Configuration().configure();
2.创建SessionFactory
SessionFactory sf = conf.buildSessionFactory();
3.打开Session
Session session = sf.openSession();
4.开始一个事物
Transaction ts = session.beginTranscation();
5.持久化操作
除查询外的其它三种操作
6.提交或回滚事物
ts.commit()---ts.rollBack();
7.关闭session
session.close();
<% @ page language="" import="" contentType="" %>
<property name="connection.driver_class">...</property>
<property name="connection.url">...</property>
<property name="connection.username">...</property>
<property name="connection.password">...</property>
<property name="connection.dialect">...</property>
<property name="connection.show_sql">...</property>
<property name="connection.hbm2ddl.auto">...</property> hibernate mapping to database data language
hbm2ddl:hibernate mapping to database language--- hibernate映射到数据库的语言
hql语句:
Configuration conf = new Configuration().configure();
SessionFactory sf = conf.buildSessionFactory();
Session session = sf.openSession();
Transaction tx = null;
...
Session session = super.gerSession();
String hql = ";;;";
Query query = session.createQuery(hql);
List list = query.list();
Session session = this.getSession();
String hql = "from fwxx fw where fw.zj >=:zj1 and fw.zj <=: zj2";
Query query = session.createQuery(hql);
query.setInteger("zj1",100);
query.setInteger("zj2",200);
二级缓存怎么配置?
1.把hibernate中相应的缓存架包导入项目中,一般用OSCache
2.将oscache的oscache.properties放入classpatch的类路径下面,他的位置和默认的myeclipse自动生成的hibernate.cfg.xml的位置是一样的。
在该文件中可以修改oscache的缓存大小,默认的是1000:
cache.capacity=1000
3.在hibernate的配置文件hibernate.cfg.xml中写入相应的二级缓存
<property name=”cache.provider_class”>
org.hibernate.cache.OSCacheProvider
</property>
3.在hibernate的配置文件hibernate.cfg.xml中写入要应用二级缓存的类及缓存策略
<class-cache class = “cn.itcast..dao.entity.User” usage=”read-only”/>
如果该类以后不需要修改则用readonly,修改则用read-write
4.若不用步骤3在hibernate.cfg.xml中指定缓存可以在实体类的相应配置文件中指定,如在User.hbm.xml中,在id属性的上一行指定:
...
<cache usage=”readonly”>
<id name=”id”><generator class=”native”/></id>
...
5.在hibernate的配置文件中启动缓存查询命令
<property name=”cache.use_query_cache”>true</property>
6.get,load和iterator方法可以按以上配置直接从缓存中读取数据
7.query与criteria由于查询命中率低,所以对他们默认的查询缓存是不支持的。
它们必须在hibernate.cfg.xml中设置查询对象是支持缓存的。
比如query查询要设置Query的对象query支持缓存:query.setCacheable(true)
缓存命中率:比如查询100次数据,有几次数据是从缓存中找到的。
一级缓存可以用evict或clear方法清掉(eict是清理一条缓存,clear是清理全部)
二级缓存可以用evict方法清理
二级缓存配置在hibernate的sessionFactory中
因此当ssh整合时,二级缓存要配置在spring的配置文件中。
ql/sql语句中:
em.getReference(Person.class,personid) 得到的是一个代理的对象,多用在删除时候.
当不存在该对象时会出现一个异常
em.gerfind(Person.class,personid) 得到的是一个实体对象,多用在查询时候.
当不存在该对象时返回null
hibernate:???????????????
因为一对多(查询两张表)效率比多对一(查询一张表??)低,实际中并不使用一对多(除非是很少量的数据),而使用多对一关系。
hibernate 主键生成策略:
<id name="id" type="interger">
<column name="id"> <generator class="identity"/>
</id>
1.identity:
使用数据库提供的主键生成机制,自动为主键赋值,不便于数据库的迁移
2.native
hibernate根据不同的数据库方言自动选择不同的主键生成方式,便于不同数据库之间的移植
3.sequence
oracle数据库使用sequence生成主键
4.uuid
支持大部分数据库,但是占用较大的存储空间
5.increase:
多线程对数据库进行写入时可能会出现相同主键而发生主键冲突。
1.set:
<set name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
</set>
2.list:
<list name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
<list-index column="order_id"/>
</list>
or
<bag name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
</bag>
3.map:
<map name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
<map-key type="String" class="name"/>
</map>
4.数组集合:
hibernate中inverse:
hibernate 中关系维护中默认由多的一方维护关系(inverse=”false”),一得一方不维护(inverse=”true”)。这样减少了update语句也就减少了垃圾sql执行代码,提高了性能。
hibernate配置文件中hibernate.hbm2ddl.auto的值:
create: 先drop表再create (默认)
create-drop:也表示创建,不过在系统关闭之前执行一下drop;
update: 加载hibernate时自动更新数据库结构
validate: 加载hibernate时候自动检查数据库表结构是否发生改变,如果改变就抛出异常,不会更新。
hibernate配置中cascade的值:
none:对任何关系不进行级联(默认)
all: 对所有关系进行级联(即:save-update和delete)
save-update: 在进行save和update操作时进行级联
delete:在进行delete时进行级联
all-delete-orphan:当一个对象在关系图中成为孤儿时,删除该节点
lazy(什么时候抓取数据)的值:
proxy:使用代理(3.0之后有的,默认)
true:是用懒加载
false:不使用懒加载
fetch(什么方式抓取数据)的值:
select:对相关的每张表进行select查询(默认)
join: 对关联的字段查询,效率较高
一对一的时候查主对象不能懒加载(hibernate无法判断相关联的从对象是否存在,若是存在才可以把主对象的外键构造出来,若不存在设为空),查从对象的时候可以懒加载。
openSessionInView是线程级别session,在线程开启期间保持打开状态,在页面渲染的时候session也是打开的。它会把session和transaction的会话周期延长。造成内存长时间被占用。
hibernate大批量数据的处理:容易造成缓存溢出问题
hibernate3.0之前:是一条记录移交记录的处理:
Session s = null;
try{
s = HibernateUtil.getSession();
Transaction t = s.beginTransaction();
Query q = s.createQuery(“from myUsers”);
List<User> users = q.list();
for(User u:users){
u.setBirthday(new Date());
}……
上面的方法可以这样写:每更新20条记录就将缓存数据写入数据库,同时清空缓存
for(int i=0;i<10000000;i++){
s.save(user);
if(i%20 == 0 ){
s.flush();
s.clear();
}
hibernate3.0之后:通过q.executeUpdate()批量执行,并且每更新一条记录就清空缓存。
Query q1 = s.createQuery(“update myUsers set birthday := ….”);
q1.executeUpdate();
t.commit();
hibernate的联合主键:
在联合主键类中必须实现serializable接口并重写equal()方法和hashCode()方法
映射文件中用<composite-id 标签:
<class name="Person">
<composite-id name="unitedKey">
<key-property name="firstName" column="first_name" length="12"/>
<key-property name="lastName" column="last_name" length="12"/>
</composite-id>
<property name="ss" length="12"/>
</class>
枚举:通过<param name="type">12</param>来指定枚举的类型是String,默认是int:
<hibernate-mapping package="com.cn">
<class name="Person" table="[right]" schema="dbo" catalog="crmDatabase">
<id name="id">
<generator class="native" />
</id>
<property name="name" type="java.lang.String"/>
<property name="gender" not-null="true">
<type name="org.hibernate.type.EnumType"><!-- 将type的name是枚举类型 -->
<param name="enumClass">com.cn.Gender</param><!-- 指定映射的Gender类路径 -->
<param name="type">12</param><!-- 12表示指定映射到数据库的类型是String,默认是int类型。此处的值根据枚举类的属性类型来决定 -->
</type>
</property>
</class>
</hibernate-mapping>
继承关系:
1、映射到同一张表:discriminator-value与subclass。sql语句执行效率高(因为执行的sql是在同一张表上),但是映射有点乱,且子类会出现空的属性。
<hibernate-mapping package="com.cn1">
<class name="Employee" discriminator-value="0">
<id name="id">
<generator class="native" />
</id>
<properties name="name" unique="true"/>
<discriminator column="type" type="String"/>
<subclass name="Seller" discriminator-value="1">
<property name="sell"/>
</subclass>
<subclass name="Skiller" discriminator-value="2">
<property name="skill"/>
</subclass>
</class>
</hibernate-mapping>
2、映射到不同的表:用joined-subclass。子类单独映射到各自的一张表中,然后利用joined-subclass连接起来。sql语句执行效率低,但是各表映射清晰。
<hibernate-mapping package="com.cn2">
<class name="Employee">
<id name="id">
<generator class="native" />
</id>
<properties name="name" unique="true"/>
<joined-subclass name="Seller" table="seller">
<key column="emp_id"/>
<property name="sell"/>
</joined-subclass>
<joined-subclass name="Skiller" table="skiller">
<key column="emp_id"/>
<property name="skill"/>
</joined-subclass>
</class>
</hibernate-mapping>
3、映射到同一张和另外表的结合:结合了第一种和第二种继承映射的优点。执行较快,结构换算清晰。
<hibernate-mapping package="com.cn3">
<class name="Employee" discriminator-value="0">
<id name="id">
<generator class="native" />
</id>
<properties name="name" unique="true"/>
<discriminator column="type" type="String"/>
<subclass name="Seller" discriminator-value="1">
<property name="sell"/>
</subclass>
<subclass name="Skiller">
<join table="skiller">
<key column="emp_id">
<property name="skill"/>
</join>
</subclass>
</class>
</hibernate-mapping>
编写一个hibernate的映射文件内容:
<hibernate-mapping package=”com.cn”>
<class name=”Employee” >
<id name=”id”>
<generator class=”native”>
</id>
<property name=”name”/>
<many-to-one name=”depart” column=”dapart_id”/>
</class>
</hibernate-mapping>