How can you add constraints in Java?

Constraints in Java can be implemented in various ways depending on the context:

At the data level (POJO/Beans): Using annotations from Bean Validation (JSR 380), such as @NotNull, @Size, @Min, @Max, @Pattern, @Valid, etc. These annotations are processed by frameworks (e.g., Spring, Hibernate Validator) for data validation upon receipt or before saving.

// Example of using Bean Validation annotations
public class User {
    @NotNull(message = "Name cannot be empty")
    @Size(min = 2, max = 50, message = "Name must be between 2 and 50 characters")
    private String name;

    @Min(value = 18, message = "Age must be at least 18")
    private int age;

    // getters and setters
}

At the database level: Constraints can be defined in the database schema (e.g., NOT NULL, UNIQUE, PRIMARY KEY, FOREIGN KEY, CHECK). These constraints are enforced by the DBMS itself and are the most reliable way to ensure data integrity.
```
-- Example SQL DDL for adding constraints
CREATE TABLE products (
    id INT PRIMARY KEY,
    name VARCHAR(255) NOT NULL UNIQUE,
    price DECIMAL(10, 2) CHECK (price >= 0)
);
```

At the application logic level: Implementing checks and validation in the application code (e.g., in service or controller layers). This can be manual condition checks or using specialized validators.

// Example of manual check in code
public void processOrder(Order order) {
    if (order.getItems().isEmpty()) {
        throw new IllegalArgumentException("Order cannot be empty");
    }
    // further processing logic
}

At the access level (security): Using security mechanisms (e.g., Spring Security) to restrict access to resources (URLs, methods) based on roles, permissions, or other conditions.
```
// Example of Spring Security annotation
@PreAuthorize("hasRole('ADMIN')")
public void deleteUser(Long userId) {
    // user deletion logic
}
```

At the type level (generics): Restricting the types that can be used with generic classes or methods.

// Example of generics with type restriction
public <T extends Number> double sum(T a, T b) {
    return a.doubleValue() + b.doubleValue();
}

The choice of method depends on the type of constraint, the level at which it should be applied, and the frameworks used. Often, combinations of these approaches are used to ensure a reliable constraint system.