若依解读------异步任务

一.异步接口

package com.ruoyi.framework.manager;

import java.util.TimerTask;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import com.ruoyi.common.utils.Threads;
import com.ruoyi.common.utils.spring.SpringUtils;

/**
 * 异步任务管理器
 * 
 * @author liuhulu
 */
public class AsyncManager
{
    /**
     * 操作延迟10毫秒
     */
    private final int OPERATE_DELAY_TIME = 10;

    /**
     * 异步操作任务调度线程池
     */
    private ScheduledExecutorService executor = SpringUtils.getBean("scheduledExecutorService");

    /**
     * 单例模式
     */
    private AsyncManager()
    {
    }

    private static AsyncManager me = new AsyncManager();

    public static AsyncManager me()
    {
        return me;
    }

    /**
     * 执行任务
     * 
     * @param task 任务
     */
    public void execute(TimerTask task)
    {
        executor.schedule(task, OPERATE_DELAY_TIME, TimeUnit.MILLISECONDS);
    }

    /**
     * 停止任务线程池
     */
    public void shutdown()
    {
        Threads.shutdownAndAwaitTermination(executor);
    }
}

二.异步的实现：（在该类中添加方法就可以了）

package com.ruoyi.framework.manager.factory;

import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.utils.*;
import com.ruoyi.common.utils.security.ShiroUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.project.monitor.logininfor.domain.Logininfor;
import com.ruoyi.project.monitor.logininfor.service.LogininforServiceImpl;
import com.ruoyi.project.monitor.online.domain.OnlineSession;
import com.ruoyi.project.monitor.online.domain.UserOnline;
import com.ruoyi.project.monitor.online.service.IUserOnlineService;
import com.ruoyi.project.monitor.operlog.domain.OperLog;
import com.ruoyi.project.monitor.operlog.service.IOperLogService;
import com.ruoyi.project.my.course.domain.Course;
import com.ruoyi.project.my.course.service.impl.CourseOrderUserServiceImpl;
import com.ruoyi.project.my.course.service.impl.CourseServiceImpl;
import com.ruoyi.project.my.course.utils.EmalUtil;
import com.ruoyi.project.my.course.vo.OrderUserVo;
import com.ruoyi.project.system.user.domain.User;
import com.ruoyi.project.system.user.service.UserServiceImpl;
import eu.bitwalker.useragentutils.UserAgent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.mail.MessagingException;
import java.util.*;

/**
 * 异步工厂（产生任务用）
 * 
 * @author liuhulu
 *
 */
public class AsyncFactory
{
    private static final Logger sys_user_logger = LoggerFactory.getLogger("sys-user");

    /**
     * 同步session到数据库
     * 
     * @param session 在线用户会话
     * @return 任务task
     */
    public static TimerTask syncSessionToDb(final OnlineSession session)
    {
        return new TimerTask()
        {
            @Override
            public void run()
            {
                UserOnline online = new UserOnline();
                online.setSessionId(String.valueOf(session.getId()));
                online.setDeptName(session.getDeptName());
                online.setLoginName(session.getLoginName());
                online.setStartTimestamp(session.getStartTimestamp());
                online.setLastAccessTime(session.getLastAccessTime());
                online.setExpireTime(session.getTimeout());
                online.setIpaddr(session.getHost());
                online.setLoginLocation(AddressUtils.getRealAddressByIP(session.getHost()));
                online.setBrowser(session.getBrowser());
                online.setOs(session.getOs());
                online.setStatus(session.getStatus());
                online.setSession(session);
                SpringUtils.getBean(IUserOnlineService.class).saveOnline(online);

            }
        };
    }

    /**
     * 操作日志记录
     * 
     * @param operLog 操作日志信息
     * @return 任务task
     */
    public static TimerTask recordOper(final OperLog operLog)
    {
        return new TimerTask()
        {
            @Override
            public void run()
            {
                // 远程查询操作地点
                operLog.setOperLocation(AddressUtils.getRealAddressByIP(operLog.getOperIp()));
                SpringUtils.getBean(IOperLogService.class).insertOperlog(operLog);
            }
        };
    }

    /**
     * 记录登陆信息
     * 
     * @param username 用户名
     * @param status 状态
     * @param message 消息
     * @param args 列表
     * @return 任务task
     */
    public static TimerTask recordLogininfor(final String username, final String status, final String message, final Object... args)
    {
        final UserAgent userAgent = UserAgent.parseUserAgentString(ServletUtils.getRequest().getHeader("User-Agent"));
        final String ip = ShiroUtils.getIp();
        return new TimerTask()
        {
            @Override
            public void run()
            {
                String address = AddressUtils.getRealAddressByIP(ip);
                StringBuilder s = new StringBuilder();
                s.append(LogUtils.getBlock(ip));
                s.append(address);
                s.append(LogUtils.getBlock(username));
                s.append(LogUtils.getBlock(status));
                s.append(LogUtils.getBlock(message));
                // 打印信息到日志
                sys_user_logger.info(s.toString(), args);
                // 获取客户端操作系统
                String os = userAgent.getOperatingSystem().getName();
                // 获取客户端浏览器
                String browser = userAgent.getBrowser().getName();
                // 封装对象
                Logininfor logininfor = new Logininfor();
                logininfor.setLoginName(username);
                logininfor.setIpaddr(ip);
                logininfor.setLoginLocation(address);
                logininfor.setBrowser(browser);
                logininfor.setOs(os);
                logininfor.setMsg(message);
                // 日志状态
                if (StringUtils.equalsAny(status, Constants.LOGIN_SUCCESS, Constants.LOGOUT, Constants.REGISTER))
                {
                    logininfor.setStatus(Constants.SUCCESS);
                }
                else if (Constants.LOGIN_FAIL.equals(status))
                {
                    logininfor.setStatus(Constants.FAIL);
                }
                // 插入数据
                SpringUtils.getBean(LogininforServiceImpl.class).insertLogininfor(logininfor);
            }
        };
    }


    /**
     * 线下预约批量发送邮箱
     *
     * @param //模拟异步发送邮箱
     * @return 任务task
     */
    public static TimerTask sendEmail(final String orderID,final String user_id,final String courseID)
    {
        return new TimerTask()
        {
            @Override
            public void run()
            {
                //获取图片位置
                String imgPath =System.getProperty("user.dir")+"\\src\\main\\resources\\static\\img\\header.png";

                //1通过courseID查询课程name
                Course course = SpringUtils.getBean(CourseServiceImpl.class).selectCourseById(Long.parseLong(courseID));

                //2.通过orderID查询该线下预约所有的人员
                OrderUserVo orderUserVo=new OrderUserVo();
                orderUserVo.setOrderID(Long.parseLong(orderID));
                List<OrderUserVo> orderUserVos=SpringUtils.getBean(CourseOrderUserServiceImpl.class).selectCourseOrderUserList(orderUserVo);

                //3.发送邮箱
                EmalUtil emalUtil = SpringUtils.getBean(EmalUtil.class);
                if(orderUserVos != null && orderUserVos.size() > 0){
                    for(OrderUserVo userVo:orderUserVos){
                        Map<String,String> map=new HashMap<String,String>();
                        map.put("courseName",course.getCourseName());
                        map.put("orderInfor",userVo.getUserName()+"同学您好，您还有一个小时有一门课程答疑，请提前准备！！！");
//                    map.put("userName",userVo.getUserName());
                        map.put("updateDate", DateUtils.getTime());
                        map.put("remark", "点击：");
                        try {
                            emalUtil.thymeleafEmail(new String[]{userVo.getEmail()},"答疑系统提示：",map,"my/email/order",imgPath);
                        } catch (MessagingException e) {
                            sys_user_logger.error(e.getMessage());
                        }
                    }
                }

                //4.通过user_id给创建人(老师)发送邮箱
                User user = SpringUtils.getBean(UserServiceImpl.class).selectUserById(Long.parseLong(user_id));
                try {
                    Map<String,String> map=new HashMap<String,String>();
                    map.put("courseName",course.getCourseName());
                    map.put("orderInfor",user.getUserName()+"老师您好，您还有一个小时有一门课程答疑，请提前准备！！！");
//                    map.put("userName",user.getUserName());
                    map.put("updateDate", DateUtils.getTime());
                    map.put("remark", "点击：");
                    emalUtil.thymeleafEmail(new String[]{user.getEmail()},"答疑系统提示：",map,"my/email/order",imgPath);
                } catch (MessagingException e) {
                    sys_user_logger.error(e.getMessage());
                }
            }
        };
    }
}

三.调用：

AsyncManager.me().execute(AsyncFactory.sendEmail(orderID,user_id,courseID));