基于SpringBoott的旅游出行保险推荐

系统展示

---

目录结构

【如需全文请按文末获取联系】

开发运行环境

前端：node22

后端：jdk1.8

数据库：mysql8

系统功能模块图

数据库设计

核心代码

package com.techology.work.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.techology.work.dto.InsuredPersonDTO;
import com.techology.work.dto.PolicyOrderCreateDTO;
import com.techology.work.mapper.InsuredPersonMapper;
import com.techology.work.mapper.PolicyHolderMapper;
import com.techology.work.mapper.PolicyOrderMapper;
import com.techology.work.model.*;
import com.techology.work.service.InsuredPersonService;
import com.techology.work.service.PolicyClaimService;
import com.techology.work.service.PolicyHolderService;
import com.techology.work.service.PolicyOrderService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
public class PolicyOrderServiceImpl extends ServiceImpl<PolicyOrderMapper, PolicyOrder> implements PolicyOrderService {

    @Autowired
    private PolicyHolderMapper policyHolderMapper;

    @Autowired
    private InsuredPersonMapper insuredPersonMapper;

    @Autowired
    private PolicyHolderService policyHolderService;

    @Autowired
    private InsuredPersonService insuredPersonService;
    @Autowired
    private PolicyClaimService policyClaimService;

    @Override
    @Transactional
    public Long createOrderWithHolderAndInsured(PolicyOrderCreateDTO dto) {
        // 创建投保人
        PolicyHolder holder = new PolicyHolder();
        BeanUtils.copyProperties(holder, dto);
        holder.setName(dto.getHolderName());
        holder.setIdNumber(dto.getHolderIdNumber());
        holder.setPhone(dto.getHolderPhone());
        holder.setEmail(dto.getHolderEmail());
        holder.setGender(dto.getHolderGender());
        holder.setBirthday(dto.getHolderBirthday());
        holder.setAddress(dto.getHolderAddress());
        holder.setCreatedAt(new Date());

        policyHolderMapper.insert(holder);

        // 创建订单
        PolicyOrder order = new PolicyOrder();
        order.setOrderNo(generateOrderNo());
        order.setProductCode(dto.getProductCode());
        order.setProductName(dto.getProductName());
        order.setHolderId(holder.getId());
        order.setUserId(dto.getUserId());
        order.setTotalPremium(dto.getTotalPremium());
        order.setStatus(dto.getStatus());
        order.setPaymentMethod(dto.getPaymentMethod());
        order.setCreatedAt(new Date());
        order.setExpireAt(dto.getExpireAt());
        this.save(order);

        // 创建被保人
        if (dto.getInsuredPersons() != null && !dto.getInsuredPersons().isEmpty()) {
            for (InsuredPersonDTO ip : dto.getInsuredPersons()) {
                InsuredPerson insured = new InsuredPerson();
                insured.setName(ip.getName());
                insured.setIdNumber(ip.getIdNumber());
                insured.setGender(ip.getGender());
                insured.setBirthday(ip.getBirthday());
                insured.setRelationship(ip.getRelationship());
                insured.setOrderId(order.getId());
                insured.setCreatedAt(new Date());

                insuredPersonMapper.insert(insured);
            }
        }

        return order.getId();
    }

    @Override
    public List<Map<String, Object>> getPopularProducts() {
        return baseMapper.getPopularProducts();
    }
    @Override
    public PolicyOrder getOrderWithDetailsById(Long orderId) {
        PolicyOrder order = this.getById(orderId);
        if (order == null) return null;

        // 设置投保人
        if (order.getHolderId() != null) {
            PolicyHolder holder = policyHolderMapper.selectById(order.getHolderId());
            order.setPolicyHolder(holder);
        }

        // 设置被保人
        List<InsuredPerson> insuredList = insuredPersonMapper.selectList(new QueryWrapper<InsuredPerson>()
                .eq("order_id", orderId));
        order.setInsuredPersons(insuredList);

        return order;
    }
    @Override
    public Page<PolicyOrder> getOrdersByUserId(int pageNum, int pageSize, Long userId) {
        Page<PolicyOrder> page = new Page<>(pageNum, pageSize);

        QueryWrapper<PolicyOrder> queryWrapper = new QueryWrapper<>();
        if (userId != null) {
            queryWrapper.eq("user_id", userId);
        }

        // 查询订单分页数据
        Page<PolicyOrder> resultPage = this.baseMapper.selectPage(page, queryWrapper);

        // 获取当前页的订单列表
        List<PolicyOrder> orderList = resultPage.getRecords();

        // 补充关联信息
        for (PolicyOrder order : orderList) {
            // 补充投保人信息
            if (order.getHolderId() != null) {
                PolicyHolder holder = policyHolderService.getPolicyHolderById(order.getHolderId());
                order.setPolicyHolder(holder);
            }

            // 补充被保人信息
            List<InsuredPerson> insuredList = insuredPersonService.getInsuredPersonsByOrderId(order.getId());
            order.setInsuredPersons(insuredList);
        }

        return resultPage;
    }
    @Override
    public boolean updateOrderStatus(Long id, String newStatus) {
        PolicyOrder order = this.getById(id);
        if (order == null) {
            return false;
        }

        // 可选：校验新状态是否合法
        if (!isValidStatus(newStatus)) {
            return false;
        }

        order.setStatus(newStatus);
        return this.updateById(order);
    }
    private boolean isValidStatus(String status) {
        return Arrays.asList("pending", "paid", "canceled", "completed").contains(status);
    }

    @Override
    public boolean deletePolicyOrderById(Long id) {
        return this.removeById(id);
    }
    public static String generateOrderNo() {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
            String datePart = sdf.format(new Date());
            int randomPart = (int) (Math.random() * 900000) + 100000; // 6位随机数
            return "ORD" + datePart + randomPart;
    }
    @Override
    public Map<String, Object> calculateClaimRate() {
        // 1. 获取总有效订单数（已支付且未取消的订单）
        QueryWrapper<PolicyOrder> orderQuery = new QueryWrapper<>();
        orderQuery.in("status", "paid", "completed");
        long totalOrdersLong = this.count(orderQuery);
        int totalOrders = (int) totalOrdersLong; // 强制转换为 int

        // 2. 获取已理赔订单数（至少有一个审核通过的理赔）
        QueryWrapper<PolicyClaim> claimQuery = new QueryWrapper<>();
        claimQuery.eq("status", "approved");

        long claimedOrdersLong = policyClaimService.count(claimQuery);
        int claimedOrders = (int) claimedOrdersLong;

        // 3. 计算理赔率
        BigDecimal claimRate;
        if (totalOrders > 0) {
            claimRate = new BigDecimal(claimedOrders)
                    .divide(new BigDecimal(totalOrders), 4, RoundingMode.HALF_UP)
                    .multiply(BigDecimal.valueOf(100));
        } else {
            claimRate = BigDecimal.ZERO;
        }

        // 4. 返回结构化数据
        Map<String, Object> result = new HashMap<>();
        result.put("claimRate", claimRate.setScale(2, RoundingMode.HALF_UP));
        result.put("totalOrders", totalOrders);
        result.put("claimedOrders", claimedOrders);

        return result;
    }
}

---

如需对应的论文或源码，以及其他定制[xah3027]