第6章 springMVC

Mr.Tong...

spring

spring

大约 19 分钟

📖1. AOP简介

✅什么是AOP

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

我们都知道OOP是一种编程思想，那么AOP也是一种编程思想，编程思想主要的内容就是指导程序员该如何编写程序，所以它们两个是不同的编程范式。

✅AOP作用

在不惊动原始设计的基础上为其进行功能增强，白话就是对一个类的方法在不进行任何修改的前提下实现增强。

📖2. AOP核心概念

连接点(JoinPoint)：是程序执行过程中的任意位置、执行方法、抛出异常、设置变量等，在SpringAOP中，理解为方法的执行。
切入点(Pointcut)：匹配连接点的式子，在SpringAOP中，一个切入点可以描述一个具体方法，也可也匹配多个方法。
- 切入点的方法一定是连接点，但是是连接点的方法就不一定要被增强，所以可能不是切入点。
通知(Advice)：通知表示切面的执行时间，是在目标方法执行之前执行，还是之后执行等。
切面(Aspect)：描述通知与切入点的对应关系。
通知类：定义通知的类

AOP中重要的三个要素：Aspect、Pointcut、Advice。意思是说：在Advice的时间、在Pointcut的位置，执行Aspect。

设计的注解有：

名称	作用	属性
@EnableAspectJAutoProxy	开启注解格式AOP功能
@Aspect	设置当前类为AOP切面类
@Pointcut	设置切入点方法	value（默认）：切入点表达式
@Before	设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行
@After	当前通知方法在原始切入点方法后运行
@Around	追加功能到方法执行的前后
@AfterReturning	追加功能到方法执行后，只有方法正常执行结束后才进行，异常则不执行
@AfterThrowing	追加功能到方法抛出异常后，只有方法执行出异常才进行

✅AOP切入点表达式

如下图定义了两个切入点，表示匹配要要增强的方法的具体位置，所以简单理解切入点和切入表达式的区别：

切入点：要增强的方法
切入点表达式：描述并匹配要增强的方法的表达式，可以是具体的当个方法，也可以是多个方法。

1630155937718

对于切入点的描述，我们其实是有两种方式的，先来看下前面的例子

1630156172790

描述方式一：执行com.itheima.dao包下的BookDao接口中的无参数update方法

execution(void com.itheima.dao.BookDao.update())

描述方式二：执行com.itheima.dao.impl包下的BookDaoImpl类中的无参数update方法

execution(void com.itheima.dao.impl.BookDaoImpl.update())

因为调用接口方法的时候最终运行的还是其实现类的方法，所以上面两种描述方式都是可以的。

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

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

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

✅ AOP通知类型

前面说通知表示切面的执行时间，是在目标方法执行之前执行，还是之后执行等，spring aop共提供了5种通知类型:

通知类型	注解	作用
前置通知	@Before	追加功能到方法执行前。
后置通知	@After	追加功能到方法执行后,不管方法执行的过程中有没有抛出异常都会执行。
环绕通知(重点)	@Around	追加功能到方法执行的前后，它可以实现其他四种通知类型的功能。
返回后通知(了解)	@AfterReturning	追加功能到方法执行后，只有方法正常执行结束后才进行，异常则不执行。
抛出异常后通知(了解)	@AfterThrowing	追加功能到方法抛出异常后，只有方法执行出异常才进行。

✅AOP通知获取数据

我们将从获取参数、获取返回值和获取异常三个方面来研究切入点的相关信息。

所有的通知类型都可以获取切入点方法参数
- JoinPoint：适用于前置、后置、返回后、抛出异常后通知
- ProceedingJoinPoint：适用于环绕通知
获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无，所以不做研究
- 返回后通知
- 环绕通知
获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无，所以不做研究
- 抛出异常后通知
- 环绕通知

非环绕通知获取方式：

在方法上添加JoinPoint,通过JoinPoint来获取参数,使用JoinPoint的方式获取参数适用于前置、后置、返回后、抛出异常后通知。

@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 ..." );
    }
	//...其他的略
}

运行App类，可以获取如下内容，说明参数100已经被获取

1630233291929

环绕通知获取方式:

环绕通知使用的是ProceedingJoinPoint，因为ProceedingJoinPoint是JoinPoint类的子类，所以对于ProceedingJoinPoint类中应该也会有对应的getArgs()方法，我们去验证下:

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

    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp)throws Throwable {
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        Object ret = pjp.proceed();
        return ret;
    }
	//其他的略
}

运行App后查看运行结果，说明ProceedingJoinPoint也是可以通过getArgs()获取参数

1630233974310

注意:

pjp.proceed()方法是有两个构造方法，分别是:

1630234756123

调用无参数的proceed，当原始方法有参数，会在调用的过程中自动传入参数
所以调用这两个方法的任意一个都可以完成功能

但是当需要修改原始方法的参数时，就只能采用带有参数的方法,如下:

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

    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        args[0] = 666;
        Object ret = pjp.proceed(args);
        return ret;
    }
	//其他的略
}

有了这个特性后，我们就可以在环绕通知中对原始方法的参数进行拦截过滤，避免由于参数的问题导致程序无法正确运行，保证代码的健壮性。

✅通配符

我们使用通配符描述切入点，主要的目的就是简化之前的配置，具体都有哪些通配符可以使用?

通配符	作用
*	单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
..	多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
+	专用于匹配子类类型

+这个使用率较低，描述子类的，咱们做JavaEE开发，继承机会就一次，使用都很慎重，所以很少用它。*Service+，表示所有以Service结尾的接口的子类。

通配符使用案例如下：

execution(void com.itheima.dao.BookDao.update())
匹配接口，能匹配到
execution(void com.itheima.dao.impl.BookDaoImpl.update())
匹配实现类，能匹配到
execution(* com.itheima.dao.impl.BookDaoImpl.update())
返回值任意，能匹配到
execution(* com.itheima.dao.impl.BookDaoImpl.update(*))
返回值任意，但是update方法必须要有一个参数，无法匹配，要想匹配需要在update接口和实现类添加参数
execution(void com.*.*.*.*.update())
返回值为void,com包下的任意包三层包下的任意类的update方法，匹配到的是实现类，能匹配
execution(void com.*.*.*.update())
返回值为void,com包下的任意两层包下的任意类的update方法，匹配到的是接口，能匹配
execution(void *..update())
返回值为void，方法名是update的任意包下的任意类，能匹配
execution(* *..*(..))
匹配项目中任意类的任意方法，能匹配，但是不建议使用这种方式，影响范围广
execution(* *..u*(..))
匹配项目中任意包任意类下只要以u开头的方法，update方法能满足，能匹配
execution(* *..*e(..))
匹配项目中任意包任意类下只要以e结尾的方法，update和save方法能满足，能匹配
execution(void com..*())
返回值为void，com包下的任意包任意类任意方法，能匹配，*代表的是方法
execution(* com.itheima.*.*Service.find*(..))
将项目中所有业务层方法的以find开头的方法匹配
execution(* com.itheima.*.*Service.save*(..))
将项目中所有业务层方法的以save开头的方法匹配

✅书写技巧

对于切入点表达式的编写其实是很灵活的，那么在编写的时候，有没有什么好的技巧让我们用用:

所有代码按照标准规范开发，否则以下技巧全部失效
描述切入点通**常描述接口**，而不描述实现类,如果描述到实现类，就出现紧耦合了
访问控制修饰符针对接口开发均采用public描述（可省略访问控制修饰符描述）
返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用*通配快速描述
包名书写尽量不使用..匹配，效率过低，常用*做单个包描述匹配，或精准匹配
接口名/类名书写名称与模块相关的采用*匹配，例如UserService书写成*Service，绑定业务层接口名
方法名书写以动词进行精准匹配，名词采用匹配，例如getById书写成getBy,selectAll书写成selectAll
参数规则较为复杂，根据业务方法灵活调整
通常**不使用异常作为匹配**规则

📖3. AOP入门案例

主要步骤：

1.导入坐标(pom.xml)

2.制作连接点(原始操作，Dao接口与实现类)

3.制作共性功能(通知类与通知)

4.定义切入点

5.绑定切入点与通知关系(切面)

✅步骤1:导入依赖

创建一个Maven项目,pom.xml添加Spring依赖

<dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.4</version>
    </dependency>
  </dependencies>

spring-context中已经导入了spring-aop,所以不需要再单独导入spring-aop，之所以导入AspectJ的jar包,因为AspectJ是AOP思想的一个具体实现，Spring有自己的AOP实现，但是相比于AspectJ来说比较麻烦，所以我们直接采用Spring整合ApsectJ的方式进行AOP开发。

✅步骤2:定义接口与实现类

比如在com.itheima.dao.impl包下创建了BookDao接口和BookDaoImpl实现类

public interface BookDao {
    
    public void update();

    public void delete();

    public void select();
}

@Repository
public class BookDaoImpl implements BookDao {

    public void update(){
        System.out.println("book dao update ...");
    }

    public void delete(){
        System.out.println("book dao delete ...");
    }

    public void select(){
        System.out.println("book dao select ...");
    }
}

✅步骤3:定义通知类和通知

通知就是将共性功能抽取出来后形成的方法，共性功能指的就是当前系统时间的打印。

public class MyAdvice {
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

类名和方法名没有要求，可以任意。

✅步骤4:定义切入点

比如要BookDaoImpl中update，定义一个叫updatePt切入点来匹配update方法

public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update(..))")
    private void updatePt(){}
    public void around(){
       
    }
}

**说明:**切入点定义依托一个不具有实际意义的方法进行，即无参数、无返回值、方法体无实际逻辑。

✅步骤5:制作切面

切面是用来描述通知和切入点之间的关系，将updatePt切点方法进行增强功能，打印执行万次update的消耗时间

public class MyAdvice {

    @Pointcut("execution(* com.itheima.dao.BookDao.update(..))")
    private void updatePt(){}

    @Around("updatePt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Signature signature = pjp.getSignature();
        String className = signature.getDeclaringTypeName();
        String methodName = signature.getName();

        System.out.println("------------------------------");
        long startTime = System.currentTimeMillis();
        for (int i = 0 ; i<10000 ; i++) {
            //调用原始操作
            pjp.proceed();
        }
        long endTime = System.currentTimeMillis();
        long totalTime = endTime-startTime;
        System.out.println(className+"."+methodName+"-->执行万次消耗时间：" + totalTime + "ms");
        return null;
    }

}

✅步骤6:将通知类定义为切面类

@Component将这个通知类注入到spring容器中，@Aspect注解标注为切面类

@Component
@Aspect
public class MyAdvice {

    @Pointcut("execution(* com.itheima.dao.BookDao.update(..))")
    private void updatePt(){}

    @Around("updatePt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Signature signature = pjp.getSignature();
        String className = signature.getDeclaringTypeName();
        String methodName = signature.getName();

        System.out.println("------------------------------");
        long startTime = System.currentTimeMillis();
        for (int i = 0 ; i<10000 ; i++) {
            //调用原始操作
            pjp.proceed();
        }
        long endTime = System.currentTimeMillis();
        long totalTime = endTime-startTime;
        System.out.println(className+"."+methodName+"-->执行万次消耗时间：" + totalTime + "ms");
        return null;
    }

}

✅步骤7:注解开启AOP功能

在spring配置文件中使用@EnableAspectJAutoProxy注解来开启注解格式AOP功能

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

✅步骤8:运行程序

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }
}

📖4. 百度网盘密码数据兼容处理

4.1 需求分析

需求: 对百度网盘分享链接输入密码时尾部多输入的空格做兼容处理。

1630240203033

问题描述:

点击链接，会提示，请输入提取码，如下图所示
当我们从别人发给我们的内容中复制提取码的时候，有时候会多复制到一些空格，直接粘贴到百度的提取码输入框
但是百度那边记录的提取码是没有空格的
这个时候如果不做处理，直接对比的话，就会引发提取码不一致，导致无法访问百度盘上的内容
所以多输入一个空格可能会导致项目的功能无法正常使用。
此时我们就想能不能将输入的参数先帮用户去掉空格再操作呢?

答案是可以的，我们只需要在业务方法执行之前对所有的输入参数进行格式处理——trim()

是对所有的参数都需要去除空格么?

也没有必要，一般只需要针对字符串处理即可。

以后涉及到需要去除前后空格的业务可能会有很多，这个去空格的代码是每个业务都写么?

可以考虑使用AOP来统一处理。

AOP有五种通知类型，该使用哪种呢?

我们的需求是将原始方法的参数处理后在参与原始方法的调用，能做这件事的就只有环绕通知。

综上所述，我们需要考虑两件事: ①：在业务方法执行之前对所有的输入参数进行格式处理——trim() ②：使用处理后的参数调用原始方法——环绕通知中存在对原始方法的调用

4.2 环境准备

创建一个Maven项目

pom.xml添加Spring依赖

<dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.4</version>
    </dependency>
  </dependencies>

添加ResourcesService，ResourcesServiceImpl,ResourcesDao和ResourcesDaoImpl类

public interface ResourcesDao {
    boolean readResources(String url, String password);
}
@Repository
public class ResourcesDaoImpl implements ResourcesDao {
    public boolean readResources(String url, String password) {
        //模拟校验
        return password.equals("root");
    }
}
public interface ResourcesService {
    public boolean openURL(String url ,String password);
}
@Service
public class ResourcesServiceImpl implements ResourcesService {
    @Autowired
    private ResourcesDao resourcesDao;

    public boolean openURL(String url, String password) {
        return resourcesDao.readResources(url,password);
    }
}

创建Spring的配置类

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

编写App运行类

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
        boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root");
        System.out.println(flag);
    }
}

最终创建好的项目结构如下:

1630241681697

现在项目的效果是，当输入密码为"root"控制台打印为true,如果密码改为"root "控制台打印的是false

需求是使用AOP将参数进行统一处理，不管输入的密码root前后包含多少个空格，最终控制台打印的都是true。

4.3 具体实现

步骤1:开启SpringAOP的注解功能

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

步骤2:编写通知类

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

步骤3:添加环绕通知

@Component
@Aspect
public class DataAdvice {
    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}
    
    @Around("DataAdvice.servicePt()")
    // @Around("servicePt()")这两种写法都对
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object ret = pjp.proceed();
        return ret;
    }
    
}

步骤4:完成核心业务，处理参数中的空格

@Component
@Aspect
public class DataAdvice {
    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}
    
    @Around("DataAdvice.servicePt()")
    // @Around("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;
    }
    
}

步骤5:运行程序

不管密码root前后是否加空格，最终控制台打印的都是true

步骤6:优化测试

为了能更好的看出AOP已经生效，我们可以修改ResourcesImpl类，在方法中将密码的长度进行打印

@Repository
public class ResourcesDaoImpl implements ResourcesDao {
    public boolean readResources(String url, String password) {
        System.out.println(password.length());
        //模拟校验
        return password.equals("root");
    }
}

再次运行成功，就可以根据最终打印的长度来看看，字符串的空格有没有被去除掉。

注意：

1630242491831

📖5. AOP工作流程

由于AOP是基于Spring容器管理的bean做的增强，所以整个工作过程需要从Spring加载bean说起:

✅流程1:Spring容器启动

容器启动就需要去加载bean,哪些类需要被加载呢?
需要被增强的类，如:BookServiceImpl
通知类，如:MyAdvice
注意此时bean对象还没有创建成功

✅流程2:读取所有切面配置中的切入点

1630151682428

上面这个例子中有两个切入点的配置，但是第一个ptx()并没有被使用，所以不会被读取。

✅流程3:初始化bean，

判定bean对应的类中的方法是否匹配到任意切入点

注意第1步在容器启动的时候，bean对象还没有被创建成功。
要被实例化bean对象的类中的方法和切入点进行匹配

1630152538083

匹配失败，创建原始对象,如UserDao
- 匹配失败说明不需要增强，直接调用原始对象的方法即可。
匹配成功，创建原始对象（目标对象）的代理对象,如:BookDao
- 匹配成功说明需要对其进行增强
- 对哪个类做增强，这个类对应的对象就叫做目标对象
- 因为要对目标对象进行功能增强，而采用的技术是动态代理，所以会为其创建一个代理对象
- 最终运行的是代理对象的方法，在该方法中会对原始方法进行功能增强

✅流程4:获取bean执行方法

获取的bean是原始对象时，调用方法并执行，完成操作
获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

📖6. AOP工作原理

动态代理

📖7. AOP总结

✅AOP的核心概念

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

✅ 切入点表达式

切入点表达式标准格式：动作关键字(访问修饰符返回值包名.类/接口名.方法名（参数）异常名)
```
execution(* com.itheima.service.*Service.*(..))
```
切入点表达式描述通配符：
- 作用：用于快速描述，范围描述
- *：匹配任意符号（常用）
- .. ：匹配多个连续的任意符号（常用）
- +：匹配子类类型
切入点表达式书写技巧
1.按标准规范开发 2.查询操作的返回值建议使用*匹配 3.减少使用..的形式描述包 4.对接口进行描述，使用*表示模块名，例如UserService的匹配描述为*Service 5.方法名书写保留动词，例如get，使用*表示名词，例如getById匹配描述为getBy* 6.参数根据实际情况灵活调整

✅ 五种通知类型

前置通知
后置通知
环绕通知（重点）
- 环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用
- 环绕通知可以隔离原始方法的调用执行
- 环绕通知返回值设置为Object类型
- 环绕通知中可以对原始方法调用过程中出现的异常进行处理
返回后通知
抛出异常后通知

✅ 通知中获取参数

获取切入点方法的参数，所有的通知类型都可以获取参数
- JoinPoint：适用于前置、后置、返回后、抛出异常后通知
- ProceedingJoinPoint：适用于环绕通知
获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无，所以不做研究
- 返回后通知
- 环绕通知
获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无，所以不做研究
- 抛出异常后通知
- 环绕通知

你认为这篇文章怎么样？

昵称

邮箱

网址

按正序
按倒序
按热度

第6章 springMVC

# 📖1. AOP简介

# ✅什么是AOP

# ✅AOP作用

# 📖2. AOP核心概念

# ✅AOP切入点表达式

# ✅ AOP通知类型

# ✅AOP通知获取数据

# ✅通配符

# ✅书写技巧

# 📖3. AOP入门案例

# ✅步骤1:导入依赖

# ✅步骤2:定义接口与实现类

# ✅步骤3:定义通知类和通知

# ✅步骤4:定义切入点

# ✅步骤5:制作切面

# ✅步骤6:将通知类定义为切面类

# ✅步骤7:注解开启AOP功能

# ✅步骤8:运行程序

# 📖4. 百度网盘密码数据兼容处理

# 4.1 需求分析

# 4.2 环境准备

# 4.3 具体实现

# 步骤1:开启SpringAOP的注解功能

# 步骤2:编写通知类

# 步骤3:添加环绕通知

# 步骤4:完成核心业务，处理参数中的空格

# 步骤5:运行程序

# 步骤6:优化测试

# 📖5. AOP工作流程

# ✅流程1:Spring容器启动

# ✅流程2:读取所有切面配置中的切入点

# ✅流程3:初始化bean，

# ✅流程4:获取bean执行方法

# 📖6. AOP工作原理

# 📖7. AOP总结

# ✅AOP的核心概念

# ✅ 切入点表达式

# ✅ 五种通知类型

# ✅ 通知中获取参数