Great question! Your current approach is totally valid for achieving the "upsert" (update or insert) behavior based on a non-primary key field like codigo—let's break down how it works, plus some optimizations and alternative approaches you might find useful.

Your Existing Solution: Valid and Functional #

First off, the code you've written is a solid way to handle this scenario:

1. You use a custom @Query with @Modifying and @Transactional to execute an UPDATE statement targeting records with a matching codigo.
2. Checking the return value (number of updated rows) lets you know if a matching record existed:
   • If resultadoUpdate == 0, no record with that codigo exists, so you call save() to insert a new one.
   • If it's greater than 0, the existing record was updated successfully.

A few notes on your implementation:

• The clearAutomatically = true on @Modifying is a great touch—it prevents stale data from lingering in the persistence context after the update, which avoids unexpected behavior down the line.
• Using SpEL expressions (:#{#concepto.getDescripcion()}) to bind properties from your Concepto object is perfectly acceptable. You can even simplify this syntax if your entity has proper getters: just use :#{#concepto.descripcion} instead of calling the getter explicitly.

Here's the simplified query for reference:

@Transactional 
@Modifying(clearAutomatically = true) 
@Query("UPDATE Concepto c SET c.idBui = :#{#concepto.idBui}," + 
"c.descripcion = :#{#concepto.descripcion}," + 
"c.admiteReglas = :#{#concepto.admiteReglas}," + 
"c.tieneCantidadFija = :#{#concepto.tieneCantidadFija}," + 
"c.tieneValorFijo = :#{#concepto.tieneValorFijo}," + 
"c.vigencia = :#{#concepto.vigencia}," + 
"c.valor = :#{#concepto.valor}, " + 
"c.detalles = :#{#concepto.detalles}" + 
" WHERE c.codigo = :#{#concepto.codigo}") 
int updateConcepto(@Param("concepto") Concepto concepto); 

Alternative Approach: Query-then-Save (JPA Entity Lifecycle Style) #

If you prefer working with JPA's entity management instead of writing raw UPDATE queries, you can first check for an existing record by codigo, then update or insert accordingly:

// First, add a findByCodigo method to your repository
Optional<Concepto> findByCodigo(String codigo);

// Then use it in your service logic
Optional<Concepto> existingConcepto = conceptoJpaRepository.findByCodigo(concepto.getCodigo());
if (existingConcepto.isPresent()) {
    // Copy new properties to the existing managed entity
    Concepto toUpdate = existingConcepto.get();
    toUpdate.setIdBui(concepto.getIdBui());
    toUpdate.setDescripcion(concepto.getDescripcion());
    toUpdate.setAdmiteReglas(concepto.getAdmiteReglas());
    // ... copy all other required properties
    conceptoJpaRepository.save(toUpdate); // Triggers update since entity has a PK
} else {
    conceptoJpaRepository.save(concepto); // Triggers insert
}

This approach leverages JPA's built-in persistence context, so you don't have to write custom UPDATE statements. The tradeoff is an extra database query to check for the existing record—if you're working in a high-concurrency environment, you might want to add a lock (e.g., findByCodigoForUpdate()) to prevent race conditions.

Bonus: Encapsulate Logic in a Custom Repository Method #

To keep your service layer clean, you can encapsulate this upsert logic directly in your repository by creating a custom implementation:

1. Define a custom repository interface:

public interface ConceptoCustomRepository {
    Concepto saveByCodigo(Concepto concepto);
}

2. Extend your main repository interface:

public interface ConceptoJpaRepository extends JpaRepository<Concepto, Long>, ConceptoCustomRepository {
    int updateConcepto(@Param("concepto") Concepto concepto);
    Optional<Concepto> findByCodigo(String codigo);
}

3. Implement the custom logic:

@Transactional
public class ConceptoCustomRepositoryImpl implements ConceptoCustomRepository {

    private final ConceptoJpaRepository conceptoJpaRepository;

    // Constructor injection (preferred over @Autowired)
    public ConceptoCustomRepositoryImpl(ConceptoJpaRepository conceptoJpaRepository) {
        this.conceptoJpaRepository = conceptoJpaRepository;
    }

    @Override
    public Concepto saveByCodigo(Concepto concepto) {
        int updatedRows = conceptoJpaRepository.updateConcepto(concepto);
        if (updatedRows == 0) {
            return conceptoJpaRepository.save(concepto);
        }
        // Return the updated entity (optional, depending on your needs)
        return conceptoJpaRepository.findByCodigo(concepto.getCodigo()).orElse(concepto);
    }
}

Now you can call conceptoJpaRepository.saveByCodigo(concepto) directly from your service, keeping all the upsert logic contained in the repository layer.

Final Verdict #

Your original implementation is perfectly valid and efficient (since it avoids an extra query). The alternatives offer more idiomatic JPA usage or cleaner code organization—choose the one that best fits your team's coding style and performance requirements.

内容的提问来源于stack exchange，提问作者Eduardo Parra