자바 서비스 구현 클래스 에서 복잡 한 논 리 를 처리 하 는 쓰기

작성 순서:
1.일반적인 업무 인 터 페 이 스 를 정의 합 니 다.

public interface SingleOperation {

    RestResponse doOperation();
}

2.Service 실현 클래스 에서 복잡 한 업무 처리 포장 서브 클래스 를 정의 합 니 다.예 를 들 어 결제 시트 업무[Create Payment]를 만들어 Single Operation 인 터 페 이 스 를 실현 합 니 다.

/**
 *        
 */
private class CreatePayment implements SingleOperation {
    final org.slf4j.Logger log = CREATE_LOG;
    final FundPaymentCreateRequest request;
    FundPayment newPayment;

    private CreatePayment(final FundPaymentCreateRequest request) {
        this.request = request;
    }

    @Override
    public RestResponse doOperation() {
        // 1.       
        // 2.          （            ）
        // 3.    
        // 4.    

        // 1.       
        final ParamValidationResult checkResult = checkCreateParam(request);
        if (!checkResult.isPass()) {
            return checkResult.toRestResponse();
        }

        // 2      ，      
        final String paymentNo;
        final boolean paymentNoExists;
        {
            final String existsPaymentNo = request.getPaymentNo();
            if (!StringUtils.isEmpty(existsPaymentNo)) {
                //         ，    ，                   
                paymentNo = existsPaymentNo;
                paymentNoExists = true;
            } else {
                //     ，    ，          
                paymentNo = ascIdGenerator.generateString(FUND_PAYMENT);
                paymentNoExists = false;
            }
        }

        //         paymentStatus    ，        ，     
        final EnumFundPaymentStatus paymentStatus =       Optional.ofNullable(request.getPaymentStatus()).orElse(EnumFundPaymentStatus.TO_AUDIT);
        //         ，       ，    receiverAccount     ，     
        final EnumFundPaymentType paymentType = Optional.ofNullable(request.getPaymentType()).orElseGet(() -> {
            if (StringUtils.isEmpty(request.getReceiverAccount())) {
                return EnumFundPaymentType.OFFLINE;
            } else {
                return EnumFundPaymentType.ONLINE;
            }
        });


        // 3.       
        return transactionTemplate.execute(status -> {
            //          ，         
            if (paymentNoExists) {
                final FundPayment queryEntity = new FundPayment();
                queryEntity.setPaymentNo(paymentNo);
                final Integer count = fundPaymentMapper.selectCount(new QueryWrapper<>(queryEntity));
                if (count > 0) {
                    log.warn("       ，     [{}]   。  ：[{}]", paymentNo, request);
                    return fail(EnumCommonRestResponseCode.BusinessError, "      ，    ");
                }
            }

            //      
            newPayment = new FundPayment();
            newPayment.setPaymentNo(paymentNo);
            newPayment.setAmount(request.getAmount());
            newPayment.setPaymentStatus(paymentStatus);
            newPayment.setPaymentType(paymentType);
            newPayment.setPayAccount(request.getPayAccount());
            newPayment.setPayName(request.getPayName());
            newPayment.setReceiverAccount(request.getReceiverAccount());
            newPayment.setReceiverName(request.getReceiverName());
            newPayment.setRemark(request.getRemark());
            fundPaymentMapper.insert(newPayment);

            //     
            final List entities = request.getRelationList().stream().map(v -> {
                final FundPaymentRelation entity = new FundPaymentRelation();
                entity.setPaymentNo(paymentNo);
                entity.setRelationType(v.getRelationType());
                entity.setRelationNo(v.getRelationNo());
                entity.fillInsert();
                return entity;
            }).collect(Collectors.toList());
            if (entities != null && entities.size() > 0) {
                fundPaymentRelationMapper.batchInsert(entities);
            }

            //    
            sendMq();
            return success(paymentNo);
        });
    }

이렇게 하면 우 리 는 복잡 한 업 무 를 여러 개의 하위 클래스 로 나 누 어 각자 의 논 리 를 쓰 면 복잡 한 문 제 를 간단하게 할 수 있다.우리 가 추출 방법 을 통 해 방법 간 에 서로 호출 하 는 것 이 아니 라 업무 가 복잡 해서 코드 를 읽 기 어렵다.