quartz定时任务

<?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:jdbc="http://www.springframework.org/schema/jdbc"  
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd ">
       
    <!-- 加入需要执行的类 -->
    <bean id="timingSchedule" class="com.littleLady.receptionWeb.schedule.TimingSchedule"/>
    
    <!-- 加入定时执行的方法 -->
    <bean id="timingScheduleJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <!-- 定时执行的类 -->
        <property name="targetObject" ref="timingSchedule"/>
        <!-- 具体的方法 -->
        <property name="targetMethod" value="execute"/>
    </bean>
    
     <!-- 加入定时执行的方法 -->
    <bean id="timingScheduleJobDetail02" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <!-- 定时执行的类 -->
        <property name="targetObject" ref="timingSchedule"/>
        <!-- 具体的方法 -->
        <property name="targetMethod" value="cancelAfterSale"/>
    </bean>
    
    <!-- 调度触发器，设置自己想要的时间规则 -->
    <bean id="timingScheduleTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <!-- 加入相关的执行类和方法 -->
        <property name="jobDetail" ref="timingScheduleJobDetail"/>
        <!-- 设置时间规则 （为了方便测试，设置成一分钟一次。具体的规则见详情）-->
        <!-- <property name="cronExpression" value="00 * * * * ?"/> -->
        <!-- <property name="cronExpression" value="0 0/3 * * * ?"/> -->
         <!-- <property name="cronExpression" value="0 0/1 * * * ?"/>  -->
        <property name="cronExpression" value="0 0 1 * * ?"/>
    </bean>
    <!-- 调度触发器，设置自己想要的时间规则 -->
    <bean id="timingScheduleTrigger02" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <!-- 加入相关的执行类和方法 -->
        <property name="jobDetail" ref="timingScheduleJobDetail02"/>
        <!-- 设置时间规则 （为了方便测试，设置成一分钟一次。具体的规则见详情）-->
        <!-- <property name="cronExpression" value="00 * * * * ?"/> -->
        <!-- <property name="cronExpression" value="0 0/3 * * * ?"/> -->
       <!--  <property name="cronExpression" value="0 0/1 * * * ?"/> -->
        <property name="cronExpression" value="0 30 1 * * ?"/>
    </bean>
    <!-- 加入调度工厂 ,设置调度触发器即可-->
    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="timingScheduleTrigger"/>
                <ref bean="timingScheduleTrigger02"/>
            </list>
        </property>
    </bean>

</beans>

package com.littleLady.receptionWeb.schedule;

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import com.littleLady.receptionWeb.pojo.Product_Invoice;
import com.littleLady.receptionWeb.pojo.Product_order;
import com.littleLady.receptionWeb.pojo.Shop_user;
import com.littleLady.receptionWeb.pojo.Shop_user_money;
import com.littleLady.receptionWeb.pojo.User_money_product;
import com.littleLady.receptionWeb.service.ShoopingService;
import com.littleLady.receptionWeb.service.UserService;
@Controller
public class TimingSchedule {
    
    @Autowired
    private UserService userService;
    @Autowired
    private ShoopingService shoopingService;
    
    
    //定时执行的方法
    public void execute(){
        System.out.println("执行时间"+ new Date());
        //查询全部用户
        List<Shop_user> userAll = userService.userAll();
        if(userAll.size()>0) {
           //循环全部用户
           for (int i = 0; i < userAll.size(); i++) {
               //获取用户对象
               Shop_user shop_user = userAll.get(i);
               System.out.println("获取当前用户="+shop_user);
               //查询当前用户对象下全部订单
               List<Product_order> userOrder = userService.userOrder(shop_user.getUser_id());
               //如果当前用户存在订单
               if(userOrder.size()>0) {
                   //循环订单
                   for (int j = 0; j < userOrder.size(); j++) {
                       //当前订单
                       Product_order product_order = userOrder.get(j);
                       System.out.println("当前订单="+product_order);
                       //获取状态为待收货状态
                       if(product_order.getOrder_state()==3) {
                           //当发货时间距离当前时间15以外改变状态为待评价,并且无售后功能,转换金额为可用余额
                           Product_Invoice quertSenderById = userService.quertSenderById(product_order.getOrder_id());
                           if(quertSenderById!=null) {
                           System.out.println("发货单="+quertSenderById);
                           //获取发货时间
                           Date inv_time = quertSenderById.getInv_time();
                           Date inv_ti=new Date(inv_time.getTime()+(15*86400000));
                           
                           //获取当前日期
                           Date date=new Date();
                           //格式化日期工具
                           SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
                           String format = sdf.format(date);
                           String format2 = sdf.format(inv_ti);
                           //转化以天为整数去掉时分秒
                           try {
                               date=sdf.parse(format);
                               inv_ti=sdf.parse(format2);
                           } catch (ParseException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                           }
                           //判断当前日期是否大于15天
                           if(date.getTime()>=inv_ti.getTime()) {
                               /**
                                * 修改订单状态(变为待评价),标记没有售后,添加收货时间
                                * 结算订单,标记订单已经结算,修改余额
                                * */
                               //改变状态
                               System.out.println("order_id="+product_order.getOrder_id());
                               Product_order order=new Product_order();
                               order.setOrder_id(product_order.getOrder_id());
                               order.setOrder_state(4);
                               order.setIfBalance(1);
                               order.setIfAfterSale(1);
                               order.setArrive_date(new Date());
                               userService.updateCancelOrderById(order);
                               
                               //标记订单结算
                               shoopingService.updateOrderAccount(order);
                               
                               //标记订单没有售后
                               shoopingService.updateOrderAfter(order);
                               
                               //添加收货时间
                               shoopingService.updateAddReceive(order);
                               
                               //修改余额
                             //查找上级代理id
                                Shop_user userById = userService.userById(shop_user.getUser_id());
                                
                                //如果沒有上級代理，就不产生余额
                                if(userById.getUser_invcode()!=null){
                                    Shop_user userTe=new Shop_user();
                                    userTe.setUser_phone(userById.getUser_invcode());
                                    List<Shop_user> userPhone = userService.userPhone(userTe);
                                    Shop_user user = userPhone.get(0);
                                    int user_id2 = user.getUser_id();
                                    
                                    //处理余额
                                    Product_order queryOrderById = shoopingService.queryOrderById(product_order.getOrder_id());
                                    DecimalFormat df = new DecimalFormat("0.00");
                                    df.setRoundingMode(RoundingMode.HALF_UP);
                                    
                                    double order_price = queryOrderById.getOrder_price()*0.1;
                                    String formats = df.format(order_price);
                                    double mau=Double.parseDouble(formats);
                                    Shop_user_money queryUserBalance = userService.queryUserBalance(user_id2);
                                    
                                    queryUserBalance.setFrozenCapital(queryUserBalance.getFrozenCapital()-mau);
                                    queryUserBalance.setMoneyAvail(queryUserBalance.getMoneyAvail()+mau);
                                    
                                    userService.updateUserBalance(queryUserBalance);
                                    
                                    //修改余额记录
                                    User_money_product product=new User_money_product();
                                    product.setOrder_id(product_order.getOrder_id());
                                    product.setMoneyAvail(mau);
                                    product.setUsable_date(new Date());
                                    userService.updateBalanceRecode(product);
                                }
                           }else {
                               System.out.println("不满足15天");
                           }
                       }
                       }else {
                           System.out.println("不是收货状态!");
                       }
                   }
               }else {
                   System.out.println("当前用户没有订单");
               }
           }
        }else {
            System.out.println("用户为空");
        }
    }
    
    public void cancelAfterSale() {
        System.err.println("执行"+new Date());
        //获取全部用户
        List<Shop_user> userAll = userService.userAll();
        //循环用户
        for (int i = 0; i < userAll.size(); i++) {
            //当前用户
            Shop_user shop_user = userAll.get(i);
            System.out.println("当前用户id="+shop_user.getUser_id());
            //获取当前用户下的所有订单
            List<Product_order> userOrder = userService.userOrder(shop_user.getUser_id());
            for (int j = 0; j < userOrder.size(); j++) {
                Product_order product_order = userOrder.get(j);
                 System.out.println("order_id="+product_order.getOrder_id());
                //是否取消售后
                if(product_order.getOrder_state()==4&&product_order.getIfAfterSale()==0&&product_order.getArrive_date()!=null) {
                    //售后状态存在收货后3天内
                    System.out.println("不存在售后");
                    System.out.println("order_id="+product_order.getOrder_id());
                    //获取收货时间
                    Date arrive_date = product_order.getArrive_date();
                    if(arrive_date!=null) {
                     System.out.println("具有收货时间");
                    //收货后3天的日期
                    Date date=new Date(arrive_date.getTime()+(86400000*3));
                    Date dateCurremt=new Date();
                    
                    SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
                    
                    String format = sdf.format(date);
                    String format2 = sdf.format(dateCurremt);
                    try {
                        date=sdf.parse(format);
                        dateCurremt=sdf.parse(format2);
                        } catch (ParseException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                            System.out.println("当前如期="+format2);
                            System.out.println("3天后的日期="+format);
                    
                    
                    
                           //如果当前日期大于3天后的收货日期当前日期
                           if(dateCurremt.getTime()>=date.getTime()) {
                               
                               System.out.println("----------------------------------------------------------------------");
                               Product_order order=new Product_order();
                               order.setOrder_id(product_order.getOrder_id());
                               order.setIfBalance(1);
                               order.setIfAfterSale(1);
                               
                               shoopingService.updateOrderAccount(order);
                               shoopingService.updateOrderAfter(order);
                               
                             //查找上级代理id
                                Shop_user userById = userService.userById(shop_user.getUser_id());
                                //如果沒有上級代理，就不产生余额
                                if(userById.getUser_invcode()!=null){
                                    Shop_user userTe=new Shop_user();
                                    userTe.setUser_phone(userById.getUser_invcode());
                                    List<Shop_user> userPhone = userService.userPhone(userTe);
                                    Shop_user shop_users = userPhone.get(0);
                                    int user_id2 = shop_users.getUser_id();
                                    
                                    //处理余额
                                    Product_order queryOrderById = shoopingService.queryOrderById(product_order.getOrder_id());
                                    DecimalFormat df = new DecimalFormat("0.00");
                                    df.setRoundingMode(RoundingMode.HALF_UP);
                                    
                                    double order_price = queryOrderById.getOrder_price()*0.1;
                                    String formats = df.format(order_price);
                                    double mau=Double.parseDouble(formats);
                                    Shop_user_money queryUserBalance = userService.queryUserBalance(user_id2);
                                    
                                    queryUserBalance.setFrozenCapital(queryUserBalance.getFrozenCapital()-mau);
                                    queryUserBalance.setMoneyAvail(queryUserBalance.getMoneyAvail()+mau);
                                    
                                    userService.updateUserBalance(queryUserBalance);
                                    //修改余额记录
                                    User_money_product product=new User_money_product();
                                    product.setOrder_id(product_order.getOrder_id());
                                    product.setMoneyAvail(mau);
                                    product.setUsable_date(new Date());
                                    userService.updateBalanceRecode(product);
                                }
                           }else {
                               System.out.println("当前日期小于3天");
                           }
                       }
                }
            }
        }
    }
}