spring学习笔记3

最新推荐文章于 2024-09-11 14:42:29 发布

想要入门的程序猿

最新推荐文章于 2024-09-11 14:42:29 发布

阅读量56

点赞数

文章标签：学习 java spring

本文链接：https://blog.csdn.net/m0_74224591/article/details/133898330

版权

1 AOP

AOP(Aspect Oriented Programming),即面向切面编程.

OOP(Object Oriented Programming ),即面向对象编程.

AOP面向切面编程,利用一种称为"横切"的技术，剖开封装的对象内部，并将那些影响了 多个类的公共行为抽取出封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性

面向切面编程的作用:就是将项目中与核心逻辑无关的代码横向抽取成切面类,通过织入作用到目标方法,以使目标方法执行前后达到增强的效果.

好处:减少系统的重复代码，降低模块之间的耦合度,便于维护,可以只关注核心业务

1.2 AOP术语
连接点(Joinpoint)：连接点是程序类中客观存在的方法，可被Spring拦截并切入内容。即每个方法在切入之前,都是连接点

切入点(Pointcut)：被Spring切入连接点。即真正会增强的目标方法

通知、增强(Advice)：可以为切入点添加额外功能，分为：前置通知、后置通知、异常通知、环绕通知等。

目标对象(Target)：被代理的目标对象

织入(Weaving)：把通知应用到具体的类，进而创建新的代理类的过程。

代理(Proxy)：被AOP织入通知后，产生的结代理类。

切面(Aspect)：由切点和通知组成，将横切逻辑织入切面所指定的连接点中

1.3 应用场景

事务管理
后续spring管理事务用的AOP原理
权限校验
后期使用Spring Security注解开发时,其实利用了AOP思想
日志记录
性能检测
等等

1.4 AOP入门编程【重点】

需求: UserService以及UserServiceImpl,在其中方法执行前,后执行增强的方法

编程的过程:

创建项目
导入依赖
核心依赖
切面依赖

目标类
切面类
织入(配置文件设置)
测试

1.4.1导入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.6.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.1.6.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

1.4.2 目标类

public interface UserService {

    void findUserById();

    void deleteUserById();

}

public class UserServiceImpl implements UserService {

    @Override
    public void findUserById() {

        System.out.println("核心业务---> 查询用户" );

    }
    @Override
    public void deleteUserById() {

        System.out.println("核心业务---> 删除用户" );

    }
}

1.4.3 切面类

演示的环绕通知

public class MyAspect {

    /**
     * 定义增强的方法:如果前后都要增强的方法
     * 那么就还使用环绕通知/增强
     */
    /**
     * 自定义环绕通知
     * @param joinPoint 连接点/切入点,即目标方法
     * @return 目标方法的返回值
     */
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 目标方法前:
        System.out.println("开启事务/权限校验" );

        // 目标方法执行
        Object ret = joinPoint.proceed( );
        System.out.println("目标方法返回值---> " + ret );
        // 目标方法后:
        System.out.println("提交事务/日志记录" );
        return ret;
    }

}

1.4.4 配置(织入)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 目标类,UserService -->
    <bean id="userService" class="com.qf.service.impl.UserServiceImpl"/>

    <!-- 切面类 -->
    <bean id="myAspect" class="com.qf.aspect.MyAspect"/>

    <!-- 织入 -->
    <aop:config>
        <!-- 确定切面-->
        <aop:aspect ref="myAspect">
            <!-- 1确定通知/增强类型 -->
            <!-- 2确定切面中增强的方法 -->
            <!-- 3确定目标类以及目标方法
               execution(返回值类型 包路径.类名.方法名(参数))
               返回值类型任意,写 *
               包路径,写com.qf
               类名,UserServiceImpl,如果是所有类,写 *
               方法名,findUserById,如果是所有方法,写 *
               () 参数列表
               (..) 代表任意参数
            -->
            <aop:around method="myAround"
                        pointcut="execution(* com.qf.service.impl.*.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

1.4.5 测试

    @Test
    public void testAspect() {
        String path = "applicationContext.xml";
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(path);

        UserService userService = context.getBean("userService", UserService.class);
        userService.findUserById();

        System.out.println("-----------------" );

        userService.deleteUserById();
    }

开启事务/权限校验
核心业务---> 查询用户
目标方法返回值---> null
提交事务/日志记录
-----------------
开启事务/权限校验
核心业务---> 删除用户
目标方法返回值---> null
提交事务/日志记录

1.5 其他增强【重点】

package com.qf.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;


public class MyAspect {

    /**
     * 定义增强的方法:如果前后都要增强的方法
     * 那么就还使用环绕通知/增强
     */

    /**
     * 自定义环绕通知
     * @param joinPoint 连接点/切入点,即目标方法
     * @return 目标方法的返回值
     */
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 目标方法前:
        System.out.println("开启事务/权限校验" );

        // 目标方法执行
        Object ret = joinPoint.proceed( );
        System.out.println("目标方法返回值---> " + ret );
        // 目标方法后:
        System.out.println("提交事务/日志记录" );
        return ret;
    }


    /**
     * 自定义前置通知
     * @param joinPoint,目标对象
     */
    public void myBefore(JoinPoint joinPoint) {
        // 目标对象
        Object target = joinPoint.getTarget( );
        System.out.println("target = " + target);
        // 获得目标方法签名(方法名)
        Signature signature = joinPoint.getSignature( );
        System.out.println("signature = " + signature);

        System.out.println("前置通知--->权限校验--->OK" );

        // 假设权限校验没有通过,通过抛出异常让代码停下,不再执行目标方法
        // System.out.println("前置通知--->权限校验--->ERROR" );
        // throw new RuntimeException("权限校验--->ERROR");
    }


    /**
     * 自定义后置通知
     */
    public void myAfter() {
        System.out.println("后置通知--->记录日志,释放资源" );
    }

    /**
     * 自定义后置返回通知
     * @param ret 用于接收目标方法返回的数据
     * @return
     */
    public Object myAfterRet(Object ret) {
        System.out.println("后置返回通知,接收到目标方法返回值--->" + ret);
        // 可以对返回的数据进行处理
        if (ret instanceof Integer) {
            Integer value = (Integer) ret;
            value *= 3;
            // 【BUG,返回值没有返回给目标方法】
            return value;
        }
        return ret;
    }

    public void myException(Exception e) {
        System.out.println("目标方法报的错---> " + e.getMessage());
    }
}

1.5.2 配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 目标类,UserService -->
    <bean id="userService" class="com.qf.service.impl.UserServiceImpl"/>
    <bean id="houseService" class="com.qf.service.impl.HouseServiceImpl"/>


    <!-- 切面类 -->
    <bean id="myAspect" class="com.qf.aspect.MyAspect"/>

    <!-- 织入 -->
    <aop:config>
        <!-- 确定切面-->
        <aop:aspect ref="myAspect">
            <!-- 1确定通知/增强类型 -->
            <!-- 2确定切面中增强的方法 -->
            <!-- 3确定目标类以及目标方法
               execution(返回值类型 包路径.类名.方法名(参数))
               返回值类型任意,写 *
               包路径,写com.qf
               类名,UserServiceImpl,如果是所有类,写 *
               方法名,findUserById,如果是所有方法,写 *
               () 参数列表
               (..) 代表任意参数
            -->
            <!--<aop:around method="myAround"
                        pointcut="execution(* com.qf.service.impl.*.*(..))"/>
            -->


            <!--<aop:before method="myBefore"
                        pointcut="execution(* com.qf.service.impl.*.*(..))"/>
            -->
            
            <!--<aop:after method="myAfter" pointcut="execution(* com.qf.service.impl.*.*(..))"/>-->

            <!--
                returning用来绑定目标方法执行后返回值,ret是myAfterRet方法的参数名
            -->
            <!--<aop:after-returning returning="ret" method="myAfterRet"
                                 pointcut="execution(* com.qf.service.impl.*.*(..))"/>-->

            <!-- throwing绑定目标方法抛出的异常,要传入给增强方法myException的参数 -->
            <aop:after-throwing throwing="e" method="myException" pointcut="execution(* com.qf.service.impl.*.*(..))"/>

        </aop:aspect>
    </aop:config>

</beans>

1.6 总结

通过AOP提供的编码流程，更便利的定制切面，更方便的定制了动态代理。
进而彻底解决了辅助功能(事务管理,日志记录,权限校验)冗余的问题；
业务类中职责单一性得到更好保障；
辅助功能也有很好的复用性。

1.7 AOP底层动态代理【面试】

AOP的底层使用的就是动态代理,使用的技术

jdk+cglib都用了

当目标类有接口的时候使用JDK动态代理
当目标类没有实现接口时,使用CGLIB动态代理

2 注解开发AOP【重点】

IOC,DI,AOP全部使用注解开发

注解	解释
@Aspect	声明类为切面类
@Around	环绕通知
@Before	前置通知
@After	后置通知
@AfterReturning	后置返回通知
@AfterThrowing	异常通知
@Pointcut	抽取切入点表达式

业务层类加注解@Service,@Autowired

重点是给切面类加注解

package com.qf.aspect;

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

/**
 *
 *
 *
 * @desc 切面
 */
@Component // 该注解,spring创建该类对象
@Aspect    // 该注解,该类是切面类
public class MyAspectAnno {

    /**
     * 定义一个切入点表达式公共方法
     */
    @Pointcut("execution(* com.qf.service.impl.*.*(..))")
    public void myPointcut(){}


    @Around("myPointcut()")
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 目标方法前:
        System.out.println("开启事务/权限校验" );

        // 目标方法执行
        Object ret = joinPoint.proceed( );
        System.out.println("目标方法返回值---> " + ret );
        // 目标方法后:
        System.out.println("提交事务/日志记录" );
        return ret;
    }

    @Before("myPointcut()")
    public void myBefore(JoinPoint joinPoint) {
        // 目标对象
        Object target = joinPoint.getTarget( );
        System.out.println("target = " + target);
        // 获得目标方法签名(方法名)
        Signature signature = joinPoint.getSignature( );
        System.out.println("signature = " + signature);

        System.out.println("前置通知--->权限校验--->OK" );

        // 假设权限校验没有通过,通过抛出异常让代码停下,不再执行目标方法
        // System.out.println("前置通知--->权限校验--->ERROR" );
        // throw new RuntimeException("权限校验--->ERROR");
    }

    @After("myPointcut()")
    public void myAfter() {
        System.out.println("后置通知--->记录日志,释放资源" );
    }

    @AfterReturning(value = "myPointcut()",returning = "ret")
    public Object myAfterRet(Object ret) {
        System.out.println("后置返回通知,接收到目标方法返回值--->" + ret);
        // 可以对返回的数据进行处理
        if (ret instanceof Integer) {
            Integer value = (Integer) ret;
            value *= 3;
            // 【BUG,返回值没有返回给目标方法】
            return value;
        }
        return ret;
    }

    @AfterThrowing(value = "myPointcut()",throwing = "e")
    public void myException(Exception e) {
        System.out.println("目标方法报的错---> " + e.getMessage());
    }
}

配置文件扫描注解,让注解生效

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">


    <!-- 扫描IOC,DI注解 -->
    <context:component-scan base-package="com.qf"/>

    <!-- AOP开启自动代理,注解生效 -->
    <aop:aspectj-autoproxy/>

</beans>

测试即可

    @Test
    public void testAspectByAnno() {
        String path = "applicationContextAnno.xml";
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(path);
        // 使用注解,对象名,默认是类名首字母小写
        UserService userService = context.getBean("userServiceImpl", UserService.class);
        userService.findUserById();

        System.out.println("-----------------" );

        userService.deleteUserById();

        System.out.println("-----------------" );
        HouseService houseService = context.getBean("houseServiceImpl", HouseService.class);
        int i = houseService.deleteHouse( );
        System.out.println("i = " + i);
    }