Spring—IOC与AOP

一.IOC（Inversion of Control，控制反转）介绍

        IOC（控制反转）是一种设计思想，其核心原则是将对象的创建、依赖关系的管理从应用程序代码中抽离出来，交给容器来负责。传统的开发方式中，对象的创建和依赖关系需要由开发者显式地在代码中进行处理，而采用IOC的方式，开发者只需通过配置文件或注解等方式描述对象的创建和依赖关系，容器会根据这些描述信息自动完成对象的创建和依赖注入。这样可以降低代码的耦合性，提高可维护性和可扩展性，使得应用程序更加灵活和易于测试。

实现IOC

        1.导入IOC相关的jar包

<dependencies>
    <!-- Spring Core：包含IOC容器的核心功能 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.10</version>
    </dependency>

    <!-- Spring Context：提供了应用程序上下文（ApplicationContext）的支持，包含了IOC容器的实现 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.10</version>
    </dependency>
</dependencies>

• spring-core：包含IOC容器的核心功能，提供了基础的依赖注入（DI）机制。
• spring-context：提供了应用程序上下文（ApplicationContext）的支持，是Spring IOC容器的具体实现。 

        2.创建 User_DemoMapper接口和对应的User_DemoMapperImpl实现类

public interface User_DemoMapper {
    public void show();
}



public class User_DemoMapperImpl implements User_DemoMapper{

    @Override
    public void show() {
        System.out.println("诸葛亮：我从未见过如此厚颜无耻之人");
    }
}

        3.编写Spring容器，applicationContext.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                                 
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 这里是配置内容 -->

    <bean id="user_demo" class="com.cskt.poji.User_Demo">
        <property name="name" value="猪脚亮说："></property>
        <property name="word" value="我从未见过如此厚颜无耻之人"></property>
    </bean>
    <bean id="userMapper" class="com.cskt.mapper.User_DemoMapperImpl"></bean>

    <bean id="userService" class="com.cskt.service.User_DemoServiceImpl">
        <property name="user_demoMapper" ref="userMapper"></property>
         <!--property标签表示配置当前bean的属性
        name属性表示配置哪一个具体的属性
        ref属性表示参照哪一个bean
        value属性表示赋值-->

    </bean>
</beans>

        4.编写一个测试类来使用Spring容器获取Bean并调用方法

public class testUser {

    @Test
    public void testUser_Demo(){
        ApplicationContext act=new ClassPathXmlApplicationContext("applicationContext.xml");
        User_Demo user_demo=(User_Demo) act.getBean("user_demo");
        System.out.println(user_demo.getName()+user_demo.getWord());
    }
}

        5.运行结果 

 

二. AOP(Aspect-Oriented Programming，面向切面编程)介绍

        AOP（面向切面编程）是一种编程思想，它的目的是将与核心业务逻辑无关的功能（例如日志记录、事务管理、权限控制等）从主要业务逻辑中分离出来，以便实现模块化和复用。在AOP中，通过定义切面（Aspect）和通知（Advice），可以在程序运行过程中自动地插入额外的行为。切面定义了在何处以及何时应用通知，通知则定义了具体的额外行为，可以包括在目标方法执行前、执行后或发生异常时执行的操作。AOP的好处是能够降低代码的重复性，提高代码的可维护性和可扩展性，使得关注点分离更加清晰。

实现AOP

        1.导入IOC相关的jar包

<dependencies>
    <!-- Spring AOP：包含AOP相关的功能和类库 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.3.10</version>
    </dependency>

    <!-- AspectJ Weaver：AspectJ的编织器，用于在运行时织入切面 -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.7</version>
    </dependency>
</dependencies>

                

• spring-aop：包含了Spring框架的AOP相关功能和类库。
• aspectjweaver：AspectJ的编织器，用于在运行时织入切面。

         2.定义一个切面类，用于在目标方法执行前后添加额外的行为

package com.cskt.aspect;

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

@Aspect
public class MyAspect {
    //前置增强  方法前面 执行  后置增强  环绕增强  异常增强  最终增强
    //切面 Aspect  Advice  beforeAdvice pointCut
    // 给那个方法增强 。。。。。，
   @Before("execution( * com.cskt.service..*.*(..))")
   public void before(){
       System.out.println("前置通知.... 在方法之前要執行的公共代码放在这里");
   }
    /**
     * 后置通知
     * returnVal,切点方法执行后的返回值
     */
    @AfterReturning(value="execution(* com.cskt.service..*.*(..)))",returning = "returnVal")
    public void AfterReturning(Object returnVal){
        System.out.println("后置通知...."+returnVal
        );
    }

    /**
     * 环绕通知
     * @param joinPoint 可用于执行切点的类
     *                  具体什么业务
     * @return
     * @throws Throwable
     */
    @Around("execution(* com.cskt.service..*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知前....");

        Object obj= (Object) joinPoint.proceed();

        System.out.println("环绕通知后....");
        return obj;
    }
    /**
     * 抛出通知
     * @param e
     */
    @AfterThrowing(value="execution(* com.cskt.service..*.*(..))",throwing = "e")
    public void afterThrowable(Throwable e){
        System.out.println("出现异常:msg="+e.getMessage());
    }

    /**
     * 无论什么情况下都会执行的方法
     */
    @After(value="execution(* com.cskt.service..*.*(..))")
    public void after(){
        //方法的对象的关闭
        //方法的回滚
        System.out.println("最终通知....");
    }
}

        3.编写Spring容器，applicationContext.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 http://www.springframework.org/schema/aop/spring-aop.xsd">
    
       <bean id="myAspect" class="com.cskt.aspect.MyAspect"/>
       <aop:aspectj-autoproxy/>
</beans>

        4.编写一个测试类来验证AOP的效果

 @Test
    public void tsetUserShow(){
        ApplicationContext apt=new ClassPathXmlApplicationContext("applicationContext.xml");
        User_DemoService userservice=(User_DemoService) apt.getBean("userService");
        userservice.show();
    }

        5.运行结果

        

        综上所述，IOC和AOP是Spring框架中两个重要的概念。IOC通过控制反转实现对象的解耦和依赖注入，AOP通过面向切面编程实现横切关注点的模块化和复用。它们的应用可以提高代码的可维护性、可测试性和可扩展性，使开发变得更加灵活和高效。