iConnector | SuperMap.Web.iConnector 是一款基于SuperMap iClient | Map library

Indeed it seems Flyway might have issues in OSGi. Maybe you can provide them an issue and your example.

Another issue with your example is that you try to access the DataSource via a url. This does not work in OSGi. The reason is that this way flyway has to have direct access to the database driver classes. This does not work in OSGi.

In OSGi the way to access a Database is with a DataSourceFactory which the database driver creates as a service. From this factory you can create a DataSource.

As not all database drivers offer this service there is pax-jdbc which provides factories for all common databases. It also allows to create a DataSource including pooling from a OSGi config.

Your approach of migrating on bundle start is a very bad idea. The methods in the activator must return quickly and a databse migration might take a while. Of course you want to make sure the migration takes place before any bundle in the system accesses the database. Fortunately there is a way to hook into the DataSource creation to do things like a migration.

See the liquibase tutorial which also shows a database migration. It uses the PreHook offered by pax-jdbc which makes sure your migration code is run before the DataSource is given to any other bundle.

For an OSGi service you generally should use an interface to announce it. This way the user of the service is not bound to your implementation class.

Using a static method to return a connection is generally a bad idea in OSGi. You will want to supply the configuration of the datasource using an OSGi configuration. These configurations are supplied at runtime and can even go away at runtime. So you need to implement this in a way to cope with a configuration or configuration change.

A good practice is to offer a factory for the connection as a service once the configuration is given to you by the configiration admin and remove the service when the config goes away.

Doing all this with plain OSGi APIs is very cumbersome. Try to avoid registering services manually as well as using service trackers. Both APIs are difficult to use correctly. Instead use a dependency injection framework like declarative services.

Your case of managing DataSources and pools is especially complicated. You should not do this yourself. There are two existing projects that already provide what you need.

• pax jdbc provides OSGi services for DataSourceFactory for most popular databases. It also handling creating DataSources from configuration as well as pooling.
• Aries Transaction control even goes a bit further and provides a slightly different programming model for databases that is very well suited for OSGi. It handles DataSources, pooling and transaction support.

As your question suggests you try to build microservices on OSGi I also recommend the enroute microservice tutorial. It includes an example of using transaction control.

I see 2 options.

You can hand-wire your dependencies by using a lambda. This means you only register IWorker and build it and its dependencies manually. This disables Auto-Wiring, but results in quite straightforward code, as shown in this example:

I am trying to make a class that has two constructors, both with three arguments

This is where you go wrong. Your application components should have exactly 1 public constructor. Having multiple is an anti-pattern, as explained here. In short:

multiple constructors are redundant, ambiguous, make your DI configuration fragile, and lead to maintainability issues.

In your case you have one constructor with an IAddRequestHandler dependency and a different constructor with an IUpdateRequestHandler dependency.

What you probably are trying to achieve is to build an object graph with only dependencies that are required for the current request, but this doesn't make sense for multiple reasons.

First of all, since injection constructors should be simple, the construction of object graphs (even really big ones), should be really fast. So trying to optimize this does not make sense. From that point of view, your controller should have one constructor, and it should accept (and require) all the dependencies that class needs.

It might also indicate that your controller actually does too much and therefore violates the Single Responsibility Principle. You probably should split up this controller into two separate classes, each with (still) one constructor. This immediately makes your object graph narrower and smaller as well.

So it sounds like you need to distinguish between Design mode and Runtime Mode.

There are some things to help you with this, you need to pick which one works best for you;

There are

• The DesignMode property
• LicenseModeUsage property

The work differently, for example DesignMode does not work in contructors but LicenseMode does. So you need determine what works best for you depending on where you need to use this.

This post explains it much better than I can; http://dotnetfacts.blogspot.de/2009/01/identifying-run-time-and-design-mode.html

I am confused how to automate this since the documentation is suggesting, that the manual creation of stubs is not necessary anymore.

Correct. As long as you satisfy the conditions stated in the preamble to the Javadoc for UnicastRemoteObject, stub objects will be generated dynamically. Basically you always have to specify a port number when constructing or exporting a remote object. You can use zero if you don't care.

So is there a more flexible way to create stubs and to move them to the clients?

You don't need to do either. So don't.

The canonical form of a variadic template function uses rvalue references and std::forward: