代码:GAT代管车辆(2)

GAT16.4—2012机动车车辆类型代码 立即下载

package com.jsecode.esb.web.action;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.jsecode.esb.common.BaseBusinessTool;
import com.jsecode.esb.model.protocol.hostEscrowVehicle.HostEscrowVehicleReq;
import com.jsecode.esb.service.HostEscrowVehicleService;
import com.jsecode.esb.util.DictionaryUtil;
import com.jsecode.platform.entity.BaseResp;
import com.jsecode.platform.util.Asserts;

/**
 * 
 * 【代管车辆】
 *
 *
 * @author jsecode01
 * @date 2016年11月18日 上午11:15:09
 * @version 1.0
 */
@Controller
@RequestMapping(value = "/clgl/host")
public class HostEscrowVehicleController extends BaseBusinessTool{

    
    @Autowired
    private HostEscrowVehicleService hostEscrowVehicleService;
    
    
    /*
     * 代管车辆新增接口
     */
    @RequestMapping(value="/escrowVehicleAdd", method = RequestMethod.POST, produces = "application/json")
    @ResponseBody
    public BaseResp hostEscrowVehiclAdd(@RequestBody HostEscrowVehicleReq req) throws Exception {
        return hostEscrowVehicleService.addHostEscrowVehicle(req);
    }
    
    
    /*
     * 代管车辆查询接口
     */
    @RequestMapping(value="/escrowVehicleSearch", method = RequestMethod.POST, produces = "application/json")
    @ResponseBody
    public BaseResp queryHostEscrowVehiclList(@RequestBody HostEscrowVehicleReq req) throws Exception {
        
        ifNoSysDeptThenSetLoginUserSysDept(req);
        
        return hostEscrowVehicleService.queryHostEscrowVehicleList(req);
    }
    
    
    /*
     * 代管车辆修改接口
     */
    @RequestMapping(value="/escrowVehicleUpdate", method = RequestMethod.POST, produces = "application/json")
    @ResponseBody
    public BaseResp updateHostEscrowVehicl(@RequestBody HostEscrowVehicleReq vehicle) throws Exception {
        Asserts.notEmpty(vehicle.getVehicleid(), "修改失败:代管车辆主键编号(Vehicleid)参数值不能为空");
        return hostEscrowVehicleService.updateHostEscrowVehicl(vehicle);
    }
    
    /*
     * 代管车辆删除接口
     */
    @RequestMapping(value="/escrowVehicleDelete", method = RequestMethod.POST, produces = "application/json")
    @ResponseBody
    public BaseResp deleteHostEscrowVehicle(@RequestBody List<String> idList) throws Exception {
        Asserts.notEmpty(idList, "没有提供需要删除的数据");
        return hostEscrowVehicleService.deleteHostEscrowVehicleList(idList);
    }
    
    
    /*
     * 代管车辆详情接口
     */
    @RequestMapping(value="/escrowVehicle/{vehicleid}", method = RequestMethod.GET, produces = "application/json")
    @ResponseBody
    public BaseResp queryHostEscrowVehicle(@PathVariable String vehicleid) throws Exception {
        return hostEscrowVehicleService.queryHostEscrowVehicle(vehicleid);
    }
    
    
    /*
     * 代管车辆导入接口
     */
    @RequestMapping(value="/escrowVehicleExcelImport", method = RequestMethod.POST, produces = "application/json")
    @ResponseBody
    public BaseResp hostEscrowVehicleExcelImport(@RequestBody List<HostEscrowVehicleReq> veList) throws Exception {
        
        Asserts.notEmpty(veList, "没有提供导入数据");
        
        DictionaryUtil.invertTranslate(veList);
        
        return hostEscrowVehicleService.addHostEscrowVehicleExcelList(veList);
    }
    
}


package com.jsecode.esb.service;

import java.util.List;

import com.jsecode.esb.model.protocol.hostEscrowVehicle.HostEscrowVehicleReq;
import com.jsecode.platform.entity.BaseResp;

public interface HostEscrowVehicleService {

    BaseResp addHostEscrowVehicle(HostEscrowVehicleReq req);

    BaseResp queryHostEscrowVehicleList(HostEscrowVehicleReq req);

    BaseResp updateHostEscrowVehicl(HostEscrowVehicleReq vehicle);

    BaseResp deleteHostEscrowVehicleList(List<String> idList);

    BaseResp queryHostEscrowVehicle(String vehicleid);

    BaseResp addHostEscrowVehicleExcelList(List<HostEscrowVehicleReq> veList);

}


package com.jsecode.esb.service.impl;

import java.util.List;

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

import com.jsecode.esb.common.Constant;
import com.jsecode.esb.db.dao.HostEscrowVehicleDao;
import com.jsecode.esb.db.dao.impl.SysConfigDAO;
import com.jsecode.esb.model.po.vm.ClglHostEscrowVehicle;
import com.jsecode.esb.model.protocol.hostEscrowVehicle.HostEscrowVehicleReq;
import com.jsecode.esb.model.protocol.po.login.LoginInfo;
import com.jsecode.esb.service.HostEscrowVehicleService;
import com.jsecode.esb.util.Common;
import com.jsecode.esb.util.DictionaryUtil;
import com.jsecode.esb.util.MemoryTable;
import com.jsecode.esb.util.PageQueryTemplet;
import com.jsecode.platform.entity.BaseResp;
import com.jsecode.platform.entity.DetailResp;
import com.jsecode.platform.entity.EcodeServiceException;
import com.jsecode.platform.util.Asserts;
import com.jsecode.platform.util.DateUtil;
import com.jsecode.platform.util.TypeUtil;
import com.jsecode.platform.util.Util;

@Service("hostEscrowVehicleService")
public class HostEscrowVehicleServiceImpl implements HostEscrowVehicleService {

    
    @Autowired
    private HostEscrowVehicleDao hostEscrowVehicleDao;

    @Override
    public BaseResp addHostEscrowVehicle(HostEscrowVehicleReq req){
        
        Asserts.notEmpty(req.getAppSysId(), "车辆使用单位不能为空");
        Asserts.notEmpty(req.getAppDeptId(), "车辆使用单位不能为空");
        Asserts.notEmpty(req.getHostno(), "车辆号码不能为空");
        
        if(haveSameHostId(req)){
            throw new EcodeServiceException(Constant.DATA_DUPLICUTE, "车辆编号["+req.getHostid()+"]不能重复");
        }
        
        if(haveSameHostno(req)){
            throw new EcodeServiceException(Constant.DATA_DUPLICUTE, "车辆号码["+req.getHostno()+"]不能重复");
        }
        
        if(haveSameXszh(req)){
            throw new EcodeServiceException(Constant.DATA_DUPLICUTE, "车辆行驶登记证["+req.getXszh()+"]不能重复");
        }
        
        if(haveSameEngineId(req)){
            throw new EcodeServiceException(Constant.DATA_DUPLICUTE, "车辆发动机号["+req.getEngineId()+"]不能重复");
        }
        
        if(haveSameHostVin(req)){
            throw new EcodeServiceException(Constant.DATA_DUPLICUTE, "车辆车架号["+req.getHostVin()+"]不能重复");
        }
        
        try{
            if(!Util.isEmpty(req.getDisplacement())){
                TypeUtil.toTargetTypeValue(req.getDisplacement(), Float.class);
            }
        } catch(Exception e) {
            throw new EcodeServiceException(Constant.DATA_DUPLICUTE, "排量必须是数字");
        }
        
        
        //获取登录用户相关信息
        MemoryTable memoryTable = MemoryTable.getInstance();
        LoginInfo loginInfo = Common.getLoginInfo(); 
        int createUserId = loginInfo.getAppUserInfo().getIntAppUserId();
        String createUserName = loginInfo.getAppUserInfo().getUserName();
        int createOrgId = loginInfo.getUserSysDept().getAppSysId();
        int createDeptId = loginInfo.getUserSysDept().getAppDeptId();
        String createOrgDeptName = memoryTable.getOrgDeptFullName(createOrgId, createDeptId);
        
        
        ClglHostEscrowVehicle vehicel = new ClglHostEscrowVehicle();
        vehicel.setHostid(req.getHostid());
        vehicel.setHostno(req.getHostno());
        vehicel.setAppSysId(req.getAppSysId());
        vehicel.setAppDeptId(req.getAppDeptId());
        vehicel.setXszh(req.getXszh());
        vehicel.setHostVehType(req.getHostVehType());
        vehicel.setHostBrand(req.getHostBrand());
        vehicel.setDisplacement(req.getDisplacement());
        vehicel.setVehiclearea(req.getVehiclearea());
        vehicel.setVehicleproperty(req.getVehicleproperty());
        vehicel.setEngineId(req.getEngineId());
        vehicel.setHostVin(req.getHostVin());
        vehicel.setYearlyinspectiontime(req.getYearlyinspectiontime());
        vehicel.setRemark(req.getRemark());
        
        vehicel.setCreateUserId(createUserId);
        vehicel.setCreateUserName(createUserName);
        vehicel.setCreateOrgId(createOrgId);
        vehicel.setCreateDeptId(createDeptId);
        vehicel.setCreateOrgDeptName(createOrgDeptName);
        vehicel.setCreateTime(DateUtil.parseStrDateTime(SysConfigDAO.getSysConfigDAO().getOracleSysDate(true)));
        
        hostEscrowVehicleDao.addHostEscrowVehicle(vehicel);
        return BaseResp.success();
    }
    
    private boolean haveSameHostId(HostEscrowVehicleReq veh){
        List<ClglHostEscrowVehicle> vehicelList = hostEscrowVehicleDao.findHostEscrowVehicleByHostId(veh.getHostid());
        return Util.isNotEmpty(vehicelList);
    }
    
    private boolean haveSameHostno(HostEscrowVehicleReq veh){
        List<ClglHostEscrowVehicle> vehicelList = hostEscrowVehicleDao.findHostEscrowVehicleByHostno(veh.getHostno());
        return Util.isNotEmpty(vehicelList);
    }
    
    private boolean haveSameXszh(HostEscrowVehicleReq veh){
        List<ClglHostEscrowVehicle> vehicelList = hostEscrowVehicleDao.findHostEscrowVehicleByXszh(veh.getXszh());
        return Util.isNotEmpty(vehicelList);
    }
    
    private boolean haveSameEngineId(HostEscrowVehicleReq veh){
        List<ClglHostEscrowVehicle> vehicelList = hostEscrowVehicleDao.findHostEscrowVehicleByEngineId(veh.getEngineId());
        return Util.isNotEmpty(vehicelList);
    }
    
    private boolean haveSameHostVin(HostEscrowVehicleReq veh){
        List<ClglHostEscrowVehicle> vehicelList = hostEscrowVehicleDao.findHostEscrowVehicleByHostVin(veh.getHostVin());
        return Util.isNotEmpty(vehicelList);
    }

    @Override
    public BaseResp queryHostEscrowVehicleList(final HostEscrowVehicleReq req){
        
        return new PageQueryTemplet() {

            @Override
            protected List<?> list() throws Exception{
                
                List<ClglHostEscrowVehicle> list = hostEscrowVehicleDao.queryHostEscrowVehicleList(req);
                
                DictionaryUtil.translate(list);
                
                return list;
            }

            @Override
            protected long totalNum() throws Exception{
                return hostEscrowVehicleDao.countHostEscrowVehicleListWhereSql(req);
            }
            
        }.query(req);
        
    }

    @Override
    public BaseResp updateHostEscrowVehicl(HostEscrowVehicleReq vehicle){
        
        Asserts.notEmpty(vehicle.getAppSysId(), "车辆使用单位不能为空");
        Asserts.notEmpty(vehicle.getAppDeptId(), "车辆使用单位不能为空");
        Asserts.notEmpty(vehicle.getHostno(), "车辆号码不能为空");
        
        ClglHostEscrowVehicle oldVehicle = hostEscrowVehicleDao.findHostEscrowVehicleById(vehicle.getVehicleid());
        Asserts.notEmpty(oldVehicle, "修改失败:查不到车辆维修记录");
        
        if(Util.isNotEmpty(vehicle.getHostid()) && !vehicle.getHostid().equals(oldVehicle.getHostid()) && haveSameHostId(vehicle)){
            throw new EcodeServiceException(Constant.DATA_DUPLICUTE, "["+vehicle.getHostid()+"]车辆编号不能重复");
        }
        
        if(!vehicle.getHostno().equals(oldVehicle.getHostno()) && haveSameHostno(vehicle)){
            throw new EcodeServiceException(Constant.DATA_DUPLICUTE, "车辆号码["+vehicle.getHostno()+"]不能重复");
        }
        
        if(Util.isNotEmpty(vehicle.getXszh()) &&!vehicle.getXszh().equals(oldVehicle.getXszh()) && haveSameXszh(vehicle)){
            throw new EcodeServiceException(Constant.DATA_DUPLICUTE, "车辆行驶登记证["+vehicle.getXszh()+"]不能重复");
        }
        
        if(Util.isNotEmpty(vehicle.getEngineId()) &&!vehicle.getEngineId().equals(oldVehicle.getEngineId()) &&haveSameEngineId(vehicle)){
            throw new EcodeServiceException(Constant.DATA_DUPLICUTE, "车辆发动机号["+vehicle.getEngineId()+"]不能重复");
        }
        
        if(Util.isNotEmpty(vehicle.getHostVin()) &&!vehicle.getHostVin().equals(oldVehicle.getHostVin()) && haveSameHostVin(vehicle)){
            throw new EcodeServiceException(Constant.DATA_DUPLICUTE, "车辆车架号["+vehicle.getHostVin()+"]不能重复");
        }
        
        oldVehicle.setHostid(vehicle.getHostid());
        oldVehicle.setHostno(vehicle.getHostno());
        oldVehicle.setAppSysId(vehicle.getAppSysId());
        oldVehicle.setAppDeptId(vehicle.getAppDeptId());
        oldVehicle.setXszh(vehicle.getXszh());
        oldVehicle.setHostVehType(vehicle.getHostVehType());
        oldVehicle.setHostBrand(vehicle.getHostBrand());
        oldVehicle.setDisplacement(vehicle.getDisplacement());
        oldVehicle.setVehiclearea(vehicle.getVehiclearea());
        oldVehicle.setVehicleproperty(vehicle.getVehicleproperty());
        oldVehicle.setEngineId(vehicle.getEngineId());
        oldVehicle.setHostVin(vehicle.getHostVin());
        oldVehicle.setYearlyinspectiontime(vehicle.getYearlyinspectiontime());
        oldVehicle.setRemark(vehicle.getRemark());
        
        hostEscrowVehicleDao.updateHostEscrowVehicle(oldVehicle);
        return BaseResp.success();
    }

    @Override
    public BaseResp deleteHostEscrowVehicleList(List<String> idList){
        hostEscrowVehicleDao.deleteHostEscrowVehicleList(idList);
        return BaseResp.success();
    }

    @Override
    public BaseResp queryHostEscrowVehicle(String vehicleid){
        ClglHostEscrowVehicle ve = hostEscrowVehicleDao.findHostEscrowVehicleById(vehicleid);
        if(!Util.isEmpty(ve)){
            MemoryTable mem = MemoryTable.getInstance();
            String sysName = mem.getSysDeptMap(ve.getAppSysId(), 0).getName();
            String deptName = mem.getSysDeptMap(ve.getAppSysId(), ve.getAppDeptId()).getName();
            ve.setAppSysName(sysName);
            ve.setAppDeptName(deptName);
        }
        return DetailResp.build(ve);
    }

    @Override
    public BaseResp addHostEscrowVehicleExcelList(List<HostEscrowVehicleReq> veList){

        int reocrdRow = 0;
        try {
            for(HostEscrowVehicleReq req : veList){
                reocrdRow++;
                this.addHostEscrowVehicle(req);
            }
        }catch(Exception e) {
            throw new RuntimeException("第["+reocrdRow+"]条记录,"+e.getMessage());
        }
        return BaseResp.success();
    }
    
}


package com.jsecode.esb.db.dao;

import java.util.List;

import com.jsecode.esb.model.po.vm.ClglHostEscrowVehicle;
import com.jsecode.esb.model.protocol.hostEscrowVehicle.HostEscrowVehicleReq;
import com.jsecode.platform.spring3.hibernate3.dao.IBaseDao;

public interface HostEscrowVehicleDao extends IBaseDao<ClglHostEscrowVehicle, String> {

    List<ClglHostEscrowVehicle> findHostEscrowVehicleByHostId(String hostid);

    List<ClglHostEscrowVehicle> findHostEscrowVehicleByHostno(String hostno);

    List<ClglHostEscrowVehicle> findHostEscrowVehicleByXszh(String xszh);

    List<ClglHostEscrowVehicle> findHostEscrowVehicleByEngineId(String engineId);

    List<ClglHostEscrowVehicle> findHostEscrowVehicleByHostVin(String hostVin);

    void addHostEscrowVehicle(ClglHostEscrowVehicle vehicel);

    List<ClglHostEscrowVehicle> queryHostEscrowVehicleList(HostEscrowVehicleReq req) throws Exception;
    
    long countHostEscrowVehicleListWhereSql(HostEscrowVehicleReq req) throws Exception;

    ClglHostEscrowVehicle findHostEscrowVehicleById(String vehicleid);

    void updateHostEscrowVehicle(ClglHostEscrowVehicle oldVehicle);

    void deleteHostEscrowVehicleList(List<String> idList);

}


package com.jsecode.esb.db.dao.impl;

import java.util.List;

import org.springframework.stereotype.Repository;

import com.jsecode.esb.db.OrgDeptSearchFilter;
import com.jsecode.esb.db.dao.HostEscrowVehicleDao;
import com.jsecode.esb.model.po.vm.ClglHostEscrowVehicle;
import com.jsecode.esb.model.protocol.hostEscrowVehicle.HostEscrowVehicleReq;
import com.jsecode.platform.spring3.hibernate3.HibernateParams;
import com.jsecode.platform.spring3.hibernate3.dao.BaseHibernateDao;
import com.jsecode.platform.util.Util;

@Repository("hostEscrowVehicleDao")
public class HostEscrowVehicleDaoImpl extends BaseHibernateDao<ClglHostEscrowVehicle, String> implements HostEscrowVehicleDao {

    @Override
    public List<ClglHostEscrowVehicle> findHostEscrowVehicleByHostId(String hostid){
        return findByProperty("hostid", hostid);
    }

    @Override
    public List<ClglHostEscrowVehicle> findHostEscrowVehicleByHostno(String hostno){
        return findByProperty("hostno", hostno);
    }

    @Override
    public List<ClglHostEscrowVehicle> findHostEscrowVehicleByXszh(String xszh){
        return findByProperty("xszh", xszh);
    }

    @Override
    public List<ClglHostEscrowVehicle> findHostEscrowVehicleByEngineId(String engineId){
        return findByProperty("engineId", engineId);
    }

    @Override
    public List<ClglHostEscrowVehicle> findHostEscrowVehicleByHostVin(String hostVin){
        return findByProperty("hostVin", hostVin);
    }

    @Override
    public void addHostEscrowVehicle(ClglHostEscrowVehicle vehicel){
        saveOrUpdate(vehicel);
    }
    
    @Override
    public void updateHostEscrowVehicle(ClglHostEscrowVehicle oldVehicle){
        saveOrUpdate(oldVehicle);
    }

    @Override
    public List<ClglHostEscrowVehicle> queryHostEscrowVehicleList(HostEscrowVehicleReq req) throws Exception{
        
        StringBuilder hql = new StringBuilder();
        HibernateParams params = new HibernateParams();
        hql.append("select * ");
        hql.append("from CLGL_HOST_ESCROW_VEHICLE a ");
        hql.append(getQueryHostEscrowVehicleListWhereSql(req, params));
        hql.append("order by a.CREATE_TIME desc ");

        return findBySql(hql.toString(), params.getParamObj(), req.getStartRow().intValue(), req.getMaxSize().intValue(), ClglHostEscrowVehicle.class);
    }

    @Override
    public long countHostEscrowVehicleListWhereSql(HostEscrowVehicleReq req) throws Exception{
        StringBuilder hql = new StringBuilder();
        HibernateParams params = new HibernateParams();
        hql.append("select count(1) ");
        hql.append("from CLGL_HOST_ESCROW_VEHICLE a ");
        hql.append(getQueryHostEscrowVehicleListWhereSql(req, params));
        return findCountBySql(hql.toString(), params.getParamObj());
    }

    private Object getQueryHostEscrowVehicleListWhereSql(HostEscrowVehicleReq req, HibernateParams params) throws Exception{
        
        StringBuilder sqlBuilder = new StringBuilder();
        
        //使用单位
        OrgDeptSearchFilter helper = createOrgDeptSearchFilter();
        sqlBuilder.append(" and (a.APPSYSID, a.APPDEPTID) in (").append(helper.getMyViewSubDeptSql(req.getAppSysId(), req.getAppDeptId(), params)).append(") ");
        
        //车牌号码
        if (!Util.isEmpty(req.getHostno())) {
            sqlBuilder.append(" and a.HOSTNO like ? ");
            params.addParamObj("%"+req.getHostno().trim()+"%");            
        }
        
        //编号
        if (!Util.isEmpty(req.getHostid())) {
            sqlBuilder.append(" and a.HOSTID like ? ");
            params.addParamObj("%"+req.getHostid().trim()+"%");            
        }
        
        //车辆性质
        if (!Util.isEmpty(req.getVehicleproperty())) {
            sqlBuilder.append(" and a.VEHICLEPROPERTY = ? ");
            params.addParamObj(req.getVehicleproperty().trim());            
        }
        
        /*//使用单位
        if (Util.isIntGT(req.getAppSysId(), 0) || Util.isIntGT(req.getAppDeptId(), 0)) {
            sqlBuilder.append(" and (a.APPSYSID = ? and a.APPDEPTID = ?) ");
            params.addParamObj(req.getAppSysId());
            params.addParamObj(req.getAppDeptId());            
        }*/
        
        return sqlBuilder.toString().replaceFirst("and", "where");
    }

    protected OrgDeptSearchFilter createOrgDeptSearchFilter() {
        return new OrgDeptSearchFilter();
    }
    
    @Override
    public ClglHostEscrowVehicle findHostEscrowVehicleById(String vehicleid){
        return findById(ClglHostEscrowVehicle.class, vehicleid);
    }

    @Override
    public void deleteHostEscrowVehicleList(List<String> idList){
        for(String id : idList){
            StringBuilder hql = new StringBuilder();
            hql.append("delete from CLGL_HOST_ESCROW_VEHICLE ");
            hql.append("where VEHICLEID = ? ");
            executeBySql(hql.toString(),new String[]{id} );
        }
    }



}




Oracle-如何修复undo坏快 undo出现坏快,导致数据库宕机,无法启动 阅读详情

相关推荐

winget安装提示:执行此命令时发生意外错误: InternetOpenUrl() failed. 0x80072efd

当我们使用Winget包管理器安装应用,提示错误:执行此命令时发生意外错误: InternetOpenUrl() failed. 0x80072efd 该怎么处理呢?请听我娓娓道来。

Linux I Tell U 8142

GAT 1400平台 Java服务端 基础接口

1400主要功能是将摄像头拍的图片主动上报到服务端,海康宇视都能在抓拍图片后自动上报。gat1400: gat1400 java 服务端 (gitee.com)大华相机需要有真实的车辆行走视频才能触发拍照,车牌的图片不能触发拍照。以下是接口图片 具体代码在。下边是注册 保活接口。

binyan_x的博客 2322

3D视觉革命丨多相机协同拼接技术如何重塑工业检测边界

本文深入探讨了多相机协同拼接技术如何突破单台3D相机的物理局限,实现工业检测从“点面”到“立体”的无死角覆盖。通过拆解系统标定、同步融合等核心技术,并结合锂电池、长轴零件等实战案例,揭示了该技术如何以虚拟“超级视觉传感器”重塑检测边界,提升精度与效率。

weixin_29056865的博客 389

Assert.assertNotNull()判断是否是空 断言

Assert.assertNotNull()判断是否是空  断言

大灰狼的博客 3万+

描述符链表(Descriptor Chain)是什么?

描述符链表是硬件加速数据传输的核心数据结构,通过链式描述符(包含地址、长度、控制标志等)实现DMA自动批量处理,显著降低CPU负载。其工作原理为:CPU初始化链表后,硬件按序处理每个描述符,完成自动跳转与中断通知。在网卡收包、NVMe存储等场景中应用广泛,优势包括批处理、低延迟和灵活调度。需注意内存对齐、缓存一致性等实现细节,优化手段包括预分配描述符池、环形缓冲区等。该技术是网络/存储领域提升吞吐量的关键方案。

guigenyi的专栏 780

IP-guard发布新版本4.87.2241.0

IP-guard发布了新版本4.87.2241.0,用户可通过提供的下载地址获取完整安装包和升级包。下载后,用户需联系厂家申请测试序列号以进行安装和使用。IP-guard是一款专注于企业文件加密、文档加密系统、防泄密软件、数据安全的软件。

IP-Guard专栏 1535

客运综合管理系统项目解析-领导查询(模块)-退票查询

2.4-2 退票查询          退票查询是基于售票管理-退票的一个查询退票记录功能,根据退票情况可以快速找到准确的退票记录和当天的退票情况,也能看到更多的退票原因便于解决过多的退票情况!功能如下图2.4-2 从界面上可以看到我们这里用到工具箱的控件有:        控件名称 说明     容器控件(框) GroupBox

广信_冯伟杰的博客 1298

RISC-V CPU设计(三)---多周期CPU的设计与实现

基本情况 本多周期CPU支持RV32I指令集(fence,ecall,ebreak除外),已通过部分指令的测试,如代码有bug,欢迎指出。 模块划分 代码将CPU划分为以下几个模块: 1.控制单元:ControlUnit 用于产生控制信号,是CPU的大脑,指挥中枢。 2.分支决策单元:BranchUnit 用于决定B型指令是否发生跳转 3.立即数单元:ImmUnit 用于从指令中解析出立即数. 4.寄存器堆:RegisterFile RISC-V的32个寄存器,其中x0寄存器恒为0,不可更改。 5.指令存储

qq_40268672的博客 5543

代码:GAT代管车辆(1)

代管车辆表: ClglHostEscrowVehicle package com.jsecode.esb.model.po.vm; import java.util.Date; import com.fasterxml.jackson.annotation.JsonFormat; import com.jsecode.esb.common.DicTypeConst;

兴趣是最好的老师 690

21、深入了解SELinux安全系统与/proc文件系统

本文深入探讨了SELinux安全系统与/proc文件系统的原理及实际应用。详细介绍了SELinux的安全上下文、域转换、运行模式、角色管理以及策略查看工具seinfo的使用;同时解析了/proc文件系统的结构与功能,涵盖进程信息查看、系统资源监控及性能优化方法。结合SELinux与/proc的协同应用,提供了系统问题排查流程与安全管理最佳实践,帮助用户提升Linux系统的安全性与稳定性。

ik678901234的博客 63

【嵌入式 – GD32开发实战指南(ARM版本)】第1部分 基础篇 - 第1章 开发环境搭建

开发环境: MDK:Keil 5.30 MCU:GD32F207IK 1.1 GD32F207I-EVAL开发板简介 笔者使用的开发板是兆易创新设计的GD32F207I-EVAL开发板。 GD32F207I-EVAL开发板使用 GD32F207IK作为主控制器,主频120MHz、集成3MB Flash、256KB SRAM、通用定时器*10、Adv. TM*2、Basic TM*2、系统时钟*1、看门狗*2、RTC*1、USART*4、UART*4、I2C*3、SPI*3、I2S*1、SDIO*1、CAN

不问归期的博客 9995

保留两位小数:数据库字段类型NUMBER,Java字段类型Double类型

1.数据库字段类型 查出的数据小数点后带两位小数 2.后台查出的json却没有两位小数 [{ recordId : 20170320142740038015948, appSysId : 23551, appDeptId : 3, orgDeptName : null, carHostNO : 1019, secureNo : 111, sec

兴趣是最好的老师 4453

PyTorch生成式人工智能(1)——神经网络与模型训练过程详解

在本节中,我们介绍了传统机器学习与人工神经网络间的差异,并了解了如何在实现前向传播之前连接网络的各个层,以计算与网络当前权重对应的损失值;实现了反向传播以优化权重达到最小化损失值的目标。并实现了网络的所有关键组成——前向传播、激活函数、损失函数、链式法则和梯度下降,从零开始构建并训练了一个简单的神经网络。

盼小辉丶的博客 1万+

sum over partition by函数的用法-但是查出来的数据格式不好给前台用,废弃

要求:按车牌号HOST_NO分组,合计CAR_PAY金额,最后合计所有金额,还要过滤出本月的时间 参考: http://blog.youkuaiyun.com/wawmg/article/details/40840093

兴趣是最好的老师 2492

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

GAT项目新需求:加油管理修改

新需求:加油管理列表要带付费方式,如果是加油卡,则显示卡号,类似江苏电力这样的页面 开发: 1.先增加数据库CAR_OIL表字段和注释 alter table CAR_OIL ADD  OILCARD_NO VARCHAR2(100); alter table CAR_OIL ADD  PAYTYPE NUMBER(2);  comment on column

兴趣是最好的老师 1415

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

解决GAT项目Bug: 用车审批中审批人登录系统后,看不到申请人提交的单子

描述:警保部下面的部门的人申请的单子,警保部的负责审批的人看不到 解决: 1.点击页面找到请求url 2.运用阿楠给我的工具,可以获取后台的url 双击testFrom0(),得到 3.找到代码 修改代码: 修改好代码: 断点打印正确的sql: 断点打印的错误的sql: select create_

兴趣是最好的老师 1311

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

GAT项目新需求:保险管理修改

1.需求: 2.原表 3.现表 4.SQL语句: --删除字段 ALTER TABLE CAR_SECURE DROP COLUMN SECURE_ACC_NO ALTER TABLE CAR_SECURE DROP COLUMN SECURE_ACC_PAY ALTER TABLE CAR_SECURE DROP COLUMN SECURE_NUM

兴趣是最好的老师 1150

WF公务车新需求:申请单和派车单编号修改

1.需求:申请单改成YCSQD_日期_1 2 3累加,跨年后重新从1开始累加,派车单改成申请单编号_CCD 2.找到相关代码 原申请单编号生成代码:YCSQD_20170410_1、YCSQD_20170410_2、YCSQD_20170411_1、YCSQD_20170411_2 @Override public synchronized String get

兴趣是最好的老师 1072

GAT-解决用车审批中,如果调度车辆是通过Excel导入的车辆,会有错误提示Bug

proxool.xml config.properties webgps.db.default.schema=STCS -----------------------------------------------------------------------------------------------------------------------------------

兴趣是最好的老师 1049

解决GAT项目Bug:导入Excel的时候没有对日期格式进行验证

问题描述:导入Excel的时候没有对日期格式进行验证 修改代码:增加对日期的验证 使用的代码: import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; pub

兴趣是最好的老师 1037

GAT保险模块的修改

1.示意图 . 2.数据库的修改 drop table CAR_SECURE; -- Create table create table CAR_SECURE ( record_id VARCHAR2(32) not null, host_no VARCHAR2(32), secure_no

兴趣是最好的老师 975

惠安惠达新需求:增加起始里程和结束里程

代码:主要要传hosti和查询的时间范围

兴趣是最好的老师 964

GWC和GAT项目搭建过程

1.说明: 公安厅项目有两个模块是依赖电力项目或者公务车项目的 公务车: 公安厅: 所以,如果单独部署公安厅项目,需要去电力或者公务车中下载上面两个包 -----------------------------------------------------------------------------------------------------------

兴趣是最好的老师 923

解决GAT项目Bug:轨迹分析查询不到数据

问题描述:左边没数据,地图上也没轨迹 控制台信息:没有该方法 搜索该类: 发现类存在于两个项目中,GAT已经引用了公司通用的jar包,而GAT代码中依然写了重复的代码,造成了冲突 解决办法:把这两个包下的代码删了,提交即可

兴趣是最好的老师 923

代码:用车申请-列表查询

/*我的用车申请列表查询接口*/ @RequestMapping(value = "/apply/myList", method = RequestMethod.POST, produces = "application/json") @ResponseBody public BaseResp applyList(@RequestBody VehUseApplyInfoListReq biz

兴趣是最好的老师 898

Jsecode maven仓库地址

公司maven仓库地址:http://artifactory.jsecode.com/artifactory/libs-release/

兴趣是最好的老师 860
上一篇: 代码:GAT代管车辆(1)
下一篇: 了解系统流程相关
ZHOU_VIP
博客等级 码龄11年 1万+粉丝 1779原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ZHOU_VIP

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

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

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

打赏作者

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

抵扣说明:

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

余额充值