Spring：Bean的配置及注解

已于 2023-04-06 23:11:40 修改
阅读量299 收藏 1
点赞数
分类专栏： javaEE 文章标签： spring java junit java-ee intellij-idea
于 2023-03-29 11:46:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52331159/article/details/129832015
版权

目录

搭建环境

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>chapter07</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.0.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.0.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.0.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.8.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.0.8.RELEASE</version>
        </dependency>
    </dependencies>


</project>

applicationContext.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p"
       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">

    <!-- 通过构造器注入成员变量的值 -->
    <bean id="student" class="com.qfedu.bean.Student">
        <constructor-arg name="sid" value="1"/>
        <constructor-arg name="name" value="ZhangSan"/>
        <constructor-arg name="age" value="20"/>
        <constructor-arg name="course" value="Java"/>
    </bean>

    <bean id="teacher" class="com.qfedu.bean.Teacher">
        <property name="tid" value="1"></property>
        <property name="name" value="LiSi"></property>
    </bean>

    <bean id="mix" class="com.qfedu.bean.Mix">
<!--        注入List-->
        <property name="myList">
            <list>
                <value>list01</value>
                <value>list02</value>
            </list>
        </property>
        <!--        注入map-->
        <property name="myMap">
            <map>
                <entry key="key01" value="map01"></entry>
                <entry key="key02" value="map02"></entry>
            </map>
        </property>
        <!--        注入array-->
        <property name="myArray">
            <array>
                <value>array01</value>
                <value>array02</value>
            </array>
        </property>
    </bean>
<!--school测试1-->
<!--    <bean id="school" class="com.qfedu.bean.School">-->
<!--        <property name="stu">-->
<!--            <ref bean="student"></ref>-->
<!--        </property>-->
<!--    </bean>-->
<!-- school测试2-->
<!--    <bean id="school" class="com.qfedu.bean.School">-->
<!--        <property name="stu" ref="student"></property>-->
<!--    </bean>-->
<!--school测试3-->
    <bean id="school" class="com.qfedu.bean.School" p:sid="1" p:stu-ref="student"></bean>

<!--    SpEL注入-->
    <bean id="employee" class="com.qfedu.bean.Employee">
        <property name="eid" value="1"></property>
        <property name="name" value="WangWu"></property>
        <property name="department" value="研发部"></property>
    </bean>
    <bean id="person" class="com.qfedu.bean.Person">
        <property name="pid" value="#{employee.eid}"></property>
        <property name="name" value="#{employee.name}"></property>
    </bean>
<!--    Bean的配置-->
    <bean id="person01" class="com.qfedu.bean.Person"></bean>
    <bean id="person02" class="com.qfedu.bean.Person" scope="prototype"></bean>
<!--    Bean的生命周期-->
<!--    <bean id="bean01" class="com.qfedu.bean.Bean01" init-method="init">-->
<!--        <property name="bid" value="1" />-->
<!--        <property name="name" value="xiaoqian"></property>-->
<!--    </bean>-->
<!--    <bean id="bean02" class="com.qfedu.bean.Bean02">-->
<!--        <property name="bid" value="1" />-->
<!--        <property name="name" value="xiaoqian"></property>-->
<!--    </bean>-->
<!--    <bean id="bean03" class="com.qfedu.bean.Bean03" destroy-method="close">-->
<!--        <property name="bid" value="1" />-->
<!--        <property name="name" value="xiaoqian"></property>-->
<!--    </bean>-->
<!--    <bean id="bean04" class="com.qfedu.bean.Bean04">-->
<!--        <property name="bid" value="1" />-->
<!--        <property name="name" value="xiaoqian"></property>-->
<!--    </bean>-->
<!--    注解-->
    <context:component-scan base-package="com.qfedu.bean"></context:component-scan>
</beans>

1 Bean的配置

1.1 注入方式

1.1.1 注入集合

Mix.class

package com.qfedu.bean;

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

public class Mix {
    private List<String> myList;
    private Map<String,String> myMap;
    private String[] myArray;

    //set方法

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public void setMyArray(String[] myArray) {
        this.myArray = myArray;
    }

    //toString方法

    @Override
    public String toString() {
        return "Mix{" +
                "myList=" + myList +
                ", myMap=" + myMap +
                ", myArray=" + Arrays.toString(myArray) +
                '}';
    }
}

TestSpring03.class 

package com.qfedu.test;

import com.qfedu.bean.Mix;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring03 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new
                ClassPathXmlApplicationContext("applicationContext.xml");
        Mix mix = applicationContext.getBean("mix", Mix.class);
        //输出Mix类对象的信息
        System.out.println(mix);
    }
}

TestSpring03测试结果
Alt

1.1.2 注入其它Bean

School.class

package com.qfedu.bean;

public class School {
    private int sid;
    private Student stu;
//    get/set方法
    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public Student getStu() {
        return stu;
    }

    public void setStu(Student stu) {
        this.stu = stu;
    }
}

TestSpring04.class

package com.qfedu.test;

import com.qfedu.bean.School;
import com.qfedu.bean.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring04 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        School school = applicationContext.getBean("school", School.class);
//        通过school获取student对象，并输出Student对象的xinxi
        Student stu = school.getStu();
        System.out.println(stu);
    }
}

TestSpring04测试结果
Alt

Alt

1.1.3 使用P：命名空间注入

TestSpring05.class

package com.qfedu.test;

import com.qfedu.bean.School;
import com.qfedu.bean.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring05 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        School school = applicationContext.getBean("school", School.class);
        int sid = school.getSid();
        System.out.println("sid:"+sid);
        Student stu = school.getStu();
        System.out.println(stu);
    }
}

TestSpring05测试结果
Alt

1.1.4 使用SpEL注入

Person.class

package com.qfedu.bean;

public class Person {
    private int pid;
    private String name;

    public void setPid(int pid) {
        this.pid = pid;
    }

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

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

TestSpring06.class

package com.qfedu.test;

import com.qfedu.bean.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring06 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = applicationContext.getBean("person", Person.class);
        System.out.println(person);
    }
}

TestSpring06测试结果
Alt

1.2 Bean的作用域

测试说明singleton返回共享实例，prototype返回新的实例。

TestSpring07.class

package com.qfedu.test;

import com.qfedu.bean.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring07 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//        person01实例
        Person person01_1 = applicationContext.getBean("person01", Person.class);
        Person person01_2 = applicationContext.getBean("person01", Person.class);
//        person01实例
        Person person02_1 = applicationContext.getBean("person02", Person.class);
        Person person02_2 = applicationContext.getBean("person02", Person.class);
//        判断两次获取的实例是否相等
        System.out.println(person01_1==person01_2);
        System.out.println(person02_1==person02_2);
    }
}

TestSpring07测试结果
Alt

1.3 Bean的生命周期

1.3.1 Bean实例初始化之前

Bean01.class

package com.qfedu.bean;

public class Bean01 {
    private String bid;
    private String name;

    public Bean01() {
    }

    public String getBid() {
        return bid;
    }

    public void setBid(String bid) {
        this.bid = bid;
    }

    public String getName() {
        return name;
    }

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

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

    public void init(){
        System.out.println("Bean的初始化完成，调用init()方法");
        System.out.println(this.toString());
    }
}

Bean02.class

package com.qfedu.bean;

import org.springframework.beans.factory.InitializingBean;

public class Bean02 implements InitializingBean {
    private String bid;
    private String name;
//无参构造
    public Bean02() {
    }

    public String getBid() {
        return bid;
    }

    public void setBid(String bid) {
        this.bid = bid;
    }

    public String getName() {
        return name;
    }

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

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

    public void afterPropertiesSet() throws Exception {
        System.out.println("Bean的初始化完成，调用afterPropertiesSet()方法");
        System.out.println(this.toString());
    }
}

TestSpring08.class

package com.qfedu.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring08 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    }
}

TestSpring08测试结果
Alt

Alt

1.3.2 Bean实例销毁之前

Bean03.class

package com.qfedu.bean;

public class Bean03 {
    private String bid;
    private String name;

    public Bean03() {
    }

    public String getBid() {
        return bid;
    }

    public void setBid(String bid) {
        this.bid = bid;
    }

    public String getName() {
        return name;
    }

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

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

    public void close(){
        System.out.println("Bean实例即将销毁，调用claose()方法");
        System.out.println(this.toString());
    }
}

Bean04.class

package com.qfedu.bean;

import org.springframework.beans.factory.DisposableBean;

public class Bean04 implements DisposableBean {
    private String bid;
    private String name;

    public Bean04() {
    }

    public String getBid() {
        return bid;
    }

    public void setBid(String bid) {
        this.bid = bid;
    }

    public String getName() {
        return name;
    }

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

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

    public void destroy() throws Exception {
        System.out.println("Bean实例即将销毁，调用destroy() 方法");
        System.out.println(this.toString());
    }
}

TestSpring09.class

package com.qfedu.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring09 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//        关闭容器，此时Bean实例即将被销毁
        AbstractApplicationContext ac = (AbstractApplicationContext) applicationContext;
        ac.registerShutdownHook();
    }
}

TestSpring09测试结果
Alt
Alt

2 注解

Sch.class

package com.qfedu.bean;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component("sch")
@Scope(scopeName = "singleton")
public class Sch {
    @Value("005")
    private String sid;
    @Autowired
    @Qualifier("stu")
    private Stu stu;

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public Stu getStu() {
        return stu;
    }

    public void setStu(Stu stu) {
        this.stu = stu;
    }

    @Override
    public String toString() {
        return "Sch{" +
                "sid='" + sid + '\'' +
                ", stu=" + stu +
                '}';
    }

    @PostConstruct
    public void init(){
        System.out.println("Bean的初始化完成，调用init()方法");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("Bean的初始化完成，调用destroy()方法");
    }
}

TestSpring10.class

package com.qfedu.test;

import com.qfedu.bean.Sch;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring10 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Sch sch = applicationContext.getBean("sch", Sch.class);
        System.out.println(sch);
        AbstractApplicationContext ac = (AbstractApplicationContext) applicationContext;
        ac.registerShutdownHook();
    }
}

2.1 先导包

Alt

2.2 修改applicationContext.xml配置

Alt
TestSpring10测试结果
Alt

忽儿
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring 注解 配置Bean
weixin_44545672的博客
01-20 225
开发工具与关键技术：eclipse.exe 作者：农村扛粑子 撰写时间：2021年 1月20日 在 Spring 中，尽管使用 XML 配置文件可以实现 Bean 的装配工作，但如果应用中 Bean 的数量较多， 会导致 XML 配置文件过于臃肿，从而给维护和升级带来一定的困难 Java 从 JDK 5.0 以后，提供了 Annotation（注解）功能，Spring 也提供了对 Annotation 技术的全面 支持。 下面就是一些注解的说明与讲解。 1.@Component 可以使用此注解描述
Spring-配置Bean
Bri0117的博客
10-07 309
Spring 配置bean 配置形式：基于XML文件的方式、基于注解的方式、基于java的配置 Bean的配置方式：通过全类名（反射）、通过工厂方法、FactoryBean IOC容器：BeanFactory、ApplicationContext Bean的注入方式：属性Set注入、构造器注入、工厂方法注入（不推荐） 1、基于XML文件的方式 <!-- applicationContext...
spring笔记:bean的自动装配与注解
chf605908340的博客
10-03 177
Bean的自动装配 前提 beans.xml存在要引用的bean 概况 简化以下命令（换一种方式表现引用bean）变成自动引用 <bean id="user" class="com.minjian.projo.User"> <property name = "cat" ref="com.minjian.projo.Cat"></property> </bean> 按类型装配 @Autowired 按Name装配 @Autowired @Qualifier(
Spring 如何使用注解装配Bean呢？
qq_25073223的博客
11-05 751
Spring 使用注解装配Bean的示例分享
Spring中bean标签解析
ZHI_YUE的博客
06-21 812
注：若使用两个ApplicationContext对象创建bean,即使设置为singleton,也会产生多个不同对象,因为有多个容器例如 如何使用@value注解设置默认值 要在Spring表达式中设置默认值，请使用Elvis operator ： 例如 上面的两行代码表示，从application.properties或者yml文件中读取address.host1的值赋给host1属性，但有些情况我们需要一个默认值，我们可以用下面的方法来实现 通过在address.host1后面加冒号，后面即可设置
Spring 注解配置Bean
BASK2311的博客
03-28 441
无论是注解方式还是配置文件方式，它们的底层工作流程都是将配置解析成BeanDefinition转换为Bean实例对象，并将其注册到Spring容器中。区别在于BeanDefinition的来源不同，注解方式是通过注解信息生成BeanDefinition，配置文件方式是通过配置文件解析器。
Spring系列三：基于注解配置bean
你好, 我在学java的博客
08-07 1702
Spring系列三: 基于注解配置bean
Spring @Bean注解配置及使用方法解析
08-19
Spring @Bean 注解配置及使用方法解析 @Bean 注解是 Spring 框架中用于生成 Bean 实例的注解，主要用在方法上，声明当前方法体中包含了最终产生 Bean 实例的逻辑。该注解可以与 @Component 或 @Configuration 一起...
详解spring 配置的两种方式：JAVA配置和注解配置
08-30
这种方式需要在配置类中声明Bean，并使用@Bean注解来指定Bean的名称和类型。例如： ```java @Configuration public class JavaConfig { @Bean public UseFunctionService useFunctionService() { return new ...
Spring Bean管理注解方式代码实例
08-19
这篇文章将详细介绍 Spring Bean 管理注解方式代码实例，包括使用注解的方式配置 applicationContext.xml、将类交给 Spring 管理、Spring 的属性注入、Spring 的其他注解等。 一、使用注解的方式配置 ...
简单了解Spring Bean常用注解的装配
08-25
在Spring框架中， Bean的装配可以通过XML配置文件或基于注解的方式进行。在基于注解的方式中，Spring框架定义了一系列的注解，用于标注和装配Bean。在本文中，我们将介绍 Spring Bean中的常用注解，包括@Component、...
Spring @Bean vs @Service注解区别
08-28
"Spring @Bean vs @Service注解区别" 在Spring框架中，@Bean和@Service都是用来创建Bean的注解，但是它们的作用域和使用场景不同。下面将详细介绍这两个注解的区别。 首先，@Bean是Spring框架中的核心注解之一，它...
学习Spring5必知必会（3）~Spring的核心 IoC 和 DI
伟庭的博客
02-26 457
学习Spring5必知必会（3）~Spring的核心 IoC 和 DI
Spring：自动装配 Bean 的两种方式、使用注解开发
taiyang3285的博客
05-18 1776
详细介绍了自动装配 Bean 的两种方式，以及使用注解开发来代替 xml 配置文件
Spring框架由配置文件转化为注解开发
qq_43708835的博客
09-23 450
Spring框架由配置文件转化为注解开发 Spring Framework的注解开发相比之前的代码量是降低了耦合、简化了书写。可以说是简单几行代码就可以实现你需要的功能，相当方便。 假如我们在做一个项目时，所有的内容都配置在.xml文件上，在Java文件和配置文件来回转换，也是相当麻烦和耗时的。为了解决这些个问题，Spring引入了注解，通过”@注解名称”的方式，让注解与Java Bean紧密结合...
spring注入的几种方式（文件配置以及注解方式）
ha_lee的博客
07-20 4476
spring注入的几种方式
Spring：三、Bean管理-注解方式
a232884c的博客
11-20 357
Spring：三、Bean管理-注解方式 1 IoC操作Bean管理（基于注解方式） 1.1 注解是代码特殊标记，格式：@注解名称(属性名称=属性值,属性名称=属性值…) 1.2 使用注解，注解作用在类上面，方法上面，属性上面 1.3 使用注解目的：简化xml配置 2 Spring针对Bean管理中创建对象提供注解 import org.springframework.stereotype.Component; import org.springframework.stereotype.Controller
Spring Security的Filter
最新发布
weixin_44263023的博客
07-08 505
如果你需要实现一些 Spring Security 没有提供的特定安全功能，你可以通过实现 javax.servlet.Filter 接口来创建自定义的过滤器，并使用 Spring Security 的 FilterRegistrationBean 或通过 Spring Security 的配置类将其添加到过滤器链中。
spring bean生命周期注解
07-31
Spring中有多种方式来定义和管理bean的生命周期。其中包括使用XML配置、注解和使用JSR250中的@PostConstruct和@PreDestroy注解。 1. XML配置方式：在XML配置文件中，可以使用<bean>标签来定义bean，并通过指定init-method和destroy-method属性来指定bean的初始化和销毁方法。例如： ```xml <bean id="user" class="com.demo.pojo.User" init-method="init" destroy-method="destroy"> </bean> ``` 在这个例子中，init-method属性指定了bean的初始化方法为"init"，destroy-method属性指定了bean的销毁方法为"destroy"。 2. 注解方式：使用注解可以更简洁地定义bean的生命周期。可以使用注解@Bean来标注一个方法，该方法返回一个bean实例，并可以使用@PostConstruct和@PreDestroy注解来指定初始化和销毁方法。例如： ```java @Configuration public class AppConfig { @Bean(initMethod = "init", destroyMethod = "destroy") public User user() { return new User(); } } ``` 在这个例子中，@Bean注解标注的方法user()返回一个User实例，并通过initMethod和destroyMethod属性指定了初始化和销毁方法。 3. 使用JSR250中的@PostConstruct和@PreDestroy注解：可以在bean类中使用@PostConstruct和@PreDestroy注解来标注初始化和销毁方法。例如： ```java public class User { @PostConstruct public void init() { // 初始化方法的逻辑 } @PreDestroy public void destroy() { // 销毁方法的逻辑 } } ``` 在这个例子中，@PostConstruct注解标注的方法init()会在bean初始化之后调用，@PreDestroy注解标注的方法destroy()会在bean销毁之前调用。 总结起来，Spring提供了多种方式来定义和管理bean的生命周期，包括XML配置、注解和使用JSR250中的@PostConstruct和@PreDestroy注解。这些方式可以根据具体的需求和项目的特点来选择和使用。[1][2][3]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值