如何在真实项目中实现一个完整的功能的流程？

当你接到一个任务需求的时候，需要先考虑到的问题如下：

一、这一步先不考虑代码的问题，先把前提条件给完成

1. 你需要先考虑一下前台给你传过来的都是什么参数，如果是AJAX传过来的话，你需要考虑一下用什么对应的实体去接受前台传过来的参数（这里如果前台传过来的参数名和你后台定义的接受实体的字段名对应不上就会报错400）
2. 然后前台传参解决之后还需要考虑你接受到的参数需要保存到那个实体对象中（这步方便你对数据进行一些转换或者判断之类的逻辑处理），这个基本是和你最终返回给前台的字段名要进行对应，不然也会报错
3. 你还需要定义一个response的实体类，里面有错误信息和Code状态码，当然还有你需要回传给前台的数据，这一步其实是就是把你要回传给前台的数据放到一个实体中，最后一期返回给前台去

二、这一步是你需要对前台拿到的参数进行一个处理的过程也就是（参数绑定和入参效验）

1. 当然如果你的传过来的参数较少或者是参数不确定（需要根据前台的具体业务进行确定的话）那就有多种选择，这里不再一一去说了例如可以直接用绑定具体参数，用@RequestParam，或者@RequestBody这个可以直接用一个form表单来去接收前台传过来的数据，也可以直接用一个Map集合来去接收数据 这是从前台进行参数绑定的五种常用方式传送门
2. 然后就是你的业务逻辑的主要的处理，这些就不多说了，大家也都差不多知道，但是还有一种就是你要把controller层的数据保存到一个实体对象中传到Service层中，这个地方可以自由发挥，也可以自己定义DTO（数据传输模型）POJO啊VO啊什么的思想都是一样只不过是包装了一层皮而已
3. 数据传到了Service层之后就需要对controller层拿到的数据进行处理啊，然后就是判空效验啥的，如果出错了怎么办，为了让项目架构更加稳定，这里其实可以专门定义ServiceException异常处理机制或者枚举（这里不多说了，大概提一下大家具体看自己业务）
4. 然后就是去调用DAO去查询你想要的数据了，这里有一种情况，就是你SQL不能完全做到的你可以放在ServiceImpl层去进行二次筛选拿到的数据（这里只是提一下，一般的项目不会用到）
5. 最后就是写mapping中映射的SQL的语句了，这里没啥想说的（其实这里的知识点特别特别多还都是致命的，所以只能看大家手写SQL的能力了）

三、最后一步就是测试了，其实这一步在真是开发项目中也是最难受的，也没啥好说的就是一顿DEBUG,怼就完了，这里推荐一下测试工具，可以使用Chrome的postman工具或者是fireFox中的自带测试工具RESTClient工具，两个我都用推荐后者吧看着舒服些

---

四、然后上面都完事的话，还需要和前台对一下接口，也就是最后的前后联调

接受前台数据的实体

package com.ia.lhc.form;

public class AccompanyCarForm {

    // 开始日期（入力）
    private String startdate;

    //结束日期
    private String enddate;

    // 所要分析卡口列表（入力）
    private String[] devicesId;

    // 卡口选择（入力）
    private String devices;

    // 车牌号码（入力）
    private String platenumber;

    // 车牌颜色（入力）
    private String colors;

    // 同行阈值（入力）
    private String standardvalue;

    // 排除车辆类型设定（入力）
    private String[] removecartype;






    public String getStartdate() {
        return startdate;
    }

    public void setStartdate(String startdate) {
        this.startdate = startdate;
    }

    public String getEnddate() {
        return enddate;
    }

    public void setEnddate(String enddate) {
        this.enddate = enddate;
    }

    public String[] getDevicesId() {
        return devicesId;
    }

    public void setDevicesId(String[] devicesId) {
        this.devicesId = devicesId;
    }

    public String getDevices() {
        return devices;
    }

    public void setDevices(String devices) {
        this.devices = devices;
    }

    public String getPlatenumber() {
        return platenumber;
    }

    public void setPlatenumber(String platenumber) {
        this.platenumber = platenumber;
    }

    public String getStandardvalue() {
        return standardvalue;
    }

    public void setStandardvalue(String standardvalue) {
        this.standardvalue = standardvalue;
    }

    public String[] getRemovecartype() {
        return removecartype;
    }

    public void setRemovecartype(String[] removecartype) {
        this.removecartype = removecartype;
    }

    public String getColors() {
        return colors;
    }

    public void setColors(String colors) {
        this.colors = colors;
    }
}

存储数据的实体

package com.ia.lhc.model;

import java.util.List;

public class AccompanyCarEntity {



//  private String colors;
//  private String followplateColor;
//  private String platenumber;
//  private String followplatenumber;

    //第二次详情需要的参数
    private String dateTime;
    private String peerDateTime;
    // 是否盗抢车辆
    private String robberyCarFlag;

    // 违章信息
    private String peccancyInfo;

    // 序号
    private int id;

    // 行政区域ID
    private int areaId;

    // 日期
    private String date;

    // 这个是已经知道的车牌
    private String platenumber1;

    // 号牌颜色1
    private String platecolor1;

    // 这个是跟随的车牌
    private String platenumber2;

    // 号牌颜色2
    private String platecolor2;

    // 同行卡口列表
    private String deviceIDs;

    // 同行时长（单位：秒）
    private String accompanyTime;

    // 两辆车伴随概率
    private String rank;

    // 同行路口数
    private String accompanyCount;

    // 车辆类型(详细)
    private String carType;

    // 车辆型号(详细)
    private String carModel;

    // 归属地(详细)
    private String ownerPlace;

    // 车主(详细)
    private String ownerCarName;

    // 身份证号码(详细)
    private String idCardNo;

    // 详细地址(详细)
    private String address;

    // 号牌种类(详细)
    private String plateType;

    // 车身颜色(详细)
    private String carColor;

    // 联系方式(详细)
    private String phoneNumber;

    // 车辆轨迹List
    private List<BasicTrailEntity> trailList;

    // 从车车辆轨迹List
    private List<BasicTrailEntity> followTrailList;



    public String getDateTime() {
        return dateTime;
    }

    public void setDateTime(String dateTime) {
        this.dateTime = dateTime;
    }

    public String getPeerDateTime() {
        return peerDateTime;
    }

    public void setPeerDateTime(String peerDateTime) {
        this.peerDateTime = peerDateTime;
    }

    public List<BasicTrailEntity> getFollowTrailList() {
        return followTrailList;
    }

    public void setFollowTrailList(List<BasicTrailEntity> followTrailList) {
        this.followTrailList = followTrailList;
    }

    public String getRobberyCarFlag() {
        return robberyCarFlag;
    }

    public void setRobberyCarFlag(String robberyCarFlag) {
        this.robberyCarFlag = robberyCarFlag;
    }

    public String getPeccancyInfo() {
        return peccancyInfo;
    }

    public void setPeccancyInfo(String peccancyInfo) {
        this.peccancyInfo = peccancyInfo;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAreaId() {
        return areaId;
    }

    public void setAreaId(int areaId) {
        this.areaId = areaId;
    }

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }

    public String getPlatenumber1() {
        return platenumber1;
    }

    public void setPlatenumber1(String platenumber1) {
        this.platenumber1 = platenumber1;
    }

    public String getPlatecolor1() {
        return platecolor1;
    }

    public void setPlatecolor1(String platecolor1) {
        this.platecolor1 = platecolor1;
    }

    public String getPlatenumber2() {
        return platenumber2;
    }

    public void setPlatenumber2(String platenumber2) {
        this.platenumber2 = platenumber2;
    }

    public String getPlatecolor2() {
        return platecolor2;
    }

    public void setPlatecolor2(String platecolor2) {
        this.platecolor2 = platecolor2;
    }

    public String getDeviceIDs() {
        return deviceIDs;
    }

    public void setDeviceIDs(String deviceIDs) {
        this.deviceIDs = deviceIDs;
    }

    public String getAccompanyTime() {
        return accompanyTime;
    }

    public void setAccompanyTime(String accompanyTime) {
        this.accompanyTime = accompanyTime;
    }

    public String getRank() {
        return rank;
    }

    public void setRank(String rank) {
        this.rank = rank;
    }

    public String getAccompanyCount() {
        return accompanyCount;
    }

    public void setAccompanyCount(String accompanyCount) {
        this.accompanyCount = accompanyCount;
    }

    public String getCarType() {
        return carType;
    }

    public void setCarType(String carType) {
        this.carType = carType;
    }

    public String getCarModel() {
        return carModel;
    }

    public void setCarModel(String carModel) {
        this.carModel = carModel;
    }

    public String getOwnerPlace() {
        return ownerPlace;
    }

    public void setOwnerPlace(String ownerPlace) {
        this.ownerPlace = ownerPlace;
    }

    public String getOwnerCarName() {
        return ownerCarName;
    }

    public void setOwnerCarName(String ownerCarName) {
        this.ownerCarName = ownerCarName;
    }

    public String getIdCardNo() {
        return idCardNo;
    }

    public void setIdCardNo(String idCardNo) {
        this.idCardNo = idCardNo;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getPlateType() {
        return plateType;
    }

    public void setPlateType(String plateType) {
        this.plateType = plateType;
    }

    public String getCarColor() {
        return carColor;
    }

    public void setCarColor(String carColor) {
        this.carColor = carColor;
    }

    public String getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    public List<BasicTrailEntity> getTrailList() {
        return trailList;
    }

    public void setTrailList(List<BasicTrailEntity> trailList) {
        this.trailList = trailList;
    }
}

controller的返回类型

package com.ia.lhc.response;

import java.util.List;
import com.ia.lhc.model.AccompanyCarEntity;
import com.ia.lhc.model.BasicCar;
import com.ia.lhc.model.MultiSpaceTimeEntity;

/**
 * @author wang.w.w
 *  一牌多车的
 */
public class AccompanyCarResponse {

    // 消息
    private String msg;

    // 识别标识
    private int code;

    // 结果集列表
    private List<AccompanyCarEntity> AccompanyCarEntityList;



    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public List<AccompanyCarEntity> getAccompanyCarEntityList() {
        return AccompanyCarEntityList;
    }

    public void setAccompanyCarEntityList(List<AccompanyCarEntity> accompanyCarEntityList) {
        AccompanyCarEntityList = accompanyCarEntityList;
    }




}

controller层 （这里有用到请求大数据接口的内容）

package com.ia.lhc.controller;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
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.ia.lhc.config.ConstantUtils;
import com.ia.lhc.config.DataSourceTypeManager;
import com.ia.lhc.config.DataSources;
import com.ia.lhc.form.AccompanyCarForm;
import com.ia.lhc.httpclient.HttpUtils;
import com.ia.lhc.model.AccompanyCarDetailEntity;
import com.ia.lhc.model.AccompanyCarEntity;
import com.ia.lhc.model.BasicCar;
import com.ia.lhc.model.BasicTrailEntity;
import com.ia.lhc.model.DevicesAreaEntity;
import com.ia.lhc.model.DevicesEntity;

import com.ia.lhc.response.AccompanyCarDetailResponse;
import com.ia.lhc.response.AccompanyCarResponse;
import com.ia.lhc.service.AccompanyCarService;
import com.ia.lhc.service.CarInfoService;
import com.ia.lhc.service.DevicesService;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

/**
 * @author wang.w.w
 *  
 */
@Controller
public class AccompanyCarController {

    @Autowired
    private DevicesService devicesService;

    @Autowired
    private CarInfoService carInfoService;

    @Autowired
    private AccompanyCarService accompanyCarService;

    /**
     * LOG信息
     */
    private Logger logger = Logger.getLogger(this.getClass().getName()); 

    /**
     * 同行车分析查询
     * @param accompanyCarForm
     * @return response
     */
    @RequestMapping(value = "/getPeerCar", method=RequestMethod.POST)
    @ResponseBody
    public AccompanyCarResponse getAccompanyCar(@RequestBody AccompanyCarForm accompanyCarForm){


        // 返回前台类
        AccompanyCarResponse response = new AccompanyCarResponse();

        // 实例化结果集
        List<AccompanyCarEntity> accompanyCarEntityList = new ArrayList<AccompanyCarEntity>();
        //用户传进来的参数      
        String starttime = accompanyCarForm.getStartdate();
        String endtime = accompanyCarForm.getEnddate();
        String platenumber = accompanyCarForm.getPlatenumber();

//      String platenumber = accompanyCarForm.getPlatenumber();
//      String colors = accompanyCarForm.getColors();           //车牌颜色
//      String[] devicesId = accompanyCarForm.getDevicesId();   //得到卡口列表
//      String[] removecartype = accompanyCarForm.getRemovecartype(); //排除的车辆颜色

        //传进来的yyyy-MM-dd转换为yyyyMMdd
        try {
            String transferStartTime = transferFormat1(starttime);
            String transferEndTime = transferFormat1(endtime);  
            accompanyCarForm.setStartdate(transferStartTime);
            accompanyCarForm.setEnddate(transferEndTime);

        } catch (ParseException e) {
            logger.info("时间格式转为字符串格式错误！");
            e.printStackTrace();
        }
        // 查询
        DataSourceTypeManager.set(DataSources.DATASOURCE2);
        accompanyCarEntityList = accompanyCarService.getAccompanyCarList(accompanyCarForm);
        if (accompanyCarEntityList.size() > 0 && accompanyCarEntityList!=null ) {           
            //1，遍历每一个同行车的列表 2.去获取同行车里面的车牌号再去获取车辆的基本信息 3，再去拿到获取该车辆是不是违章和是否是强盗车
            BasicCar carInfo2 = new BasicCar();
            for(AccompanyCarEntity accompanyCarEntity:accompanyCarEntityList){  
                //把用户输入的时间给保存到实体中以便二次使用,因为请求大数据接口只需要截止日期
                accompanyCarEntity.setDateTime(endtime);
                accompanyCarEntity.setPeerDateTime(endtime);
                //同行时间转为时分秒字符串
                String accompanyTime = accompanyCarEntity.getAccompanyTime();
                String accompanyTimeStr = secondChangeMinute(accompanyTime);
                accompanyCarEntity.setAccompanyTime(accompanyTimeStr);
                //这部分是把概率小数转为%形式
                String rank = accompanyCarEntity.getRank();
                double parseDouble = (Double.parseDouble(rank))*100;
                String rankStr =  String.valueOf(parseDouble)+"%";
                accompanyCarEntity.setRank(rankStr);



                //判断哪个是主车哪个是从车
                boolean result = platenumber.equals(accompanyCarEntity.getPlatenumber1());
                if(result){
                    String   platenumber1 = accompanyCarEntity.getPlatenumber1();
                    String  platenumber2 = accompanyCarEntity.getPlatenumber2();
                    accompanyCarEntity.setPlatenumber1(platenumber1);
                    accompanyCarEntity.setPlatenumber2(platenumber2);
                }else{
                    String  platenumber1 = accompanyCarEntity.getPlatenumber2();
                    String  platenumber2 = accompanyCarEntity.getPlatenumber1();
                    accompanyCarEntity.setPlatenumber1(platenumber1);
                    accompanyCarEntity.setPlatenumber2(platenumber2);
                }

                // 查询车辆违法信息
                DataSourceTypeManager.set(DataSources.DATASOURCE1); 
                carInfo2 = carInfoService.getCarInfo(accompanyCarEntity.getPlatenumber2());
                if(carInfo2!=null){
                    //把根据车牌号查询到的是否违章信息和是否强盗车信息保存到实体中
                    accompanyCarEntity.setRobberyCarFlag(carInfo2.getRobberyCarFlag());
                    accompanyCarEntity.setPeccancyInfo(carInfo2.getPeccancyInfo());
                }
                else{
                    accompanyCarEntity.setRobberyCarFlag("");
                    accompanyCarEntity.setPeccancyInfo("");
                }

            }   
            response.setAccompanyCarEntityList(accompanyCarEntityList);
            response.setCode(ConstantUtils.RETURN_RESULT_SUCCESS_CODE_0);
            response.setMsg("同行车查询成功！");

        }else {
            response.setCode(ConstantUtils.RETURN_RESULT_FAIL_CODE_1);
            response.setMsg("未找到同行车信息！");
            response.setAccompanyCarEntityList(new ArrayList<AccompanyCarEntity>());
        }

        return response;
    }

    /**
     * 同行车分析详细信息
     * @param params
     * @return response
     */
    @RequestMapping(value = "/getPeerCarDetaill", method=RequestMethod.POST)
    @ResponseBody
    public AccompanyCarDetailResponse getAccompanyCarDetail(@RequestBody Map<String, String> params){

        // 返回前台类
        AccompanyCarDetailResponse response = new AccompanyCarDetailResponse();


        //同行车详情车辆信息包含了主车和从车以及各个车的轨迹信息集合
        AccompanyCarDetailEntity accompanyCarDetailEntity = new AccompanyCarDetailEntity();

        //主车
        String carId = params.get("platenumber");   //车牌号码
        String datetime = params.get("dateTime");   // 获取截止的时间
        String colors = params.get("colors"); // 获取车牌颜色

        //从车
        String peerCarId= params.get("followplatenumber");  //与上个车的同行车牌号
        String peerdatetime = params.get("peerDateTime");   // 获取截止的时间
        String peercolors = params.get("followplateColor"); // 获取车牌颜色


        //把从前台拿到的数据放到实体中保存
        accompanyCarDetailEntity.setPlatenumber(carId);
        accompanyCarDetailEntity.setFollowplatenumber(peerCarId);
        //保存时间
        accompanyCarDetailEntity.setPlateColor(colors);
        accompanyCarDetailEntity.setFollowplateColor(peercolors);
//保存前台传过来的时间，当做大数据的开始时间
        accompanyCarDetailEntity.setTime(datetime);
        accompanyCarDetailEntity.setFollowTime(peerdatetime);

        // 实例化车辆详细信息
        BasicCar carInfo = new BasicCar();          //同行车
        BasicCar peerCarInfo = new BasicCar();      //与之同行车辆详细信息    
        // 调接口查询车辆基本信息
        DataSourceTypeManager.set(DataSources.DATASOURCE1); 
        //然后查询基本车辆信息
        carInfo = carInfoService.getCarInfo(carId);
        DataSourceTypeManager.set(DataSources.DATASOURCE1); 
        peerCarInfo = carInfoService.getCarInfo(peerCarId);     
         if(carInfo!=null && peerCarInfo!=null){
             accompanyCarDetailEntity.setPlatenumber(carInfo.getIdCardNo());
             accompanyCarDetailEntity.setCarBrand(carInfo.getCarBrand());
             accompanyCarDetailEntity.setRegistAddress(carInfo.getOwnerPlace()); //车辆归属地
             accompanyCarDetailEntity.setCarOwner(carInfo.getOwnerCarName());
             accompanyCarDetailEntity.setOwnerCardId(carInfo.getIdCardNo());
             accompanyCarDetailEntity.setAddress(carInfo.getAddress());         //通信地址
             accompanyCarDetailEntity.setPlateType(carInfo.getPlateType());
             accompanyCarDetailEntity.setCarColor(carInfo.getCarColor());
             accompanyCarDetailEntity.setPhoneNumber(carInfo.getPhoneNumber());
             accompanyCarDetailEntity.setCarSubBrand(carInfo.getCarModel());  //车辆型号

//下面这个是拿到同行车的那个信息
             accompanyCarDetailEntity.setFollowplatenumber(carInfo.getIdCardNo());
             accompanyCarDetailEntity.setFollowcarBrand(carInfo.getCarModel());
             accompanyCarDetailEntity.setFollowregistAddress(carInfo.getOwnerPlace()); //车辆归属地
             accompanyCarDetailEntity.setFollowcarOwner(carInfo.getOwnerCarName());
             accompanyCarDetailEntity.setFollowcarOwner(carInfo.getIdCardNo());
             accompanyCarDetailEntity.setFollowaddress(carInfo.getAddress());       //通信地址
             accompanyCarDetailEntity.setFollowplateType(carInfo.getPlateType());
             accompanyCarDetailEntity.setFollowcarColor(carInfo.getCarColor());
             accompanyCarDetailEntity.setFollowphoneNumber(carInfo.getPhoneNumber());
         }
         else {
            response.setMsg("未找到车辆详细信息");
            response.setCode(ConstantUtils.RETURN_RESULT_FAIL_CODE_1);

            //测试数据
            accompanyCarDetailEntity.setPlateType("大货车");
            accompanyCarDetailEntity.setCarColor("红色");
            accompanyCarDetailEntity.setCarBrand("奥迪");
            accompanyCarDetailEntity.setAddress("通讯地址天水");
            accompanyCarDetailEntity.setCarOwner("车主张三");
            accompanyCarDetailEntity.setOwnerCardId("220234566478");
            accompanyCarDetailEntity.setRegistAddress("注册地址大连");
            accompanyCarDetailEntity.setCarSubBrand("A8");

             accompanyCarDetailEntity.setFollowplateType("卡车车牌");
             accompanyCarDetailEntity.setFollowcarBrand("雷克萨斯");
             accompanyCarDetailEntity.setFollowregistAddress("大连"); //车辆归属地
             accompanyCarDetailEntity.setFollowcarOwner("李四");
             accompanyCarDetailEntity.setFollowcarSubBrand("RX350");
             accompanyCarDetailEntity.setFollowcarOwner("666666666");
             accompanyCarDetailEntity.setFollowaddress("辽宁省大连市东软F5座");      //通信地址
             accompanyCarDetailEntity.setFollowcarColor("紫色");
             accompanyCarDetailEntity.setFollowphoneNumber("155555555555");




            }
        // 实例化入参JSON
        JSONObject inJson = new JSONObject();
        JSONObject inJson2 = new JSONObject();

        // 实例化出参JSON
        JSONObject outJson = new JSONObject();
        JSONObject outJson2 = new JSONObject();

        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");



        // 测试数据
//      inJson.put("platenumber", "['鲁GZP684']");
//      inJson.put("starttime", "2016-10-01 00:00:00");
//      inJson.put("endtime", "2016-10-01 00:00:00");
//      inJson.put("colors", "['蓝']");
        try {
            //主车转Json
            inJson.put("numbers", "['"+carId+"']");
            inJson.put("endtime", transferFormat(datetime));
            Date date = formatter.parse(datetime);
            Calendar rightNow = Calendar.getInstance();
            rightNow.setTime(date);
            rightNow.add(Calendar.DAY_OF_YEAR,-1);//日期-1天
            Date dt1=rightNow.getTime();
            String reStr = formatter.format(dt1);
            inJson.put("starttime", transferFormat(reStr));
            inJson.put("colors", "['"+colors+"']");

            // 调接口查询车辆轨迹信息
            String url = ConstantUtils.RETURN_SELECT_URL + "/carpass/query/single";
            String strOutJson = HttpUtils.doPost(url, inJson.toString());
            outJson = JSONObject.fromObject(strOutJson);

            // 转化为java使用的json字符串格式
            String result = "";
            if (outJson != null) {
                // 转化为java使用的json字符串格式
                result = outJson.get("result").toString();
            }
            //主车的结果判断
            if (ConstantUtils.RETURN_RESULT_IABC_OK.equals(result)) {
                JSONObject jsonContext = new JSONObject();
                jsonContext = (JSONObject) outJson.get("context");
                JSONArray jsonArray = JSONArray.fromObject(jsonContext.get("result"));
                List<BasicTrailEntity> trailEntityList = new ArrayList<BasicTrailEntity>();
                BasicTrailEntity trailEntity = new BasicTrailEntity();
                for (int i = 0; i < jsonArray.size(); i++) {
                    trailEntity = new BasicTrailEntity();
                    trailEntity.setRowKeyTrail(jsonArray.getJSONObject(i).get("rowKey").toString());
                    trailEntity.setDateTimeTrail(jsonArray.getJSONObject(i).get("datetime").toString());
                    trailEntity.setColorTrail(jsonArray.getJSONObject(i).get("color").toString());
                    trailEntity.setDeviceIdTrail(jsonArray.getJSONObject(i).get("deviceId").toString());
                    trailEntity.setPlatenumberTrail(jsonArray.getJSONObject(i).get("platenumber").toString());
                    trailEntity.setStreet_xTrail(jsonArray.getJSONObject(i).get("street_x").toString());
                    trailEntity.setStreet_yTrail(jsonArray.getJSONObject(i).get("street_y").toString());
                    trailEntity.setStreetTrail(jsonArray.getJSONObject(i).get("street").toString());
                    trailEntity.setGps_xTrail(jsonArray.getJSONObject(i).get("gps_x").toString());
                    trailEntity.setGps_yTrail(jsonArray.getJSONObject(i).get("gps_y").toString());
                    trailEntity.setPlatenumbercolorTrail(jsonArray.getJSONObject(i).get("platenumbercolor").toString());
                    trailEntity.setCarlocationTrail(jsonArray.getJSONObject(i).get("carlocation").toString());
                    trailEntityList.add(trailEntity);
                }


                accompanyCarDetailEntity.setTrailList(trailEntityList);
                response.setAccompanyCarDetailEntity(accompanyCarDetailEntity);
                response.setCode(ConstantUtils.RETURN_RESULT_SUCCESS_CODE_0);
            } else {
                response.setMsg("未找到同行车轨迹信息！");
                response.setCode(ConstantUtils.RETURN_RESULT_FAIL_CODE_1);
            }
        } catch (Exception e) {
            e.printStackTrace();
            response.setMsg("系统异常");
            response.setCode(ConstantUtils.RETURN_RESULT_FAIL_CODE_1);
        }
下面是从车的
        try {

            // 测试数据
//          inJson2.put("followplatenumber", "['鲁V0652J']");
//          inJson2.put("starttime", "2016-10-01 00:00:00");
//          inJson2.put("endtime", "2016-10-02 00:00:00");
//          inJson2.put("followplateColor", "['蓝']");

        //从车转Json
            inJson2.put("numbers", "['"+peerCarId+"']");
            inJson2.put("endtime", transferFormat(peerdatetime));
            Date date2 = formatter.parse(peerdatetime);
            Calendar rightNow2 = Calendar.getInstance();
            rightNow2.setTime(date2);
            rightNow2.add(Calendar.DAY_OF_YEAR,-1);//日期-1天
            Date dt2=rightNow2.getTime();
            String reStr2 = formatter.format(dt2);
            inJson2.put("starttime", transferFormat(reStr2));
            inJson2.put("colors", "['"+peercolors+"']");


            // 调接口查询车辆轨迹信息
            String url2 = ConstantUtils.RETURN_SELECT_URL + "/carpass/query/single";
            String strOutJson2 = HttpUtils.doPost(url2, inJson2.toString());
            outJson2 = JSONObject.fromObject(strOutJson2);  
            // 转化为java使用的json字符串格式
            String result2 = "";
            if ( outJson2 != null) {
                // 转化为java使用的json字符串格式
                result2 = outJson2.get("result").toString();
            }
            //从车的结果判断
            if (ConstantUtils.RETURN_RESULT_IABC_OK.equals(result2)) {
                JSONObject jsonContext2 = new JSONObject();
                jsonContext2 = (JSONObject) outJson2.get("context");
                JSONArray jsonArray2 = JSONArray.fromObject(jsonContext2.get("result"));
                List<BasicTrailEntity> trailEntityList2 = new ArrayList<BasicTrailEntity>();
                BasicTrailEntity trailEntity2 = new BasicTrailEntity();
                for (int i = 0; i < jsonArray2.size(); i++) {
                    trailEntity2 = new BasicTrailEntity();
                    trailEntity2.setRowKeyTrail(jsonArray2.getJSONObject(i).get("rowKey").toString());
                    trailEntity2.setDateTimeTrail(jsonArray2.getJSONObject(i).get("datetime").toString());
                    trailEntity2.setColorTrail(jsonArray2.getJSONObject(i).get("color").toString());
                    trailEntity2.setDeviceIdTrail(jsonArray2.getJSONObject(i).get("deviceId").toString());
                    trailEntity2.setPlatenumberTrail(jsonArray2.getJSONObject(i).get("platenumber").toString());
                    trailEntity2.setStreet_xTrail(jsonArray2.getJSONObject(i).get("street_x").toString());
                    trailEntity2.setStreet_yTrail(jsonArray2.getJSONObject(i).get("street_y").toString());
                    trailEntity2.setStreetTrail(jsonArray2.getJSONObject(i).get("street").toString());
                    trailEntity2.setGps_xTrail(jsonArray2.getJSONObject(i).get("gps_x").toString());
                    trailEntity2.setGps_yTrail(jsonArray2.getJSONObject(i).get("gps_y").toString());
                    trailEntity2.setPlatenumbercolorTrail(jsonArray2.getJSONObject(i).get("platenumbercolor").toString());
                    trailEntity2.setCarlocationTrail(jsonArray2.getJSONObject(i).get("carlocation").toString());
                    trailEntityList2.add(trailEntity2);
                }


                accompanyCarDetailEntity.setFollowTrailList(trailEntityList2);
                //把同行车那个实体给set到response中
                response.setAccompanyCarDetailEntity(accompanyCarDetailEntity);
                response.setCode(ConstantUtils.RETURN_RESULT_SUCCESS_CODE_0);
            } else {
                response.setMsg("未找到同行车从车轨迹信息！");
                response.setCode(ConstantUtils.RETURN_RESULT_FAIL_CODE_1);
            }
        } catch (Exception e) {
            e.printStackTrace();
            response.setMsg("系统异常");
            response.setCode(ConstantUtils.RETURN_RESULT_FAIL_CODE_1);
        }


         return response;

    }



    /**
     * 获取全部卡口列表
     * @param request
     * @return List<DevicesEntity>
     */
    @RequestMapping(value = "/getAccompanyCarCheckPointList", method=RequestMethod.POST)
    @ResponseBody
    public List<DevicesAreaEntity> getAccompanyCarCheckPointList(HttpServletRequest request){
        // 卡口集合
        List<DevicesEntity> list = new ArrayList<DevicesEntity>();
        // 卡口所属区域集合
        List<DevicesAreaEntity> areaList = new ArrayList<DevicesAreaEntity>();
        // 查询卡口所属区域集合
        DataSourceTypeManager.set(DataSources.DATASOURCE1);
        areaList = devicesService.getDevicesAreaList();
        if (areaList.size() > 0) {
            for (int i=0; i<areaList.size(); i++) {
                list = new ArrayList<DevicesEntity>();
                DataSourceTypeManager.set(DataSources.DATASOURCE1);
                list = devicesService.getDevicesList(areaList.get(i).getDevicesAreaName());
                if (list.size() > 0) {
                    areaList.get(i).setDevicesEntityList(list);
                }
            }
        }
        return areaList;
    }

    /**
     * 获取排除车辆类型设定
     */
//  @RequestMapping(value = "/getAccompanyCarVehicleType", method=RequestMethod.POST)
//  @ResponseBody
//  public List<VehicleInfoEntity> getFreqCarVehicleType() {
//      List<VehicleInfoEntity> list = new ArrayList<VehicleInfoEntity>();
//      list = carInfoService.getVehicleType();
//      return list;
//  }

    /**
     * 加入战果
     * @param params
     * @return Response
     */
//  @RequestMapping(value= "/addAccompanyCarResults", method=RequestMethod.POST)
//  @ResponseBody
//  public void addFreqCarResults(@RequestBody Map<String, String> params){
//      // TODO
//  }

    /**
     * 日期类型yyyyMMddHHmmss转换为yyyy-MM-dd HH:mm:ss
     * @param time
     * @return String
     */
    public String changeJsonTime(String time) {
        String str = "";
        SimpleDateFormat sdf=new SimpleDateFormat("yyyyMMddHHmmss"); 
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            if (time.length() == 14) {
                str = formatter.format(sdf.parse(time));
            } else {
                str = time;
            }
        } catch (Exception e) {
            //做转化失败的操作 
            str = time;
        }
        return str;
    }

    /** 
    * yyyy-MM-dd HH:mm:ss转换为yyyyMMddhhmmss
    * @throws ParseException  
    */  
    public String transferFormat(String inTime) throws ParseException{  
        SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");   
        SimpleDateFormat s2 = new SimpleDateFormat("yyyyMMddhhmmss");  
        Date tempDate =null;  
        String outTime = null;  
        tempDate = s1.parse(inTime);  
        outTime = s2.format(tempDate);
        // outTime = s2.format(s2.parse(s1.format(tempDate)));  
        return outTime;  
    }  

    /** 
    * yyyy-MM-dd转换为yyyyMMdd
    * @throws ParseException  
    */  
    public String transferFormat1(String inTime) throws ParseException{  
        SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd");   
        SimpleDateFormat s2 = new SimpleDateFormat("yyyyMMdd");  
        Date tempDate =null;  
        String outTime = null;  
        tempDate = s1.parse(inTime);  
        outTime = s2.format(tempDate);
        // outTime = s2.format(s2.parse(s1.format(tempDate)));  
        return outTime;  
    }  

    /**
     * 对日期yyyy-MM-dd HH:mm:ss格式进行效验
     * @param strDateTime
     * @return int
     */
    public int checkDateFormatAndValite(String strDateTime) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        int result = 0;
        try {
            Date ndate = format.parse(strDateTime);
            String str = format.format(ndate);
            //success
            if (str.equals(strDateTime)) {
                result = 1;
            } else {
                result = 0;
            }
        } catch (ParseException e) {
            e.printStackTrace();
            result = -1;
        }
        return result;
    }
    /*
     * 把字符串的秒转为x时x分x秒格式
     * 
     * */
    public String secondChangeMinute(String second){

        int secondInt = Integer.parseInt(second);
          int h = 0;
          int d = 0;
          int s = 0;
          int temp = secondInt%3600;
               if(secondInt>3600){
                 h= secondInt/3600;
                      if(temp!=0){
                 if(temp>60){
                 d = temp/60;
              if(temp%60!=0){
                 s = temp%60;
              }
              }else{
                 s = temp;
              }
             }
            }else{
                d = secondInt/60;
             if(secondInt%60!=0){
                s = secondInt%60;
             }
            }

           return h+"时"+d+"分"+s+"秒";

    }

}

service层

package com.ia.lhc.service;

import java.util.List;
import com.ia.lhc.form.AccompanyCarForm;
import com.ia.lhc.model.AccompanyCarDetailEntity;
import com.ia.lhc.model.AccompanyCarEntity;

public interface AccompanyCarService {

    /**
     * 获取同行车分析
     * @return List<AccompanyCarEntity>
     */
    public List<AccompanyCarEntity> getAccompanyCarList(AccompanyCarForm accompanyCarForm);
}

serviceImpl层

package com.ia.lhc.service.impl;

import java.util.ArrayList;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ia.lhc.form.AccompanyCarForm;
import com.ia.lhc.mapper.AccompanyCarMapper;
import com.ia.lhc.model.AccompanyCarEntity;
import com.ia.lhc.service.AccompanyCarService;

@Service
public class AccompanyCarServiceImpl implements AccompanyCarService{

    @Autowired
    private AccompanyCarMapper accompanyCarMapper;

    /**
     * 获取同行车分析
     */
    @Override
    public List<AccompanyCarEntity> getAccompanyCarList(AccompanyCarForm accompanyCarForm) {

//      String str = String.join(",", accompanyCarForm.getDevicesId());
//      accompanyCarForm.setDevices(str);
        String[] devicesId = accompanyCarForm.getDevicesId();   

        List<AccompanyCarEntity> list = accompanyCarMapper.getAccompanyCarList(accompanyCarForm);   
        //为了防止报空指针，如果当数组的第一个数等于1说明卡口列表就是为空
        if(devicesId!=null && devicesId.length > 0){
            List<AccompanyCarEntity> resultList = new ArrayList<AccompanyCarEntity>();

            for(AccompanyCarEntity accompanyCarEntity : list){
                String deviceIDs = accompanyCarEntity.getDeviceIDs();    //数据库的字符串
                String[] strArr = accompanyCarForm.getDevicesId();       //前台传过来的字符串数组
                int i = 0;
                for( ; i < strArr.length; i++){
                    int indexNum = deviceIDs.indexOf(strArr[i]);    
                    if(indexNum<0){
                        break;
                    }
                }
                if(i>=strArr.length){
                    resultList.add(accompanyCarEntity);
                }
            }   
            return resultList;
        }
        else{
            return list;
        }


    }
}

DAO层的接口

package com.ia.lhc.mapper;

import java.util.List;
import com.ia.lhc.form.AccompanyCarForm;
import com.ia.lhc.model.AccompanyCarEntity;

public interface AccompanyCarMapper {

    /**
     * 获取同行车分析
     * @param accompanyCarForm
     * @return
     */
    List<AccompanyCarEntity> getAccompanyCarList(AccompanyCarForm accompanyCarForm);
}

DAO的Mapping

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.ia.lhc.mapper.AccompanyCarMapper" >
  <resultMap id="BaseResultMap" type="com.ia.lhc.model.AccompanyCarEntity" >
    <result column="id" property="id" jdbcType="INTEGER" />
    <result column="areaId" property="areaId" jdbcType="INTEGER" />
    <result column="date" property="date" jdbcType="VARCHAR" />
    <result column="platenumber1" property="platenumber1" jdbcType="VARCHAR" />
    <result column="platecolor1" property="platecolor1" jdbcType="VARCHAR" />
    <result column="platenumber2" property="platenumber2" jdbcType="VARCHAR" />
    <result column="platecolor2" property="platecolor2" jdbcType="VARCHAR" />
    <result column="deviceIDs" property="deviceIDs" jdbcType="VARCHAR" />
    <result column="accompanyTime" property="accompanyTime" jdbcType="NUMERIC" />
    <result column="rank" property="rank" jdbcType="NUMERIC" />
    <result column="accompanyCount" property="accompanyCount" jdbcType="INTEGER" />
  </resultMap>

  <sql id="Base_Column_List">
    id,areaId,date,platenumber1,platecolor1,platenumber2,platecolor2,deviceIDs,accompanyTime,rank,accompanyCount
  </sql>

  <!-- 获取同行车分析 -->
  <select id="getAccompanyCarList" resultMap="BaseResultMap" parameterType="com.ia.lhc.form.AccompanyCarForm">
    SELECT
    <include refid="Base_Column_List" />
    FROM
        iabc_ttr_accompanycar AC
    WHERE  
       AC.date between #{startdate} and #{enddate} 

    <if test="platenumber !=null and platenumber !=''">
       <!--  AND (AC.platenumber1 =#{platenumber}) -->
       AND AC.platenumber1 LIKE CONCAT(#{platenumber,jdbcType=VARCHAR}, '%') OR AC.platenumber2 LIKE CONCAT(#{platenumber,jdbcType=VARCHAR}, '%')
    </if>
    <if test="colors!=null and colors!=''">
        AND (AC.platecolor1  = #{colors})
    </if>

  </select>

</mapper>