public interface DataBaseDriver {
    void connect();
}

// MySQL Implement
public class MySQLDriver implements DataBaseDriver {
    @Override
    public void connect() {
        System.out.println("MySQL connecting...");
    }
}

// PostgreSQL Implement
public class PostgreSQLDriver implements DataBaseDriver {
    @Override
    public void connect() {
        System.out.println("PostgreSQL connecting...");
    }
}

com.solisamicus.MySQLDriver
com.solisamicus.PostgreSQLDriver

ServiceLoader<DataBaseDriver> loader = ServiceLoader.load(DataBaseDriver.class);
for (DataBaseDriver driver : loader) {
    driver.connect();
}

Connection conn = DriverManager.getConnection(url,username,password);

/**
 * Load the initial JDBC drivers by checking the System property
 * jdbc.properties and then use the {@code ServiceLoader} mechanism
 */
static {
    loadInitialDrivers();
    println("JDBC DriverManager initialized");
}

private static void loadInitialDrivers() {
    String drivers;
    try {
        drivers = AccessController.doPrivileged(new PrivilegedAction<Str
            public String run() {
                return System.getProperty("jdbc.drivers");
            }
        });
    } catch (Exception ex) {
        drivers = null;
    }
    // If the driver is packaged as a Service Provider, load it.
    // Get all the drivers through the classloader
    // exposed as a java.sql.Driver.class service.
    // ServiceLoader.load() replaces the sun.misc.Providers()
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
            ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Dri
            Iterator<Driver> driversIterator = loadedDrivers.iterator();
            /* Load these drivers, so that they can be instantiated.
             * It may be the case that the driver class may not be there
             * i.e. there may be a packaged driver with the service clas
             * as implementation of java.sql.Driver but the actual class
             * may be missing. In that case a java.util.ServiceConfigura
             * will be thrown at runtime by the VM trying to locate
             * and load the service.
             *
             * Adding a try catch block to catch those runtime errors
             * if driver not available in classpath but it's
             * packaged as service and that service is there in classpat
             */
            try{
                while(driversIterator.hasNext()) {
                    driversIterator.next();
                }
            } catch(Throwable t) {
            // Do nothing
            }
            return null;
        }
    });
    println("DriverManager.initialize: jdbc.drivers = " + drivers);
    if (drivers == null || drivers.equals("")) {
        return;
    }
    String[] driversList = drivers.split(":");
    println("number of Drivers:" + driversList.length);
    for (String aDriver : driversList) {
        try {
            println("DriverManager.Initialize: loading " + aDriver);
            Class.forName(aDriver, true,
                    ClassLoader.getSystemClassLoader());
        } catch (Exception ex) {
            println("DriverManager.Initialize: load failed: " + ex);
        }
    }
}

String factoryClass = getSystemProperty(FACTORY_PROPERTY, null);
if (factoryClass != null) {
    factory = newFactory(factoryClass, baseClassLoader, contextClassLoader);
}

if (factory == null) {
    // META-INF/services/org.apache.commons.logging.LogFactory
    final InputStream is = getResourceAsStream(contextClassLoader, SERVICE_ID);
    if (is != null) {
        BufferedReader rd = new BufferedReader(new InputStreamReader(is, "UTF-8"));
        String factoryClassName = rd.readLine();
        rd.close();

        if (factoryClassName != null && !"".equals(factoryClassName)) {
            factory = newFactory(factoryClassName, baseClassLoader, contextClassLoader);
        }
    }
}

if (factory == null) {
    if (props != null) {
        String factoryClass = props.getProperty(FACTORY_PROPERTY);
        if (factoryClass != null) {
            factory = newFactory(factoryClass, baseClassLoader, contextClassLoader);
        }
    }
}

if (factory == null) {
    factory = newFactory(FACTORY_DEFAULT, thisClassLoader, contextClassLoader);
}

package com.solisamicus.payment.api;

public interface PaymentService {
    void pay(Double amount);

    String getType();
}

package com.solisamicus.payment.impl;

import com.solisamicus.payment.api.PaymentService;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class AlipayService implements PaymentService {
    @Override
    public void pay(Double amount) {
        log.info("Pay with Alipay: {}", amount);
    }

    @Override
    public String getType() {
        return "alipay";
    }
}

package com.solisamicus.payment.impl;

import com.solisamicus.payment.api.PaymentService;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class WechatPayService implements PaymentService {
    @Override
    public void pay(Double amount) {
        log.info("Pay with WeChat: {}", amount);
    }

    @Override
    public String getType() {
        return "wechat";
    }
}

package com.solisamicus.payment.loader;

import com.solisamicus.payment.api.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.io.support.SpringFactoriesLoader;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.ServiceLoader;

@Slf4j
@Component
public class PaymentLoader {

    // Java SPI
    public List<PaymentService> loadJavaSPI() {
        List<PaymentService> services = new ArrayList<>();
        ServiceLoader<PaymentService> loader = ServiceLoader.load(PaymentService.class);
        for (PaymentService service : loader) {
            services.add(service);
            log.info("Loaded payment service: {}", service.getClass().getName());
        }
        return services;
    }

    // Spring
    public List<PaymentService> loadSpring(ClassLoader classLoader) {
        List<PaymentService> services = new ArrayList<>();
        List<String> names = SpringFactoriesLoader.loadFactoryNames(PaymentService.class, classLoader);
        for (String name : names) {
            try {
                Class<?> clazz = Class.forName(name);
                PaymentService service = (PaymentService) clazz.newInstance();
                services.add(service);
                log.info("Loaded payment service: {}", name);
            } catch (Exception e) {
                log.error("Failed to load payment service: " + name, e);
            }
        }
        return services;
    }
}

package com.solisamicus.payment.service;

import com.solisamicus.payment.api.PaymentService;
import com.solisamicus.payment.loader.PaymentLoader;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Slf4j
@Service
public class PaymentManager {

    @Autowired
    private PaymentLoader paymentLoader;

    private final Map<String, PaymentService> serviceMap = new ConcurrentHashMap<>();

    @PostConstruct
    public void init() {
        List<PaymentService> services = paymentLoader.loadJavaSPI();
        // List<PaymentService> services = paymentLoader.loadSpring(getClass().getClassLoader());
        for (PaymentService service : services) {
            serviceMap.put(service.getType(), service);
            log.info("Registered payment service: {}", service.getType());
        }
    }

    public void processPayment(Double amount, String type) {
        PaymentService service = serviceMap.get(type.toLowerCase());
        if (service == null) {
            throw new IllegalArgumentException("Unsupported payment type: " + type);
        }
        service.pay(amount);
    }
}

package com.solisamicus.payment.controller;

import com.solisamicus.payment.service.PaymentManager;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@Slf4j
@RestController
@RequestMapping("/payment")
public class PaymentController {

    @Autowired
    private PaymentManager paymentManager;

    @PostMapping("/pay")
    public ResponseEntity<?> pay(@RequestParam Double amount, @RequestParam String type) {
        try {
            paymentManager.processPayment(amount, type);
            return ResponseEntity.ok("Payment processed successfully");
        } catch (Exception e) {
            log.error("Payment failed", e);
            return ResponseEntity.badRequest().body("Payment failed: " + e.getMessage());
        }
    }
}

package com.solisamicus.payment;

import com.solisamicus.payment.loader.PaymentLoader;
import com.solisamicus.payment.api.PaymentService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

import static org.junit.jupiter.api.Assertions.assertFalse;

@SpringBootTest
class PaymentServiceTest {

    @Autowired
    private PaymentLoader paymentLoader;

    @Test
    void testLoadJavaSPI() {
        List<PaymentService> services = paymentLoader.loadJavaSPI();
        assertFalse(services.isEmpty());
    }

    @Test
    void testLoadSpring() {
        List<PaymentService> services = paymentLoader.loadSpring(getClass().getClassLoader());
        assertFalse(services.isEmpty());
    }
}