Improve wording for transactional rollback rule semantics

[cenlm]

The description in the Rollback Rules section contains an error:

"When a rollback rule is defined with an exception type, that type will be used to match against the type of a thrown exception and its super types, providing type safety and avoiding any unintentional matches that may occur when using a pattern. For example, a value of jakarta.servlet.ServletException.class will only match thrown exceptions of type jakarta.servlet.ServletException and its subclasses."

The phrase "and its super types" should be corrected to "and its subtypes".

Corrected English Version:

"When a rollback rule is defined with an exception type, that type will be used to match against the type of a thrown exception and its subtypes, providing type safety and avoiding any unintentional matches that may occur when using a pattern. For example, a value of jakarta.servlet.ServletException.class will only match thrown exceptions of type jakarta.servlet.ServletException and its subclasses."

Document Url: https://docs.spring.io/spring-framework/reference/data-access/transaction/declarative/rolling-back.html

Related Issues

• Support type-safe transaction rollback rules #28098
• Document that transaction rollback rules may result in unintentional matches #28125

[sbrannen]

Hi @cenlm,

Congratulations on opening your first issue for the Spring Framework! 👍

The current wording is correct.

When a rollback rule is defined with an exception type, that type will be used to match against the type of a thrown exception and its super types,

The configured exception type (C) will be used to match against the thrown exception type (T) as well as any super types of T, up to and including C.

The matching algorithm does not need to concern itself with subtypes of T.

This is evident in the implementation of RollbackRuleAttribute.getDepth(Throwable).

spring-framework/spring-tx/src/main/java/org/springframework/transaction/interceptor/RollbackRuleAttribute.java

Lines 165 to 187 in 4791565

	public int getDepth(Throwable exception) {
	return getDepth(exception.getClass(), 0);
	}
	private int getDepth(Class<?> exceptionType, int depth) {
	if (this.exceptionType != null) {
	if (this.exceptionType.equals(exceptionType)) {
	// Found it!
	return depth;
	}
	}
	else if (exceptionType.getName().contains(this.exceptionPattern)) {
	// Found it!
	return depth;
	}
	// If we've gone as far as we can go and haven't found it...
	if (exceptionType == Throwable.class) {
	return -1;
	}
	return getDepth(exceptionType.getSuperclass(), depth + 1);
	}

However, I can see how the current wording can be confusing.

Thus, I will repurpose this issue to improve the wording.