【Spring】二、IoC（上）（xml配置）

最新推荐文章于 2023-07-20 20:00:00 发布
最新推荐文章于 2023-07-20 20:00:00 发布
阅读量137 收藏
点赞数
分类专栏： Spring 文章标签： spring java xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41365204/article/details/130220588
版权

IoC（上）（xml配置）

Spring通过IoC容器来进行管理、所有的JAVA对象的实例化和初始化，控制对象之间的依赖关系，通过IoC进行管理的对象叫做Java Bean，其在本质上与自己new出来的对象没有区别。

IoC是一种思想，不是一种技术，其将创建对象和维护对象之间关系的权利交出去，降低了耦合度，提高了扩展性。

IoC中的抽象类 BeanDefinitionReader 所实例化的方法，会通过Bean的信息通过BeanFactory+反射的方式对java bean进行实例化，再初始化，最终得到实例对象（使用contex.getBean()可以获取对象）。

依赖注入

DI（依赖注入）实现了控制反转的思想

依赖注入是指在spring创建对象的过程中，将对象依赖属性通过配置注入。

依赖注入常使用set注入或构造注入的方式进行。

IoC容器使用BeanFactory进行实现，但该接口不对开发人员开放，其子接口ApplicationContext面相spring的使用者。

Bean管理的两种方式

基于xml配置文件进行Bean管理

将之前在子模块的POM.xml文件中的以来配置修改到父工程的POM.xml文件中。

在Java中创建一个User类：

package com.qinghe.spring6.iocxml;

public class User {
    private String name;
    private Integer age;

    public void run() {
        System.out.println("run....................");
    }
}

在Bean.xml中创建一个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">
    <bean id="user" class="com.qinghe.spring6.iocxml.User"></bean>
</beans>

Bean的获取

创建一个ApplicationContext对象，根据该ApplicationContext对象获取需要的Bean

  • 根据bean.xml中的id进行获取
  • 根据类型进行获取
  • 根据id和类型获取
        //创建一个ApplicationContext对象，用来获取Bean
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");

        //1 利用context对象获取Bean对象（根据id）
        User user1 = (User)context.getBean("user");
        System.out.println("根据id获取Bean:" + user1);

        //2 利用类型获取Bean对象
        User user2 = context.getBean(User.class);
        System.out.println("根据类型获取Bean:" + user2);

        //3 利用id和类型获取Bean对象
        User user3 = context.getBean("user", User.class);
        System.out.println("根据id和类型获取Bean:" + user3);

若UserDao.class获取到的是一个接口，则会自动获取它的实现类（前提是实现类在bean.xml中进行过配置），但若在bean.xml中配置过多个UserDao的实现类，则无法自动获取（不知道要的是哪个）

        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        
        //如果通过类型获取的是一个接口，则获取到的自动是他的实现类userDaoImpl
        UserDao userDao = context.getBean(UserDao.class);
        System.out.println(userDao);
        userDao.run();
    }

依赖注入

基本类型依赖注入

依赖注入是指向类中的属性注入数值，有利用set进行注入与利用构造器进行注入等方式

  • 基于set方法进行依赖注入

    在bean中对属性要生成set方法，在配置文件中进行相应的配置，在测试文件中使用IoC进行创建对象时就会由spring自动进行依赖注入，得到一个有属性值的对象。

    bean-di.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">

<!--    进行类的配置与依赖的注入-->
    <bean id="book" class="com.qinghe.spring6.iocxml.di.Book">
<!--        property标签调用set方法注入具体的依赖-->
        <property name="bname" value="芜湖起飞"></property>
        <property name="author" value="大司马"></property>
    </bean>
</beans>

  • 基于构造器进行注入

    在配置文件中进行相应的配置、标签为constructor-arg。

    <!--    基于构造器进行依赖注入-->
    <bean id="bookCon" class="com.qinghe.spring6.iocxml.di.Book">
<!--        构造器注入的方式-->
        <constructor-arg name="bname" value="红楼梦"></constructor-arg>
        <constructor-arg name="author" value="曹雪芹"></constructor-arg>
    </bean>

若要赋null，则应该在property标签下使用null标签

    <property name="others">
        <null/>
    </property>

特别的，若要在属性中赋"<“或”>"则应该使用xml实体（转义）使用&lt;表示<， 使用&gt;表示>。（别忘记分号）

<property name="others" value="&lt;&gt;"></property>

更特别的，xml支持使用CDATA区来对符号（>，<）进行解析，解析的结果会完全成立为CDATA区内的结果，不会被误识别。

    <property name="others">
        <value>[!CDATA[a > b]]</value>
    </property>

对象类型依赖注入

若需要注入每个对象类型的数据，则要提前在bean中声明好，再进行注入

  • 引入外部bean的方式
    <bean id="dept" class="com.qinghe.spring6.iocxml.ditest.Dept">
        <property name="dname" value="安保部"></property>
    </bean>
    <bean id="emp" class="com.qinghe.spring6.iocxml.ditest.Emp">
<!--        ref属性可以将一个已经在xml中配置完成的类所创建的对象作为参数传递给另一个类-->
        <property name="dept" ref="dept"></property>
        <property name="ename" value="马冬梅"></property>
        <property name="age" value="18"></property>
    </bean>

这种通过ref属性引入另一个Bean标签的方式来注入对象的方式叫做通过引入外部bean的方式进行对象类型的依赖注入。

  • 内部Bean方式进行依赖注入
    <bean id="emp2" class="com.qinghe.spring6.iocxml.ditest.Emp">
        <property name="dept">
            <bean id="dept2" class="com.qinghe.spring6.iocxml.ditest.Dept">
                <property name="dname" value="财务部"></property>
            </bean>
        </property>
        <property name="ename" value="mary"></property>
        <property name="age" value="3"></property>
    </bean>

在一个Bean中创建另一个Bean的方式叫做内部Bean的方式进行依赖注入

  • 级联赋值

    级联赋值可以在xml文件中实现对已有属性的赋值：

        <bean id="dept" class="com.qinghe.spring6.iocxml.ditest.Dept"></bean>
    <bean id="emp" class="com.qinghe.spring6.iocxml.ditest.Emp">
      <property name="ename" value="tom"></property>
        <property name="age" value="999"></property>
        <property name="dept" ref="dept"></property>
        <!-- 使用级联赋值进行部门信息的更新操作 -->
        <property name="dept.dname" value="使用级联赋值更新了部门信息"></property>
    </bean>

数组类型依赖注入

若bean对象中存在一个数组，要通过如下配置方式对数组进行依赖注入

    <bean id="dept" class="com.qinghe.spring6.iocxml.ditest.Dept">
        <property name="dname" value="数组测试部"></property>
    </bean>
    <bean id="emp" class="com.qinghe.spring6.iocxml.ditest.Emp">
        <property name="ename" value="Huying"></property>
        <property name="age" value="18"></property>
        <property name="dept" ref="dept"></property>
        <!-- 对数组类型的成员变量进行赋值 -->
        <property name="loves">
            <array>
                <value>吃饭</value>
                <value>睡觉</value>
                <value>赖床</value>
            </array>
        </property>
    </bean>

集合类型依赖注入

  • List型依赖注入方式：
<!--    注入emp类型对象-->
    <bean id="emp1" class="com.qinghe.spring6.iocxml.ditest.Emp">
        <property name="ename" value="huying"></property>
        <property name="age" value="18"></property>
    </bean>
<!--    再引入一个emp类型的对象-->
    <bean id="emp2" class="com.qinghe.spring6.iocxml.ditest.Emp">
        <property name="ename" value="yinghu"></property>
        <property name="age" value="81"></property>
    </bean>

<!--    注入一个dept类型的对象-->
    <bean id="dept" class="com.qinghe.spring6.iocxml.ditest.Dept">
<!--        注入普通属性-->
        <property name="dname" value="List部"></property>
<!--        注入list类型的属性（若list保存的是对象，则要用ref标签，若保存的是普通的数据类型，则可以使用value标签）-->
        <property name="empList">
            <list>
                <ref bean="emp1"></ref>
                <ref bean="emp2"></ref>
            </list>
        </property>
    </bean>
  • Map型依赖注入的方式
   <bean id="student" class="com.qinghe.spring6.iocxml.dimap.Student">
        <property name="sid" value="1200"></property>
        <property name="sname" value="张三"></property>
<!--        在student对象之中注入map，-->
        <property name="teacherMap">
            <map>
<!--                每一个键值对使用entry标签注入-->
                <entry>
                    <key>
                        <value>000001</value>
                    </key>
<!--                    对象类型的属性要用ref标签注入-->
                    <ref bean="teacher1"></ref>
                </entry>
                <entry>
                    <key>
                        <value>000002</value>
                    </key>
                    <ref bean="teacher2"></ref>
                </entry>
            </map>
        </property>
    </bean>

<!--    注入两个teacher类型的普通对象用于演示-->
    <bean id="teacher1" class="com.qinghe.spring6.iocxml.dimap.Teacher">
        <property name="teacherId" value="110"></property>
        <property name="teacherName" value="西门"></property>
    </bean>

    <bean id="teacher2" class="com.qinghe.spring6.iocxml.dimap.Teacher">
        <property name="teacherId" value="111"></property>
        <property name="teacherName" value="上官"></property>
    </bean>

  • 引入bean类型的方式进行list、map的注入

    在使用bean类型引入的方式进行注入时，需要提前对命名空间进行配置：

    在beans标签的属性中添加xmlns:util="http://www.springframework.org/schema/util"

    并在xsi:schemaLocation中添加两行网址：

                       http://www.springframework.org/schema/util
                   http://www.springframework.org/schema/util/spring-util.xsd

最终效果（bean-diref.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: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">

<!--    util:list标签在外引入list-->
    <util:list id="lessonList">
        <ref bean="lesson1"></ref>
        <ref bean="lesson2"></ref>
    </util:list>

<!--    util:map标签在外注入map-->
    <util:map id="teacherMap">
<!--        注入120021 - teacher1的键值对-->
        <entry>
            <key>
                <value>120021</value>
            </key>
            <ref bean="teacher1"></ref>
        </entry>
        <entry>
            <key>
                <value>120012</value>
            </key>
            <ref bean="teacher2"></ref>
        </entry>
    </util:map>

<!--    创建一个student对象-->
    <bean id="student" class="com.qinghe.spring6.iocxml.dimap.Student">
        <property name="sid" value="10086"></property>
        <property name="sname" value="金毛"></property>
<!--        注入生成的list和map-->
        <property name="lessonList" ref="lessonList"></property>
        <property name="teacherMap" ref="teacherMap"></property>
    </bean>

<!--    创建两个teacher对象进行准备-->
    <bean id="teacher1" class="com.qinghe.spring6.iocxml.dimap.Teacher">
        <property name="teacherId" value="001"></property>
        <property name="teacherName" value="上官"></property>
    </bean>
    <bean id="teacher2" class="com.qinghe.spring6.iocxml.dimap.Teacher">
        <property name="teacherId" value="002"></property>
        <property name="teacherName" value="西门"></property>
    </bean>

<!--    创建两个Lesson对象进行准备-->
    <bean id="lesson1" class="com.qinghe.spring6.iocxml.dimap.Lesson">
        <property name="lesson" value="屠龙剑法"></property>
    </bean>
    <bean id="lesson2" class="com.qinghe.spring6.iocxml.dimap.Lesson">
        <property name="lesson" value="走为上计"></property>
    </bean>
</beans>

p命名空间注入

在beans的属性配置中添加一行：

xmlns:p="http://www.springframework.org/schema/p"

就引入了p命名空间，可以在bean的配置中快速进行属性以及数据的配置

    <bean id="studentp" class="com.qinghe.spring6.iocxml.dimap.Student"
          <!-- 使用p空间进行配置，-ref代表引入外部bean标签 -->
          p:sid="002" p:sname="Dasima" p:lessonList-ref="lessonList" p:teacherMap-ref="teacherMap">
    </bean>

引入外部属性文件

通常在开发过程中，手动进行配置xml文件是相当复杂且难以维护的，故添加引入外部属性文件的方式进行管理

  • 添加演示使用依赖：mysql、druid

        <dependencies>
<!--        mysql数据库依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.31</version>
        </dependency>
    </dependencies>

  • 配置jdbc.properties文件

jdbc.user=root
jdbc.password=123456
jdbc.url=jdbc:mysql://loaclhost:3306/spring?serverTimezone=UTC
jdbc.driver=com.mysql.cj.Driver
  • 配置命名空间：

添加这几样命名空间的配置

xmlns:context="http://www.springframework.org/schema/context"       

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd"
  • 添加文件的引入以及属性的配置
<!--    引入外部属性文件,之后可以在属性添加中进行操作-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

<!--    进行依赖注入，使用${}符号可以动态表示-->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"></property>
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="username" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

这样就配置好了数据库的信息，若要修改数据库信息则只需要修改jdbc.properties文件，不再需要进入.xml文件中进行配置

关于Bean

Bean的作用域

Spring中可以配置Bean的scope属性来配置Bean的作用域，singleton代表该对象在IoC容器中始终为单例，在IoC容器初始化时进行创建

prototype代表这个bean在IoC容器中有多个实例，在获取bean时才进行创建。

若是singleton则会在ApplicationContext对象创建时就创建了注入的对象（这体现在日志信息中）（scope默认为singleton）。

而proptotype会在.getBean()时才创建对象。

若是在WebApplicationContext环境下还有另外两种作用域

request指在一次请求中有效、session指在一个会话范围内有效

Bean的生命周期

  1. 调用无参构造器创建对象
  2. 为bean设置内部属性（调用set方法）
  3. bean后置处理器（初始化前）（调用spring文件中的某一个BeanPostProcess接口的一个实现类，该实现类的两个方法中的postProcessBeforeInitialization方法会在作为后置处理器先调用）
  4. bean对象初始化（会调用指定的初始化方法（该方法可以在bean标签中通过init-method属性设置））（该方法可以在类中设置）
  5. bean后置处理器（初始化后）（调用spring文件中的某一个BeanPostProcess接口的一个实现类，该实现类的两个方法中的postProcessAfterInitialization方法会在作为后置处理器后调用）
  6. bean对象创建完成、可以调用了
  7. bean对象销毁（会调用指定固定销毁方法，（该方法可以在bean标签中通过destroy-method属性设置））（该方法可以在类中设置）
  8. IoC容器关闭

ClassPathXmlApplicationContext中有.close()方法可以对对象进行销毁

注意，后置处理器中的方法也可以自己定义，要自己建立一个BeanPostProcessor接口的实现类并且重写两个后置处理器的方法，之后在xml文件夹中进行如下配置：

<bean id="起一个名字" class="实现类的全路径"></bean>

后置处理器的自定义：

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("3 bean后置处理器，初始化之前执行");
        System.out.println(beanName + "::" + bean);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("5 bean后置处理器，初始化之后执行");
        System.out.println(beanName + "::" + bean);
        return bean;
    }
}

FactoryBean

FactoryBean是spring中的一个接口，实现了这个接口的类要实现两个方法：

    @Override
    public User getObject() throws Exception {
        return new User();
    }

    @Override
    public Class<?> getObjectType() {
        return User.class;
    }

在xml文件中正常配置这个java类。

其中特殊的是，FactoryBean创建的是getObject()方法中返回的对象，而不是本身类的对象。

xml自动装配

xml文件中的配置不需要自己编写，Bean标签下的autowire属性可以自动在配置文件中找到合适的bean并配置到自己需要的属性中。

autowire有 byType、byName两种方法。

byType会根据自身bean需要的类型在配置文件（IoC容器）中寻找合适的对象。

byName会根据其他bean的id与自己需要的属性的属性名（自己定义的那个名字）来寻找合适的对象并进行注入。

    <bean id="userController" class="com.qinghe.spring6.iocxml.auto.controller.UserController" autowire="byType">

    </bean>

    <bean id="userService" class="com.qinghe.spring6.iocxml.auto.service.UserServiceImpl" autowire="byType">

    </bean>

    <bean id="userDao" class="com.qinghe.spring6.iocxml.auto.dao.UserDaoImpl">

    </bean>
清河__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手写SpringIoc的XML实现方式
01-24
手写SpringIoc的XML实现方式，仿照Spring底层Bean工厂类实现ClassPathXmlApplicationContext
配置IOC的方式（配置文件和注解）
Circ
07-07 327
注解方式和配置文件方式都有自己的适用场景和优劣势，具体选择哪种方式取决于项目的需求、团队的偏好和开发的复杂度。一般而言，注解方式适合简单的依赖注入场景，而配置文件方式适合复杂的依赖注入和需要灵活配置的场景。难以配置复杂依赖：对于复杂的依赖关系，使用注解方式可能会变得复杂和难以配置，可能需要编写大量的注解和参数配置。配置复杂：相比注解方式，配置文件方式可能需要编写更多的配置信息，配置文件的编写和维护可能会增加开发的工作量。注解的使用需要遵循特定的注解规范和语法，需要适应和学习。
Spring IOC的三种配置方式
从事棋.牌行业五年，参与项目从0到1的过程，担任过海外项目的技术负责人，对业务中的俱乐部设计，玩法设计，架构，算法，数据有深刻的理解。
11-28 1553
IOC：        Inversion of Control 控制反转. 指的是对象的创建权反转(交给)给 Spring 管理，想要让Spring帮我们管理对象，前提是将对象交由Spring来创建。 Spring提供了三种IOC的配置： 1、XML声明配置 2、注解声明配置 （推荐） 3、JavaConfig声明配置 （推崇）   XML声明配置       顾名思义，就是将b...
2.IOC之xml配置
Steven的博客
12-09 405
在项目目录“/src/main/java/com/steven”下新建service目录，并在service目录下新建IUserService接口和UserServiceImpl实现类，具体代码如下。
springIOC简单模拟实现-----XML方式
qq_35566295的博客
05-25 231
springIOC简单模拟实现-----XML方式 为了看懂spring底层代码结构，模拟完成了一个依赖注入的小例子，仅供自己更好的理解springIoc。 1、创建一个dao接口和对应的两个实现类。 public interface UserService { public void find(); } public class UserDaoImpl implements UserD...
Ioc配置的三种方式~
weixin_49361731的博客
02-19 98
IOC配置的多种方式
spring IOC容器依赖注入XML配置
02-05
spring IOC容器依赖注入XML配置详解 运行环境：eclipse 构建工具：maven 不提供maven构建，maven用来解决jar包的依赖
Spring5_IOC.pdf
12-30
一图详解IOC
day02_eesy_02xml_IOC.zip
12-28
spring配置xml完成IOC,这只是其中一个spring配置xml完成IOC,这只是其中一个spring配置xml完成IOC,这只是其中一个spring配置xml完成IOC,这只是其中一个spring配置xml完成IOC,这只是其中一个spring配置xml完成IOC,这...
Spring-IoC 复习笔记.rar
10-23
《Spring-IoC 复习笔记》博客附件。 博客地址：https://blog.csdn.net/Supreme_Sir/article/details/109165058
IOC的两种实现——xml与注解(最全讲解与代码示例)
zsy_yyds的博客
10-18 544
IOC实现的万字讲解，满满的科技与狠活
Spring IoC的模拟实现
卧龙居
09-15 1410
Spring最重要的两大块，一个是依赖注入，另一个就是切面编程。其中，依赖注入用的范围更广。在WEB编程之中，通过xml来配置各个Bean之间的关系，使得开发过程更符合高内聚，低耦合的要求。 众所周知，使用Spring时，需要定义一个listener在web.xml文件中。当请求到达服务器是，根据listener，就会自动读取配置的applicationContext.xml文件。这个xml文件
Spring的xml文档配置
Dylan6868的博客
05-12 3712
1 2注解的context名称空间 <?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
Spring_Ioc基本配置使用（基于xml）
qq_41931364的博客
07-20 475
Spring_Ioc1、IOC简介1.1、什么是IOC2、容器2.1、容器概述 1、IOC简介 1.1、什么是IOC IOC是Inversion of Control的缩写，多数书籍翻译成“控制反转”。 是Spring框架里面管理对象的一个容器。 2、容器 2.1、容器概述 ApplicationContext是Spring容器IOC实现的代表，它负责实例化、配置和组装Bean。容器通过读取配置元数据获取有关实例化、配置和组装哪些对象的说明。配置元数据可以使用xml、Java注解活Java代码来呈现，它允许
Spring-Xml配置
m0_71212413的博客
03-02 2922
Spring-Xml配置
Spring5_IOC容器--基于xml操作
wanananhh的博客
08-17 243
IOC
IOC的模拟实现
weixin_46421861的博客
04-19 143
文章目录Ioc:Ioc的模拟实现： Ioc和Aop是Spring框架中重要的两个技术。 Ioc: Ioc称为控制反转，即不再有APP代码实现对类对象的初始化，而是由Spring完成自动初始化过程。这个过程又称为“注入”。 这里需要通过配置方式，告知Ioc自动注入过程。 Ioc的模拟实现： 1.通过两个注解，实现Ioc注入的配置。 @Component：此注解用于类，表示有此注解的类都将成为一个bean放入beanFactory中。 @Autowired：此注解用于成员或者set方法（主要用于set方法），表
Spring xml配置
weixin_48456383的博客
06-15 1620
Spring 配置xml文件作为IOC容器依赖注入的载体，以及配置aop，扫包的重要手段，在spring项目中至关重要。这里以讨论其中的属性元素，通畅的spring xml布局文件如下 id属性是标识单个bean定义的字符串。 class属性定义bean的类型并使用完全限定的类名。事实上可以使用应用程序上下文构造函数从所有这些XML片段加载bean定义。这个构造函数接受多个Resource位置，譬如 元素的value属性将属性或构造函数......
Spring：xml 配置
最新发布
啊Q老师
07-20 6610
Spring xml配置介绍
spring ioc的spring.xml
05-23
在Spring中，IOC容器是通过XML文件进行配置的。这个XML文件一般被命名为spring.xml或applicationContext.xml。 下面是一个简单的spring.xml文件示例： ``` <?xml version="1.0" encoding="UTF-8"?> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值