一、Spring概述

( 1 ) 背景

( 2 ) 是什么

( 3 ) 核心特性

二、Spring中的ioc

2.1 讲解

2.2 主要功能

2.3 实例演示

三、注入方式

3.1 set注入

3.2 构造注入

3.3 接口注入

四、Web容器整合

4.1 思考

4.2 实操

对我们的收获

一、Spring概述

( 1 ) 背景

Spring框架的背景和诞生可以追溯到Java企业级应用开发（Java EE）的发展过程中。

在传统的Java EE开发中，应用程序的开发和部署往往需要涉及大量的配置文件和繁琐的代码。开发人员需要手动管理对象的生命周期、依赖关系和事务处理等。这种开发模式存在许多痛点，包括开发效率低下、代码冗余、维护困难等。

为了解决这些问题，Rod Johnson于2002年创建了Spring框架。他的目标是简化Java企业级应用程序的开发，使开发人员能够更加专注于解决业务逻辑，而不是被底层的技术细节所束缚。

Spring框架的设计理念基于两个关键概念：IoC（控制反转）和AOP（面向切面编程）。

控制反转（IoC）是一种设计原则，通过将对象的创建、配置和管理交由容器负责，实现了对象之间的松耦合。开发人员只需描述对象之间的依赖关系，容器负责将这些对象进行实例化并通过依赖注入的方式传递依赖关系。这种反转控制的方式提高了代码的可测试性、扩展性和可维护性。

面向切面编程（AOP）则是一种编程范式，用于实现横切关注点的复用和模块化。通过AOP，开发人员可以将与核心业务逻辑无关的功能（如日志记录、事务管理等）以切面的方式进行统一管理，避免了代码的重复。

Spring框架的出现填补了Java EE开发过程中的许多空白，大大简化了企业级应用程序的开发和维护工作。它提供了一套强大而灵活的工具和模块，涵盖了从底层基础设施到应用程序逻辑的方方面面。因此，Spring框架成为了Java开发社区中最受欢迎和广泛应用的开源开发框架之一。

( 2 ) 是什么

Spring是一个基于Java平台的应用程序开发框架，它为开发人员提供了一套灵活的工具和库，用于构建和部署高性能的企业级应用程序。
Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。
Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。
然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。
除此之外，Spring还提供了诸如事务管理、消息传递、调度任务、缓存等功能模块，以满足不同应用场景的需求。
Spring框架是一个强大而灵活的Java开发框架，旨在简化企业级应用程序的开发过程，提高开发效率，降低代码的复杂性，并促进代码的重用和可维护性。它的设计思想和功能模块使其成为当今Java开发领域最受欢迎和广泛使用的开发框架之一。
总体而言，Spring框架提供了丰富的功能和模块，帮助开发人员构建可维护、可扩展、高性能的企业级应用程序。它的开放性和灵活性使得它成为Java开发领域中最流行的应用程序开发框架之一。

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

( 3 ) 核心特性

Spring框架的设计理念是基于IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）的原则。它的目标是简化企业级应用程序的开发过程，使开发人员能够更加专注于业务逻辑的实现，而无需关注底层的基础设施代码。

Spring框架的核心特性包括：

1. IoC容器：Spring的IoC容器将应用程序的组件（如对象、依赖等）的创建、配置和管理工作都交由容器负责。开发人员只需通过配置文件或注解方式告知容器需要创建哪些对象，容器会自动完成对象的实例化和依赖注入。
2. AOP支持：Spring提供了对AOP的全面支持，使开发人员能够更加方便地在应用程序中实现横切关注点的模块化和复用。通过AOP，开发人员可以将一些与核心业务逻辑无关的功能，如日志记录、事务管理等，以切面的方式进行统一管理。
3. 数据访问支持：Spring提供了丰富的数据访问支持，包括对ORM框架（如Hibernate、MyBatis）、JDBC、事务管理等的集成。开发人员可以通过Spring的数据访问模块，更加方便地进行数据库操作。
4. MVC框架：Spring的MVC框架是一种基于模型-视图-控制器（Model-View-Controller）的Web应用程序开发框架。它提供了一个灵活、可扩展的模型视图控制器架构，使开发人员能够更加高效地开发Web应用程序。
5. 安全性支持：Spring提供了一套完整的安全性支持，包括基于角色的访问控制、身份验证、加密等功能。开发人员可以通过Spring的安全模块，更好地保护应用程序的数据和资源。

二、Spring中的ioc

2.1 讲解

IoC（Inversion of Control，控制反转）是Spring框架的核心概念之一。IoC容器是Spring框架提供的一个核心模块，负责对象的创建、配置和管理，实现了对象之间的松耦合。

在传统的开发模式中，当一个对象需要依赖其他对象时，该对象需要自行负责创建和管理它所依赖的对象。这种方式会导致大量的依赖关系交织在代码中，增加了代码的复杂性，同时也使得对象的创建和配置过程与核心业务逻辑紧密耦合在一起。

而IoC容器的作用是将这种对象之间的依赖关系的控制权转移到容器中，将对象的创建和配置过程解耦。开发人员只需通过配置文件或注解方式描述对象之间的依赖关系，容器负责根据配置信息进行对象的实例化和依赖注入。这意味着控制权从对象本身转移到了IoC容器，因此称之为"控制反转"。

2.2 主要功能

IoC容器提供了以下主要功能：

对象的实例化：IoC容器负责创建应用程序所需要的对象实例。开发人员只需提供对象的配置信息，容器会根据配置信息创建对象，并管理对象的生命周期。
依赖注入：IoC容器负责将对象之间的依赖关系注入到对象中。开发人员只需声明对象所需要的依赖，容器会根据依赖关系自动注入相关的对象。这样，对象之间的依赖关系通过容器自动管理，减少了对象之间的解耦。
配置管理：IoC容器通过配置文件或注解的方式管理对象的配置信息。开发人员可以在配置文件中定义对象的属性、依赖关系和生命周期等信息，容器会根据配置信息完成对象的创建和配置过程。
生命周期管理：IoC容器负责管理对象的生命周期。在对象被创建之前和销毁之后，容器会触发相应的回调方法，进行初始化和清理工作。开发人员可以通过实现特定的接口或添加特定的注解来定义对象的生命周期的行为。

通过使用IoC容器，开发人员可以更加专注于业务逻辑的实现，而不用关心对象的创建和配置过程。这样可以大大简化代码，提高开发效率，同时也使得代码更加松耦合、可维护和可测试。Spring框架的IoC容器是Spring应用程序开发中一个重要的基础设施，为开发人员带来了诸多好处。

2.3 实例演示

控制反转：将实例化对象的权力，由开发者控制转交给spring容量来控制

可以先按照我这个项目结构来创建以下接口和类及xml配置文件。(也可根据自己习惯创建)

pom.xml配置文件的引用标签

<?xml version="1.0" encoding="UTF-8"?>

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>Spring</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>Spring Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <spring.version>5.0.1.RELEASE</spring.version>
    <javax.servlet.version>4.0.0</javax.servlet.version>
    <junit.version>4.12</junit.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <!-- 2、导入spring依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- 5.1、junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <!-- 5.2、servlet -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${javax.servlet.version}</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>Spring</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

UserService 接口

package com.CloudJun.ioc.service;

/**
 * @author CloudJun
 * @create  2023-08-15 9:14
 */
public interface UserService {

    public String update();

}

UserServiceImpl 实现类

package com.CloudJun.ioc.service.impl;

import com.CloudJun.ioc.service.UserService;

/**
 * @author CloudJun
 * @create  2023-08-15 9:15
 */
public class UserServiceImpl implements UserService {

//    在原有的基础上做迭代 (进行增加/修改)

    public String update(){
        //如果已经修改用户信息方法
        System.out.println("修改个人用户信息");
        return "list";
    }

}

UserServiceImpl2 实现类

package com.CloudJun.ioc.service.impl;

import com.CloudJun.ioc.service.UserService;

/**
 * @author CloudJun
 * @create  2023-08-15 9:15
 */
public class UserServiceImpl2 implements UserService {

//    在原有的基础上做迭代 (进行增加/修改)

    public String update(){
        //如果已经修改用户信息方法
        System.out.println("修改个人用户信息");
        //例如:需要增加修改用户头像的方法
        System.out.println("更改用户头像信息");

        return "list";
    }

}

GoodsAction 控制器

package com.CloudJun.ioc.web;

import com.CloudJun.ioc.service.UserService;
import com.CloudJun.ioc.service.impl.UserServiceImpl;

/**
 * @author CloudJun
 * @create  2023-08-15 11:08
 */
public class GoodsAction {

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    /**
     * 例如:在不同的控制器中进行方法调用
     */
    private UserService userService;


    public String update(){
        userService.update();
        return "list";
    }
}

UserAction 控制器

package com.CloudJun.ioc.web;

import com.CloudJun.ioc.service.UserService;
import com.CloudJun.ioc.service.impl.UserServiceImpl;

/**
 * @author CloudJun
 * @create  2023-08-15 1058
 */
public class UserAction {

    /**
     * 手动实例化的弊端
     *  1.如果依赖的接口实现需要大批量改动及迭代时，维护的成本极高
     *  2.当接口的实现类不统一，维护成本更高
     */

    private UserService userService ;

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public String update(){
         userService.update();
         return "list";
     }


}

spring-context.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--    在spring配置文件spring-context.xml中配置，那么该类javabean就交给spring容器管理 -->

        <bean class="com.CloudJun.ioc.web.UserAction" id="userAction">
            <property name="userService" ref="userServiceImpl"></property>

        </bean>

        <bean class="com.CloudJun.ioc.web.GoodsAction" id="goodsAction">
            <property name="userService" ref="userServiceImpl2"></property>

        </bean>

        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl" id="userServiceImpl" ></bean>
        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl2" id="userServiceImpl2"></bean>
</beans>

demo 测试类

package com.CloudJun.ioc.demo;

import com.CloudJun.ioc.web.GoodsAction;
import com.CloudJun.ioc.web.UserAction;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author CloudJun
 * @create  2023-08-15 11:42
 */
public class demo {

    public static void main(String[] args) {

        //加载spring核心配置文件(建模)，获取spring上下文对象及上下文对象中可以获取任何javabean的对象
        ClassPathXmlApplicationContext  context  =  new ClassPathXmlApplicationContext("/spring-context.xml");

        UserAction userAction  = (UserAction) context.getBean("userAction");
        System.out.println("没有增加/修改（迭代）的输出");
        userAction.update();

        GoodsAction goodsAction = (GoodsAction) context.getBean("goodsAction");
        System.out.println("进行了增加/修改（迭代）的输出");
        goodsAction.update();

    }

}

测试结果:

三、注入方式

3.1 set注入

将GoogsAction中的所有代码修改为以下代码:

package com.CloudJun.ioc.web;

import com.CloudJun.ioc.service.UserService;

import java.util.List;

/**
 * @author CloudJun
 * @create  2023-08-15 11:08
 */
public class GoodsAction {


    /**
     * 例如:在不同的控制器中进行方法调用
     */
    private UserService userService;
    private String gname;//名称
    private int age;//保质期
    private List<String> peoples;//使用人群


    public String getGname() {
        return gname;
    }

    public void setGname(String gname) {
        this.gname = gname;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public List<String> getPeoples() {
        return peoples;
    }

    public void setPeoples(List<String> peoples) {
        this.peoples = peoples;
    }

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }


    public void pop(){
        System.out.println("名称:"+this.gname);
        System.out.println("保证期:"+this.age);
        System.out.println("使用人群:"+this.peoples);
    }


    public String update(){
        userService.update();
        return "list";
    }
}

再修改spring-context.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byName"
       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">

<!--    在spring配置文件spring-context.xml中配置，那么该类javabean就交给spring容器管理 -->

        <bean class="com.CloudJun.ioc.web.UserAction" id="userAction">
         <property name="userService" ref="userServiceImpl"></property>
 
        </bean>

        <bean class="com.CloudJun.ioc.web.GoodsAction" id="goodsAction">
            <property name="userService" ref="userServiceImpl2"></property>
            <property name="gname" value="辣条"></property>
            <property name="age" value="2"></property>
            <property name="peoples">
                <list>
                    <value>小孩</value>
                    <value>靓女</value>
                    <value>广西老表</value>
                </list>
            </property>
        </bean>

        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl" id="userService" ></bean>
        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl2" id="userServiceImpl2"></bean>
</beans>

最后返回到demo测试类里面进行执行，结果为:

3.2 构造注入

将UserAction中的所有代码修改为以下代码:

package com.CloudJun.ioc.web;

import com.CloudJun.ioc.service.UserService;

import java.util.List;

/**
 * @author CloudJun
 * @create  2023-08-15 1058
 */
public class UserAction {

    /**
     * 手动实例化的弊端
     *  1.如果依赖的接口实现需要大批量改动及迭代时，维护的成本极高
     *  2.当接口的实现类不统一，维护成本更高
     */

    private UserService userService ;

    private  String uname;//姓名
    private  int age;//年龄
    private List<String> hobby;//爱好

    public UserAction() {
    }

    public UserAction(String uname, int age, List<String> hobby) {
        this.uname = uname;
        this.age = age;
        this.hobby = hobby;
    }

    public UserService getUserService() {
        return userService;
    }
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void pop(){
        System.out.println("名字为:"+this.uname);
        System.out.println("年龄为:"+this.age);
        System.out.println("爱好为:"+this.hobby);
    }

    public String update(){
         userService.update();
         return "list";
     }


}

再修改spring-context.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byName"
       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">

<!--    在spring配置文件spring-context.xml中配置，那么该类javabean就交给spring容器管理 -->

        <bean class="com.CloudJun.ioc.web.UserAction" id="userAction">
            <property name="userService" ref="userService"></property>
            <constructor-arg name="uname" value="卡卡西" ></constructor-arg>
            <constructor-arg name="age" value="18" ></constructor-arg>
            <constructor-arg name="hobby"  >
                <list>
                    <value>唱，跳</value>
                    <value>篮球</value>
                </list>
            </constructor-arg>
        </bean>

        <bean class="com.CloudJun.ioc.web.GoodsAction" id="goodsAction">
            <property name="userService" ref="userServiceImpl2"></property>
            <property name="gname" value="辣条"></property>
            <property name="age" value="2"></property>
            <property name="peoples">
                <list>
                    <value>小孩</value>
                    <value>靓女</value>
                    <value>广西老表</value>
                </list>
            </property>
        </bean>

        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl" id="userService" ></bean>
        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl2" id="userServiceImpl2"></bean>
</beans>

最后返回到demo测试类里面进行执行，结果为:

3.3 接口注入

自动装配: byName byType

byName：javaBean会根据属性名在spring的上下文中的bean的id进行查找，主要有就会自动装配

修改spring-context.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byName"
       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">

<!--    在spring配置文件spring-context.xml中配置，那么该类javabean就交给spring容器管理 -->

        <bean class="com.CloudJun.ioc.web.UserAction" id="userAction">
            <!--<property name="userService" ref="userService"></property>
            <constructor-arg name="uname" value="卡卡西" ></constructor-arg>
            <constructor-arg name="age" value="18" ></constructor-arg>
            <constructor-arg name="hobby"  >
                <list>
                    <value>唱，跳</value>
                    <value>篮球</value>
                </list>
            </constructor-arg>-->
        </bean>

        <bean class="com.CloudJun.ioc.web.GoodsAction" id="goodsAction">
           <!-- <property name="userService" ref="userServiceImpl2"></property>
            <property name="gname" value="辣条"></property>
            <property name="age" value="2"></property>
            <property name="peoples">
                <list>
                    <value>小孩</value>
                    <value>靓女</value>
                    <value>广西老表</value>
                </list>
            </property>-->
        </bean>

        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl" id="userService" ></bean>
        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl2" id="userServiceImpl2"></bean>
</beans>

测试结果:

注意：如果名称不同或者没有改名称将会有空指针报错（null值报错）

byType：JavaBean会议根据属性名对应的接口，在spring上下文中进行查找

查找方式:是根据spring上下文中是否有接口实现类进行匹配，只要有就自动配置。

修改spring-context.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byType"
       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">

<!--    在spring配置文件spring-context.xml中配置，那么该类javabean就交给spring容器管理 -->

        <bean class="com.CloudJun.ioc.web.UserAction" id="userAction">
            <!--<property name="userService" ref="userService"></property>
            <constructor-arg name="uname" value="卡卡西" ></constructor-arg>
            <constructor-arg name="age" value="18" ></constructor-arg>
            <constructor-arg name="hobby"  >
                <list>
                    <value>唱，跳</value>
                    <value>篮球</value>
                </list>
            </constructor-arg>-->
        </bean>

        <bean class="com.CloudJun.ioc.web.GoodsAction" id="goodsAction">
           <!-- <property name="userService" ref="userServiceImpl2"></property>
            <property name="gname" value="辣条"></property>
            <property name="age" value="2"></property>
            <property name="peoples">
                <list>
                    <value>小孩</value>
                    <value>靓女</value>
                    <value>广西老表</value>
                </list>
            </property>-->
        </bean>

        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl" id="userService" ></bean>
<!--        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl2" id="userServiceImpl2"></bean>-->
</beans>

测试结果:

注意：如果没有或者有两个以上的接口实现类将会报错，因为是自动查询如有多个将不知道是哪个。

四、Web容器整合

4.1 思考

现在是每一个请求都建模一次，非常消耗性能。
希望只进行一次建模，然后每个请求都要可以获取到spring上下文。
那就是监听器，将spring上下文放入tomcat上下文中。

4.2 实操

先修改spring-context.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byType"
       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">

<!--    在spring配置文件spring-context.xml中配置，那么该类javabean就交给spring容器管理 -->

        <bean class="com.CloudJun.ioc.web.UserAction" id="userAction">
            <!--<property name="userService" ref="userService"></property>
            <constructor-arg name="uname" value="卡卡西" ></constructor-arg>
            <constructor-arg name="age" value="18" ></constructor-arg>
            <constructor-arg name="hobby"  >
                <list>
                    <value>唱，跳</value>
                    <value>篮球</value>
                </list>
            </constructor-arg>-->
        </bean>

        <bean class="com.CloudJun.ioc.web.GoodsAction" id="goodsAction">
           <!-- <property name="userService" ref="userServiceImpl2"></property>
            <property name="gname" value="辣条"></property>
            <property name="age" value="2"></property>
            <property name="peoples">
                <list>
                    <value>小孩</value>
                    <value>靓女</value>
                    <value>广西老表</value>
                </list>
            </property>-->
        </bean>

        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl" id="userService" ></bean>
<!--        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl2" id="userServiceImpl2"></bean>-->
</beans>

之后创建一个监听器: SpringListener

package com.CloudJun.ioc.listener;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

/**
 * @author CloudJun
 * @create  2023-08-16 20:21
 */
@WebListener
public class SpringListener implements ServletContextListener {

        //将spring上下文放入tomcat上下文中。

    public void contextInitialized(ServletContextEvent sce) {
        //加载spring核心配置文件(建模)，获取spring上下文对象及上下文对象中可以获取任何javabean的对象
        ClassPathXmlApplicationContext context  =  new ClassPathXmlApplicationContext("/spring-context.xml");
        //获取tomcat上下文
        ServletContext servletContext= sce.getServletContext();
        servletContext.setAttribute("springContext",context);

    }



}

之后进行测试，我们创建一个UserServlet进行访问

package com.CloudJun.ioc.web;

import com.CloudJun.ioc.service.UserService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @author CloudJun
 * @create  2023-08-16 20:28
 */

@WebServlet("/userList")
public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       this.doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ClassPathXmlApplicationContext context  = (ClassPathXmlApplicationContext) req.getServletContext().getAttribute("springContext");

        UserService userService= (UserService) context.getBean("userService");
        System.out.println(userService);
        userService.update();

    }
}

然后开启服务器(Tomcat) 进行请求测试

打开浏览器

直接输入请求地址: localhost:8080/Spring_war/userList (Spring_war中间这个是可以自己修改的，需要根据自己的请求地址进行访问)

请求完毕后直接看控制台的测试结果

对我们的收获

学习Spring框架后，你将获得以下几方面的收获：

1. 简化开发流程：Spring框架提供了丰富的开发工具和模块，帮助你简化企业级应用程序的开发过程。通过使用Spring的IoC容器和注解，你可以将应用程序的对象的创建和配置工作交给框架处理，从而简化了开发过程，减少了冗余的代码。
2. 提高开发效率：Spring框架提供了很多现成的功能模块，如数据访问、事务管理、安全性支持等，可以减少开发人员手动编写这些功能模块的工作量。你可以通过配置或注解的方式快速集成这些功能，从而提高了开发效率。
3. 松耦合的设计：通过IoC容器和依赖注入，Spring框架实现了对象之间的松耦合。你可以更加专注于业务逻辑的实现，而不用过多关注对象之间的依赖关系。这种松耦合的设计使得应用程序更加灵活、可扩展和易于维护。
4. 更好的可测试性：Spring框架的设计理念使得应用程序的各个组件可以更容易地进行单元测试和集成测试。通过依赖注入，你可以轻松地模拟各个组件的依赖关系，从而更方便地编写测试代码，并保证应用程序的质量。
5. AOP的应用：Spring框架提供了全面的AOP支持，使你能够将与核心业务逻辑无关的功能模块（如事务管理、日志记录、缓存等）以切面的方式进行统一管理。这种模块化的设计能够提高代码的重用性和可维护性。
6. 更好的代码组织和可维护性：通过使用Spring框架，你可以将应用程序的不同层次的代码（如控制层、业务逻辑层、数据访问层）更好地组织起来，实现代码的分层和模块化。这种组织方式使得代码更具可读性、可维护性，方便团队协作开发。