A detailed explanation of common annotation extension comparison examples for Java

1. Comparison between @Controller and @RestController

2. Comparison between using @Data and not using @Data

Things to note：

• use@DataWhen  , if the class has an inheritance relationship, you need to add@EqualsAndHashCode(callSuper=true)
• Some scenarios (such as JPA entity classes) need to explicitly define the parameterless constructor (by@NoArgsConstructor）

3. Comparison between using @TableName and not using @TableName

Things to note：

• The table name contains SQL keywords and needs to be escaped:@TableName("order")
• The table sub-table scenario can be accessed through the dynamic table name processor (TableNameHandler)accomplish

4. Comparison of dependency injection annotation

Code Example：

// @Autowired + @Qualifier
@Autowired 
@Qualifier("mysqlDataSource")
private DataSource dataSource;

// @Resource
@Resource(name = "oracleDataSource")
private DataSource dataSource;

5. Comparison of Spring MVC parameter binding annotations

Code Example：

// PathVariable
@GetMapping("/users/{id}")
public User getUser(@PathVariable Long id) { ... }

// RequestBody
@PostMapping("/users")
public ResponseEntity<?> createUser(@RequestBody UserDTO userDTO) { ... }

6. Comparison of JPA/Hibernate mapping annotation

Code Example：

@Entity
@Table(name = "departments")
public class Department {
    @OneToMany(mappedBy = "department")
    private List<Employee> employees;
}

@Entity
public class Employee {
    @ManyToOne
    @JoinColumn(name = "dept_id")
    private Department department;
}

7. Comparison of Spring Boot configuration annotations

Configuration example：

# 
app:
  security:
    enabled: true
    timeout: 300

Code implementation：

@Configuration
@ConfigurationProperties(prefix = "")
public class SecurityConfig {
    private boolean enabled;
    private int timeout;
    // getters/setters
}

8. Lombok annotation comparison

Code Example：

@Value
@Builder
public class ImmutablePoint {
    private final int x;
    private final int y;
}

// useImmutablePoint point = ().x(10).y(20).build();

9. Comparison of transaction management annotations

Code Example：

@Service
public class UserService {
    @Transactional
    public void updateUser(User user) {
        (user);
    }
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    @Modifying
    @Query("UPDATE User u SET  = ?1 WHERE  = ?2")
    int updateNameById(String name, Long id);
}

10. Comparison of test-related annotations

Test Example：

// Full integration test@SpringBootTest
class UserServiceIntegrationTest {
    @Autowired
    private UserService userService;
}

// Control layer testing@WebMvcTest()
class UserControllerTest {
    @MockBean
    private UserService userService;
    @Autowired
    private MockMvc mockMvc;
}

Comprehensive comparison summary table

Best Practice Recommendations

• Layered useStrictly follow the Controller→Service→Repository hierarchical architecture to avoid the use of cross-layer annotations.

• Minimize annotation

  • Preferential use of combined annotations provided by the framework (e.g.@RestControllerreplace@Controller+@ResponseBody）
  • Avoid repeated annotations (such as using them at the same time@Componentand@Service）

• Lombok specifications

  • Uniform use of entity classes@Data + @Builder
  • Disable unconstrained@AllArgsConstructor

• Transaction control

  • Service layer unified statement@Transactional(readOnly = true)
  • Explicitly specified write operations@Transactional(rollbackFor = )

• Test isolation

  • Unit testing using Mockito + JUnit5
  • Integration Testing on Demand Selection@WebMvcTestor@DataJpaTest

Through systematic annotation comparison and combination use, code standardization and team collaboration efficiency can be significantly improved. It is recommended to combine code quality management tools such as SonarLint to ensure the rationality and consistency of the use of annotations.

Summarize

This is the end of this article about comparing Java common annotation extensions. For more related Java common annotation extensions, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!