http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
(4):采用注解方式配置事务所需的注解处理器
<tx:annotation-driven transaction-manager="txManager"/>

(5):为业务bean注入数据源

(6)
@Transactional 被声明的类的每个方法将会在同一个事务中执行.
在需要事务执行环境的业务逻辑层需要使用 @Transactional 注解

2:
使用属性文件保存数据库连接信息
需要在Spring配置文件中配置的元素为:
<context:property-placeholder location="classpath:jdbc.properties"/>
加入classpath 的目的为高速Spring容器文件在类路径下
然后将在Spring配置文件中的元素以${名称}代替属性文件的相应的键即可

2:
改变Spring的默认事务行为:
(1):使Spring回滚checked例外(默认不会滚):
在方法的声明上标注
@Transactional(rollbackFor=异常的名称.class)
其中异常的名称为方法抛出的异常(例外)的类名称
则Spring在遇到此checked异常时,就会回滚事务

(2):使Spring不回滚unchecked 例外(默认回滚)
在方法的声明上标注
@Transactional(noRollbackFor=RuntimeException.class)
则在方法遇到unchecked例外(运行期异常)时,则会提交事务
或者使用 noRollbackForClassName="异常的名称" 和 rollbackForClassName="异常的名称" 来指定

3:
以下的事务可以在 @Transactional(propagation=Propagation.xxx) 中的xxx即为以下事务的类型.
Spring事务的分类:
REQUIRED,NOT_SUPPORTED,REQUIRESNEW,MANDATORY,SUPPORTS,NERVER,NESTED
REQUIRED:
业务方法需要在一个事务中运行.如果方法运行时,已经处在一个事务中,那么假如到该事务,否则为自己创建一个新的事务.
NOT_SUPPORTED:
声明方法不需要事务.如果方法没有关联到一个事务,容器不会为它开启事务.如果方法在一个事务中被调用,该事务会被挂起,在方法调用结束后,原先的事务便会恢复执行.
REQUIRESNEW:
属性表明不管是否存在事务,业务方法总会为自己发起一个新的事务,容器不会为它开启事务.
如果方法已经存在一个事务中,则原有事务被挂起,新的事务会被创建,直到方法执行结束,新的事务才算结束.原先事务才会恢复执行.
MANDATORY:
该属性指定业务方法只能在一个已近存在的事务中执行,业务方法不能发起自己的事务.如果业务方法没有在事务的环境下调用,容器就会抛出例外.
SUPPORTS:
这一事务表明属性,如果业务方法在某个事务范围内被调用,则方法称为该事务的一部分.如果业务方法在事务范围外被调用,则方法在没有事务的环境下执行.
NEVER:
指定业务方法绝对不能再事务范围内执行.如果业务方法在某个事务中执行,容器会抛出异常,只有业务方法没有关联到任何事务,才能正常执行.
NESTED:
如果一个活动的事务存在,则运行一个嵌套的事务中.如果没有活动事务,则按REQUIRED属性执行.它使用了一个单独的事务,这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。但外部事务的回滚会造成内部事务的回滚. 它只对DataSourceTransactionManager事务管理器起效.

4:
@Transactional(timeout=30)
中指定事务的超时时间,一般情况下不用设置

5:
@Transactional(readOnly="")
在只读事务中使用,可以提高效率,但不可以执行增删改.

6:
@Transactional(isolation=Isolation.DEFAULT);
指定数据库的事务隔离级别:主要由底层数据库实现.
包括种类:
Read Uncommited : 读未提交数据(会出现脏数据,不可重复读和幻读)
Read Commited : 读已提交数据(会出现不可重复读和幻读) (SQLServer 默认级别)
Repeatable Read : 可重复读(会出现幻读) (MySQL 默认级别)(一般情况下是这种级别)
Serializable : 串行化
这几种级别是由数据库的不同的锁来实现:如 共享锁,更新锁,排他锁

脏读: 一个事务读取到另一个事务未提交的更新数据.

不可重复读: 在同一个事务中,多次读取同一数据返回的结果有所不同.即:后续读取可以读取另一事物已提交的更新数据.
相反,"可重复读"在同一事务多次读取数据时,能够保证所读取数据一样,也就是说,后续数据不能读到另一事物已提交的更新数据.
可重复读在数据库采取的技术为"快造"技术

幻读:一个事物读取都另一事物已提交的insert数据.


7:
使用XML方式配置Spring事务:
<aop:config>
 <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
 <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config>
<tx:advice id="txAdvice" transaction-manager="txManager">
 <tx:attributes>
  <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/> <!-- 对读取方法采用只读 事务 -->
  <tx:method name="*"/> <!-- 其他按照默认设置 如事务隔离级别 事务类型 -->
 </tx:attributes>
</tx:advice>

2:
Spring aop 应用方面:
例如:权限系统、运行期监控

3:
<bean id="aspectbean" class="cn.rui.aop.XmlInterceptor"/>
<aop:config>
 <aop:aspect id="asp" ref="aspectbean">
  <aop:pointcut id="mycut" expression="execution(* com.rui..*.*(..))"/>
  <aop:before pointcut-ref="mycut" method="doAccessCheck"/>
  <aop:after-returning pointcut-ref="mycut" method="doAfterReturning"/>
  <aop:after-throwing pointcut-ref="mycut" method="doAfterThrowing"/>
  <aop:after point-ref="mycut" method="doAfter"/>
  <aop:around point-ref="mycut" method="doBasicProfiling"/>
 </aop:aspect>
</aop:config>

4:
对于执行的表达式 execution(* com.rui..*.*(..)) execution(1 2..3.4(5))

中对于1 为方法的返回值 可以指定任意类型 * 代表所有类型, 其他类型用包名 + 类名如java.lang.String,空为void, 若取非某种类型则为 ! 加上 类型即可 如: !java.lang.String 或 !void

对于2 为包名 对于包名后的两个点意为包含所有的子包,也可直接为包名+ 类名

对于3为类名 可以写 * 代表所有的类,也可指定特定的类 直接类名即可

对于4为方法名 * 代表所有方法 ,也可指定特定的方法

对于 5 为方法的参数 可以指定 .. 代表所有的方法,对于方法的比如方法的第一个参数必须为java.lang.Integer 的则表达式为 (java.lang.Integer,..)
对于最后一个参数必须为java.lang.String则为(..,java.lang.String) 前面的两个点代表String类型前可能有也可能没有

2:
加入Spring AOP的支持
(1):加入jar包，在配置文件中导入aop命名空间，加入<aop:aspectj-autoproxy/>元素
(2):定义切面类
(3):在切面类中加入注解:

: 在类前的注解
@Aspect

: 声明一个切入点
@Pointcut("execution(* cn.itcast.service..*.*(..))")
private void anyMethod() {} // 定义切入点的名称是通过方法的定义来定义的.

:定义前置通知
@Before("anyMethod() && args(userName)") 其中 userName 为限制方法的参数必须为String 类型的
public void doAccessCheck(String userName) {}

:定义后置通知
@AfterReturning(pointcut="anyMethod()",returning="revalue")
public void doReturnCheck(String revalue) {}

:定义例外通知
@AfterThrowing(pointcut="anyMethod()",throwing="ex")
public void doExceptionAction(Exception ex){}

:定义最终通知
@After("anyMethod()")
public void doReleaseAction() {}

:环绕通知
@Around("anyMethod()")
public doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
 return pjp.proceed();
}

以上 anyMethod() 为切入点的名称, 为要应用的切入点
args 、returning、throwing 为可不定义的可选参数,但被标注方法也要跟着参数的有无而改变方法的参数.
环绕通知的方法的签名是死格式

3:
把类加入Spring管理:
在Spring配置文件中加入或用 @Component 组件注解进行标注即可.

4:
通知流程图:
// 环绕通知
// 前置通知
try{
 // 方法执行
 // 后置通知
}catch(Exception e){
 // 例外通知
}finally{
 // 最终通知
}

5:
第 19 集

2:
返回属性的类型 是否是 指定参数的类型或者是指定参数的基类(即把参数强转成properdesc类型是否可以，可以则返回true，否则返回false)
PropertyDescriptor properdesc = Introspector.getBeanInfo(Bean.class).getPropertyDescriptors();
properdesc.getPropertyType().isAssignableFrom(other.class);

3:
getDeclaredFields() 得到所有类中声明的字段（但不包括从父类继承过来的类型）

4:
用注解来实现依赖注入的规则：
（1）：在 字段 或 setter 方法上注明注解
(2):读取XML文件
（3）：得到所有的属性 遍历 赋值
 (4): 得到所有的字段 判断是否有注解 赋值

5:
@Autowired(required=false) 中 required 默认为true，指的是当找不到时会抛出异常，当为false时，会给其赋值为null

6:
自动装配的几种方式：
byType: 按类型装配，可以根据属性的类型，在容器中寻找跟该类型匹配的bean。
如果发现多个，那么将会抛出异常。如果没有找到，即属性值为null
byName: 按名称装配，可以根据属性的名称，在容器中寻找跟该属性名相同的bean，
如果没有找到，即属性为null
constructor与byType的方式类似，不同之处在于它应用于构造函数。如果在容器中没有找到与构造器参数类型一致的bean，那么将会抛出异常。
autodetect: 通过bean类的自省机制（introspection）来决定是使用constructor还是
byType方式进行自动装配。如果没有发现默认的构造器，那么将使用byType方式。

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

8:
使用Spring classpath 自动扫描 方式 把组件纳入spring容器中管理 的步骤：
一：加入context命名空间 
二：在XML文件中加入 元素 <context:component-scan base-package="cn.itcast"/> 注册Spring自动扫描处理器,这个元素默认注册了以前<context:annotation-config />元素所注册的所有处理器
三：在DAO类前加入 @Repository 注解,在Service类前加入 @Service 注解，在控制组件类前加入 @Control 注解
四：注解所注明的类默认为单例 即 @Scope("singleton") ,如果需要，可以用 @Scope("prototype") 来使用 原型模式（每一次请求，可以标注在 @Control 上）
五：可以使用 @PostContruct 来标注初始化的方法 ，使用 @PreDestory 来标注销毁的方法 。其 @PostContruct 等同于 以前在XML文件中写的 init-method="" 注解，其 @PreDestory 注解等同于 在xml文件中配置的 destory-method="" 元素
六：要使其执行 @PreDestory 所标注的方法则使用 单例singleton模式，而不是原型prototype模式

9:
使用cglib 来创建没有实现接口的类的代理对象
一：加入 cglib-nodep-2.1_3.jar 文件
二：Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(要代理的类);
enhancer.setCallback(实现MethodInterceptor接口的类);

四：写一个实现 MethodInterceptor 接口的类，并且实现其方法

2:
PropertyDescriptor[] propDesc = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
ConvertUtils.convert(value,propDesc[0].getPropertyType()); // 转换属性的类型

3:
ProperyDescriptor
Properties props = new Properties();
props.load(this.getClass().getResourceAsStream("相对路径如：config.properties或者：绝对路径: /包名/config.properties")

4:
对于集合的类型的注入：
<property name="sets">
 <set>
  <value>set1</value>
  <value>set2</value>
  <value>set3</value>
 </set>
</property>
<property name="lists">
 <list>
  <value>list1</value>
  <value>list2</value>
  <value>list3</value>
 </list>
</property>
<property name="props">
 <props>
  <prop key="key1">value1</prop>
  <prop key="key2">value2</prop>
  <prop key="key3">value3</prop>
 </props>
</property>
<property name="map">
 <map>
  <entry key="key-1" value="value-1">
  <entry key="key-2" value="value-3">
  <entry key="key-2" value="value-3">
 </map>
</property>

5:
使用构造器进行bean的配置
（1）：在实体bean中创建构造函数
public PersonServiceBean(PersonDao personDao, String name) {
 this.personDao = personDao;
 this.name = name;
}
(2): 在配置文件中配置，根据构造函数的索引进行配置，索引从0开始
<constructor-arg index="0" ref="personDao"></constructor-arg>
<constructor-arg index="1" value="zhangsan"></constructor-arg>

6:
使用字段Field注入：
@Autowired 默认按类型装配，如果想使用名称装配，可以结合 @Qualifier注解一起使用
eg:
@Autowired @Qualifier("personDaoBean")
private PersonDao personDao;
@Resource 如果指定name属性则根据name，否则按照标注的属性名称进行寻找，
当找不到与名称匹配的bean才会按类型装配,可以用在字段上，也可以用在setter方法上

2:
依赖注入:
使用构造函数 或 setter 方法

3:
事务是局限在数据库连接之内的,所以使用两个连接的方法是不能使用同一个事务的.

解决办法:
Connection conn = null;
conn.setAutoCommit(false);
Bean1.update(); // 更新金额
Bean2.save(); // 记录操作日志
// 提交事务

4:
如果不论更新金额是否成功,都需要记录日志,则需要使两个方法分别使用不同的事务.

5:
Spring 声名式事务

保证两个方法在同一个事务中执行,在方法的前面加上:
@Transactional(propagation=Propagation.Required)

使方法在新的事务中执行:
@Transactional(propagation=Propagation.RequiredNew)

6:
Spring 给我们带来的好处:
(1): 降低组件之间的耦合度,实现软件各层之间的解耦
(2): 可以使用容器提供的众多服务,如:事务管理服务,消息服务等等.
当我们使用容器管理事务时,开发人员就不需要手工控制事务,也不需要处理复杂的事务传播.
(3): 容器提供单利模式支持,开发人员不在需要自己编写实现代码.
(4): 容器提供众多的辅助类,使这些类能够加快应用的开发:如 JdbcTemplate,HibernateTemplate
(5): Spring对于主流的应用框架提供了集成支持,如:集成Hibernate,JPA,Struts等,这样更便于应用的开发.

7:
使用Spring 提供的服务很少,应用属于轻量级
使用Spring 提供的服务很多,应用属于重量级
EJB 容器默认为应用提供了EJB规范中的所有的功能,所以它属于重量级的
EJB 的服务包括: 安全服务, jndi服务,

2:
依赖注入:
使用构造函数 或 setter 方法

3:
事务是局限在数据库连接之内的,所以使用两个连接的方法是不能使用同一个事务的.

解决办法:
Connection conn = null;
conn.setAutoCommit(false);
Bean1.update(); // 更新金额
Bean2.save(); // 记录操作日志
// 提交事务

4:
如果不论更新金额是否成功,都需要记录日志,则需要使两个方法分别使用不同的事务.

5:
Spring 声名式事务

保证两个方法在同一个事务中执行,在方法的前面加上:
@Transactional(propagation=Propagation.Required)

使方法在新的事务中执行:
@Transactional(propagation=Propagation.RequiredNew)

6:
Spring 给我们带来的好处:
(1): 降低组件之间的耦合度,实现软件各层之间的解耦
(2): 可以使用容器提供的众多服务,如:事务管理服务,消息服务等等.
当我们使用容器管理事务时,开发人员就不需要手工控制事务,也不需要处理复杂的事务传播.
(3): 容器提供单利模式支持,开发人员不在需要自己编写实现代码.
(4): 容器提供众多的辅助类,使这些类能够加快应用的开发:如 JdbcTemplate,HibernateTemplate
(5): Spring对于主流的应用框架提供了集成支持,如:集成Hibernate,JPA,Struts等,这样更便于应用的开发.

7:
使用Spring 提供的服务很少,应用属于轻量级
使用Spring 提供的服务很多,应用属于重量级
EJB 容器默认为应用提供了EJB规范中的所有的功能,所以它属于重量级的
EJB 的服务包括: 安全服务, jndi服务,