What's the difference between Eclipse Packages and Plug-ins?

Question

In Dependencies tab, I have a choice between plug-ins and packages. What\'s the difference between them? For org.eclipse.compare, I have it in imported package

Answer 1

You use Imported Packages when you want to use a specific package but do not care which plugin provides it. OSGI will choose one for you.

Answer 2

Eclipse plugins is something like extension to the IDE itself. But imported packages are actually packages that you'll use in your current project.

One is for development IDE another is for the project you are coding.

Answer 3

An Eclipse plug-in is basically an OSGi bundle with additional plugin.xml file which Eclipse IDE understands and interprets.

So the answer to your question lies in the OSGi specification and the OSGi programming model, since, very simply put, Eclipse is an Application running on implementation of OSGi called Equinox.

OSGi is all about having modular applications and so it defines several levels of modularity. One such level is a bundle-level (module-level) modularity and more fine grained level is the package level modularity.

So you can have your OSGi application (a set of bundles; eclipse is just that) which consists of db-bundle (which provides data store services), app-domain-bundle (which provides your application domain services) and remote-bundle (which exposes to the web your application via REST for example).

And then you say remote-bundle depends on domain-bundle which depends on db-bundle. Which is all good, but cripples the inherent modularity OSGi provides, because you are basically restricting your application to specific implementations of db-bundle and remote-bundle i.e. to specific implementations of the services they provide.

Instead, you can establish the above dependencies not between bundles but between packages i.e. establish a service-level dependencies. Then you say domain-bundle requires dbstore.service package to run, it doesn't care which bundle provides it it just needs an instance of this service to be able to work. So you can have multiple bundles providing implementations of the dbstore.service, and the domain-bundle can pick and choose at runtime what service to use.

It is really hard to explain OSGi concepts in just a several sentences, I'd really suggest you dig around the web on this and maybe even have a look at the OSGi specification.

Another way to explain it is to say that bundle/plug-in is a jar file with specific structure and metadata descriptors (MANIFEST.MF and plugin.xml), which describe its contents in Java language concepts - which java packages and services this specific jar contains and will expose to the OSGi runtime so that they can be consumed by other bundles. I.e. the bundle is the physical deployable entity while the descriptors are metadata about what actually is being deployed.

EDIT: Package or Service-level dependencies also have some drawbacks, as Lii points out in the comments below, the main one being that it adds complexity and dynamics to the dependency model. Have a look at her or his comment below - it is worth reading!