SSM改造SpringBoot（定时任务）

最新推荐文章于 2024-05-21 10:08:11 发布

郝大侠001

最新推荐文章于 2024-05-21 10:08:11 发布

阅读量319

点赞数

分类专栏： SpringBoot

本文链接：https://blog.csdn.net/jmkmlm123456/article/details/102452852

版权

SpringBoot 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

定时任务思路：
1.将定时任务写入到数据库中
2.启动web监听，每秒钟扫描一次数据库，用来启动定时任务。

0.项目结构

在这里插入图片描述

1.pom

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.10.BUILD-SNAPSHOT</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.demo</groupId>
    <artifactId>task3</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>task3</name>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <!-- spring-boot:run 中文乱码解决 -->
                <configuration>
                    <fork>true</fork>
                    <!--增加jvm参数-->
                    <jvmArguments>-Dfile.encoding=UTF-8</jvmArguments>
                </configuration>

            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </pluginRepository>
        <pluginRepository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>

2.bean

TaskOnTime.java

public class TaskOnTime {
    private Integer id;

    private Integer serId;

    private Integer iscancel;

    private Integer status;

    private Date tasktime;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getSerId() {
        return serId;
    }

    public void setSerId(Integer serId) {
        this.serId = serId;
    }

    public Integer getIscancel() {
        return iscancel;
    }

    public void setIscancel(Integer iscancel) {
        this.iscancel = iscancel;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public Date getTasktime() {
        return tasktime;
    }

    public void setTasktime(Date tasktime) {
        this.tasktime = tasktime;
    }
}

3.Controller

InterfaceController.java


@Controller
@ResponseBody
public class InterfaceController {

    @Autowired
    TaskOnTimeService taskOnTimeService;
    //定时任务
    @RequestMapping("/taskTime")
    public String taskOnTime(@RequestBody Map<String,Object> map) throws Exception {
        System.out.println(map.toString());
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd HH:mm:ss");
        Date tasktime = dateFormat.parse((String) map.get("tasktime"));

        //参数异常处理
        if (DataUtils.isEmpty(map.get("id")) || DataUtils.isEmpty(map.get("environment")) || DataUtils.isEmpty(map.get("status")) ||DataUtils.isEmpty(map.get("tasktime"))) {
            throw new ValidationException(RmErrorCode.PLAT_NO_CONFIG_ERROR, "参数错误");
        }
        //取消任务
        if (map.get("status").equals("2") && map.get("iscancel").equals("1")) {
            return taskOnTimeService.cancelTask(DataUtils.castInteger(map.get("id"))) > 0 ? "OK" : "Fail";
        }

        //加入定时任务
        if (map.get("status").equals("2") && map.get("iscancel").equals("0")) {
            return taskOnTimeService.startTimeTask(DataUtils.castInteger(map.get("id")),tasktime,DataUtils.castInteger(map.get("iscancel")),DataUtils.castInteger(map.get("status")))> 0 ? "OK" : "Fail";
        }

        return null;
    }

}

4.dao

TaskOnTimeDao.java

@Mapper
public interface TaskOnTimeDao {

    int cancelTask(@Param("serId") Integer serId);

    List<TaskOnTime> selectOntimeTask(@Param("iscancel") Integer iscancel, @Param("status") Integer status);

    int startTimeTask(@Param("serId") Integer serId, @Param("tasktime") Date taskTime, @Param("iscancel") Integer iscancel, @Param("status") Integer status);

    int updateStatus(@Param("serId") Integer serId);
}

4.1 xml

TaskOntimeDao.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.demo.task3.dao.TaskOnTimeDao">
    <resultMap id="TaskOnTimeMap" type="com.demo.task3.bean.TaskOnTime">
        <id column="id" property="id" jdbcType="INTEGER"/>
        <result column="ser_id" property="serId" jdbcType="INTEGER"/>
        <result column="task_time" property="tasktime" jdbcType="TIMESTAMP"/>
        <result column="is_cancel" property="iscancel" jdbcType="INTEGER"/>
        <result column="status" property="status" jdbcType="INTEGER"/>
    </resultMap>

    <insert id="startTimeTask" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO jrm_online_task (ser_id,task_time,is_cancel,status)
        VALUES (#{serId},#{tasktime},#{iscancel},#{status})
    </insert>

    <update id="cancelTask">
        UPDATE jrm_online_task
        SET is_cancel='1'
        WHERE ser_id = #{serId}
    </update>
    <update id="updateStatus">
        UPDATE jrm_online_task
        SET status='1'
        WHERE ser_id = #{serId}
    </update>

    <select id="selectOntimeTask" resultMap="TaskOnTimeMap">
        SELECT * FROM jrm_online_task
        WHERE is_cancel=#{iscancel} AND status=#{status}
    </select>
</mapper>

5.init

DataInitializer.java

@Component
public class DataInitializer implements ApplicationListener<ContextRefreshedEvent> {
    protected Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    TaskOnTimeService taskOnTimeService;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (event.getApplicationContext().getParent() == null) {
        }

        onTimeTask();
    }
    public void onTimeTask(){
        logger.info("定时任务监听启动");
        Map<String, Object> mapTmp = new ConcurrentHashMap<>();
        mapTmp.put("environment", 0);
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
        scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                List<TaskOnTime> taskOnTimes = taskOnTimeService.selectOntimeTask(0, 2);

                for (TaskOnTime taskOnTime : taskOnTimes) {
                    mapTmp.put("id", taskOnTime.getSerId());
                    mapTmp.put("status", 1);

                    try {
                        if (taskOnTime.getTasktime().getTime() <= System.currentTimeMillis()) {
                            /*if(interfaceService.onOff(mapTmp).get("msg").equals("操作成功!")){
                                taskOnTimeService.updateStatus(taskOnTime.getSerId());
                            }else {
                                logger.info("定时任务"+mapTmp.get("id")+"启动失败");
                            }*/
                            logger.info("定时任务"+mapTmp.get("id")+"执行一次");
                            taskOnTimeService.updateStatus(taskOnTime.getSerId());
                        }

                    } catch (Exception e) {
                        logger.error("定时任务"+mapTmp.get("id")+"启动失败", e);
                    }
                }
            }
        }, 0, 1, TimeUnit.SECONDS);
    }
}

6.service

TaskOnTimeService.java

@Service
public class TaskOnTimeService {

    @Autowired
    TaskOnTimeDao taskOnTimeDao;

    public int cancelTask(Integer serId){
        return taskOnTimeDao.cancelTask(serId);
    }

    public List<TaskOnTime> selectOntimeTask(Integer iscancel, Integer status) {
        return taskOnTimeDao.selectOntimeTask(iscancel,status);
    }

    public int startTimeTask(Integer serId, Date taskTime, Integer iscancel, Integer status) {
        return taskOnTimeDao.startTimeTask(serId,taskTime,iscancel,status);
    }

    public int updateStatus(Integer serId) {
        return taskOnTimeDao.updateStatus(serId);
    }
}

7.util

DataUtils.java
工具转换类

public class DataUtils {
    public static final String STR_COMMA_HALF = ",";

    public DataUtils() {
    }

    public static byte[] objectToByte(Object object) {
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        byte[] bytes = null;

        try {
            ObjectOutputStream oo = new ObjectOutputStream(bo);
            oo.writeObject(object);
            bytes = bo.toByteArray();
        } catch (IOException var4) {
            var4.printStackTrace();
        }

        return bytes;
    }

    public static Object byteToObject(byte[] bytes) {
        ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
        Object object = null;

        try {
            ObjectInputStream in = new ObjectInputStream(bi);
            object = in.readObject();
        } catch (ClassNotFoundException var5) {
            var5.printStackTrace();
        } catch (IOException var6) {
            var6.printStackTrace();
        }

        return object;
    }

    public static boolean isEmpty(Object obj) {
        if (null == obj) {
            return true;
        } else {
            String strTmp = obj.toString().trim();
            return "".equals(strTmp) || "null".equalsIgnoreCase(strTmp);
        }
    }

    public static boolean isListEmpty(List<Object> list) {
        Iterator var1 = list.iterator();

        Object obj;
        do {
            if (!var1.hasNext()) {
                return false;
            }

            obj = var1.next();
        } while(!isEmpty(obj));

        return true;
    }

    public static boolean isNotEmpty(Object obj) {
        if (null == obj) {
            return false;
        } else {
            String strTmp = obj.toString().trim();
            return !"".equals(strTmp) && !"null".equalsIgnoreCase(strTmp);
        }
    }

    public static boolean isEmpty(String str) {
        if (null == str) {
            return true;
        } else {
            String strTmp = str.trim();
            return "".equals(strTmp) || "null".equals(strTmp);
        }
    }

    public static boolean isNotEmpty(String str) {
        if (null == str) {
            return false;
        } else {
            String strTmp = str.trim();
            return !"".equals(strTmp) && !"null".equals(strTmp);
        }
    }

    public static boolean isNumber(Object obj) {
        return !isEmpty(obj) && obj.toString().trim().matches("^[+\\-]?[0-9]+[.]?[0-9]*[E]?[0-9]*$");
    }

    public static Double castDouble(Object obj) {
        return isEmpty(obj) ? null : Double.valueOf(obj.toString().trim());
    }

    public static BigDecimal castDecimal(Object obj) {
        return isEmpty(obj) ? null : new BigDecimal(obj.toString().trim());
    }

    public static BigDecimal editDecimalDefault(BigDecimal bgd, BigDecimal defaultVal) {
        return bgd == null ? defaultVal : bgd;
    }

    public static BigDecimal castDecimalPct(String pctStr) {
        return isEmpty(pctStr) ? null : (new BigDecimal(pctStr.trim().replace("<", "").replace("〈", "").replace("＜", "").replace(">", "").replace("〉", "").replace("＞", "").replace("%", ""))).divide(BigDecimal.valueOf(100L));
    }

    public static Short castShort(Object obj) {
        return isEmpty(obj) ? null : Short.valueOf(obj.toString().trim());
    }

    public static Integer castInteger(Object obj, boolean forcible) {
        if (forcible) {
            return isEmpty(obj) ? null : Integer.valueOf(obj.toString().trim());
        } else {
            return castInteger(obj);
        }
    }

    public static Integer castIntegerDefault(Object obj, Integer defaultValue) {
        Integer value = castInteger(obj);
        return isEmpty((Object)value) ? defaultValue : value;
    }

    public static Integer castInteger(Object obj) {
        if (isEmpty(obj)) {
            return null;
        } else {
            BigDecimal value = new BigDecimal(obj.toString().trim());
            return value.intValue();
        }
    }

    public static Integer editIntegerDefault(Integer num, Integer defaultVal) {
        return num == null ? defaultVal : num;
    }

    public static Integer castIntegerWithCheck(Object obj) {
        return !isEmpty(obj) && obj.toString().trim().matches("^[+|-]?[0-9]*[.]?[0-9]*$") ? Integer.valueOf(obj.toString().trim()) : null;
    }

    public static Long castLong(Object obj) {
        return isEmpty(obj) ? null : Long.valueOf(obj.toString().trim());
    }

    public static Boolean castBoolean(Object obj) {
        return isEmpty(obj) ? null : Boolean.valueOf(obj.toString().trim());
    }

    public static String castStr(Object obj) {
        return isEmpty(obj) ? null : obj.toString().trim();
    }

    public static String castStrBlank(Object obj) {
        return isEmpty(obj) ? "" : obj.toString().trim();
    }

    public static String castStrDefault(Object obj, String defaultVal) {
        return isEmpty(obj) ? defaultVal : obj.toString().trim();
    }

    public static <K, V> Map<K, V> castMap(Object obj) {
        return isEmpty(obj) ? null : (Map)obj;
    }

    public static <K, V> V castMap(Map<K, V> obj, K key) {
        if (isEmpty((Object)obj)) {
            return null;
        } else {
            return isEmpty(obj.get("key")) ? null : obj.get("key");
        }
    }



    public static String formatAmount(BigDecimal amount) {
        if (amount == null) {
            return "";
        } else {
            DecimalFormat df = new DecimalFormat("###0.00");
            return df.format(amount.doubleValue());
        }
    }

    public static BigDecimal intAmountFront(BigDecimal amount, int num) {
        if (amount == null) {
            return null;
        } else {
            BigDecimal result = amount.setScale(0, 4);
            int len = String.valueOf(result.longValue()).length();
            return num > 1 && len > num ? result.setScale(num - len, 4) : result;
        }
    }



    public static String escapeSqlLike(String condLike) {
        return isNotEmpty(condLike) ? castStrBlank(condLike).replace("/", "//").replace("_", "/_").replace("%", "/%").replace("'", "/'") : "";
    }

    public static Long[] splitIds(String ids) {
        if (isNotEmpty(ids)) {
            List<Long> idList = new ArrayList();
            String idsTmp = castStrBlank(ids);
            StringTokenizer st = new StringTokenizer(idsTmp, ",");

            while(st.hasMoreElements()) {
                String idTmp = st.nextToken();
                if (isNumber(idTmp)) {
                    idList.add(castLong(idTmp));
                }
            }

            if (!idList.isEmpty()) {
                Long[] idArr = new Long[idList.size()];

                for(int i = 0; i < idList.size(); ++i) {
                    idArr[i] = (Long)idList.get(i);
                }

                return idArr;
            }
        }

        return new Long[0];
    }

    public static String escapeMysqlChar(String str) {
        return isNotEmpty(str) ? str.trim().replaceAll("[^\\u0000-\\uFFFF]", "") : "";
    }

    public static String ellipsis(String source, int length) {
        String target = castStrBlank(source);
        return target.length() > length ? target.substring(0, length - 1) + "…" : target;
    }


    private String getLastMapKey(Map<String, Object> map) throws Exception {
        Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();

        Map.Entry tail;
        for(tail = null; iterator.hasNext(); tail = (Map.Entry)iterator.next()) {
        }

        return (String)tail.getKey();
    }

    public static boolean compareDate(String date) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String currDate = sdf.format(new Date());
        Date parseDate = sdf.parse(currDate);
        Calendar nowDate = Calendar.getInstance();
        nowDate.setTime(parseDate);
        Date compParseDate = sdf.parse(date);
        Calendar compDate = Calendar.getInstance();
        compDate.setTime(compParseDate);
        return nowDate.before(compDate);
    }
}

SQL

CREATE TABLE `task` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `ser_id` int(11) NOT NULL COMMENT '任务id',
  `task_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' ON UPDATE CURRENT_TIMESTAMP COMMENT '定时任务时间',
  `is_cancel` int(1) NOT NULL COMMENT '是否取消定时任务',
  `status` int(1) NOT NULL COMMENT '上线状态',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=latin1;

郝大侠001

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
SSM改造SpringBoot（定时任务）

定时任务思路：1.将定时任务写入到数据库中2.启动web监听，每秒钟扫描一次数据库，用来启动定时任务。0.项目结构1.pom<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001...
复制链接

扫一扫