2.3 Spring系列教程3-Spring AOP

于 2024-10-01 17:41:15 发布
阅读量923 收藏 13
点赞数 25
分类专栏： JavaEE Spring 文章标签： spring java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40467855/article/details/142672868
版权

Spring的AOP模块是Spring框架体系中十分重要的内容，该模块一般适用于具有横切逻辑的场景，如访问控制、事务管理和性能监控等，本章将对Spring AOP的相关知识进行详细讲解。

一 Spring AOP介绍

1.1 AOP概述

​ AOP的全称是Aspect Oriented Programming，即面向切面编程。和OOP不同，AOP主张将程序中相同的业务逻辑进行横向隔离，并将重复的业务逻辑抽取到一个独立的模块中，以达到提高程序可重用性和开发效率的目的。

​ 在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录），同样的代码仍然会分散到各个方法中。

例如，订单系统中有添加订单信息、更新订单信息和删除订单信息3个方法，这3个方法中都包含事务管理业务代码，订单系统的逻辑如图所示。

image-20240930173948819

  • AOP面向切面编程的优势

    ​ 由订单系统可知，添加订单信息、修改订单信息、删除订单信息的方法体中都包含事务管理的业务逻辑，这就带来了一定数量的重复代码并使程序的维护成本增加。基于AOP的面向切面编程，可以为此类问题提供解决方案，AOP可以将事务管理的业务逻辑从这三个方法体中抽取到一个可重用的模块，进而降低横向业务逻辑之间的耦合，减少重复代码。AOP的使用，使开发人员在编写业务逻辑时可以专心于核心业务，而不用过多地关注其他业务逻辑的实现，不但提高了开发效率，又增强了代码的可维护性。

1.2 Spring AOP术语

术语名称英文说明
切面Aspect切面是指关注点形成的类（关注点是指类中重复的代码），通常是指封装的、用于横向插入系统的功能类（如事务管理、日志记录等）。在实际开发中，该类被Spring容器识别为切面，需要在配置文件中通过<bean>元素指定
连接点Joinpoint连接点是程序执行过程中某个特定的节点，例如，某方法调用时或处理异常时。在Spring AOP中，一个连接点通常是一个方法的执行。
切入点Pointcut当某个连接点满足预先指定的条件时，AOP就能够定位到这个连接点，在连接点处插入切面，该连接点也就变成了切入点。
通知/增强处理Advice通知/增强处理就是插入的切面程序代码。可以将通知/增强处理理解为切面中的方法，它是切面的具体实现
目标对象Target目标对象是指被插入切面的方法，即包含主业务逻辑的类对象。或者说是被一个或者多个切面所通知的对象
织入Weaving将切面代码插入到目标对象上，从而生成代理对象的过程。织入可以在编译时，类加载时和运行时完成。在编译时进行织入就是静态代理，而在运行时进行织入则是动态代理。
代理Proxy将通知应用到目标对象之后，程序动态创建的通知对象，就称为代理。代理类既可能是和原类具有相同接口的类，也可能就是原类的子类，可以采用调用原类相同的方式调用代理类。
引介Introduction引介是一种特殊的通知，它为目标对象添加一些属性和方法。这样，即使一个业务类原本没有实现某一个接口，通过AOP的引介功能，也可以动态地为该业务类添加接口的实现逻辑，让业务类成为这个接口的实现类。

二 Spring AOP的实现机制

2.1 JDK动态代理

默认情况下，Spring AOP使用JDK动态代理，JDK动态代理是通过java.lang.reflect.Proxy 类实现的，可以调用Proxy类的newProxyInstance()方法创建代理对象。JDK动态代理可以实现无侵入式的代码扩展，并且可以在不修改源代码的情况下，增强某些方法。

2.1.1 示例代码

Java代码位于SpringLearn/src/main/java/site/icefox/javaeelearn/Learn3/target21下

  • UserDao.java

    package site.icefox.javaeelearn.Learn3.target21;

public interface UserDao {
    void addUser();

    void deleteUser();
}

  • UserDaoImpl.java

    package site.icefox.javaeelearn.Learn3.target21;

import lombok.Data;

@Data
public class UserDaoImpl implements UserDao {
    public void addUser() {
        System.out.println("添加用户");
    }

    public void deleteUser() {
        System.out.println("删除用户");
    }
}

  • MyProxy.java

    package site.icefox.javaeelearn.Learn3.target21;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MyProxy implements InvocationHandler {
    private UserDao userDao;

    public Object createProxy(UserDao userDao) {
        this.userDao = userDao;
        ClassLoader classLoader = MyProxy.class.getClassLoader(); // 1.类加载器
        Class[] classes = userDao.getClass().getInterfaces(); // 2.被代理对象实现的所有接口
        return Proxy.newProxyInstance(classLoader, classes, this); // 3.返回代理对象
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MyAspect.check_Permissions();
        Object res = method.invoke(userDao, args);
        MyAspect.log();
        return res;
    }
}

  • MyAspect.java

    package site.icefox.javaeelearn.Learn3.target21;

public class MyAspect {// 切面类：存在多个通知Advice（增强的方法）
    public static void check_Permissions(){
        System.out.println("模拟检查权限...");		}
    public static void log(){
        System.out.println("模拟记录日志...");		}
}

  • JDKTest.java

    package site.icefox.javaeelearn.Learn3.target21;

public class JDKTest {
    public static void main(String[] args) {
        MyProxy jdkProxy = new MyProxy();// 创建代理对象
        UserDao userDao = new UserDaoImpl();// 创建目标对象
        // 从代理对象中获取增强后的目标对象
        UserDao userDao1 = (UserDao) jdkProxy.createProxy(userDao);
        // 执行方法
        userDao1.addUser();
        userDao1.deleteUser();
    }
}
2.1.2 预期结果
模拟检查权限...
添加用户
模拟记录日志...
模拟检查权限...
删除用户
模拟记录日志...

进程已结束，退出代码为 0

2.2 CGLib动态代理

JDK动态代理存在缺陷，它只能为接口创建代理对象，当需要为类创建代理对象时，就需要使用CGLib（Code Generation Library）动态代理，CGLib动态代理不要求目标类实现接口，它采用底层的字节码技术，通过继承的方式动态创建代理对象。

2.2.1 示例代码

Java代码位于SpringLearn/src/main/java/site/icefox/javaeelearn/Learn3/target22下

  • CglibProxy.java

    package site.icefox.javaeelearn.Learn3.target22;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {

    public Object createProxy(Object target) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //创建一个切面
        MyAspect myAspect = new MyAspect();
        //前增强
        myAspect.check_Permissions();
        Object obj = methodProxy.invokeSuper(proxy, args);
        //后增强
        myAspect.log();
        return obj;
    }
}

  • CglibTest.java

    package site.icefox.javaeelearn.Learn3.target22;

public class CglibTest {
    public static void main(String[] args) {
        CglibProxy cglibProxy = new CglibProxy();
        UserDao userDao = new UserDao(); // 创建目标对象
        UserDao userDaoProxy = (UserDao) cglibProxy.createProxy(userDao); // 获取代理对象

        // 执行方法
        userDaoProxy.addUser();
        userDaoProxy.deleteUser();
    }
}

  • MyAspect.java

    package site.icefox.javaeelearn.Learn3.target22;

public class MyAspect {// 切面类：存在多个通知Advice（增强的方法）

    public void check_Permissions() {
        System.out.println("模拟检查权限...");
    }

    public void log() {
        System.out.println("模拟记录日志...");
    }
}

  • UserDao.java

    package site.icefox.javaeelearn.Learn3.target22;

public class UserDao {
    public void addUser() {
        System.out.println("添加用户");
    }

    public void deleteUser() {
        System.out.println("删除用户");
    }
}
2.2.2 预期结果
模拟检查权限...
添加用户
模拟记录日志...
模拟检查权限...
删除用户
模拟记录日志...

进程已结束，退出代码为 0

三 基于XML的AOP实现

使用AOP代理对象的好处

因为Spring AOP中的代理对象由IoC容器自动生成，所以开发者无须过多关注代理对象生成的过程，只需选择连接点、创建切面、定义切点并在XML文件中添加配置信息即可。Spring提供了一系列配置Spring AOP的XML元素。

3.1 配置Spring AOP的XML元素

元素描述
<aop:config>Spring AOP配置的根元素
<aop:aspect>配置切面
<aop:advisor>配置通知器
<aop:pointcut>配置切点
<aop:before>配置前置通知,在目标方法执行前实施增强,可以应用于权限管理等功能
<aop:after>配置后置通知,在目标方法执行后实施增强,可以应用于关闭流、上传文件、删除临时文件等功能
<aop:around>配置环绕方式,在目标方法执行前后实施增强,可以应用于日志、事务管理等功能
<aop:after-returning>配置返回通知,在目标方法成功执行之后调用通知
<aop:after-throwing>配置异常通知,在方法抛出异常后实施增强,可以应用于处理异常记录日志等功能

3.2 配置说明

3.2.1 配置切面

在Spring的配置文件中，配置切面使用的是<aop:aspect>元素，该元素会将一个已定义好的Spring Bean转换成切面Bean，因此，在使用<aop:aspect>元素之前，要在配置文件中先定义一个普通的Spring Bean。Spring Bean定义完成后，通过<aop:aspect>元素的ref属性即可引用该Bean。配置<aop:aspect>元素时，通常会指定id和ref两个属性。

  • aop:aspect元素的id属性和ref属性的描述：

    属性说明
    id用于定义该切面的唯一标识
    ref用于引用普通的Spring Bean
3.2.2 配置切入点

在Spring的配置文件中，切入点是通过<aop:pointcut>元素来定义的。当<aop:pointcut>元素作为<aop:config>元素的子元素定义时，表示该切入点是全局的，它可被多个切面共享；当<aop:pointcut>元素作为<aop:aspect>元素的子元素时，表示该切入点只对当前切面有效。定义<aop:pointcut>元素时，通常会指定id、expression属性。

  • <aop:pointcut>元素的id属性和expression属性描述：

    属性说明
    id用于指定切入点的唯一标识
    expression用于指定切入点关联的切入点表达式

  • Spring AOP切入点表达式的基本格式

    execution(
    modifiers-pattern?
    ret-type-pattern
    declaring-type-pattern?
    name-pattern(param-pattern)
    throws-pattern?
)

  • execution表达式各部分参数说明

    参数名称说明
    modifiers-pattern表示定义的目标方法的访问修饰符，如public、private等。
    ret-type-pattern表示定义的目标方法的返回值类型，如void、String等。
    declaring-type-pattern表示定义的目标方法的类路径，如com.itheima.jdk.UserDaoImpl。
    name-pattern表示具体需要被代理的目标方法，如add()方法。
    param-pattern表示需要被代理的目标方法包含的参数，本章示例中目标方法参数都为空。
    throws-pattern表示需要被代理的目标方法抛出的异常类型。
3.2.3 配置通知

在Spring的配置文件中，使用<aop:aspect>元素配置了5种常用通知，分别为前置通知、后置通知、环绕通知、返回通知和异常通知。

  • <aop:aspect>元素的常用属性

    属性描述
    pointcut该属性用于指定一个切入点表达式,Spring将在匹配该表达式的连接点时织入该通知。
    pointcut-ref该属性指定一个已经存在的切入点名称,如配置代码中的myPointCut。通常pointcut和pointcut-ref两个属性只需要使用其中一个即可。
    method该属性指定一个方法名,指定将切面Bean中的该方法转换为增强处理。
    throwing该属性只对<after-throwing>元素有效,它用于指定一个形参名,异常通知方法可以通过该形参访问目标方法所抛出的异常。
    returning该属性只对<after-returning>元素有效,它用于指定一个形参名,后置通知方法可以通过该形参访问目标方法的返回值。

3.3 示例代码

Java代码位于SpringLearn/src/main/java/site/icefox/javaeelearn/Learn3/target30下

xml代码位于SpringLearn/src/main/resources/learn3/target30下

  • TestXml.java

    package site.icefox.javaeelearn.Learn3.target30;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestXml {
    public static void main(String[] args) {
        ApplicationContext context = new
                ClassPathXmlApplicationContext("learn3/target30/applicationContext.xml");
        UserDao userDao = context.getBean("userDao", UserDao.class);
        userDao.delete();
        System.out.println();
        userDao.insert();
        System.out.println();
        userDao.select();
        System.out.println();
        userDao.update();
    }
}

  • UserDao.java

    package site.icefox.javaeelearn.Learn3.target30;

public interface UserDao {
    void insert();
    void delete();
    void update();
    void select();
}

  • UserDaoImpl.java

    package site.icefox.javaeelearn.Learn3.target30;

public class UserDaoImpl implements UserDao {
    public void insert() {
        System.out.println("添加用户信息");
    }

    public void delete() {
        System.out.println("删除用户信息");
    }

    public void update() {
        System.out.println("更新用户信息");
    }

    public void select() {
        System.out.println("查询用户信息");
    }
}

  • XmlAdvice.java

    package site.icefox.javaeelearn.Learn3.target30;

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

public class XmlAdvice {
    //前置通知
    public void before(JoinPoint joinPoint) {        //使用JoinPoint接口实例作为参数获得目标对象的类名和方法名
        System.out.print("这是前置通知！");
        System.out.print("目标类：" + joinPoint.getTarget());
        System.out.println("，被织入增强处理的目标方法为：" + joinPoint.getSignature().getName());
    }

    //返回通知
    public void afterReturning(JoinPoint joinPoint) {//使用JoinPoint接口实例作为参数获得目标对象的类名和方法名
        System.out.print("这是返回通知（方法不出现异常时调用）！");
        System.out.println("被织入增强处理的目标方法为：" + joinPoint.getSignature().getName());
    }

    /**
     * 环绕通知
     * ProceedingJoinPoint是JoinPoint子接口，表示可以执行目标方法
     * 1.必须是Object类型的返回值
     * 2.必须接收一个参数，类型为ProceedingJoinPoint
     * 3.必须throws Throwable
     */
    public Object around(ProceedingJoinPoint point) throws Throwable {//使用ProceedingJoinPoint接口实例作为参数获得目标对象的类名和方法名
        System.out.println("这是环绕通知之前的部分！");
        //调用目标方法
        Object object = point.proceed();
        System.out.println("这是环绕通知之前的部分！");
        return object;
    }

    //异常通知
    public void afterException() {
        System.out.println("异常通知！");
    }

    //后置通知
    public void after() {
        System.out.println("这是后置通知！");
    }
}

3.4 预期结果

这是前置通知！目标类：site.icefox.javaeelearn.Learn3.target30.UserDaoImpl@7adf16aa，被织入增强处理的目标方法为：delete
这是环绕通知之前的部分！
删除用户信息
这是后置通知！
这是环绕通知之前的部分！
这是返回通知（方法不出现异常时调用）！被织入增强处理的目标方法为：delete

这是前置通知！目标类：site.icefox.javaeelearn.Learn3.target30.UserDaoImpl@7adf16aa，被织入增强处理的目标方法为：insert
这是环绕通知之前的部分！
添加用户信息
这是后置通知！
这是环绕通知之前的部分！
这是返回通知（方法不出现异常时调用）！被织入增强处理的目标方法为：insert

这是前置通知！目标类：site.icefox.javaeelearn.Learn3.target30.UserDaoImpl@7adf16aa，被织入增强处理的目标方法为：select
这是环绕通知之前的部分！
查询用户信息
这是后置通知！
这是环绕通知之前的部分！
这是返回通知（方法不出现异常时调用）！被织入增强处理的目标方法为：select

这是前置通知！目标类：site.icefox.javaeelearn.Learn3.target30.UserDaoImpl@7adf16aa，被织入增强处理的目标方法为：update
这是环绕通知之前的部分！
更新用户信息
这是后置通知！
这是环绕通知之前的部分！
这是返回通知（方法不出现异常时调用）！被织入增强处理的目标方法为：update

进程已结束，退出代码为 0

四 基于注解的AOP实现

4.1 Spring AOP的注解

元素描述
@Aspect配置切面
@Pointcut配置切点
@Before配置前置通知
@After置后置通知
@Around配置环绕方式
@AfterReturning配置返回通知
@AfterThrowing配置异常通知

4.2 示例代码

Java代码位于SpringLearn/src/main/java/site/icefox/javaeelearn/Learn3/target40下

xml代码位于SpringLearn/src/main/resources/learn3/target40下

  • AnnoAdvice.java

    package site.icefox.javaeelearn.Learn3.target40;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class AnnoAdvice {
    //切点
    @Pointcut("execution( * site.icefox.javaeelearn.Learn3.target40.UserDaoImpl.*(..))")
    public void poincut() {
    }

    //前置通知
    @Before("poincut()")
    public void before(JoinPoint joinPoint) {        //使用JoinPoint接口实例作为参数获得目标对象的类名和方法名
        System.out.print("这是前置通知！");
        System.out.print("目标类：" + joinPoint.getTarget());
        System.out.println("，被织入增强处理的目标方法为：" + joinPoint.getSignature().getName());
    }

    //返回通知
    @AfterReturning("poincut()")
    public void afterReturning(JoinPoint joinPoint) {//使用JoinPoint接口实例作为参数获得目标对象的类名和方法名
        System.out.print("这是返回通知（方法不出现异常时调用）！");
        System.out.println("被织入增强处理的目标方法为：" + joinPoint.getSignature().getName());
    }

    /**
     * 环绕通知
     * ProceedingJoinPoint是JoinPoint子接口，表示可以执行目标方法
     * 1.必须是Object类型的返回值
     * 2.必须接收一个参数，类型为ProceedingJoinPoint
     * 3.必须throws Throwable
     */
    @Around("poincut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {//使用ProceedingJoinPoint接口实例作为参数获得目标对象的类名和方法名
        System.out.println("这是环绕通知之前的部分！");
        //调用目标方法
        Object object = point.proceed();
        System.out.println("这是环绕通知之前的部分！");
        return object;
    }

    //异常通知
    @AfterThrowing("poincut()")
    public void afterException() {
        System.out.println("异常通知！");
    }

    //后置通知
    @After("poincut()")
    public void after() {
        System.out.println("这是后置通知！");
    }
}

  • TestAnnotation.java

    package site.icefox.javaeelearn.Learn3.target40;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAnnotation {
    public static void main(String[] args) {
        ApplicationContext context = new
                ClassPathXmlApplicationContext("learn3/target40/applicationContext-Anno.xml");
        UserDao userDao = context.getBean("userDao", UserDao.class);
        userDao.delete();
        System.out.println();
        userDao.insert();
        System.out.println();
        userDao.select();
        System.out.println();
        userDao.update();
    }
}

  • UserDao.java

    package site.icefox.javaeelearn.Learn3.target40;

public interface UserDao {
    void insert();

    void delete();

    void update();

    void select();
}

  • UserDaoImpl.java

    package site.icefox.javaeelearn.Learn3.target40;

public class UserDaoImpl implements UserDao {
    public void insert() {
        System.out.println("添加用户信息");
    }

    public void delete() {
        System.out.println("删除用户信息");
    }

    public void update() {
        System.out.println("更新用户信息");
    }

    public void select() {
        System.out.println("查询用户信息");
    }
}

  • applicationContext-Anno.xml

    <?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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 注册Bean -->
    <bean name="userDao" class="site.icefox.javaeelearn.Learn3.target40.UserDaoImpl"/>
    <bean name="AnnoAdvice" class="site.icefox.javaeelearn.Learn3.target40.AnnoAdvice"/>
    <!-- 开启@aspectj的自动代理支持 -->
    <aop:aspectj-autoproxy/>
</beans>

4.3 预期结果

这是环绕通知之前的部分！
这是前置通知！目标类：site.icefox.javaeelearn.Learn3.target40.UserDaoImpl@24faea88，被织入增强处理的目标方法为：delete
删除用户信息
这是返回通知（方法不出现异常时调用）！被织入增强处理的目标方法为：delete
这是后置通知！
这是环绕通知之前的部分！

这是环绕通知之前的部分！
这是前置通知！目标类：site.icefox.javaeelearn.Learn3.target40.UserDaoImpl@24faea88，被织入增强处理的目标方法为：insert
添加用户信息
这是返回通知（方法不出现异常时调用）！被织入增强处理的目标方法为：insert
这是后置通知！
这是环绕通知之前的部分！

这是环绕通知之前的部分！
这是前置通知！目标类：site.icefox.javaeelearn.Learn3.target40.UserDaoImpl@24faea88，被织入增强处理的目标方法为：select
查询用户信息
这是返回通知（方法不出现异常时调用）！被织入增强处理的目标方法为：select
这是后置通知！
这是环绕通知之前的部分！

这是环绕通知之前的部分！
这是前置通知！目标类：site.icefox.javaeelearn.Learn3.target40.UserDaoImpl@24faea88，被织入增强处理的目标方法为：update
更新用户信息
这是返回通知（方法不出现异常时调用）！被织入增强处理的目标方法为：update
这是后置通知！
这是环绕通知之前的部分！

进程已结束，退出代码为 0

五 结语

a88，被织入增强处理的目标方法为：delete
删除用户信息
这是返回通知（方法不出现异常时调用）！被织入增强处理的目标方法为：delete
这是后置通知！
这是环绕通知之前的部分！

这是环绕通知之前的部分！
这是前置通知！目标类：site.icefox.javaeelearn.Learn3.target40.UserDaoImpl@24faea88，被织入增强处理的目标方法为：insert
添加用户信息
这是返回通知（方法不出现异常时调用）！被织入增强处理的目标方法为：insert
这是后置通知！
这是环绕通知之前的部分！

这是环绕通知之前的部分！
这是前置通知！目标类：site.icefox.javaeelearn.Learn3.target40.UserDaoImpl@24faea88，被织入增强处理的目标方法为：select
查询用户信息
这是返回通知（方法不出现异常时调用）！被织入增强处理的目标方法为：select
这是后置通知！
这是环绕通知之前的部分！

这是环绕通知之前的部分！
这是前置通知！目标类：site.icefox.javaeelearn.Learn3.target40.UserDaoImpl@24faea88，被织入增强处理的目标方法为：update
更新用户信息
这是返回通知（方法不出现异常时调用）！被织入增强处理的目标方法为：update
这是后置通知！
这是环绕通知之前的部分！

进程已结束，退出代码为 0


## 五 结语

本章主要讲解了Spring中的AOP。首先介绍了Spring AOP，包括Spring AOP的概述和Spring AOP的术语；然后讲解了Spring AOP的实现机制，包括JDK动态代理和CGLib动态代理；接着讲解了基于XML的AOP实现，并使用案例的方式实现了基于XML文件的AOP；最后讲解了基于注解的AOP实现。通过本章的学习，读者可以对Spring AOP有基础的了解，为框架开发奠定基础。
喝Java也加唐~
关注
专栏目录
2024最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
**My Coding Family**
04-20 8万+
从0到1以知识点+实例+项目的教学模式对SpringBoot框架由浅入深进行学习，快来跟bug菌一起学习吧。
第8章 Spring AOP
小猪宝宝的博客
08-31 2226
首先介绍了Spring AOP，包括Spring AOP的概述和Spring AOP的术语；然后讲解了Spring AOP的实现机制，包括JDK动态代理和CGLib动态代理；接着讲解了基于XML的AOP实现，并使用案例的方式实现了基于XML文件的AOP；最后讲解了基于注解的AOP实现。.........
Java EE企业级应用开发习题（第一次）
weixin_57242411的博客
03-28 1129
B、AOP采取横向隔离机制，将分散在各个方法中的重复代码提取出来，这种采用横向隔离机制的方式，采用OOP思想是无法办到的。B、AOP采取横向隔离机制，将分散在各个方法中的重复代码提取出来，这种采用横向隔离机制的方式，采用OOP思想是无法办到的。A、Aspect：切面是指关注点（指类中重复的代码）形成的类，通常是指封装的、用于横向插入系统的功能类。A、Spring AOP的实现机制分两种，一种是JDK动态代理，一种是CGLib动态代理。6、下列AOP专业术语中，用于表示切面与连接点的交叉点的是（ ）。
javaweb复习-作业1-有解析
weixin_51035156的博客
12-18 2132
1 以下不属于ProxyFactoryBean类中的常用可配置属性的是（）。 A、 target B、 proxyInterfaces C、 targetClass D、 interceptorNames 正确答案： C 常用可配置属性： target：代理的目标对象 proxyInterface: 代理所需要的实现的接口，可以是多个接口，该属性还有一个别名属性interfaces. proxyTargertClass： 是否对类进行代理（而不是对接口进行代理）.
Java EE 企业级应用开发教程题库（第二版）
四川兔兔的博客
06-12 8810
Java EE这是一门偏向于实践的课，奈何考试理论居多。Mybatis,Spring,SpringMVC一学期想搞懂三个框架，嘿嘿，难哦！如果你是大一大二的同学，认认真真学习，真的有用。如果你是大三的同学，像就业并且走这个方向的同学，也认真学习。如果你大三考研的同学，自己安排时间。这里是我平时的五个作业，建立成一个题库供大家搜索。里面的答案部分很怪，但就是给的标答，大家可以找老师商讨。使用法则：Ctrl + F 键搜索你需要的题目。
Spring AOP
qq_53217531的博客
04-24 286
​ AOP的全称是Aspect Oriented Programming，即面向切面编程。和OOP不同，AOP主张将程序中相同的业务逻辑进行横向隔离，并将重复的业务逻辑抽取到一个独立的模块中，以达到提高程序可重用性和开发效率的目的。​ 在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录），同样的代码仍然会分散到各个方法中。
Spring Boot 实战教程，由浅入深详细介绍springboot的使用
03-12
### Spring Boot 实战教程知识点详解 #### 一、Spring Boot 简介 **1.1 Spring 概述** Spring 是一个开源框架，最初由 Rod Johnson 创建，它为 Java 应用程序提供了一种简化的方式来处理依赖管理和面向切面编程...
SPRING-framework5 最新英文版 详细教程
09-04
### Spring Framework 5.0.0.M1 详尽教程概览 #### 一、Spring框架概述 **1. 开始使用Spring** Spring 框架是一个轻量级且全面的框架，它提供了构建企业级应用程序所需的所有核心功能。本章节主要介绍了如何开始...
spring-framework 中文文档.pdf
最新发布
07-02
对于初学者来说，Spring 提供了一系列资源和指南来帮助快速上手。这些资源包括官方文档、教程、示例项目等。建议首先了解Spring的核心概念，然后逐步学习各个模块的功能和用法。 #### 二、核心技术 Spring ...
spring注解:spring aop注解详解
热门推荐
weixin_37862824的博客
01-09 1万+
AOP的基本概念、切面、切点、通知、环绕通知
Spring（八）：Spring之AOP全解析
weixin_43162044的博客
11-02 464
面向切面编程，一种编程范式，指导开发者如何组织程序结构面向对象编程作用：在不惊动原始设计的基础上为其进行功能增强Spring理念：无入侵式/无侵入式。
AOP那些学术概念—通知、增强处理连接点（JoinPoint)切面（Aspect）
xuyan5971的博客
06-21 1387
AOP那些学术概念—通知、增强处理连接点（JoinPoint)切面（Aspect） 1、我所知道的AOP 初看起来，上来就是一大堆的术语，而且还有个拉风的名字，面向切面编程，都说是OOP的一种有益补充等等。一下让你不知所措，心想着：管不得很多人都和我说AOP多难多难。当我看进去以后，我才行发现：他就是一些Java基础上的朴实无华的应用，包括IOC（见《Spring IOC(依赖注入、控
《Spring AOP原理理解》
m0_65004039的博客
11-18 367
Spring的AOP模块是Spring框架体系中十分重要的内容，该模块一般适用于具有横切逻辑的场景，例如，访问控制、事务管理和性能监控等。和OOP不同，AOP主张横向隔离，并将重复的业务逻辑抽取到一个独立的模块中，以达到提高程序可重用性和开发效率的目的。 1.1.1、切面（Aspect） 切面是指类中重复的代码形成的类，通常指的是事务管理、日志记录等的功能类，在开发过程中，该类被Spring容器识别为切面，在配置文件中通过bean指定。 1.1.2、
Spring系列--AOP
qq_43404873的博客
11-17 753
AOP简介 什么是AOP AOP的全称是 Aspect-Oriented Programming,即面向切面编程。在传统的业务处理代码中，通常都会进行事务处理、日志记录等。虽然使用OOP(面向对象编程)可以通过组合或继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录），相同的代码仍然会分散到各个方法中。如果想要关闭某个功能，或者对其进行修改，就必须修改所有相关方法。 为了解决这一问题，AOP思想随之产生。AOP采取横向抽取机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或运行时再将这些提
Spring学习笔记2——AOP
bains的博客
07-07 202
AOP概念 简介 AOP为Aspect Oriented Programming的缩写，意为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。OOP的延续，Spring框架中的一个重要内容，函数式编程的一种衍生范型；利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分的耦合度降低，提高程序的可重用性，同时提高开发效率。 作用和优势 作用：在程序云溪期间，在不修改源码的情况下对方法进行功能增强； 优势：减少重复代码，提高开发效率，便于维护。 底层实现 AOP的底
为什么JDK动态代理只能代理接口，不能直接代理类？
weixin_42227763的博客
06-16 2370
为什么JDK的动态代理要基于接口实现而不能基于继承实现？ 1. 问题 在阅读本文之前，可以先思考一下下面几个问题。 为什么说JDK的动态代理要基于接口实现，而不能基于继承来实现？ 在JDK的动态代理中，在目标对象方法内部调用自己的另一个方法时，另一个方法在执行时，为什么没有经过代理对象？ 2. JDK的动态代理的固定写法 JDK的动态代理的写法比较固定，需要先定义一个接口和接口的实现类，然后再定义一个实现了InvocationHandler接口的实现类。然后调用Proxy类的newInstance
Spring-05 AOP入门（ 原理解析）
linyuancsdn的博客
09-12 381
OOP > 面向对象AOP > 面向切面 (切面 切入点 - 面)AOP 一般适用于, 具有横切逻辑的场合, 比如访问控制,事务管理,性能检测等等​ Spring框架的AOP机制采用一种称为“横切”的技术，可以让开发者把业务流程中的通用功能抽取出来，单独编写功能代码。在业务流程执行过程中，Spring框架会根据业务流程要求，自动把独立编写的功能代码切入到流程的合适位置。厨师 核心 打荷 辅助打荷 备料 (鸡蛋 , 西红柿 )大厨 开始炒菜摆盘代码 必须由程序员来操作完成的 核心。
为什么JDK动态代理只能代理接口，不能直接代理类？CGlib为什么可以代理类？
lx1315998513的博客
10-07 4003
在？撸个问题。一、JDK动态代理与CGlib动态代理二、为什么JDK动态代理只能代理接口，不能直接代理类？（一）简单的实现JDK动态代理三、CGlib为什么可以代理类？四、总结五、参考： 一、JDK动态代理与CGlib动态代理 众所周知，Spring会基于代理的类去动态的选择使用JDK创建代理对象还是CGLIB（当然也可以配置全都使用CGlib），这取决于被代理的对象是类还是接口。 java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。 CGli
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

喝Java也加唐~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值