自定义注解调用方法

 

1.自定义注解

import org.springframework.stereotype.Component;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface InterfaceInfo {

    String value();
    String desc() default "";
}

2. 注解使用以及子类实现

package org.qtmszl.qtmszl.business.bll.basicDataMaintenance.dmsslk;

import java.util.List;
import java.util.Map;

import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;

@InterfaceInfo(value = "RECEIVE_DMS_SLK_CLAIMTYPE",desc = "XXXX接口")
public class CLaimTypeListener extends DataSynchronizeListener<ClaimTypeVo> implements InterfaceProcess {
    @Autowired
    private TbClaimTypeService tbClaimTypeService;
    @Autowired
    private TiDmsClaimTypeService ticlaimTypeService;
    @Autowired
    private UserCompanyUtil userCompanyUtil;

    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    protected void receiveData(ClaimTypeVo vo){
        logger.info("==========数据处理开始==============");
        if(!StringUtil.objCheckIsNull(vo)) {
            InterFaceCheckResult check = new InterFaceCheckResult();
            try {
                check = tbClaimTypeService.check(vo);
                if (!check.isSuccess()) {
                    saveServiceCenter(vo,check);
                }
            } catch (Exception e) {
                check.setError(e.getMessage());
                saveServiceCenter(vo,check);
                logger.error(e.getMessage());
            }

        }
        logger.info("==========数据处理结束==============");
    }

    private void saveServiceCenter(ClaimTypeVo vo, InterFaceCheckResult check) {
        // 校验不通过存入接口表
        TiDmsClaimType claimType = new TiDmsClaimType();
        try {
            org.springframework.beans.BeanUtils.copyProperties(vo, claimType);
        } catch (Exception e) {
            throw new BeanCopyPropertiesException(e.getMessage());
        }
        claimType.setValidationDesc(check.getError());
        claimType.setValidation("1");
        claimType.setCreateby("DMS-DOL接口");
        claimType.setCompany(vo.getCompany());
        TiDmsClaimType finBypk = ticlaimTypeService.findByPk(claimType);
        if(null != finBypk){
            claimType.setCreateby("DMS-DOL接口");
            claimType.setId(finBypk.getId());
            ticlaimTypeService.update(claimType);
        } else {
            ticlaimTypeService.insert(claimType);
        }
    }

    @Override
    public void insert(ClaimTypeVo vo) {
        this.receiveData(vo);
    }

    @Override
    public void update(ClaimTypeVo oldData, ClaimTypeVo newData) {
        this.receiveData(newData);
    }

    @Override
    public void delete(ClaimTypeVo vo) {
        // super.delete(feature);
    }

    @Override
    @KafkaListener(topics = { "DWS_SLK_CLAIM_TYPE" })
    public void onMessage(ConsumerRecord<String, String> data, Consumer<?, ?> consumer) {
        super.onMessage(data, consumer);
    }

    @Override
    public void onError(ConsumerRecord<String, String> data, Consumer<?, ?> consumer, String message, Data<ClaimTypeVo> featureData) {
        super.onError(data, consumer, message, featureData);
    }

    @Override
    public GridResult<?> query(BaseSearchViewModel baseSearchViewModel, Map<String, Object> parmter) {
        TiDmsClaimType tiDmsClaimType = StringUtil.toBean(TiDmsClaimType.class, parmter);
        tiDmsClaimType.setCompany(userCompanyUtil.getUserCompany());
        GridResult<TiDmsClaimType> dmsDealerGridResult = ticlaimTypeService.query(baseSearchViewModel, tiDmsClaimType);
        return dmsDealerGridResult;
    }

    @Override
    public void reprocess(Long obj) {
        if(!StringUtil.isEmpty(obj)){
            ClaimTypeVo claimTypeVo = new ClaimTypeVo();
            TiDmsClaimType byId = ticlaimTypeService.findById(obj);
            claimTypeVo.setCompany(userCompanyUtil.getUserCompany());
            try {
                org.springframework.beans.BeanUtils.copyProperties(byId,claimTypeVo);
            }catch (Exception e){
                throw    new BeanCopyPropertiesException(e.getMessage());
            }

            InterFaceCheckResult check = tbClaimTypeService.check(claimTypeVo);
            if(check.isSuccess()){
                ticlaimTypeService.deleteById(byId.getId());
            }else{
                byId.setValidationDesc(check.getError());
                ticlaimTypeService.update(byId);
            }
        }
    }

    @Override
    public void reprocessAll() {
        String userCompany = userCompanyUtil.getUserCompany();
        List<TiDmsClaimType> datas = ticlaimTypeService.queryAll(userCompany);
        if(datas.size()>0){
            for (TiDmsClaimType model : datas) {
                ClaimTypeVo claimTypeVo = new ClaimTypeVo();
                model.setCompany(userCompany);
                try {
                    BeanUtils.copyProperties(model,claimTypeVo);
                }catch (Exception e){
                 throw    new BeanCopyPropertiesException(e.getMessage());
                }
                InterFaceCheckResult check = tbClaimTypeService.check(claimTypeVo);
                if(check.isSuccess()){
                    ticlaimTypeService.deleteById(claimTypeVo.getId());
                }else{
                    model.setValidationDesc(check.getError());
                    ticlaimTypeService.update(model);
                }
            }
        }
    }

    @Override
    public void update(Map<String,Object> obj) {
        if(obj.size() > 0){
            TiDmsClaimType tbClaimType = new TiDmsClaimType();
            tbClaimType.setCompany(userCompanyUtil.getUserCompany());
            tbClaimType.setId(Long.valueOf(obj.get("id")+""));
            tbClaimType.setTypeCode((String)obj.get("typeCode"));
            tbClaimType.setDescZh((String)obj.get("descZh"));
            tbClaimType.setDescEn((String)obj.get("descEn"));
            tbClaimType.setValidation((String)obj.get("validation"));
            tbClaimType.setValidationDesc((String)obj.get("validationDesc"));
            ticlaimTypeService.update(tbClaimType);
        }
    }

    
    @Override
    public void delete(Long id) {
        ticlaimTypeService.deleteById(id);
    }
    @Override
    public List<String> findValiDation() {
        return ticlaimTypeService.findValiDation();
    }
}

3.公共接口

package org.testzl.qtmszl.business.bll.interfaces;

import org.testzl.qtmszl.framework.viewmodel.BaseSearchViewModel;
import org.testzl.qtmszl.framework.viewmodel.ui.GridResult;

import java.util.List;
import java.util.Map;

public interface IntarfaceService {
    
    public void reprocess(String interfaceName,Long id);
    public void reprocessAll(String interfaceName);
    public GridResult<?> queryAll(String interfaceName, BaseSearchViewModel baseSearchViewModel,Map<String, Object> parmter);
    public void delete(String interfaceName,Long id);
    void update(String interfaceName, Map<String, Object> obj);
    public List<String> findValiDation(String interfaceName);
}

4.公共接口实现类

package org.testzl.qtmszl.business.bll.interfaces;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.testzl.qtmszl.business.bll.basicDataMaintenance.TbMqinterfaceInfoService;
import org.testzl.qtmszl.framework.interfaces.InterfaceInfo;
import org.testzl.qtmszl.framework.interfaces.InterfaceProcess;
import org.testzl.qtmszl.framework.viewmodel.BaseSearchViewModel;
import org.testzl.qtmszl.framework.viewmodel.ui.GridResult;
import org.testzl.qtmszl.repository.model.basicDataMaintenance.TbMqinterfaceInfo;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.stereotype.Component;

@Component
public class InterfaceProcessPostProcessor implements BeanPostProcessor,IntarfaceService, ApplicationRunner{
    public Map<String,InterfaceProcess> interfaces = new ConcurrentHashMap<>();
    @Autowired
    TbMqinterfaceInfoService mqinterfaceInfoService;
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Class<?> targetClass = AopUtils.getTargetClass(bean);
        InterfaceInfo ann = AnnotationUtils.findAnnotation(targetClass, InterfaceInfo.class);
        if(ann!=null) {
            interfaces.put(ann.value(), (InterfaceProcess)bean);
        }
        return bean;
    }

    @Override
    public void reprocess(String interfaceName,Long id) {
        interfaces.get(interfaceName).reprocess(id);
    }

    @Override
    public void reprocessAll(String interfaceName) {
        interfaces.get(interfaceName).reprocessAll();
    }

    @Override
    public GridResult<?> queryAll(String interfaceName, BaseSearchViewModel baseSearchViewModel,
            Map<String, Object> parmter) {
        return interfaces.get(interfaceName).query(baseSearchViewModel, parmter);
    }

    @Override
    public void delete(String interfaceName,Long id) {
        interfaces.get(interfaceName).delete(id);
    }
    @Override
    public void update(String interfaceName,Map<String,Object> obj) {
        interfaces.get(interfaceName).update(obj);
    }
    @Override
    public void run(ApplicationArguments args) throws Exception {
        for (String key : interfaces.keySet()) {
            TbMqinterfaceInfo interfaceName = mqinterfaceInfoService.findByInterfaceName(key);
            if(interfaceName==null) {
                InterfaceProcess interfaceProcess = interfaces.get(key);
                Class<?> targetClass = AopUtils.getTargetClass(interfaceProcess);
                InterfaceInfo ann = AnnotationUtils.findAnnotation(targetClass, InterfaceInfo.class);
                interfaceName = new TbMqinterfaceInfo();
                interfaceName.setInterfaceName(ann.value());
                interfaceName.setInterfaceDesc(ann.desc());
                mqinterfaceInfoService.insert(interfaceName);
            }
        }
    }

    @Override
    public List<String> findValiDation(String interfaceName) {
        return interfaces.get(interfaceName).findValiDation();
    }

}

5.接口调用（controller）

package org.testzl.qtmszl.controller.interf;

import org.testzl.qtmszl.business.bll.basicDataMaintenance.TbMqinterfaceInfoService;
import org.testzl.qtmszl.business.bll.interfaces.IntarfaceService;
import org.testzl.qtmszl.controller.interf.vo.*;
import org.testzl.qtmszl.framework.usercompany.UserCompanyUtil;
import org.testzl.qtmszl.framework.viewmodel.BaseResult;
import org.testzl.qtmszl.framework.viewmodel.ui.GridResult;
import org.testzl.qtmszl.repository.interfaces.vo.TbMqinterfaceInfoVo;
import org.testzl.qtmszl.repository.model.basicDataMaintenance.TbMqinterfaceInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/inteface")
public class IntefaceController {
    @Autowired
    private TbMqinterfaceInfoService mqinterfaceInfoService;
    @Autowired
    private IntarfaceService intarfaceService;
    @Autowired
    private UserCompanyUtil userCompanyUtil;

    @RequestMapping("/query")
    public GridResult<TbMqinterfaceInfoVo> query(@RequestBody InterfaceSearchVo interfaceSearchVo) {
        TbMqinterfaceInfo tbMqinterfaceInfo = new TbMqinterfaceInfo();
        tbMqinterfaceInfo.setCompany(userCompanyUtil.getUserCompany());
        tbMqinterfaceInfo.setInterfaceName(interfaceSearchVo.getInterfaceName());
        tbMqinterfaceInfo.setInterfaceDesc(interfaceSearchVo.getInterfaceDesc());
        return mqinterfaceInfoService.query(interfaceSearchVo, tbMqinterfaceInfo);
    }

    @RequestMapping("/queryInterfaceInfo")
    public GridResult<?> query(@RequestBody SubInterfaceSearchVo interfaceSearchVo) {
        return intarfaceService.queryAll(interfaceSearchVo.getInterfaceName(), interfaceSearchVo,
                interfaceSearchVo.getParams());
    }

    @RequestMapping("/reprocess")
    public BaseResult reprocess(@RequestBody InterfaceResProcessVo resProcessVo) {
        for (Long id : resProcessVo.getIds()) {
            intarfaceService.reprocess(resProcessVo.getInterfaceName(), id);
        }
        return new BaseResult();
    }

    @RequestMapping("/reprocessAll")
    public BaseResult reprocessAll(@RequestBody Map<String, Object> params) {
        String interfaceName = (String) params.get("interfaceName");
        intarfaceService.reprocessAll(interfaceName);
        return new BaseResult();
    }

    @RequestMapping("/update")
    public BaseResult update(@RequestBody SubInterfaceUpdateVo interfaceSearchVo) {
        intarfaceService.update(interfaceSearchVo.getInterfaceName(), interfaceSearchVo.getParams());
        return new BaseResult();
    }

    @RequestMapping("/delete")
    public BaseResult delete(@RequestBody IntefaceDeleteVo params) {
        String interfaceName = params.getInterfaceName();
        Long[] ids = params.getIds();
        for (Long id : ids) {
            intarfaceService.delete(interfaceName, id);
        }
        return new BaseResult();
    }

    @RequestMapping("/findValiDation")
    public BaseResult findValiDation(String interfaceName) {
        List<String> findValiDation = intarfaceService.findValiDation(interfaceName);
        BaseResult baseResult = new BaseResult();
        baseResult.setBody(findValiDation);
        return baseResult;
    }
}