Spring框架学习笔记（三）：AOP编程

最新推荐文章于 2024-06-04 20:26:31 发布
最新推荐文章于 2024-06-04 20:26:31 发布
阅读量597 收藏 26
点赞数 19
分类专栏： Spring 文章标签： 学习 笔记 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76144723/article/details/138604855
版权

1 动态代理

1.1 通过案例理解动态代理

（1）需求说明：
1. 有 Vehicle接口(交通工具接口, 有一个 run 方法), 下面有两个实现类 Car 和 Ship
2. 当运行 Car 对象 的 run 方法和 Ship 对象的 run 方法时，输入如下内容, 注意观察前后
有统一的输出

（2）准备代码： Vehicle.java，Car.java，Ship.java

public interface Vehicle {
    public void run();
    public String fly(int height);
}
public class Car implements Vehicle{

    @Override
    public void run(){
        System.out.println("小汽车在水上running...");
    }

    @Override
    public String fly(int height) {
        return "小汽车飞到了" + height + "米";
    }
}
public class Ship implements Vehicle{
    @Override
    public void run() {
        System.out.println("大轮船在水上running...");
    }
    @Override
    public String fly(int height) {
        return "大轮船飞到了" + height + "米";
    }
}

（3）动态代理实现：创建代理类VehicleProxyProvider.java(该类中有详细注释，演示了动态代理的实现过程)

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

/**
 * 该类返回一个代理对象
 */
public class VehicleProxyProvider {

    //该属性表示真正要执行的对象(实现了Vehicle接口的类)
    private Vehicle target_vehicle;

    //构造器
    public VehicleProxyProvider(Vehicle target_vehicle) {
        this.target_vehicle = target_vehicle;
    }

    //编写一个方法，可以返回一个代理对象
    public Vehicle getProxy(){
        //得到类的加载器
        ClassLoader classLoader = target_vehicle.getClass().getClassLoader();
        //得到接口信息
        Class<?>[] interfaces = target_vehicle.getClass().getInterfaces();
        //使用基于接口的匿名内部类创建InvocationHandler对象
        InvocationHandler h = new InvocationHandler(){
            /**
             * invoke方法在将来调用target_vehicle的方法时，会使用到
             * @param proxy 表示代理对象
             * @param method 就是想要通过代理对象调用的那个方法
             * @param args 表示要调用的方法需要传入的参数
             * @return 表示target_vehicle的方法执行后的结果
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //这里可以写调用方法前要进行的操作
                System.out.println("交通工具开始运行了...");
                //通过反射调用该方法
                Object result = method.invoke(target_vehicle, args);
                //这里可以写调用方法后要进行的操作
                System.out.println("交通工具停止运行了...");

                return result;
            }
        };
        //java.lang.reflect中的Proxy类有动态代理的相关方法，静态方法newProxyInstance()可以创建一个代理对象
        /*
        ClassLoader loader:类的加载器
        Class<?>[] interfaces:要代理对象的接口的信息
        InvocationHandler h:调用处理器/对象,InvocationHandler是一个接口，
        里面有一个方法public Object invoke(Object proxy, Method method, Object[] args)
        public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
         */
        Vehicle proxy = (Vehicle)Proxy.newProxyInstance(classLoader, interfaces, h);
        return proxy;
    }
}

（4）测试代码：

@Test
public void proxyRun(){
    //创建代理类对象，传入要代理的对象
    VehicleProxyProvider vehicleProxyProvider = new VehicleProxyProvider(new Ship());
    //获取到代理对象，该对象可以代理执行方法
    //1.proxy编译类型是Vehicle
    //2.运行类型是代理类型class com.sun.proxy.$Proxy8
    Vehicle proxy = vehicleProxyProvider.getProxy();
    System.out.println(proxy.getClass());
    //所以这里调用的不是ship中的run方法，而是代理对象的invoke
    proxy.run();
    String fly = proxy.fly(100);
    System.out.println(fly);
}

（5）运行结果：

1.2 通过案例理解横切关注点

（1）需求说明：

有一个 SmartAnimal 接口，可以完成简单的加减法, 要求在执行 getSum()和 getSub()时，输出执行前，执行过程，执行后的日志输出

（2）准备代码：SmartAnimalable.java，SmartDog.java

public interface SmartAnimalable {
    //求和
    float getSum(float i, float j);
    //求差
    float getSub(float i, float j);
}
public class SmartDog implements SmartAnimalable {
    @Override
    public float getSum(float i, float j) {
        float result = i + j;
        System.out.println("方法内部打印result = " + result);
        return result;
    }

    @Override
    public float getSub(float i, float j) {
        float result = i - j;
        System.out.println("方法内部打印result = " + result);
        return result;
    }
}

（3）动态代理实现：创建MyProxyProvider.java，加入横切关注点（该类中有详细注释，介绍了几个横切关注点包括 前置通知、返回通知、异常通知、最终通知）

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

public class MyProxyProvider {

    //定义我们要执行的目标对象, 该对象需要实现SmartAnimalable
    private SmartAnimalable target_obj;

    //构造器
    public MyProxyProvider(SmartAnimalable target_obj) {
        this.target_obj = target_obj;
    }

    //方法, 可以返回代理对象，该代理对象可以执行目标对象
    public SmartAnimalable getProxy() {

        //1. 先到的类加载器/对象
        ClassLoader classLoader = target_obj.getClass().getClassLoader();

        //2. 得到要执行的目标对象的接口信息
        Class<?>[] interfaces = target_obj.getClass().getInterfaces();

        //3. 创建InvocationHandler
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object result = null;
                try {
                    System.out.println("方法执行前-日志-方法名-" + method.getName() + "-参数 "
                            + Arrays.asList(args)); //这里从AOP看，就是一个横切关注点-前置通知
                    //使用反射调用方法
                    result = method.invoke(target_obj, args);
                    System.out.println("方法执行正常结束-日志-方法名-" + method.getName() + "-结果result= "
                            + result);//从AOP看, 也是一个横切关注点-返回通知

                } catch (Exception e) {
                    e.printStackTrace();
                    //如果反射执行方法时，出现异常,就会进入到catch{}
                    System.out.println("方法执行异常-日志-方法名-" + method.getName()
                            + "-异常类型=" + e.getClass().getName());//从AOP看, 也是一个横切关注点-异常通知
                } finally {//不管你是否出现异常,最终都会执行到finally{}
                    //从AOP的角度看, 也是一个横切关注点-最终通知
                    System.out.println("方法最终结束-日志-方法名-" + method.getName());
                }

                return result;
            }
        };

        //创建代理对象
        SmartAnimalable proxy =
                (SmartAnimalable)Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
        return proxy;
    }
}

（4）测试代码：

@Test
public void smartDogTestByProxy() {

    SmartAnimalable smartAnimalable = new SmartDog();

    MyProxyProvider myProxyProvider =
            new MyProxyProvider(smartAnimalable);

    //我们返回了代理对象
    SmartAnimalable proxy =
            myProxyProvider.getProxy();

    proxy.getSum(10, 2);
    System.out.println("====================");
    proxy.getSub(10, 2);

}

（5）运行结果：

2 AOP 的基本介绍

概念：AOP 的全称(aspect oriented programming) ，面向切面编程

AOP 相关概念示意图

 AOP 实现方式

（1）基于动态代理的方式 [ 内置 aop 实现 ]，即前面动态代理案例所使用的方式
（2）使用框架 aspectj 来实现

3 AOP 编程快速入门

3.1 基本说明

（1）需要引入核心的 aspect 包（如果是maven项目，第一篇文章导入的依赖包含了该依赖项，这步可以省略）

（2）在切面类中声明通知方法

  • 前置通知：@Before
  • 返回通知：@AfterReturning
  • 异常通知：@AfterThrowing
  • 后置通知：@After
  • 环绕通知：@Around
五种通知和前面写的动态代理类方法的对应关系

3.2 快速入门案例

使用 aop 编程的方式，来实现手写的动态代理案例效果，就以上一个案例为例

（1）准备代码  SmartAnimalable.java，SmartDog.java 
public interface SmartAnimalable {
    //求和
    float getSum(float i, float j);
    //求差
    float getSub(float i, float j);
}
@Component
public class SmartDog implements SmartAnimalable {
    @Override
    public float getSum(float i, float j) {
        //System.out.println("日志-方法名-getSum-参数 " + i + " " + j);
        float result = i + j;
        System.out.println("方法内部打印result = " + result);
        //System.out.println("日志-方法名-getSum-结果result= " + result);
        return result;
    }

    @Override
    public float getSub(float i, float j) {
        //System.out.println("日志-方法名-getSub-参数 " + i + " " + j);
        float result = i - j;
        System.out.println("方法内部打印result = " + result);
        //System.out.println("日志-方法名-getSub-结果result= " + result);
        return result;
    }
}

（2）创建SmartAnimalAspect.java(该类有详细注释，介绍了AOP编程的详细步骤)

/**
 * 切面类 , 类似于我们以前自己写的MyProxyProvider,但是功能强大很多
 */
@Aspect //表示是一个切面类[底层切面编程的支撑(动态代理+反射+动态绑定...)]
@Component //会注入SmartAnimalAspect到容器
public class SmartAnimalAspect {
    //希望将showBeginLog方法切入到SmartDog-getSum前执行-前置通知
    /**
     * 1. @Before 表示前置通知:即在我们的目标对象执行方法前执行
     * 2. value = "execution(public float com.spring.aop.aspectj.SmartDog.getSum(float, float)
     * 指定切入到哪个类的哪个方法  形式是:访问修饰符 返回类型 全类名.方法名(形参列表)
     * 3. showBeginLog方法可以理解成就是一个切入方法, 这个方法名是可以程序员指定  比如:showBeginLog
     * 4. JoinPoint joinPoint 在底层执行时，由AspectJ切面框架， 会给该切入方法传入 joinPoint对象
     * , 通过该方法，程序员可以获取到 相关信息
     * @param joinPoint
     */
    @Before(value = "execution(public float com.spring.aop.aspectj.SmartDog.getSum(float, float))")
    public void showBeginLog(JoinPoint joinPoint) {
        //通过连接点对象joinPoint 可以获取方法签名
        Signature signature = joinPoint.getSignature();
        System.out.println("SmartAnimalAspect3-切面类showBeginLog()-方法执行前-日志-方法名-" + signature.getName() + "-参数 "
                + Arrays.asList(joinPoint.getArgs()));
    }

    //返回通知：即把showSuccessEndLog方法切入到目标对象方法正常执行完毕后的地方
    //1. 如果我们希望把目标方法执行的结果，返回给切入方法
    //2. 可以再 @AfterReturning 增加属性 , 比如 returning = "res",表示返回值
    //3. 同时在切入方法增加 Object res
    //4. 注意: returning = "res" 和 Object res 的 res名字一致
    @AfterReturning(value = "execution(public float com.spring.aop.aspectj.SmartDog.getSum(float, float))", returning = "res")
    public void showSuccessEndLog(JoinPoint joinPoint, Object res) {
        Signature signature = joinPoint.getSignature();
        System.out.println("SmartAnimalAspect3-切面类showSuccessEndLog()-方法执行正常结束-日志-方法名-" + signature.getName() + " 返回的结果是=" + res);
    }

    //异常通知：即把showExceptionLog方法切入到目标对象方法执行发生异常的的catch{}
    @AfterThrowing(value = "execution(public float com.spring.aop.aspectj.SmartDog.getSum(float, float))", throwing = "throwable")
    public void showExceptionLog(JoinPoint joinPoint, Throwable throwable) {
        Signature signature = joinPoint.getSignature();
        System.out.println("SmartAnimalAspect3-切面类showExceptionLog()-方法执行异常-日志-方法名-" + signature.getName() + " 异常信息=" + throwable);
    }

    //最终通知：即把showFinallyEndLog方法切入到目标方法执行后(不管是否发生异常,都要执行 finally{})
    @After(value = "execution(public float com.spring.aop.aspectj.SmartDog.getSum(float, float))")
    public void showFinallyEndLog(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("SmartAnimalAspect3-切面类showFinallyEndLog()-方法最终执行完毕-日志-方法名-" + signature.getName());
    }
}

（3）创建 beans07.xml 并配置

<context:component-scan base-package="com.spring.aop.aspectj"/>

<!--    开启基于注解的AOP功能-->
<aop:aspectj-autoproxy/>

（4）测试代码

@Test
public void smartDogTestByProxy(){
    ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("beans07.xml");
    SmartAnimalable bean = ioc.getBean(SmartAnimalable.class);
    System.out.println(bean.getClass());
    bean.getSum(1,2);
}

（5）运行结果

 3.3 细节说明

（1）切入表达式的更多配置，比如使用模糊配置，以下表示SmartDog类中的所有方法，都会被执行该前置通知方法

@Before(value="execution(* com.aop.proxy.SmartDog.*(..))")

（2）以下表示所有访问权限，所有包的下所有有类的所方法，都会被执行该前置通知方法 

@Before(value="execution(* *.*(..))")

（3）当 spring 容器开启了 <!-- 开启基于注解的 AOP 功能 --> <aop:aspectj-autoproxy/> , 我们获 取注入的对象, 需要以接口的类型来获取, 因为你注入的对象.getClass() 已经是代理类型了

注意：如果不加该配置，AOP编程不会生效

（4）当 spring 容器开启了 <!-- 开启基于注解的 AOP 功能 --> <aop:aspectj-autoproxy/> , 我们获 取注入的对象, 也可以通过 id 来获取, 但是也要转成接口类型

4 AOP-切入表达式

4.1 具体使用

4.1.1 作用

通过表达式的方式定位一个或多个具体的连接点。

4.1.2 语法细节

（1）语法

value = "execution([权限修饰符] [返回值类型] [简单类名/全类名].[方法名]([参数列表]))"

（2）举例说明

表达式：

value = "execution(* com.spring.ArithmeticCalculator.*(..))"

含义：

  • ArithmeticCalculator接口中声明的所有方法。
  • 第一个“*”代表任意修饰符及任意返回值。
  • 第二个“*”代表任意方法。
  • “..”匹配任意数量、任意类型的参数。
  • 若目标类、接口与该切面类在同一个包中可以省略包名。

表达式：

value = "execution(public * ArithmeticCalculator.*(..))"

含义：ArithmeticCalculator接口的所有公有方法

表达式：

value = "execution(public double ArithmeticCalculator.*(..))"

含义：ArithmeticCalculator 接口中返回 double 类型数值的公有方法

表达式：

value = "execution(public double ArithmeticCalculator.*(double,..)"

含义：ArithmeticCalculator 接口中返回 double 类型数值，第一个参数为 double 类型的公有方法。“..” 匹配任意数量、任意类型的参数。

表达式：

value = "execution(public double ArithmeticCalculator.*(double, double))"

含义：ArithmeticCalculator 接口中返回 double 类型数值，参数类型为 double,double类型的公有方法

4.1.3 “&&”、“Ⅱ”、“!”的使用

在AspectJ中，切入点表达式可以通过“&&”、“Ⅱ”、“!”等操作符结合起来。

表达式：

value = "execution(* *.add(int,.)) || execution(* *.sub(int,…))"

含义：

任意类中第一个参数为int类型的add方法或sub方法

4.1.4 注意事项和细节

（1）切入表达式也可以指向类的方法, 这时切入表达式会对该类/对象生效

（2）切入表达式也可以指向接口的方法, 这时切入表达式会对实现了接口的类/对象生效

（3）切入表达式也可以对没有实现接口的类，进行切入

5 AOP-JoinPoint

通过 JoinPoint 可以获取到调用方法的签名

JoinPoint对象常用方法：

joinPoint.getSignature().getName()：获取目标方法名
joinPoint.getSignature().getDeclaringType().getSimpleName()：获取目标方法所属类的简单类名
joinPoint.getSignature().getDeclaringTypeName()：获取目标方法所属类的类名
joinPoint.getSignature().getModifiers()：获取目标方法声明类型(public、private、protected)
Object[] args = joinPoint.getArgs()：获取传入目标方法的参数，返回一个数组
joinPoint.getTarget()：获取被代理的对象
joinPoint.getThis()：获取代理对象自己

6 AOP-返回通知获取结果

在返回通知方法获取返回结果

/**
 * returning = "res", Object res 名称保持一致
 * @param joinPoint
 * @param res 调用 getSum() 返回的结果
 */
@AfterReturning(value = "execution(public float com.spring.aop.joinpoint.SmartDog.getSum(float, float))", returning = "res")
public void showSuccessEndLog(JoinPoint joinPoint, Object res) {
    System.out.println("返回通知" + "--结果是--" + res );
}

7 AOP-异常通知中获取异常

如何在异常通知方法中获取异常信息。

@AfterThrowing(value = "execution(public float com.spring.aop.joinpoint.SmartDog.getSum(float, float))", throwing = "throwable")
public void showExceptionLog(JoinPoint joinPoint, Throwable throwable) {
    System.out.println("异常通知 -- 异常信息--" + throwable);
}

8 AOP-环绕通知

环绕通知可以完成其它四个通知要做的事情

注意：在环绕通知中一定要调用 joinPoint.proceed()来执行目标方法

@Around(value="execution(public float com.hspedu.spring.aop.aspectj.SmartDog.getSum(float, float))")
public Object doAround(ProceedingJoinPoint joinPoint) {
    Object result = null;
    String methodName = joinPoint.getSignature().getName();
    try {
        //1.相当于前置通知完成的事情
        Object[] args = joinPoint.getArgs();
        List<Object> argList = Arrays.asList(args);
        System.out.println("AOP 环绕通知--" + methodName + "方法开始了--参数有： " + argList);
        //在环绕通知中一定要调用 joinPoint.proceed()来执行目标方法
        result = joinPoint.proceed();
        //2.相当于返回通知完成的事情
        System.out.println("AOP 环绕通知" + methodName + "方法结束了--结果是：" + result);
    } catch (Throwable throwable) {
        //3.相当于异常通知完成的事情
        System.out.println("AOP 环绕通知" + methodName + "方法抛异常了--异常对象：" + throwable);
    } finally {
        //4.相当于最终通知完成的事情
        System.out.println("AOP 后置通知" + methodName + "方法最终结束了...");
    }
    return result;
}

9 AOP-切入点表达式重用

为了统一管理切入点表达式，可以使用切入点表达式重用技术。

/*
 * 这样定义的一个切入点表达式，就可以在其它地方直接使用
 */
@Pointcut(value = "execution(public float com.spring.aop.joinpoint.SmartDog.getSum(float, float))")
public void myPointCut() {
}

@Before(value = "myPointCut()")
public void showBeginLog(JoinPoint joinPoint) { //前置方法
    //得到方法的签名
    Signature signature = joinPoint.getSignature();
    //得到方法名. 
    String method_name = signature.getName();
    //得到参数
    Object[] args = joinPoint.getArgs();
    System.out.println("前置通知" + "--调用的方法是 " + method_name + "--参数是--" + Arrays.asList(args));
}

@After(value = "myPointCut()")
public void showFinallyEndLog() {
    System.out.println("最终通知 -- AOP-切入点表达式重用");
}

/**
 * returning = "res", Object res 名称保持一致
 * @param joinPoint
 * @param res 调用 getSum() 返回的结果
 */
@AfterReturning(value = "myPointCut()", returning = "res")
public void showSuccessEndLog(JoinPoint joinPoint, Object res) {
    System.out.println("返回通知" + "--结果是--" + res);
}
@AfterThrowing(value = "myPointCut()", throwing = "throwable")
public void showExceptionLog(JoinPoint joinPoint, Throwable throwable) {
    System.out.println("异常通知 -- 异常信息--" + throwable);
}

10 AOP-切面优先级问题

如果同一个方法，有多个切面在同一个切入点切入，那么执行的优先级如何控制.

基本语法:@order(value=n) 来控制 n 值越小，优先级越高(默认值很大，优先级很低)

@Aspect //表示这个类是一个切面类
@Order(value = 2)
@Component //需要加入 IOC 容器
public class SmartAnimalAspect2 {}

细节说明:

  • 不能理解成：优先级高的每个消息通知都先执行，这个和方法调用机制(和 Filter 过滤器链式调用类似)

11 AOP-基于 XML 配置 AOP

前面我们是通过注解来配置 aop 的，在 spring 中，我们也可以通过 xml 的方式来配置 AOP

案例：

在xml配置 SmartAnimalAspect.java 类为 SmartDog.java 的切入类

（1）准备代码martAnimalAspect.java、SmartDog.java，把注解全部去掉

public class SmartAnimalAspect {

    public void showBeginLog(JoinPoint joinPoint) {
        //通过连接点对象joinPoint 可以获取方法签名
        Signature signature = joinPoint.getSignature();
        System.out.println("SmartAnimalAspect3-切面类showBeginLog()-方法执行前-日志-方法名-" + signature.getName() + "-参数 "
                + Arrays.asList(joinPoint.getArgs()));
    }

    public void showSuccessEndLog(JoinPoint joinPoint, Object res) {
        Signature signature = joinPoint.getSignature();
        System.out.println("SmartAnimalAspect3-切面类showSuccessEndLog()-方法执行正常结束-日志-方法名-" + signature.getName() + " 返回的结果是=" + res);
    }

    public void showExceptionLog(JoinPoint joinPoint, Throwable throwable) {
        Signature signature = joinPoint.getSignature();
        System.out.println("SmartAnimalAspect3-切面类showExceptionLog()-方法执行异常-日志-方法名-" + signature.getName() + " 异常信息=" + throwable);
    }
    
    public void showFinallyEndLog(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("SmartAnimalAspect3-切面类showFinallyEndLog()-方法最终执行完毕-日志-方法名-" + signature.getName());
    }
}
public class SmartDog implements SmartAnimalable {
    @Override
    public float getSum(float i, float j) {
        //System.out.println("日志-方法名-getSum-参数 " + i + " " + j);
        float result = i + j;
        System.out.println("方法内部打印result = " + result);
        //System.out.println("日志-方法名-getSum-结果result= " + result);
        return result;
    }

    @Override
    public float getSub(float i, float j) {
        //System.out.println("日志-方法名-getSub-参数 " + i + " " + j);
        float result = i - j;
        System.out.println("方法内部打印result = " + result);
        //System.out.println("日志-方法名-getSub-结果result= " + result);
        return result;
    }
}

（2）配置xml文件

<!-- 配置 SmartAnimalAspect bean -->
<bean id="smartAnimalAspect" class="com.spring.aop.xml.SmartAnimalAspect"/>
<!--配置 SmartDog-->
<bean class="com.spring.aop.xml.SmartDog" id="smartDog"/>
<aop:config>
    <!-- 配置统一切入点 -->
    <aop:pointcut expression="execution(public float com.spring.aop.xml.SmartDog.getSum(float, float))"
                  id="myPointCut"/>
    <aop:aspect ref="smartAnimalAspect" order="1">
        <!-- 配置各个通知对应的切入点 -->
        <aop:before method="showBeginLog" pointcut-ref="myPointCut"/>
        <aop:after-returning method="showSuccessEndLog" pointcut-ref="myPointCut" returning="res"/>
        <aop:after-throwing method="showExceptionLog" pointcut-ref="myPointCut" throwing="throwable"/>
        <aop:after method="showFinallyEndLog" pointcut-ref="myPointCut"/>
        <!-- 还可以配置环绕通知 -->
        <!-- <aop:around method=""/> -->
    </aop:aspect>
</aop:config>

（3）测试代码

@Test
public void test1(){
    ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("beans08.xml");
    SmartAnimalable smartDog = ioc.getBean(SmartAnimalable.class);
    smartDog.getSum(1,1);
}

（4）运行结果

随遇而安622&508
关注
  • 19
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring框架学习笔记05：Spring AOP基础
howard2005的专栏
09-29 1009
文章目录一、Spring AOP概述1、AOP含义2、AOP作用3、AOP与OOP4、AOP使用方式二、采用配置方式使用AOP1、在net.hw.spring包里创建lesson05.aop_xml子包2、在aop_xml子包里创建杀龙任务类 - SlayDragonQuest3、在aop_xml子包里创建勇敢骑士类 - BraveKnight4、在aop_xml子包里创建游吟诗人类 - Minstrel5、创建Spring配置文件 一、Spring AOP概述 1、AOP含义 AOP: Aspect-O
Spring框架学习笔记6-AOP编程-AspectJ方式
White
10-12 722
4 AspectJ框架 4.1AspectJ框架简介 一个基于java的aop框架 在Spring2.0后增加了对AspectJ框架的支持。在Spring框架中建议使用AspectJ框架开发AOP. 4.1.1AspectJ框架中的通知类型 前面四个与spring aop框架相同。 前置通知before 后置通知afterReturning 环绕通知around 异常通知afterThrowing 最终通知after ：无论程序发生任何事情，都将执行 4.1.2Spring整合AspectJ框架所依赖的ja
2021-3-24：Spring框架学习笔记05：Spring AOP基础
Lydialhf的博客
03-24 152
Spring框架学习笔记05：Spring AOP基础 刚结束了Spring管理Bean的四种方式，现在我们进行新一阶段的学习，学习Spring AOP新知识。 Spring AOP概述 1、AOP含义 AOP: Aspect-Oriented Programming （面向切面编程） 2、AOP作用 软件开发原则：高内聚，低耦合。 Spring的AOP作用在于解耦。AOP让一组类共享相同的行为（比如事务管理、日志管理、安全管理）。OOP（Object-Oriented Programming）只能通过继承
Spring框架学习笔记
shmilyche的博客
05-10 418
一、Spring简介 1、概念 Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。 Spring提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。 2
框架Spring学习笔记（IOC，AOP）
v3424的博客
11-18 327
Spring学习Spring概述IOC学习1.1什么是IOC1.2IOC详解AOP学习1.1什么是AOP1.2AOP作用和优势1.3AOP相关术语1.4相关注解1.5切入点表达式 Spring概述 介绍：Spring框架是企业使用最多的框架，没有之一。Spring是一站式框架，称之为一站式框架的原因是Spring可以整合其他框架。 学习目标： Spring IoC：对象工厂及依赖注入； Spring AOP：面向切面编程技术，为Spring事务管理打下基础。 Spring Transaction mana
Spring学习笔记（一）Spring框架入门
weixin_72154059的博客
02-06 1432
1、 我们经常挂在口中的Spring指的是（Spring 框架）它是一个开源框架，有着活跃而庞大的社区。这就是它之所以能长久不衰的原因，Spring支持广泛的应用场景，它可以让Java企业级开发应用程序开更简单。2、Spring是由Rod Johnson组织和开发的一个分层的Java SE/EE一站式（full-stack）轻量级开源框架。它最为核心的理念是IoC（控制反转）和AOP（面向切面编程），其中，IoC是Spring的基础，它支撑着Spring对JavaBean的管理功能；
学习笔记：尚硅谷Spring6基础篇
D_boj的博客
08-14 1824
本章介绍，Spring6基础使用、Spring的IOC原理、Spring6整合日志框架、容器IOC、面向切面AOP以及依赖注入的方式、自动装配和依赖注入等
Spring框架【超详细学习笔记】
qq_51451731的博客
07-20 757
Spring学习整理，大家一起进步！！！
Spring个人学习笔记3（AOP）
qq_26641137的博客
05-15 817
Spring 框架AOP思想学习与复习
SpringAOP学习笔记
01-27
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性...
javaSpring学习笔记
03-12
在“Java Spring学习笔记”中，你将找到对Spring框架的全面介绍，包括IoC（控制反转）和DI（依赖注入）原理、AOP（面向切面编程）、Spring MVC、Spring Boot等核心内容。每个主题都结合了理论知识和实际示例，帮助你...
spring项目开发学习笔记
04-08
AOP面向切面编程：(可以在不修改源代码的前提下,增强权限,日志,事务功能)切面编程将业务逻辑从应用服务中分离 容器(spring)：管理dao,service,action,...包含并管理应用对象的生命周期和配置 框架：使用组件配置...
PL_Java_Spring框架_学习笔记.xmind
09-04
内容： Spring资源管理 Spring表达式语言 ...AOP切面编程-代理功能的加强 Spring与JMS消息组件 Spring与WebService Spring与Redis数据库 JDBC操作模板 Spring事务管理 SpringDataJPA SpringMVC SpringSecurity
SpringBoot学习笔记——AOP全局统一日志管理
12-21
一、前言 我们开发的Web系统都会有日志模块，用来...AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业
Diffusers代码学习-链式Inpainting
duhaining1976的博客
06-03 1023
AIGC研究及应用系列
Elixir学习笔记——二进制、字符串和字符列表
最新发布
chenxupest的专栏
06-04 697
在“基本类型”中，我们学习了一些关于字符串的知识，并使用 is_binary/1 函数进行检查："hello"true在本章中，我们将明确二进制到底是什么、它们与字符串的关系以及 Elixir 中单引号值“like this”的含义。虽然字符串是计算机语言中最常见的数据类型之一，但它们却非常复杂，经常被误解。要理解 Elixir 中的字符串，我们必须了解 Unicode 和字符编码，特别是 UTF-8 编码。
学习整理 docker
wonder_dog的博客
05-31 321
nexus。
超大功率光伏并网逆变器学习(三相) 一
我的博客
05-31 384
1.超大功率用的IGBT开关频率通常很低,比如6KHz。2.线电压和相电压的关系。
Spring框架的优点有支持AOP编程吗
05-11
是的，Spring框架支持AOP编程。AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它允许开发人员将横切关注点（如事务管理、安全性、日志记录等）从应用程序主逻辑中分离出来，以便更好地实现模块...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值