日志 + 加密

liujie

2026-05-12 d3d65af98906ccc78652c16be7e8a9fbdc03f258

 xp-robotaxi-operation-boot/src/main/java/com/xiaopeng/operation/service/impl/XpWhitelistServiceImpl.java

@@ -2,11 +2,14 @@

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.PhoneUtil;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaopeng.api.model.account.SysUser;
import com.xiaopeng.api.model.operation.XpWhitelist;
import com.xiaopeng.api.model.operation.XpWhitelistOperlog;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.exception.ServiceException;
import com.xiaopeng.common.core.utils.SensitiveDataCryptoUtil;
import com.xiaopeng.common.core.utils.ip.IpUtils;
import com.xiaopeng.common.core.web.page.PageInfo;
import com.xiaopeng.operation.constant.I18nKeyConstant;
@@ -15,7 +18,6 @@
import com.xiaopeng.operation.mapper.XpWhitelistOperlogMapper;
import com.xiaopeng.operation.query.WhitelistPageListQuery;
import com.xiaopeng.operation.service.IXpWhitelistService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.shardingsphere.transaction.annotation.ShardingSphereTransactionType;
import org.apache.shardingsphere.transaction.core.TransactionType;
import org.springframework.beans.factory.annotation.Autowired;
@@ -23,6 +25,7 @@
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
@@ -49,15 +52,19 @@
    private XpWhitelistOperlogMapper xpWhitelistOperlogMapper;
    @Override
    public PageInfo<XpWhitelist> pageList(WhitelistPageListQuery query) {
        query.setAccountQueryValues(SensitiveDataCryptoUtil.queryValues(query.getAccount()));
        PageInfo<XpWhitelist> pageInfo = new PageInfo<>(query.getPageNum(),query.getPageSize());
        List<XpWhitelist> list = this.baseMapper.pageList(pageInfo,query);
        decryptWhitelistAccounts(list);
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public List<XpWhitelist> exportList(WhitelistPageListQuery query) {
        query.setAccountQueryValues(SensitiveDataCryptoUtil.queryValues(query.getAccount()));
        List<XpWhitelist> list = this.baseMapper.exportList(query);
        decryptWhitelistAccounts(list);
        return list;
    }

@@ -96,10 +103,11 @@
        if (CollUtil.isNotEmpty(candidates)) {
            existsAccounts = this.lambdaQuery()
                    .select(XpWhitelist::getAccount)
                    .in(XpWhitelist::getAccount, candidates)
                    .in(XpWhitelist::getAccount, buildQueryValues(candidates))
                    .list()
                    .stream()
                    .map(XpWhitelist::getAccount)
                    .map(SensitiveDataCryptoUtil::decryptIfPossible)
                    .filter(StringUtils::hasLength)
                    .collect(Collectors.toSet());
        }
@@ -231,7 +239,7 @@
            throw new ServiceException("以下帐号格式不正确：", I18nKeyConstant.ACCOUNT_FORMAT_ERROR, new Object[]{dto.getAccount()});
        }
        XpWhitelist old = this.lambdaQuery()
                .eq(XpWhitelist::getAccount, dto.getAccount())
                .in(XpWhitelist::getAccount, SensitiveDataCryptoUtil.queryValues(dto.getAccount()))
                .ne(XpWhitelist::getId, dto.getId())
                .last("limit 1").one();
        if (old != null) {
@@ -302,7 +310,9 @@
    @Override
    public R deleteByIds(List<Long> ids, SysUser sysUser) {
        List<String> accounts = this.lambdaQuery().in(XpWhitelist::getId, ids).list()
                .stream().map(XpWhitelist::getAccount).collect(Collectors.toList());
                .stream().map(XpWhitelist::getAccount)
                .map(SensitiveDataCryptoUtil::decryptIfPossible)
                .collect(Collectors.toList());
        this.removeBatchByIds(ids);
        StringBuilder operationContent = new StringBuilder("删除账号:");
        StringBuilder accountBuilder = new StringBuilder();
@@ -347,6 +357,107 @@
    @Override
    public List<String> getAllWhiteList() {
        return lambdaQuery().select(XpWhitelist::getAccount).list()
                .stream().map(XpWhitelist::getAccount).collect(Collectors.toList());
                .stream().map(XpWhitelist::getAccount)
                .map(SensitiveDataCryptoUtil::decryptIfPossible)
                .collect(Collectors.toList());
    }

    private static List<String> buildQueryValues(Iterable<String> plainValues) {
        Set<String> values = new LinkedHashSet<>();
        if (plainValues == null) {
            return new ArrayList<>();
        }
        for (String plainValue : plainValues) {
            if (StringUtils.hasLength(plainValue)) {
                values.addAll(SensitiveDataCryptoUtil.queryValues(plainValue));
            }
        }
        return new ArrayList<>(values);
    }

    @Override
    public XpWhitelist getById(Serializable id) {
        XpWhitelist whitelist = super.getById(id);
        decryptWhitelistAccount(whitelist);
        return whitelist;
    }

    @Override
    public boolean save(XpWhitelist entity) {
        encryptWhitelistAccount(entity);
        try {
            return super.save(entity);
        } finally {
            decryptWhitelistAccount(entity);
        }
    }

    @Override
    public boolean saveBatch(java.util.Collection<XpWhitelist> entityList) {
        if (entityList != null) {
            entityList.forEach(this::encryptWhitelistAccount);
        }
        try {
            return super.saveBatch(entityList);
        } finally {
            decryptWhitelistAccounts(entityList);
        }
    }

    @Override
    public boolean updateById(XpWhitelist entity) {
        encryptWhitelistAccount(entity);
        try {
            return super.updateById(entity);
        } finally {
            decryptWhitelistAccount(entity);
        }
    }

    @Override
    public boolean updateBatchById(java.util.Collection<XpWhitelist> entityList) {
        if (entityList != null) {
            entityList.forEach(this::encryptWhitelistAccount);
        }
        try {
            return super.updateBatchById(entityList);
        } finally {
            decryptWhitelistAccounts(entityList);
        }
    }

    @Override
    public List<XpWhitelist> list(Wrapper<XpWhitelist> queryWrapper) {
        List<XpWhitelist> list = super.list(queryWrapper);
        decryptWhitelistAccounts(list);
        return list;
    }

    @Override
    public List<XpWhitelist> list() {
        List<XpWhitelist> list = super.list();
        decryptWhitelistAccounts(list);
        return list;
    }

    private void encryptWhitelistAccount(XpWhitelist whitelist) {
        if (whitelist != null) {
            whitelist.setAccount(SensitiveDataCryptoUtil.encrypt(whitelist.getAccount()));
        }
    }

    private static void decryptWhitelistAccount(XpWhitelist whitelist) {
        if (whitelist != null) {
            whitelist.setAccount(SensitiveDataCryptoUtil.decryptIfPossible(whitelist.getAccount()));
        }
    }

    private static void decryptWhitelistAccounts(Iterable<XpWhitelist> list) {
        if (list == null) {
            return;
        }
        for (XpWhitelist item : list) {
            decryptWhitelistAccount(item);
        }
    }
}