spring03-黑马-笔记

spring

1、AOP简介

核心概念

AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程
序结构。

作用:在不惊动原始设计的基础上为其进行功能增强，前面咱们有技术就可以实现这样的功能即代
理模式。

入门案例

案例设定：测算接口执行效率，但是这个案例稍微复杂了点，我们对其进行简化。
简化设定：在方法执行前输出当前系统时间。
思路：
1.导入坐标(pom.xml)
2.制作连接点(原始操作，Dao接口与实现类)
3.制作共性功能(通知类与通知)
4.定义切入点
5.绑定切入点与通知关系(切面)

	<dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>

• 定义通知类和通知
• 定义切入点
• 制作切面
• 将通知类配给容器并标识其为切面类

package com.itheima.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAdvice {

    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){

    }

    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

开启注解格式AOP功能

package com.itheima.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}

AOP工作流程

• 流程1:Spring容器启动
• 流程2:读取所有切面配置中的切入点
• 流程3:初始化bean，
  获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作
• 流程4:获取bean执行方法
  获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作
  

AOP核心概念

• 目标对象(Target)：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的
• 代理(Proxy)：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现

2.AOP配置管理

AOP切入点表达式

切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）

execution(public User com.itheima.service.UserService.1 findById(int))

• execution：动作关键字，描述切入点的行为动作，例如execution表示执行到指定切入点
• public:访问修饰符,还可以是public，private等，可以省略
• User：返回值，写返回值类型
• com.itheima.service：包名，多级包使用点连接
• UserService:类/接口名称
• findById：方法名
• int:参数，直接写参数的类型，多个类型用逗号隔开
• 异常名：方法定义中抛出指定异常，可以省略

通配符

AOP通知类型

共提供了5种通知类型:

• 前置通知
• 后置通知
• 环绕通知(重点)
• 返回后通知(了解)
• 抛出异常后通知(了解)

(1)前置通知，追加功能到方法执行前,类似于在代码1或者代码2添加内容
(2)后置通知,追加功能到方法执行后,不管方法执行的过程中有没有抛出异常都会执行，类似于在代
码5添加内容
(3)返回后通知,追加功能到方法执行后，只有方法正常执行结束后才进行,类似于在代码3添加内容，
如果方法执行抛出异常，返回后通知将不会被添加
(4)抛出异常后通知,追加功能到方法抛出异常后，只有方法执行出异常才进行,类似于在代码4添加内
容，只有方法抛出异常后才会被添加
(5)环绕通知,环绕通知功能比较强大，它可以追加功能到方法执行的前后，这也是比较常用的方式，
它可以实现其他四种通知类型的功能，具体是如何实现的，需要我们往下学习。

package com.itheima.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAdvice {

    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    @Pointcut("execution(int com.itheima.dao.BookDao.select())")
    private void pt2(){}

   // @Before("pt()")
    public void before(){
        System.out.println("before advice ...");
    }

   // @After("pt()")
    public void after(){
        System.out.println("after advice ...");
    }

    //@Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around before advice ...");
        //表示对原始操作的调用
        Object ret = pjp.proceed();
        System.out.println("around after advice ...");
        return ret;
    }

   // @Around("pt2()")
    public Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around before advice ...");
        //表示对原始操作的调用
//        Object ret = pjp.proceed();
        Integer ret = (Integer) pjp.proceed();
        System.out.println("around after advice ...");
        return ret + 666;
    }

    @AfterReturning("pt2()")
    public void afterReturning(){
        System.out.println("afterReturning advice ...");
    }

    @AfterThrowing("pt2()")
    public void afterThrowing(){
        System.out.println("afterThrowing advice ...");
    }
}

业务层接口执行效率

package com.itheima.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class ProjectAdvice {

    //匹配任务层的所有方法
    @Pointcut("execution(* com.itheima.service..*Service.*(..))")
    private  void servicePt(){}


    @Around("ProjectAdvice.servicePt()")
    public void runSeed(ProceedingJoinPoint pjp) throws Throwable {
       Signature signature = pjp.getSignature();
//        System.out.println(signature.getDeclaringType());
//        System.out.println(signature.getName());
        String className = signature.getDeclaringTypeName();
        String methodName = signature.getName();

        Long  start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            pjp.proceed();
        }
        Long end = System.currentTimeMillis();
        System.out.println("万次执行时间: "+ className + "." + methodName +  "=====>" + (end-start) + "ms");
    }
}

AOP通知获取数据

获取参数、获取返回值和获取异常三个方面

package com.itheima.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.itheima.dao.Bookdao.findName(..))")
    private void pt(){}


//    @Before("pt()")
    public void before(JoinPoint jp) {
        //获取参数
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("before advice ..." );
    }
//    @After("pt()")
    public void after(JoinPoint jp) {
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("after advice ...");
    }
//    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) {
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        args[0] = 666;
        Object ret = null;
        try {
            ret = pjp.proceed(args);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return ret;
    }
//    @AfterReturning(value = "pt()", returning = "ret")
    public void afterReturning(JoinPoint jp, Object ret) {
        //获取返回值
        System.out.println("afterReturning advice ..." + ret);
    }
    @AfterThrowing(value = "pt()", throwing = "t")
    public void afterThrowing(Throwable t) {
        System.out.println("afterThrowing advice ..."+t);
    }
}

案例

package com.itheima.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class DataAdvice {
    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}

    @Around("DataAdvice.servicePt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            //判断参数是不是字符串
            if (args[i].getClass().equals(String.class)){
                args[i] = args[i].toString().trim();
            }
        }
        Object ret = pjp.proceed(args);
        return ret;
    }
}

概念：AOP(Aspect Oriented Programming)面向切面编程，一种编程范式
作用：在不惊动原始设计的基础上为方法进行功能增强
核心概念
代理（Proxy）：SpringAOP的核心本质是采用代理模式实现的
连接点（JoinPoint）：在SpringAOP中，理解为任意方法的执行
切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法
切面（Aspect）：描述通知与切入点的对应关系
目标对象（Target）：被代理的原始对象成为目标对象

3.AOP事务管理

 @Transactional
    public void transfer(String out, String in, Double money);

@Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }

@EnableTransactionManagement
public class SpringConfig {
}

事务的传播行为

package com.itheima.service;

import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

public interface LogService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out, String in, Double money);
}

package com.itheima.service.impl;

import com.itheima.dao.LogDao;
import com.itheima.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
    @Override
    public void log(String out, String in, Double money) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}