Java desenvolve um método para atualizar de forma inteligente a lista List<YourEntity> com List<String> como condição de filtro (com código de combate real)

texto:

Em projetos reais de desenvolvimento de software, muitas vezes é necessário atualizar e manter a lista de desenvolvedores. Este artigo apresentará como usar Java para escrever um método inteligente para executar operações de exclusão e adição em lote na lista de desenvolvedores de acordo com os requisitos. Ao mesmo tempo, para facilitar a compreensão, anexaremos exemplos de códigos específicos.

fundo

Digamos que temos uma lista que armazena IDs de usuário desenvolvedor userListe uma tabela de banco de dados stProjectDevelopmentsque contém registros relacionados a desenvolvedores. Nosso objetivo é manter o registro consistente com o ID do usuário em userList, com base nas atualizações de .stProjectDevelopmentsuserList

1. Soluções

Implementaremos esse método de atualização inteligente da seguinte maneira:

1. Obtenha um registro existente

Primeiro, usamos uma operação de consulta ao banco de dados stProjectDevelopmentspara obter todos os registros da tabela e armazená-los em stProjectDevelopmentsuma lista.

//查询该项目下的所有开发人员
LambdaQueryWrapper<StProjectDevelopment> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(StProjectDevelopment::getProjectId,projectId);
List<StProjectDevelopment> stProjectDevelopments = stProjectDevelopmentMapper.selectList(wrapper);

2. Exclua usuários redundantes

Em seguida, precisamos excluir registros redundantes no banco de dados, ou seja, usuários que existem stProjectDevelopmentsna lista, mas não . userListPara conseguir isso, comparamos existingUserIds( stProjectDevelopmentslista de IDs de usuário extraída da lista) e userList, e descobrimos qual lista de IDs de usuário precisa ser excluída userIdsToDelete.

Aqui está um exemplo de código para excluir usuários redundantes:

List<StProjectDevelopment> developmentsToDelete = stProjectDevelopments.stream()
    .filter(development -> !userList.contains(development.getUserId()))
    .collect(Collectors.toList());

if (!developmentsToDelete.isEmpty()) {
    
    
    List<Integer> idsToDelete = developmentsToDelete.stream()
        .map(StProjectDevelopment::getId)
        .collect(Collectors.toList());

    stProjectDevelopmentMapper.deleteBatchIds(idsToDelete);
}

3. Adicione usuários ausentes

Agora, precisamos adicionar usuários userListque existem, mas stProjectDevelopmentsestão faltando na lista. Semelhante à operação de exclusão, comparamos userListe existingUserIdsdescobrimos a lista de IDs de usuário que precisam ser adicionados userIdsToAdd.

Aqui está um exemplo de código para adicionar um usuário ausente:

List<String> userIdsToAdd = userList.stream()
    .filter(userId -> !existingUserIds.contains(userId))
    .collect(Collectors.toList());

if (!userIdsToAdd.isEmpty()) {
    
    
    List<StProjectDevelopment> newDevelopments = userIdsToAdd.stream()
        .map(userId -> {
    
    
            StProjectDevelopment development = new StProjectDevelopment();
            development.setUserId(userId);
            // 设置其他字段的初始值
            return development;
        })
        .collect(Collectors.toList());

    stProjectDevelopmentMapper.insertBatch(newDevelopments);
}

2. Exemplo de código

Aqui está um exemplo completo que demonstra como agrupar a solução acima em um único método:

/**
  * 筛选修改的开发人员
  *
  * @param userList  原项目开发用户列表
  * @param projectId 项目ID
  * @author yangz
  * @date 2023/07/12
  */
public void updateStProjectDevelopments(List<String> userList,String projectId, String currentUserId) {
    
    
    //查询该项目下的所有开发人员
    LambdaQueryWrapper<StProjectDevelopment> wrapper = new LambdaQueryWrapper<>();
    wrapper.eq(StProjectDevelopment::getProjectId,projectId);
    List<StProjectDevelopment> stProjectDevelopments = stProjectDevelopmentMapper.selectList(wrapper);

    //筛选出所有的userId列表
    List<String> existingUserIds = stProjectDevelopments.stream()
        .map(StProjectDevelopment::getUserId)
        .collect(Collectors.toList());

    // 删除多余的用户
    List<StProjectDevelopment> developmentsToDelete = stProjectDevelopments.stream()
        .filter(development -> !userList.contains(development.getUserId()))
        .collect(Collectors.toList());
    if (!developmentsToDelete.isEmpty()) {
    
    
        List<String> userIdsToDelete = developmentsToDelete.stream()
            .map(StProjectDevelopment::getId)
            .collect(Collectors.toList());
        stProjectDevelopmentMapper.deleteBatchIds(userIdsToDelete);
    }

    // 新增缺少的用户
    List<String> userIdsToAdd = userList.stream()
        .filter(userId -> !existingUserIds.contains(userId))
        .collect(Collectors.toList());
    if (!userIdsToAdd.isEmpty()) {
    
    
        List<StProjectDevelopment> newDevelopments = userIdsToAdd.stream()
            .map(userId -> {
    
    
                StProjectDevelopment development = new StProjectDevelopment();
                //对象参数赋值
                stProjectDevelopmentSetParam(currentUserId, projectId, userId, development);
                return development;
            })
            .collect(Collectors.toList());
        stProjectDevelopmentMapper.batchInsert(newDevelopments);
    }
}

Resumir

No desenvolvimento real do projeto, esse método inteligente de atualização de lista pode nos ajudar a lidar com as alterações do desenvolvedor com mais eficiência e manter a consistência dos registros do banco de dados. Usando o código de exemplo, você pode entender e aplicar melhor as soluções deste artigo.

Espero que este artigo ajude você a escrever um método de atualização de lista de desenvolvedores eficiente e inteligente!