Hibernate JPA异常：查询语句竟增删多对多映射表数据

Alright, let's break down why you're seeing unexpected inserts/deletes in your SECURITY_USER_ROLE junction table when executing that named query, and walk through actionable fixes:

1. Audit Your Many-to-Many Cascade Settings #

This is the most common culprit. If your securityRoles association in SecurityUser has overly broad cascade types (like CascadeType.ALL, CascadeType.PERSIST, or CascadeType.REMOVE), Hibernate might be propagating unintended changes to the junction table when it loads entities via the join fetch query.

For a typical user-role relationship, you rarely need cascading operations on the junction table—roles are usually standalone entities that shouldn't be created/deleted just because a user is modified.

Fix: Update your @ManyToMany annotation to remove unnecessary cascades:

@ManyToMany(fetch = FetchType.LAZY)
@JoinTable(
    name = "SECURITY_USER_ROLE",
    joinColumns = @JoinColumn(name = "USER_ID"),
    inverseJoinColumns = @JoinColumn(name = "ROLE_ID")
)
private Set<SecurityRole> securityRoles = new HashSet<>();

If you absolutely need cascading (e.g., detaching roles when a user is detached), use targeted types like CascadeType.DETACH or CascadeType.MERGE—never CascadeType.REMOVE or ALL here.

2. Ensure You're Not Accidentally Modifying the Loaded Collection #

When you use join fetch to load the securityRoles collection, Hibernate brings those entities into the persistence context. If your code later modifies this collection (even inadvertently, like adding/removing roles without realizing), Hibernate's dirty-checking mechanism will sync those changes to the database when the transaction commits—this includes altering the junction table.

Fixes:

• Use a DTO projection instead of loading full entities if you only need read-only data. This avoids loading mutable collections entirely:

  @NamedQuery(
      name = SecurityUser.GET_ALL_USERS_WITH_ROLES_DTO,
      query = "select new com.yourpackage.UserDTO(u.id, u.username, r.roleName, l.languageCode) from SecurityUser u join u.securityRoles r join u.userLanguage l"
  )
  

• Detach entities immediately after querying if you don't need to modify them:

  List<SecurityUser> users = entityManager.createNamedQuery(SecurityUser.GET_ALL_USERS_WITH_ROLES, SecurityUser.class)
      .getResultList();
  users.forEach(entityManager::detach);
  

3. Validate Bidirectional Association Ownership #

If SecurityRole has a reverse association back to SecurityUser, make sure the reverse end is correctly marked as the non-owning side. The owning side of a many-to-many relationship is the one that defines the @JoinTable—the reverse side should use mappedBy to point to the owning side's field.

If you accidentally configure the reverse side as the owning side, modifying the SecurityUser collection in SecurityRole will trigger changes to the junction table.

Fix: Ensure your SecurityRole association looks like this:

@ManyToMany(mappedBy = "securityRoles")
private Set<SecurityUser> users = new HashSet<>();

Always modify the owning side (SecurityUser.securityRoles) when you need to update user-role relationships—never the reverse side.

4. Use Read-Only Transactions & Disable Auto-Flush #

Hibernate automatically flushes the persistence context before executing queries to ensure data consistency. If there are uncommitted changes in the context (even from unrelated operations), this flush might accidentally modify the junction table.

Fixes:

• Mark your query method as @Transactional(readOnly = true)—this tells Hibernate to optimize for read operations, reducing dirty-checking and preventing accidental writes:

  @Transactional(readOnly = true)
  public List<SecurityUser> getAllUsersWithRoles() {
      return entityManager.createNamedQuery(SecurityUser.GET_ALL_USERS_WITH_ROLES, SecurityUser.class)
          .getResultList();
  }
  

• Explicitly set the flush mode to COMMIT or NEVER for the query to avoid pre-query flushes:

  List<SecurityUser> users = entityManager.createNamedQuery(SecurityUser.GET_ALL_USERS_WITH_ROLES, SecurityUser.class)
      .setFlushMode(FlushModeType.COMMIT)
      .getResultList();
  

Start with checking your cascade settings—nine times out of ten, that's the root cause. If that doesn't resolve it, move on to verifying collection modifications and association ownership.

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