private Object targetObject;

       public Object newProxy(Object targetObject) {

              this.targetObject = targetObject;

              return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),

                                                                targetObject.getClass().getInterfaces(),

                                                                this);

       }

       public Object invoke(Object proxy, Method method, Object[] args)

                     throws Throwable {

              checkSecurity();

              Object ret = null;

              try {

                     ret = method.invoke(this.targetObject, args);

              }catch(Exception e) {

                     e.printStackTrace();

                     throw new java.lang.RuntimeException(e);

              }

              return ret;

       }

       private void checkSecurity() {

              System.out.println("----------checkSecurity()---------------");

       }

}

Advice===checkSecurity

Before advice

After advice

Pointcut(add*)

Weave(应用到目标对象)

Spring只支持方法连接点

Target object proxy introduction

scope可以取值： 

       * singleton:每次调用getBean的时候返回相同的实例

       * prototype:每次调用getBean的时候返回不同的实例

根据名称自动装配

<beans xmlns="http://www.springframework.org/schema/beans"

            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

            xmlns:aop="http://www.springframework.org/schema/aop"

            xmlns:tx="http://www.springframework.org/schema/tx"

            xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd

           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd"

           default-autowire="byName"

           >

不适合实施阶段

根据类型自动装配

<beans xmlns="http://www.springframework.org/schema/beans"

            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

            xmlns:aop="http://www.springframework.org/schema/aop"

            xmlns:tx="http://www.springframework.org/schema/tx"

            xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd

           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd"

           default-autowire="byType"

           >

       参见：spring文档3.3章节

什么是属性编辑器，作用？

       * 自定义属性编辑器，spring配置文件中的字符串转换成相应的对象进行注入

       spring已经有内置的属性编辑器，我们可以根据需求自己定义属性编辑器

       * 如何定义属性编辑器？

              * 继承PropertyEditorSupport类，覆写setAsText()方法，参见：UtilDatePropertyEditor.java

              * 将属性编辑器注册到spring中，参见：applicationContext-editor.xml

依赖对象的注入方式，可以采用：

       * ref属性

       * <ref>标签

       * 内部<bean>来定义

如何将公共的注入定义描述出来？

       * 通过<bean>标签定义公共的属性，指定abstract=true

       * 具有相同属性的类在<bean>标签中指定其parent属性

       参见：applicationContext-other.xml

       <bean id="bean1" class="com.spring.Bean1">

              <property name="strValue" value="Hello"/>

              <!--

              <property name="intValue" value="123"/>

               -->

               <property name="intValue">

                    <value>123</value>

               </property>

               <property name="listValue">

                    <list>

                           <value>list1</value>

                           <value>list2</value>

                    </list>

               </property>

               <property name="setValue">

                    <set>

                           <value>set1</value>

                           <value>set2</value>

                    </set>

               </property>

               <property name="arrayValue">

                    <list>

                           <value>array1</value>

                           <value>array2</value>

                    </list>

               </property>

               <property name="mapValue">

                    <map>

                           <entry key="k1" value="v1"/>

                           <entry key="k2" value="v2"/>

                    </map>

               </property>

               <property name="dateValue">

                    <value>2008-08-15</value>

               </property>

       </bean>

       <bean id="bean2" class="com.bjsxt.spring.Bean2">

              <property name="bean3" ref="bean3"/>

              <property name="bean4">

                     <ref bean="bean4"/>

              </property>   

              <property name="bean5" ref="bean5"/>

       </bean>

       <!--

       <bean id="bean3" class="com.bjsxt.spring.Bean3">

              <property name="id" value="1000"/>

              <property name="name">

                     <value>Jack</value>

              </property>

              <property name="password" value="123"/>

       </bean>

       <bean id="bean4" class="com.bjsxt.spring.Bean4">

              <property name="id" value="1000"/>

              <property name="name" value="Jack"/>

       </bean>

        -->

       <bean id="bean5" class="com.bjsxt.spring.Bean5">

              <property name="age" value="20"/>

       </bean>

</beans>

属性编辑器：

       <bean id="customEditorConfigurer" class="org.springframework.beans.factory.config.CustomEditorConfigurer">

              <property name="customEditors">

                     <map>

                            <entry key="java.util.Date">

                                   <bean class="com.bjsxt.spring.UtilDatePropertyEditor">

                                          <property name="format" value="yyyy-MM-dd"/>

                                   </bean>

                            </entry>

                     </map>

              </property>

       </bean>  

       <!--

       <bean id="utilDatePropertyEditor" class="com.bjsxt.spring.UtilDatePropertyEditor"></bean>

        -->

public class UtilDatePropertyEditor extends PropertyEditorSupport {

       private String format="yyyy-MM-dd";

       @Override

       public void setAsText(String text) throws IllegalArgumentException {

              System.out.println("UtilDatePropertyEditor.saveAsText() -- text=" + text);

              SimpleDateFormat sdf = new SimpleDateFormat(format);

              try {

                     Date d = sdf.parse(text);

                     this.setValue(d);

              } catch (ParseException e) {

                     e.printStackTrace();

              }

       }

       public void setFormat(String format) {

              this.format = format;

       }

}

   <bean id="beanAbstract" abstract="true">

            <property name="id" value="1000"/>

            <property name="name" value="Jack"/>

   </bean>        

   <bean id="bean3" class="com.bjsxt.spring.Bean3" parent="beanAbstract">

            <property name="name" value="Tom"/>

            <property name="password" value="123"/>

   </bean>       

   <bean id="bean4" class="com.bjsxt.spring.Bean4" parent="beanAbstract"/>

       * SPRING_HOME/dist/spring.jar

       * SPRING_HOME/lib/jakarta-commons/commons-logging.jar

       * SPRING_HOME/lib/log4j/log4j-1.2.14.jar

2、拷贝spring配置文件到src下

3、拷贝log4j配置文件到src下

4、在UserManagerImpl中提供构造函数或setter方法，spring将实例化好的UserDao实现注入给我们

5、让spring管理我们的对象创建和依赖，必须在spring配置中进行定义

6、编写客户端

spring Ioc容器的关键点：

       * 必须将被管理的对象定义到spring配置文件中

       * 必须定义构造函数或setter方法，让spring将对象注入过来

       <class name="DataDict" table="t_data_dict">

              <id name="id">

                     <generator class="assigned"/>

              </id>

              <discriminator column="category" type="string"/>

              <property name="name" not-null="true"/>

              <subclass name="ItemCategory" discriminator-value="item_category"/>

              <subclass name="ItemUnit" discriminator-value="item_unit"/>

       </class>

</hibernate-mapping>

<hibernate-mapping package="com.bjsxt.drp.business.itemmgr.model">

       <class name="Item" table="t_items">

              <id name="itemNo">

                     <generator class="assigned"/>

              </id>

              <property name="itemName" not-null="true"/>

              <property name="spec"/>

              <property name="pattern"/>

              <many-to-one name="category"/>

              <many-to-one name="unit"/>

       </class>

</hibernate-mapping>

Hibernate最佳实践

1． 使用Configuration装载映射文件时，不要使用绝对路径装载，最好的方式是通过getResourceAsStream()装载映射文件，这样Hibernate会从classpath中寻找已配置的映射文件。

2． SessionFactory的创建非常消耗资源，整个应用一般只要一个SessionFactory就够了，只有多个数据库的时候才会使用多个SessionFactory.

3． 在整个应用中，Session和事务应该能够统一管理。

4． 将所有的集合属性诶智设置为懒加载。

5． 关联关系，首先Set

6． 一对多使用双向

7． HQL子句本身大小写无关，但是其中出现的类名和属性名必须注意大小写区分

8． 非分布式架构中，不需要使用DTO来向上层传输数据，直接使用POJO的Entity就可以了。

9． 如果要精通Hibernate,熟练掌握关系数据库理论和SQL是前提条件。

保持默认，同fetch="select",如：

<many-to-one name="classes" column="classesid" fetch="select"/>

fetch="select",另外发送一条select语句抓取当前对象关联实体或集合

使用join其实集合的lazy已经失效

hibernate抓取策略（单端代理的批量抓取）

设置fetch="join",如：

<many-to-one name="classes" column="classesid" fetch="join"/>

fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合

此时lazy会失效

hibernate抓取策略（集合代理的批量抓取）

保持默认，同fetch="select",如：

<set name="students" inverse="true" cascade="all" fetch="select">

fetch="select",另外发送一条select语句抓取当前对象关联实体或集合

hibernate抓取策略（集合代理的批量抓取）

设置fetch="join",如：

<set name="students" inverse="true" cascade="all" fetch="join">

fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合

此时lazy会失效

hibernate抓取策略（集合代理的批量抓取）

设置fetch="subselect",如：

<set name="students" inverse="true" cascade="all" fetch="subselect">

fetch="subselect",另外发送一条select语句抓取在前面查询到的所有实体对象的关联集合

hibernate抓取策略，,batch-szie在<class>上的应用

batch-size属性，可以批量加载实体类，参见：Classes.hbm.xml

<class name="Classes" table="t_classes" batch-size="3">

hibernate抓取策略,batch-szie在集合上的应用

batch-size属性，可以批量加载实体类，参见：Classes.hbm.xml

<set name="students" inverse="true" cascade="all" batch-size="5">

JDBC fetch size:

每次取多少条数据，需要JDBC和地层数据库的支持。不会一次性把全部数据读入内存，而是按照一定的数量来批量读取相应的数据。

Fetch size建议值50

Hibernate.jdbc.fetch_size

JDBC batch size

批量更新

建议值30

hibernate.jdbc.batch_size

大多数基于数据版本记录机制（version）实现，一般是在数据库表中加入一个version字段

读取数据时将版本号一同读出，之后更新数据时版本号加一，如果提交数据时版本号小于或等于数据表中

的版本号，则认为数据是过期的，否则给予更新

优点：并发性比较好

T_inventory 1001   nao   1000- 800 0 - 1

用户1 itemNo = 1001 itemName= nao quantity=1000-200=800 version=0

用户2 itemNo = 1001 itemName= nao quantity=1000 – 200=800 version=0

       private int itemNo;

       private String itemName;

       private int quantity;

       private int version;

       <class name="com.bjsxt.hibernate.Inventory" table="t_inventory" optimistic-lock="version">默认就是version

              <id name="itemNo">

                     <generator class="native"/>

              </id>

              <version name="version"/>

              <property name="itemName"/>

              <property name="quantity"/>

       </class>

              Inventory inv = new Inventory();

                     inv.setItemNo(1001);

                     inv.setItemName("脑白金");

                     inv.setQuantity(1000);

                     session.save(inv);

初始化无需保存version

缺点：用户体验不好（录入了大量东西，但提交时被告知已经修改，这样不好）

还可以采用时间戳

对于遗留系统，可以挨个字段比较

悲观锁

悲观锁的实现，通常依赖于数据库机制，在整个过程中将数据锁定，其它任何用户都不能读取或修改（适合短事务）

T_inventory 1001   nao   1000- 800

用户1 itemNo = 1001 itemName= nao quantity=1000-200=800

用户2 itemNo = 1001 itemName= nao quantity=1000 – 200=800

这样会造成更新丢失：

悲观锁：会锁住记录，在一个用户修改完成前，其他用户不能读取和修改

session.load(class, id, LockMode)用这种方式

session.load(Inventory.class, 1, LockMode.UPRADE); 这样会生成select..for update语句

加悲观锁后在load时马上发sql语句

缺点：并发性不好

在hibernate中,component是某个实体的逻辑组成部分，它与实体的根本区别是没有oid，

component可以成为是值对象（DDD）

采用component映射的好处：它实现了对象模型的细粒度划分，层次会更分明，复用率会更高

       <class name="com.bjsxt.hibernate.User" table="t_user">

              <id name="id">

                     <generator class="native"/>

              </id>

              <property name="name"/>

              <component name="contact">

                     <property name="email"/>

                     <property name="address"/>

                     <property name="zipCode"/>

                     <property name="contactTel"/>

              </component>

       </class>

对应表还是一张User表只是对象力度细分

              User user = new User();

                     user.setName("张三");

                     Contact contact = new Contact();

                     contact.setAddress("xxxxx");

                     contact.setEmail("xxx@rrr.com");

                     contact.setZipCode("1111111");

                     contact.setContactTel("9999999999");

                     user.setContact(contact);

                     session.save(user);

复合主键映射

复合（联合）主键映射

通常将复合主键相关的属性，单独放到一个类中

       * 此类必须实现序列化接口

       * 覆写hashcode和equals方法

       public class FiscalYearPeriodPK implements Serializable {

       //核算年

       private int fiscalYear;

       //核算月

       private int fiscalPeriod;

       public int getFiscalYear() {

              return fiscalYear;

       }

       public void setFiscalYear(int fiscalYear) {

              this.fiscalYear = fiscalYear;

       }

       public int getFiscalPeriod() {

              return fiscalPeriod;

       }

       public void setFiscalPeriod(int fiscalPeriod) {

              this.fiscalPeriod = fiscalPeriod;

       }

       @Override

       public int hashCode() {

              final int prime = 31;

              int result = 1;

              result = prime * result + fiscalPeriod;

              result = prime * result + fiscalYear;

              return result;

       }

       @Override

       public boolean equals(Object obj) {

              if (this == obj)

                     return true;

              if (obj == null)

                     return false;

              if (getClass() != obj.getClass())

                     return false;

              final FiscalYearPeriodPK other = (FiscalYearPeriodPK) obj;

              if (fiscalPeriod != other.fiscalPeriod)

                     return false;

              if (fiscalYear != other.fiscalYear)

                     return false;

              return true;

       }

}

       <class name="com.bjsxt.hibernate.FiscalYearPeriod" table="t_fiscal_year_period">

              <composite-id name="fiscalYearPeriodPK">

                     <key-property name="fiscalYear"/>

                     <key-property name="fiscalPeriod"/>  

              </composite-id>

              <property name="beginDate"/>

              <property name="endDate"/>

              <property name="periodSts"/>

       </class>

在继承映射中如果class的abstract属性设成true就不会生成表

set

list

array

map 

t_CollectionMapping

t_set_values

t_list_value

t_array_value

t_map_value

              <id name="id">

                     <generator class="native"/>

              </id>

              <property name="name"/>

              <set name="setValue" table="t_set_value">

                     <key column="set_id"/>

                     <element type="string" column="set_value"/>

              </set>

              <list name="listValue" table="t_list_value">

                     <key column="list_id"/>

                     <list-index column="list_index"/>//为了保存顺序

                     <element type="string" column="list_value"/>

              </list>

              <array name="arrayValue" table="t_array_value">

                     <key column="array_id"/>

                     <list-index column="array_index"/>

                     <element type="string" column="array_value"/>

              </array>

              <map name="mapValue" table="t_map_value">

                     <key column="map_id"/>

                     <map-key type="string" column="map_key"/>

                     <element type="string" column="map_value"/>

              </map>

可以对类进行代理

用在

Class: 可以取值true,false,默认true

Property: 可以取值true,false,需要类增强工具

集合:true/false/extra

one-to-one,many-to-one:取false,proxy/noproxy

lazy概念：只有真正使用该对象时，才会创建，对于hibernate来说，只有真正使用时才会发出sql

测试类lazy:

查id不发sql,因为你传的就是主键，查别的属性会发sql

hibernate的lazy有效期必须是session在open时才可以

解决方式是使用openSessionInview

测试集合lazy:

get集合时不会发sql,迭代会发sql

查个数的时候会把整个集合查出来，这样的话对效率有影响

把class的lazy设置成false时，再load类时会把普通属性都查出来，但是集合不查

class标签上的lazy不会影响到集合上的lazy特性

class标签上的lazy特性只对普通属性起作用

lazy在集合上用extra在获取size的时候会发出count语句，这样对效率有提升

在单端关联上lazy默认，和集合一样，在get时返回代理不发查询语句，在使用时发出sql

在单端关联上lazy=false,在访问普通属性时发出两条sql,查询属性以及对应的关联对象

将class标签上lazy设置成false,其它默认：

不会影响单端关联，也不会影响集合

t_user id |     name 1 | 10 2 | 祖儿 3 | 杰伦

t_role id |        name 1 | 数据录入人员 2 | 商务主管 3 | 大区经理

t_user_role userid | roleid 1                      | 1 1                      | 2 2                      | 2 2      | 3 3      | 1 3      | 2 3      | 3

 

具体映射方式：

       <set name="roles" table="t_user_role">要创建的中间表

           <key column="userid"></key>中间表中的一个字段

           <many-to-many class="com.hibernate.Roles" column="roleid"></many-to-many>中间表的另一个字段

       </set>

双向：

       <set name="users" table="t_user_role">

           <key column="roleid"></key>

           <many-to-many class="com.hibernate.Users" column="userid"></many-to-many>

       </set>

inverse用于一对多，多对多

table属性必须和单向关联中的table属性值一致

key中column属性要与单向关联中many-to-many中的column属性值一致

在many-to-many中的column属性值要与单向关联中key标签的column属性值一致

                     Roles r1 = new Roles();

                     r1.setName("r1");

                     session.save(r1);

                     Roles r2 = new Roles();

                     r2.setName("r2");  

                     session.save(r2);

                     Roles r3 = new Roles();

                     r3.setName("r3");

                     session.save(r3);

                     Users u1 = new Users();

                     Set u1Roles = new HashSet();

                     u1Roles.add(r1);

                     u1Roles.add(r2);

                     u1.setName("u1");

                     u1.setRoles(u1Roles);

                     session.save(u1);

t_classes id     |    name 1     |   尚学堂

t_student id     |    name     |   classesid 1      |   10        |     1 2      |   祖儿     |     1

 

一对多关联映射例用了多对一关联映射原理

多对一关联映射：在多的一端加入一个外键指向一的一端，他维护的关系是多指向一的

一对多关联映射：在多的一端加入一个外键指向一的一端，他维护的关系是一指向多的关系

也就是说一对多和多对一的映射策略是一样的，只是站的角度不同

       <set name="student">属性名

           <key column="classesid"></key>在student生成外键名

           <one-to-many class="com.hibernate.Student" />要添加的表得类

       </set>

先保存学生，后保存班级的效果：先存学生，但是学生表外键字段插入null,然后保存班级，然后更新学生表对应的外键字段。缺点是会发出很多update语句（与set中的数据条数有关），还有如果外键设置为非空情况肯定会保存失败

在一一端维护关系的缺点：

如果将student表的classesid字段设置为非空，则无法保存

因为不是在student这一端维护关系，所以student不知道是哪个班的，所以需要发出多余的update语句来更新关系

双向：

<many-to-one name="classes" column="classesid"></many-to-one>

注意column一定要和one-to-many中的key的column一样，否则会生成新的列

先存班级，再存学生。

为解决上面的问题：

       <set name="student" inverse="true">让一的一端失效，让多的一端维护，关系上的翻转，但是关系字段插入为null,所以只能在多得一端：先存classes将classes设置到student,然后存student

           <key column="classesid"></key>

           <one-to-many class="com.hibernate.Student" />

       </set>

在一的方向保存方式：

Classes classes = new Classes();

Student s1 = new Student();

S1.setClasses(classes);

Set students = new HashSet();

Students.add(s1);

Classes.setStudent(students);

Session.save(classes);

配置需要：

       <set name="student" inverse="true" cascade=”all”>

           <key column="classesid"></key>

           <one-to-many class="com.hibernate.Student" />

       </set>

不需要保存student

一对多双向关联：

在一一端的集合上采用key在对方表中加入一个外键指向一一端

在多一端采用many-to-one

注意key标签指定的外键字段必须和many-to-one指定的外键字段一致，否则引用字段的错误

如果在一一端维护一对多关联关系，hibernate会发出多余的update语句，所以我们一般在多的一端来维护关联关系

关于inverse属性：

inverse主要用在一对多和多对多双向关联上，inverse可以被设置到集合标签set上，默认inverse为false,所以我们可以从一一端和多一端维护关联关系，如果设置成inverse为true,则我们只能从多一端来维护关联关系

注意：inverse属性，只影响数据的存储，也就是持久化

inverse和cascade

inverse是关联关系的控制方向

cascade是操作上的连锁反应

保存classes会根据inverse保存student,student根据cascade要先保存classes

Session flush方法主要做了两件事情：

清理缓存：

执行SQL：

session在什么情况下执行flush

默认在事务提交时

显示的调用flush

在执行查询前，如：iterate

在uuid情况下：save时不会发sql语句（与native不同）

执行flush会立刻发出SQL,临时集合会清理掉

数据库隔离级别：

Select @@tx_isolation;

Set transaction isolation level read uncommitted;

测试uuid主键生成策略：

因为user的主键生成策略采用uuid,所以调用完成save后，只是将user纳入了session管理，不会发出insert语句，但是id已经生成，session中的existsInDatabase状态为false

调用flush,hibernate会清理缓存，执行SQL

如果数据库的隔离级别设置为未提交读，那么我们可以看到flush过的数据，并且我们看到session中的existsInDatabase状态为true

提交事务默认情况下commit操作会先执行flush清理缓存，所以不用显示调用flush

commit后数据是无法回滚的

evict将对象从session中清除，session的EntryEntries属性中拿出

无法成功提交事务，因为hibernate在清理缓存时，在session的insertions临时集合中取出user对象进行insert操作后需要更新EntityEntries的existsInDatabase属性为true,而我们采用evict已经将user从session的Entity Entries中拿出了，所以找不到相关数据，无法更新，抛出异常

解决方式是在evict前之行session.flush,将insertions清除，将existsInDatabase设置为true,当执行evict后提交时就不会发生异常情况了，因为hibernate清理缓存时，在session的insertions集合中无法找到user对象，所以就不会发出insert语句，也不会更新session中的existsInDatabase的状态

测试native主键生成策略：

因为user得主键生成策略为native,所以调用session.save后将执行insert语句，返回由数据库生成的id,纳入了session的管理，还修改了session中的existsInDatabase状态为true

这种情况evict后commit没有任何问题：因为save的同时已经发出insert语句并清理insertions

更新existsInDatabase状态为true,在执行evict时将对象从session中拿出，commit时由于insertions不存在，所以不会发出insert语句也不会更新existsInDatabase的状态，所以不存在主键生成策略为uuid时遇到的问题

测试assign主键生成策略：

测试用例：先增加一个，然后修改，然后再增加

但是生成语句时却是：先增加，然后修改

hibernate按照save,update,delete顺序提交相关操作

如何按照我们的意图操作？

在update后显示执行flush

多对一many-to-one

用户和组

public class Group {

       private String id;

       private String name;

}

public class User {

       private String id;

       private String name;

       private Group group;

}

t_classes id     |    name 1     |   尚学堂

t_student id     |    name     |   classesid 1      |   10        |     1 2      |   祖儿      |     1

 

关系映射的本质：

将关联关系映射到数据库，所谓的关联关系是对象模型内存中的一个或多个引用

persistence对象不能应用transient对象

在save时就发出insert语句

一般可以先保存主表对象，然后保存从表对象

除了正常方式，可以变通：

<many-to-one name="group" column="groupid" cascade="all"/>

cascade:all, none, save-update, delete默认是none

在存user时先将group存了

采用cascade属性是解决TransientObjectException异常的一种手段

变通的手段不那么推荐，因为不符合正常逻辑

加载多的时候就会加载1

<many-to-one>会在多的一端加入一个外键，指向1的一端，这个外建是由<many-to-one>中的column属性定义的，如果忽略这个属性那么默认的外建与实体的属性一致

<many-to-one>标签的定义实例：

理解级联的含义？

是对象的连锁操作

一对一：

Person-IdCard

两种策略实现一对一关联映射

主键关联单向：person相对card时外建表，参照card的id

t_person id    |    name 1               | 菜10 2               | 容祖儿

t_idcard id    |    cardNo 1    |   8888888888 2    |   9999999999

 

hibernate一对一主键关联单向

           <generator class="foreign">

              <param name="property">idCard</param>

           </generator>

<one-to-one name="idCard" constrained="true"></one-to-one>

constrained属性代表要增加外建引用约束

只有一对一主建关联映射中内置默认了cascade=true

one-to-one是告诉如何加载

一对一主建关联映射：让两个实体对象的id保持相同，这样可以避免多余的字段被创建

具体映射

       <id name="id">

           <!—person的主键来源于idCard, 也就是共享idCard的主键 -->

           <generator class="foreign">

              <param name="property">idCard</param>

           </generator>

       </id>

       <property name="name" />

       <!—指示hibernate怎么加载它的关联对象，默认根据主键加载

       constrained=”true”,表明当前主键上存在一个约束，person的主键作为外键参照了idCard

-->

       <one-to-one name="idCard" constrained="true"></one-to-one>

双向：值需要载IdCard里面增加

       <one-to-one name="person"></one-to-one>

指示hibernate如何加载person默认根据主键加载

one to one不会象其他映射一样，他不会改表

一对一外键关联（数据库加字段）多对一特例：

t_person id    |    name   | idcard 3               | 菜10     |   100 4               | 容祖儿   |    200

t_idcard id    |    cardNo 100   |   8888888888 200   |   9999999999

 

    <class name="com.hibernate.Person" table="t_person">

       <id name="id">

           <generator class="native">

           </generator>

       </id>

       <property name="name" />

        <many-to-one name="idCard" unique="true" cascade="all"></many-to-one>

    </class>

采用<many-to-one>标签，制定多的一段的unique=true,这样就限制了多的一段得多重性唯一，通过这种手段映射一对一唯一外键关联

双向：

由于一对一默认按照主键关联，所以原来的one-to-one标签就不可以了，还需要加上一个属性引用，告诉从哪个属性进行关联。

<one-to-one name="person" property-ref="idCard"></one-to-one>

一对一唯一外键双向关联，需要在另一端(idcard)添加<one-to-one>标签，指示hibernate如何加载其关联对象，默认根据主键加载person，外键关联映射中，因为两个实体采用的是person的外键维护的关系，所以不能指定主键加载person,而要根据person的外键加载，所以采用如下映射方式：

<one-to-one name="person" property-ref="idCard"></one-to-one>

JDBC是本地事务，只对单一数据库起作用

Hibernate基本映射

实体类 –〉表

实体类中的普通属性 –〉表字段

采用<class>标签映射成数据库表，通过<property>标签将普通属性映射成表字段

所谓普通属性指不包括自定义类，集合和树组等

auto-import：如果HQL中所需要得类和所在的类不再一个包内如果此属性为false就会报错，默认为true

class属性：

dynamic-update:如果为true则只发出修改字段的update语句，默认为false

dynamic-insert:如果为true,为null的字段不会放到insert语句中

lazy:默认为true

id属性：

必须配到第一个

name:属性column属性 type:类型 length限制字段长度

<generator class=”uuid” />可以制定increment,缺电如果有两个jvm(级群环境)，不能保证生成唯一

identity:自增 mysql

sequence: oracle

uuid是hibernate生成的，不是数据库生成的

guid:sql server,mysql

native:自动选择

assigned:手动分配

<property>: name, column,type

update, insert:如果设置成false,则生成的语句不会出现这些字段

unique：唯一性，比如姓名唯一

not-null:默认时可以为空

uuid方式比自增效率合并发行都要好，缺点是字符串查找比数字慢

注意：如果实体类和实体类的属性和sql中的关键字重复，那么必须采用table或column重新命名

实体类设计原则：

必须要有无参构造方法，

提供一个标示(identifier)属性（可选）

使用非final得类（可选），影响lazy

提供get,set方法

可以使用hibernate.connection.pool设置池

可以使用第三方的池

hibernate.hbm2ddl自动建表

持久对象 get load find iterate save saveorupdate update lock

离线对象 evict close clear 数据库有对应

session级缓存叫一级缓存，save后便纳入管理close后释放

persistent对象如果修改会发出update语句，但是是在commit时发出的

当属性发生改变，hibernate会自动和数据库同步

Name:name

Name:name1

save和属性变化会生成两个独立的对象

在commit时会进行脏数据检查，save会发出insert,修改后会对比新的和原来的不一样，所以会发出update语句。如果前后两个一样不会发update语句

detached对象update方法会变成persistence状态再commit後会发出update语句

get通过id返回的就是对象是persistence状态，发出查询语句,查不到不会抛异常，返回null

load返回的是对象代理，并不发出SQL,是Lazy的，是等到使用到的时候(user.getName)才发出查询,找不到抛异常

可以手动构造detached对象

delete方法会发出delete语句使得对象变成transient状态

分页：根据方言生成不同的分页sql语句

           Query query = session.createQuery("from User");

           query.setFirstResult(0);

           query.setMaxResults(2);

           query.list();

表示层，业务层，持久层，数据库

对象模型到关系模型的转换

阻抗不匹配（继承关系数据库没有这种概念）

还有缓存，除了Hibernate还有OJB,JDO,TopLink,EJB,JPA

IBatis是基于sql映射

操纵对象使得更加对象化，有很好的数据库移植性，透明持久化（不需要继承或者实现什么，纯POJO）

使用情况：对单个对象修改，保存，查询比较适合，对象之间有着很清晰的关系

聚集性操作就不适合，这是O/R映射的一个特点，如果使用数据库特定优化机制的时候也不适合使用

原来的设计方式是先建数据模型，然后对象模型

现在的模式应该是对象模型，然后映射数据模型（自动生成表）

Hibernate支持两种方式配置文件，一种是properties,一种是xml

第一个hibernate项目

1． 创建java项目

2． 引入库

3． 创建全局配置文件，最好加入log4j配置文件

4． 定义实体类

5． 定义实体类的配置文件

6． 将User.hbm.xml加入到全局配置中

7． 编写hbm2ddl工具类，将实体类生成数据库表

一个数据库对应一个SessionFactory,他是线程安全的

Session对Connection进行了包装，在连接池里面拿连接，hibernate默认实现了连接池，也可以集成第三方的连接池，session管理了缓存，这也是跟连接不一样的地方，session是非线程安全的，一个session对应一个业务请求

JNDI:一个树，所有EJB都注册到这个树上，好处是对想可以统一管理，而且不依赖于连接池实现

Query也支持SQL查询

对想也可以获得事件，但是必须实现接口，但是侵入性增大，所以不建议使用，现在一般使用Interceptor

UserType是转换器

基于XML配置方式声明切面

<bean id=”orderservice” class=”cn.service.OrderServiceBean” />

<bean id=”log” class=”cn.service.LogPrint” />

<aop:config>

       <aop:aspect id=”myaop” ref=”log”>

       <aop:pointcut id=”mycut” expression=”execution(* cn.service..*.*(..))”/>

       <aop:before pointcut-ref=”mycut” method=”doAccessCheck” />

       <aop:after-returning pointcut-ref=”mycut” method=”doReturnCheck” />

       <aop:after-throwing pointcut-ref=”mycut” method=”doExceptionAction” />

       <aop:after pointcut-ref=”mycut” method=”doReleaseAction” />

       <aop:around pointcut-ref=”mycut” method=”doBasicProfiling” />

</aop:aspect>

</aop:config>

例外通知会屏蔽后置通知

使用环绕通知可以代替前面所提的所有通知类型

@Aspect

public class MyInterceptor {

       @Pointcut("execution (* cn.service.impl.PersonServiceBean.*(..))")

       public void anyMethod() {} //declare a pointcut

       @Before("anyMethod()") //declare a before advice, parameter is the name of the pointcut

       public void doAccessCheck() {

              System.out.println("before advice");

       }

       @After("anyMethod()")

       public void doAfterReturning() {

              System.out.println("after advice");

       }

       @AfterReturning("anyMethod()")

       public void doAfter() {

              System.out.println("final advice");

       }

       @AfterThrowing("anyMethod()")

       public void doThrow() {

              System.out.println("throw advice");

       }    

       @Around("anyMethod()")

       public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {

              //if () {check authority

                     System.out.println("in");

                     Object result = pjp.proceed();

                     System.out.println("out");

              //}

              return result;

       }

}

如何得到输入参数，返回结果，抛出的异常？

@Aspect

public class MyInterceptor {

    @Pointcut("execution (* cn.service.impl.PersonServiceBean.*(..))")

    public void anyMethod() {} //declare a pointcut

    @Before("anyMethod() && args(name)") //declare a before advice, parameter is the name of the pointcut

    public void doAccessCheck(String name) {

       System.out.println("before advice");

       System.out.println(name);

    }

    @After("anyMethod()")

    public void doAfterReturning() {

       System.out.println("after advice");

    }

    @AfterReturning(pointcut = "anyMethod()", returning = "result")

    public void doAfter(String result) {

       System.out.println("final advice");

       System.out.println(result);

    }

    @AfterThrowing(pointcut = "anyMethod()", throwing = "ex")

    public void doThrow(Exception ex) {

       System.out.println("throw advice");

    }  

    @Around("anyMethod()")

    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {

       //if () {check authority

           System.out.println("in");

           Object result = pjp.proceed();

           System.out.println("out");

       //}

       return result;

    }

}

使用Spring进行面向切面（AOP）编程

要进行AOP编程，首先我们要在Spring的配置文件中引入aop命名空间：

<beans xmlns=http://www.springframework.org/schema/beans

xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance

xmlns:aop=http://www.springframework.org/schema/aop

xsi:schemaLocation=”http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springramework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-2.5.xsd”>

</beans>

spring提供两种切面使用方式，实际工作中我们可以选用其中一种：

基于XML配置方式进行AOP开发

基于注解方式进行AOP开发

基于注解方式声明切面

首先启动对@AspectJ注解的支持（蓝色部分）：

<beans xmlns=http://www.springframework.org/schema/beans

xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance

xmlns:aop=http://www.springframework.org/schema/aop

xsi:schemaLocation=”http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springramework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-2.5.xsd”>

<aop:aspectj-autoproxy/>

</beans>

@Aspect

public class MyInterceptor {

    @Pointcut("execution (* cn.service.impl.PersonServiceBean.*(..))")

    public void anyMethod() {} //declare a pointcut

    @Before("anyMethod()") //declare a before advice, parameter is the name of the pointcut

    public void doAccessCheck() {

       System.out.println("before advice");

    }

}

比较奇怪的是使用方法作为切入点名称

配置文件：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <bean id="myInterceptor" class="cn.service.MyInterceptor"></bean>

    <bean id="personService" class="cn.service.impl.PersonServiceBean"></bean>

</beans>

感谢ITCAST发布的免费视频

在类没有提供接口的情况下，这时候需要用到一个第三方的CGLIB

import java.lang.reflect.Method;

import com.inventec.service.impl.PersonServiceBean;

import net.sf.cglib.proxy.Enhancer;

import net.sf.cglib.proxy.MethodInterceptor;

import net.sf.cglib.proxy.MethodProxy;

public class CGlibProxyFactory implements MethodInterceptor{

    private Object targetObject;

    public Object createProxyInstance(Object targetObject) {

       this.targetObject = targetObject;

       Enhancer enhancer = new Enhancer();

       enhancer.setSuperclass(this.targetObject.getClass());//override the methods which are not final of the target object

       enhancer.setCallback(this);

       return enhancer.create();

    }

    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

       // TODO Auto-generated method stub

       PersonServiceBean bean = (PersonServiceBean) this.targetObject;

       Object result = null;

       if (bean.getUser() != null) {

           result = methodProxy.invoke(targetObject, args);

       }

       return result;

    }

}

分三步：

1.       创建Enhancer

2.       设置目标对象为超类

3.       创建对象

这样就产生了一个目标对象的子类

可以在调用方法前，后，以及出现例外时处理，无论抛不抛异常都会执行的方法

分别为前置通知，后置通知，例外通知，最终通知

还有一种叫做环绕通知，可以决定是否决定业务方法。

AOP中的概念

Aspect(切面)：指横切性关注点的抽象即为切面，它与类很相似，只是两者的关注点不一样，类是对物体特征的抽象，而切面是横切性关注点的抽象。

Joinpoint(连结点)：所谓连结点是指那些被拦截到的点。在spring中，这些点指的是方法，因为spring只支持方法类型的连结点，实际上joinpoint还可以是field或类构造器。

Pointcut(切入点)：所谓切入点是指我们要对那些joinpoint进行拦截的定义。

Advice(通知)：所谓通知是指拦截到joinpoint之后要做的事情就是通知。通知分为前置通知，后置通知，异常通知，最终通知，环绕通知。

Target(目标对象)：代理的目标对象。

Weave(织入)：指将aspects应用到target对象并导致proxy对象创建的过程为织入。

Introduction(引入)：再不修改类代码的前提下，Introduction可以在运行期为类动态添加一些方法或Field.

AOP—代理对象

1．  拦截所有业务方法

2．  判断用户是否有权限，由权限就允许它执行业务方法，没有权限不允许执行业务方法。

代理对象创建由两种：静态代理，动态代理

应用的条件是目标对象必须实现接口

横切性关注点

Source:

public interface PersonService {

       public void save(String name);

       public void update(String name, Integer personid);

       public String getPersonName(Integer personid);

}

public class PersonServiceBean implements PersonService {

       private String user = null;

       public PersonServiceBean() {

       }

       public PersonServiceBean(String user) {

              this.user = user;

       }

       public String getPersonName(Integer personid) {

              // TODO Auto-generated method stub

              System.out.println("I'm getPersonName.");

              return "XXX";

       }

       public void save(String name) {

              // TODO Auto-generated method stub

              System.out.println("I'm save.");

       }

       public void update(String name, Integer personid) {

              // TODO Auto-generated method stub

              System.out.println("I'm update.");

       }

       public String getUser() {

              return user;

       }

}

public class JDKProxyFactory implements InvocationHandler {

       private Object targetObject;

       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

              // TODO Auto-generated method stub

              PersonServiceBean bean = (PersonServiceBean) this.targetObject;

              Object result = null;

              if (bean.getUser() != null) {

                     result = method.invoke(targetObject, args);

              }

              return result;

       }

       public Object createProxyInstance(Object targetObject) {

              this.targetObject = targetObject;

              return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),

                            this.targetObject.getClass().getInterfaces(), this);

       }

}

public class AOPTest {

       @Test

       public void proxyTest() {

              JDKProxyFactory factory = new JDKProxyFactory();

              PersonService service = (PersonService) factory.createProxyInstance(new PersonServiceBean());

              service.getPersonName(1);

       }

}

通过在classpath自动扫描方式把组件纳入spring容器中管理

前面的例子我们都是使用XML的bean定义来配置组件。在一个稍大的项目中，通常会有上百个组件，如果这些组件采用xml的bean定义来配置，显然会增加配置文件的体积，查找以及维护起来也不太方便。Spring2.5为我们引入了组件自动扫描机制，他可以在类路径底下寻找标注了@Component,@Service,@Controller,@Repository注解的类，并把这些类纳入进spring容器中管理。它的作用和在xml文件中使用bean节点配置组件时一样的。要使用自动扫描机制，我们需要打开以下配置信息：

<beans xmlns=http://www.springframework.org/schema/beans

xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance

xmlns:context=http://www.springframework.org/schema/context

xsi:schemaLocation=”http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-2.5.xsd”>

<context:component-scan base-package=”cn.test”>

</beans>

其中base-package为需要扫描的包（含子包）

@Service用于标注业务层组件，@Controller用于标注控制层组件（如struts中的action）,@Repository用于标注数据访问组件，即DAO组件，而@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。

@Service

public class PersonServiceBean implements PersonService {

@Repository

public class PersonDaoBean implements PersonDao {

              AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

              PersonService personService = (PersonService) ctx.getBean("personServiceBean");

              System.out.println(personService);

getBean的默认名称是类名（头字母小写），如果想自定义，可以@Service(“aaaaa”)这样来指定，这种bean默认是单例的，如果想改变，可以使用@Service(“aaaaa”) @Scope(“prototype”)来改变。可以使用以下方式指定初始化方法和销毁方法（方法名任意）：

    @PostConstruct

    public void init() {

    }

    @PreDestroy

    public void destory() {

    }

@Autowire默认按照类型进行注入

@Autowired @Qualifier("personDaoxxx")这样就是按照名称进行装配

@Autowired（required=true）必须注入值，不能为null,为false无论注入什么值都是null

以上都是手工装配

自动装配依赖对象

对于自动装配，大家了解一下就可以了，实在不推荐大家使用。例子：

<bean id=”…” class=”….”>

autowire属性取值如下：

byType：按类型装配，可以根据属性的类型，在容器中寻找根该类型匹配的bean.如果发现多个，那么将会抛出异常。如果没有找到，即属性值为null。

byName：按名称装配，可以根据属性的名称，在容器中寻找根该属性名相同的bean,如果没有找到，即属性值为null。

Constructor与byType的方式类似，不同之处在于它应用于构造器参数。如果在容器中没有找到与构造器参数类型一致的bean,那么将会抛出异常。

Autodetect：通过bean类的自省机制来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式。

使用Field注入（用于注解方式）

注入依赖对象可以采用手工装配或自动装配，在实际应用中建议使用手工装配。

还可以使用@Autowired或@Resource我们需要在xml配置文件中配置以下信息：

<beans xmlns=http://www.springframework.org/schema/beans

xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance

xmlns:context=http://www.springframework.org/schema/context

xsi:schemaLocation=”http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-2.5.xsd”>

<context:annotation-config/>

</beans>

这个配置隐式注册了多个对注释进行解析处理的处理器：AutowiredAnnotationBeanPostProcessor,CommonAnnotationBeanPostProcessor,PersistenceAnnotationBeanPostProcessor,RequiredAnnotationBeanPostProcessor

注：@Resource注解在Spring安装目录的lib\j2ee\common-annotations.jar

@Autowired和@Resource注解方式进行装配，区别是：

@Autowired默认按类型装配，@Resource默认按名称装配，当找不到与名称匹配的bean才会按类型装配。

@Autowired

private PersonDao personDao用于字段上

@Autowired

public void setOrderDao(OrderDao orderDao) {用于属性的setter方法上

       this.orderDao = orderDao;

}

@Autowired朱解释按类型装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它的required属性为false,如果我们向使用按名称装配，可以结合@Qualifier注解一起使用。如下：

@Autowired @Qualifier(“personDaoBean”)

private PersonDao personDao;

@Resource注解和@Autowired一样，也可以标注在字段或属性的setter方法上，但它默认按名称装配。名称可以通过@Resource的name属性指定，如果没有指定name属性，挡住解标注在字段上，即默认取字段的名称作为bean名称寻找依赖对象，挡住解标注在属性的setter方法上，即默认取属性名作为bean名称寻找依赖对象。

@Resource(name=”personDaoBean”)

private PersonDao personDao//用于字段上

注意如果没有指定name属性，并且按照默认的名称仍然找不到依赖对象时，@Resource注解会回退到按类型装配，但一旦指定了name属性，就只能按名称装配了。

public class PersonServiceBean implements PersonService {

       private PersonDao personDao;

       private String name;

       public void save() {

       }

       public PersonServiceBean(PersonDao personDao, String name) {

              super();

              this.personDao = personDao;

              this.name = name;

       }

}

配置文件：

    <bean id="personService" class="service.impl.PersonServiceBean" init-method="init" destroy-method="destory">      

       <constructor-arg index="0" type="PersonDao" ref="personDao">

       </constructor-arg>

       <constructor-arg index="1" type="java.lang.String" value="str">

       </constructor-arg>      

    </bean>