~ 小团子

Spring系列四：AOP切面编程

文章目录

AOP-官方文档
- AOP 讲解
- AOP APIs
动态代理
- 初始动态代理
- 动态代理深入
- AOP问题提出
- - 使用土方法解决
  - 对土方法解耦-开发最简单的AOP类
  - 土方法缺点
Spring AOP
- 基本介绍
- AOP编程快速入门
- 注意事项和细节
- 课后作业
- AOP-切入表达式
- - 注意事项和细节
- AOP-JoinPoint
- 返回通知获取结果
- 异常通知获取异常信息
- 环绕通知
- 切入点表达式重用
- 切面类执行顺序
- - 注意事项和细节
- 基于XML配置AOP
- 课后作业
引出对Spring底层实现再思考
- 创建maven项目
- 思考一: 原生Spring如何实现依赖注入和(singleton, prototype)
- 思考二: 原生Spring容器如何实现BeanPostProcessor
- 思考三: 原生Spring容器如何实现AOP
- 补充说明
Spring整体架构分析

上文中, 我们学习到了 Spring系列一：spring的安装与使用

接下来我们学习, AOP切面编程

AOP-官方文档

AOP 讲解

AOP 讲解: spring-framework-5.3.8\docs\reference\html/index.html

AOP APIs

**AOP APIs:** spring-framework-5.3.8\docs\javadoc-api\index.html ![在这里插入图片描述](https://img-blog.csdnimg.cn/56031cbcced5419294f23dfbd1e167f1.png) ![在这里插入图片描述](https://img-blog.csdnimg.cn/cb3261b47ad74389b4b7e18bd51b5014.png)

动态代理

初始动态代理

需求说明
1.由Vehicle (交通工具接口, 有一个run方法), 下面有两个类 Car 和 Ship
2.当运行Car对象的 run 方法和 ship对象的 run 方法时, 输入如下内容

交通工具开始运行了…
轮船在海上航行…
交通工具停止运行了…

交通工具开始运行了…
小汽车在路上跑…
交通工具停止运行了…

解决方案一: 传统方案

//接口, 该接口有run方法
public interface Vehicle {
    void run();
}

public class Car implements Vehicle{
    @Override
    public void run() {
        System.out.println("交通工具开始运行了....");
        System.out.println("小汽车在路上 running....");
        System.out.println("交通工具停止运行了....");
    }
}

public class Ship implements Vehicle{
    @Override
    public void run() {
        System.out.println("交通工具开始运行了....");
        System.out.println("大轮船在路上 running....");
        System.out.println("交通工具停止运行了....");
    }
}

public class TestVehicle {
    @Test
    public void run() {
        //OOP基础=>java基础
        Vehicle vehicle = new Ship();
        //动态绑定
        vehicle.run();
    }
}

来思考一下, 这个解决方案好吗? ====> 代码冗余, 其实就是单个对象的调用, 并没有很好的解决.

解决方案二: 动态代理方式
动态代理解决思路: 在调用方法时, 使用反射机制, 根据方法去决定调用哪个对象方法

public class VehicleProxyProvider {
    //定义一个属性
    //target_vehicle 表示真正要执行的对象
    //该对象实现了Vehicle接口
    private Vehicle target_vehicle;

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

    //编写一个方法, 可以返回一个代理对象
    //解读：
    //1.这个方法非常重要, 理解有一定难度
    //2.
    public Vehicle getProxy() {

        //得到类加载器
        ClassLoader classLoader =
                target_vehicle.getClass().getClassLoader();

        //得到要代理的对象/被执行对象 的接口信息, 底层是通过接口来完成调用
        Class<?>[] interfaces = target_vehicle.getClass().getInterfaces();

        //创建InvocationHandler 对象
        //因为 InvocationHandler 是接口, 所以我们可以通过匿名对象的方式来创建该对象
        /**
         * public interface InvocationHandler {
         *     public Object invoke(Object proxy, Method method, Object[] args)
         *          throws Throwable;
         * }
         * invoke 方法是将来执行target_vehicle的方法时, 会调用到
         */

        InvocationHandler invocationHandler = new InvocationHandler() {
            /*
                class VehicleProxyProvider$01 implements InvocationHandler {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("交通工具开始运行了....");
                        //这里是我们的反射基础 => OOP
                        Object result = method.invoke(target_vehicle, args);
                        System.out.println("交通工具停止运行了....");
                        return result;
                    }
                }
                InvocationHandler invocationHandler = new VehicleProxyProvider$01();
             */

            /**
             * invoke 方法是将来执行我们的target_vehicle的方法时, 会调用到
             *
             * @param proxy  表示代理对象
             * @param method 就是通过代理对象调用方法时, 的那个方法 代理对象.run()
             * @param args   表示调用 代理对象.run(xx) 传入的参数
             * @return 表示 代理对象.run(xx) 执行后的结果.
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("交通工具开始运行了....");
                //这里是我们的反射基础 => OOP
                //method 是 public abstract void com.zzw.spring.aop.proxy.Vehicle.run()
                //target_vehicle 是 Ship对象
                //args 是 null
                //这里通过反射+动态绑定机制, 就会执行到被代理对象的方法
                //执行完毕就返回
                Object result = method.invoke(target_vehicle, args);
                System.out.println("交通工具停止运行了....");
                return result;
            }
        };

        /*
            public static Object newProxyInstance(ClassLoader loader,
                                                  Class[] interfaces,
                                                  InvocationHandler h)
         解读
         1.Proxy.newProxyInstance() 可以返回一个代理对象
         2.ClassLoader loader: 类加载器,
         3.Class[] interfaces 就是将来要代理的对象的接口信息
         4.InvocationHandler h 调用处理器/对象, 有一个非常重要的方法invoke
        */
        Vehicle proxy =
                (Vehicle) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);

        return proxy;
    }
}

public class TestVehicle {

    @Test
    public void proxyRun() {
        //创建Ship对象
        Vehicle vehicle = new Ship();
        //创建VehicleProxyProvider对象, 并且我们传入的要代理的对象
        VehicleProxyProvider vehicleProxyProvider
                = new VehicleProxyProvider(new Car());

        //获取代理对象, 该对象可以代理执行方法
        //解读
        //1.proxy 编译类型Vehicle,
        //2.运行类型 是代理类型, 即 class com.sun.proxy.$Proxy8
        Vehicle proxy = vehicleProxyProvider.getProxy();

        System.out.println("proxy的编译类型是 Vehicle");
        System.out.println("proxy的运行类型是" + proxy.getClass());
        //下面解读/debug怎么执行到 代理对象的 public Object invoke(Object proxy, Method method, Object[] args)
        //梳理完毕, proxy的编译类型是Vehicle, 运行类型是Proxy  class com.sun.proxy.$Proxy8
        //所以当执行run方法时, 会执行到 代理对象的invoke
        //如果体现动态 [1.被代理的对象 2.方法]
        //proxy.run();
        String result = proxy.fly(10000);
        System.out.println("result=" + result);
        System.out.println("ok");

    }

debug

动态代理深入

需求说明
1.有一个SmartAnimal 接口, 可以完成简单的加减法, 要求在执行 getSum() 和 getSub() 时, 输出执行前, 执行过程, 执行后的日志结果. 输出内容如下:

日志-方法名-getSum-参数 1.5 4.5
方法内部打印result = 6.0
日志-方法名-getSum-结果result= 6.0
=================================
日志-方法名-getSub-参数 1.4 3.3
方法内部打印result = -1.9
日志-方法名-getSub-结果result= -1.9

解决方案一: 传统方案

public interface SmartAnimalAble {
    //求和
    float getSum(float i, float j);

    //求差
    float getSub(float i, float j);
}

public class SmartCat 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= " + (i + j));
        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= " + (i - j));
        return result;
    }
}

public class AopTest {
    @Test
    public void run() {
        SmartAnimalAble smartAnimalAble = new SmartCat();
        smartAnimalAble.getSum(1.5f, 4.5f);
        System.out.println("=================================");
        smartAnimalAble.getSub(1.4f, 3.3f);
    }
}

解决方案二: 动态代理方式
考虑代理对象调用方法(底层是反射调用)时, 可能出现的异常- [横切关注点]

//可以返回一个动态代理对象, 可以执行SmartCat对象的方法
public class MyProxyProvider {
    //这是一个属性, 是我们要执行的目标对象
    //该对象实现了SmartAnimal接口
    private SmartAnimalAble target_obj;

    //构造器
    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 {
                String name = method.getName();//方法名
                Object result = null;
                try {
                    System.out.println("方法执行前-日志-方法名-" + name + "-参数 "
                            + Arrays.asList(args));//这里从aop的角度看,就是一个横切关注点-前置通知
                    //使用反射调用方法
                    result = method.invoke(target_obj, args);
                    System.out.println("方法执行正常结束-日志-方法名-" + name + "-结果result= "
                            + result);//这里从aop的角度看, 也是一个横切关注点-返回通知
                    return result;
                } catch (Exception e) {
                    e.printStackTrace();
                    //如果反射执行方法时, 出现异常, 就会进入到catch{}
                    System.out.println("方法执行异常-日志-方法名-" + name + "-异常类型="
                            + e.getClass().getName());//这里从aop的角度看, 又是一个横切关注点-异常通知
                } finally {//不管你是否出现了异常, 最终都会执行到 finally {}
                    //这里从aop的角度看, 还是一个横切关注点-最终通知
                    System.out.println("方法最终结束-日志-方法名-" + name);
                }
                return result;
            }
        };

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

public class AopTest {

    @Test
    public void smartCatTestProxy() {
        //创建SmartCat对象
        SmartAnimalAble smartAnimalAble = new SmartCat();
        MyProxyProvider myProxyProvider
                = new MyProxyProvider(smartAnimalAble);
        //获取代理对象, 该对象可以代理执行方法
        SmartAnimalAble proxy = myProxyProvider.getProxy();

        System.out.println("proxy的编译类型是 SmartAnimalAble");
        System.out.println("proxy的运行类型是 " + proxy.getClass());
        //proxy的编译类型是SmartAnimal, 运行类型是 Class com.sun.proxy.$Proxy8
        //所以当执行getSum方法时, 会执行到 代理对象的invoke
        proxy.getSum(1.2f, 2.4f);
        System.out.println("=================================");
        proxy.getSub(1.3f, 4.5f);
        System.out.println("ok");
    }
}

AOP问题提出

在MyProxyProvider.java中, 我们的输出语句功能比较弱, 在实际开发中, 我们希望是以一个方法的形式, 嵌入到真正执行的目标方法前.

如图分析

使用土方法解决

1). 需求分析
使用土方法解决前面的问题, 后面使用Spring的AOP组件完成

2). 先建一个包, 把相关文件拷贝过来, 进行修改完成.

//我们的一个方法, 在目标对象执行前执行
public void before(Method method, Object[] args) {
    System.out.println("before方法执行前-日志-方法名-" + method.getName() + "-参数 "
            + Arrays.asList(args));//这里从aop的角度看,就是一个横切关注点-前置通知
}

//我们的一个方法, 在目标对象执行后执行
public void after(Method method, Object result) {
    System.out.println("after方法执行正常结束-日志-方法名-" + method.getName() + "-结果result= "
            + result);//这里从aop的角度看, 也是一个横切关注点-返回通知
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    String name = method.getName();//方法名
    Object result = null;
    before(method, args);
    //使用反射调用方法
    result = method.invoke(target_obj, args);
    after(method, result);
    return result;
}

3). 该方法问题分析: 耦合度高

对土方法解耦-开发最简单的AOP类

public class ZzwAOP {
    //我们的一个方法, 在目标对象执行前执行
    public static void before(Method method, Object[] args) {
        System.out.println("ZzwHsp-方法执行前-日志-方法名-" + method.getName() + "-参数 "
                + Arrays.asList(args));//这里从aop的角度看,就是一个横切关注点-前置通知
    }

    //我们的一个方法, 在目标对象执行后执行
    public static void after(Method method, Object result) {
        System.out.println("ZzwHsp-方法执行正常结束-日志-方法名-" + method.getName() + "-结果result= "
                + result);//这里从aop的角度看, 也是一个横切关注点-返回通知
    }
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    String name = method.getName();//方法名
    Object result = null;
    try {
        //before(method, args);
        ZzwAOP.before(method, args);

        //使用反射调用方法
        result = method.invoke(target_obj, args);

        //after(method, result);
        ZzwAOP.after(method, result);
        
        return result;
    } catch (Exception e) {
    }
}

土方法缺点

土方法不够灵活;
土方法复用性差;
土方法是一种硬编码 (因为没有注解和反射支撑)

Spring AOP 闪亮登场 - 底层是ASPECTJ

Spring AOP

基本介绍

什么是AOP
AOP的全称(aspect oriented programming), 面向切面编程.

第一张图

AOP实现方式
1.基于动态代理的方式 [内置aop实现]
2.使用框架aspectj来实现

AOP编程快速入门

●说明
1.需要引入核心的aspect包
2.在切面类中声明通知方法
1)前置通知: @Before
2)返回通知: @AfterReturning
3)异常通知: @AfterThrowing
4)后置通知: @After 最终通知
5)环绕通知: @Around

●需求说明
我们使用aop编程的方式, 来实现手写的动态代理案例效果, 以上一个案例为例进行讲解.

1.导入AOP编程需要的包

2.创建包spring/aop/aspect

package com.zzw.spring.aop.aspectj;

public interface SmartAnimalAble {
    //求和
    float getSum(float i, float j);

    //求差
    float getSub(float i, float j);
}

易错点: 不要引入别的包下的SmartAnimalAble, 要引入同包下的SmartAnimalAble

@Component //使用@Component 当spring容器启动时, 将 SmartDog 注入到容器
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;
    }
}

切面类, 类似于我们前面自己写的MyProxyProvider, 但是功能强大很多

@Aspect //表示是一个切面类[底层切面编程的支撑(动态代理+反射+动态绑定)]
@Component //会将SmartAnimalAspect注入到容器
public class SmartAnimalAspect {

    //希望将showBeginLog方法切入到SmartDog-getSum前执行-前置通知

    /**
     * 解读
     * 1. @Before 表示是前置通知, 即在我们的目标对象执行方法前执行
     * 2. value = "execution(public float com.zzw.spring.aop.aspectj.SmartDog.getSum(float, float))"
     * 指定切入到哪个类的哪个方法 形式是: 访问修饰符 返回类型 全类名.方法名(形参列表)
     * 3. showBeginLog方法可以理解成就是一个切入方法, 这个方法名是可以由程序员指定的 比如:showBeginLog
     * 4. JoinPoint joinPoint 在底层执行时, 由AspectJ切面编程框架, 会给该切入方法传入 joinPoint对象
     * , 通过该方法, 程序员可以获取到 相关信息
     * @param joinPoint
     */
    @Before(value = "execution(public float com.zzw.spring.aop.aspectj.SmartDog.getSum(float, float))")
    public void showBeginLog(JoinPoint joinPoint) {
        //通过连接点对象joinPoint, 可以获取方法签名
        Signature signature = joinPoint.getSignature();
        System.out.println("切面类showBeginLog()-方法执行前-日志-方法名-" + signature.getName() + "-参数 "
                + Arrays.asList(joinPoint.getArgs()));
    }

    //返回通知: 即把showSuccessEndLog方法切入到目标对象方法正常执行完毕后的地方
    @AfterReturning(value = "execution(public float com.zzw.spring.aop.aspectj.SmartDog.getSum(float, float))")
    public void showSuccessEndLog(JoinPoint joinPoint, Object res) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面类showSuccessEndLog()-方法执行正常结束-日志-方法名-" + signature.getName());
    }

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

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

新建beans08.xml


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

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

测试

public class AopAspectjTest {

    @Test
    public void smartDogTestByProxy() {

        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans08.xml");

        //这里我们需要通过接口类型来获取到注入的SmartDog对象-就是代理对象
        SmartAnimalAble smartAnimalAble =
                ioc.getBean(SmartAnimalAble.class);


        smartAnimalAble.getSum(1, 2);


        //System.out.println("smartAnimalAble运行类型是 " + smartAnimalAble.getClass());//class com.sun.proxy.$Proxy16
    }
}

注意事项和细节

1.关于切面类方法命名可以自己规范一下, 比如showBeginLog(), showSuccessEndLog(), showExceptionLog(), showFinallyEndLog()

2.切入表达式的更多配置, 比如使用模糊配置
@Before(value=“execution(* com.zzw.aop.proxy.SmartDog.*(…))”)

第一个\*表示: 任意修饰符和返回类型
第二个\*表示: 任意方法名
..表示: 任意形参列表

3.表示所有访问权限, 所有包下的所有类的所有方法, 都会被执行该前置通知方法
@Before(value=“execution(* *.*(…))”)

4.当spring容器开启了 基于注解的AOP功能 , 我们获取注入的对象, 需要以接口的类型来获取, 因为你注入的对象.getClass() 已经是代理类型了

5.当spring容器开启了 基于注解的AOP功能 , 我们获取注入的对象, 也可以通过id来获取, 但是也要转成接口类型.

//这里我们需要通过接口类型来获取到注入的SmartDog对象-就是代理对象
SmartAnimalAble smartAnimalAble = ioc.getBean(SmartAnimalAble.class);

//SmartAnimalAble smartAnimalAble = (SmartAnimalAble) ioc.getBean("smartDog");

课后作业

1.有接口 UsbInterface (方法 work)
2.实现子类 Phone 和 Camera 实现 UsbInterface
3.请在SmartAnimalAspect 切面类, 写一个方法(可输出日志信息作为前置通知, 在Phone和Camera对象执行work方法前调用
4.其它如返回通知, 异常通知, 后置通知, 也可以加入.

新建包 com.zzw.spring.aop.homework;

接口

public interface UsbInterface {
    void work(String name);
}

实现类

@Component //将Phone当作一个组件注入到容器中
public class Phone implements UsbInterface{
    @Override
    public void work(String name) {
        System.out.println(name + " 手机正在工作中....");
    }
}

@Component //将Camera对象注入到Spring容器
public class Camera implements UsbInterface{
    @Override
    public void work(String name) {
        System.out.println(name + " 相机正在工作中....");
    }
}

切面类

@Aspect
@Component
public class SmartAnimalAspect {
    //希望将showBeginLog切入到Phone/Camera-work() 前执行
    //前置通知
    //切入表达式也可以指向接口的方法, 这时切入表达式会对实现了接口的类/对象生效
    //比如下面我们是对UsbInterface切入, 那么对实现类 Phone/Camera 都生效
    //@Before(value = "execution(public void *.work(String))")
    @Before(value = "execution(public void com.zzw.spring.aop.homework.UsbInterface.work(String))")
    public void showBeginLog(JoinPoint joinPoint) {
        //通过连接点对象, 可以获取方法签名
        Signature signature = joinPoint.getSignature();
        System.out.println("切面类showBeginLog()-方法执行前-日志-方法名-" + signature.getName() + "-参数"
        + Arrays.asList(joinPoint.getArgs()));
    }

    //返回通知
    @AfterReturning(value = "execution(public void UsbInterface.work(String))")
    //@AfterReturning(value = "execution(public void com.zzw.spring.aop.homework.*.work(String))")
    public void showSuccessEndLog(JoinPoint joinPoint) {
        //通过连接点对象, 可以获取方法名
        Signature signature = joinPoint.getSignature();
        System.out.println("切面类showSuccessEndLog()-方法执行正常结束-日志-方法名-" + signature.getName());
    }

    //异常通知
    //@AfterThrowing(value = "execution(public void *.work(String))")
    @AfterThrowing(value = "execution(public void UsbInterface.work(String))")
    public void showExceptionLog(JoinPoint joinPoint) {
        //通过连接点对象, 可以获取方法名
        Signature signature = joinPoint.getSignature();
        System.out.println("切面类showExceptionLog()-方法执行异常-日志-方法名-" + signature.getName());
    }

    //后置通知
    //@After(value = "execution(public void *.work(String))")
    @After(value = "execution(public void UsbInterface.work(String))")
    public void showFinallyEndLog(JoinPoint joinPoint) {
        //通过连接点对象, 可以获取方法名
        Signature signature = joinPoint.getSignature();
        System.out.println("切面类showFinallyEndLog()-方法最终执行完毕-日志-方法名-" + signature.getName());
    }
}

beans09.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:context="http://www.springframework.org/schema/context"
       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/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

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

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

测试类

public class AspAspectjTest {
    public static void main(String[] args) {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans09.xml");

        UsbInterface phone = (UsbInterface) ioc.getBean("phone");
        phone.work("华为");

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

        UsbInterface camera = (UsbInterface) ioc.getBean("camera");
        camera.work("索尼");

        //System.out.println("phone的运行类型是" + phone.getClass());
    }
}

AOP-切入表达式

切入点表达式

1.作用
通过表达式的方式定位一个或多个具体的连接点

2.语法细节
    ①切入点表达式的语法格式
    execution([权限修饰符] [返回值类型] [简单类名/全类名] [方法名] (参数列表))
    ②举例说明

表达式	execution(* com.zzw.spring.aop.aspectj.SmartDog.*(..))
含义	如果SmartAnimalAble是接口, 则表示接口/类中声明的所有方法. 第一个 * 代表任意修饰符及任意返回值第二个 * 表示任意方法 .. 匹配任意数量, 任意类型的参数 (规定.的数量是2个) 若目标类, 接口与该切面类在同一个包中可以省略包名

表达式	execution(public * SmartDog.*(..))
含义	SmartDog 接口/类中的所有公有方法

表达式	execution(public double SmartDog.*(..))
含义	SmartDog 接口/类中返回double类型数值的方法

表达式	execution(public double SmartDog.*(double, ..))
含义	第一个参数为double类型的方法. ..匹配任意数量, 任意类型的参数

表达式	execution(public double SmartDog.*(double, double))
含义	参数类型为double, double类型的方法

表达式	execution(public double SmartDog.*(double, double))
含义	参数类型为double, double类型的方法

③在AspectJ中, 切入点表达式可以通过&&, ||, ! 等操作符结合起来

表达式	execution(* .add(int, ..)) \|\| execution( *.sub(int, ..))
含义	任意类中第一个参数为int类型的add方法或sub方法

注意事项和细节

1.切入表达式也可以指向类的方法, 这时切入表达式会对该类/对象生效
2.切入表达式也可以指向接口的方法, 这时切入表达式会对实现了接口的类/对象生效
3.切入表达式也可以对没有实现接口的类, 进行切入

@Component //把Car视为一个组件[对象], 注入到Spring容器
public class Car {
    public void run() {
        System.out.println("小汽车 run...");
    }
}

//切面类
@Aspect //表示是一个切面类
@Component //会将SmartAnimalAspect注入到容器
public class SmartAnimalAspect {
    //给Car配置一个前置通知
    @Before(value = "execution(public void Car.run())")
    public void ok1(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面类的ok1()-执行的目标方法-" + signature.getName());
    }
}

测试

public class AopAspectjTest {
    @Test
    public void test3() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans08.xml");

        Car car = ioc.getBean(Car.class);

        //说明: car对象仍然是代理对象
        System.out.println("car的运行类型=" + car.getClass());
        //car的运行类型=class com.zzw.spring.aop.aspectj.Car$$EnhancerBySpringCGLIB$$5e9a8b7a

        car.run();
    }
}

4.补充: 动态代理jdk的Proxy和Spring的CGlib

AOP-JoinPoint

1.通过JoinPoint可以获取到调用方法的签名
2.其他常用方法

@Aspect //表示是一个切面类
@Component //会将SmartAnimalAspect注入到容器
public class SmartAnimalAspect {
    //给Car配置一个最终通知
    @After(value = "execution(public void Car.run())")
    public void ok4(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();//获取代理对象自己       
    }
}

返回通知获取结果

切面类

@Aspect //表示是一个切面类[底层切面编程的支撑(动态代理+反射+动态绑定)]
@Component //会将SmartAnimalAspect注入到容器
public class SmartAnimalAspect {
    //返回通知: 即把showSuccessEndLog方法切入到目标对象方法正常执行完毕后的地方
    //解读
    //1.如果我们希望把目标方法, 执行的结果, 返回给切入方法
    //2.可以在 @AfterReturning 增加属性,  比如 returning = "res"
    //3.同时在切入方法增加 Object res
    //4.注意: returning = "res" 和 Object res 的 res名字一样
    @AfterReturning(value = "execution(public float com.zzw.spring.aop.aspectj.SmartDog.getSum(float, float))", returning = "res")
    public void showSuccessEndLog(JoinPoint joinPoint, Object res) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面类showSuccessEndLog()-方法执行正常结束-日志-方法名-" + signature.getName() + " 返回的结果是=" + res);
    }
}

异常通知获取异常信息

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

@Component //使用@Component 当spring容器启动时, 将 SmartDog 注入到容器
public class SmartDog implements SmartAnimalAble {
    @Override
    public float getSum(float i, float j) {
        float result = i + j;
        int res = 1 / 0;//模拟一个算数异常
        System.out.println("方法内部打印result = " + result);
        return result;
    }
}

切面类

@Aspect //表示是一个切面类[底层切面编程的支撑(动态代理+反射+动态绑定)]
@Component //会将SmartAnimalAspect注入到容器
public class SmartAnimalAspect {
    //异常通知: 即把showExceptionLog方法切入到目标对象方法执行发生异常后的catch{}
    @AfterThrowing(value = "execution(public float com.zzw.spring.aop.aspectj.SmartDog.getSum(float, float))", throwing = "throwable")
    public void showExceptionLog(JoinPoint joinPoint, Throwable throwable) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面类showExceptionLog()-方法执行异常-日志-方法名-" + signature.getName() + " 异常信息=" + throwable);
    }
}

环绕通知

需求: 如果使用环绕通知完成其它四个通知的功能.

新建SmartAnimalAspect2切面类, 并把SmartAnimalAspect切面类注解注释, 避免干扰; 去掉SmartDog的异常代码.

//切面类
@Aspect //表示是一个切面类[底层切面编程的支撑(动态代理+反射+动态绑定)]
@Component //会将SmartAnimalAspect注入到容器
public class SmartAnimalAspect2 {

    //演示环绕通知的使用
    //1. @Around 表示这是一个环绕通知[可以完成其它四个通知的功能]
    //2. (value = "execution(public float getSum(float, float))") 切入点表达式
    //3. doAround 表示要切入的方法 - 调用的基本结构 try-catch-finally
    @Around(value = "execution(public float com.zzw.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 {
            //相当于最终通知完成的事情
            System.out.println("AOP环绕通知[=最终通知]--" + methodName + "方法最终结束了...");
        }
        return result;
    }
}

测试

public class AopAspectjTest {
    @Test
    public void testDoAround() {
        //获取Spring容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans08.xml");

        SmartAnimalAble smartAnimalAble = ioc.getBean(SmartAnimalAble.class);

        smartAnimalAble.getSum(10, 2);
    }
}

结果

Connected to the target VM, address: '127.0.0.1:60160', transport: 'socket'
AOP环绕通知[=前置通知]--getSum方法开始了--参数有: [10.0, 2.0]
方法内部打印result = 12.0
AOP环绕通知[=返回通知]--getSum方法结束了--结果是: 12.0
AOP环绕通知[=最终通知]--getSum方法最终结束了...

切入点表达式重用

为了统一管理切入点表达式, 我们可以使用切入点表达式重用技术

对SmartAnimalAspect.java稍作修改

//切面类, 类似于我们前面自己写的MyProxyProvider, 但是功能强大很多
@Aspect //表示是一个切面类[底层切面编程的支撑(动态代理+反射+动态绑定)]
@Component //会将SmartAnimalAspect注入到容器
public class SmartAnimalAspect {

    //定义一个切入点, 在后面使用时可以直接引用, 提高了复用性
    @Pointcut(value = "execution(public float com.zzw.spring.aop.aspectj.SmartDog.getSum(float, float))")
    public void myPointCut() {

    }
 
    //@Before(value = "execution(public float com.zzw.spring.aop.aspectj.SmartDog.getSum(float, float))")
    //这里我们使用定义好的切入点
    @Before(value = "myPointCut()")
    public void showBeginLog(JoinPoint joinPoint) {
        //通过连接点对象joinPoint, 可以获取方法签名
        Signature signature = joinPoint.getSignature();
        System.out.println("切面类showBeginLog()[使用的myPointCut()]-方法执行前-日志-方法名-" + signature.getName() + "-参数 "
                + Arrays.asList(joinPoint.getArgs()));
    }

    //返回通知: 即把showSuccessEndLog方法切入到目标对象方法正常执行完毕后的地方
    //@AfterReturning(value = "execution(public float com.zzw.spring.aop.aspectj.SmartDog.getSum(float, float))", returning = "res")
    //使用切入点
    @AfterReturning(value = "myPointCut()", returning = "res")
    public void showSuccessEndLog(JoinPoint joinPoint, Object res) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面类showSuccessEndLog()-方法执行正常结束-日志-方法名-" + signature.getName() + " 返回的结果是=" + res);
    }

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

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

切面类执行顺序

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

●基本语法
import org.springframework.core.annotation.Order;
通过@order(value=n) 来控制. n值越小, 优先级越高

●代码
新建SmartAnimalAspect3.java, 将SmartAnimalAspect2.java注销, 保留SmartAnimalAspect.java

1.如果这两个类不加@order注解, 那么执行结果如下

SmartAnimalAspect-切面类showBeginLog()[使用的myPointCut()]-方法执行前-日志-方法名-getSum-参数 [1.0, 2.0]
SmartAnimalAspect3-切面类showBeginLog()-方法执行前-日志-方法名-getSum-参数 [1.0, 2.0]
方法内部打印result = 3.0
SmartAnimalAspect3-切面类showSuccessEndLog()-方法执行正常结束-日志-方法名-getSum 返回的结果是=3.0
SmartAnimalAspect3-切面类showFinallyEndLog()-方法最终执行完毕-日志-方法名-getSum
SmartAnimalAspect-切面类showSuccessEndLog()-方法执行正常结束-日志-方法名-getSum 返回的结果是=3.0
SmartAnimalAspect-切面类showFinallyEndLog()-方法最终执行完毕-日志-方法名-getSum

如果两个类加了@order注解

@Order(value = 2)//表示该切面类执行的顺序, value的值越小, 优先级越高
@Aspect
@Component 
public class SmartAnimalAspect {
	//内容省略
}

@Order(value = 1)//表示该切面类执行的顺序, value的值越小, 优先级越高
@Aspect
@Component 
public class SmartAnimalAspect3 {
	//内容省略
}

那么执行结果如下

SmartAnimalAspect3-切面类showBeginLog()-方法执行前-日志-方法名-getSum-参数 [1.0, 2.0]
SmartAnimalAspect-切面类showBeginLog()[使用的myPointCut()]-方法执行前-日志-方法名-getSum-参数 [1.0, 2.0]
方法内部打印result = 3.0
SmartAnimalAspect-切面类showSuccessEndLog()-方法执行正常结束-日志-方法名-getSum 返回的结果是=3.0
SmartAnimalAspect-切面类showFinallyEndLog()-方法最终执行完毕-日志-方法名-getSum
SmartAnimalAspect3-切面类showSuccessEndLog()-方法执行正常结束-日志-方法名-getSum 返回的结果是=3.0
SmartAnimalAspect3-切面类showFinallyEndLog()-方法最终执行完毕-日志-方法名-getSum

注意事项和细节

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

方法调用机制如下图所示

基于XML配置AOP

基本说明
前面我们是通过注解来配置aop的, 在spring中, 我们也可以通过xml的方式来配置AOP.

将SmartAnimalAble.java ,SmartDog.java 拷贝至 spring/aop/xml包下
注意: 不要引错包

切面类

//这是我们开发一个切面类, 但是不用注解, 而是使用xml配置
public class SmartAnimalAspect {

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

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

    public void showExceptionLog(JoinPoint joinPoint, Throwable throwable) {
        Signature signature = joinPoint.getSignature();
        System.out.println("SmartAnimalAspect[XML配置]-切面类showExceptionLog()-方法执行异常-日志-方法名-" + signature.getName() + " 异常信息=" + throwable);
    }

    public void showFinallyEndLog(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("SmartAnimalAspect[XML配置]-切面类showFinallyEndLog()-方法最终执行完毕-日志-方法名-" + signature.getName());
    }
}

beans09_2.xml


<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/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    
    
    <bean class="com.zzw.spring.aop.xml.SmartAnimalAspect" id="smartAnimalAspect"/>
    
    <bean class="com.zzw.spring.aop.xml.SmartDog" id="smartDog"/>
    
    <aop:config>
        
        <aop:pointcut id="myPointCut" expression="execution(public float com.zzw.spring.aop.xml.SmartDog.getSum(float, float))"/>
        
        <aop:aspect ref="smartAnimalAspect" order="10">
            
            <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:aspect>
    aop:config>
beans>

测试

public class AopAspectjXMLTest {

    @Test
    public void testAspectByXML() {
    
        ApplicationContext ioc =  new ClassPathXmlApplicationContext("beans09_2.xml");

        SmartAnimalAble smartAnimalAble = ioc.getBean(SmartAnimalAble.class);

        smartAnimalAble.getSum(1, 2);
    }
}

课后作业

1.请编写一个Cal接口
(1)方法 cal1(int n) 计算1 + 2 +...+ n
(2)方法 cal2(int n) 计算 1 * 2 *...* n

2.实现类 MyCal, 实现Cal的方法

3.请分别使用 注解方式 / XML配置方式 完成AOP编程
(1) 在执行cal1 前打印开始执行的时间, 执行完后打印结束的时间
(2) 在执行cal2 前打印开始执行的时间, 执行完后打印结束的时间

❶基于注解

接口

public interface Cal {
    //计算1+2+...+n
    int cal1(int n);

    //计算1*2*...*n
    int cal2(int n);
}

实现类

@Component
public class MyCal implements Cal{

    @Override
    public int cal1(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }

    @Override
    public int cal2(int n) {
        int res = 1;
        for (int i = 1; i <= n; i++) {
            res *= n;
        }
        return res;
    }
}

切面类

@Aspect //CalAspect是一个切面类
@Component //CalAspect作为对象, 注入到Spring容器
public class CalAspect {

    //注意: 如果目标类和切面类, 在同一个包, 可以省略包名
    //因为cal1和cal2方法, 都要去输出开始执行时间, 因此使用 MyCal.* 通配符
    @Pointcut(value = "execution(public int MyCal.*(int))")
    public void myPointCut() {

    }

    //前置通知
    @Before(value = "myPointCut()")
    public void calStart(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println(signature.getName() + " 执行, 开始执行时间=" + System.currentTimeMillis());
    }

    //返回通知
    @AfterReturning(value = "myPointCut()", returning = "res")
    public void calEnd(JoinPoint joinPoint, Object res) {
        Signature signature = joinPoint.getSignature();
        System.out.println(signature.getName() + " 执行结果=" + res);
        System.out.println(signature.getName() + " 执行, 结束时间=" + System.currentTimeMillis());
    }
}

beans10.xml


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

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

    
    <aop:aspectj-autoproxy/>
beans>

测试

public class AopAspectjTest {
    @Test
    public void test() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans10.xml");

        Cal cal = ioc.getBean(Cal.class);

        cal.cal1(10);
        System.out.println("====================================");
        cal.cal2(10);

    }
}

结果

cal1 执行, 开始执行时间=1691395310255
cal1 执行结果=55
cal1 执行, 结束时间=1691395310256
====================================
cal2 执行, 开始执行时间=1691395310256
cal2 执行结果=1410065408
cal2 执行, 结束时间=1691395310257

❷基于XML配置方法
接口

public interface Cal {
    //计算1+2+...+n
    int cal1(int n);

    //计算1*2*...*n
    int cal2(int n);
}

实现类

public class MyCal implements Cal{

    @Override
    public int cal1(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }

    @Override
    public int cal2(int n) {
        int res = 1;
        for (int i = 1; i <= n; i++) {
            res *= ;
        }
        return res;
    }
}

切面类

public class CalAspect {

    //前置通知
    public void calStart(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println(signature.getName() + " 执行[基于XML配置], 开始执行时间=" + System.currentTimeMillis());
    }

    //返回通知
    public void calEnd(JoinPoint joinPoint, Object res) {
        Signature signature = joinPoint.getSignature();
        System.out.println(signature.getName() + " 执行结果=" + res);
        System.out.println(signature.getName() + " 执行[基于XML配置], 结束时间=" + System.currentTimeMillis());
    }
}

beans11.xml


<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 class="com.zzw.spring.aop.homework02.xml.CalAspect" id="calAspect"/>
    
    <bean class="com.zzw.spring.aop.homework02.xml.MyCal" id="myCal"/>
    
    <aop:config>
        
        <aop:pointcut id="myPointCut" expression="execution(public int com.zzw.spring.aop.homework02.xml.MyCal.*(int))"/>
        
        <aop:aspect ref="calAspect" order="10">
            
            <aop:before method="calStart" pointcut-ref="myPointCut"/>
            
            <aop:after-returning method="calEnd" pointcut-ref="myPointCut" returning="res"/>
        aop:aspect>
    aop:config>
beans>

测试

public class AopAspectjXMLTest {
    @Test
    public void testMyCalByXML() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans11.xml");

        Cal cal = ioc.getBean(Cal.class);

        cal.cal1(10);
        System.out.println("====================================");
        cal.cal2(10);
    }
}

结果

cal1 执行[基于XML配置], 开始执行时间=1691396329275
cal1 执行结果=55
cal1 执行[基于XML配置], 结束时间=1691396329275
====================================
cal2 执行[基于XML配置], 开始执行时间=1691396329275
cal2 执行结果=1410065408
cal2 执行[基于XML配置], 结束时间=1691396329275

引出对Spring底层实现再思考

创建maven项目

1.创建maven项目

2.加入依赖

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0modelVersion>

  <groupId>com.zzwgroupId>
  <artifactId>zzw-springartifactId>
  <version>1.0-SNAPSHOTversion>

  <dependencies>
    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>5.3.8version>
    dependency>
    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-aspectsartifactId>
      <version>5.3.8version>
    dependency>
  dependencies>
project>

2.项目目录结构, 文件夹对应不上的可以自己添加或删除.

//就是一个Controller
//也可以使用 @Controller
在默认情况下, 我们配置@Component,@Repository,@Controller,@Service 是单例
@Component
public class UserAction { 

}

//也可以使用 @Repository
@Component
public class UserDao {
    public void hi() {
        System.out.println("UserDao hi()...");
    }
}

//也可以使用 @Service
@Component
public class UserService {

    //也可以使用 @Resource
    @Autowired
    private UserDao userDao;//定义一个属性

    public void m1() {
        userDao.hi();
    }
}

src目录下创建beans.xml


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

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

beans>

测试1

public class AppMain {
    public static void main(String[] args) {

        //测试/看看是否可以得到spring容器中的bean, 同时看看依赖注入是否OK
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");

        UserAction userAction = ioc.getBean("userAction", UserAction.class);
        UserAction userAction2 = ioc.getBean("userAction", UserAction.class);

        System.out.println("userAction=" + userAction);
        System.out.println("userAction2=" + userAction2);

        UserDao userDao = ioc.getBean("userDao", UserDao.class);
        System.out.println("userDao=" + userDao);

        UserService userService = ioc.getBean("userService", UserService.class);
        System.out.println("userService=" + userService);
    }
}

报错: Caused by: java.io.FileNotFoundException: class path resource [beans.xml] cannot be opened because it does not exist, 其错误原因是

实际上 beans.xml 应该在 src/main/resources 下创建


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

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

beans>

此时项目结构图如下所示:

运行结果

userAction=com.zzw.spring.component.UserAction@679b62af
userAction2=com.zzw.spring.component.UserAction@679b62af
userDao=com.zzw.spring.component.UserDao@5cdd8682
userService=com.zzw.spring.component.UserService@d6da883

思考一: 原生Spring如何实现依赖注入和(singleton, prototype)

1.Spring底层如何实现: IOC容器创建和初始化
2.Spring底层如何实现: 根据 singleton, prototype来返回bean对象

案例注入默认是单例注入, 标识了注解@Scope(value = "prototype")后代表多例

//在默认情况下, 我们配置@Component,@Repository,@Controller,@Service 是单例
//@Scope(value = "prototype") 表示以多例形式, 返回 UserAction bean
//多例是懒加载
//思考: Spring容器底层如何实现
@Component
@Scope(value = "prototype")
public class UserAction {

}

测试2

public class AppMain {
    public static void main(String[] args) {

        //测试/看看是否可以得到spring容器中的bean, 同时看看依赖注入是否OK
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");

        UserAction userAction = ioc.getBean("userAction", UserAction.class);
        UserAction userAction2 = ioc.getBean("userAction", UserAction.class);

        System.out.println("userAction=" + userAction);
        System.out.println("userAction2=" + userAction2);

        UserDao userDao = ioc.getBean("userDao", UserDao.class);
        System.out.println("userDao=" + userDao);

        UserService userService = ioc.getBean("userService", UserService.class);
        System.out.println("userService=" + userService);

        //测试一下当前的依赖注入
        userService.m1();
    }
}

运行结果

userAction=com.zzw.spring.component.UserAction@60bd273d
userAction2=com.zzw.spring.component.UserAction@121314f7
userDao=com.zzw.spring.component.UserDao@130c12b7
userService=com.zzw.spring.component.UserService@5e600dd5
UserDao hi()...

思考二: 原生Spring容器如何实现BeanPostProcessor

//编写一个后置处理器
public class MyBeanProcessor implements BeanPostProcessor {

    /**
     * 在Bean的 init初始化方法前调用
     *
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization() 被调用... " + beanName + " bean=" + bean.getClass());
        return bean;
    }

    /**
     * 在Bean的 init初始化方法后调用
     *
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization() 被调用... " + beanName + " bean=" + bean.getClass());
        return bean;
    }
}

@Component
public class UserService {

    @Autowired
    private UserDao userDao;

    public void m1() {
        userDao.hi();
    }

    //这里我们需要指定init() 是初始化方法
    @PostConstruct
    public void init() {
        System.out.println("UserService init()...");
    }
}


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

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

    
    <bean class="com.zzw.spring.process.MyBeanProcessor" id="myBeanProcessor"/>
beans>

测试3

public class AppMain {
    public static void main(String[] args) {

        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");

        UserAction userAction = ioc.getBean("userAction", UserAction.class);
        UserAction userAction2 = ioc.getBean("userAction", UserAction.class);

        System.out.println("userAction=" + userAction);
        System.out.println("userAction2=" + userAction2);

        UserDao userDao = ioc.getBean("userDao", UserDao.class);
        System.out.println("userDao=" + userDao);

        UserService userService = ioc.getBean("userService", UserService.class);
        System.out.println("userService=" + userService);

        //测试一下当前的依赖注入
        //userService.m1();
    }
}

运行结果

postProcessBeforeInitialization() 被调用... userDao bean=class com.zzw.spring.component.UserDao
postProcessAfterInitialization() 被调用... userDao bean=class com.zzw.spring.component.UserDao
postProcessBeforeInitialization() 被调用... userService bean=class com.zzw.spring.component.UserService
UserService init()...
postProcessAfterInitialization() 被调用... userService bean=class com.zzw.spring.component.UserService
postProcessBeforeInitialization() 被调用... userAction bean=class com.zzw.spring.component.UserAction
postProcessAfterInitialization() 被调用... userAction bean=class com.zzw.spring.component.UserAction
postProcessBeforeInitialization() 被调用... userAction bean=class com.zzw.spring.component.UserAction
postProcessAfterInitialization() 被调用... userAction bean=class com.zzw.spring.component.UserAction
userAction=com.zzw.spring.component.UserAction@1ffaf86
userAction2=com.zzw.spring.component.UserAction@6574a52c
userDao=com.zzw.spring.component.UserDao@6c1a5b54
userService=com.zzw.spring.component.UserService@1c7696c6

拿掉UserAction的@Scope(value = “prototype”)注解, 运行结果如下

postProcessBeforeInitialization() 被调用... userAction bean=class com.zzw.spring.component.UserAction
postProcessAfterInitialization() 被调用... userAction bean=class com.zzw.spring.component.UserAction
postProcessBeforeInitialization() 被调用... userDao bean=class com.zzw.spring.component.UserDao
postProcessAfterInitialization() 被调用... userDao bean=class com.zzw.spring.component.UserDao
postProcessBeforeInitialization() 被调用... userService bean=class com.zzw.spring.component.UserService
UserService init()...
postProcessAfterInitialization() 被调用... userService bean=class com.zzw.spring.component.UserService
userAction=com.zzw.spring.component.UserAction@71a794e5
userAction2=com.zzw.spring.component.UserAction@71a794e5
userDao=com.zzw.spring.component.UserDao@76329302
userService=com.zzw.spring.component.UserService@5e25a92e

知识点: 基于注解的方式配置后置处理器(别忘了扫描包)

//编写一个后置处理器
@Component
public class MyBeanProcessor implements BeanPostProcessor {

    /**
     * 在Bean的 init初始化方法前调用
     *
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization() 被调用... " + beanName + " bean=" + bean.getClass());
        return bean;
    }

    /**
     * 在Bean的 init初始化方法后调用
     *
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization() 被调用... " + beanName + " bean=" + bean.getClass());
        return bean;
    }
}


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.zzw.spring.component"/>
    <context:component-scan base-package="com.zzw.spring.process"/>
beans>

思考三: 原生Spring容器如何实现AOP

//接口
public interface SmartAnimalAble {

    float getSum(float i, float j);

    float getSub(float i, float j);
}

@Component
public class SmartDog implements SmartAnimalAble{
    public float getSum(float i, float j) {
        float res = i + j;
        System.out.println("SmartDog getSum() 结果=" + res);
        return res;
    }

    public float getSub(float i, float j) {
        float res = i - j;
        System.out.println("SmartDog getSub() 结果=" + res);
        return res;
    }
}

//这是一个切面类
@Aspect
@Component
public class SmartAnimalAspect {

    //给SmartDog配置前置, 返回, 异常, 最终通知

    //前置通知
    @Before(value = "execution(public float com.zzw.spring.aop.SmartDog.getSum(float, float))")
    public void showBeginLog(JoinPoint joinPoint) {
        //通过连接点对象joinPoint, 可以获取方法签名
        Signature signature = joinPoint.getSignature();
        System.out.println("SmartAnimalAspect-切面类showBeginLog()-方法执行前-日志-方法名-" + signature.getName() + "-参数 "
                + Arrays.asList(joinPoint.getArgs()));
    }

    //返回通知: 即把showSuccessEndLog方法切入到目标对象方法正常执行完毕后的地方
    @AfterReturning(value = "execution(public float com.zzw.spring.aop.SmartDog.getSum(float, float))", returning = "res")
    public void showSuccessEndLog(JoinPoint joinPoint, Object res) {
        Signature signature = joinPoint.getSignature();
        System.out.println("SmartAnimalAspect-切面类showSuccessEndLog()-方法执行正常结束-日志-方法名-" + signature.getName() + " 返回的结果是=" + res);
    }

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

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


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

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

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

    
    <bean class="com.zzw.spring.process.MyBeanProcessor" id="myBeanProcessor"/>
beans>

测试4

public class AppMain {
    public static void main(String[] args) {

        //测试/看看是否可以得到spring容器中的bean, 同时看看依赖注入是否OK
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");

        UserAction userAction = ioc.getBean("userAction", UserAction.class);
        UserAction userAction2 = ioc.getBean("userAction", UserAction.class);

        System.out.println("userAction=" + userAction);
        System.out.println("userAction2=" + userAction2);

        UserDao userDao = ioc.getBean("userDao", UserDao.class);
        System.out.println("userDao=" + userDao);

        UserService userService = ioc.getBean("userService", UserService.class);
        System.out.println("userService=" + userService);

        //测试一下当前的依赖注入
        userService.m1();

        //测试一下AOP
        SmartAnimalAble smartDog = ioc.getBean(SmartAnimalAble.class);
        System.out.println(smartDog.getSum(1,2));
    }
}

运行结果

postProcessBeforeInitialization() 被调用... userAction bean=class com.zzw.spring.component.UserAction
postProcessAfterInitialization() 被调用... userAction bean=class com.zzw.spring.component.UserAction
postProcessBeforeInitialization() 被调用... userDao bean=class com.zzw.spring.component.UserDao
postProcessAfterInitialization() 被调用... userDao bean=class com.zzw.spring.component.UserDao
postProcessBeforeInitialization() 被调用... userService bean=class com.zzw.spring.component.UserService
UserService init()...
postProcessAfterInitialization() 被调用... userService bean=class com.zzw.spring.component.UserService
postProcessBeforeInitialization() 被调用... smartAnimalAspect bean=class com.zzw.spring.aop.SmartAnimalAspect
postProcessAfterInitialization() 被调用... smartAnimalAspect bean=class com.zzw.spring.aop.SmartAnimalAspect
postProcessBeforeInitialization() 被调用... smartDog bean=class com.zzw.spring.aop.SmartDog
postProcessAfterInitialization() 被调用... smartDog bean=class com.sun.proxy.$Proxy16
userAction=com.zzw.spring.component.UserAction@26ceffa8
userAction2=com.zzw.spring.component.UserAction@26ceffa8
userDao=com.zzw.spring.component.UserDao@600b90df
userService=com.zzw.spring.component.UserService@7c8c9a05
UserDao hi()...
SmartAnimalAspect-切面类showBeginLog()-方法执行前-日志-方法名-getSum-参数 [1.0, 2.0]
SmartDog getSum() 结果=3.0
SmartAnimalAspect-切面类showSuccessEndLog()-方法执行正常结束-日志-方法名-getSum 返回的结果是=3.0
SmartAnimalAspect-切面类showFinallyEndLog()-方法最终执行完毕-日志-方法名-getSum
3.0

简析Spring AOP 和 BeanPostProcessor关系

1.AOP实现Spring可以通过给一个类, 加入注解 @EnableAspectJAutoProxy 来指定

2.追一下@EnableAspectJAutoProxy的源码

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AspectJAutoProxyRegistrar.class}) 
public @interface EnableAspectJAutoProxy {
    boolean proxyTargetClass() default false;

    boolean exposeProxy() default false;
}

    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry); 
        AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy != null) {
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }

            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }

    @Nullable
    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {
        return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source); 
    }

3.看一下AnnotationAwareAspectJAutoProxyCreator的类图

4.解读
1)AOP底层是基于BeanPostProcessor机制的.
2)即在Bean创建好后, 根据是否需要AOP处理, 决定返回代理对象, 还是原生Bean
3)在返回代理对象时, 就可以根据要代理的类和方法来返回
4)机制并不难, 本质就是BeanPostProcessor机制 + 动态代理技术

补充说明

后置处理器	SmartDog类型
postProcessBeforeInitialization()	class com.zzw.spring.aop.SmartDog
postProcessAfterInitialization()	class com.sun.proxy.$Proxy16

为何: SmartDog 在 postProcessBeforeInitialization() 中类型是普通类型, 在postProcessAfterInitialization()中成了代理类型.
其本质原因在: SmartAnimalAspect类是一个切面类, 并且对SmartDog中的方法做了切入, 所以后置处理器处理成了代理对象.

Spring整体架构分析

下乘: Spring系列五：手动实现Spring底层机制, 未完待续…

你可能感兴趣的:(Spring5,spring)

SpringBlade dict-biz/list 接口 SQL 注入漏洞文章永久免费只为良心 oracle 数据库
SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
spring如何整合druid连接池？惜.己 spring spring junit 数据库 java idea 后端 xml
目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
springboot+vue项目实战一-创建SpringBoot简单项目苹果酱0567 面试题汇总与解析 spring boot 后端 java 中间件开发语言
这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
Spring MVC 全面指南：从入门到精通的详细解析一杯梅子酱技术栈学习 spring mvc java
引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
Spring Boot中实现跨域请求 BABA8891 spring boot 后端 java
在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmq rabbitmq java
重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException 屿小夏 java 开发语言
文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗? 瑞金彭于晏 spring boot 后端 java MVC spring 数据库
SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
spring mvc @RequestBody String类型参数 zoyation spring-mvc spring mvc
通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
Java -jar 如何在后台运行项目 vincent_hahaha
撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
spring security中几大组件的作用和执行顺序阿信在这里 java spring
springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
探索Zebra4J：构建高效企业级Web应用的微服务框架叶准鑫Natalie
探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台网顺技术团队成品程序项目 java vue.js 汽车课程设计 spring boot
基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
分布式锁和spring事务管理暴躁的鱼锁及事务分布式 spring java
最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
Java面试笔记记录6 今天背八股了吗 java 面试笔记
1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
Sentinel 眼泪落在琴弦 springcloud java java
Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
Spring @Async 深度解读：默认线程池执行器的配置与优化小码快撩 spring java 前端
在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
Sentinel实时监控不展示问题朱杰jjj sentinel sentinel
问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
36. MyBatis如何支持多数据库操作？如何配置不同的数据源？这孩子叫逆 Mybatis笔记 mybatis 数据库
在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
SpringBoot整合ES搜索引擎实现网站热搜词及热度计算码踏云端 springboot Elasticsearch spring boot elasticsearch 后端热搜词热度计算 java
博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
Spring Security静态资源过滤（11）小黑屋说YYDS spring
在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
Spring Security定义多个过滤器链（10）小黑屋说YYDS spring
在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
java 技术架构相关文档圣心 java 架构开发语言
在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
SpringSecurity初学总结 weixin_66442229 spring
springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
java获取applicationcontext,SpringBoot获取ApplicationContext的3种方式花儿街参考
ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能。ApplicationContext获取的几种方式1直接使用Autowired注入@ComponentpublicclassBook1{@AutowiredprivateApplicationContextapplicationContext;pub
SpringBoot 设置传入参数非必要 loveLifeLoveCoding springboot spring boot java spring
查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
SpringBoot 获取 ApplicationContext loveLifeLoveCoding springboot spring boot java spring
1.概念ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能2.获取ApplicationContext的方式2.1.创建工具类通过此工具类，可以方便的获取bean组件,获取配置信息等importorg.springframework.beans.BeansException;importorg.spr
java打印标签（机型TOSHIBA条码打印机B-EX4T）  嘘  JAVA java
java打印标签实现方式标签效果代码获取更多相关资料实现rfid写入功能实现方式打印机设置网络ipjava获取socket连接，调用TPCL指令标签效果代码packageorg.jeecg.modules.invinfo.util;importorg.jeecg.modules.invinfo.vo.BatKcInventoryDetailVo;importorg.springframework.
web前段跨域nginx代理配置刘正强 nginx cms Web
nginx代理配置可参考server部分 server { listen 80; server_name localhost;
spring学习笔记 caoyong spring
一、概述 a>、核心技术 : IOC与AOP b>、开发为什么需要面向接口而不是实现接口降低一个组件与整个系统的藕合程度，当该组件不满足系统需求时，可以很容易的将该组件从系统中替换掉，而不会对整个系统产生大的影响 c>、面向接口编口编程的难点在于如何对接口进行初始化,(使用工厂设计模式)
Eclipse打开workspace提示工作空间不可用 0624chenhong eclipse
做项目的时候，难免会用到整个团队的代码，或者上一任同事创建的workspace， 1.电脑切换账号后，Eclipse打开时，会提示Eclipse对应的目录锁定，无法访问，根据提示，找到对应目录，G:\eclipse\configuration\org.eclipse.osgi\.manager，其中文件.fileTableLock提示被锁定。解决办法，删掉.fileTableLock文件，重
Javascript 面向对面写法的必要性？一炮送你回车库 JavaScript
现在Javascript面向对象的方式来写页面很流行，什么纯javascript的mvc框架都出来了：ember 这是javascript层的mvc框架哦,不是j2ee的mvc框架我想说的是，javascript本来就不是一门面向对象的语言，用它写出来的面向对象的程序，本身就有些别扭，很多人提到js的面向对象首先提的是：复用性。那么我请问你写的js里有多少是可以复用的，用fu
js array对象的迭代方法换个号韩国红果果 array
1.forEach 该方法接受一个函数作为参数，对数组中的每个元素使用该函数 return 语句失效 function square(num) { print(num, num * num); } var nums = [1,2,3,4,5,6,7,8,9,10]; nums.forEach(square); 2.every 该方法接受一个返回值为布尔类型
对Hibernate缓存机制的理解归来朝歌 session 一级缓存对象持久化
在hibernate中session一级缓存机制中，有这么一种情况：问题描述：我需要new一个对象，对它的几个字段赋值，但是有一些属性并没有进行赋值，然后调用 session.save()方法，在提交事务后，会出现这样的情况： 1：在数据库中有默认属性的字段的值为空 2：既然是持久化对象，为什么在最后对象拿不到默认属性的值？通过调试后解决方案如下：对于问题一，如你在数据库里设置了
WebService调用错误合集 darkranger webservice
Java.Lang.NoClassDefFoundError: Org/Apache/Commons/Discovery/Tools/DiscoverSingleton 调用接口出错，一个简单的WebService import org.apache.axis.client.Call;import org.apache.axis.client.Service; 首先必不可
JSP和Servlet的中文乱码处理 aijuans Java Web
JSP和Servlet的中文乱码处理前几天学习了JSP和Servlet中有关中文乱码的一些问题，写成了博客，今天进行更新一下。应该是可以解决日常的乱码问题了。现在作以下总结希望对需要的人有所帮助。我也是刚学，所以有不足之处希望谅解。一、表单提交时出现乱码：在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以
面试经典六问 atongyeye 工作面试
题记：因为我不善沟通，所以在面试中经常碰壁，看了网上太多面试宝典，基本上不太靠谱。只好自己总结，并试着根据最近工作情况完成个人答案。以备不时之需。以下是人事了解应聘者情况的最典型的六个问题： 1 简单自我介绍关于这个问题，主要为了弄清两件事，一是了解应聘者的背景，二是应聘者将这些背景信息组织成合适语言的能力。我的回答：(针对技术面试回答，如果是人事面试，可以就掌
contentResolver.query()参数详解百合不是茶 android query()详解
收藏csdn的博客,介绍的比较详细,新手值得一看 1.获取联系人姓名一个简单的例子，这个函数获取设备上所有的联系人ID和联系人NAME。 [java] view plain copy public void fetchAllContacts() {
ora-00054:resource busy and acquire with nowait specified解决方法 bijian1013 oracle 数据库 kill nowait
当某个数据库用户在数据库中插入、更新、删除一个表的数据，或者增加一个表的主键时或者表的索引时，常常会出现ora-00054:resource busy and acquire with nowait specified这样的错误。主要是因为有事务正在执行（或者事务已经被锁），所有导致执行不成功。 1.下面的语句
web 开发乱码征客丶 spring Web
以下前端都是 utf-8 字符集编码一、后台接收 1.1、 get 请求乱码 get 请求中，请求参数在请求头中；乱码解决方法： a、通过在web 服务器中配置编码格式：tomcat 中，在 Connector 中添加URIEncoding="UTF-8"； 1.2、post 请求乱码 post 请求中，请求参数分两部份， 1.2.1、url？参数，
【Spark十六】： Spark SQL第二部分数据源和注册表的几种方式 bit1129 spark
Spark SQL数据源和表的Schema case class apply schema parquet json JSON数据源准备源数据 {"name":"Jack", "age": 12, "addr":{"city":"beijing&
JVM学习之:调优总结 -Xms -Xmx -Xmn -Xss BlueSkator -Xss -Xmn -Xms -Xmx
堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置： java -Xmx355
jqGrid 各种参数详解(转帖) BreakingBad jqGrid
jqGrid 各种参数详解分类：源代码分享个人随笔请勿参考解决开发问题 2012-05-09 20:29 84282人阅读评论(22) 收藏举报 jquery 服务器 parameters function ajax string
读《研磨设计模式》-代码笔记-代理模式-Proxy bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /* * 下面
应用升级iOS8中遇到的一些问题 chenhbc ios8 升级iOS8
1、很奇怪的问题，登录界面，有一个判断，如果不存在某个值，则跳转到设置界面，ios8之前的系统都可以正常跳转，iOS8中代码已经执行到下一个界面了，但界面并没有跳转过去，而且这个值如果设置过的话，也是可以正常跳转过去的，这个问题纠结了两天多，之前的判断我是在 -(void)viewWillAppear:(BOOL)animated 中写的，最终的解决办法是把判断写在 -(void
工作流与自组织的关系？ comsci 设计模式工作
目前的工作流系统中的节点及其相互之间的连接是事先根据管理的实际需要而绘制好的，这种固定的模式在实际的运用中会受到很多限制，特别是节点之间的依存关系是固定的，节点的处理不考虑到流程整体的运行情况，细节和整体间的关系是脱节的，那么我们提出一个新的观点，一个流程是否可以通过节点的自组织运动来自动生成呢？这种流程有什么实际意义呢？这里有篇论文，摘要是：“针对网格中的服务
Oracle11.2新特性之INSERT提示IGNORE_ROW_ON_DUPKEY_INDEX daizj oracle
insert提示IGNORE_ROW_ON_DUPKEY_INDEX 转自：http://space.itpub.net/18922393/viewspace-752123 在 insert into tablea ...select * from tableb中，如果存在唯一约束，会导致整个insert操作失败。使用IGNORE_ROW_ON_DUPKEY_INDEX提示，会忽略唯一
二叉树:堆 dieslrae 二叉树
这里说的堆其实是一个完全二叉树,每个节点都不小于自己的子节点,不要跟jvm的堆搞混了.由于是完全二叉树,可以用数组来构建.用数组构建树的规则很简单: 一个节点的父节点下标为: (当前下标 - 1)/2 一个节点的左节点下标为: 当前下标 * 2 + 1 &
C语言学习八结构体 dcj3sjt126com c
为什么需要结构体，看代码 # include <stdio.h> struct Student //定义一个学生类型，里面有age, score, sex, 然后可以定义这个类型的变量 { int age; float score; char sex; } int main(void) { struct Student st = {80, 66.6,
centos安装golang dcj3sjt126com centos
#在国内镜像下载二进制包 wget -c http://www.golangtc.com/static/go/go1.4.1.linux-amd64.tar.gz tar -C /usr/local -xzf go1.4.1.linux-amd64.tar.gz #把golang的bin目录加入全局环境变量 cat >>/etc/profile<
10.性能优化-监控-MySQL慢查询 frank1234 性能优化 MySQL慢查询
1.记录慢查询配置 show variables where variable_name like 'slow%' ; --查看默认日志路径查询结果：--不用的机器可能不同 slow_query_log_file=/var/lib/mysql/centos-slow.log 修改mysqld配置文件：/usr /my.cnf[一般在/etc/my.cnf，本机在/user/my.cn
Java父类取得子类类名 happyqing java this 父类子类类名
在继承关系中，不管父类还是子类，这些类里面的this都代表了最终new出来的那个类的实例对象，所以在父类中你可以用this获取到子类的信息！ package com.urthinker.module.test; import org.junit.Test; abstract class BaseDao<T> { public void
Spring3.2新注解@ControllerAdvice jinnianshilongnian @Controller
@ControllerAdvice，是spring3.2提供的新注解，从名字上可以看出大体意思是控制器增强。让我们先看看@ControllerAdvice的实现： @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Component public @interface Co
Java spring mvc多数据源配置 liuxihope spring
转自：http://www.itpub.net/thread-1906608-1-1.html 1、首先配置两个数据库 <bean id="dataSourceA" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close&quo
第12章 Ajax（下） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
BW / Universe Mappings blueoxygen BO
BW Element OLAP Universe Element Cube Dimension Class Charateristic A class with dimension and detail objects (Detail objects for key and desription) Hi
Java开发熟手该当心的11个错误 tomcat_oracle java 多线程工作单元测试
#1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目可以在属性文件中配置，那么使它成为
推行国产操作系统的优劣 yananay windows linux 国产操作系统
最近刮起了一股风，就是去“国外货”。从应用程序开始，到基础的系统，数据库，现在已经刮到操作系统了。原因就是“棱镜计划”，使我们终于认识到了国外货的危害，开始重视起了信息安全。操作系统是计算机的灵魂。既然是灵魂，为了信息安全，那我们就自然要使用和推行国货。可是，一味地推行，是否就一定正确呢？先说说信息安全。其实从很早以来大家就在讨论信息安全。很多年以前，就据传某世界级的网络设备制造商生产的交

Spring系列四：AOP切面编程

文章目录

AOP-官方文档

AOP 讲解

AOP APIs

动态代理

初始动态代理

动态代理深入

AOP问题提出

使用土方法解决

对土方法解耦-开发最简单的AOP类

土方法缺点

Spring AOP

基本介绍

AOP编程 快速入门

注意事项和细节

课后作业

AOP-切入表达式

注意事项和细节

AOP-JoinPoint

返回通知获取结果

异常通知获取异常信息

环绕通知

切入点表达式重用

切面类执行顺序

注意事项和细节

基于XML配置AOP

课后作业

引出对Spring底层实现再思考

创建maven项目

思考一: 原生Spring如何实现依赖注入和(singleton, prototype)

思考二: 原生Spring容器如何实现BeanPostProcessor

思考三: 原生Spring容器如何实现AOP

补充说明

Spring整体架构分析

你可能感兴趣的:(Spring5,spring)

AOP编程快速入门