Spring5详解——IOC容器

最新推荐文章于 2024-10-12 16:52:06 发布
最新推荐文章于 2024-10-12 16:52:06 发布
阅读量444 收藏 3
点赞数
分类专栏： java 文章标签： spring java ioc bean maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36251309/article/details/108739287
版权
本文详细介绍了Spring5的IOC容器，包括IOC的核心概念、底层原理、BeanFactory和ApplicationContext接口，以及如何通过XML和注解方式进行Bean管理。讨论了Bean的作用域、生命周期、自动装配，并涉及了外部属性文件和FactoryBean的应用。
摘要由CSDN通过智能技术生成

主要内容：

1.Spring框架概述
2.IOC容器
3.AOP
4.JdbcTemplate
5.事务的管理
6.Spring5新特性

Spring框架概述

1.Spring框架是一个轻量级的开源的JavaEE框架。

轻量级：jar包数量少、体积小，不需要额外依赖其他的组件。
开源：免费提供源代码。
框架：使我们的开发更加方便、更加简洁，解决企业应用开发的复杂性。

2.Spring可以解决企业应用开发的复杂性。
3.Spring有两个核心部分：IOC和AOP。

IOC:以前通过new 的方式创建对象，现在可以把创建对象的过程交给Spring进行创建
AOP：面向切面

4.方便程序的测试
5.方便集成各种优秀的框架
6.降低Java EE API的使用难度
7.方便进行事务的管理
8.Java源码是经典学习范例

Spring入门案例

1.点击这里，下载Spring5的相关jar包
2.导入Spring基础包
在这里插入图片描述
如果不想要手动进行导包，想要使用maven：

 <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

3.创建普通的类，在这个类中创建普通的方法

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

4.创建Spring配置文件，在配置文件中配置想要创建的对象

<?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.study.spring5.User"></bean>
</beans>

5.进行测试代码编写

public class TestSpring5 {
    @Test
    public void testAdd(){
        //加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //获取配置文件中创建的对象
        User user = context.getBean("user", User.class);//这里的第一个参数对应配置文件中的id，第二个参数代表了返回的类型
        System.out.println(user);
        user.add();
    }
}

运行结果：

"C:\Program Files\Java\jdk1.8.0_241\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.3\lib\idea_rt.jar=53496:C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.3\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.3\lib\idea_rt.jar;C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.3\plugins\junit\lib\junit-rt.jar;C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.3\plugins\junit\lib\junit5-rt.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_241\jre\lib\rt.jar;C:\blog完整项目\spring5_demo1\out\production\spring5_demo1;C:\blog完整项目\spring5_demo1\lib\spring-beans-5.2.6.RELEASE.jar;C:\blog完整项目\spring5_demo1\lib\spring-context-5.2.6.RELEASE.jar;C:\blog完整项目\spring5_demo1\lib\spring-expression-5.2.6.RELEASE.jar;C:\blog完整项目\spring5_demo1\lib\spring-core-5.2.6.RELEASE.jar;C:\Users\1\.m2\repository\junit\junit\4.12\junit-4.12.jar;C:\Users\1\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;C:\blog完整项目\spring5_demo1\lib\commons-logging-api-1.1.jar" com.intellij.rt.execution.junit.JUnitStarter -ideVersion5 -junit4 com.study.spring5.testdemo.TestSpring5,testAdd
com.study.spring5.User@42f93a98
add.............

IOC容器

  1. 控制反转，把创建对象和调用对象的过程交给spring管理。
  2. 使用IOC的目的：降低耦度。

在这里插入图片描述

在这里插入图片描述

IOC底层原理

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

在这里插入图片描述

IOC接口(BeanFactory)

  1. IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。
  2. Spring提供IOC容器实现的两种实现方式：（通过两个接口）
    （1）BeanFactory：IOC容器的基本实现，是在Spring内部使用的接口，不提供给开发人员进行使用；加载加载配置文件的时候不会创建对象，在获取对象的时候才会去创建对象。
    （2）ApplicationContext：BeanFactory的子接口，提供更多更强大的功能，一般由开发人员进行使用；在加载配置文件的时候就回把所有的配置文件对象进行创建。
//ApplicationContext的实现类
ApplicationContext context = new ClassPathXmlApplication("bean.xml");
ApplicationContext context = new FileSystemXmlApplicationContext("D:/workspace/applicationContext.xml");

ClassPathXmlApplicationContext
默认文件路径是src下那一级
classpath:和classpath*:的区别:
classpath: 只能加载一个配置文件,如果配置了多个,则只加载第一个
classpath*: 可以加载多个配置文件,如果有多个配置文件,就用这个

FileSystemXmlApplicationContext
这个类,默认获取的是项目路径,默认文件路径是项目名下一级，与src同级。
如果前边加了file:则说明后边的路径就要写全路径了,就是绝对路径
file:D:/workspace/applicationContext.xml

1. 什么是Bean管理 ？

（1）Spring创建对象
（2）Spring注入属性

2. 实现Bean管理操作的两种方式

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

IOC操作Bean管理（基于xml）

1.基于xml方式创建对象

在spring的配置文件中，使用bean标签，标签里面添加对应的属性，就可以实现对象的创建。
在bean标签里面有许多属性，id：给这个对象取一个标识别名（唯一标识），class：类全路径（包全路径）。
创建对象的时候，也是默认执行无参数的构造方法。

<!--配置User对象的创建-->
    <bean id="user" class="com.study.spring5.User"></bean>
2.基于xml方式注入属性
  1. DI:依赖注入是ioc中的具体实现，肯定是在创建对象的基础上再注入属性。
第一种方式：set方法注入
public class Book {
    private String bName;
    private String bAuthor;

    public void setbName(String bName) {
        this.bName = bName;
    }

    public void setbAuthor(String bAuthor) {
        this.bAuthor = bAuthor;
    }
    public void getBookNameAndAuthor(){
        System.out.println(this.bName+":::"+this.bAuthor);
    }
}


<!--配置Book对象的创建-->
    <bean id="book" class="com.study.spring5.Book">
        <property name="bName" value="易经经"></property>
        <property name="bAuthor" value="达摩老祖"></property>
    </bean>

@Test
    public void testBook(){
        //加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //获得配置文件中的对象
        Book book = context.getBean("book",Book.class);
        System.out.println(book);
        book.getBookNameAndAuthor();
    }

输出结果

com.study.spring5.Book@6aba2b86
易经经:::达摩老祖
第二种方式：有参数的构造注入。
public class Book {
    private String bName;
    private String bAuthor;

    public Book(String bName, String bAuthor) {
        this.bName = bName;
        this.bAuthor = bAuthor;
    }

    public void getBookNameAndAuthor(){
        System.out.println(this.bName+":::"+this.bAuthor);
    }
}

<!--配置Book对象的创建-->
    <bean id="book" class="com.study.spring5.Book">
        <constructor-arg name="bName" value="abc"></constructor-arg>
        <constructor-arg name="bAuthor" value="123"></constructor-arg>
    </bean>

@Test
    public void testBook(){
        //加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //获得配置文件中的对象
        Book book = context.getBean("book",Book.class);
        System.out.println(book);
        book.getBookNameAndAuthor();
    }

输出结果：

com.study.spring5.Book@44ebcd03
abc:::123
第三种：p名称空间注入

使用p名称空间注入，可以简化基于xml配置方式。底层使用的还是set方法进行注入。

  1. 在配置文件中，添加p名称空间。
  2. 进行属性注入，在bean标签里面进行操作。
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"    //添加p名称空间。
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="book" class="com.study.spring5.Book" p:bName="九阳神功" p:bAuthor="无名氏">//进行属性注入
    </bean>
</beans>
xml注入其他类型的属性吧
  1. 字面量
    在这里插入图片描述
2. 注入属性-外部bean

（1） 创建两个service类和dao类

public interface UserDao {
    public void update();
}


public class UserDaoImpl implements UserDao {

    @Override
    public void update() {
        System.out.println("update......................");
    }
}

（2） 在service中调用dao里面的方法


public class UserService {
    //创建userdao类型的属性，生成set方法
    private UserDao userDao;

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

    public void add(){
        System.out.println("service add............");
        //1.创建UserDao对象（原始方式）
       /* UserDao u = new UserDaoImpl();//多态
        u.update();*/
        //2.使用spring注入
        userDao.update();
    }
}

（3） 在spring的配置文件中进行配置

<?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">
    <!--1.service和dao对象创建-->
    <bean id="userService" class="com.study.spring5.service.UserService">
        <!--注入userDao对象
            name：类里面的属性名
            ref属性：创建userDao对象bean标签id值
        -->
        <property name="userDao" ref="userDao"></property>
    </bean>

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

@Test
    public void testBean1(){
        //加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        //获取配置创建对象
        UserService userService = context.getBean("userService",UserService.class);
        userService.add();
    }
3. 注入属性-内部bean和级联赋值

（1） 一对多关系：部门和员工
一个部门有多个员工，一个员工只有一个部门。部门是“一”，员工是“多”。

public class Dept {
    private String dname;
    private String address;

    public void setDname(String dname) {
        this.dname = dname;
    }

    public void setAddress(String address) {
        this.address = address;
    }
    public void info(){
        System.out.println("dname = "+dname+",address = "+address);
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}




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;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
    public void info(){
        System.out.println(ename+gender+dept);
    }


}



<?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">
    <!--1.内部bean-->
    <bean id="emp" class="com.study.spring5.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="anne"></property>
       <property name="gender" value="girl"></property>
        <property name="dept">
            <bean id="dept" class="com.study.spring5.bean.Dept">
                <property name="dname" value="财务部"></property>
            </bean>
        </property>
    </bean>


</beans>
3. 注入属性-级联赋值
<?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">
    <!--1.内部bean-->
    <bean id="emp" class="com.study.spring5.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="anne"></property>
        <property name="gender" value="girl"></property>
        <!--级联赋值-->
        <property name="dept" ref="dept"></property><!--第一种写法，在外面创建bean，使用ref-->
        <property name="dept.dname" value="技术部"></property><!--需要在Emp中生成dept的get方法-->

    </bean>
    <bean id="dept" class="com.study.spring5.bean.Dept">
        <property name="dname" value="安保部"></property>
    </bean>
</beans>

IOC操作Bean管理（xml注入集合属性）

  1. 注入数组类型属性
  2. 注入List集合类型属性
  3. 注入Map集合类型属性
    （1）创建类，定义数组、list、map、set类型属性，生成对应的set方法
public class Stu {
  

    //1.数组类型属性
    private String[] courses;
    //2.创建list集合类型属性
    private List<String> list;
    //3.map集合类型属性
    private Map<String,String> maps;
    //4.set集合类型属性
    private Set<String> sets;

    public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
    }

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }
}

（2）在Spring配置文件中

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

    <bean id="stu" class="com.study.spring5.collection.Stu">
        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>java</value>
                <value>c++</value>
            </array>
        </property>
        <!--list类型属性注入-->
        <property name="list">
            <list>
                <value>zhangsan</value>
                <value>zhangsi</value>
            </list>
        </property>
        <!--map属性注入-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="C++" value="c++"></entry>
            </map>
        </property>
        <property name="sets">
            <set>
                <value>abc</value>
                <value>123</value>
            </set>
        </property>
    </bean>
</beans>


public class TestSpring5Demo1 {
    @Test
    public  void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        Stu stu = context.getBean("stu", Stu.class);
        stu.test();
    }
}

输出结果：

[java, c++]
[zhangsan, zhangsi]
{JAVA=java, C++=c++}
[abc, 123]

需要注意的一些细节问题：
1. 在集合里面设置对象类型值

package com.study.spring5.collection;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @Author:
 * @Description:
 * @Date: Created in 22:07 2020/10/12
 * Modified By:
 */
public class Stu {


    //1.数组类型属性
    private String[] courses;
    //2.创建list集合类型属性
    private List<String> list;
    //3.map集合类型属性
    private Map<String,String> maps;
    //4.set集合类型属性
    private Set<String> sets;
    //5.学生所学的多门课程
    private List<Course> courseList;
    public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
        System.out.println(courseList);
    }

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }
}


package com.study.spring5.collection;

/**
 * @Author:
 * @Description:
 * @Date: Created in 22:28 2020/10/12
 * Modified By:
 */
public class Course {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Course{" +
                "name='" + name + '\'' +
                '}';
    }
}


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

    <bean id="stu" class="com.study.spring5.collection.Stu">
        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>java</value>
                <value>c++</value>
            </array>
        </property>
        <!--list类型属性注入-->
        <property name="list">
            <list>
                <value>zhangsan</value>
                <value>zhangsi</value>
            </list>
        </property>
        <!--map属性注入-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="C++" value="c++"></entry>
            </map>
        </property>
        <property name="sets">
            <set>
                <value>abc</value>
                <value>123</value>
            </set>
        </property>
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
                <ref bean="course3"></ref>
            </list>
        </property>
    </bean>

    <!--创建多个course对象-->
    <bean id="course1" class="com.study.spring5.collection.Course">
        <property name="name" value="HTML"></property>
    </bean>
    <bean id="course2" class="com.study.spring5.collection.Course">
        <property name="name" value="CSS"></property>
    </bean>
    <bean id="course3" class="com.study.spring5.collection.Course">
        <property name="name" value="JAVA"></property>
    </bean>

</beans>

public class TestSpring5Demo1 {
    @Test
    public  void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        Stu stu = context.getBean("stu", Stu.class);
        stu.test();
    }
}

输出结果：

[java, c++]
[zhangsan, zhangsi]
{JAVA=java, C++=c++}
[abc, 123]
[Course{name='HTML'}, Course{name='CSS'}, Course{name='JAVA'}]

2. 把集合注入部分提取出来

  1. 在Spring配置文件中引入名称空间util
    在这里插入图片描述

  2. 使用util标签完成list集合注入提取

public class Book {
    private List<String> list;

    public void setList(List<String> list) {
        this.list = list;
    }


    public void test() {
        System.out.println(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:p="http://www.springframework.org/schema/p"
       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>java</value>
            <value>html</value>
            <value>css</value>
        </util:list>
        <!--提取list集合类型属性注入使用-->
    <bean id="book" class="com.study.spring5.collection.Book">
        <property name="list" ref="bookList"></property>
    </bean>

</beans>

 @Test
    public  void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        Book book= context.getBean("book", Book.class);
        book.test();
    }

输出结果：

[java, html, css]

IOC操作Bean管理（FactoryBean）

  1. Spring有两种类型的bean，一种普通bean，一种工厂bean（FactoryBean）
  2. 普通bean：在配置文件中定义什么类型就返回什么类型；
  3. 工厂bean：在配置文件中定义的类型和返回的类型可以是不同的；
    第一步，创建一个类作为工厂Bean，实现接口FactoryBean；
    第二步，实现接口里面的方法，在实现的方法中定义返回的bean类型；

普通bean：

public class MyBean{

}

@Test
    public  void test3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        MyBean myBean= context.getBean("myBean", MyBean.class);
        System.out.println(myBean);
    }

<?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:p="http://www.springframework.org/schema/p"
       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">

    <bean id="myBean" class="com.study.spring5.factoryBean.MyBean">
    </bean>

</beans>

工厂bean：

public class MyBean implements FactoryBean<Course>{

    @Override
    public Course getObject() throws Exception {
        //返回什么类型主要由这个方法控制
        Course course = new Course();
        course.setName("JAVA");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}


<?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:p="http://www.springframework.org/schema/p"
       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">

    <bean id="myBean" class="com.study.spring5.factoryBean.MyBean">//定义返回MyBean
    </bean>

</beans>

@Test
    public  void test3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        Course course= context.getBean("myBean", Course.class);//实际返回Course
        System.out.println(course);
    }

输出结果：

Course{name='JAVA'}

IOC操作Bean管理（bean的作用域）

  1. 在Spring里面，设置bean实例是单实例还是多实例
  2. 在Spring里面，默认情况下是单实例对象
    @Test
    public  void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        Book book1= context.getBean("book", Book.class);
        Book book2 = context.getBean("book", Book.class);
        System.out.println(book1);
        System.out.println(book2);
    }

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:p="http://www.springframework.org/schema/p"
       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>java</value>
            <value>html</value>
            <value>css</value>
        </util:list>
        <!--提取list集合类型属性注入使用-->
    <bean id="book" class="com.study.spring5.collection.Book">
        <property name="list" ref="bookList"></property>
    </bean>

</beans>

输出结果：

com.study.spring5.collection.Book@223191a6
com.study.spring5.collection.Book@223191a6

3.通过设置scope设置bean是单实例或多实例
第一个值，默认值，singleton，表示单实例对象
第二个值，prototype表示多实例对象

修改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:p="http://www.springframework.org/schema/p"
       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>java</value>
            <value>html</value>
            <value>css</value>
        </util:list>
        <!--提取list集合类型属性注入使用-->
    <bean id="book" class="com.study.spring5.collection.Book" scope="prototype">//通过这里的scope设置多实例
        <property name="list" ref="bookList"></property>
    </bean>

</beans>

输出结果：

com.study.spring5.collection.Book@223191a6
com.study.spring5.collection.Book@49139829
singleton和prototype区别
  1. singleton单实例，prototype多实例
  2. 设置scope值是singleton时，加载spring配置文件的时候就会创建实例对象
  3. 设置scope值是prototype时，在调用getBean方法时创建多实例对象

IOC操作Bean管理（bean的生命周期）

什么是生命周期？

  1. 从对象创建到销毁的过程

bean生命周期

  1. 通过构造器创建bean实例（无参构造）
  2. 为bean的属性设置值和对于其他bean引用（调用set方法）
  3. 调用bean的初始化方法（需要进行配置初始化的方法）
  4. bean可以使用了（对象获取到了）
  5. 当容器关闭的时候，调用bean的销毁的方法（需要进行配置销毁的方法）

public class Order {
    private String oname;


    public Order() {
        System.out.println("1.调用无参构造方法");
    }

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("2.对bean的属性设置值");
    }
    public void initMethod(){
        System.out.println("3.初始化方法");
    }
    public void destroy(){
        System.out.println("5.destroy bean");
    }
}


 @Test
    public  void test4(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        Order order= context.getBean("order", Order.class);
        System.out.println(order);
        //手动bean实例销毁
        context.close();
    }

<?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:p="http://www.springframework.org/schema/p"
       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">

    <bean id="order" class="com.study.spring5.bean.Order" init-method="initMethod" destroy-method="destroy">
        <property name="oname" value="airpods"></property>
    </bean>

</beans>

输出结果：

1.调用无参构造方法
2.对bean的属性设置值
3.初始化方法
com.study.spring5.bean.Order@158da8e
5.destroy bean

bean生命周期 bean的后置处理器

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

演示：添加后置处理器的效果

  1. 创建类，实现接口BeanPostProcessor，创建后置处理器
  2. xml文件中，配置后置处理器
//后置处理器
public class MyBean implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化方法之前，postProcessBeforeInitialization");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化方法之前，postProcessAfterInitialization");
        return bean;
    }
}

输出结果：

1.调用无参构造方法
2.对bean的属性设置值
初始化方法之前，postProcessBeforeInitialization
3.初始化方法
初始化方法之前，postProcessAfterInitialization
com.study.spring5.bean.Order@7c729a55
5.destroy bean

IOC操作Bean管理（xml自动装配）

通过autowire实现自动装配
bean标签属性autowire常用的两个值：
byName：根据属性名称注入，注入值bean的id值和类属性名一样；
byType：根据类型注入，但是如果有两个该类型的bean配置，则会报错，spring不确定你需要哪个bean

public class Dep {
    @Override
    public String toString() {
        return "Dep{}";
    }
}


public class Emp {
    private Dep dep;

    public void setDep(Dep dep) {
        this.dep = dep;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "dep=" + dep +
                '}';
    }
    public void test(){
        System.out.println(dep);
    }
}


<?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:p="http://www.springframework.org/schema/p"
       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">

    <bean id="emp" class="com.study.spring5.autowire.Emp" autowire="byName">

    </bean>
    <bean id="dep" class="com.study.spring5.autowire.Dep"></bean>
</beans>

@Test
    public  void test5(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean6.xml");
        Emp emp= context.getBean("emp", Emp.class);
        System.out.println(emp);
        emp.test();
    }

输出结果：

Emp{dep=Dep{}}
Dep{}

IOC操作Bean管理（外部属性文件）

  1. 直接配置数据库信息：配置德鲁伊连接池，引入德鲁伊连接池的jar包
  2. 创建外部属性文件，properties格式文件，写上数据库信息
  3. 把外部properties属性文件引入到spring配置文件中（引入context名称空间）
        <dependency>  
                <groupId>com.alibaba</groupId>  
                <artifactId>druid</artifactId>  
                <version>1.0.9</version>  
            </dependency>

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

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.userName=root
prop.password=root

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

    <!--在spring配置文件中使用标签引入外部属性文件-->
    <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>

IOC操作Bean管理（基于注解方式）

  1. 什么是注解？
    注解是代码的特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值...）
  2. 使用注解，注解可以作用在类、方法、属性上面
  3. 使用注解的目的是为了简化xml配置

Spring针对Bean管理中创建对象提供注解
@Component：把普通pojo实例化到spring容器中
@service：用于标注控制层
@Controller：用于标注服务层，主要用来进行业务的逻辑处理
@Repository：用于标注数据访问层，也可以说用于标注数据访问组件，即DAO组件

上面四个注解功能是一样的，都可以用来创建bean实例

基于注解实现对象创建
  1. 引入aop的依赖
  2. 开启组件的扫描
  3. 创建类，加上注解
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>


<?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:p="http://www.springframework.org/schema/p"
       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.study.spring5"></context:component-scan>

</beans>

//value可以省略，默认为类名的首字母小写
@Service(value = "userService")//类似于<bean name="  class=" ...>
public class UserService {
    public void add(){
        System.out.println("add...");
    }
}


public class TestSpring5Demo1 {
    @Test
    public void testService(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService",UserService.class);
        System.out.println(userService);
        userService.add();
    }
}

加载配置文件，在配置文件中只配置了“<context:component-scan base-package="com.study.spring5"></context:component-scan>”开启了组件扫描，Spring知道我们要通过注解创建对象了，那么它会到我们所配置的包路径下，找到所有类进行扫描，找到有相关注解的类进行对象创建

开启组件扫描的细节：

<?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:p="http://www.springframework.org/schema/p"
       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.study.spring5"></context:component-scan>


    <!--示例1：
        user-default-filters="false" 表示现在不使用默认的filter，自己配置filter
        context:includer-filter 设置扫描哪些内容，本示例中只扫描包含Controller这个注解的类
    --><context:component-scan base-package="com.study.spring5">
            <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>

    <!--示例1：
        user-default-filters="false" 表示现在不使用默认的filter，自己配置filter
        context:includer-filter 设置不去扫描哪些内容，本示例中不扫描包含Controller这个注解的类
    --><context:component-scan base-package="com.study.spring5">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

</beans>
基于注解实现属性注入
  • @AutoWired：根据属性类型进行自动注入/装配
  • @Qualifier：根据属性名称注入
  • @Resource：可以根据类型注入，也可以根据名称注入
  • @Value：注入普通类型属性
public interface UserDao {
    public void add();
}


@Repository
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("userDaoImpl");
    }
}


//value可以省略，默认为类名的首字母小写
@Service(value = "userService")//类似于<bean name="  class=" ...>
public class UserService {

    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
    @Autowired//根据类型进行注入，找到userDao的实现类userDaoImpl
    private UserDao userDao;
    public void add(){
        System.out.println("add...");
        userDao.add();
    }
}

@Test
    public void testService(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService",UserService.class);
        System.out.println(userService);
        userService.add();
    }

@Autowried根据类型进行注入，当userDao有多个实现类是，不确定注入哪一个实现类，可以使用@Qualifier（value = ‘xxx’）

@Resource//根据类型进行注入
private UserDao userDao;

@Resource(name = "userDaoImpl")//根据名字进行注入
private UserDao userDao;

@Resource并不是java本身所提供的，import javax.annotation.Resource;Spring官方更建议使用@Autowried

	@Value(value = "123")
    private String username;
完全注解开发

1.创建配置类，替代xml配置文件。
2.编写测试类

@Configuration  //作为配置类，替代xml文件
@ComponentScan(basePackages = {"com.study.spring5"})//开启组件扫描
public class SpringConfig {
}

@Test
    public void testService(){
        //加载配置类
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService",UserService.class);
        System.out.println(userService);
        userService.add();
    }
_白月光梦境
关注
专栏目录
Spring ——Spring IoC容器详解（图示）
云源
02-20 399
1.1 Spring IoC容器 从昨天的例子当中我们已经知道spring IoC容器的作用，它可以容纳我们所开发的各种Bean。并且我们可以从中获取各种发布在Spring IoC容器里的Bean，并通过描述得到它。 1.2 Spring IoC容器的设计 　　Spring IoC容器的设计主要是基于BeanFactory和ApplicationContext两个接口，其中A...
细说Spring——IoC详解（IoC概览）
啦啦啦的博客
05-12 2692
一、前言 我之前写过一个专栏Sping+SpringMVC+Mybatis学习笔记，这个专栏主是我在学习SSM的一些笔记，但是这个专栏中只讲解了怎么使用Spring框架，但是却很少涉及Spring原理性的知识，为了弥补这个不足，我决定再开一个专栏，专门记录我对Spring原理性知识的了解，希望能够帮助Spring的初学者快速建立起对Spring框架的认知。 这里的很多知识都是通过阅读《Spri...
spring的IOC容器
ZgaoYi的博客
04-21 1524
文章目录1. IOC、IOC容器、Bean、DI2. 核心概念小结3，入门案例3.1 IOC入门案例3.1.1 入门案例思路分析3.1.2 入门案例代码实现步骤1:创建Maven项目步骤2:添加Spring的依赖jar包步骤3:添加案例中需要的类步骤4:添加spring配置文件步骤5:在配置文件中完成bean的配置步骤6:获取IOC容器步骤7:从容器中获取对象进行方法调用步骤8:运行程序3.2 DI入门案例3.2.1 入门案例思路分析3.2.2 入门案例代码实现步骤1: 去除代码中的new步骤2:为属性提供
Spring5入门
最新发布
LH1013886337的博客
10-12 920
Spring 是轻量级的开源的 JavaEE 框架Spring 可以解决企业应用开发的复杂性Spring 有两个核心部分：IOC 和 AopSpring 特点jar包地址:https://repo.spring.io/release/org/springframework/spring/</</
Spring IOC容器
Jak的博客
11-20 424
一、Spring框架概述 1.1 概述 1.Spring是轻量级的开源JavaEE框架 2.Spring可以解决企业应用开发的复杂性 3.Spring有两个核心部分：IOC和AOP IOC: 控制反转，把创建对象过程交给Spring进行管理。 Aop：面向切面编程，不修改源代码的情况下，进行功能增强。 4.Spring特点 方便解耦，简化开发 Aop编程支持 方便程序测试 方便和其他框架进行整合 方便进行事务操作 降低API开发难度 1.2入门案例 1.2.1 创建类User .
Spring IoC容器
不能如期而至的专栏
08-09 672
Spring IoC容器 谈及SpringBoot，必须要说Spring，而Spring IoC容器是Spring容器的内核。APO、声明式事务等功能都是在此基础之上开花结果的。 一. 什么是IoC IoC(Inverse of Control) 即控制反转。 所谓的反转，就是通过容器来控制业务对象的之间的依赖关系，而非传统实现中，由代码直接操控。这也是控制反转的概念所在：控制权由应用代码转移...
Spring 中的 IoC 容器
WriteOnRead
01-18 222
概述 对于 Java 后端开发而言，Spring 框架的重要性不言而喻。而 Spring 中最核心的无非就是 IoC 和 AOP。相关的概念不再赘述，网上可以找到很多对它们的介绍。这里想...
Spring源码详解：IOC容器核心功能与实现
Spring源码分析深入探讨了Spring框架的核心组件——IoC（Inversion of Control，控制反转）容器在框架中的关键作用。BeanFactory是Spring中最基本的IoC容器接口，它是应用程序与Spring框架交互的核心桥梁。Spring...
细说Spring——IoC详解（XML配置一）
啦啦啦的博客
05-14 4043
在我们经过了： 细说Spring——IoC详解（一） 细说Spring——IoC详解（二） 细说Spring——IoC详解（三） 的学习之后，已经对Spring的Ioc容器有了一定的了解，我们队容器如何创建对象有了细致的了解，接下来就是一些其他零零散散的东西，这一期就主要讲解Spring IoC容器的XML配置文件。 一、我们应该怎么理解和认识Spring的配置文件呢？ 其实，Sp...
JAVAWEB开发之Spring详解之——Spring的入门以及IOC容器装配Bean(xml和注解的方式)、Spring整合web开发、整合Junit4测试
04-22 2924
Spring框架学习路线 Spring的IOCSpring的AOP，AspectJSpring的事务管理，三大框架的整合 Spring框架概述 什么是Spring？  Spring是分层的JavaSE/EE full-stack(一站式)轻量级开源框架。 所谓分层： SUN提供的EE的三层结构：web层、业务层、数据访问层(也称持久层，集成层)。Struts2是we
Spring之IoC容器篇
kissship的博客
08-17 1399
Spring是一个开源的应用程序开发框架，它由Rod Johnson创建，主要用于构建企业级Java应用程序。它提供了一个全面的编程和配置模型，可以简化Java开发过程，提高开发效率和可维护性。即为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。目的：解决企业应用开发的复杂性功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能范围：任何Java应用简单来说，
springIOC容器
AlbenXie的博客
05-26 644
利用SpringIOC实现策略模式有必要使用ConcurrentHashMap吗？ 1、 Spring 项目中很多 bean 都设计成配置完成后线程安全的, 也是就是在 Spring 初始化阶段, 因为 Spring 本身是单线程初始化, 不会遇到问题, 初始化完成后, 不再修改, 属性只读, 也就不存在多线程修改造成竞态的问题. 你要确保在使用过程中不修改, 也就不需要 Concurrent...
Spring IOC 容器
HanQiuyue123的博客
04-21 178
目录 一、搭建Sping开发环境 二、IOC容器及Bean的配置 三、Bean 在IOC 容器中 的生命周期方法 四、注入依赖方式 五、注入依赖对象 六、注入集合 七、util schema 及bean之间的关系 八、P命名空间 九、引入外部属性文件 十、Spring表达式语言：SpEL 下面是学习时的一些资料和练习整理： 一、搭建Sping开发环境 所...
Spring之IOC容器
qq_36851469的博客
01-30 569
IOC容器 DefaultSingletonBeanRegistry中singletonObjects就是自定义Bean最终的IOC容器。 入口：AbstractApplicationContext–>finishBeanFactoryInitialization(beanFactory) DefaultListableBeanFactory /** Map of bean definit...
Spring_IOC 容器
m0_70703282的博客
05-22 888
FactoryBean 工厂Bean1.设计模式：工厂方法设计模式2.implements FactoryBean<Person>接口2.1 public Xxx getObject(){} 实际返回的bean实例> getObjectType(){} 实际返回的bean的类型2.3 public boolean isSingleton() {} 实际返回的bean是否是单例，true则是单例@Component//1.实际从IOC容器中获取的实例bean，即Person。
Spring_IOC容器
sunnyez的博客
05-26 126
Spring5 IOC容器
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值