Descrição do background: Geralmente, se você precisar atualizar vários dados por vez, há duas maneiras de atualizá -los uma a uma. (1) Longar o código comercial para atualizar um por um. (2) Atualize todos os dados de uma só vez (para serem mais precisos, é uma instrução SQL para atualizar todos os dados, colocar as operações de atualização um por um no lado do banco de dados e o lado do código comercial é atualizar todos os dados de uma só vez). Os dois métodos têm seus prós e contras. A seguir, analisará brevemente os prós e contras dos dois métodos e apresentará principalmente a implementação do segundo método em Mybatis.
Atualizar um por um
Esse método é obviamente o mais simples e menos propenso a erros. Mesmo que ocorra um erro, ele afeta apenas os dados de erro. Pode ser controlado por cada peça de dados. Se a atualização falhar ou ter sucesso, ela poderá ser obtida de qual conteúdo é atualizado para qual conteúdo. O código pode ser assim:
updateBatch(List<MyData> datas){ for(MyData data: datas){ try{ myDataDao.update(data);//Update a data, update of the xml file below in mybatis } catch(Exception e){ ...//If the update fails, you can do some other operations, such as printing an error log, etc.} }}//Implementation of update operation in mybatis <putate> atualize myData Set ... onde ... </puta>O maior problema com esse método é o problema de eficiência. Ele atualiza um por um e se conecta ao banco de dados a cada vez, depois atualiza e libera os recursos de conexão (embora a eficiência de dados frequentemente conectados possa ser bastante aprimorada através do pool de conexões, que não pode suportar a grande quantidade de dados). Essa perda refletirá o problema da eficiência quando a quantidade de dados for grande. É também quando atende às necessidades comerciais, a segunda implementação de atualização em lote mencionada acima é geralmente usada (é claro, esse método também possui limitações de escala de dados, que serão mencionadas posteriormente).
Atualização em lote SQL
Uma instrução SQL é usada para atualizar todos os dados em lotes. Vamos dar uma olhada em como geralmente é escrito em mybatis (remover a sintaxe mybatis é a instrução SQL nativa, para que não falo sobre como ela é escrita no SQL).
<update id = "updateBatch" parameterType = "java.util.list"> atualize mydata_table set status = <foreach collection = "list" item = "item" index = "index" separator = "" abeto = "case id" close = "end"> quando # # # #when. item = "Item" separador = "," Open = "(" Close = ")"> #{item.id, jdbctype = bigint} </foueach>onde quando ... então ... a sintaxe do "interruptor" no SQL. Aqui, a sintaxe <foreach> do mybatis é usada para reunir a atualização do lote SQL. O exposto acima significa que o campo de status dos dados passados na lista de ID no parâmetro UpdateBatch é atualizado em lote. Você também pode usar <fort> para implementar a mesma função, o código é o seguinte:
<update id = "updateBatch" parameterType = "java.util.list"> atualize mydata_table <TRIM prefix = "set" suffixOverrides = ","> <trim prefix = "status = case" suffix = "end ="> <foreach collection = "item" = " #" index = "quando" quando "quando" # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #) </foreach> </rod> </rod> where id in <foreach collection = "list" index = "index" item = "item" separator = "," open = "(" close = ")"> #{item.id, jdbctype = bigint} </foreEach> </atualização><NuDM> Descrição da propriedade
1.Prefix, sufixo significa adicionar conteúdo na frente ou após a peça embrulhada na etiqueta de acabamento
2. Se houver prefixarrides ao mesmo tempo, o sufixo -soma significa que o conteúdo nas substituições será substituído por prefixo e sufixo.
3. Se apenas prefixar os gritos, o sufixoverrides significa excluir o conteúdo especificado por XXXoverídeos no início ou no final.
O código acima é convertido em SQL da seguinte forma:
Atualize mydata_table set status = case quando id = #{item.id} então #{item.status} // Este deve ser o <foreach> expandir o valor ... termine onde id em (...);Obviamente, esta é a implementação de atualização de lote mais fácil. Às vezes, vários campos podem precisar ser atualizados, então você precisa
<TRIM prefix = "status = case" suffix = "end"> <foreach collection = "list" item = "item" index = "index"> Quando id = #{item.id} então #{item.status} </foreach> </rod>Copie várias vezes, altere o conteúdo do prefixo e quando ... então ... e se você precisar definir o valor padrão para um determinado campo, poderá usar outro
<TRIM prefix = "status = case" suffix = "end"> <foreach collection = "list" item = "item" index = "index"> quando id = #{item.id} então #{item.status} </ -foreach> else default_value </rodle>Há também uma situação mais comum em que os dados a serem atualizados precisam ser julgados e apenas dados que atendem às condições podem ser atualizados. Esta situação pode ser feita:
<TRIM prefix = "status = case" suffix = "end"> <foreach collection = "list" item = "item" index = "index"> <if test = "item.status!
Nesse caso, apenas status != null && status != -1 Dados na lista a ser atualizado podem ser atualizados. Outros serão atualizados com valores padrão, sem manter os dados originais inalterados. E se você quiser manter os dados originais inalterados? Ou seja, atualizações que atendem às condições e aquelas que não atendem às condições permanecem inalteradas. Uma maneira simples de fazer isso é adicionar outro <se>, porque não há se ... else ... sintaxe em mybatis, mas o mesmo efeito pode ser alcançado através de múltiplos <se>, da seguinte forma:
<TRIM prefix = "status = case" suffix = "end"> <foreach collection = "list" item = "item" index = "index"> <if test = "item.status! id =#{item.id} Então mydata_table.status // esses são os dados originais </if> </foreach> </avim>A atualização geral do lote está escrita da seguinte maneira:
<update id = "updateBatch" parameterType = "java.util.list"> atualize mydata_table <trim prefix = "set" suffixOverrides = ","> <trim prefix = "status = case" suffix = "end"> <foreach collection = "item" = "item! Quando id =#{item.id} então#{item.status} </if> <if test = "item.status == null ou item.status == -1"> Quando id =#{item.id} então mydata_table.status // dados originais </if> </foreAching> </trim> separador = "," Open = "(" Close = ")"> #{item.id, jdbctype = bigint} </foreEach> </putaEsse método de banco de dados em lote e núcleo pode atualizar todos os dados em uma conexão de banco de dados, evitando a sobrecarga do estabelecimento e desconexão frequentes do banco de dados e melhorando bastante a eficiência da atualização de dados. No entanto, o problema é que, se ocorrer um erro de atualização durante esse processo, será difícil saber quais dados estão errados. Se a garantia de transação dos dados for usada, depois que ocorrer um erro, todas as atualizações serão revertidas automaticamente. E esse método geralmente é mais propenso a erros. Portanto, a solução usual é fazer compromissos, isto é, atualizar parte dela em lotes (a paginação é feita, por exemplo, há um total de 1.000 dados e 100 dados são atualizados por vez). Isso pode compartilhar a probabilidade de erros e é mais fácil localizar o erro.
Obviamente, se a quantidade de dados for realmente grande, esta atualização em lote também levará a atualizações ineficientes (por exemplo, se 100 itens forem atualizados por vez, se 1 bilhão de dados for atualizado, 10 milhões de vezes serão necessários para atualizar 10 milhões de vezes, e 10 milhões de bancos de dados serão estabelecidos e desconectados, o que é injetável). Neste momento, você só pode considerar outras soluções, como a introdução de um mecanismo de cache.
Resumir
O exposto acima é o lote UpdateBatch introduzido pelo editor usando o UpdateBatch no mybatis. Espero que seja útil para todos. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a todos a tempo. Muito obrigado pelo seu apoio ao site wulin.com!