4

For jstl tags, an API javax.servlet.jsp.jstl-api-1.2.1.jar & implementation javax.servlet.jsp.jstl-1.2.1.jar are provided.

For servlets, an API in servlet-api.jar & implementation jar from tomcat or GlassFish are provided.

For collections, API like java.util.List & corresponding implementations like java.util.ArrayList & java.util.LinkedList are provided.

IDE Netbeans is another example.

  1. Implementation jar includes both the API(mostly interfaces) and its implementation, What are the advantages in providing a solution with an API JAR and their corresponding implementations(a separate JAR), for programmers/developers to use?

  2. For developing enterprise applications using java, Is providing an API the standard approach for stable contract between developers?

overexchange
  • 15,768
  • 30
  • 152
  • 347
  • 1
    Because it makes it possible to easily change the implementation, without changing the code that uses the API. See also: [Type List vs ArrayList](https://stackoverflow.com/questions/2279030/type-list-vs-type-arraylist-in-java) – Jesper Dec 28 '17 at 07:44
  • @Jesper I understand the usage at `class` & `interface` level, to program with interfaces. But [here](https://stackoverflow.com/q/47999963/3317808) at jar level, I did not include api jar. Things worked with implementation jar only, because implementation jar has both api(mostly java `interface`) & it's implementation class. – overexchange Dec 28 '17 at 08:23
  • See https://stackoverflow.com/questions/383947/what-does-it-mean-to-program-to-an-interface – Raedwald Dec 28 '17 at 08:43
  • See https://www.youtube.com/watch?v=aAb7hSCtvGw – overexchange Dec 28 '17 at 14:25

4 Answers4

3

I have advocated separating the API from its implementation in my Practical API Design book. At that time I valued the simple library as well as modular library approaches. We used them both successfully when designing NetBeans Platform APIs. I usually felt uneasy when it came to vendor library style - a common approach used in Java EE world.

Later I realized the optimal solution depends on the desired degree of proximity (see my detailed explanation). In short, it depends how closely the API author is related to the one who implements the API. Is it the same person? Is it a group that sit down and agreed on a specification? Are they different, but we expect way more users of the library than those who implement it? Or do we expect almost every user to implement (something in) the library? The answer to this question then leads to:

  • None to many
  • One to many
  • Few to many
  • Many to many

Proximity classification. Each of them can be handy in some situations. However, my all time favorite is many to many approach with full featured modular library design.

Jaroslav Tulach
  • 519
  • 4
  • 7
2

1) If you put the API in a different jar, then you can let it be used by clients that can't access the implementation. For example:

  • You can exclude the implementation from the compile-time classpath of clients, to ensure that clients of the API don't require any particular implementation.

  • You can exclude the implementation from the run-time classpath of API clients (either via ClassLoaders like servlets do or separate JVMs), so that clients can't depend on any particular implementation, and so that they can use libraries that would conflict with the ones that the implementation uses.

2) Not really individual developers, but it's common to use a strategy like that to avoid conflicts and unwanted dependencies between different development teams.

Matt Timmermans
  • 53,709
  • 3
  • 46
  • 87
0

This is because only the API is standardised, and multiple implementations are possible, and the API is an incomplete specification. In the case of servlets, in addition to the servlets API, which your Web App uses, there is the web application server (Tomcat or Glassfish). The application server is a large program, with many other features and APIs. For a Web Application, your servlets are not "the program"; the application server is. It is not that your servlets delegate to the server, the server delegates to your code (in a WAR).

Raedwald
  • 46,613
  • 43
  • 151
  • 237
0

In programming using an implementation, you might need the API specification (interfaces, abstract classes etc) too. 

Interface obj = new ClassImpletingInterface();

which could also be done as

ClassImpletingInterface obj = new ClassImpletingInterface();

If your program used only the latter, you might get away having just the implementation jar that didn't include the API package. As far as possible, one should use the former for better maintainability etc. Now the question of why can't the API package just be bundled into the implementation jar - one API one jar. Might sound simple, but may not be desirable. You might prefer to use the javax.servelet.jsp.jstl-api package obtained from the authentic source; not bundled in com.newbie.servlet-0.0.1.jar. There can be legal aspects that prevent such bundling. Further, an implementation not necessarily provide functionality for the complete specification. Your imports for an API could come from two different implementations as different parts, and they could be for different release levels of the specification. In that case, perhaps rare, each bundling a different release level of API may cause trouble because jar search within a directory is not completely defined. So, bundling of API and implementation into separate jars is cleaner.

Madhu
  • 119
  • 5