设计服务启动界面

Question

The simple answer is of course to include a start method on the Service interface.

interface Service {
   void start();
   OperationResult operation( parameters );
   ...
}

This of course sux because most users of the Service don't want or care about starting the service they just want to use methods like operation.

How would you solve this problem? I have a simple solution which does have one major limitation without polluting the Service interface thus I would like to hear of peoples proposals.

Answer 1

如果有必要启动一个服务，然后对其进行填充，然后终止该服务，则应该有一个对象，其功能仅是启动服务并提供一个对象，然后该对象可用于对服务进行填充，包括终止它（后一种操作-最好通过IDisposable处理-应该会使“ do-stuff”对象无效）。

Answer 2

A few ways:

• start it whenever it gets constructed
• throw an exception from operation methods if the service isn't started, indicating improper usage
• automatically start it from every method, if it isn't started

Answer 3

Your question arises because you are mixing implementation issues (start() method, eg) with the actions (operation() method). Start is an implementation issue because you could create an instance for each caller or you can have a singleton (as in cached instances). The caller should not have to call the method at all. In fact, if you keep the start method and change your implementation to a singleton tomorrow, the code may stop working for the existing clients.

IMO, you should get rid of the start method from this interface and let the caller worry about delegating the task that your operation method does best.

If you push the start method (an optimization step that has nothing to do with the interface) to your implementation, you can solve the problem in any number of ways. For example,

a. call start() if it has not been called before in operation() method. You will need to deal with synchronization issues. b. call start() in the constructor of your implementation object and be done with it.

etc.

Answer 4

If you don't want the consumer to care about calling a startup. You can consider delegate your startup code internally to a protected method that lazy initializes what you are currently doing this on startup. Such as:

    protected MyService getMyService() {
    if(myService == null) {
        myService = new MyServiceImpl();
        myService.startup();
    }
    return idpPersistence;
}

Call methods like this:

public String findByThis(String tag, String key) {
    return getMyService().findThat(MyClass.class, column, key);
}

This of course has some tradeoffs. If you service is expensive on startup, then the first caller well take that hit first.

Another option is to implement these using a static{} block but that's of course sometimes not very testable as well. Also, doing your startup routines on object consturction, which sometimes violates IOC patterns as well. I went with adding a Service interface because the clients I had were internal, and I wanted all services initialized and ready on startup.