子母车密集库项目中提升机代码JAVA

最新推荐文章于 2025-12-08 16:37:50 发布
原创 最新推荐文章于 2025-12-08 16:37:50 发布 · 325 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #hibernate #开发语言

该代码实现了一个名为LiftThread的类，继承自BlockThread，用于处理自动化仓储系统中电梯（Lift）的工作状态。它检查电梯是否在等待响应，处理不同状态的作业，如充电、存储和检索任务，并使用MsgSender发送指令到相关组件。此外，它还涉及数据库操作，如查询和更新状态。

package com.thread.threads;

import com.asrs.business.consts.AsrsJobType;
import com.asrs.domain.AsrsJob;
import com.asrs.domain.RouteDetail;
import com.asrs.message.Message03;
import com.thread.blocks.*;
import com.thread.utils.MsgSender;
import com.util.hibernate.HibernateUtil;
import com.util.hibernate.Transaction;
import org.apache.commons.lang.StringUtils;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;

import java.util.List;

/**
 * Created by 
 */
public class LiftThread extends BlockThread<Lift> {


    public LiftThread(String blockNo) {
        super(blockNo);
    }

    @Override
    public void run() {
        while (true) {
            try {
                Transaction.begin();
                Session session = HibernateUtil.getCurrentSession();
                Lift lift = getBlock();
                if (lift.isWaitingResponse()) {

                } else if(lift.getStatus().equals("2")){

                }else {
                    if (StringUtils.isBlank(lift.getReservedMcKey()) && StringUtils.isBlank(lift.getMcKey())) {


//                        Query query = HibernateUtil.getCurrentSession().createQuery("from RouteDetail r,Block b,AsrsJob a where r.currentBlockNo = b.blockNo and " +
//                                " b.mcKey = a.mcKey and r.nextBlockNo=:nB order by a.id asc").setParameter("nB", lift.getBlockNo());
                        Query query = HibernateUtil.getCurrentSession().createQuery("select r from RouteDetail r,Block b,AsrsJob a where r.currentBlockNo = b.blockNo and " +
                                " b.mcKey = a.mcKey and r.nextBlockNo=:nB order by a.id asc").setParameter("nB", lift.getBlockNo());
                        List<RouteDetail> details = query.list();
                        boolean hasjob = false;
                        for (RouteDetail detail : details) {
                            Block block = Block.getByBlockNo(detail.getCurrentBlockNo());
                            if (StringUtils.isNotEmpty(block.getMcKey()) || StringUtils.isNotEmpty(block.getReservedMcKey())) {
                                String mckey = StringUtils.isNotEmpty(block.getMcKey()) ? block.getMcKey() : block.getReservedMcKey();
                                AsrsJob asrsJob = AsrsJob.getAsrsJobByMcKey(mckey);
                                if (asrsJob != null && detail.getRoute().getType().equals(asrsJob.getType())
                                        && detail.getRoute().getFromStation().equals(asrsJob.getFromStation())
                                        && detail.getRoute().getToStation().equals(asrsJob.getToStation())) {
                                    if (asrsJob.getType().equals(AsrsJobType.RECHARGED)) {
                                        if (block instanceof MCar) {
                                            HibernateUtil.getCurrentSession().createQuery("update Lift set reservedMcKey=:mckey where blockNo=:blockNo").setParameter("blockNo", lift.getBlockNo())
                                                    .setParameter("mckey", block.getMcKey()).executeUpdate();
                                            hasjob = true;
                                            break;
                                        }
                                    } else if (asrsJob.getType().equals(AsrsJobType.RECHARGEDOVER)) {
                                        if (block instanceof Conveyor) {
                                            HibernateUtil.getCurrentSession().createQuery("update Lift set reservedMcKey=:mckey where blockNo=:blockNo").setParameter("blockNo", lift.getBlockNo())
                                                    .setParameter("mckey", block.getMcKey()).executeUpdate();
                                            hasjob = true;
                                            break;
                                        }
                                    } else {

                                        Query jq = HibernateUtil.getCurrentSession().createQuery("from AsrsJob where type =:tp1 or type =:tp2");
                                        jq.setParameter("tp1", AsrsJobType.RECHARGED);
                                        jq.setParameter("tp2", AsrsJobType.RECHARGEDOVER);
                                        List<AsrsJob> jobs = jq.list();

                                        if (!jobs.isEmpty()) {
                                            Transaction.commit();
                                            Thread.sleep(500);
                                            break;
                                        }

                                        Conveyor block1 = (Conveyor) Block.getByBlockNo("0003");
                                        if (StringUtils.isNotEmpty(block1.getOnCar())) {
                                            Transaction.commit();
                                            Thread.sleep(500);
                                            break;
                                        }

                                        HibernateUtil.getCurrentSession().createQuery("update Lift set reservedMcKey=:mckey where blockNo=:blockNo").setParameter("blockNo", lift.getBlockNo())
                                                .setParameter("mckey", block.getMcKey()).executeUpdate();
                                        hasjob = true;
                                        break;
                                    }
                                }
                            }
                        }
                        if (!hasjob) {
                            if (lift.getLevel() != 1) {
                                Query dockQ = HibernateUtil.getCurrentSession().createQuery("from Dock where liftNo=:liftNo and level=1");
                                dockQ.setParameter("liftNo", lift.getBlockNo());
                                dockQ.setMaxResults(1);
                                Dock dock = (Dock) dockQ.uniqueResult();
                                MsgSender.send03(Message03._CycleOrder.move, "9999", lift, "", dock.getDockNo(), "", "");
                            }
                        }

                    } else if (StringUtils.isNotBlank(lift.getReservedMcKey())) {
                        AsrsJob asrsJob = AsrsJob.getAsrsJobByMcKey(lift.getReservedMcKey());
                        if (AsrsJobType.RECHARGED.equals(asrsJob.getType())) {

                            MCar mCar = (MCar) lift.getPreBlock(asrsJob.getMcKey(), asrsJob.getType());
                            if (mCar.getLevel() == lift.getLevel()
                                    && mCar.getDock().equals(mCar.getDock(mCar.getBlockNo(), lift.getBlockNo()))
                                    && StringUtils.isNotEmpty(mCar.getsCarBlockNo())) {
                                MsgSender.send03(Message03._CycleOrder.loadCar, lift.getReservedMcKey(), lift, "", mCar.getDock(mCar.getBlockNo(), lift.getBlockNo()), "", "");
                            } else {
                                if (mCar.getLevel() != lift.getLevel()) {
                                    MsgSender.send03(Message03._CycleOrder.move, lift.getReservedMcKey(), lift, "", mCar.getDock(mCar.getBlockNo(), lift.getBlockNo()), "", "");
                                }
                            }

                        } else {

                            Block block = (Block) session.createCriteria(Block.class).add(Restrictions.eq("mcKey", lift.getReservedMcKey())).setMaxResults(1).uniqueResult();
                            if (block instanceof MCar) {
                                MCar dock = (MCar) block;
                                String dock1 = dock.getDock(dock.getBlockNo(), lift.getBlockNo());
                                if (lift.getLevel() == dock.getLevel() || (lift.getLevel() == 0 && dock.getLevel() == 1) && dock.getDock().equals(dock1)) {
                                    //dock移栽卸货
                                } else {
                                    MsgSender.send03(Message03._CycleOrder.move, lift.getReservedMcKey(), lift, "", dock.getDock(dock.getBlockNo(), lift.getBlockNo()), "", "");
                                }
                            } else if (block instanceof Conveyor) {
                                Conveyor conveyor = (Conveyor) block;
                                if (lift.getLevel() == 1) {

                                } else {
                                    MsgSender.send03(Message03._CycleOrder.move, lift.getReservedMcKey(), lift, "", conveyor.getDock(), "", "");

                                }
                            }

                        }

                    } else if (StringUtils.isNotBlank(lift.getMcKey())) {
                        AsrsJob asrsJob = AsrsJob.getAsrsJobByMcKey(lift.getMcKey());
                        if (AsrsJobType.RETRIEVAL.equals(asrsJob.getType())) {
                            Block nextBlock = lift.getNextBlock(asrsJob.getType(), asrsJob.getToStation());
                            if (nextBlock instanceof StationBlock) {
                                if (lift.getLevel() == 1) {
                                    if (!nextBlock.isWaitingResponse()) {
                                        MsgSender.send03(Message03._CycleOrder.moveUnloadGoods, lift.getMcKey(), lift, "", nextBlock.getBlockNo(), "", "");
                                        Thread.sleep(200);
                                        MsgSender.send03(Message03._CycleOrder.moveCarryGoods, lift.getMcKey(), nextBlock, "", lift.getBlockNo(), "", "");
                                    } else {
                                        //等待可以移栽
                                    }
                                } else {
                                    MsgSender.send03(Message03._CycleOrder.move, lift.getReservedMcKey(), lift, "", nextBlock.getBlockNo(), "", "");
                                }
                            } else if (nextBlock instanceof Conveyor) {
                                if (lift.getLevel() == 1) {
                                    if (!nextBlock.isWaitingResponse() && StringUtils.isEmpty(nextBlock.getMcKey())) {
                                        MsgSender.send03(Message03._CycleOrder.moveUnloadGoods, lift.getMcKey(), lift, "", nextBlock.getBlockNo(), "", "");
                                        Thread.sleep(200);
                                        MsgSender.send03(Message03._CycleOrder.moveCarryGoods, lift.getMcKey(), nextBlock, "", lift.getBlockNo(), "", "");
                                    } else {
                                        //等待可以移栽
                                    }

                                } else {
                                    Conveyor conveyor = (Conveyor) nextBlock;
                                    MsgSender.send03(Message03._CycleOrder.move, lift.getMcKey(), lift, "", conveyor.getDock(), "", "");
                                }
                            }
                        } else if (AsrsJobType.PUTAWAY.equals(asrsJob.getType()) || AsrsJobType.COUNT.equals(asrsJob.getType())) {

                            Block nextBlock = lift.getNextBlock(asrsJob.getType(), asrsJob.getToStation());
                            if (nextBlock instanceof MCar) {
                                MCar dock = (MCar) nextBlock;
                                String dock1 = dock.getDock(dock.getBlockNo(), lift.getBlockNo());
                                if (lift.getLevel() == dock.getLevel() || (lift.getLevel() == 0 && dock.getLevel() == 1) && dock.getDock().equals(dock1)) {
                                    if (!nextBlock.isWaitingResponse()
                                            && StringUtils.isNotEmpty(dock.getReservedMcKey())
                                            && dock1.equals(dock.getDock())) {
                                        MsgSender.send03(Message03._CycleOrder.moveUnloadGoods, lift.getMcKey(), lift, "", nextBlock.getBlockNo(), "", "");
                                        MsgSender.send03(Message03._CycleOrder.moveCarryGoods, lift.getMcKey(), nextBlock, "", lift.getBlockNo(), "", "");
                                    } else {
                                        //等待可以移栽

                                    }
                                } else {
                                    if (lift.getLevel() == dock.getLevel() || (lift.getLevel() == 0 && dock.getLevel() == 1)) {
                                        // 提升机不移动
                                    } else {
                                        MsgSender.send03(Message03._CycleOrder.move, lift.getMcKey(), lift, "", dock1, "", "");
                                    }
                                }
                            }
                        } else if (AsrsJobType.RECHARGEDOVER.equals(asrsJob.getType())) {
                            Block nextBlock = lift.getNextBlock(asrsJob.getType(), asrsJob.getToStation());
                            if (nextBlock instanceof MCar) {
                                MCar mCar = (MCar) nextBlock;
                                if (lift.getLevel() == mCar.getLevel()
                                        && mCar.getDock().equals(mCar.getDock(mCar.getBlockNo(), lift.getBlockNo()))) {
                                    MsgSender.send03(Message03._CycleOrder.unloadCar, lift.getMcKey(), lift, "", mCar.getDock(), "", "");
                                } else {
                                    MsgSender.send03(Message03._CycleOrder.move, asrsJob.getMcKey(), lift, "", mCar.getDock(mCar.getBlockNo(), lift.getBlockNo()), "", "");

                                }
                            }
                        } else if (AsrsJobType.RECHARGED.equals(asrsJob.getType())) {
                            Block nextBlock = lift.getNextBlock(asrsJob.getType(), asrsJob.getToStation());
                            if (nextBlock instanceof Conveyor) {
                                if (lift.getLevel() == 1) {
                                    if (!nextBlock.isWaitingResponse()) {
                                        MsgSender.send03(Message03._CycleOrder.unloadCar, asrsJob.getMcKey(), lift, "", "0101", "", "");
                                        MsgSender.send03(Message03._CycleOrder.loadCar, asrsJob.getMcKey(), nextBlock, "", lift.getOnCar(), "", "");
                                    }
                                } else {
                                    MsgSender.send03(Message03._CycleOrder.move, asrsJob.getMcKey(), lift, "", "0101", "", "");

                                }
                            }
                        } else if (AsrsJobType.CHANGELEVEL.equals(asrsJob.getType())) {
                            Block nextBlock = lift.getNextBlock(asrsJob.getType(), asrsJob.getToStation());
                            if (nextBlock instanceof MCar) {
                                MCar mCar = (MCar) nextBlock;
                                if (lift.getLevel() == mCar.getLevel()) {
                                    if (mCar.isLiftSide()) {
                                        if (StringUtils.isNotEmpty(mCar.getDock()))
                                            MsgSender.send03(Message03._CycleOrder.unloadCar, asrsJob.getMcKey(), lift, "", mCar.getDock(), "", "");
                                    }
                                } else {
                                    MsgSender.send03(Message03._CycleOrder.move, lift.getMcKey(), lift, "", mCar.getDock(mCar.getBlockNo(), lift.getBlockNo()), "", "");
                                }
                            }
                        }
                    }
                }
                Transaction.commit();
            } catch (Exception ex) {
                Transaction.rollback();
                ex.printStackTrace();
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

子母车密集库项目中子车代码JAVA
xdpcxq的专栏
02-11 649
/子车不在母车上，子车有排列层，查找货位是否是aj的源货位，如果一样，取货上车，如果不是，简单接车。//子车不在母车上，子车有排列层，查找货位是否是aj的源货位，如果一样，取货上车，如果不是，简单接车。//子车不在母车上，子车有排列层，查找货位是否是aj的源货位，如果一样，取货上车，如果不是，简单接车。//子车不在母车上，子车有排列层，查找货位是否是aj的源货位，如果一样，取货上车，如果不是，简单接车。//子车在堆垛机，子车有reservedmckey，子车的任务和堆垛机的任务不一样。
基于 Java 的俄罗斯方块游戏的设计与实现
weixin_46879314的博客
07-22 1269
基于Java 的俄罗斯方块游戏的设计与实现
纯干货！Java后端开发十二条经验分享！
Java_LingFeng的博客
12-01 2108
本文是博主从事后端开发以来，对公司、个人项目的经验总结，包含代码编写、功能推荐、第三方库使用及优雅配置等，希望大家看到都能有所收获
深入理解 Java 并发锁
m0_50414588的博客
04-02 4764
一、并发锁简介 确保线程安全最常见的做法是利用锁机制（Lock、sychronized）来对共享数据做互斥同步，这样在同一个时刻，只有一个线程可以执行某个方法或者某个代码块，那么操作必然是原子性的，线程安全的。 在工作、面试中，经常会听到各种五花八门的锁，听的人云里雾里。锁的概念术语很多，它们是针对不同的问题所提出的，通过简单的梳理，也不难理解。 可重入锁 可重入锁又名递归锁，是指同一个线程在外层方法获取了锁，在进入内层方法会自动获取锁。 可重入锁可以在一定程度上避免死锁。 Reentrant.
Java语言基础
浅汐入梦的博客
07-04 1157
本文主要整理了阿里云大学中的课程内容，介绍JavaSE的发展历史，JDK开发环境的搭建，CLASSPATH属性作用，Java程序基本结构、基本数据类型的划分及使用、程序结构、方法的定义与使用。本文是作为Java系列的初期介绍，掌握内容之后可以继续学习Java面向对象编程及高级开发部分。...
【java毕业设计】基于java+swing+Eclipse的俄罗斯方块游戏GUI设计与实现（毕业论文+程序源码）——俄罗斯方块游戏
m0_66238867的博客
06-23 4453
大家好，今天给大家介绍基于java+swing+Eclipse的俄罗斯方块游戏GUI设计与实现，文章末尾附有本毕业设计的论文和源码下载地址哦。文章目录： 这篇论文详细的描述分析了经典传统的俄罗斯方块实现的基本思路和一些基本游戏规则，在此基础之上，更进一步地开发出俄罗斯方块的创新创意模式，在经典游戏基础上开发出随着分数增高而等级增高难度加大的模式，并且创意性的开发出可操控方块颜色变换的模块，并且增添了游戏声音和音乐模块。本论文对上述功能给出了具体实现流程、详细描述、和一些源代码。 本论文阐述了俄罗斯方块游戏的
基于C++Web 智能租赁、库存优化实例
keny-大成的博客
08-06 1080
摘要：基于Java 基于C++Web 智能租赁、库存优化实例，库存租赁优化等技术实践
【经验】马士兵Java自学之路——(精华版)
一见你就笑
05-24 719
目录 JAVA自学之路 一: 学会选择 2 JAVA自学之路 二: JAVA自学路线图 3 JAVA自学之路 三: 要动手 3 JAVA自学之路 四: 要事为先 4 JAVA自学之路 五: 问题解决之道 6 1：要仔细的观察错误的现象，是的，要仔细 6 2：要仔细思考问题会出在哪些环节（重要） 6 3：如何定位错误（重要）分析清楚有哪些环节之后，下一步就是定位到底什么环节出错了。…...
我们如何学好java
程序员涂小哥的技术博客
08-13 1687
转载：http://www.zhihu.com/question/19945685 马士兵有一篇文章，我觉得写得很好，原文转载如下，希望题主可以好好读读。 ------------------------------------------------------------------------------------------------------------ 目录 JA
JAVA实现的子母车密集库管理系统项目解析
在本项目中，子母车密集库项目代码JAVA是一种实现自动化控制的软件系统。代码基于JAVA语言开发，涉及的业务逻辑包含但不限于以下几点： 1. 子车位置管理：项目代码需要能够准确判断子车的位置状态，即子车是否在母...
RaceTheSunBot:机器人玩太阳竞赛
05-18
在这个项目中，Java被选为开发语言，因为它提供了强大的跨平台能力，且拥有丰富的库支持，适合构建复杂的游戏逻辑和控制系统。 2. **游戏框架选择** "RaceTheSunBot"并未指定特定的游戏引擎或框架，但通常，开发者...
Java SE——12.异常（≠错误）《干货笔记》
要努力去发光，而不是被照亮~
12-08 1027
Java SE——12.异常（≠错误）《干货笔记》
MVP改成MVVM模式
u014035162的专栏
12-05 846
面将登录示例改造成（基于 Android Jetpack 的 ViewModel + LiveData + DataBinding），核心是抛弃 Presenter 中间层，通过 ViewModel 管理数据和业务逻辑，LiveData 实现数据驱动 UI，DataBinding 简化视图与数据的绑定。
基于Java旅游信息推荐系统(源码+数据库+文档)
JIngJaneIL的博客
12-08 502
本文介绍了基于SpringBoot+Vue的旅游信息推荐系统和学生成绩管理系统开发项目。系统采用前后端分离架构，后端使用SpringBoot框架简化企业级开发，前端采用Vue.js实现响应式界面，数据库选用MySQL。文章详细说明了系统设计原则、技术选型理由，并提供了代码示例和测试案例。项目包含完整功能演示视频，所有源码经过验证可正常运行。同时提供最新计算机毕业设计选题参考，文末附有源码获取方式。系统适用于大学生项目实战开发，具有模块化设计、安全性强等特点。
零基础学JAVA--Day41(IO文件流+IO流原理+InputStream+OutputStream)
Dxxyyyy的博客
12-05 927
文件在程序中是以流的形式来操作的流：数据在数据源（文件）和程序（内存）之间经历的路径输入流：数据从数据源（文件）到程序（内存）的路径输出流：数据从程序（内存）到数据源（文件）的路径。
Drools规则引擎实战指南
qq_41262225的博客
12-05 499
Drools规则引擎实战指南摘要 Drools是一款开源的Java业务规则管理系统(BRMS)，通过将业务逻辑与代码分离，提高系统灵活性。本文介绍了Drools的核心架构，包括KieBase知识库、KieSession工作内存和规则执行队列Agenda。实战部分展示了Maven依赖配置、项目结构设计，以及实体模型定义方法。通过规则引擎，业务人员可直接维护业务规则，无需修改代码即可实现业务逻辑变更，显著提升系统可维护性。文章还提供了Spring Boot集成方案和规则文件组织结构，帮助开发者快速上手Drool
内存屏障-给出一个乱序执行的实际例子
最新发布
小狗爱吃黄桃罐头的博客
12-08 94
我们跑一个小小的demo看一看int X,Y;int r1,r2;X=1;r1 = Y;Y=1;r2 = X;;X=0;Y=0;detected++;return 0;
Java---集合
2301_80275859的博客
12-04 534
本文介绍了Java集合框架的核心概念和使用方法。主要内容包括：1）集合的基本概念和分类（单列集合Collection和双列集合Map）；2）Collection接口的常用方法（add、remove、contains等）和两种遍历方式（迭代器和增强for循环）；3）List接口特点（有序、可重复）及其实现类ArrayList、LinkedList和Vector的对比；4）Set接口特点（无序、不可重复）及其实现类HashSet和LinkedHashSet；5）底层数据结构分析，包括数组、链表和红黑树的应用场景
【开题答辩全过程】以 基于Javaweb的电动汽车充电桩管理系统为例，包含答辩的问题和答案
shiji9932的博客
12-03 469
本文介绍了一位14年经验的技术专家可提供的毕设支持服务，包括Java、Python等多语言项目开发与答辩指导。重点展示了一个"电动汽车充电桩管理系统"的答辩案例，详细说明了系统功能（预约管理、费用计算等）、技术实现（SpringBoot+Vue+MySQL）及关键问题解决方案（如预约冲突处理、断电检测机制）。文中提供了答辩问答实录，展现了从选题背景到技术细节的完整答辩过程，并附有评委的正面评价。最后建议学生可参考往届真实开题报告，提供选题指导、源码参考等服务，强调独立完成的重要性，同时表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

meslog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值