的Java吉斯商

Question

我有一個小問題，我想不出來挽救我的生命。

基本上我需要隨時動態地使用吉斯，然後遍歷所有這些註冊類。

比方說，這是我的同班同學註冊策略，但這些策略可以隨時通過運行應用程序被添加。

// Strategy registration may happen anytime, this is just an example 
strategyManager.register(ExampleStrategy1.class); 
strategyManager.register(ExampleStrategy2.class); 

StrategyImpl類

public class StrategyImpl implements Strategy { 

    @Override 
    public void register(Class<? extends StrategyDispatcher> strat) { 
     //Add this class into provider or create an instance for it and add it into guice but how? 
    } 

    @Override 
    public void dispatchStrategy() { 
     //Find all strategies and execute them 
    } 

} 

我已經使用提供可靠的，但不知道我怎麼會註冊類添加到供應方和檢索它們呢？

@Override 
protected void configure() { 
    bind(Strategy.class).toProvider(StrategyProvider.class); 
} 

我的供應商類總是得到相同的實例

public class StrategyProvider implements Provider<StrategyDispatcher> { 

    public LogManager get() { 
     return new StrategyDispatcherImpl(); 
    } 

} 

，我添加擴展StrategyDispatcherImpl類，所以我可以施展他們的策略是什麼？

我需要多結合添加到一個相同的實例，但它需要使用配置綁定方法進行動態並沒有這樣做，但隨後另一種方式能夠找到所有這些戰略和執行。

Answer 1

如果你真的需要它在應用生命週期中的「任何時候」發生那麼吉斯那麼我想你會需要某種吉斯感知廠。即

public class TestStuff { 
    @Test 
    public void testDynamicCreation() { 
     Injector injector = Guice.createInjector(); 
     StrategyManager manager = injector.getInstance(StrategyManager.class); 
     Hello hello = injector.getInstance(Hello.class); 
     manager.doStuff(); 
     assertThat(hello.helloCalled, is(false)); 

     manager.register(Hello.class); // DYNAMIC!! 
     manager.doStuff(); 
     assertThat(hello.helloCalled, is(true)); 
    } 
} 

interface Strategy { 
    void doStuff(); 
} 

@Singleton 
class Hello implements Strategy { 
    boolean helloCalled = false; 
    public void doStuff() { 
     helloCalled = true; 
    } 
} 


class StrategyManager { 
    private final Collection<Strategy> strategies = new ArrayList<>(); 
    private final StrategyFactory factory; 

    @Inject 
    StrategyManager(StrategyFactory factory) { 
     this.factory = factory; 
    } 

    public void register(Class<? extends Strategy> strat) { 
     strategies.add(factory.create(strat)); 
    } 

    public void doStuff() { 
     for (Strategy s : strategies) { 
      s.doStuff(); 
     } 
    } 
} 

class StrategyFactory { 
    private final Injector injector; 

    @Inject 
    StrategyFactory(Injector injector) { 
     this.injector = injector; 
    } 

    public Strategy create(Class<? extends Strategy> clazz) { 
     return injector.getInstance(clazz); 
    } 
} 

如果不是在初始化階段後，「動態」，那麼你是經過「multibinder」我想。