Guice：通过方法创建对象

Question

Suppose I have two similar (but different) methods (or maybe static methods) create_x() and create_y() to create objects (call them x and y ) both (of class derived) of class Parser .

Now I want to bind the objects created by these two methods like as in answer to my previous question :

bind(Parser.class)
        .annotatedWith(Names.named("x"))
        .to(ParserXImplementation.class);

bind(Parser.class)
        .annotatedWith(Names.named("y"))
        .to(ParserYImplementation.class);

but with object created by create_x() , create_y() instead of instances of classes ParserXImplementation , ParserYImplementation . (So that there is no necessity to create classes ParserXImplementation , ParserYImplementation .)

Note that I want the objects to be singletons.

I want the answers both for the case if create_x() , create_y() are static methods and for the case if they are instance methods. If they are instance methods, the class containing them may itself be subject to dependency injection.

How to do this? (injecting dependencies to instances created by methods)

Answer 1

From https://github.com/google/guice/wiki/ProvidesMethods :

When you need code to create an object, use an @Provides method. The method must be defined within a module, and it must have an @Provides annotation. The method's return type is the bound type. Whenever the injector needs an instance of that type, it will invoke the method.

public class BillingModule extends AbstractModule {
  @Override
  protected void configure() {
    ...
  }

  @Provides
  TransactionLog provideTransactionLog() {
    DatabaseTransactionLog transactionLog = new DatabaseTransactionLog();
    transactionLog.setJdbcUrl("jdbc:mysql://localhost/pizza");
    transactionLog.setThreadPoolSize(30);
    return transactionLog;
  }
}

Further, it says that it can use annotation like @Named("x") and @Named("y") to differentiate x and y as described in the answer to Binding the same interface twice (Guice) .

This is what I need (however the method is defined inside a module rather than in an arbitrary class).