java 实现自动派单(自动分配任务)

最新推荐文章于 2024-09-24 09:35:27 发布

薛思远的csdn

最新推荐文章于 2024-09-24 09:35:27 发布

阅读量6k

点赞数 2

原文链接：https://blog.csdn.net/yiding123/article/details/84622005

版权

需求：

最近要实现一个自动派单功能，就是如果有任务来了，那么任务平均分配给现有的员工，如果之前取了任务的员工下次来任务时就分配给下一个，如果有新员工则将员工添加到队列的最后，如果有员工离职就将员工信息从队列里移除。

实现：

1.写一个定时任务，定时将任务放入任务队列中TaskQueue，并将员工放入User队列中，如果员工已存在则不添加，如果新员工则加入队列中，如果员工不存在了就从队列中移除。

2.写一个线程，从任务队列中取任务，如果任务不存在则阻塞，取到任务后，将该任务派给下一个员工，并将该员工添加到员工队列末尾，这样达到按员工次序分配任务。

3.实现一个任务队列，如果在取任务时任务不存在则阻塞。

4.实现一个员工队列，在取下一个员工后将该员工从列头移到列尾，并且可以将新员工加入到队列未尾，可以将不存在的员工从队列中移除。

核心代码：

import java.util.Collection;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
 
/**
 * 任务队列
 * 如果在取任务时没有任务，则阻塞
 * @author dg
 *
 */
public class TaskQueue {
    
    private static TaskQueue instance;
    
    private static BlockingQueue queue = null;
    
    private TaskQueue(){
        queue = new LinkedBlockingDeque();
    }
    
    public static TaskQueue getInstance(){
        if(instance == null){
            instance = new TaskQueue();
        }
        return instance;
    }
    
    /**
     * 获取队列大小
     * @return
     */
    public static int getSize(){
        return queue.size();
    }
    
    /**
     * 放入队列中
     * @param msg
     */
    public void put(Object obj){
        if(obj != null){
            try {
                queue.put(obj);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 放入队列中
     * @param msg
     */
    public void putAll(Collection objs){
        if(objs != null){
            queue.addAll(objs);
        }
    }
    
    /**
     * 从队列中取出一个
     * @return
     */
    public Object take(){
        try {
            Object obj = queue.take();    
            return obj;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
 
}

/**
 * 存放即将被派任务的员工
 * 每次取出员工时不移除该员工，而是将其放到队列末尾
 * 如果员工已不存在，将其移除
 * @author dg
 *
 */
public class UserQueue {
    
    private static UserQueue instance = null;
    private static BlockingQueue<User> queue = null;
    
    private UserQueue(){
        queue =  new LinkedBlockingDeque<User>();
    }
    
    public static UserQueue getInstance(){
        if(instance == null){
            instance = new UserQueue();
        }
        return instance;
    }
 
    /**
     * 取下一个员工
     * @return
     */
    public User takeNext(){
        User user = null;
        try {
            user = queue.take();
            this.put(user);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return user;
    }
    
    /**
     * 将新员工放入队列中未尾
     */
    public void put(User user){
        if(queue.contains(user)){
            return;
        }else{
            try {
                queue.put(user);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public void putAll(Collection<User> users){
        for(User user : users){
            this.put(user);
        }
    }
    
    /**
     * 将已不存在的员工移除
     */
    public void remove(User user){
        if(queue.contains(user)){
            queue.remove(user);
        }
    }
    
    /**
     * 获取目前队列中所有的user
     * @return
     */
    public Object[] getAllUsers(){
        Object[] obj = queue.toArray();
        return obj;
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        User user1 = new User();
        user1.setUid(1);
        user1.setAccount("11");
        
        User user2 = new User();
        user2.setUid(1);
        user2.setAccount("11");
        
        User user3 = new User();
        user3.setUid(3);
        user3.setAccount("11");
        
        User user4 = new User();
        user4.setUid(4);
        user4.setAccount("444");
        
        User user5 = new User();
        user5.setUid(5);
        user5.setAccount("555");
        
        UserQueue.getInstance().put(user1);
        UserQueue.getInstance().put(user2);
        UserQueue.getInstance().put(user3);
        UserQueue.getInstance().put(user4);
        UserQueue.getInstance().put(user5);
        
        for(int i = 0 ; i < 20; i++){
            System.out.println(UserQueue.getInstance().takeNext().getUid());
            if(i == 5){
                UserQueue.getInstance().remove(user2);
            }
        }
        
        Object[] users = UserQueue.getInstance().getAllUsers();
        System.out.println("=======");
        for(Object user:users){
            System.out.println(((User)user).getUid());
        }
    }
 
}

对于要实现User对象的比较，首先要重写equals方法.以下是我重写的User的equals方法

public boolean equals(Object obj) {
        if(!(obj instanceof User)){
            return false;
        }
        User u = (User)obj;
        return (u.getAccount().equals(account) && u.getUid().equals(uid));
    }


import java.util.List;
import java.util.TimerTask;
 
import org.apache.log4j.Logger;
 
import com.cms.common.ServiceUtil;
import com.cms.common.SysConfig;
import com.cms.entity.ClientRecord;
import com.cms.entity.User;
import com.cms.service.ClientService;
 
/**
 * 定时将客户意向放入任务队列
 * 并且重新成功员工队列 
 * @author dg
 *
 */
public class GenerateTask extends TimerTask {
    
    private static Logger logger = Logger.getLogger(GenerateTask.class);
    private ClientService clientService = (ClientService)ServiceUtil.getService("clientService");
 
    public void run() {
        try {
            String autoTaskRoleIds = SysConfig.getStrValue("autotask.roleid");
            if(autoTaskRoleIds == null || autoTaskRoleIds.trim().equals("") 
                    || autoTaskRoleIds.split(",").length == 0){
                logger.error("自动派单角色未设置");
                return;
            }
            //取全部名单
            List<User> userList = clientService.getAllAutoTaskUsers(autoTaskRoleIds.split(","));
            if(userList == null || userList.size() == 0){
                logger.error("目前还未有业务员无法派单");
                return;
            }
            //将已不存在的用户移除
            Object[] users = UserQueue.getInstance().getAllUsers();
            for(Object user : users){
                if(!userList.contains(user)){
                    UserQueue.getInstance().remove((User)user);
                }
            }
            //重新生成名单
            UserQueue.getInstance().putAll(userList);
            //生成任务
            List<ClientRecord> recordList = clientService.getAllUnAssignRecord();
            TaskQueue.getInstance().putAll(recordList);
        } catch (Throwable t) {
            logger.error("自动派单任务异常!" ,t);
        }finally{
            logger.info("此次任务执行完毕!");
        }
    }
}

import org.apache.log4j.Logger;
 
import com.cms.common.ServiceUtil;
import com.cms.entity.ClientRecord;
import com.cms.entity.User;
import com.cms.schedule.TaskQueue;
import com.cms.schedule.UserQueue;
import com.cms.service.ClientService;
 
/**
 * 从任务队列里取到任务，自动派单给业务员
 * @author dg
 *
 */
public class AutoDispatchTaskThread implements Runnable{
    
    private static Logger logger = Logger.getLogger(AutoDispatchTaskThread.class);
    private ClientService clientService = (ClientService)ServiceUtil.getService("clientService");
    
    private boolean stop = false;
 
    @Override
    public void run() {
        try{
            while(!stop){
                ClientRecord record = (ClientRecord)TaskQueue.getInstance().take();
                User user = UserQueue.getInstance().takeNext();
                clientService.assginRecord(record.getRid(), user.getUid());
            }
        }catch(Throwable t){
            logger.error(t.getMessage(),t);
        }
    }
}

————————————————
版权声明：本文为CSDN博主「yiding123」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yiding123/article/details/84622005