1. 概述

  1. Spring是轻量级的开源的JavaEE框架
  2. Spring可以解决企业应用开发的复杂性

  3. Spring有两个核心部分：IOC和AOP

    1. IOC：控制反转，把创建对象的过程交给Spring进行管理
    2. AOP：面向切面，不修改源代码进行功能增强

  4. Spring特点

    1. 方便解耦，简化开发
    2. Aop编程支持
    3. 方便程序测试
    4. 方便和其它框架进行整合
    5. 方便进行事务操作
    6. 降低API开发难度

2. 入门案例

2.1 下载Spring5

下载地址：https://repo.spring.io/release/org/springframework/spring/

2.2 创建普通Java工程

2.3 导入Spring5的Jar包

相关jar包

2.4 创建普通类

public class User {
    public void add() {
        System.out.println("add......");
    }
}

2.5 创建Spring配置文件，在配置文件中配置要创建的对象

  1. Spring中的配置文件使用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">
    <!--配置User类对象的创建-->
    <bean id="user" class="com.hxuanyu.spring5.User"/>
</beans>

2.6 测试代码编写

@Test
public void testAdd() {
    // 1. 加载spring配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
    // 2. 获取配置创建对象
    User user = context.getBean("user", User.class);
    // 3. 输出
    System.out.println(user);
    user.add();
}

3. IOC概念和原理

3.1 什么是IOC

  1. 控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理
  2. 使用IOC目的：为了耦合度降低
  3. 入门案例就是IOC的实现

3.2 IOC底层原理

  1. xml解析
  2. 工厂模式
  3. 反射

3.3 原理图解

原始方式中，一个类要调用另一个类中的方法，则必须要在内部声明一个对应的对象，通过对象调用相应的方法，耦合度高。

原始方式

使用工厂模式对这一过程进行解耦。即创建一个工厂类，通过工厂类生成对象，并调用其中的方法。这种方式降低了UserService和User的耦合度，但是工厂类还是和User类有耦合。

工厂模式

为了使耦合度降到最低，IOC使用xml解析和反射进一步将耦合降到最低。在工厂模式的基础上，IOC在工厂类内部解析xml得到类名，通过Class.forname(classValue)得到对象的类，再调用clazz.newInstance()并进行强制转换得到对象。最终返回该对象。这种方式通过配置文件的方式将实体类和调用者之间的耦合进一步降低。

3.4 IOC（BeanFactory接口）

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

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

    1. BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员使用。加载配置文件时不会创建对象，在获取对象时才去创建对象
    2. ApplicationContext：BeanFactory接口的子接口，提供更多强大的功能，一般由开发人员进行使用，加载配置文件时就会把在配置文件中的对象进行创建

  3. ApplicationContext接口的主要实现类

    1. FileSystemXmlApplicationContext：从系统文件系统中获取xml配置文件
    2. ClassPathXmlApplicationContext：从项目内部获取xml配置文件

3.4 IOC操作Bean管理

3.4.1 概念

  1. 什么是Bean管理（指两个操作）

    1. Spring创建对象
    2. Spring注入属性

  2. Bean管理操作有两种方式

    1. 基于xml配置文件方式
    2. 基于注解方式实现

3.4.2 FactoryBean

  1. Spring中有两种类型的bean，一种普通bean，另外一种工厂bean（FactoryBean）
  2. 普通bean：在配置文件中定义的类型就是返回的类型
  3. 工厂bean：在配置文件中定义的bean类型可以和返回值类型不一样

第一步：创建类，让这个类作为工厂bean，实现接口FactoryBean

第二部：实现接口中的方法，在实现的方法中定义返回的bean类型

3.4.3 Bean的作用域

  1. 在spring中可以设置创建的bean实例是单实例还是多实例
  2. 在spring中，默认情况下，bean是单实例的对象

  3. 设置多实例的方法：

    1. 在spring配置文件bean标签中的属性scope用于设置单实例还是多实例

    2. scope属性值：

      • 默认值：singleton，表示是单实例对象
      • prototype，表示是多实例

    3. 两个值的区别：

      • 设置为singleton时，加载spring配置文件时就会创建单实例对象
      • 设置为property时，不是在加载spring配置文件时创建对象，而是在调用getBean()方法时创建多个实例对象。

3.4.4 Bean的生命周期

  1. 通过构造器创建bean实例（无参）
  2. 为bean的属性设置和对其他的bean引用（调用set方法）
  3. 调用bean的初始化方法（需要进行配置初始化的方法）
  4. bean的使用
  5. 当容器关闭时，调用bean的销毁方法（需要进行配置销毁的方法）
public class Orders {

    private String oname;

    public Orders() {
        System.out.println("第一步，调用无参构造函数");
    }

    public void setOname(String oname) {
        System.out.println("第二步，调用set方法设置属性值");
        this.oname = oname;
    }

    public void initMethod(){
        System.out.println("第三步，执行初始化方法");
    }


    public void destoryMethod(){
        System.out.println("第五步，执行销毁方法");
    }


}
<?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">
    <bean id="orders" class="com.hxuanyu.spring5.bean.Orders" init-method="initMethod" destroy-method="destoryMethod">
        <property name="oname" value="手机"></property>
    </bean>
</beans>
@Test
public void test4() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("第四步，bean的使用");
    System.out.println(orders);

    //手动销毁实例
    context.close();
}

运行结果：

> 第一步，调用无参构造函数
> 第二步，调用set方法设置属性值
> 第三步，执行初始化方法
> 第四步，bean的使用
> com.hxuanyu.spring5.bean.Orders@1990a65e
> 第五步，执行销毁方法

bean的后置处理器

  1. 通过构造器创建bean实例（无参）
  2. 为bean的属性设置和对其他的bean引用（调用set方法）
  3. 把bean实例传递给bean后置处理器的方法postProcessBeforeInitialization
  4. 调用bean的初始化方法（需要进行配置初始化的方法）
  5. 把bean实例传递给bean后置处理器的方法postProcessAfterInitialization
  6. bean的使用
  7. 当容器关闭时，调用bean的销毁方法（需要进行配置销毁的方法）

3.5 基于xml方式

3.5.1 基于xml方式创建对象

  1. 在spring配置文件中，使用bean标签，标签内添加对应的属性，就可以实现对象的创建

  2. 在bean标签中有很多属性：

    • id：唯一标识
    • class：类全路径（包类路径）
  3. 创建对象时，默认也是执行无参构造方法完成对象创建

3.5.2 注入属性

  1. 基于xml方式注入属性：DI，即依赖注入，就是所说的注入属性，是IOC中的一种具体实现
  2. 第一种注入方式：使用set方法

  3. 第二种注入方式：使用有参构造进行注入

    1. 创建类，定义属性，创建属性对应的有参数构造方法
    2. 在spring配置文件中进行配置

  4. P名称空间注入（了解）

    1. 使用p名称空间注入，可以简化基于xml配置方式。首先添加命名空间到xml约束中：xmlns:p="www.springframework.org/schema/p"
    2. 进行属性注入，在bean标签里进行操作，直接添加p:属性名=“属性值”即可。
/**
 * 使用set方法进行注入属性
 */
public class Book {
    // 创建属性
    private String bname;
    private String author;

    // 创建属性对应的set方法
    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

/**
 * 使用有参构造函数注入
 */
public class Order {
    private String oname;
    private String address;

    public Order(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}
<?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">
    <!--配置User类对象的创建-->
    <!--set方法注入属性-->
    <bean id="book" class="com.hxuanyu.spring5.Book">
        <!--使用property完成属性注入
            name: 类的属性名
            value: 向属性注入的值
        -->
        <property name="bname" value="Java程序设计"/>
        <property name="author" value="abcabc"/>
    </bean>
    <bean id="order" class="com.hxuanyu.spring5.Order">
        <constructor-arg name="oname" value="abc"/>
        <constructor-arg name="address" value="123"/>
    </bean>
</beans>

3.5.3 注入其他类型

除了注入字符串类型外，xml方式还可以注入其他类型的属性：

字面量：即直接对属性固定值进行设置的值，包括控制和特殊符号值

<!--设置一个空值-->
<property name="address">
    <null/>
</property>

<!--属性值包含特殊符号
 1 把<>进行转义 < >
 2 把带特殊符号内容写到 CDATA
-->
<property name="address">
 <value><![CDATA[<<南京>>]]></value>
</property>

3.5.4 注入外部bean

常规做法：在service中创建dao类，调用其方法，耦合度较高
  1. 创建两个类Service类和Dao类
  2. 在Service中调用Dao类
  3. 在spring配置文件中进行配置
public class UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("Service add ...........");
        userDao.update();
    }
}

<?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">

    <!--service和dao对象创建-->
    <bean id="userService" class="com.hxuanyu.spring5.service.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>

    <bean id="userDao" class="com.hxuanyu.spring5.dao.UserDaoImpl"/>
</beans>

3.5.5 注入内部bean

  1. 一对多关系：部门和员工，一个部门有多个员工，一个员工属于一个部门
  2. 在实体类之间表示一对多的关系，员工表示所属部门，使用对象类型属性进行表示
public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }
}
public class Emp {
    private String ename;
    private String gender;
    // 员工属于某一个部门，使用对象形式进行表示
    private Dept dept;

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}
<?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">
    <!--内部bean-->
    <bean id="emp" class="com.hxuanyu.spring5.bean.Emp">
        <!--先设置普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!--设置对象类型属性-->
        <property name="dept" >
            <bean id="dept" class="com.hxuanyu.spring5.bean.Dept">
                <property name="dname" value="安保部"></property>
            </bean>
        </property>
    </bean>
</beans>

3.5.6 级联赋值

  • 第一种写法
<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">
    <!--级联赋值操作-->
    <bean id="emp" class="com.hxuanyu.spring5.bean.Emp">
        <property name="ename" value="lucy">
      
        </property>
        <property name="gender" value="女">
      
        </property>
        <property name="dept" ref="dept">
      
        </property>
    </bean>
    <bean id="dept" class="com.hxuanyu.spring5.bean.Dept">
        <property name="dname" value="财务部">
      
        </property>
    </bean>
</beans>
  • 第二种写法
<?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">
    <!--级联赋值操作-->
    <bean id="emp" class="com.hxuanyu.spring5.bean.Emp">
        <property name="ename" value="lucy">

        </property>
        <property name="gender" value="女">

        </property>
        <property name="dept" ref="dept">

        </property>
        <!--一定要写get方法，否则无法在内部进行赋值操作-->
        <property name="dept.dname" value="技术部"></property>
    </bean>
    <bean id="dept" class="com.hxuanyu.spring5.bean.Dept">
        <property name="dname" value="财务部">

        </property>
    </bean>
</beans>
这种写法一定要在注入的类中声明get方法，否则无法获取到对象，也就无法设置值

3.5.7 注入集合属性

  1. 创建类，定义数组、List、map、set类型属性，生成对应的set方法
  2. 在配置文件中进行配置
<?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">
    <bean id="student" class="com.hxuanyu.spring5.collectiontype.Student">
        <!--注入数组类型-->
        <property name="courses">
            <array>
                <value>java</value>
                <value>数据库</value>
            </array>
        </property>
        <!--注入集合类型-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>小张</value>
            </list>
        </property>
        <!--map类型注入-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
        <!--set集合注入-->
        <property name="set">
            <set>
                <value>MySql</value>
                <value>Radis</value>
            </set>
        </property>
    </bean>
</beans>

在集合中设置对象类型的值

<?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">
    <bean id="student" class="com.hxuanyu.spring5.collectiontype.Student">
        <!--注入数组类型-->
        <property name="courses">
            <array>
                <value>java</value>
                <value>数据库</value>
            </array>
        </property>
        <!--注入集合类型-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>小张</value>
            </list>
        </property>
        <!--map类型注入-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
        <!--set集合注入-->
        <property name="set">
            <set>
                <value>MySql</value>
                <value>Radis</value>
            </set>
        </property>
        <!--值为对象的list注入-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
        <!--创建多个对象的集合-->
    </bean>
    <bean id="course1" class="com.hxuanyu.spring5.collectiontype.Course">
        <property name="cname" value="Spring5框架"></property>
    </bean>
    <bean id="course2" class="com.hxuanyu.spring5.collectiontype.Course">
        <property name="cname" value="MyBatis框架"></property>
    </bean>
</beans>

把集合注入的部分提取出来

  1. 在spring配置文件中引入名称空间 util
  2. 使用util标签完成list集合注入使用util标签完成list集合注入提取
<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <!--提取list集合类型属性注入-->
    <util:list id="booklist">
        <value>易筋经</value>
        <value>九阳神功</value>
        <value>九阴真经</value>
    </util:list>

    <!--提取list集合类型属性注入使用-->
    <bean id="book" class="com.hxuanyu.spring5.collectiontype.Book">
        <property name="list" ref="booklist"></property>
    </bean>
</beans>

3.5.8 xml自动装配

根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入

使用autowire属性进行自动注入，有两个常用值：

  • byName：根据属性名称注入，要求注入值bean的id与类的属性名一样
  • byType：根据属性类型注入
<?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">
    <!--配置自动装配-->
    <bean id="emp" class="com.hxuanyu.spring5.autowire.Emp" autowire="byName"></bean>
    <bean id="dept" class="com.hxuanyu.spring5.autowire.Dept"></bean>
</beans>

3.5.9 外部属性文件

应用场景：一些不经常改变的值可以存在外部文件中，通过引用方式引入，例如数据库的配置

  • 直接配置德鲁伊连接池
<?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">
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
</beans>

  • 引入外部属性文件配置数据库连接池

    1. 创建外部属性文件。properties格式文件，写数据库信息
    2. 把外部properties属性文件引入到Spring配置文件中，需要引入context名称空间
    3. 在spring配置文件使用标签引入外部属性文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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">
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverCLass}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.userName}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>
</beans>
prop.driverCLass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.userName=root
prop.password=root

3.4 基于注解方式

  1. 什么是注解

    • 注解是代码的特殊标记，格式为：@注解名称(属性名称=属性值，属性名称=属性值..)
    • 注解可以使用在类、方法和属性上
    • 使用注解的目的：简化xml配置

  2. Spring针对Bean管理中创建对象提供的注解

    • @Component：
    • @Service：
    • @Controller：
    • @Repository：
上面四个注解功能是一样的，都可以用来创建bean对象。

3.4.1 创建对象

  1. 引入依赖包spring-aop

  2. 开启组件扫描

    • 如果扫描多个包，则多个包用逗号隔开
    • 也可以扫描包上层目录实现扫描多个包
  3. 创建类，在类上添加创建对象注解，其中value属性可以省略不写，默认值为类名，首字母小写

  4. 开启组件扫描后，会扫描包下所有的类，同时Spring支持更加细致的扫描配置：

    • 使用use-default-filters="false"表示不使用默认配置，使用自定义配置
    • include-filter表示只扫描带Controller注解的类
    • exclude-filter表示不扫描带Controller注解的类
<?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"
       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">
    <!--开启组件扫描-->
    <context:component-scan base-package="com.hxuanyu"/>
    <!--使用use-default-filters="false"表示不使用默认配置，使用自定义配置-->
    <context:component-scan base-package="com.hxuanyu" use-default-filters="false">
        <!--表示只扫描带Controller注解的类-->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>
    <context:component-scan base-package="com.hxuanyu" use-default-filters="false">
        <!--表示不扫描带Controller注解的类-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>
</beans>
// value可省略不写，默认为类名首字母小写
@Component(value = "userService")
public class UserService {
    public void add() {
        System.out.println("service add");
    }
}

3.4.2 注入属性

  • @AutoWire：根据属性类型进行自动装配

    • 先把service和dao对象创建，在service和dao类添加创建对象注解
    • 在service注入dao对象，在service类添加dao类型属性，在属性上使用注解
@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        System.out.println("dao add......");
    }
}

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    public void add() {
        System.out.println("service add");
        userDao.add();
    }
}
  • @Qualifer：根据属性名称注入，需要和@AutoWire一起使用，适用于一个接口的多个实现类的情况，因为此时自动装配无法根据类型判断要注入到哪一个。使用时需要写明要注入哪个类
@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        System.out.println("dao add......");
    }
}

@Service
public class UserService {
    @Autowired
    @Qualifier(value = "userDaoImpl1")
    private UserDao userDao;

    public void add() {
        System.out.println("service add");
        userDao.add();
    }
}
  • @Resource：既可以根据名称注入，也可以自动注入，不设置name属性时使用自动注入，设置的话使用指定的名称注入。但由于这个注解属于javax包，因此不建议优先使用该注解
@Service
public class UserService {

    @Resource(name = "userDaoImpl")
    private UserDao userDao;
    public void add() {
        System.out.println("service add");
        userDao.add();
    }
}
  • Value：注入普通类型的属性
@Service
public class UserService {

    @Value(value = "abc")
    private String name;

    public void add() {
        System.out.println("service add.......... name = " + name);
        userDao.add();
    }
}

3.4.3 完全注解开发

@Configuration
@ComponentScan(basePackages = {"com.hxuanyu.spring5"})
public class SpringConfig {

}
最后修改：2023 年 11 月 14 日
© 允许规范转载
如果觉得我的文章对你有用，请随意赞赏