wms / hhwms · Files

package com.huaheng.framework.web.controller;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.huaheng.api.srm.domain.SRMResult;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.framework.web.domain.AjaxResultTv;
import com.huaheng.framework.web.domain.ResultErp;
import com.huaheng.framework.web.page.PageDomain;
import com.huaheng.framework.web.page.TableDataInfo;
import com.huaheng.framework.web.page.TableSupport;
import com.huaheng.pc.system.user.domain.User;
import org.apache.commons.collections.MapUtils;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;

import javax.annotation.Nonnull;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * web层通用数据处理
 *
 * @author huaheng
 */
public class BaseController {
    /**
     * 将前台传递过来的日期格式的字符串，自动转化为Date类型
     */
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        dateFormat.setLenient(false);
        binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));

//        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//        LocalDateTime time = LocalDateTime.now();
//        String localTime = df.format(time);
//        将LocalDateTime转为String
    }

    /**
     * 设置请求分页数据
     */
    protected void startPage() {
        PageDomain pageDomain = TableSupport.buildPageRequest();
        Integer pageNum = pageDomain.getPageNum();
        Integer pageSize = pageDomain.getPageSize();
        if (StringUtils.isNotNull(pageNum) && StringUtils.isNotNull(pageSize)) {
            String orderBy = pageDomain.getOrderBy();
            PageHelper.startPage(pageNum, pageSize, orderBy);
        }
    }

    protected void startPages() {
        PageDomain pageDomain = TableSupport.buildPageRequest();
        Integer pageNum = pageDomain.getPageNum();
        Integer pageSize = pageDomain.getPageSize() / 2;
        if (StringUtils.isNotNull(pageNum) && StringUtils.isNotNull(pageSize)) {
            String orderBy = pageDomain.getOrderBy();
            PageHelper.startPage(pageNum, pageSize, orderBy);
        }
    }

    /**
     * 设置请求分页数据
     */
    protected void startPage(Integer pageNum, Integer pageSize, String orderBy) {
        PageHelper.startPage(pageNum, pageSize, orderBy);
    }

    /**
     * 响应请求分页数据
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    protected TableDataInfo getDataTable(List<?> list) {
        TableDataInfo rspData = new TableDataInfo();
        rspData.setCode(200);
        rspData.setData(list);
        rspData.setTotal(new PageInfo(list).getTotal());
        return rspData;
    }

    /**
     * 响应返回结果
     *
     * @param rows 影响行数
     * @return 操作结果
     */
    protected AjaxResult toAjax(int rows) {
        return rows > 0 ? success() : error();
    }

    /**
     * 响应返回结果
     *
     * @param succeed 是否成功
     * @return 操作结果
     */
    protected AjaxResult toAjax(boolean succeed) {
        return succeed ? success() : error();
    }

    /**
     * 返回成功
     */
    public AjaxResult success() {
        return AjaxResult.success("操作成功！");
    }

    /**
     * 返回失败消息
     */
    public AjaxResult error() {
        return AjaxResult.error("操作失败！");
    }

    /**
     * 返回成功消息
     */
    public AjaxResult success(String message) {
        return AjaxResult.success(message);
    }

    /**
     * 返回失败消息
     */
    public AjaxResult error(String message) {
        return AjaxResult.error(message);
    }

//    /**
//     * 返回错误码消息
//     */
//    public AjaxResult error(int code, String message)
//    {
//        return AjaxResult.error(code, message);
//    }

    /**
     * 页面跳转
     */
    public String redirect(String url) {
        return StringUtils.format("redirect:{}", url);
    }

    public User getUser() {
        return ShiroUtils.getUser();
    }

    public void setUser(User user) {
        ShiroUtils.setUser(user);
    }

    public Integer getUserId() {
        return getUser().getId();
    }

    public String getLoginName() {
        return getUser().getLoginName();
    }

    /**
     * mybatis-plus响应请求分页数据
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    protected TableDataInfo getMpDataTable(List<?> list, Long total) {
        TableDataInfo rspData = new TableDataInfo();
        rspData.setCode(200);
        rspData.setData(list);
        rspData.setTotal(total);
        return rspData;
    }

    Semaphore semaphore = new Semaphore(1);

    public AjaxResult handleMultiProcess(MultiProcessListener multiProcessListener) {
        AjaxResult ajaxResult = null;
        int max_time = 30 * 1000;
        int now = 0;
        boolean avail = true;
        while (avail) {
            int availablePermits = semaphore.availablePermits();
            if (availablePermits > 0) {
                avail = false;
                try {
                    semaphore.acquire(1);
                    ajaxResult = multiProcessListener.doProcess();
                } catch (Exception e) {
                    e.printStackTrace();
                    ajaxResult = AjaxResult.error(e.getMessage());
                } finally {
                    semaphore.release(1);
                }
            } else {
                ajaxResult = AjaxResult.error("多线程处理异常");
                try {
                    now = now + 200;
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (now >= max_time) {
                    avail = false;
                }
            }
        }
        return ajaxResult;
    }

    public interface MultiProcessListener {
        AjaxResult doProcess();
    }

    // 下发任务并发控制
    Map<String, Boolean> multiProcessMap = new HashMap<>();

    public AjaxResult handleMultiProcessV1(String taskKey, MultiProcessListener multiProcessListener) {
        AjaxResult ajaxResult = null;
        int max_time = 50 * 1000;
        int now = 0;
        boolean avail = true;
        while (avail) {
            boolean availablePermits = MapUtils.getBoolean(multiProcessMap, taskKey, false);
            if (!availablePermits) {
                avail = false;
                try {
                    multiProcessMap.put(taskKey, true);
                    ajaxResult = multiProcessListener.doProcess();
                } catch (Exception e) {
                    e.printStackTrace();
//                    throw new RuntimeException(e);
                    ajaxResult = AjaxResult.error(e.getMessage());
                } finally {
                    multiProcessMap.put(taskKey, false);
                }
            } else {
                ajaxResult = AjaxResult.error("多线程处理异常, 待处理现场太多，等待时间超出30秒");
                try {
                    now = now + 200;
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (now >= max_time) {
                    avail = false;
                }
            }
        }
        return ajaxResult;
    }
    public AjaxResult handleMultiProcessV2(String taskKey, MultiProcessListener multiProcessListener) {
        AjaxResult ajaxResult = null;
        int max_time = 10*60*1000;
        int now = 0;
        boolean avail = true;
        while (avail) {
            boolean availablePermits = MapUtils.getBoolean(multiProcessMap, taskKey, false);
            if (!availablePermits) {
                avail = false;
                try {
                    multiProcessMap.put(taskKey, true);
                    ajaxResult = multiProcessListener.doProcess();
                } catch (Exception e) {
                    e.printStackTrace();
//                    throw new RuntimeException(e);
                    ajaxResult = AjaxResult.error(e.getMessage());
                } finally {
                    multiProcessMap.put(taskKey, false);
                }
            } else {
                ajaxResult = AjaxResult.error("多线程处理异常, 待处理现场太多，等待时间超出60秒");
                try {
                    now = now + 200;
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (now >= max_time) {
                    avail = false;
                }
            }
        }
        return ajaxResult;
    }

    public AjaxResult handleMultiProcessV3(String taskKey, MultiProcessListener multiProcessListener) {
        AjaxResult ajaxResult = null;
        int max_time = 10*90*1000;
        int now = 0;
        boolean avail = true;
        while (avail) {
            boolean availablePermits = MapUtils.getBoolean(multiProcessMap, taskKey, false);
            if (!availablePermits) {
                avail = false;
                try {
                    multiProcessMap.put(taskKey, true);
                    ajaxResult = multiProcessListener.doProcess();
                } catch (Exception e) {
                    e.printStackTrace();
//                    throw new RuntimeException(e);
                    ajaxResult = AjaxResult.error(e.getMessage());
                } finally {
                    multiProcessMap.put(taskKey, false);
                }
            } else {
                ajaxResult = AjaxResult.error("多线程处理异常, 待处理现场太多，等待时间超出90秒");
                try {
                    now = now + 200;
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (now >= max_time) {
                    avail = false;
                }
            }
        }
        return ajaxResult;
    }

    /**
     * 获取分布式锁，自定义锁等待，释放时间</br>
     * 注意锁与事务的顺序：获取分布式锁 -> 开启事务 -> 执行业务 -> 提交事务 -> 释放分布式锁
     * @param      lockKey
     * @param      multiProcessListener
     * @return
     */
    public AjaxResult handleMultiProcessLock(String taskKey,String lockKey,MultiProcessListener multiProcessListener ) {
        AjaxResult ajaxResult = null;
        int max_time = 10*90*1000;
        int now = 0;
        String key=taskKey+"_"+lockKey;
        boolean avail = true;
        while (avail) {
            boolean availablePermits = MapUtils.getBoolean(multiProcessMap, key, false);
            if (!availablePermits) {
                avail = false;
                try {
                    multiProcessMap.put(key, true);
                    ajaxResult = multiProcessListener.doProcess();
                } catch (Exception e) {
                    e.printStackTrace();
//                    throw new RuntimeException(e);
                    ajaxResult = AjaxResult.error(e.getMessage());
                } finally {
                    multiProcessMap.put(key, false);
                }
            } else {
                ajaxResult = AjaxResult.error("多线程处理异常, 待处理现场太多，等待时间超出90秒");
                try {
                    now = now + 200;
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (now >= max_time) {
                    avail = false;
                }
            }
        }
        return ajaxResult;
    }
    public interface MultiProcessListenerErp {
        ResultErp doProcess();
    }
    public ResultErp handleMultiProcessErp(String taskKey, MultiProcessListenerErp multiProcessListener) {
        ResultErp ajaxResult = null;
        int max_time = 30 * 1000;
        int now = 0;
        boolean avail = true;
        while (avail) {
            boolean availablePermits = MapUtils.getBoolean(multiProcessMap, taskKey, false);
            if (!availablePermits) {
                avail = false;
                try {
                    multiProcessMap.put(taskKey, true);
                    ajaxResult = multiProcessListener.doProcess();
                } catch (Exception e) {
                    e.printStackTrace();
//                    throw new RuntimeException(e);
                    ajaxResult = ResultErp.error(e.getMessage());
                } finally {
                    multiProcessMap.put(taskKey, false);
                }
            } else {
                ajaxResult = ResultErp.error("多线程处理异常, 待处理现场太多，等待时间超出30秒");
                try {
                    now = now + 200;
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (now >= max_time) {
                    avail = false;
                }
            }
        }
        return ajaxResult;
    }
    public interface MultiProcessListenerTv {
        AjaxResultTv doProcess();
    }
    public AjaxResultTv handleMultiProcessTv(String taskKey, MultiProcessListenerTv multiProcessListener) {
        AjaxResultTv ajaxResult = null;
        int max_time = 30 * 1000;
        int now = 0;
        boolean avail = true;
        while (avail) {
            boolean availablePermits = MapUtils.getBoolean(multiProcessMap, taskKey, false);
            if (!availablePermits) {
                avail = false;
                try {
                    multiProcessMap.put(taskKey, true);
                    ajaxResult = multiProcessListener.doProcess();
                } catch (Exception e) {
                    e.printStackTrace();
//                    throw new RuntimeException(e);
                    ajaxResult = AjaxResultTv.error(e.getMessage());
                } finally {
                    multiProcessMap.put(taskKey, false);
                }
            } else {
                ajaxResult = AjaxResultTv.error("多线程处理异常, 待处理现场太多，等待时间超出30秒");
                try {
                    now = now + 200;
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (now >= max_time) {
                    avail = false;
                }
            }
        }
        return ajaxResult;
    }
    public interface MultiProcessListenerSrm {
        SRMResult doProcess();
    }
    public SRMResult handleMultiProcessSrm(String taskKey, MultiProcessListenerSrm multiProcessListener) {
        SRMResult ajaxResult = new SRMResult();
        int max_time = 30 * 1000;
        int now = 0;
        boolean avail = true;
        while (avail) {
            boolean availablePermits = MapUtils.getBoolean(multiProcessMap, taskKey, false);
            if (!availablePermits) {
                avail = false;
                try {
                    multiProcessMap.put(taskKey, true);
                    ajaxResult = multiProcessListener.doProcess();
                } catch (Exception e) {
                    e.printStackTrace();
//                    throw new RuntimeException(e);
                    ajaxResult.setSuccess(false);
                    ajaxResult.setMessage(e.getMessage());
                } finally {
                    multiProcessMap.put(taskKey, false);
                }
            } else {
                ajaxResult.setSuccess(false);
                ajaxResult.setMessage("多线程处理异常, 待处理现场太多，等待时间超出30秒");
//                ajaxResult = ResultErp.error("多线程处理异常, 待处理现场太多，等待时间超出30秒");
                try {
                    now = now + 200;
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (now >= max_time) {
                    avail = false;
                }
            }
        }
        return ajaxResult;
    }

    // 存放每个 key 对应的独立锁
    private static final Map<String, ReentrantLock> lockMap = new ConcurrentHashMap<>();

    /**
     * 手工锁控制并发，带最大等待时间
     */
    public AjaxResult handleMultiProcessLock1(String taskKey, String lockKey, MultiProcessListener multiProcessListener) {
        String key = taskKey + "_" + lockKey;
        ReentrantLock lock = lockMap.computeIfAbsent(key, k -> new ReentrantLock());

        boolean locked = false;
        try {
            // 最长等待 90 秒尝试获取锁
            locked = lock.tryLock(90, TimeUnit.SECONDS);

            if (locked) {
                // 拿到锁后执行逻辑
                return multiProcessListener.doProcess();
            } else {
                return AjaxResult.error("多线程处理异常：等待超时（超过90秒未获取锁）");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return AjaxResult.error("执行异常：" + e.getMessage());
        } finally {
            // 只有成功获取锁后才能释放
            if (locked) {
                lock.unlock();
            }
            // 可选：清理无用锁对象，防止内存堆积
            if (!lock.hasQueuedThreads()) {
                lockMap.remove(key);
            }
        }
    }

    // 使用线程安全的ConcurrentHashMap存储锁状态
    private final Map<String, Boolean> lockMap1 = new ConcurrentHashMap<>();
    /**
     * 基于手工锁的并发控制处理
     * @param lockKey 锁标识（方法名称+唯一号组合）
     * @param task 需要执行的任务
     * @return 处理结果
     */
    public AjaxResult handleSingleNodeLock(String lockKey, Runnable task) {
        // 1. 原子操作获取锁（使用putIfAbsent实现CAS效果）
        Boolean lockAcquired = lockMap1.putIfAbsent(lockKey,  Boolean.TRUE) == null;

        // 2. 未获取到锁直接返回
        if (!lockAcquired) {
            return AjaxResult.error(" 系统处理中，请稍后重试");
        }

        try {
            // 3. 执行任务
            task.run();
            return AjaxResult.success();
        } catch (Exception e) {
            // 4. 捕获任务执行异常
            return AjaxResult.error(" 任务执行失败: " + e.getMessage());
        } finally {
            // 5. 确保锁释放（无论成功失败都执行）
            lockMap1.remove(lockKey);
        }
//        AjaxResult ajaxResult1 =handleSingleNodeLock("complete",() -> {
//            // 这里编写具体业务逻辑
//            // ...订单处理代码...
//        });
    }

}