spring与hibernate整合及hibernate知识点

一、Hibernate
1、Hibernate映射关系
关联关系有两个分类：（1）单向关系：只需单向访问关联端。
（2）双向关系：关联的两端可以互相访问。
<1>、单向N-1关联
（1）无连接表的N-1关联
使用<many-to-one>元素。
<many-to-one>元素常用属性：
 name:该属性的名字
 column:指定进行关联的外键列的列名
 class:关联实体的全限定类名
 cascade:指定哪些操作会从主表记录级联到子表记录
（2）有连接表的N-1关联
<2>、单向1-1关联
从持久化类来看，单向1-1与单向N-1没有丝毫区别，配置也类似，在<many-to-one>元素中增加unique=“true”即可。
（1基于外键的单向1-1
    两个实体各自有不同的主键，但其中有一个实体有一个外键引用了另一个实体的主键。增加unique=“true”
(2)基于主键的单向1-1
    关联的两个实体共享一个主键值。
    基于主键关联的持久化类不能拥有自己的主键生成策略，它的主键由关联类负责生成。
    采用<one-to-one>元素，并通过name属性指定关联实体属性的属性名。
<3>、单向1-N关联
单向1-N关联的持久化类里需要使用集合属性，映射文件中使用<one-to-many>元素，并通过class属性指定关联实体的类型。
对于单向1-N关联，需要在1的一端增加Set属性的set和get方法。
   注意：(1)必须指定cascade=“all”.
         (2)尽量少用单向1-N关联，而是使用双向1-N关联。
<4>、单向N-N关联
单向N-N关联和1-N关联的持久化类代码完全相同，控制关系的一端需要增加一个Set集合属性，被关联的持久化实例以集合形式存在。
N-N关联与有连接表的1-N关联相似，只要去掉<many-to-many>元素的unique=“true”即可。
<many-to-many>元素的class属性指定关联实体的类名。
<5>、双向1-N关联
对于1-N关联，Hibernate推荐使用双向关联，而且不要让1的一端控制关联关系，而使用N的一端控制关联关系。
两端都需要增加对类关联属性的访问，N的一端增加<many-to-one>引用到关联实体的属性，1的一端增加集合属性<set>，并使用<many-to-many>映射关联属性。
注意：inverse=“true”用于指定N的一端不控制关联关系。
<6>、双向N-N关联
双向N-N只能使用连接表来建立两个实体之间的关联关系。
两端都使用Set集合来增加对集合属性的访问。增加<many-to-many>元素来映射关联实体类。
<7>、双向1-1关联
需要修改两边的持久化类，让两个持久化类都增加引用关联实体的属性。
（1）基于外键的双向1-1关联
     外键可以存放在任意一边，需要存放外键的一端需要增加<many-to-one>元素并设置unique=“true”。
    另一端需要使用<one-to-one>，并使用name属性指定关联属性名。
（2）基于主键的双向1-1关联
     其中一端的主键生成器使用foreign策略。
2、HQL：(Hibernate Query Language )Hibernate查询语言
Query query = session.createQuery("from Person as p where p.name=?");
      query.setString(0,"1");
      List list = query.list();
      for(int i=0;i<list.size();i++) {
          Person p = (Person) list.get(i);
          System.out.println(p.getId());
          System.out.println(p.getAge());
     }
from子句：from关键字后紧跟持久化类的类名。
   例如：from Person as p或 from Person p
select子句：
（1）查询单个属性。select子句用于确定选择出的属性，当然select选择的属性必须是from 后持久化类包含的属性。
   例如：select p.name from Person as p
（2）查询多个属性。查询语句可以返回多个对象和（或）属性，存放在 Object[]队列中。
例如：
         select p.name,p.address from Person as p
eg：
Query query = session.createQuery("select p.name,p.age from Person as p");
      List list = query.list();
      for(int i=0;i<list.size();i++) {
             Object obj[] = (Object[])list.get(i);
             System.out.println("姓名是"+obj[0]+"年龄是"+obj[1]);
     }
（3）封装成对象。
例如：
   select new Person(p.name,p.age) from Person as p
        前提是Person支持p.name 和p.age的构造方法.
eg：
Query query = session.createQuery("select new Person(p.name,p.age) from Person as p");
      List list = query.list();
      for(int i=0;i<list.size();i++) {
              Person p = (Person)list.get(i);
              System.out.println("姓名是"+p.getName()+"年龄是"+p.getAge());
     }
HQL也支持在选出的属性上，使用聚集函数。HQL支持的聚集函数与SQL完全相同，有如下5 个：
1. avg，计算属性平均值。
2. count，统计选择对象的数量。
3. max，统计属性值的最大值
4. min，统计属性值的最小值。
5. sum，计算属性值的总和。
例如：
select count(*) from Person
select max(p.age) from Person as p
where子句：用于筛选选中的结果，缩小选择的范围。如果没有为持久化实例命名别名，可以直接使用属性名引用属性。
  例如：from Person where name like 'tom%'
         如果为持久化实例命名了别名，则应该使用完整的属性名。
  例如：from Person as p where p.name like "tom%"
Hibernate 2中的更新：
Person user=(Person)session.get(Person.class,new Integer(1));
user.setAge(new Integer(18));
session.save(user);
Hibernate 3中的更新：
String hql=“update Person  set age=18 where id=1”;
Query query=session.createQuery(hql);
query.executeUpdate();

Hibernate中的批量更新：
String hql=“update Person set age=18”;
Query query=session.createQuery(hql);
query.executeUpdate();
Hibernate中的批量删除：
String hql=“delete Person where age>18”;
Query query=session.createQuery(hql);
query.executeUpdate();

3、ORM的数据缓存包含如下层次：
1. 事务级缓存：在当前事务范围内的数据缓存策略。
2. 应用级缓存：在某个应用中，或者应用中某个独立数据访问子集中的共享缓存。
3. 分布式缓存：在多个应用实例，多个JVM之间共享的缓存模式。
Hibernate的数据缓存分为两个层次：
1. 内部缓存（也称为一级缓存）：session.save（）
2. 二级缓存
     二级Cache是SessionFactory范围内的缓存,所有的Session共享同一个二级Cache。
     在引入二级缓存时必须考虑以下两个问题：
1. DB是否与其他应用共享
2. 应用是否需要部署在集群环境中

Hibernate中缓存在以下情况中发挥作用：
1. 通过id（主键）加载数据时
2. 延迟加载
   如果数据满足以下条件，则可以纳入缓存管理：
1. 数据不会被第三方应用更改
2. 数据大小在可接受的范围内
3. 数据更新频率较低
4. 同一数据可能会被系统频繁利用
5. 非关键数据
不适合放入缓存的数据：
1.经常被修改的数据。
2.财务数据，绝对不允许出现并发。
3.与其他应用共享的数据
4.Hibernate中本身并未提供二级缓存的产品化实现，而是通过第三方缓存组件提供了接入接口。
4、（1）事务的特性
     事务是一步或几步操作组成的逻辑执行单元。
     事务具备4个特性:   原子性
一致性
隔离性
持久性
（2）Hibernate的事务
    Hibernate直接使用JDBC连接和JTA资源，不添加任何附加锁定行为 。
    利用事务可避免的相关问题：
– 避免脏读
– 不可重复读
– 虚读
事务实现方式：1）、编程式事务实现
2）、声明式事务实现1、xml配置文件
                                        2、Annotation
5、Hibernate性能优化1）开启懒加载方式（延迟加载）
2）开启二级缓存


二、Spring
Spring是一个开源框架，是为了解决企业应用程序开发复杂性而创建的一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

1、Spring包括两个重要的概念：
 IoC(Inversion of Control)中文译为控制反转也可以叫做DI（Dependency Injection，依赖注入）
 AOP(Aspect Oriented Programming)面向切面的编程。
2、在Spring中大量使用以下两种设计模式：
1.单态模式
       单态模式限制了类实例的创建。采用这种模式设计的类可以保证仅有一个实例。
2.工厂模式
       工厂模式根据调用数据返回某个类的一个实例。
Spring实现两种设计模式
（1）Spring对工厂模式的实现
      随着Spring提供工厂模式的实现，在使用Spring时，无需自己提供工厂类，因为Spring容器是最大的工厂。
（2）Spring对单态模式的实现
      Spring对接收容器管理的全部bean，默认采用单态模式管理。
控制bean对象4个作用域：
1.singleton:单例模式，只有一个实例（默认）
2.prototype:原型模式，每次调用getBean()都获得一个新的实例
3.request:对于每次HTTP请求，都将产生一个实例
4.session:对于每次HTTPSession，都将产生一个实例
5.global session:每个全局的HTTPSession对应一个Bean实例(很少用）
3、何谓轻量级（Lightweight）
 所谓“轻量级”是相对于“重量级”来讲的。
 重量级容器是一种入侵式的。

4、Spring配置文件基本结构
eg：

自动装配 autowire 属性可以接受如下值：no、byName、byType

5、Spring有两个核心容器：BeanFactory和ApplicationContext。
BeanFactory和ApplicationContext区别：
Spring容器最基本的接口是BeanFactroy。
      BeanFactory负责配置、创建和管理Bean。
      BeanFactory有一个子接口：ApplicationContext。
      BeanFactory中的getBean()，可获得指定Bean的引用，无需关心Bean的实例化过程。
      Spring配置文件中使用<bean…/>配置一个Bean的实例。

ApplicationContext是BeanFactory的子接口，它增强了BeanFactory的功能。
除了具备BeanFactory的全部功能外，还有一些额外的功能，如国际化支持、事件机制、载入多个配置文件等。

ApplicationContext的国际化支持：
    ApplicationContext继承了MessageResource接口，因此具有国际化功能。
ApplicationContext接口扩展了MessageSource接口，因而提供了消息处理的功能（i18n或者国际化）。
BeanFactory创建实例的示例：
//以类加载路径下的配置文件创建ClassPathResource实例
ClassPathResource isr = new ClassPathResource("bean.xml");
//以Resource对象作为参数，创建BeanFactory的实例
XmlBeanFactory factory = new XmlBeanFactory(isr);
Chinese b1 = (Chinese)factory.getBean("chi");

示例：
//创建Spring的ApplicationContext
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Person p = (Person)ctx.getBean("person");

6、读图











1.核心容器：提供Spring框架的基本功能。
2.Spring 上下文：是一个配置文件，向Spring框架提供上下文信息。
3.Spring  AOP：通过配置管理特性，SpringAOP模块直接将面向切面的编程功能集成到了Spring框架中。
4.Spring DAO：JDBC DAO抽象层提供了有意的异常层次结构。
5.Spring ORM：Spring框架插入了若干个ORM框架，从而提供了ORM的对象工具。
6.Spring Web 模块：为基于Web的应用程序提供上下文。
7.Spring MVC 框架：MVC框架是一个全功能的构建Web应用程序的MVC实现。

7、Spring web MVC基本原理图


8、AOP
1）关注点(Concern)
     关注点也就是我们要考察或解决的问题。
     把一个系统中的核心功能称为核心关注点跨越多个模块的关注点称为横切关注点或交叉关注点(Crosscutting Concerns) 。
     在AOP的编程方法中，主要在于对关注点的提起及抽象。
2）切面(Aspect)
     切面是一个抽象的概念，从软件的角度来说是指在应用程序不同模块中的某一个领域或方面。
     AOP中的切面(aspect)是实现世界领域问题的抽象，除了包括属性、方法以外，同时切面中还包括切入点Pointcut、增强(advice)等。 
3）连接点(Join point)
     连接点也就是运用程序执行过程中需要插入切面模块的某一点。
     这个点可以是一个方法、一个属性、构造函数、类静态初始化块，甚至一条语句。
4）切入点(Pointcut)
     切入点指一个或多个连接点，可以理解成一个点的集合。切入点的描述比较具体，而且一般会跟连接点上下文环境结合。
pointcut :指定切入点表达式
5）增强或通知(Advice)
     增强(Advice)里面定义了切面中的实际逻辑（即实现)， 即法增强(Advice)是指在定义好的切入点处，所要执行的程序代码。

9、通常需要通过一个value属性，指定一个切入点表达式，用于指定该增强处理将被织入哪些切入点。
  eg：//执行lee包下所有类的、所有方法都将作为切入点
@After("execution(* lee.*.*(..))")


10、Spring有两种方式定义切入点和增强处理（AOP实现方式）：
① 基于Annotation的方式：使用@Aspect、@PointCut等Annotation
② 基于XML配置文件的管理方式：使用Spring的配置文件
Advice分类：
@Before－标识一个前置增强；
@AfterReturning－标识返回后增强；
@AfterThrowing－标识异常抛出增强；
@After－标识后增强；
@Around－标识环绕增强； 

11、配置切入点
          使用<aop:pointcut…/>元素。
          当把其作为<aop:config…/>的子元素时，表示该切入点可被多个切面共享。
          当把其作为<aop:aspect…/>的子元素时，表示该切入点只能在对应的切面中有效。
      两个属性：
① id：指定该切入点的标识名
② expression:指定该切入点关联的切入点表达式

12、Spring 和 Hibernate 整合
  DAO 、数据库访问对象（注意编程）
HibernateDaoSupport 实现DAO
       Spring 为Hibernate 的DAO 提供了工具类一HibernateDaoSupport。该类主要提供如下两个方法来方便DAO 的实现:
    public final HibernateTemplate getHibernateTemplate()
    public final void setSessionFactory(SessionFactory sessionFactory)

    Hibernate的DAO实现依然借助于HibernateTemplate的模板访问方式，只是HibernateDaoSupport提供了两个工具方法，所以代码更加简洁了。
    程序无需理会Hibernate的Session管理，Spring会采用“每次事务打开一个Session”的策略，自动提高DB访问的性能。

13、（1）Spring对Hibernate的支持
     通过Spring整合Hibernate，使持久层的访问更加容易。
1）基于依赖注入的SessionFactory管理机制
2）更优秀的Session管理机制
3）统一的事务处理
4）统一的异常处理机制
5）HibernateTemplate支持类
Spring对Hibernate的简化：
• Spring提供了HibernateTemplate，用于简化持久层的访问。程序员只需要完成持久层逻辑，通用的操作则由HibernateTemplate完成。
• Spring对Hibernate的简化，还得益于Spring的异常处理策略。

使用HibernateTemplate无须实现特定接口，只需提供一个SessionFactory的引用，就可执行持久化操作。
    HibernateTemplate的构造方法：
    1） HibernateTemplate()
    2） HibernateTemplate(SessionFactory s)
    3） HibernateTemplate(SessionFactory s,boolean allowCreate)
14、数据注入次序
dataSource→sessionFactory→DAO实现类→service→action
15、模板中提供的数据访问方法：this.getHibernateTemplate();
① void delete(Object entity): 删除指定持久化实例。
② deleteAll(Collection entities): 删除集合内全部持久化类实例。
③ find(String query String): 根据HQL 查询字符串来返回实例集合。
④ findByNamedQuery(String queryName): 根据命名查询返回实例集合。
⑤ get(Class entityClass, Serializable id): 根据主键加载特定持久化类的实例。
⑥ save(Object entity): 保存新的实例。
⑦ saveOrUpdate(Object entity): 根据实例状态，选择保存或者更新。
⑧ update(Object entity): 更新实例的状态，要求entity 是持久状态。
⑨ setMaxResults(int maxResults): 设置分页的大小。
16、编程 (仅供参考)
eg：
1、 spring与hibernate整合
1.删除主键为6的记录
2.将主键为7的对象的年龄改为999
3.查询所有人的年龄
4.查询姓名为9的人的年龄
5.将所有人的年龄改为888
PersonDao.java
public interface PersonDao
{
  Person get(Integer id);
  Integer save(Person person);
  void update(Person person);
  void delete(Integer id);
  void delete(Person person);
  List<Person> findByName(String name);
  public List findAllPerson();
}
PersonDaoHibernate.java
public class PersonDaoHibernate extends HibernateDaoSupport implements PersonDao
{
public Person get(Integer id)
{
return (Person)getHibernateTemplate().get(Person.class, id);
}
public Integer save(Person person)
{
return (Integer)getHibernateTemplate()
.save(person);
}
public void update(Person person)
{
getHibernateTemplate().update(person);
}
public void delete(Integer id)
{
getHibernateTemplate().delete(get(id));
}
public void delete(Person person)
{
getHibernateTemplate().delete(person);
}
public List<Person> findByName(String name)
{
return (List<Person>)getHibernateTemplate()
.find("from Person p where p.name like ?" , name);
}
public List findAllPerson()
{
return (List<Person>)getHibernateTemplate()
.find("from Person");
}
}
HibernateTest.java
public class HibernateTest
{
public static void main(String[] args)throws Exception
{
//创建Spring容器
ApplicationContext ctx=new ClassPathXmlApplicationContext("bean.xml");
//获取DAO组件
PersonDao pdao = (PersonDao)ctx.getBean("personDao");
//循环插入10条记录
/*for (int i = 0 ; i < 10  ; i++ )
{
pdao.save(new Person(i + "" , i + 10));
}*/

//pdao.delete(6);   //删除主键为6的记录

/*Person p=pdao.get(7);
p.setAge(999);
pdao.update(p);*/  //将主键为7的对象的年龄改为999

/*List<Person> l=pdao.findAllPerson();
for(int i=0;i<l.size();i++)
{
Person p=l.get(i);
System.out.print("Age:"+p.getAge()+"\n");
    }*/  //查询所有人的年龄


/*List<Person> l=pdao.findByName("9");
for(int i=0;i<l.size();i++)
{
Person p=l.get(i);
System.out.print("Age:"+p.getAge()+"\n");
    }*/   //查询姓名为9的人的年龄

List<Person> l2=pdao.findAllPerson();
for(int i=0;i<l2.size();i++)
{
Person p=l2.get(i);
p.setAge(888);
pdao.update(p);
    }   //将所有人的年龄改为888
    }
}
bean.xml
<property name="mappingResources">
<list>
<!-- 以下用来列出Hibernate映射文件 -->
<value>Person.hbm.xml</value>
</list>
</property>
<!-- 定义DAO Bean-->
<bean id="personDao" class="lee.PersonDaoHibernate">
<!-- 注入持久化操作所需的SessionFactory -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
2、 Spring
输出圆的面积
MyCircle.java
  public class MyCircle
{
int r;
public void setR(int r)
{
this.r=r;
}
public int getR()
{
return r;
}
public double area()
{
return 3.14*r*r;
}
}
SpringTest.java
public class SpringTest
{
public static void main(String[] args)
{
//创建Spring的ApplicationContext
ApplicationContext ctx = new
ClassPathXmlApplicationContext ("applicationContext.xml");
//输出Spring容器
System.out.println(ctx);
MyCircle m = (MyCircle)ctx.getBean("mycircle");
    System.out.print(m.area());
   }
}
applicationContext.xml
<bean id="mycircle" class="lee.MyCircle">
  <property name="r" value="2" />
  </bean>
3、Spring与Hibernate与Struts整合 （略）