Java Interoperability

/**
 * Java-compatible component providing static access to Koin functionality
 */
object KoinJavaComponent {
    /**
     * Inject dependency lazily in Java code
     * @param clazz - Class type to inject
     * @param qualifier - Optional qualifier for disambiguation
     * @param parameters - Optional parameters for injection
     * @return Lazy instance of the requested type
     */
    @JvmStatic
    @JvmOverloads
    fun <T> inject(
        clazz: Class<*>,
        qualifier: Qualifier? = null,
        parameters: ParametersDefinition? = null
    ): Lazy<T>
    
    /**
     * Inject dependency lazily with null safety in Java code
     * @param clazz - Class type to inject
     * @param qualifier - Optional qualifier for disambiguation
     * @param parameters - Optional parameters for injection
     * @return Lazy instance of the requested type or null
     */
    @JvmStatic
    @JvmOverloads
    fun <T> injectOrNull(
        clazz: Class<*>,
        qualifier: Qualifier? = null,
        parameters: ParametersDefinition? = null
    ): Lazy<T?>
    
    /**
     * Get dependency instance immediately in Java code
     * @param clazz - Class type to get
     * @param qualifier - Optional qualifier for disambiguation
     * @param parameters - Optional parameters for injection
     * @return Instance of the requested type
     */
    @JvmStatic
    @JvmOverloads
    fun <T> get(
        clazz: Class<*>,
        qualifier: Qualifier? = null,
        parameters: ParametersDefinition? = null
    ): T
    
    /**
     * Get dependency instance with null safety in Java code
     * @param clazz - Class type to get
     * @param qualifier - Optional qualifier for disambiguation
     * @param parameters - Optional parameters for injection
     * @return Instance of the requested type or null
     */
    @JvmStatic
    @JvmOverloads
    fun <T> getOrNull(
        clazz: Class<*>,
        qualifier: Qualifier? = null,
        parameters: ParametersDefinition? = null
    ): T?
    
    /**
     * Get the global Koin instance
     * @return Global Koin instance
     */
    @JvmStatic
    fun getKoin(): Koin
}

import org.koin.java.KoinJavaComponent;
import org.koin.core.qualifier.Qualifier;
import org.koin.core.parameter.ParametersDefinition;

// Basic injection in Java
public class UserController {
    // Lazy injection - resolved on first access
    private final Lazy<UserService> userService = 
        KoinJavaComponent.inject(UserService.class);
    
    // Direct injection - resolved immediately
    private final Logger logger = 
        KoinJavaComponent.get(Logger.class);
    
    public User createUser(UserData userData) {
        logger.info("Creating user");
        return userService.getValue().create(userData);
    }
}

// Injection with qualifiers
public class PaymentService {
    private final Lazy<PaymentGateway> primaryGateway = 
        KoinJavaComponent.inject(
            PaymentGateway.class,
            KoinKt.named("primary")
        );
    
    private final PaymentGateway backupGateway = 
        KoinJavaComponent.getOrNull(
            PaymentGateway.class,
            KoinKt.named("backup")
        );
    
    public boolean processPayment(Payment payment) {
        try {
            return primaryGateway.getValue().process(payment);
        } catch (Exception e) {
            if (backupGateway != null) {
                return backupGateway.process(payment);
            }
            throw e;
        }
    }
}

// Injection with parameters
public class ReportGenerator {
    public Report generateReport(String reportType, Date fromDate, Date toDate) {
        ParametersDefinition params = () -> ParametersKt.parametersOf(
            reportType, fromDate, toDate
        );
        
        ReportBuilder builder = KoinJavaComponent.get(
            ReportBuilder.class,
            null,
            params
        );
        
        return builder.build();
    }
}

// Advanced usage with Koin instance
public class DatabaseManager {
    private final Koin koin = KoinJavaComponent.getKoin();
    
    public void switchDatabase(String environment) {
        // Use Koin instance directly for advanced operations
        DatabaseConfig config = koin.get(
            DatabaseConfig.class,
            KoinKt.named(environment),
            null
        );
        
        // Reconfigure database connection
        reconfigure(config);
    }
}

// Kotlin module definition
val javaInteropModule = module {
    single<UserService> { UserServiceImpl(get()) }
    single<Logger> { LoggerImpl() }
    
    single<PaymentGateway>(named("primary")) { StripePaymentGateway() }
    single<PaymentGateway>(named("backup")) { PayPalPaymentGateway() }
    
    factory<ReportBuilder> { (type: String, from: Date, to: Date) ->
        ReportBuilderImpl(type, from, to)
    }
    
    single<DatabaseConfig>(named("production")) { ProductionDbConfig() }
    single<DatabaseConfig>(named("development")) { DevelopmentDbConfig() }
}

// Start Koin with Java-compatible setup
startKoin {
    modules(javaInteropModule)
}

// Java classes using the Kotlin-defined dependencies
public class Application {
    public static void main(String[] args) {
        // Dependencies are available via KoinJavaComponent
        UserController controller = new UserController();
        PaymentService paymentService = new PaymentService();
        
        // Use the services
        User user = controller.createUser(new UserData("John", "john@example.com"));
        boolean success = paymentService.processPayment(new Payment(100.0));
    }
}

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class KoinServletListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // Initialize Koin when servlet context starts
        ServletContext context = sce.getServletContext();
        
        // Start Koin with configuration
        KoinApplication app = StartKoinKt.startKoin(koinApp -> {
            koinApp.modules(WebModulesKt.getWebModules());
            return null;
        });
        
        // Store Koin instance in servlet context
        context.setAttribute("koin", app.getKoin());
    }
    
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // Clean up Koin when servlet context stops
        StopKoinKt.stopKoin();
    }
}

// Servlet using Koin
public class UserServlet extends HttpServlet {
    private final Lazy<UserService> userService = 
        KoinJavaComponent.inject(UserService.class);
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        String userId = req.getParameter("userId");
        User user = userService.getValue().findById(userId);
        
        // Handle response
        resp.getWriter().write(user.toJson());
    }
}

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

@Configuration
public class KoinSpringBridge {
    
    // Expose Koin dependencies as Spring beans
    @Bean
    public UserService userService() {
        return KoinJavaComponent.get(UserService.class);
    }
    
    @Bean
    public PaymentProcessor paymentProcessor() {
        return KoinJavaComponent.get(PaymentProcessor.class);
    }
    
    // Initialize Koin alongside Spring
    @Bean
    public KoinApplication koinApplication() {
        return StartKoinKt.startKoin(app -> {
            app.modules(ApplicationModulesKt.getAppModules());
            return null;
        });
    }
}

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

public class ServiceTest {
    
    @BeforeEach
    void setUp() {
        // Start Koin for testing
        StartKoinKt.startKoin(app -> {
            app.modules(TestModulesKt.getTestModules());
            return null;
        });
    }
    
    @AfterEach
    void tearDown() {
        // Clean up after each test
        StopKoinKt.stopKoin();
    }
    
    @Test
    void testUserService() {
        UserService userService = KoinJavaComponent.get(UserService.class);
        
        User user = userService.create(new UserData("Test User"));
        assertNotNull(user);
        assertEquals("Test User", user.getName());
    }
    
    @Test
    void testPaymentServiceWithQualifier() {
        PaymentGateway gateway = KoinJavaComponent.get(
            PaymentGateway.class,
            KoinKt.named("test")
        );
        
        assertTrue(gateway instanceof MockPaymentGateway);
    }
}

// All standard Koin types are available in Java through static imports
// Qualifiers
val named: (String) -> Qualifier = ::named
val qualifier: (String) -> Qualifier = ::qualifier

// Parameters
val parametersOf: (Array<Any>) -> ParametersHolder = ::parametersOf

// Type aliases for Java compatibility
typealias ParametersDefinition = () -> ParametersHolder