What is Service loader in Java?
Service Loader is a new class added in Java 1.6 and it provides good means of developing loosely coupled application.
It allows us to link an interface to a particular implementation at run time based on configuration thus providing us with loose coupling
It also provides a sort of Dependency Injection (DI) though not as powerful as Spring framework but does provide a good facility in case you don’t require a full blown DI feature.
Also various design patterns like Strategy can be easily done with the help of Service Loader.
What is the Logic behind Service Loader?
Each interfaces present in the application is called service since they define what can be done but not how it can be done.
A single interface can have multiple implementations and each implementation is called service provider
Service Loader makes use of both the above concepts and to link a particular implementation with interface i.e. link a particular service with a service provider makes use of provider configuration file
Provider configuration file:
This file contains mapping of interface to implementation and is present in the resource directory META-INF/services
Within this file, contains a list of fully-qualified binary names of concrete provider classes, one per line and is compliant with UTF -8
Not clear yet, See example to make things crisp and clear
Let consider Account Interface as shown, We can see it has following methods
- setType(String type)
- setBalance(int balance)
- setBranch(String branch)
We will create this example using Eclipse IDE. Following are the steps: -
1) Create a Java Project as shown. Give project name as ServiceLoaderEg
2) Create new package com.questpond.eg
5) Similarly CurrentAccount
8) Create a main class called Main and within it write the following code
9) On running the above code we get following output
As we see from the screen shot the CurrentAccount implementation is used which is evident by the Sys out method printed and the type of Account
Note: Before running the example please copy META-INF folder completely within bin folder of eclipse
10) From the above example we see that the invoking class is not dependant directly on the Implementation and just depends on interface and the mapping between them is done by using ServiceLoader. Thus we achieve loosely coupled application
Many times when development happens cross team it is quite possible the team may have dependency on the code each other develop. So some classes if not completely developed can affect the dead lines of project as well testing. To do up with this we can create Mock objects corresponding to each classes which has not been fully developed and the mapping can be done by using ServiceLoader. Once the class is completely developed we can replace the Mock object with actual implementation via again Service Loader Thus we achieve Loosely coupled application as well Dependency Injection.
Download Source Code for Service Loader in Java.
Video on Service Loader:
Also see the following video which will clear your picture more on Service Loader.
More articles and videos coming:
I am going to write more articles as well as record more videos on
Java interview questions and new rich features like concurrent collections. Semaphores, Executors and so on in coming time. So stay tuned