项目背景

最近公司需要引入一款新的人脸设备，并且想要整合一下之前的设备，想要做到一个项目里面能使用两个不同平台的设备，这两个平台之前都做过对接，但是由于写的人不同，所以逻辑上有一点点不一样，但是其实也可以按照同样的逻辑去写。

重构第一步：抽取共性与差异

注意，重构一定要在你熟悉业务与架构的情况下进行重构，如果不熟悉，并且没有必要的情况下，不建议对代码做任何修改，经过上线校验的代码，写的再差也比没经过验证的代码强。
以我这次重构的一个步骤为例，人员信息同步（增加、修改），其实他就可以抽象成以下这么一个流程
获取在线的设备 -> 检查图片质量是否合格 -> 开启线程异步同步 -> 检查设备是否存在该人员 ？修改 ： 删除

重构第二步：根据第一步的流程确定架构

这里先放一下原代码，这段代码在只有一种设备的情况下是没有问题的，但是现在我这里一个程序需要兼容不同的设备，并且设备的处理逻辑大体上是相同的，只不过与设备交互的地方有点不一样

    private void doSyncPerson(PersonalInfo personalInfo, OperateType operateType, UserSyncReq userInfo, String address) {
        Integer deviceId;
        try {
            deviceId = deviceService.getDeviceId(address);
        } catch (Exception e) {
            throw new ServiceException("获取设备id失败,address: " + address);
        }
        if (isExistsPerson(address, deviceId, String.valueOf(userInfo.getUser_id()))) {
            operateType = OperateType.EditPerson;
            personalInfo.setOperator(operateType.name());
        }
        personalInfo.getInfo().setDeviceId(deviceId);
        HaiqingResp response = haiqingDeviceClient.post(address, operateType, personalInfo,HaiqingResp.class);
        if(response.isError()){
            throw new ServiceException("同步人员信息失败");
        }
    }

    private PersonalInfo searchPerson(String address, int deviceId, String searchId) {
        Map<String, Object> json = new HashMap<>();
        json.put("operator", OperateType.SearchPerson.name());
        Map<String, Object> info = new HashMap();
        info.put("DeviceID", deviceId);
        info.put("SearchType", 0);
        info.put("SearchID", searchId);
        info.put("Picture", 0);
        json.put("info", info);
        return haiqingDeviceClient.post(address, OperateType.SearchPerson, json,PersonalInfo.class);

    }


    private boolean isExistsPerson(String address, int deviceId, String searchId) {
        PersonalInfo personalInfo = this.searchPerson(address, deviceId, searchId);
        if (personalInfo == null) {
            return false;
        }
        if (personalInfo.getInfo() == null) {
            return false;
        }
        return personalInfo.getInfo().getCustomizeId() != null;
    }

开始重构

    @Override
    public AcmsRespDTO userSync(UserSyncReq userSyncReq) {
        List<String> device_address_list = userSyncReq.getDevice_address_list();
        userSyncReq.setDevice_address_list(filterOnlineDevices(device_address_list));
// checkImage是个接口方法 由子类实现
        boolean isPass = checkImage(userSyncReq.getPhoto(), userSyncReq.getDevice_address_list());
        if(!isPass){
            return AcmsRespDTO.error("图片校验失败");
        }
        for (String address : userSyncReq.getDevice_address_list()) {
            ScheduleConfig scheduleConfig = new ScheduleConfig();
            scheduleConfig.setKey(IdUtil.fastSimpleUUID());
            scheduleConfig.setStartTime(new Date());
            scheduleConfig.setDelay(defaultDelay);
// 用户同步的抽象类
            AbstractUserSyncThread userSyncThread = getUserSyncThread();
            userSyncThread.setScheduleConfig(scheduleConfig);
            userSyncThread.setUserSyncReq(userSyncReq);
            userSyncThread.setAddress(address);
            scheduleConfig.setRunnable(userSyncThread);
            scheduledTaskService.addPollingTask(scheduleConfig);
        }

        return  AcmsRespDTO.success();
    }

public abstract class AbstractUserSyncThread extends AbstractScheduleTimesRunnable {

    protected UserSyncReq userSyncReq;

    protected String address;

    @Override
    protected void timesRun() {
        if(checkUserExist()){
            log.info("用户存在，修改");
            updateUser();
        }else{
            log.info("用户不存在，新增");
            addUser();
        }
    }

    /**
     * 检查用户是否存在 子类实现
     * @return
     */
    protected abstract boolean checkUserExist();

//子类实现新增方法
    protected abstract void addUser();
//子类实现修改方法
    protected abstract void updateUser();

    public UserSyncReq getUserSyncReq() {
        return userSyncReq;
    }

    public void setUserSyncReq(UserSyncReq userSyncReq) {
        this.userSyncReq = userSyncReq;
    }

    public String getAddress() {
        return address;
    }

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

第三步：由子类确认具体实现

这里以其中一个设备为例

@Service("HaiQing")
@Slf4j
public class HaiQingAcmsInterface extends AbstractAcmsInterface {

    @Autowired
    private HaiqingDeviceClient haiqingDeviceClient;

    @Override
    public AcmsRespDTO usePicCheck(String photo) {
        return null;
    }


    @Override
    public boolean checkImagePass(String photo, String address) {
        DetectFaceFromPicReq request = new DetectFaceFromPicReq();
        request.setOperator(OperateType.DetectFaceFromPic);
        DetectFaceFromPicReq.Info info = new DetectFaceFromPicReq.Info();
        info.setPicinfo(photo);
        request.setInfo(info);
        try {
            DetectFaceFromPicResp detectFaceFromPicResp = haiqingDeviceClient
                    .post(address, OperateType.DetectFaceFromPic, request, DetectFaceFromPicResp.class);
            int detectFace = Optional.ofNullable(detectFaceFromPicResp)
                    .map(DetectFaceFromPicResp::getInfo)
                    .map(DetectFaceFromPicResp.Info::getDetectFace)
                    .orElse(0);
            return detectFace == 1;
        } catch (Exception ignored) {
            log.error("校验图片异常",ignored);
        }
        return false;
    }

    @Override
    public AbstractUserSyncThread getUserSyncThread() {
        return new HaiQingUserSyncThread();
    }

    @Override
    public AbstractUserDelThread getUserDelThread() {
        return new HaiQingUserDelThread();
    }

    @Override
    public AbstractDeviceSyncThread getDeviceSyncThread() {
        return new HaiQingDeviceSyncThread();
    }
}

public class HaiQingUserSyncThread  extends AbstractUserSyncThread {

    private static HaiqingDeviceClient haiqingDeviceClient = SpringUtils.getBeanByClass(HaiqingDeviceClient.class);

    private static HaiQingDeviceService haiQingDeviceService = SpringUtils.getBeanByClass(HaiQingDeviceService.class);


    @Override
    protected boolean checkUserExist() {
        return haiQingDeviceService.checkUserExist(address,userSyncReq.getUser_id());
    }

    @Override
    protected void addUser() {
        PersonalInfo personalInfo = getPersonalInfo();
        personalInfo.setOperator(OperateType.AddPerson.name());
        HaiqingResp response = haiqingDeviceClient.post(address, OperateType.AddPerson, personalInfo,HaiqingResp.class);
        if(response.isOk()){
            stop();
        }
    }

    @Override
    protected void updateUser() {
        PersonalInfo personalInfo = getPersonalInfo();
        personalInfo.setOperator(OperateType.EditPerson.name());
        HaiqingResp response = haiqingDeviceClient.post(address, OperateType.EditPerson, personalInfo,HaiqingResp.class);
        if(response.isOk()){
            stop();
        }
    }

    private PersonalInfo getPersonalInfo(){
        PersonalInfo personalInfo = new PersonalInfo();
        personalInfo.setPicInfo(userSyncReq.getPhoto());
        Personal personal = new Personal();
        personal.setIdType(0);
        personal.setCustomizeId(Long.parseLong(userSyncReq.getUser_id()));
        personal.setTelnum(userSyncReq.getPhone());
        personal.setName(userSyncReq.getUser_name());
        personalInfo.setInfo(personal);

        Integer deviceId = haiQingDeviceService.getDeviceId(address);
        personal.setDeviceId(deviceId);

        return personalInfo;
    }
}

总结

公司内部的代码也就只能放部分片段了，重构以后代码相对来说更加清晰了一些，
说说重构的好处和坏处，按照这种架构的话呢，它固定了程序的流程，让程序以一定的流程去执行，但是也减少的一定的自由性，如果有其他设备要接入的话，按照这套模式就非常简单（按照这个架构重构另一个设备的代码就只花了一个小时，在对应实现的地方把原来的代码贴上去就行），但是如果你要改架构，就会变得非常复杂，还有，这种架构也用到了模板设计模式、工厂设计模式、对于新人来说可能会难以理解。