学习Spring的第一天 —— IoC，DI，AOP

我是烧饼

已于 2023-08-21 16:46:18 修改

阅读量49

点赞数 1

文章标签：学习 spring java

于 2023-08-21 16:30:52 首次发布

本文链接：https://blog.csdn.net/m0_74363146/article/details/132407057

版权

1.什么是Spring框架？

Spring框架是一个用于构建企业级Java应用程序的开源框架。它提供了一套全面的解决方案，包括依赖注入、面向切面编程、事务管理、数据访问、Web开发等功能。

以下是Spring框架的主要组件：

核心容器（Core Container）：包含了Spring框架的核心功能，例如依赖注入（Dependency Injection）和控制反转（Inversion of Control）。这些功能使得应用程序的各个组件可以松散耦合，便于测试和维护。
AOP（Aspect-Oriented Programming）：提供了面向切面编程的支持，可以将横切关注点（如日志记录、安全性等）从业务逻辑中抽离出来，以模块化的方式进行管理。
数据访问（Data Access）：包括对数据库的访问、事务管理等功能。Spring提供了对多种数据访问技术的支持，如JDBC、ORM框架（如Hibernate、MyBatis）等。
Web开发（Web Development）：Spring提供了用于开发Web应用程序的一系列功能，包括MVC框架、RESTful服务支持、文件上传、页面模板引擎等。
测试（Testing）：Spring框架提供了测试相关的支持，如集成测试、单元测试等。

除了上述核心组件外，Spring框架还提供了很多扩展模块，如Spring Security（安全认证和授权）、Spring Batch（批处理）、Spring Integration（集成）、Spring Cloud（微服务开发）等。这些模块可以根据项目需求进行选择和集成，以便更好地满足应用程序的需求。

(1)结构体系图

2.什么是控制反转(IoC: Inversion of Control)和依赖注入(DI:Dependency Injection)?

（1）控制反转和依赖注入是面向对象编程中的两个重要概念。
（2）控制反转指的是将控制权从调用组件的代码中转移到外部容器中。外部容器负责创建、配置和管理组件之间的依赖关系，将组件之间解耦合，降低了组件间的依赖性。
（3）依赖注入是控制反转的一种实现方式。它通过在组件内部提供一个接口或者注解，让外部容器负责注入依赖的对象。也就是说，当一个组件需要依赖其他组件时，不再需要自己去创建依赖的对象，而是由外部容器来创建并注入到组件中。这样做的好处是，组件只需要关注自身的逻辑，而不需要关心依赖对象的创建和管理

有什么优点：
（4）控制反转和依赖注入都是为了解耦合和降低组件间的依赖性，提高代码的可测试性、可扩展性和可维护性更加灵活。在使用这两个概念时，可以选择不同的实现方式，如使用依赖注入框架或者手动实现依赖注入。

3.什么是AOP?

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它旨在通过将横切关注点（Cross-cutting Concerns）从主要业务逻辑中分离出来，以提高代码的模块化性和可维护性。

(1)AOP的核心思想是什么？

AOP的核心思想是通过引入切面（Aspect），将横切关注点从主要业务逻辑中分离出来。切面定义了在哪些连接点（Join Point）上执行哪些操作（Advice），并可以通过切点（Pointcut）选择性地匹配连接点。

(2)AOP有哪些增强处理类型及特点？

类型：
（1） 前置通知（Before Advice）：在目标方法执行之前执行的通知。它可以用于执行一些预处理操作，例如参数验证、权限检查等。前置通知不会影响目标方法的执行流程，除非抛出异常或改变传入参数的值。

（2）后置通知（After Advice）：在目标方法执行之后执行的通知。无论目标方法是否正常结束，后置通知都会被执行。它常用于执行一些善后操作，例如资源释放、日志记录等。

（3）返回通知（After Returning Advice）：在目标方法正常返回结果后执行的通知。它可以获取并处理目标方法的返回值。返回通知常用于执行一些与返回结果相关的操作，例如数据处理、结果转换等。

（4）异常通知（After Throwing Advice）：在目标方法抛出异常后执行的通知。它可以处理目标方法抛出的异常，并根据业务需要进行相应的操作，例如错误处理、异常日志记录等。

（5）环绕通知（Around Advice）：在目标方法执行之前和之后执行的通知，可以完全控制目标方法的执行过程。环绕通知能够决定是否执行目标方法以及在执行前后进行特定的操作，例如性能监控、事务管理等。

特点：
解耦合，可扩展性，灵活性，可读性，横跨多个模块的能力

4.第一个Spring程序

(1)导入依赖

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <!-- 2.Spring dao依赖 -->
        <!-- spring-jdbc包括了一些如jdbcTemplate的工具类 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <!-- 3.Spring web依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>

(2)编写Spring配置文件，创建一个applicationContext.xml 文件

(3)编写applicationContext.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
        http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 这里是配置内容 -->

</beans>

(4)编写测试代码通过Spring进行属性注入

(1)get，set 方法

(1)创建一个实体类

(2)

注：记得封装

(3) 在applicationContext.xml通过bean元素声明需要Spring创建的实例。该实例通过class属性指定(放路劲)，并通过id属性为该实例指定一个名称

(4)在实体类重新写一个tostring的方法

(5)创建一个测试类，写一个测试方法

注：这个getBean里面放的user就是第3点bean标签id取的名字

(2)构造方法注入

(1)创建mapper和service

(2)在applicationContext.xml通过bean元素声明

(3)在mapper接口写方法然后实现接口

(4)在service接口写方法然后写一个构造方法再实现接口

(5)写一个测试类

5.AOP在项目中的运用

(1)添加依赖

 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>


        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjtools</artifactId>
            <version>1.9.5</version>
        </dependency>

        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.0</version>
        </dependency>

        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

(2)在applicationContext.xml切面声明

(3)新建一个包还有一个java类

(4)在MyAspect类织入增强处理（代码在下面给你们了哦），首先我们先来了解一下表达式匹配规则

规则：

public * addNewUser(entity.User)："*"表示匹配所有类型的返回值

public void *(entity.User)："*"表示匹配所有方法名

public void addNewUser(..)：".."表示匹配任意参数个数和类型

* com.service.*.*(..)：匹配com.service包下所有类的所有方法

* com.service..*.*(..)：匹配com.service包及其子包下所有类的所有方法

代码：

/**
     * 前置通知
     */
    @Before("execution(* cskt.service..*.*(..)))")
     public void before(){
            System.out.println("前置通知....在方法之前要执行的公共代码放在这里");
     }

    /**
     * 后置通知
     */
    @AfterReturning(value="execution(* cskt.service..*.*(..))))",returning="returnVal")
    public void AfterReturning(Object returnVal){
        System.out.println("后置通知...."+returnVal+"");
    }

    /**
     * 环绕通知
     */
    @Around("execution(* cskt.service..*.*(..)))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("环绕通知前。。。");
        Object ojb=(Object) joinPoint.proceed();
        System.out.println("环绕通知后。。。");
        return ojb;
    }

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

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

(5)在测试类里面测试一下，用的是上面写的构造方法注入的测试类，只是想告诉你们，这个增强处理是只要用了方法就会执行

(6)为什么要用AOP的增强处理有什么好处？

使用 AOP 的增强处理有以下好处：

解耦合：通过将横切关注点从核心业务逻辑中抽离出来，AOP 可以实现不同模块之间的松耦合。这意味着，在不改变业务逻辑的情况下，可以轻松地添加、修改或移除横切关注点。这使得系统更加灵活、可维护性更高，并且易于进行单元测试。
提高模块化：AOP 允许将通用的横切关注点集中管理，从而促进模块化开发。例如，日志记录、性能监控、安全性检查等功能可以作为一个独立的模块实现，并通过增强处理与核心业务逻辑进行组合。这样，可以简化代码的编写和维护，提高代码的复用性。
集中处理横切关注点：在传统的开发模式中，横切关注点可能会分散在各个模块和方法中，难以统一管理。而 AOP 允许将这些关注点集中放置在一个或多个增强处理中，提高了代码的可读性和维护性。
提供声明式编程：通过增强处理，AOP 可以实现声明式编程风格。开发人员可以使用注解、配置文件等方式来声明需要进行拦截和处理的切点，并指定相应的增强处理逻辑。这样，业务逻辑和横切关注点的关系更加清晰，代码具有更好的可读性和可维护性。
降低重复代码：横切关注点通常包含一些通用的代码逻辑，例如日志记录、异常处理等。使用 AOP 的增强处理可以将这些通用逻辑从业务代码中剥离出来，减少了代码的重复性。这样，可以提高代码的可维护性、降低错误率，并且有助于保持代码的一致性。

6.总结

我是烧饼

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
学习Spring的第一天 —— IoC，DI，AOP

Spring框架是一个用于构建企业级Java应用程序的开源框架。它提供了一套全面的解决方案，包括依赖注入、面向切面编程、事务管理、数据访问、Web开发等功能。以下是Spring框架的主要组件：核心容器（Core Container）：包含了Spring框架的核心功能，例如依赖注入（Dependency Injection）和控制反转（Inversion of Control）。这些功能使得应用程序的各个组件可以松散耦合，便于测试和维护。
复制链接

扫一扫