Spring ioc和aop小结

最新推荐文章于 2024-07-25 11:59:12 发布
最新推荐文章于 2024-07-25 11:59:12 发布
阅读量1.1k 收藏
点赞数
文章标签： spring aop ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44231439/article/details/108719343
版权

IOC

什么是IOC

  • 控制反转，把对象创建和对象之间的调用过程交给Spring进行管理
  • 使用IOC的目的：为了降低耦合度

IOC底层原理

解析xml文件，获取bean标签的class属性，即全类名，通过反射获取到其Class对象，调用newInstance方法来创建一个对象。

IOC容器

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。

Spring提供IOC容器实现的两种方式（两个接口）

两个接口作用相似，都可以通过加载配置文件，通过对象工厂创建对象。不过两者有一定的区别。

  • BeanFactory

    IOC容器的基本实现，是Spring内部使用的接口，不提供开发人员进行使用。

    特点：延迟加载，调用的时候再创建对象。

  • ApplicationContext

    BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。 基本上所有场合都能直接用ApplicationContext。在加载配置文件时就会创建全部对象。

    Application的三个实现类：

    1. ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话加载不了
    2. FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件（必须要有访问权限)
    3. AnnotationConfigApplicationContext：他是用于读取注解注解配置容器的类

IOC操作Bean管理

什么是Bean管理

Bean管理指的是两个操作：1. Spring创建对象。2. Spring注入属性

在XML中Bean对象的三种创建方式

  • 通过调用无参构造器创建。如果类中没有无参构造器，就会创建失败。
  • 使用普通工厂中的成员方法创建对象。先注册Bean工厂，然后注册需要的Bean对象，通过factory-bean属性指定工厂，factory-method指定工厂中的方法，就能够创建Bean对象。
  • 使用工厂的静态方法创建对象。通过Bean标签的class属性指向工厂方法，factory-method指向静态方法，这样就可以获得一个Bean对象。相比于上面使用成员方法创建对象，可以少注册一个工厂的Bean对象。

Bean管理操作的两种方式

  • 基于xml配置文件方式实现
  • 基于注解方式实现
基于xml方式

  1. 基于xml方式创建对象

    <!--配置xx对象的创建-->
<bean id="xx" class="xx.xx.xx"/>
    • 在xml文件中，使用bean标签，标签里添加对应的属性，就可以实现对象创建
    • bean标签的常用属性
      • id属性：容器中的唯一标识，不允许重复
      • class属性：类全路径（包类路径）
    • 创建对象时候，默认是执行无参数构造方法完成对象创建

  2. 基于xml方式注入属性

    DI（Dependency Injection，依赖注入）： DI是IOC的一种具体实现，就是注入属性，有以下两种方式在xml中注入属性

    1. 使用set方法注入：使用bean标签的property属性进行注入。

      <bean class="com.me.pojo.Dog" id="dog">
        <property name="name" value="汪酱"/>
        <property name="weight" value="20"/>
    </bean>

    2. 使用有参构造注入属性

      <bean class="com.me.pojo.Dog" id="dog">
        <constructor-arg name="name" value="汪酱"/>
        <constructor-arg name="weight" value="20"/>
    </bean>
基于注解方式
  1. 基于注解创建对象，在类上加入注解@Component，@Service，@Controller，@Repository，可以自动在xml中创建相应的Bean实例。这四个注解的功能是完全一样的，名字不同可以快速确定当前这个类是什么类型的服务。
/*
  这里的value对应的是bean标签中的id属性，class属性会获取当前的类的包类路径。
  如果不加value属性，默认是首字母小写的类名
*/
@Service(value ="xxService")

  1. 基于注解方式实现属性注入

    • @Autowired

      根据属性类型进行注入，在属性上添加@Autowired后，可以不添加该属性的setter方法，因为该注解底层是通过反射进行注入了，并不需要走setter方法。

    • @Qualifier

      根据属性名称进行注入，可以与@Autowired注解一起使用。

    • @Resource

      可以根据类型注入，也可以根据名称注入

    • @Value

      用在成员属性上，给属性添加基本类型+String的值

Bean的作用域

通过bean标签中的scope管理Bean对象的作用域

  1. singleton（默认）：单例，在解析xml文件时创建，并全局唯一
  2. prototype：多例（原型），在调用getBean方法时创建对象，每个对象独立，互不干扰。
  3. request：作用于web应用的请求范围
  4. session：作用于web应用的会话范围

Bean的生命周期

生命周期：从对象创建到对象销毁的过程

Bean标签中有两个属性用于配置bean对象在生命周期的一些方法。

init-method=“”：配置初始化方法。

destroy-method=“”：配置销毁方法。

  1. 通过构造器创建Bean实例 bean（无参构造）
  2. 为bean的属性设置值和对其他bean的引用（调用set方法）
  3. 调用bean的初始化方法（需要配置init-method）
  4. bean可以使用了（对象获取到了）
  5. 当容器关闭时，调用bean的销毁方法（需要配置destroy-method）

单例对象的生命周期：与容器的生命的周期相同，容器创建就创建，容器销毁就销毁。

多例对象的生命周期：在被调用时创建，当无用时销毁。

Bean的自动装配

使用bean标签的autowire属性进行自动注入。

一般autowire常用属性有两个：

  1. byType ，根据对象类型进行自动注入，在xml搜索与当前bean中的属性的类型相同的bean，然后进行set注入。

  2. byName，根据name或者id进行查找，查找到与属性的属性名相同的bean时进行注入。

全注解开发

在Java类上使用注解@Configuration表明该Java类是Spring的配置类，用于替代xml配置文件，这样一来就可以不写xml文件。

关于在Junit中无法自动装配的问题

如果出现在Junit单元测试中使用@Autowired无法自动装配，完成以下步骤以可。

  1. 导入spring-test依赖，然后在Test类上加入注解@RunWith(SpringJUnit4ClassRunner.class)
  2. 加入注解@ContextConfiguration，来标明想要导入这个测试类的Bean。
  3. 如果使用的是xml文件作为配置，则使用@ContextConfiguration的locations属性，写入所有配置了Bean的xml文件。要注意xml文件中需要写component-scan标签，扫描所有的bean对象。
  4. 如果使用全注解开发，则使用classes属性添加作为配置的Java类。要注意使用@ComponentScan注解扫描Bean对象所在的位置。

AOP

什么是AOP

面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

通俗描述：不通过修改源代码的方式，在主干功能中添加一个新功能。

底层原理

AOP底层使用动态代理，有两种情况的动态代理

  1. 有接口情况，使用JDK动态代理，通过创建一个接口实现类的代理对象并加入额外的功能，最终完成功能的添加。
  2. 没有接口情况，使用CGLIB动态代理，通过继承创建一个子类的代理对象，加入额外的功能，最终完成功能的添加。

JDK动态代理

使用Proxy类（在java.lang.reflect中）里面的方法创建对象。通过调用里面的newProxyInstance方法返回指定接口的代理类的实例。方法有三个参数。

  1. 第一个参数是类加载器。可以通过调用对象的getClass方法获得Class对象，然后调用getClassLoader获得类加载器。
  2. 第二个参数是该类实现的接口。与上述步骤差不多，获得Class对象后，调用getInterfaces获取该类实现的接口。
  3. 第三个参数是InvocationHandler（接口），需要自己写一个其实现类，在里面完成功能的增强。

步骤

  1. 创建接口，定义方法

    public interface CalculateDao {
    int add(int a, int b);

    CalculateDao update(String id);
}

  2. 创建接口实现类，实现方法

    public class CalculateDaoImpl implements CalculateDao {
   @Override
    public int add(int a, int b) {
        System.out.println("add方法执行了");
        return a+b;
    }

    @Override
    public CalculateDao update(String id) {
        System.out.println("update方法执行了");
        System.out.println(id);
        return this;
    }
}

  3. 使用Proxy类创建接口代理对象前需要实现InvocationHandler

    class ProxyFactory implements InvocationHandler {
    private Object obj;

    /**
     * @param obj Object包容所有传进来对象
     */
    public ProxyFactory(Object obj) {
        this.obj = obj;
    }

    /**
     * @param proxy  代理对象信息
     * @param method 被调用的方法
     * @param args   方法传入的参数
     * @return 返回值
     * @throws Throwable 抛异常
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	    if ("update".equals(method.getName())) {
            method.invoke(obj, args);
            return proxy;
        }
        System.out.println("方法执行前....."+method.getName()+":传递的参数"+ Arrays.toString(args));
        Object result = method.invoke(obj, args);
        System.out.println("方法执行后....."+obj);
        return result;
    }
}

  4. 调用Proxy的newInstance方法创建代理对象

    CalculateDao cal = (CalculateDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), CalculateDaoImpl.class.getInterfaces(), new ProxyFactory(new CalculateDaoImpl()));
System.out.println("结果为："+cal.add(1, 5));
/*
控制台输出：
方法执行前.....add:传递的参数[1, 5]
add方法执行了
方法执行后.....
结果为：6
*/

关于Invoke方法中的第一个参数proxy

用法：可以在特定条件下让方法返回proxy，达到对该代理对象的连续调用。

注意事项：如果要返回proxy并连续调用，那么被调用的方法的返回值一定要是接口类型

//在Main方法中
CalculateDao cal = (CalculateDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), CalculateDaoImpl.class.getInterfaces(), new ProxyFactory(new CalculateDaoImpl()));
cal.update("13").update("12");
/*
结果为：
update方法执行了
13
update方法执行了
12
*/

AOP术语

  • 连接点

    类里面可以被增强的方法，这些方法被称为连接点。

  • 切入点

    实际被增强的方法被成为切入点。

  • 通知（增强）

    • 实际增强的逻辑部分成为通知（增强）

    • 通知有多种类型

      1. 前置通知( @Before ）

        在被增强的方法执行前会执行

      2. 后置通知( @AfterReturning )

        在被增强的方法执行后会执行，被增强方法出现异常后将不会执行

      3. 环绕通知( @Around )

        在被增强的方法执行的前后都会执行,环绕通知的写法比较特殊。环绕通知需要有返回值，并且与被增强方法的返回值一致。 如下所示。环绕通知可以做到其他4个通知的功能。

        @Around(value = "execution(* com.me.spring.aopwithannotation.User.add(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint){
        Object result = null;
        try {
            System.out.println("环绕前置");
            //proceed方法用于执行被增强的方法
            result= proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
            System.out.println("环绕后置");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return result;//其他通知获得的返回值就是环绕通知的返回值
    }

      4. 异常通知（ @afterThrowing）

        在被增强的方法出现异常时会执行

      5. 最终通知（@After）

        类似于java代码块的finally，无论是否出现异常，都会执行

  • 切面

    切面是通知和切入点的结合

  • 织入

    把切面应用到目标对象来创建新的代理对象的过程

AOP操作（准备）

Spring框架一般都是基于AspectJ实现AOP操作

什么是AspectJ

AspectJ不是Spring的组成部分，是一个独立的AOP框架。一般把AspectJ和Spring框架一起使用，进行AOP操作。

切入点表达式

execution([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]))

基于AspectJ实现AOP操作

基于注解方式实现（一般使用）

相同切入点的抽取，如下所示

//抽取了公共点以后，接下来的切入只需要在value值中写入pointCur()即可
@Pointcut(value = "execution(* com.me.spring.aopwithannotation.User.add(..))")
    public void pointCut(){ }

多个代理类同时对一个方法进行增强：

//每个代理类上都加上Order注解，里面的x为数字，代表优先级。数字越小，优先级越高
@Order(x)

  • 创建被增强类User

    @Component
public class User {
    public int add(int a, int b) {
        return a + b;
    }
}

  • 创建增强类UserProxy

    @Component
@Aspect
public class UserProxy {
    @Pointcut(value = "execution(* com.me.spring.aopwithannotation.User.add(int,int))")
    public void pointCut() {
    }

    @Before(value = "pointCut()")
    public void logStart(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("[" + signature.getName() + "]开始执行，参数为" + Arrays.asList(joinPoint.getArgs()));
    }

    @After(value = "pointCut()")
    public void logEnd(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("[" + signature.getName() + "]方法执行完成");
    }
    

    @AfterThrowing(value = "pointCut()", throwing = "exception")
    public void afterThrowing(JoinPoint joinPoint, Exception exception) {
        Signature signature = joinPoint.getSignature();
        System.out.println("[" + signature.getName() + "] 出现异常，异常信息为" + exception);
    }

    @AfterReturning(value = "pointCut()", returning = "result")
    public void logReturn(JoinPoint joinPoint, Object result) {
        Signature signature = joinPoint.getSignature();
        System.out.println("[" + signature.getName() + "]方法正常执行，结果为" + result);
    }
}

  • 配置xml文件

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:component-scan base-package="com.me.spring.aopwithannotation"/>
    <aop:aspectj-autoproxy/>
</beans>

  • 测试结果

    ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
User user = context.getBean("user", User.class);
user.add(1, 5);
/*
运行结果：
[add]开始执行，参数为[1, 5]
[add]方法正常执行，结果为6
[add]方法执行完成
*/
基于xml配置文件实现
<!--xml文件配置-->
<!--注册被增强类与增强类-->
    <bean id="user" class="com.me.spring.aopwithannotation.User"/>
    <bean id="userProxy" class="com.me.spring.aopwithannotation.UserProxy"/>
    <aop:config>
        <!--选择切入点-->
        <aop:pointcut id="addPoint" expression="execution(* com.me.spring.aopwithannotation.User.add(..))"/>
        <!--配置切面-->
        <aop:aspect ref="userProxy">
            <!--配置通知-->
            <aop:before method="logStart" pointcut-ref="addPoint"/>
            <aop:after-returning method="logReturn" pointcut-ref="addPoint" returning="result"/>
            <aop:after method="logEnd" pointcut-ref="addPoint"/>
        </aop:aspect>
    </aop:config>
入门复读机
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
将spring ioc和aop结合
01-29 726
通过以下两篇文章，便可以自己做一个aop和ioc的结合，并通过xml文件进行动态的配置 Spring 的aop实现原理：http://blog.csdn.net/lr222584/article/details/54755031 自己写一个简单的Spring IOC容器：http://blog.csdn.net/lr222584/article/details/54744583 包结
java代码中init method和destroy method的三种使用方式
热门推荐
程序员涂小哥的技术博客
12-12 4万+
在java的实际开发过程中，我们可能常常需要使用到init method和destroy method，比如初始化一个对象（bean）后立即初始化（加载）一些数据，在销毁一个对象之前进行垃圾回收等等。 周末对这两个方法进行了一点学习和整理，倒也不是专门为了这两个方法，而是在巩固spring相关知识的时候提到了，然后感觉自己并不是很熟悉这个，便好好的了解一下。 根据特意的去了解后，发现实际上可以有
Spring IOC及AOP学习总结
lantian0802的专栏
05-08 1829
一、Spring IOC体系学习总结： Spring中有两个容器体系，一类是BeanFactory、另一类是ApplicationContext。BeanFactory提供了基础的容器功能。ApplicationContext则是基于BeanFactory建立的一套更加丰富的容器体系，基于ApplicationContext构建了Spring AOP体系（基于AOP体系又构建了声明式事务
Spring之重点知识 IOC(控制反转)和AOP(面向切面编程)学习小结
我跌跌撞撞奔向你
03-13 288
Spring优点： 1.Spring是一个开源，免费的框架 2.Spring是一个轻量级的，非入侵式的框架（引入后不会改变原来的代码，只需要引入包即可。） 3.控制反转，面向切面编程 4.支持事务处理，支持对框架的整合 【重点一】IOC（控制反转）： 在Spring框架之前，我们在开发项目时，需要建立这么几个类，controller类，service接口，serviceImpl实现，dao接口类及dao实现类。当serviceImpl中使用dao操作数据库时，需要先new Dao() ，然后调用具体方法 来
谈谈自己对Spring中IOC和AOP的理解
lensen明
11-26 1035
Spring框架的核心思想主要是IOC和AOP的思想IOCIOC概念Spring中的IOCAOP新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 IOC IOC概念 所谓IOC即 Inversion Of Control--
Spring-对IOC和AOP的自我见解
Ara_Hu的博客
03-12 247
对于Spring，我们在学习它之前，就需要知道它的两大核心，IOC和AOP，博主就谈谈自己对这两大核心的看法和理解： IOC IOC，全称Inversion of Control，就是控制反转的意思，控制反转一种设计原则，它也是一种设计思想，可以用来降低代码之间的耦合度，在开发中，我们都追求“高内聚、低耦合”的代码，IOC就是对此问题的一种解决方式，Spring中的依赖注入（Dependency ...
Spring笔记和小结
07-28
它通过提供IoC（控制反转）和AOP（面向切面编程）等核心特性，简化了企业级应用的开发工作。在本笔记中，我们将探讨Spring框架的基础知识，并结合一个简单的过山车订购系统的例子来说明其应用。 首先，让我们来看看...
Java中Spring获取bean方法小结
09-02
在Java开发中，Spring框架是不可或缺的一部分，它提供了一个强大的依赖注入（DI）和面向切面编程（AOP）的容器。Spring的核心在于其BeanFactory和ApplicationContext，它们使得对象的管理和装配变得简单。这里我们将...
Spring框架小结
01-26
主要讲述aop、控制反转IOC的原理、以及spring的工作原理及流程
Spring 个人小结
09-25
spring 个人小结 ，工厂模式 源码解析 ，AOP ，IOC 隔离事务
Spring3.2小结
02-20
Spring是一个开源的Java框架，它旨在简化企业级应用程序的开发，通过提供一个容器来管理和配置对象，以及支持面向切面编程（Aspect-Oriented Programming，AOP）。 **控制反转（IoC）**： 控制反转是Spring的核心...
对Spring的IOC和AOP的思考
zzd的博客
07-08 98
往Spring的IOC容器中注册添加bean（java对象）的重要性在于：只有我们把这些组件（java对象）加入到Spring的容器中，我们才能使用Spring容器为我们提供的强大功能，比如AOP和声明式事务（我觉得声明式事务其实算是AOP的一个应用）。 所以说啊，Spring说白了就是两个内容，IOC和AOP。IOC把我们需要的java对象（组件）管理起来，然后通过AOP机制对这些被管理起来的java对象进行增强。 ...
Spring 的IOC和AOP总结
weixin_33935505的博客
01-04 153
Spring 的IOC和AOP IOC 1.IOC 许多应用都是通过彼此间的相互合作来实现业务逻辑的，如类A要调用类B的方法，以前我们都是在类A中，通过自身new一个类B，然后在调用类B的方法，现在我们把new类B的事情交给spring来做，在我们调用的时候，容器会为我们实例化。 IOC（DI）：其实这个Spring架构核心的概念没有这么复杂，更不像有些书上描述的那样晦涩。java程序员都...
Spring中IOC和AOP的详细解释
三也_攻城狮
08-29 8473
我们是在使用Spring框架的过程中，其实就是为了使用IOC，依赖注入，和AOP，面向切面编程，这两个是Spring的灵魂。 主要用到的设计模式有工厂模式和代理模式。 IOC就是典型的工厂模式，通过sessionfactory去注入实例。 AOP就是典型的代理模式的体现。 代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消
Spring学习总结—IOC和AOP
dukay2021的博客
08-10 290
1. 概述 1.1 简介 Spring 是分层的 full-stack（全栈） 轻量级开源框架，以 IoC 和 AOP 为内核，提供了展现层Spring MVC和业务层事务管理等众多的企业级应⽤技术，还能整合开源世界众多著名的第三⽅框架和类库，已经成为使⽤最多的 Java EE 企业应⽤开源框架。 1.2 核心结构 Spring框架是一个轻量级的解决方案，可以一站式地构建企业级应用。Spring是模块化的，所以可以只使用其中需要的部分。主要包括几大模块：数据处理模块、Web模块、AOP/Aspect
SpringCloud之使用 Nacos 实现高效购物车商品信息处理
Takumilove的博客
07-24 1171
通过上述步骤，我们成功实现了一个高效的购物车商品信息处理流程。使用 Nacos 来进行服务发现，并结合手写的负载均衡策略，确保了服务调用的高可用性和稳定性。这样不仅提升了系统的性能，还能给用户带来更好的购物体验。
SpringBoot添加密码安全配置以及Jwt配置
最新发布
qq_64468032的博客
07-25 872
然后修改之前的SecurityConfig配置类，里面的configure方法里面的.antMatchers里面追加的url是不需要验证就能进行使用的请求，比如登录注册等url请求的放开，需要的话可以一直追加。如果数据库中的密码没有加密，可以通过测试类将密码进行加密，然后用加密之后的字符串与数据库中的数据进行替换即可。通过以下操作可以直接从token中获取用户的信息，然后通过用户的信息进行验证并返回用户需要的信息。在没有配置的情况下，默认用户名为 user ，密码在控制台中查找（如下）。
Java面试八股之Spring容器的启动流程
u012151345的博客
07-23 1055
在整个过程中，Spring遵循了IoC（控制反转）和DI（依赖注入）原则，确保Bean的创建、配置、组装和管理都在容器的统一控制之下，实现了松耦合和可扩展的软件架构。创建BeanDefinition：解析配置信息的过程中，Spring会为每个Bean生成对应的BeanDefinition对象，它包含了Bean的类型、构造方法参数、属性值、初始化方法、依赖关系、作用域、生命周期回调方法等所有相关信息。Spring容器的启动流程涉及一系列有序的操作，以确保容器正确初始化并准备好管理应用程序中的Bean。
Spring Task详解
SRY12240419的博客
07-24 763
Spring Task是Spring框架提供的任务调度工具，可以按照约定的时间自动执行某个代码逻辑
SpringIOC和SpringAOP实验小结
05-27
好的，我来回答你的问题。 Spring IOC（Inversion of Control，控制反转）是一种设计模式，它可以帮助我们实现松耦合的代码结构。在Spring框架中，IOC容器负责管理对象的创建和依赖关系的注入，使得我们的代码更加灵活、可维护、可测试。 在实验中，我们学习了如何配置Spring IOC容器，包括使用XML配置文件、注解配置和Java配置。我们还学习了如何使用IOC容器，包括获取Bean对象、构造函数注入、属性注入和集合注入等。 Spring AOP（Aspect Oriented Programming，面向切面编程）是一种编程思想，它可以帮助我们实现横切关注点的复用。在Spring框架中，AOP模块提供了对切面的支持，我们可以通过配置切面和通知，来实现对目标方法的增强。 在实验中，我们学习了如何配置Spring AOP，包括使用XML配置文件和注解配置。我们还学习了AOP中常用的概念，包括切面、连接点、切点和通知等。最后，我们还实现了一个简单的AOP切面，来演示如何通过AOP实现日志记录。 以上就是我对SpringIOC和SpringAOP实验的小结，希望能对你有所帮助。如果你有其他问题，可以继续问我。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值