Java-基于接口的框架中服务提供者的目的？

Question

I have listed below notes from 'Effective Java' and the code it references.

My question -

why does the author feel service provider interface saves having to register by class name and instantiate reflectively ? Can't the registration API in the static factory 'providers' be modified to register instances of 'services' instead of 'service providers'?

So do -

// Maps service names to services
private static final Map<String, Service> services =
    new ConcurrentHashMap<String, Service>();
public static final String DEFAULT_PROVIDER_NAME = "<def>";

// Provider registration API
public static void registerDefaultService( Service s) {
    registerService(DEFAULT_PROVIDER_NAME, s);
}
public static void registerService(String name, Service s){
    services.put(name, s);
}

instead of the example from the text below.

Excerpt from the text -

An optional fourth component of a service provider framework is a service provider interface, which providers implement to create instances of their service implementation. In the absence of a service provider interface, implementations are registered by class name and instantiated reflectively (Item 53). In the case of JDBC, Connection plays the part of the service interface, DriverManager.registerDriver is the provider registration API, DriverManager.getConnection is the service access API, and Driver is the service provider interface.

And here's the code -

// Service provider framework sketch

// Service interface
public interface Service {
    ... // Service-specific methods go here
}

// Service provider interface
public interface Provider {
    Service newService();
}

// Noninstantiable class for service registration and access
public class Services {
    private Services() { }  // Prevents instantiation (Item 4)

    // Maps service names to services
    private static final Map<String, Provider> providers =
        new ConcurrentHashMap<String, Provider>();
    public static final String DEFAULT_PROVIDER_NAME = "<def>";

    // Provider registration API
    public static void registerDefaultProvider(Provider p) {
        registerProvider(DEFAULT_PROVIDER_NAME, p);
    }
    public static void registerProvider(String name, Provider p){
        providers.put(name, p);
    }

    // Service access API
    public static Service newInstance() {
        return newInstance(DEFAULT_PROVIDER_NAME);
    }
    public static Service newInstance(String name) {
        Provider p = providers.get(name);
        if (p == null)
            throw new IllegalArgumentException(
                "No provider registered with name: " + name);
        return p.newService();
    }
}

Thanks in advance!!

Answer 1

The provider in this case is a factory, and all the usual reasons for using a factory apply. Different service implementations might need very different construction code, and using a factory means the registry doesn't need to know about the implementation details, just the bare minimum needed to specify the service's behavior.

Answer 2

我认为服务提供者接口的好处之一可能是，在实际需要时，在服务提供者实例及其使用者之间进行松散耦合。