Write Less Code.
Ship Better Software.

@Entity
@Getter
@Setter
public class Person {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @CreatedBy
    private String createdBy;

    @CreatedDate
    @Temporal(TemporalType.TIMESTAMP)
    @Column(columnDefinition = "TIMESTAMP WITH TIME ZONE")
    private Date createdDate;

    @LastModifiedBy
    private String lastModifiedBy;

    @LastModifiedDate
    @Temporal(TemporalType.TIMESTAMP)
    @Column(columnDefinition = "TIMESTAMP WITH TIME ZONE")
    private Date lastModifiedDate;

    @Column(unique = true)
    private Long uid;

    private String firstName;
    private String lastName;
    private OffsetDateTime birthDate;

    /**
     * Hash code based on the primary key.
     * Ref: https://stackoverflow.com/questions/5031614
     */
    @Override
    public int hashCode() {
        // If the ID is null, fall back to object identity
        if (id == null) {
            return super.hashCode();
        }
        return Objects.hashCode(id);
    }

    /**
     * Equals based on the primary key.
     * Ref: https://stackoverflow.com/questions/5031614
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;

        // Fix for comparing transient and proxied entities
        Class<?> c1 = Hibernate.getClass(this);
        Class<?> c2 = Hibernate.getClass(obj);
        if (!c1.equals(c2))
            return false;

        BaseEntity other = (BaseEntity) obj;

        // If the IDs are null, fall back to object identity
        if (id == null || other.getId() == null) {
            return super.equals(obj);
        }
        return Objects.equals(this.getId(), other.getId());
    }

    /**
     * To String based on the primary key.
     */
    @Override
    public String toString() {
        return new ToStringBuilder(this)
                .append("id", this.getId())
                .toString();
    }
}

// Plus a class that implements
// org.springframework.data.domain.AuditorAware

@PreAuthorize("hasAuthority('permission')")
@SecurityRequirement(name = "JWT")
public void operation(
    @AuthenticationPrincipal(expression =
        "#this instanceof T(org.springframework
            .security.oauth2.jwt.Jwt)
            ? claims['name'] : null")
    @Parameter(hidden = true)
    String name) {

}

package ....any.arbitrary.subpackage;

@RequestMapping("<prefix>/group/operationName.v1")
public class OperationNameControllerV1 {

    @GetMapping
    @Tag(name = "group")
    public ReturnModel handle() {

    }
}

// You implement all the following for backend microservices:

// 1. SecurityFilterChain bean that enables
//    OAuth2 ResourceServer authorization via JWT

// 2. Disable form login, BASIC auth and CSRF

// 3. CORS Filter for mobile + credentialed requests

// 4. Activate method security
//    (@PreAuthorize and @PostAuthorize)

// 5. Enable meta-annotation templating
//    for method security

// 6. JwtAuthenticationConverter for loading
//    authorities from JWT claim (e.g., "roles")

// 7. Bearer Swagger security scheme
//    (e.g., "JWT") for OpenAPI

// 8. Post-processing filter to feed MDC
//    with user data (enriched logging)

// 9. Post-processing filter to enhance the Spring
//    authentication token with web data
//    (e.g., IP from "X-Forwarded-For" header)