java如何在普通方法中异步执行另外一个方法的几种方式

吱唔猪_兔

已于 2024-07-04 16:12:09 修改

阅读量691

点赞数 7

文章标签： java 开发语言 spring boot

于 2024-07-04 16:09:17 首次发布

本文链接：https://blog.csdn.net/weixin_55915253/article/details/140182077

版权

是不是有很多不经常接触这方面的大佬，可能会跟我刚开始一样，觉得直接在方法里面使用一个异步方法就以为会异步执行了，其实并不是，因为在Java 中，异步方法调用不会改变当前方法的执行顺序。在方法中使用异步方法，可能无法实现预期的异步效果，原因如下：

异步方法调用会返回一个 Promise 对象，但在方法内部，你可能会直接调用另一个同步方法，导致异步方法的结果无法被正确处理。

例如：

public void asyncMethod() {
    // 异步方法调用
    someService.asyncMethod().then(result -> {
        // 这里的代码是在异步方法调用成功后执行的
    });

    // 直接调用另一个同步方法
    someService.syncMethod();
}

如果在异步方法调用之前有大量的同步代码，可能会导致主线程被阻塞，从而影响异步方法的执行。

要解决这个问题，你可以将异步方法调用移到主线程之外，例如在事件循环（Event Loop）中执行。这样，即使异步方法调用之前的同步代码量较大，也不会影响异步方法的执行。

你可以使用以下方法在 Java 中实现异步方法调用：

2.1 使用 CompletableFuture：Java 8 引入了 CompletableFuture，它允许你以异步的方式执行任务。

public CompletableFuture<Void> asyncMethod() {
    return CompletableFuture.runAsync(() -> {
        // 在这里执行异步方法
    });
}

2.2 使用 ExecutorService：通过创建一个 ExecutorService 实例，你可以将任务提交到线程池中，从而实现异步执行。

public void asyncMethod() {
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    executorService.submit(() -> {
        // 在这里执行异步方法
    });
}

2.3 使用java的触发机制，

Java事件处理机制是一种观察者模式，它允许一个对象（事件源）发出事件通知，其他对象（监听器）响应这个事件。这种机制通常用于处理UI组件中的用户操作，如按钮点击、文本输入等。

事件处理机制的主要参与者包括：

事件对象（event object）：当事件发生时，事件源会创建一个事件对象，并将其传递给注册的监听器。事件对象通常包含事件的状态信息，可以作为参数传递给监听器的方法。在监听器的方法中，事件对象通常被用来获取事件的相关信息。
事件源（event source）：事件源是发出事件通知的对象。在Java中，事件源通常是通过继承java.awt.event.ActionListener或java.util.EventListener接口的类来作为事件源。事件源对象可以添加和移除监听器。当事件发生时，事件源会通知所有注册的监听器。
监听器（listener）：监听器是响应事件通知的对象。监听器需要实现一个特定的事件监听器接口，如ActionListener、ItemListener、TextListener等。当事件发生时，监听器会响应事件并执行相应的操作。

例如，上一篇文章讲述的，项目中需要实现转码功能，那么怎么能让他异步处理转码这个操作呢，转码操作请参考文章：vue+java的几种实现预览文件的方式-CSDN博客

1.定义一个文件转码事件类ConvertFileEventVo来继承ApplicationEvent

import lombok.*;
import org.springframework.context.ApplicationEvent;

@Getter
@Setter
public class ConvertFileEventVo extends ApplicationEvent {

    //用于记录上传文件地址的类，可以随便创建一个
    private CompetitionCreationFile creationFileObj;


    public ConvertFileEventVo(Object source, CompetitionCreationFile creationFileObj) {
        super(source);
        this.creationFileObj = creationFileObj;
    }
}

2.记录上传文件的类


@Data
@AllArgsConstructor
@NoArgsConstructor
public class CompetitionCreationFile
{
    private static final long serialVersionUID = 1L;

    /** 自增id */
    private Long id;

    /** 作品id */
    private Long creationId;

    /** 文件地址 */
    private String filePath;

    /** 文件封面 */
    private String fileCover;

    /** 预览文件 */
    private String previewFile;

    /** 是否转换  0-否，1-是，2-错误 */
    private Integer transcodeIf;

}

3.在文件提交的时候，触发异步转码


@Service
@Slf4j
public class XXServiceImpl implements IXXService {
    @Autowired
    private ApplicationContext applicationContext;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void submitWork(CompetitionCreationFile creationFile){
        .....
        //触发事件开始转码
        ConvertFileEventVo convertFileEventVo = new ConvertFileEventVo(creationFile,creationFile);
        applicationContext.publishEvent(convertFileEventVo);
        
    }


}

4.转码事件监听器

import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.utils.PDFToImageConverter;
import com.ruoyi.common.utils.file.FileTransForUtils;
import com.ruoyi.common.utils.file.GetVideoGainImg;
import com.ruoyi.competition.domain.pojo.CompetitionCreationFile;
import com.ruoyi.competition.domain.pojo.CompetitionTaskAnnexFile;
import com.ruoyi.competition.event.domain.ConvertFileEventVo;
import com.ruoyi.competition.mapper.CompetitionCreationFileMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
public class ConvertFileEventListener  implements ApplicationListener<ConvertFileEventVo> {

    @Autowired
    private CompetitionCreationFileMapper competitionCreationFileMapper;

    /**
     * 异步转码事件，
     * 触发条件：提交文件
     * @param convertFileEventVo
     *
     * */
    @Override
    @Async
    public void onApplicationEvent(ConvertFileEventVo convertFileEventVo) {
        CompetitionCreationFile creationFileObj = convertFileEventVo.getCreationFileObj();
        String filePath = creationFileObj.getFilePath();
        String inputPath = RuoYiConfig.getProfile()+filePath.replace(RuoYiConfig.getServerPath(),"");
        String outputPath = inputPath.split("\\.")[0]+".pdf";
        String suffix = inputPath.substring(inputPath.lastIndexOf("."));
        String type = FileTransForUtils.getResourceTypesDocument(suffix);
        if("word".equals(type)){
            boolean boo = FileTransForUtils.word3Pdf(inputPath, outputPath);
            if (boo) {
                String fileCoverPath = inputPath.split("\\.")[0]+".jpg";
                Boolean aBoolean = PDFToImageConverter.convertFirstPageToImage(outputPath, fileCoverPath);
                if(aBoolean){
                    creationFileObj.setFileCover(RuoYiConfig.getServerPath()+fileCoverPath.replace(RuoYiConfig.getProfile(),""));
                }
                creationFileObj.setTranscodeIf(1);
                creationFileObj.setPreviewFile(RuoYiConfig.getServerPath()+outputPath.replace(RuoYiConfig.getProfile(),""));
                competitionCreationFileMapper.updateCompetitionCreationFile(creationFileObj);
            }else {
                CompetitionCreationFile errorFile = new CompetitionCreationFile();
                errorFile.setTranscodeIf(2);
                errorFile.setId(creationFileObj.getId());
                competitionCreationFileMapper.updateCompetitionCreationFile(errorFile);

            }
        }
        else if("excel".equals(type)){
            boolean boo = FileTransForUtils.excel3pdf(inputPath, outputPath);
            if (boo) {
                String fileCoverPath = inputPath.split("\\.")[0]+".jpg";
                Boolean aBoolean = PDFToImageConverter.convertFirstPageToImage(outputPath, fileCoverPath);
                if(aBoolean){
                    creationFileObj.setFileCover(RuoYiConfig.getServerPath()+fileCoverPath.replace(RuoYiConfig.getProfile(),""));
                }
                creationFileObj.setTranscodeIf(1);
                creationFileObj.setPreviewFile(RuoYiConfig.getServerPath()+outputPath.replace(RuoYiConfig.getProfile(),""));
                competitionCreationFileMapper.updateCompetitionCreationFile(creationFileObj);
            }else {
                CompetitionCreationFile errorFile = new CompetitionCreationFile();
                errorFile.setTranscodeIf(2);
                errorFile.setId(creationFileObj.getId());
                competitionCreationFileMapper.updateCompetitionCreationFile(errorFile);
            }
        }
        else if("ppt".equals(type)){
            boolean boo = FileTransForUtils.ppt3pdf(inputPath, outputPath);
            if (boo) {
                String fileCoverPath = inputPath.split("\\.")[0]+".jpg";
                Boolean aBoolean = PDFToImageConverter.convertFirstPageToImage(outputPath, fileCoverPath);
                if(aBoolean){
                    creationFileObj.setFileCover(RuoYiConfig.getServerPath()+fileCoverPath.replace(RuoYiConfig.getProfile(),""));
                }
                creationFileObj.setTranscodeIf(1);
                creationFileObj.setPreviewFile(RuoYiConfig.getServerPath()+outputPath.replace(RuoYiConfig.getProfile(),""));
                competitionCreationFileMapper.updateCompetitionCreationFile(creationFileObj);
            }else {
                CompetitionCreationFile errorFile = new CompetitionCreationFile();
                errorFile.setTranscodeIf(2);
                errorFile.setId(creationFileObj.getId());
                competitionCreationFileMapper.updateCompetitionCreationFile(errorFile);
            }
        }
        else if("pdf".equals(type)){
            String fileCoverPath = inputPath.split("\\.")[0]+".jpg";
            Boolean aBoolean = PDFToImageConverter.convertFirstPageToImage(outputPath, fileCoverPath);
            if(aBoolean){
                creationFileObj.setFileCover(RuoYiConfig.getServerPath()+fileCoverPath.replace(RuoYiConfig.getProfile(),""));
                creationFileObj.setTranscodeIf(1);
                competitionCreationFileMapper.updateCompetitionCreationFile(creationFileObj);
            }else {
                CompetitionCreationFile errorFile = new CompetitionCreationFile();
                errorFile.setTranscodeIf(2);
                errorFile.setId(creationFileObj.getId());
                competitionCreationFileMapper.updateCompetitionCreationFile(errorFile);
            }

        }

    }


}

2.4 自定义注解的方式来实现异步处理

就拿最简单的接口访问日志记录来举例，如果使用同步方法的话，可以想象，当接口访问量增大时，这个延迟时间会加长多少，所以使用异步记录，那么话不多说，直接拿若依的源代码开讲吧

1.定义一个自定义注解

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 com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.enums.OperatorType;

/**
 * 自定义操作日志记录注解
 * 
 * @author ruoyi
 *
 */
@Target({ ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log
{
    /**
     * 模块 
     */
    public String title() default "";

    /**
     * 功能
     */
    public BusinessType businessType() default BusinessType.OTHER;

    /**
     * 操作人类别
     */
    public OperatorType operatorType() default OperatorType.MANAGE;

    /**
     * 是否保存请求的参数
     */
    public boolean isSaveRequestData() default true;
}

2.定义切面

package com.ruoyi.framework.aspectj;

import java.lang.reflect.Method;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.HandlerMapping;
import com.alibaba.fastjson.JSON;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.enums.BusinessStatus;
import com.ruoyi.common.enums.HttpMethod;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.ip.IpUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.framework.manager.AsyncManager;
import com.ruoyi.framework.manager.factory.AsyncFactory;
import com.ruoyi.framework.web.service.TokenService;
import com.ruoyi.system.domain.SysOperLog;

/**
 * 操作日志记录处理
 *
 * @author ruoyi
 */
@Aspect
@Component
public class LogAspect
{
    private static final Logger log = LoggerFactory.getLogger(LogAspect.class);

    // 配置织入点
    @Pointcut("@annotation(com.ruoyi.common.annotation.Log)")
    public void logPointCut()
    {
    }

    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "logPointCut()", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, Object jsonResult)
    {
        handleLog(joinPoint, null, jsonResult);
    }

    /**
     * 拦截异常操作
     *
     * @param joinPoint 切点
     * @param e 异常
     */
    @AfterThrowing(value = "logPointCut()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e)
    {
        handleLog(joinPoint, e, null);
    }

    protected void handleLog(final JoinPoint joinPoint, final Exception e, Object jsonResult)
    {
        try
        {
            // 获得注解
            Log controllerLog = getAnnotationLog(joinPoint);
            if (controllerLog == null)
            {
                return;
            }

            // 获取当前的用户
            LoginUser loginUser = SpringUtils.getBean(TokenService.class).getLoginUser(ServletUtils.getRequest());

            // *========数据库日志=========*//
            SysOperLog operLog = new SysOperLog();
            operLog.setStatus(BusinessStatus.SUCCESS.ordinal());
            // 请求的地址
            String ip = IpUtils.getIpAddr(ServletUtils.getRequest());
            operLog.setOperIp(ip);
            // 返回参数
            operLog.setJsonResult(JSON.toJSONString(jsonResult));

            operLog.setOperUrl(ServletUtils.getRequest().getRequestURI());
            if (loginUser != null)
            {
                operLog.setOperName(loginUser.getUsername());
            }

            if (e != null)
            {
                operLog.setStatus(BusinessStatus.FAIL.ordinal());
                operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));
            }
            // 设置方法名称
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = joinPoint.getSignature().getName();
            operLog.setMethod(className + "." + methodName + "()");
            // 设置请求方式
            operLog.setRequestMethod(ServletUtils.getRequest().getMethod());
            // 处理设置注解上的参数
            getControllerMethodDescription(joinPoint, controllerLog, operLog);
            // 保存数据库
            AsyncManager.me().execute(AsyncFactory.recordOper(operLog));
        }
        catch (Exception exp)
        {
            // 记录本地异常日志
            log.error("==前置通知异常==");
            log.error("异常信息:{}", exp.getMessage());
            exp.printStackTrace();
        }
    }

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     *
     * @param log 日志
     * @param operLog 操作日志
     * @throws Exception
     */
    public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog) throws Exception
    {
        // 设置action动作
        operLog.setBusinessType(log.businessType().ordinal());
        // 设置标题
        operLog.setTitle(log.title());
        // 设置操作人类别
        operLog.setOperatorType(log.operatorType().ordinal());
        // 是否需要保存request，参数和值
        if (log.isSaveRequestData())
        {
            // 获取参数的信息，传入到数据库中。
            setRequestValue(joinPoint, operLog);
        }
    }

    /**
     * 获取请求的参数，放到log中
     *
     * @param operLog 操作日志
     * @throws Exception 异常
     */
    private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog) throws Exception
    {
        String requestMethod = operLog.getRequestMethod();
        if (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod))
        {
            String params = argsArrayToString(joinPoint.getArgs());
            operLog.setOperParam(StringUtils.substring(params, 0, 2000));
        }
        else
        {
            Map<?, ?> paramsMap = (Map<?, ?>) ServletUtils.getRequest().getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
            operLog.setOperParam(StringUtils.substring(paramsMap.toString(), 0, 2000));
        }
    }

    /**
     * 是否存在注解，如果存在就获取
     */
    private Log getAnnotationLog(JoinPoint joinPoint) throws Exception
    {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();

        if (method != null)
        {
            return method.getAnnotation(Log.class);
        }
        return null;
    }

    /**
     * 参数拼装
     */
    private String argsArrayToString(Object[] paramsArray)
    {
        String params = "";
        if (paramsArray != null && paramsArray.length > 0)
        {
            for (int i = 0; i < paramsArray.length; i++)
            {
                if (!isFilterObject(paramsArray[i]))
                {
                    Object jsonObj = JSON.toJSON(paramsArray[i]);
                    if(!StringUtils.isNull(jsonObj)){
                        params += jsonObj.toString() + " ";
                    }

                }
            }
        }
        return params.trim();
    }

    /**
     * 判断是否需要过滤的对象。
     *
     * @param o 对象信息。
     * @return 如果是需要过滤的对象，则返回true；否则返回false。
     */
    public boolean isFilterObject(final Object o)
    {
        return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse;
    }
}

3.使用注解

    @Log(title = "测试接口日志记录", businessType = BusinessType.INSERT)
    @PostMapping("/test")
    public ApiRestResponse test(@RequestBody TestObj obj){
        XXService.test(obj);
        return ApiRestResponse.success();
    }