Spring学习笔记(3)

1.Spring AOP框架相关概念

Aspect(切面): 是通知和切入点的结合,通知和切入点共同定义了关于切面的全部内容---它的功能、在何时和何地完成其功能。

 

joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点。如personService的add方法之前。

 

Pointcut(切入点): 指一堆连接点的集合。比如所有名字为add*的方法之前。有一种表达式语言描述这个切入点。Spring使用AspectJ的切入点描述语法，有点类似于正则表达式。execution(*cn.itcast.gz.service..add*(..))。

 

Advice(通知): 指在连接点(切入点）的什么位置，做什么事情。

 

Target(目标对象):代理的目标对象。即对哪个对象进行切入其它方面的代码。

 

Weaving(织入): 把几个切面的代码切入核心业务组件的过程。静态织入，在编译的时候就织入(支持aop特殊编译器,AspectJ)。动态织入，编译使用的普通的java编译器，在运行的时候通过代理来进行织入(Spring)。静态织入比动态织入运行性能高。

 

Introduction(引入): 在不修改代码的情况下，给一个已经存在的业务组件动态添加一些方法，字段，增加功能。(动态让其去实现一些接口。)

2.Spring AOP框架的基本应用

2.1 AOP简单应用

1）引入aop相关的jar包

aopalliance.jar aop         联盟

aspectjweaver.jar          AspectJ

cglib-nodep-2.1_3.jar           生成代理类

org.springframework.aop-3.1.1.RELEASE.jar aop     核心包

 

2）在beans.xml配置文件中加入aop命名空间

3）配置切面Bean

4）配置切面

5）配置切入点

6）配置通知

配置文件：

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

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

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

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

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

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

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

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

      <bean id="personDAO"class="com.maple.spring.aop.PersonDAOImpl"/>

       

      <bean id="securityAspectBean"class="com.maple.spring.aop.SecurityAspect"/>

     

      <aop:config>

          

           <aop:aspect ref="securityAspectBean">

                

                 <aop:pointcut expression="execution(*com.maple.spring.aop.IPersonDAO.*(..))" id="personDAOMethods"/>

                

<aop:before method="checkPermission"pointcut-ref="personDAOMethods"/>

           aop:aspect>

      aop:config>

beans>

切面Bean：

publicclass SecurityAspect {

      publicboolean checkPermission() {//无参数的方法

           System.out.println("执行权限检查....----------");

           boolean flag = false;

           if(!"admin".equals(UserContext.getUser())){

                 System.out.println("无权限。。。--------");

                 thrownew RuntimeException("没有权限！");

           }else {

                 flag= true;

                 System.out.println("有权限。。。--------");

           }

           return flag;

      }

}

全局切入点的配置：

但有多个切面要织入一个同一个切入点的时候，可以将切入点配置成全局的切入点，即将其提取到切面外面。

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

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

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

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

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

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

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

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

      <bean id="personDAO"class="com.maple.spring.aop.PersonDAOImpl"/>

       

      <bean id="securityAspectBean"class="com.maple.spring.aop.SecurityAspect"/>

      <bean id="writeLogAspectBean"class="com.maple.spring.aop.WriteLogAspect"/>

     

      <aop:config>

          

<aop:pointcut expression="execution(*com.maple.spring.aop.IPersonDAO.*(..))" id="personDAOMethods"/>

          

           <aop:aspect ref="securityAspectBean">

                

                 <aop:before method="checkPermission"pointcut-ref="personDAOMethods"/>

           aop:aspect>

          

           <aop:aspect ref="writeLogAspectBean">

                 <aop:before method="writeLogBefore"  pointcut-ref="personDAOMethods"/>

                 <aop:after-returning method="writeLogAfter"  pointcut-ref="personDAOMethods"/>

           aop:aspect>

      aop:config>

beans>

2.2AOP通知详解—基于XML配置

1）前置通知 aop:before

2）后置通知 aop:after-running

3）异常通知 aop:after-throwing

4）最终通知 aop:after

5) 环绕通知（可以替代前面四种通知） aop:around

<bean id="personDAO"class="com.maple.spring.aop.PersonDAOImpl"/>

      <bean id="writeLogAspectBean"class="com.maple.spring.aop.WriteLogAspect"/>

<aop:config>

<aop:pointcut expression="execution(*com.maple.spring.aop.IPersonDAO.*(..))" id="personDAOMethods"/>

           <aop:aspect ref="writeLogAspectBean">

<aop:before method="writeLogBefore"  pointcut-ref="personDAOMethods"/>

                 <aop:after-returning method="writeLogAfter"  pointcut-ref="personDAOMethods"/>

<aop:after-throwing method="wrtetLogThrow"  pointcut-ref="personDAOMethods"throwing="e"/>

<aop:after method="wrtetLogFianl"pointcut-ref="personDAOMethods" />aop:aspect>

      aop:config>

5) 环绕通知（可以替代前面四种通知） aop:around

 

所谓的环绕通知是指环绕在切入点四周的方法。用环绕通知可以在切入点方法的前面后面，任意位置执行执行自己的代码，由自己控制要不要调用目标对象的方法。

使用环绕通知时，对切面Bean中的方法是有要求的，方法必须返回Object类，并有一个ProceedingJoinPoint类型的参数。如：

public Object check(ProceedingJoinPointpoint) {

       .....

       Objectret = ....

       returnret

}

切面Bean：

publicclass AroundAspect {

      /**

       * 方法必须返回Object类型且有一个ProceedingJoinPoint类型的参数

       */

      public Objectcheck(ProceedingJoinPoint point) {

           Objectobj = null;

           try {

                 //前置通知

                 System.out.println("执行权限检查...........");

                  obj = point.proceed();//放行，即执行目标对象上的方法

                 //后置通知

                 System.out.println("执行审计功能...........");

           }catch (Throwable e) {

                 //异常通知

                 System.out.println("出现异常" + e.getMessage());

                 thrownew RuntimeException(e.getMessage());

           }finally {

                 //最终通知

                 System.out.println("方法调用完了");

           }

           return obj;

      }

}

配置文件：

<bean id="personDAO"class="com.maple.spring.aop.PersonDAOImpl"/>

      <bean id="aroundAspectBean"class="com.maple.spring.aop.AroundAspect" />

      <aop:config>

           <aop:pointcut expression="execution(*com.maple.spring.aop.IPersonDAO.*(..))" id="personDAOMethods"/>

           <aop:aspect ref="aroundAspectBean">

                

<aop:around method="check"pointcut-ref="personDAOMethods"/>

           aop:aspect>

      aop:config>

2.3AOP通知详解—基于Annotation配置

1）用到的注解

 

@Aspect 用在类上，说明该类是一个切面Bean。

@Pointcut("execution(*com.maple.spring..*(..))")用在自定义方法上，定义一个切入点

@Before("personDAOMehtods()")前置通知

@AfterReturning("personDAOMehtods()")后置通知

@AfterThrowing(pointcut="personDAOMehtods()",throwing="e")@After("personDAOMehtods()")最终通知

@Around("personDAOMehtods()")环绕通知

@Aspect//说明该类是一个切面Bean

publicclassWriteLogAspectAnntation {

      //配置一个名为personDAOMehtods()的切入点

      @Pointcut("execution(*com.maple.spring..*(..))")

      publicvoidpersonDAOMehtods(){   }

      @Before("personDAOMehtods()")

      publicvoid writeLogBefore() {

           System.out.println(UserContext.getUser()+"准备调用方法");

      }

      @AfterReturning("personDAOMehtods()")

      publicvoid writeLogAfter() {

           System.out.println(UserContext.getUser()+"调用方法成功");

      }

      @AfterThrowing(pointcut="personDAOMehtods()", throwing="e")

      publicvoidwrtetLogThrow(Exception e) {

           System.out.println(UserContext.getUser()+"出现异常：" +e.getMessage() + new Date());

      }    

      @After("personDAOMehtods()")

      publicvoid wrtetLogFianl() {

System.out.println(UserContext.getUser()+"最终。。。" + new Date());

      }

}

3. Spring中的数据库

3.1模版技术

把具有相同功能的代码模板抽取到一个工具类中。如把访问jdbc的模板代码抽到Template中，使用模板类，可以不用管有关连接管理，关闭等细节。只在我们的代码包括核心业务的代码把访问jdbc的模板代码抽到Template中，使用模板类，可以不用管有关连接管理，关闭等细节。只在我们的代码包括核心业务的代码。

3.2 Spring中的JdbcTemplete

Spring 提供了JdbcTemplate类，用于简化jdbc操作。只要写核心业务代码就可以了。

publicclass PersonImpl implements IPersonDAO {

      //使用Sprig提供的jdbc操作模版

      private JdbcTemplate template;

      /**

       * 提供setter方法，让spring注入值

       * @param template

       */

      publicvoid setTemplate(JdbcTemplatetemplate) {

           this.template = template;

      }

      @Override

      publicvoid save(final Person p) {

           //调用自定的executeUpdate方法进行保存

           Stringsql = "insert into persons(name, age) values('"+ p.getName() + "', " + p.getAge()+ ")";

           template.execute(sql);

      }

      @Override

      publicvoid remove(final Long id) {

           Stringsql = "delete from persons where id=" + id;

           template.execute(sql);

      }

      @Override

      publicvoid update(final Long id, final Person p) {

           Stringsql = "update persons set name='" + p.getName() + "', age=" + p.getAge() +" where id =" + id;

           template.execute(sql);

      }

}

配置文件：

     

      <context:property-placeholder location="db.properties"/>

     

      <bean id="dataSource"class="org.apache.commons.dbcp.BasicDataSource">

          

<property name="driverClassName"value="${driverClassName}"/>

<property name="url"value="${url}"/>

<property name="username"value="${username}"/>

<property name="password"value="${password}"/>

      bean>

     

      <bean id="template"class="org.springframework.jdbc.core.JdbcTemplate">

           <constructor-arg name="dataSource"ref="dataSource"/>

      bean>

      <bean id="personDAO"class="com.maple.spring.dao.impl.PersonImpl">

          

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

      bean>

3.3使用JdbcTemplete最好的方式

以上方式使用Spring提供的JdbcTemplete还需要手动注入。不是最好的方法。最好的是让实现类同时继承JdbcDAOSupport类，该类提供了getJdbcTemplate()方法，可以直接获取JdbcTemplate对象。

publicclass PersonImpl2 extends JdbcDaoSupport implements IPersonDAO {

      @Override

      publicvoid save(final Person p) {

           Stringsql = "insert into persons(name, age) values('"+ p.getName() + "', " + p.getAge()+ ")";

           getJdbcTemplate().execute(sql);

      }

      @Override

      publicvoid remove(final Long id) {

           Stringsql = "delete from persons where id=" + id;

           getJdbcTemplate().execute(sql);

      }

      @Override

      publicvoid update(final Long id, final Person p) {

           Stringsql = "update persons set name='" + p.getName() + "', age=" + p.getAge() +" where id =" + id;

           getJdbcTemplate().execute(sql);

      }

 

      @Override

      public Person get(final Long id) {

           //要传入一个RowMapper对象，自己处理返回结果集

           returngetJdbcTemplate().queryForObject("select * from persons where id=" + id, new MyRowMapper());

      }

      @Override

      public Listlist() {

returngetJdbcTemplate().query("select * from persons", new MyRowMapper());

      }

      /**

       * TODO自定义RowMapper

       */

      privateclass MyRowMapper implementsRowMapper {

           @Override

public PersonmapRow(ResultSet rs, int rowNum) throws SQLException {

                 Personp  = new Person();

                 p.setId(rs.getLong("id"));

                 p.setName(rs.getString("name"));

                 p.setAge(rs.getInt("age"));

                 return p;

           }

      }

}

配置文件：

      <context:property-placeholder location="db.properties"/>

     

      <bean id="dataSource"class="org.apache.commons.dbcp.BasicDataSource">

          

<property name="driverClassName"value="${driverClassName}"/>

           <property name="url"value="${url}"/>

           <property name="username"value="${username}"/>

           <property name="password"value="${password}"/>

      bean>

      <bean id="personDAO"class="com.maple.spring.dao.impl.PersonImpl2">

          

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

      bean>

4.事务管理

4.1事务概述

事务是一组操作的执行单元，相对于数据库操作来讲，事务管理的是一组SQL指令，比如增加，修改，删除等，事务的一致性，要求，这个事务内的操作必须全部执行成功，如果在此过程种出现了差错，比如有一条SQL语句没有执行成功，那么这一组操作都将全部回滚。

 

事务的特点（ACID）

Atomic(原子性):要么都发生，要么都不发生。

Consistent(一致性):数据应该不被破坏。

Isolate(隔离性):用户间操作不相混淆。

Durable(持久性):永久保存,例如保存到数据库中等。

 

事务隔离级别：

DEFAULT     使用后端数据库默认的隔离级别(spring中的的选择项)。

READ_UNCOMMITED      允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读。

READ_COMMITTED 允许在并发事务已经提交后读取。可防止脏读，但幻读和不可重复读仍可发生。

REPEATABLE_READ 对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏、不可重复读，但幻读仍可能发生。

SERIALIZABLE   完全服从ACID的隔离级别，确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的。

 

脏读:一个事务读取了另一个事务改写但还未提交的数据,如果这些数据被回滚，则读到的数据是无效的。

不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同。换句话说就是，后续读取可以读到另一事务已提交的更新数据。相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是，后续读取不能读到另一事务已提交的更新数据。

幻读：一个事务读取了几行记录后，另一个事务插入一些记录，幻读就发生了。再后来的查询中，第一个事务就会发现有些原来没有的记录。

 

小结:

不同的隔离级别采用不同的锁类型来实现，在四种隔离级别中，Serializable的隔离级别最高，Read Uncommited的隔离级别最低。

 

大多数据库默认的隔离级别为ReadCommited，如SqlServer,也有少部分数据库默认的隔离级别为Repeatable_Read ，如Mysql。

 

Oracle数据库支持READ COMMITTED和SERIALIZABLE两种事务隔离性级别，不支持READ UNCOMMITTED和REPEATABLE READ这两种隔离性级别。虽然SQL标准定义的默认事务隔离性级别是SERIALIZABLE，但是Oracle数据库默认使用的事务隔离性级别却是READ COMMITTED.

4.2 Spring管理事务的方法

1）编程序事务管理

编写程序式的事务管理可以清楚的定义事务的边界，可以实现细粒度的事务控。比如可以通过程序代码来控制你的事务何时开始，何时结束等，与声明式事务管理相比，它可以实现细粒度的事务控制。

 

2）声明式事务管理

如果程序不需要细粒度的事务控制，则可以使用声明式事务，在Spring中，只需要在Spring配置文件中做一些配置，即可将操作纳入到事务管理中，解除了和代码的耦合， 这是对应用代码影响最小的选择，从这一点再次验证了Spring关于AOP的概念。当程序不需要事务管理的时候，可以直接从Spring配置文件中移除该设置。

4.3基于XML配置的申明式事务

步骤：

1.      在配置文件中引入用于声明事务的tx命名空间。

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

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

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

2.      配置数据源

3.      配置dao和service Bean

4.      配置事务管理器DataSourceTransactionManager并注入其依赖的数据源

5.      配置事务切入点(配置哪些方法需要事务tx:method)

6.      配置切面并加入增强点(aop:config,aop:advisor)

 

 

propagation的取值：

REQUIRED(常用)业务方法需要在一个事务中运行。如果方法运行时，已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务。

 

SUPPORTS(常用)       这一事务属性表明，如果业务方法在某个事务范围内被调用，则方法成为该事务的一部分。如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行。

 

NOT_SUPPORTED     声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。

 

REQUIRESNEW  属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务会被挂起，新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复执行。

 

MANDATORY     该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用，容器就会抛出例外。

 

Never     指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出例外，只有业务方法没有关联到任何事务，才能正常执行。

 

NESTED       如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按REQUIRED属性执行.它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效。

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

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

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

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

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

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

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

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

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

http://www.springframework.org/schema/context/spring-context-3.0.xsd

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

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

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

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

     

      <context:property-placeholder location="db.properties"/>

     

      <bean id="dataSource"class="org.apache.commons.dbcp.BasicDataSource">

          

<property name="driverClassName"value="${driverClassName}" />

           <property name="url"value="${url}" />

           <property name="username"value="${username}" />

           <property name="password"value="${password}" />

      bean>

     

      <bean id="accountDAO"class="com.maple.spring.dao.impl.AccoutDAOImpl">

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

      bean>

     

      <bean id="transferService"class="com.maple.spring.service.impl.TransferServiceImpl">

          

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

      bean>

     

      <bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

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

      bean>

     

      <tx:advice id="transferServiceAdvice"transaction-manager="transactionManager">

          

           <tx:attributes>

<tx:method name="saveMoney"propagation="REQUIRED"/>

<tx:method name="takeMoney"propagation="REQUIRED"/>

<tx:method name="transferMoney"propagation="REQUIRED"/>

<tx:method name="*"propagation="SUPPORTS"/>

           tx:attributes>

      tx:advice>

     

      <aop:config>

          

<aop:advisor advice-ref="transferServiceAdvice"pointcut="execution(*com.maple.spring.service.impl.TransferServiceImpl.*(..))"/>

      aop:config>

beans>

4.4基于注解配置的申明式事务

用到的注解：

@Transactional 该注解可以用于类或方法上，用于指明该类的所有方法或某个方法需要事务。

 

@Transactional//该类的所有方法都需要事务

publicclassTransferServiceImplAnno implements ITransferService {

      @Override

      publicvoid saveMoney(Stringname, Double money) {

           //先判断账户是否存在

           Accounta = accountDAO.get(name);

           if(a != null) {

                 a.setBalance(a.getBalance()+ money);

                 accountDAO.update(a.getId(),a);//更新账户的钱

           }else {

                 //否则新创建一个账户并将钱存进去

                 a= new Account(name, money);

                 accountDAO.save(a);

           }

      }

/**

       * 给方法添加额外的事务配置，在方法中配置的事务优先执行

       */

@Transactional(propagation=Propagation.SUPPORTS,readOnly=true)

      public AccountgetAccount(String name){

           returnaccountDao.get(name);

      }

}

配置文件：

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

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

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

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

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

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

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

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

 

     

      <import resource="beans-db.xml"/>

     

      <bean id="accountDAO"class="com.maple.spring.dao.impl.AccoutDAOImpl">

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

      bean>

     

      <bean id="transferService"class="com.maple.spring.service.impl.TransferServiceImplAnno">

          

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

      bean>

     

      <bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

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

      bean>

     

     

beans>