Spring Boot

  // within main method
  ApplicationContext apc = SpringApplication.run(ClassName.class)
  for (String s : apc.getBeanDefinitionNames()) {
    System.out.println(s);
  }

// mapper
  // UserMapper.java
@Mapper
public interface UserMapper extends BaseMapper<User> { // User has to be same as table name within database
}

// controller
  // UserController
@RestController
public class UserController {
  @Autowired
  private UserMapper userMapper;

  @GetMapping("/user")
  public List query() {
    List<User> list = userMapper.selectList(null);
    return list; // automatically convert to json
  }

  @PostMapping("/user")
  public String save(User user) {
    int i = userMapper.insert(user); // i is the number of rows inserted
    if (i > 0) {
      return "successfully inserted";
    } else {
      return "insertation failed";
    }
  }
}

@ToString(callSuper = true, exclude = "user") 
public class Profile { ... }

@EqualsAndHashCode(callSuper = true, onlyExplicitlyIncluded = true)
public class User {
    @EqualsAndHashCode.Include private final Long id; // Immutable ID only
}

@NoArgsConstructor(access = AccessLevel.PROTECTED) // JPA-safe
public class Entity { ... }

@Service
@RequiredArgsConstructor // Injects final dependencies
public class OrderService {
    private final OrderRepository repo;
}

@AllArgsConstructor // For non-persistent objects
public record ProductDto(String id, String name) {}

@Data // Only for simple POJOs with no inheritance
public class Config {
    private String apiKey;
    private int timeout;
}

@Value // Immutable class
public class Point {
    int x;
    int y;
}

@Builder
public class Widget {
    @Builder.Default private String type = "DEFAULT"; 
    private final int id;
}

@Slf4j
public class OrderService {
    void process() {
        log.info("Order processed"); // Injects 'log'
    }
}

@SneakyThrows(IOException.class) // Rarely justified
public void unsafeOperation() { ... }

@Entity
@Getter @Setter // Safe
public class User {
    @ToString.Exclude private byte[] passwordHash;
    @EqualsAndHashCode.Exclude @OneToMany private List<Order> orders;
}

@Value
@AllArgsConstructor(access = AccessLevel.PRIVATE) // For Jackson
public class TestDto { ... }

# Fail on warnings
config.stopBubbling = true
lombok.anyConstructor.addConstructorProperties = true

// Equivalent Traditional Class
public final class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int x() { return x; }
    public int y() { return y; }

    // Auto-generated:
    // - equals() (compares all fields)
    // - hashCode() (uses all fields)
    // - toString() (e.g., "Point[x=1, y=2]")
}

public record Point(int x, int y) {
    // Compact constructor (no parameters)
    public Point {
        if (x < 0 || y < 0) 
            throw new IllegalArgumentException("Negative values");
        // Fields auto-assigned after this block
    }
}

public record Point(int x, int y) {
    public double distance() {
        return Math.sqrt(x*x + y*y);
    }
}

public record User(String name) implements Serializable {}

public record User(
    @NotBlank String name,
    @Min(18) int age
) {}

public record ApiResponse<T>(
    int status,
    String message,
    T data
) {
    public ApiResponse {
        Objects.requireNonNull(data);
    }
}

// Usage
ApiResponse<User> response = new ApiResponse<>(200, "OK", user);

@Configuration
public class ModelMapperConfig {
  @Bean
  public ModelMapper modelMapper() {
    return new ModelMapper();
  }
}

@Service
public class UserService {
  private final ModelMapper modelMapper;

  @Autowired
  public UserService(ModelMapper modelMapper) {
    this.modelMapper = modelMapper;
  }

  public UserDTO convertToDto(User user) {
    return modelMapper.map(user, UserDTO.class);
  }
}

modelMapper
  .typeMap(Source.class, Destination.class)
  .addMapping(Source::getFoo, Destination::setBar);

src
└── main
    ├── java
    │   └── com
    │       └── yourcompany
    │           └── yourproject
    │               ├── YourProjectApplication.java
    │               ├── config
    │               │   └── (configuration classes: security, web, etc.)
    │               ├── controller
    │               │   └── (REST/controllers)
    │               ├── dto
    │               │   └── (Data Transfer Objects)
    │               ├── entity
    │               │   └── (JPA entities/domain models)
    │               ├── exception
    │               │   └── (custom exceptions and handlers)
    │               ├── repository
    │               │   └── (Spring Data repositories)
    │               ├── service
    │               │   └── (service layer)
    │               ├── mapper
    │               │   └── (MapStruct/ModelMapper mappers)
    │               ├── util
    │               │   └── (utility/helper classes)
    │               └── (any feature-based packages, e.g., user, order, etc.)
    ├── resources
    │   ├── application.yml
    │   ├── static
    │   │   └── (static web resources)
    │   ├── templates
    │   │   └── (Thymeleaf/Freemarker templates)
    │   └── (other resource files)
    └── test
        └── java
            └── com
                └── yourcompany
                    └── yourproject
                        └── (test classes, mirroring main structure)

└── user
    ├── UserController.java
    ├── UserService.java
    ├── UserRepository.java
    ├── User.java
    ├── UserDto.java
    └── UserMapper.java
└── order
    └── (order-related classes)

package com.yourcompany.yourapp;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;

@Configuration
@EnableAsync
public class AsyncConfig {

  @Bean(name = "taskExecutor")
  public Executor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(4);        // Number of threads to keep in pool
    executor.setMaxPoolSize(10);        // Max threads allowed
    executor.setQueueCapacity(100);     // Queue size before rejecting new tasks
    executor.setThreadNamePrefix("Async-"); // Thread name prefix for easier debugging
    executor.initialize();
    return executor;
  }

  // You can also add an AsyncUncaughtExceptionHandler bean to handle uncaught exceptions from @Async void methods
  @Bean
  public AsyncUncaughtExceptionHandler asyncUncaughtExceptionHandler() {
    return (throwable, method, obj) -> {
      System.err.println("Exception in async method: " + method.getName() + ", message: " + throwable.getMessage());
    };
  }
}

package com.example.validation.config;

import org.kie.api.runtime.KieContainer;
import org.kie.spring.KModuleBeanFactoryPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class KieConfig {
    @Bean
    public KModuleBeanFactoryPostProcessor kiePostProcessor() {
        return new KModuleBeanFactoryPostProcessor();
    }

    @Bean
    public KieContainer kieContainer(org.kie.api.KieServices ks) {
        return ks.getKieClasspathContainer();
    }
}

package com.example.validation.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Configuration
public class VirtualThreadConfig {

    @Bean(destroyMethod = "shutdown")
    public ExecutorService virtualThreadExecutor() {
        // Java 21 virtual thread-per-task executor
        return Executors.newVirtualThreadPerTaskExecutor();
    }
}

@Repository
public class BigTableDao {

    private final JdbcTemplate jdbcTemplate;

    public BigTableDao(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void streamRows(int fetchSize, Consumer<RowData> rowConsumer) {
        jdbcTemplate.setFetchSize(fetchSize);
        jdbcTemplate.setMaxRows(0);

        String sql = "SELECT * FROM big_table"; // no ORDER BY if not required

        jdbcTemplate.query(con -> {
            PreparedStatement ps = con.prepareStatement(
                sql,
                ResultSet.TYPE_FORWARD_ONLY,
                ResultSet.CONCUR_READ_ONLY
            );
            ps.setFetchSize(fetchSize);
            return ps;
        }, rs -> {
            rowConsumer.accept(mapRow(rs));
        });
    }

    private RowData mapRow(ResultSet rs) throws SQLException {
        RowData row = new RowData();
        row.setId(rs.getLong("id"));
        row.setCol1(rs.getString("col1"));
        row.setCol2(rs.getString("col2"));
        // map other columns...
        return row;
    }
}

@Service
public class StreamingValidationService {

    private final BigTableDao bigTableDao;
    private final KieContainer kieContainer;
    private final ValidationResultRepository resultRepository;

    public StreamingValidationService(BigTableDao bigTableDao,
                                      KieContainer kieContainer,
                                      ValidationResultRepository resultRepository) {
        this.bigTableDao = bigTableDao;
        this.kieContainer = kieContainer;
        this.resultRepository = resultRepository;
    }

    public void validateLargeTable() {
        List<RowData> batch = new ArrayList<>(500);

        bigTableDao.streamRows(500, row -> {
            batch.add(row);
            if (batch.size() == 500) {
                processBatch(batch);
                batch.clear();
            }
        });

        if (!batch.isEmpty()) {
            processBatch(batch);
        }
    }

    private void processBatch(List<RowData> batch) {
        List<ValidationResult> allResults = Collections.synchronizedList(new ArrayList<>());

        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Callable<Void>> tasks = new ArrayList<>();

            for (RowData row : batch) {
                tasks.add(() -> {
                    StatelessKieSession kieSession = kieContainer.newStatelessKieSession();

                    List<ValidationResult> results = new ArrayList<>();
                    kieSession.setGlobal("results", results);

                    kieSession.execute(row); // Stateless: runs rules immediately

                    allResults.addAll(results);
                    return null;
                });
            }

            executor.invokeAll(tasks);

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("Batch processing interrupted", e);
        }

        // Single DB write per batch
        resultRepository.bulkInsert(allResults);
    }

}

@Configuration
public class KieConfig {

    private static final List<String> poolDrlList = List.of(
        "rules/poolRule1.drl",
        "rules/poolRule2.drl"
    );

    private static final List<String> loanDrlList = List.of(
        "rules/loanRule1.drl",
        "rules/loanRule2.drl"
    );

    @Bean
    public KModuleBeanFactoryPostProcessor kiePostProcessor() {
        return new KModuleBeanFactoryPostProcessor();
    }

    @Bean(name = "poolKieContainer")
    public KieContainer poolKieContainer(KieServices ks) {
        return createKieContainer(ks, poolDrlList);
    }

    @Bean(name = "loanKieContainer")
    public KieContainer loanKieContainer(KieServices ks) {
        return createKieContainer(ks, loanDrlList);
    }

    private KieContainer createKieContainer(KieServices ks, List<String> drlFiles) {
        KieFileSystem kfs = ks.newKieFileSystem();

        // Minimal KieModule XML
        KieModuleModel kModuleModel = ks.newKieModuleModel();
        kfs.writeKModuleXML(kModuleModel.toXML());

        // Write DRL files to KieFileSystem
        for (String drl : drlFiles) {
            kfs.write("src/main/resources/" + drl, ks.getResources().newClassPathResource(drl));
        }

        KieBuilder kieBuilder = ks.newKieBuilder(kfs).buildAll();

        if (kieBuilder.getResults().hasMessages(org.kie.api.builder.Message.Level.ERROR)) {
            throw new RuntimeException("Error building KIE base: " + kieBuilder.getResults());
        }

        ReleaseId releaseId = kieBuilder.getKieModule().getReleaseId();
        return ks.newKieContainer(releaseId);
    }
}

@Service
public class PoolValidationService {

    private final KieContainer poolKieContainer;

    public PoolValidationService(@Qualifier("poolKieContainer") KieContainer poolKieContainer) {
        this.poolKieContainer = poolKieContainer;
    }

    public void validatePoolData(RowData rowData) {
        try (StatelessKieSession session = poolKieContainer.newStatelessKieSession()) {
            session.execute(rowData);
        }
    }
}

@Service
public class LoanValidationService {

    private final KieContainer loanKieContainer;

    public LoanValidationService(@Qualifier("loanKieContainer") KieContainer loanKieContainer) {
        this.loanKieContainer = loanKieContainer;
    }

    public void validateLoanData(RowData rowData) {
        try (StatelessKieSession session = loanKieContainer.newStatelessKieSession()) {
            session.execute(rowData);
        }
    }
}

@Service
public class ValidationService {

    private final KieContainer poolKieContainer;
    private final KieContainer loanKieContainer;

    public ValidationService(
        @Qualifier("poolKieContainer") KieContainer poolKieContainer,
        @Qualifier("loanKieContainer") KieContainer loanKieContainer
    ) {
        this.poolKieContainer = poolKieContainer;
        this.loanKieContainer = loanKieContainer;
    }

    public void validatePool(RowData poolRow) {
        try (StatelessKieSession session = poolKieContainer.newStatelessKieSession()) {
            session.execute(poolRow);
        }
    }

    public void validateLoan(RowData loanRow) {
        try (StatelessKieSession session = loanKieContainer.newStatelessKieSession()) {
            session.execute(loanRow);
        }
    }

    // Or a generic method, if you can detect type or pass an enum param:
    public void validate(RowData data, ValidationType type) {
        KieContainer container = switch (type) {
            case POOL -> poolKieContainer;
            case LOAN -> loanKieContainer;
        };

        try (StatelessKieSession session = container.newStatelessKieSession()) {
            session.execute(data);
        }
    }

    public enum ValidationType {
        POOL, LOAN
    }
}

public enum ValidationRuleSet {
    POOL(List.of("rules/poolRule1.drl", "rules/poolRule2.drl")),
    LOAN(List.of("rules/loanRule1.drl", "rules/loanRule2.drl"));

    private final List<String> drlFiles;

    ValidationRuleSet(List<String> drlFiles) {
        this.drlFiles = drlFiles;
    }

    public List<String> getDrlFiles() {
        return drlFiles;
    }
}

@Configuration
public class KieConfig {

    @Bean
    public KModuleBeanFactoryPostProcessor kiePostProcessor() {
        return new KModuleBeanFactoryPostProcessor();
    }

    @Bean(name = "poolKieContainer")
    public KieContainer poolKieContainer(KieServices ks) {
        return createKieContainer(ks, ValidationRuleSet.POOL);
    }

    @Bean(name = "loanKieContainer")
    public KieContainer loanKieContainer(KieServices ks) {
        return createKieContainer(ks, ValidationRuleSet.LOAN);
    }

    private KieContainer createKieContainer(KieServices ks, ValidationRuleSet ruleSet) {
        List<String> drlFiles = ruleSet.getDrlFiles();
        KieFileSystem kfs = ks.newKieFileSystem();

        KieModuleModel kModuleModel = ks.newKieModuleModel();
        kfs.writeKModuleXML(kModuleModel.toXML());

        for (String drl : drlFiles) {
            kfs.write("src/main/resources/" + drl, ks.getResources().newClassPathResource(drl));
        }

        KieBuilder kieBuilder = ks.newKieBuilder(kfs).buildAll();

        if (kieBuilder.getResults().hasMessages(org.kie.api.builder.Message.Level.ERROR)) {
            throw new RuntimeException("Error building KIE base: " + kieBuilder.getResults());
        }

        ReleaseId releaseId = kieBuilder.getKieModule().getReleaseId();
        return ks.newKieContainer(releaseId);
    }
}