Service Loader implementations needing default public constructors

Question

I was trying to understand how in Java Service Loader works? I came across this blog: Could you please help me understand why the author claims: The implementation must have a public parameterless constructor. Okay I get the first part. Now a follow up question. I can post it as a follow up a question but thought it would be better to have it as part of the same question. Consider the java doc: It says: In addition, the constructor of a non-private inner member class must be compiled such that it has as its first parameter, an additional implicit parameter representing the immediately enclosing instance (§8.1.3). So does that mean I cannot externalize a inner class. Please consider the following code: ``` import java.io.*; class Y { class ABC { ABC() { System.out.println("ABC Constructor"); } public void writeExternal(ObjectOutput out) throws IOException { System.out.println("ABC.writeExternal"); } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { S…

Accepted Answer

That's because it's required to create a new instance via reflection.

I guess here's relevant code, line 362:

```
S p = service.cast(Class.forName(cn, true, loader).newInstance());
```

Thus it invokes "parameterless" constructor since `Class.newInstance()` can only invoke the zero-argument constructor.

Edit:

Actually, it's not required to create a zero-argument constructor for `public class` unless you define another constructor.

javadoc:

You don't have to provide any constructors for your class, but you must be careful when doing this. The compiler automatically provides a no-argument, default constructor for any class without constructors.

So, the following code is perfectly correct:

```
public final class MyServiceImpl implements MyService { 
    @Override
    public long getTime() {
        return System.currentTimeMillis();
    } 
}
```

Default constructor for `MyServiceImpl` will be the same as:

```
public MyServiceImpl() { }
```

Since `MyServiceImpl` is a public class:

if the class is declared public, then the default constructor is implicitly given the access modifier public

Thus constructor in `MyServiceImpl` is redundant.

My guess is that author of the blog post just wanted to make sure that `ServiceLoader` will be able to instantiate service provider even when it contains some explicit constructors with arguments.

Conclusion: Service provider should have explicit no-argument constructor only if it contains explicit constructors with arguments. Default constructor will suffice otherwise.

Service Loader implementations needing default public constructors

Solution

Problem

Related problems