什么是spring，Ioc和Di的作用，如何简单使用sporing

xiao伟程序员

已于 2023-08-21 16:19:13 修改

阅读量198

点赞数

文章标签： spring sql java

于 2023-08-21 15:06:33 首次发布

本文链接：https://blog.csdn.net/lw12345118/article/details/132405891

版权

1.什么是Spring

Spring是一个开源的Java应用开发框架，它提供了一种轻量级的、非侵入性的编程方式，帮助开发人员构建可扩展、高效、模块化的企业级应用程序。Spring框架由多个模块组成，每个模块都可以独立使用或者与其他模块集成。其中最核心的模块是Spring Core，它提供了IoC（控制反转）和DI（依赖注入）的功能，使得对象之间的依赖关系更加松散、易于管理。

Spring框架还包括其他重要的模块，如Spring MVC用于构建Web应用程序，Spring Data用于简化数据库访问，Spring Security用于身份认证和授权，Spring AOP用于实现面向切面编程等。同时，Spring还提供了丰富的第三方整合和扩展，如与Hibernate、MyBatis等ORM框架的集成，与JPA、JMS、Redis等技术的无缝整合。

2.Spring作用是什么

简化开发：Spring提供了一种简洁、灵活的编程模型，通过IoC（控制反转）和DI（依赖注入）实现对象之间的解耦，降低了代码的复杂性，使得开发人员能够更加专注于业务逻辑的实现，而不需要关注底层的繁琐细节。
提高可测试性：Spring的IoC和DI机制使得应用程序的各个组件之间的依赖关系清晰明确，并且这些依赖关系可以通过配置文件进行管理。这样，在进行单元测试时，可以方便地使用Mock对象替代真实的依赖对象，从而隔离测试的影响范围，提高了代码的可测试性。
支持面向切面编程：Spring框架集成了AOP（面向切面编程），可以通过配置方式实现横切关注点的模块化，例如日志记录、事务管理、安全控制等。通过AOP，可以在不修改原有代码的情况下，将这些横切关注点与业务逻辑相分离，提高了代码的可维护性和可复用性。
整合其他技术和框架：Spring框架提供了与许多其他常用技术和框架的整合支持，如Hibernate、MyBatis等ORM框架、JPA、JMS等，使得在使用这些技术时能够更加方便地进行配置和集成。
提供企业级功能支持：Spring框架还提供了一系列的企业级功能模块，如事务管理、安全控制、远程调用、缓存管理等，这些功能模块可以帮助开发人员快速构建健壮、可靠的企业级应用程序。

3.什么是控制反转和依赖注入？

控制反转（Inversion of Control，IoC）和依赖注入（Dependency Injection，DI）是Spring框架的核心概念。

控制反转(IoC) 创建对象的控制权转移，是一种程序设计思想，脱离出来，创建对象不能自己创建了，这个功能Spring帮助你完成，你只需要配置好需要使用的Bean，使用就可以了，默认是单例的，使用映射映射的文件

依赖注入(DI) 将依赖的对象注入到需要的类中去，是"控制反转"设计思想的具体实现方式，简单来说就是在我们创建对象的过程中需要给类去添加属性和方法，使用控制反转，对象不能自己来创建了，依赖注入就是以配置的行驶去给我们初始化Bean

4.什么是AOP？

AOP（Aspect-Oriented Programming，面向切面编程）是一种软件开发中的编程范式。它通过将横切关注点（Cross-cutting Concerns）与业务逻辑相分离，以模块化的方式实现对系统的功能进行统一管理。

在传统的面向对象编程中，业务逻辑通常被分散在系统的各个模块中，而横切关注点（如日志记录、事务管理、安全控制等）则会涉及多个模块。这样使得代码的可读性、可维护性和复用性变差。AOP的出现解决了这个问题。

AOP框架负责将切面织入到目标对象中，生成代理对象，当目标对象的连接点被触发时，代理对象会执行相应的切面逻辑和业务逻辑。

AOP的优势在于它可以将横切关注点与业务逻辑解耦，提高代码的可维护性和复用性。通过AOP，可以避免在每一个模块中重复编写相同的代码，使得系统更加清晰、可扩展和易于维护。

5.AOP的核心思想是什么？

AOP的核心思想是通过将系统中的横切关注点（Cross-cutting Concerns）从主要业务逻辑中分离出来，以模块化的方式进行管理。

传统的面向对象编程中，业务逻辑通常被分散在系统的各个模块中，而横切关注点则会涉及多个模块，例如日志记录、事务管理、安全控制等。这样导致代码的可读性、可维护性和复用性较差。

AOP的核心思想是将横切关注点与业务逻辑相分离。它通过定义切面（Aspect），将横切关注点的逻辑封装在切面中。切面可以看作是一组跨越多个类的行为，在特定的连接点上执行特定的操作，比如方法的调用、异常的抛出等。

6.AOP有哪些增强处理类型及特点，如何使用

1.有哪些增强

前置增强（Before Advice）：在目标方法执行之前执行的增强处理。前置增强可以用于在方法执行前进行一些预处理操作，例如参数验证、权限检查等。
后置增强（After Advice）：在目标方法执行之后执行的增强处理。后置增强可以用于进行一些清理工作或记录日志等操作。
返回增强（After Returning Advice）：在目标方法成功执行并返回结果后执行的增强处理。返回增强可以获取目标方法的返回值，并进行相应的处理。
异常抛出增强（After Throwing Advice）：在目标方法抛出异常后执行的增强处理。异常抛出增强可以捕获目标方法抛出的异常，并进行相应的处理。
环绕增强（Around Advice）：围绕目标方法执行的增强处理，它可以在目标方法的前后都执行自定义的逻辑。环绕增强可以完全控制目标方法的执行过程，包括是否调用目标方法以及如何处理返回值和异常等。

2.不同类型的增强处理在执行时机和应用场景上有所区别：

前置增强适用于在目标方法执行前进行预处理操作。
后置增强适用于在目标方法执行后进行清理工作或记录日志等操作。
返回增强适用于获取目标方法的返回值并进行相应处理，例如修改返回结果或根据返回结果进行逻辑判断。
异常抛出增强适用于捕获目标方法抛出的异常，并进行异常处理或错误日志记录等操作。
环绕增强是最灵活的一种增强类型，可以在目标方法的前后都执行自定义的逻辑，可以完全控制目标方法的执行过程。

3.如何使用Aop

1.创建Aspect类，指定需要增强的代码

配置我们需要增强的哪个类，那个方法需要增强，增强只适用于删除修改新增时，查询不需要增强处理

@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("最终通知....");
    }
}

2.在配置文件中配置Aop

在头部添加Aop，给aop分配空间

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

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

">

在配置中开启增强，并且导入增强类指定增强

<aop:aspectj-autoproxy/>
<bean id="aspect" class="com.cskt.aspect.MyAspect"></bean>

7.使用Spring开发项目的步骤

1.下载Spring依赖，并引入到项目中

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.20</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjtools</artifactId>
        <version>1.9.5</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.19</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.3.10</version>
    </dependency>
</dependencies>

2.编写Spring配置文件applicationContext.xml

3.编写测试代码，在配置文件中配置Bean

@Data
public class User {
    private String name;
    private String word;

    public User(String name, String word) {
        this.name = name;
        this.word = word;
    }

    public void show(){
        System.out.println(name+"说"+word);
    }
    
}

给user类一个说话的能力，通过构造注入的方法配置在配置文件中

也可以使用setter方法注入

<bean id="user" class="com.cskt.pojo.User">
    <constructor-arg name="name" value=""/>
    <constructor-arg name="word" value=""/>
    <property name="name" value=""/>
    <property name="word" value=""/>
</bean>

4.编写测试类来测试数据

public class testUser {
    @Test
    public void testUser(){
        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = (User)ctx.getBean("user");
        user.show();
    }
}