Spring学习第四天

Spring学习第四天

一、Spring 的 AOP 简介

1.1、 什么是 AOP

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

1.2 、AOP 的作用及其优势

• 作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强

• 优势：减少重复代码，提高开发效率，并且便于维护

1.3、 AOP 的底层实现

实际上，AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

1.4 、AOP 的动态代理技术

常用的动态代理技术

• JDK 代理 : 基于接口的动态代理技术

• cglib 代理：基于父类的动态代理技术

1.5 、JDK 的动态代理

①目标类接口

public interface TargetInterface {
    public void method();
}

②目标类

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

③动态代理代码

Target target = new Target(); //创建目标对象
//创建代理对象
TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(target.getClass()
.getClassLoader(),target.getClass().getInterfaces(),new InvocationHandler() {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) 
            throws Throwable {
        System.out.println("前置增强代码...");
        Object invoke = method.invoke(target, args);
        System.out.println("后置增强代码...");
        return invoke;
    }
}
);
//调用代理对象的方法测试
// 测试,当调用接口的任何方法时，代理对象的代码都无序修改
proxy.method();

1.6 、cglib 的动态代理

①目标类

public class Target {
    public void method() {
        System.out.println("Target running....");
    }
}

②动态代理代码

Target target = new Target(); //创建目标对象
Enhancer enhancer = new Enhancer();   //创建增强器
enhancer.setSuperclass(Target.class); //设置父类
enhancer.setCallback(new MethodInterceptor() { //设置回调
    @Override
    public Object intercept(Object o, Method method, Object[] objects, 
    MethodProxy methodProxy) throws Throwable {
        System.out.println("前置代码增强....");
        Object invoke = method.invoke(target, objects);
        System.out.println("后置代码增强....");
        return invoke;
    }
});
Target proxy = (Target) enhancer.create(); //创建代理对象
//测试,当调用接口的任何方法时，代理对象的代码都无序修改
proxy.method();

1.7 、AOP 相关概念

Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

在正式讲解 AOP 的操作之前，我们必须理解 AOP 的相关术语，常用的术语如下:

• Target（目标对象）：代理的目标对象

• Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类

• Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点

• Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义

• Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知

• Aspect（切面）：是切入点和通知（引介）的结合

• Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

1.8 、AOP 开发明确的事项

1**.** 需要编写的内容

• 编写核心业务代码（目标类的目标方法）

• 编写切面类，切面类中有通知(增强功能方法)

• 在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合

2. AOP 技术实现的内容

Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

3. AOP 底层使用哪种代理方式

在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

二、基于 XML 的 AOP 开发

2.1、 快速入门

①导入 AOP 相关坐标

<!--导入spring的context坐标，context依赖aop-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>
    <!-- aspectj的织入 -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>//其中aop更全面
    <version>1.8.13</version>
</dependency>

②创建目标接口和目标类（内部有切点）

public interface TargetInterface {
    public void method();
}

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

③创建切面类（内部有增强方法）

public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

④将目标类和切面类的对象创建权交给 spring

<!--配置目标类-->
    <bean id="target" class="com.itheima.aop.Target"></bean>
<!--配置切面类-->
    <bean id="myAspect" class="com.itheima.aop.MyAspect"></bean>

⑤在 applicationContext.xml 中配置织入关系

<aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
        <!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
        <aop:before method="before" pointcut="execution(public void com.itheima.aop.Target.method())"></aop:before>
    </aop:aspect>
</aop:config>

⑥测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}

2.2、 XML 配置 AOP 详解

1. 切点表达式的写法

表达式语法：

​ execution([修饰符] 返回值类型 包名.类名.方法名(参数))

• 访问修饰符可以省略

• 返回值类型、包名、类名、方法名可以使用星号* 代表任意

• 包名与类名之间一个点 . 代表当前包下的类，两个点 … 表示当前包及其子包下的类

• 参数列表可以使用两个点 … 表示任意个数，任意类型的参数列表

例如：

​ execution(public void com.itheima.aop.Target.method())

​ execution(void com.itheima.aop.Target.*(…))

​ execution(* com.itheima.aop..(…))

​ execution(* com.itheima.aop….(…))

​ execution(* ….*(…))

2. 通知的类型

通知的配置语法：

<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>

环绕通知演示

public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前增强....");
        Object proceed = pjp.proceed();//切点方法
        System.out.println("环绕后增强....");
        return proceed;
    }

3**.** 切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替 pointcut 属性来引用抽取后的切点表达式。

<aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
        <aop:pointcut id="myPointcut" expression="execution(* com.itheima.aop.*.*(..))"/>
     	<aop:before method="before" pointcut-ref="myPointcut"></aop:before>
     </aop:aspect>
</aop:config>

三、基于注解的 AOP 开发

3.1、 代码演示

@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("execution(* com.itheima.aop.*.*(..))")
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

在配置文件中开启组件扫描和 AOP 的自动代理

<!--组件扫描-->
    <context:component-scan base-package="com.itheima.aop"/>
<!--aop的自动代理-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

3.2 注解配置 AOP 详解

1**.** 注解通知的类型

通知的配置语法：@通知注解(“切点表达式")

2. 切点表达式的抽取

@@Component("myAspect")
@Aspectpublic class MyAspect {
    @Before("MyAspect.myPoint()")
    public void before(){
        System.out.println("前置代码增强.....");
    }
    @Pointcut("execution(* com.itheima.aop.*.*(..))")
    public void myPoint(){}
}

四、声明式事务控制

4.1、编程式事务控制相关对象

1.1 PlatformTransactionManager

PlatformTransactionManager 接口是 spring 的事务管理器，它里面提供了我们常用的操作事务的方法。

注意：

PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类，例如：Dao 层技术是jdbc 或 mybatis 时：org.springframework.jdbc.datasource.DataSourceTransactionManager

Dao 层技术是hibernate时：org.springframework.orm.hibernate5.HibernateTransactionManager

1.2 TransactionDefinition

TransactionDefinition 是事务的定义信息对象，里面有如下方法：

1.事务隔离级别

设置隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读。

• ISOLATION_DEFAULT //默认为可重复读

• ISOLATION_READ_UNCOMMITTED //读未提交，脏读

• ISOLATION_READ_COMMITTED //导致不可重复读

• ISOLATION_REPEATABLE_READ //解决了脏读和不可重复读的问题，但是会产生幻读

• ISOLATION_SERIALIZABLE //串行化 串行化读，事务只能一个一个执行，避免了 脏读、不可重复读、幻读。执行效率慢，使用时慎重

2. 事务传播行为

• REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）

• SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）

• MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常

• REQUERS_NEW：新建事务，如果当前在事务中，把当前事务挂起。

• NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起

• NEVER：以非事务方式运行，如果当前存在事务，抛出异常

• NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 REQUIRED 类似的操作

• 超时时间：默认值是-1，没有超时限制。如果有，以秒为单位进行设置

• 是否只读：建议查询时设置为只读

1.3 TransactionStatus

TransactionStatus 接口提供的是事务具体的运行状态，方法介绍如下。

4.2、基于 XML 的声明式事务控制

1.1、什么是声明式事务控制

Spring 的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明，就是指在配置文件中声明，用在 Spring 配置文件中声明式的处理事务来代替代码式的处理事务。

声明式事务处理的作用

• 事务管理不侵入开发的组件。具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可

• 在不需要事务管理的时候，只要在设定文件上修改一下，即可移去事务管理服务，无需改变代码重新编译，这样维护起来极其方便

注意：Spring 声明式事务控制底层就是AOP。

1.2 声明式事务控制的实现

①引入tx命名空间

<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"       xmlns:aop="http://www.springframework.org/schema/aop"       xmlns:tx="http://www.springframework.org/schema/tx"       xsi:schemaLocation="        http://www.springframework.org/schema/context        http://www.springframework.org/schema/context/spring-context.xsd        http://www.springframework.org/schema/aop        http://www.springframework.org/schema/aop/spring-aop.xsd        http://www.springframework.org/schema/tx         http://www.springframework.org/schema/tx/spring-tx.xsd        http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd">

②配置事务增强

<!--平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
<!--事务增强配置-->
        <tx:advice id="txAdvice" transaction-manager="transactionManager">
            <tx:attributes>
                <tx:method name="*"/>
            </tx:attributes>
        </tx:advice>

③配置事务 AOP 织入

<aop:config>
        <aop:pointcut id="txPointcut" expression="execution(* com.itheima.service.impl.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    </aop:config>

④测试事务控制转账业务代码

@Override
public void transfer(String outMan, String inMan, double money) {
    accountDao.out(outMan,money);
    int i = 1/0;
    accountDao.in(inMan,money);
}

4.3、基于注解的声明式事务控制

1. 编写 AccoutDao

   @Repository("accountDao")
   public class AccountDaoImpl implements AccountDao {
       @Autowired
       private JdbcTemplate jdbcTemplate;
       public void out(String outMan, double money) {
           jdbcTemplate.update("update account set money=money-? where name=?",money,outMan);
       }
       public void in(String inMan, double money) {
           jdbcTemplate.update("update account set money=money+? where name=?",money,inMan);
       }
   }
   

2. 编写AccountService

   @Service("accountService")
   @Transactional
   public class AccountServiceImpl implements AccountService {
   @Autowired
   private AccountDao accountDao;
   @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRED)
   public void transfer(String outMan, String inMan, double money) {
   accountDao.out(outMan,money);
   int i = 1/0;
   accountDao.in(inMan,money);
   }
   }
   
   

3. 编写 applicationContext.xml 配置文件

   <!—之前省略datsSource、jdbcTemplate、平台事务管理器的配置-->
   <!--组件扫描-->
       <context:component-scan base-package="com.itheima"/>
   <!--事务的注解驱动-->
   <tx:annotation-driven/>