Spring 框架——@Async 注解

于 2025-03-10 22:57:29 发布
阅读量1k 收藏 12
点赞数 11
分类专栏： 面试 学习路线 阿里巴巴 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74825152/article/details/146166270
版权
目录

1.同步调用与异步调用

在 Java 中，同步调用和异步调用是两种不同的操作方式，用于处理方法调用和任务执行。

1.1.同步调用

（1）定义：同步调用指的是调用方法时，调用者会等待被调用的方法执行完成后才继续执行后续的代码。也就是说，方法调用是阻塞的，当前线程会被阻塞直到方法执行结束并返回结果。

（2）示例：

public class SyncExample {
    public static void main(String[] args) {
        System.out.println("Start");

        //同步调用
        String result = longRunningTask();
        System.out.println("Result: " + result);

        System.out.println("End");
    }

    public static String longRunningTask() {
        try {
            //模拟长时间运行的任务
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Task Completed";
    }
}

（3）解释：
在上述代码中，longRunningTask() 方法会暂停当前线程 3 秒钟，然后返回结果。在 main 方法中，longRunningTask() 的调用是同步的，System.out.println("Result: " + result); 会等待 longRunningTask() 完成后才执行。

1.2.异步调用

（1）定义：异步调用指的是调用方法时，调用者不会等待方法执行完成，而是立即继续执行后续的代码。被调用的方法在后台线程中执行，调用者可以通过回调、Future 模式或其他机制获取结果。

（2）示例：

import java.util.concurrent.CompletableFuture;

public class AsyncExample {
    public static void main(String[] args) {
        System.out.println("Start");

        //异步调用
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> longRunningTask());

        //继续执行其他操作
        System.out.println("Doing other work while waiting for result...");

        //获取异步任务的结果（会阻塞，直到任务完成）
        future.thenAccept(result -> System.out.println("Result: " + result));

        System.out.println("End");
    }

    public static String longRunningTask() {
        try {
            //模拟长时间运行的任务
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Task Completed";
    }
}

（3）解释：在上述代码中，longRunningTask() 被异步执行，通过 CompletableFuture.supplyAsync 方法。在异步执行期间，System.out.println("Doing other work while waiting for result..."); 会继续执行，不会被阻塞。future.thenAccept(result -> System.out.println("Result: " + result)); 会在任务完成后处理结果。

1.3.总结
  • 同步调用：
    • 特点：调用方在发起方法调用后，必须等待被调用的方法完成并返回结果之后，才能继续执行后续的操作（即会阻塞）。在同步调用中，调用方和被调用方的执行顺序是严格按照调用顺序进行的。
    • 适用场景：
      • 依赖顺序：当某个操作必须在另一个操作完成后才能进行时。
      • 简单任务：当任务执行时间短且没有并发问题时。
      • 确保执行顺序：需要确保多个步骤按顺序完成，比如数据库事务处理。
  • 异步调用：
    • 特点：调用方发起方法调用后，不必等待被调用的方法完成，而是可以继续执行后续的操作。被调用的方法将在后台线程中运行，完成后会通知调用方结果或执行回调。
    • 适用场景：
      • 任务需要较长时间完成，阻塞主线程会影响程序的响应性。
      • 需要处理多个任务时，通过异步调用可以提高并发处理能力。
      • 用户界面应用中，异步操作可以防止界面冻结，提升用户体验。

2.注解 @Async 介绍

@Async 注解中的 Async 是单词 Asynchronous 的缩写。Asynchronous 指的是“异步的”，即操作或方法的执行不会阻塞当前线程，允许在后台执行任务的同时继续进行其他操作。使用 @Async 注解可以让 Spring 在后台线程池中异步执行被注解的方法，从而提升应用的性能和响应能力。@Async 注解的代码如下所示：

package org.springframework.scheduling.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.aot.hint.annotation.Reflective;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Reflective
public @interface Async {
    String value() default "";
}

@Async 注解用在方法和类上的作用分别如下：

2.1.用在方法上

（1）功能：标记方法为异步执行，这意味着方法将在一个新的线程中执行，不会阻塞调用该方法的线程。并且方法所在的类必须要被 Spring 作为 Bean 管理。
（2）限制：只对 public 方法有效，且方法返回类型为 void 或者 Future。
（3）例子：

@Async
public CompletableFuture<String> asyncMethod() {
    // 执行异步任务
}
2.2.用在类上

（1）功能：标记类中的所有 public 方法都为异步执行。这个类必须要被 Spring 作为 Bean 管理，并且所有被 @Async 注解的方法都会异步执行。
（2）限制：类上使用 @Async 不一定能保证类中所有方法都异步执行，特别是如果方法被类内部直接调用时，例如方法 asyncMethod2 在同一类内直接调用方法 asyncMethod1，asyncMethod1 会在当前线程中同步执行，而不是异步执行。
（3）例子：

@Async
@Service
public class MyService {
    public CompletableFuture<String> asyncMethod1() {
        // 执行异步任务
    }

    public CompletableFuture<String> asyncMethod2() {
        // 执行异步任务
    }
}

3.使用演示

一般来说，@Async 注解用在方法上来指定特定方法异步执行，标记整个类的方式较少使用。

3.1.在启动类或者配置类上增加 @EnableAsync 注解

例如，在 Spring Boot 项目的启动类上增加 @EnableAsync 注解：

@EnableAsync	//开启异步调用
@SpringBootApplication
public class MyExampleApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyExampleApplication.class, args);
    }

}

@EnableAsync 注解用于启用 Spring 框架的异步方法执行功能。它使得应用程序能够处理被 @Async 注解标记的方法，确保这些方法在独立的线程中异步执行。将 @EnableAsync 注解添加到配置类或者启动类上后，Spring 将自动配置所需的支持，并允许 @Async 注解在应用程序中生效。

3.2.在异步方法上增加 @Async 注解
package com.example.myexample.service.async;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class MyAsyncTask {
    @Async
    public void notifyUser() {
        log.info("asyncTask 方法所处的线程：{}", Thread.currentThread().getName());
        //模拟处理异步任务
        try {
            Thread.sleep(3000);
            log.info("通知用户保存订单成功");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}
3.3.调用异步方法
package com.example.myexample.controller;

import com.example.myexample.service.OrderService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@RequestMapping("asyncTest")
public class AsyncTestController {
    @Resource
    private OrderService orderService;

    @PostMapping
    public String saveOrder() {
        orderService.saveOrder();
        return "success";
    }
}


package com.example.myexample.service;

public interface OrderService {
    void saveOrder();
}


package com.example.myexample.service.impl;

import com.example.myexample.service.OrderService;
import com.example.myexample.service.async.MyAsyncTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Slf4j
@Service
public class OrderServiceImpl implements OrderService {

    @Resource
    private MyAsyncTask myAsyncTask;

    @Override
    public void saveOrder() {
        log.info("saveOrder 方法所处的线程：{}", Thread.currentThread().getName());
        log.info("保存订单");
        //调用异步方法
        myAsyncTask.notifyUser();
        postProcess();
    }

	public void postProcess() {
        log.info("postProcess 方法所处的线程：{}", Thread.currentThread().getName());
    }
}

上述代码只包括了调用异步方法的核心部分，其它部分代码（例如 Controller 层）并未给出。

3.4.测试

使用 Postman 进行测试：

http://localhost:8080/asyncTest/

在这里插入图片描述

日志打印结果如下，从中可以发现：方法 saveOrder 和 notifyUser 在不同的线程中执行了，即 notifyUser 确实被异步调用了。

在这里插入图片描述

3.5.其它说明

如果要将异步方法改为有返回值，可以将返回类型从 void 改为 Future<T> 或 CompletableFuture<T>。这里我们使用 CompletableFuture 作为返回类型：

@Async
public CompletableFuture<String> notifyUser2() {
    log.info("asyncTask 方法所处的线程：{}", Thread.currentThread().getName());
    // 模拟处理异步任务
    try {
        Thread.sleep(3000);
        log.info("通知用户保存订单成功");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    return CompletableFuture.completedFuture("通知用户保存订单成功");
}


public void saveOrder2() {
    log.info("saveOrder 方法所处的线程：{}", Thread.currentThread().getName());
    log.info("保存订单");
    CompletableFuture<String> future = myAsyncTask.notifyUser2();
    //在需要时可以调用 get() 来阻塞当前线程直到异步任务完成
    try {
        String result = future.get(); // 这将阻塞直到异步任务完成
        System.out.println("任务结果: " + result);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

有关 Future 模式的相关知识可以参考 Java 并发编程面试题——Future 模式这篇文章。

4.注意事项

4.1.@Async 注解失效的常见情况

@Async 注解在某些情况下可能会失效，包括：

  • 方法定义不符合要求：@Async 方法必须是 public，并且不能是 final、static 或 private。
  • 类未被 Spring 扫描：确保含有 @Async 注解的类被 Spring 扫描到。通常需要将类放在 @Component、@Service 或其他 Spring 管理的组件中。
  • 缺少 @EnableAsync 注解：在配置类上未添加 @EnableAsync 注解，Spring 不会启用异步处理。
  • 方法调用在同一类内部：@Async 方法被同一类的其他方法调用时不会生效，因为 Spring 的代理机制无法处理同一类内的调用。
  • 返回值处理不当：异步方法通常返回 Future 或 void，确保返回值类型正确处理。
4.2.使用 @Async 注解可能会导致循环依赖
4.2.1.示例

需要注意的是，如果代码编写不当，在使用 @Async 注解可能会导致循环依赖，例如：

@Service
public class CDTestsService1Impl implements CDTestsService1 {
    @Autowired
    private CDTestsService2 cdTestsService2;

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


@Service
public class CDTestsService2Impl implements CDTestsService2 {
    @Autowired
    private CDTestsService1 cdTestsService1;

    @Override
    public void performTask() {
        cdTestsService1.performAsyncTask();
    }
}


@RestController
@RequestMapping("asyncTest")
public class AsyncTestController {

    @Resource
    private CDTestsService2 cdTestsService2;

    @PostMapping("/cdTest")
    public String cdTest() {
        cdTestsService2.performTask();
        return "success";
    }
}

当启动项目时，会出现循环依赖的异常提示：
在这里插入图片描述

4.2.2.原因分析
  • 循环依赖：
    • CDTestsService1Impl 依赖于 CDTestsService2Impl，并且 CDTestsService2Impl 依赖于 CDTestsService1Impl。这种相互依赖会导致 Spring 容器在创建这些 bean 时发生问题。
    • 当 Spring 容器创建 CDTestsService1Impl 时，它需要注入 CDTestsService2Impl。接着，创建 CDTestsService2Impl 时，它需要注入 CDTestsService1Impl。这样，就会形成一个死循环，因为两个 bean 互相等待对方被完全创建和注入。
  • @Async 注解的影响：
    • @Async 注解用于异步执行方法。这意味着 performAsyncTask 方法会在不同的线程中运行，因此不会阻塞当前线程。但是，Spring 在执行异步方法时，仍然需要确保异步方法的 bean 实例在调用之前已完全创建和注入。
    • 由于 performAsyncTask 是异步的，Spring 在调用这个方法时可能会遇到由于循环依赖未完全解决而引发的异常。
4.2.3.解决方案

（1）使用构造函数注入
使用构造函数注入可以避免循环依赖问题。构造函数注入在 bean 创建时确保所有依赖项都已解决，因此更可靠。

@Service
public class CDTestsService1Impl implements CDTestsService1 {
    private final CDTestsService2 cdTestsService2;

    @Autowired
    public CDTestsService1Impl(CDTestsService2 cdTestsService2) {
        this.cdTestsService2 = cdTestsService2;
    }

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

@Service
public class CDTestsService2Impl implements CDTestsService2 {
    private final CDTestsService1 cdTestsService1;

    @Autowired
    public CDTestsService2Impl(CDTestsService1 cdTestsService1) {
        this.cdTestsService1 = cdTestsService1;
    }

    @Override
    public void performTask() {
        cdTestsService1.performAsyncTask();
    }
}

（2）使用 @Lazy 注解
@Lazy 注解可以推迟 bean 的初始化，解决循环依赖问题。你可以将 @Lazy 注解添加到字段注入中，以便在需要时才加载依赖。

@Service
public class CDTestsService1Impl implements CDTestsService1 {
    @Autowired
    @Lazy
    private CDTestsService2 cdTestsService2;

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

@Service
public class CDTestsService2Impl implements CDTestsService2 {
    @Autowired
    @Lazy
    private CDTestsService1 cdTestsService1;

    @Override
    public void performTask() {
        cdTestsService1.performAsyncTask();
    }
}

（3）分离异步调用
如果 performAsyncTask 不需要立即执行，考虑将它移到另一个服务中，或通过其他机制避免直接的循环依赖。

@Service
public class CDTestsService1Impl implements CDTestsService1 {
    @Autowired
    private TaskExecutor taskExecutor;  // Spring 提供的 TaskExecutor

    @Override
    public void performAsyncTask() {
        taskExecutor.execute(() -> {
            System.out.println("performAsyncTask...");
        });
    }
}

@Service
public class CDTestsService2Impl implements CDTestsService2 {
    @Autowired
    private CDTestsService1 cdTestsService1;

    @Override
    public void performTask() {
        cdTestsService1.performAsyncTask();
    }
}

使用 TaskExecutor 来执行异步任务可以将异步执行的逻辑与服务依赖解耦，避免直接在服务之间形成循环依赖。

Spring学习总结（29）——Spring异步处理@Async的使用以及原理、源码分析（@EnableAsync）
科技D人生
12-02 6160
在开发过程中，我们会遇到很多使用线程池的业务场景，例如异步短信通知、异步记录操作日志。大多数使用线程池的场景，就是会将一些可以进行异步操作的业务放在线程池中去完成。例如在生成订单的时候给用户发送短信，生成订单的结果不应该被发送短信的成功与否所左右，也就是说生成订单这个主操作是不依赖于发送短信这个操作，所以我们就可以把发送短信这个操作置为异步操作。那么本文就是来看看Spring中提供的优雅的异步处理...
Spring系列-9 Async注解使用与原理
shengyu
02-26 7697
本文作为[Spring系列]的第九篇，介绍@Async注解的使用、注意事项和实现原理，原理部分会结合Spring框架代码进行。@Async一般注解在方法上，用于实现方法的异步：方法调用者立即返回。
Spring之@Async异步注解
热门推荐
sun134911的博客
08-13 1万+
1.注解介绍 @Async注解，该注解可以被标注在方法上，以便异步地调用该方法。调用者将在调用时立即返回，方法的实际执行将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执行。在项目应用中，@Async调用线程池，推荐使用自定义线程池的模式。自定义线程池常用方案：重新实现接口AsyncConfigurer。 2.Spring的线程池 1. SimpleAsyncTaskExecutor：，这个类不重用线程，默认每次调用都会创建一个新的线程。 2. SyncTaskExecu
深入理解Spring注解@Async解决异步调用问题
08-18
主要介绍了深入理解Spring注解@Async解决异步调用问题，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Spring使用@Async注解
1
06-13 1904
本文讲述@Async注解，在Spring体系中的应用。本文仅说明@Async注解的应用规则，对于原理，调用逻辑，源码分析，暂不介绍。对于异步方法调用，从Spring3开始提供了@Async注解，该注解可以被标注在方法上，以便异步地调用该方法。调用者将在调用时立即返回，方法的实际执行将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执行。 在项目应用中，@Async调用线程池，推荐使用自定义线程池的模式。自定义线程池常用方案：重新实现接口AsyncConfigurer...
Spring @Async注解
勇往直前的专栏
07-07 1118
1.@Async @Async源码@Async的value属性可以指定执行线程池，当其被标注在类或者方法上，用于实现方法的异步执行，当被标注在类上，表明类中的所有方法都被指定的异步执行器执行。 2.实现原理 为了更基础的分析异步调用背后的实现原理，这里选择使用xml配置文件的方式。使用xml配置文件方式时，一般会配置如下元素： <task:annotation-driven executor="myExecutor" exception-handler="exceptionHandler"/
当@Async注解遇上Spring的循环依赖：一个故障排查之旅
步子哥的博客
03-21 490
Spring框架提供了很多便利，但它不是万能的。在使用@Async等高级特性时，我们需要更深入地理解它们的工作原理和潜在限制。通过避免循环依赖或者将异步方法分离到单独的Bean中，我们可以继续享受Spring带来的便利，同时避免一些常见的坑。下次在使用@Async时，记得检查你的Bean之间的关系，确保你的Spring应用可以顺畅地启动和运行。希望这篇文章能够帮助你理解@Async注解和Spring循环依赖之间的复杂关系，以及如何解决由此带来的问题。
【java框架】SpringBoot(10) -- SpringBoot巧用 @Async提升API接口并发能力 .pdf
12-04
在高并发的Web应用中，提高接口的并发处理能力是至关重要的，而SpringBoot框架提供了一种简单有效的方法——使用`@Async`注解来实现异步调用，从而优化性能。本文将深入探讨什么是异步调用，以及如何在SpringBoot中...
Spring异步处理——@Async注解
java123456111的博客
10-30 1618
Async是spring框架中十分好用的异步写法：1，在方法上使用该@Async注解，申明该方法是一个异步任务；2，在类上面使用该@Async注解，申明该类中的所有方法都是异步任务；3，使用此注解的方法的类对象，必须是spring管理下的bean对象；4，要想使用异步任务，需要在主类上开启异步配置，即，配置上@EnableAsync注解；@Async注解工作原理就是在调用被注解的方法时，Spring会将该方法的执行转移到线程池中的一个线程进行处理。
@Async注解
u012102536的博客
03-23 4091
原地址：新来了个技术总监：谁再用 @Async 创建线程以后就不用来了！！ 在很久很久之前，我有一段痛苦的记忆。那种被故障所驱使的感觉，在我脑海里久久无法驱散。 原因无它，有小伙伴开启了线程池的暴力使用模式。没错，就是下面这篇文章。 夺命故障 ! 炸出了投资人！ 我有必要简单的复述一下。其主要原因，就是开发人员，在每一次方法调用里，都创建了一个单独的线程池去处理。这样的话，如果请求量一增加，整个操作系统的压力就会耗尽，最终所有的业务都无法响应。 我一直认为这是一个非常偶发的低级错误，发生频率非
Spring之@Async注解（异步调用）
宇智波小强的博客
07-27 1542
本文讲述@Async注解，在Spring体系中的应用。本文仅说明@Async注解的应用规则，对于原理，调用逻辑，源码分析，暂不介绍。对于异步方法调用，从Spring3开始提供了@Async注解，该注解可以被标注在方法上，以便异步地调用该方法。调用者将在调用时立即返回，方法的实际执行将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执行。 在项目应用中，@Async调用线程池，推荐使用自定义线程池的模式。自定义线程池常用方案：重新实现接口AsyncConfigurer。 ..
Spring @Async注解【总结记录】
单枪匹码
08-20 1209
从Spring3开始提供了@Async注解，用于异步方法调用，调用者将在调用时立即返回，方法的实际执行将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执行。 该注解可以被标注在类或方法（通常是Service层的方法）上，用于实现方法的异步执行，当被标注在类上时表明类中的所有方法都被指定的异步执行器执行。
@Async括号内的内容有什么用
最新发布
03-18
### @Async注解括号内参数的作用及配置方法 #### 参数 `value` 的作用 @Async 注解的括号内有一个可选参数 `value`，用于指定自定义线程池 Bean 的名称。当未提供该参数时，默认会使用 Spring 提供的标准线程池执行异步操作；而如果提供了具体的线程池名称，则会按照所指定的线程池来进行任务调度[^1]。 以下是具体配置方式： #### 自定义线程池的创建与绑定 为了更好地控制并发行为以及资源分配，开发者可以定义自己的线程池，并将其注入到应用上下文中。下面是一个完整的例子，展示了如何设置一个带有特定属性的线程池并与 @Async 关联起来。 ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.EnableAsync; import java.util.concurrent.Executor; import java.util.concurrent.ThreadPoolExecutor; @Configuration @EnableAsync public class AsyncConfig { @Bean(name = "customThreadPoolTaskExecutor") // 定义线程池 bean 名称为 customThreadPoolTaskExecutor public Executor taskExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(5); // 设置核心线程数 executor.setMaxPoolSize(10); // 设置最大线程数 executor.setQueueCapacity(25); // 设置队列容量 executor.setThreadNamePrefix("Custom-"); // 设置线程名前缀以便于调试跟踪 executor.initialize(); // 初始化线程池 return executor; } } ``` 接着，在需要异步运行的方法上标注如下内容即可利用上述定制化线程池完成任务分发： ```java @Async("customThreadPoolTaskExecutor") public void asyncMethodWithCustomThreadPool() { System.out.println(Thread.currentThread().getName()); } ``` 这里的关键在于将 `"customThreadPoolTaskExecutor"` 填入到了 @Async 注解内部作为其唯一参数，这表明此方法应该由名为 `customThreadPoolTaskExecutor` 的线程池负责执行[^3]。 #### 注意事项 值得注意的是，虽然可以在 @Async 中指明使用的线程池名字，但如果希望整个项目统一采用某种策略或者默认值的话，也可以省略这个字段让框架自行决定合适的执行器实例[^4]。 另外还需注意几个常见误区可能导致 @Async 功能失灵的情况已被提及过多次但仍值得再次强调一下：确保目标函数具有公共访问权限(public)，并且它所属的对象是由 spring IOC 控制而不是简单的新建出来的普通 Java 实例对象；还有就是避免在同一类里面直接互相调用其他标记了 @Async 的成员函数——这种情形下由于反射机制等原因会造成实际并未触发真正的异步逻辑而是同步阻塞等待直到结束才继续往下走[^5]。 ### 总结 综上所述，通过合理规划并正确运用这些技巧可以帮助我们更高效地开发基于多线程环境的应用程序结构设计模式下的解决方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值