在目录中查找最新文件，然后选择具有相同DateTime的所有文件(Find newest file in directory, then select all files with same DateTime)

 如果要使用完全相同的配置实例（类Props），可以将其实例绑定为具有提供程序绑定的单例 。 这当然不是唯一的解决方案，但对我来说这是有道理的。 
 
 这是一个例子： 
 
 定义提供者： 
 
public class PropsProvider implements Provider<Props>
{
    @Override
    public Props get()
    {
        ...read and return Props here...
    }
}
 
 在单例范围内使用提供程序绑定： 
 
bind(Props.class).toProvider(PropsProvider.class).in(Singleton.class);
 
 注入您的配置： 
 
@Inject
public Connection(Props props) {
    this.props = props;
}
 
 您可以阅读文档： 
 
 
 
 单身人士最适合： 
 
 
 
  
 有状态对象，例如配置或计数器 
 
  
 构造或查找昂贵的对象 
 
  
 占用资源的对象，例如数据库连接池。 
 
 
 
 
 也许您的配置对象与第一个和第二个条件匹配。 我会避免从模块中读取配置。 在这看到原因。 
 
 我在一些单元测试案例中使用按需注入，我想在被测组件中注入模拟依赖项并使用字段注入（这就是为什么我试图避免现场注入:-)）我宁愿不使用InjectMocks由于某些原因。 
 
 这是一个示例： 
 
 零件： 
 
class SomeComponent
{
    @Inject
    Dependency dep;

    void doWork()
    {
        //use dep here
    }
}
 
 测试本身： 
 
@RunWith(MockitoJUnitRunner.class)
public class SomeComponentTest
{
    @Mock
    private Dependency mockDependency;

    private SomeComponent componentToTest;

    @Before
    public void setUp() throws Exception
    {
        componentToTest = new SomeComponent();

        Injector injector = Guice.createInjector(new AbstractNamingModule()
        {
            @Override
            protected void configure()
            {
                bind(Dependency.class).toInstance(mockDependency);
            }
        });

        injector.injectMembers(componentToTest);
    }

    @Test
    public void test()
    {
         //test the component and/or proper interaction with the dependency
    }

}

If you want to use the very same configuration instance (of class Props) you could bind its instance as a singleton with a provider binding. This is of course not the only solution, but it makes sense for me.
 
Here is an example:
 
Define a provider:
 
public class PropsProvider implements Provider<Props>
{
    @Override
    public Props get()
    {
        ...read and return Props here...
    }
}
 
Use a provider binding in singleton scope:
 
bind(Props.class).toProvider(PropsProvider.class).in(Singleton.class);
 
Inject your configuration:
 
@Inject
public Connection(Props props) {
    this.props = props;
}
 
You may read in the documentation:
 
 
 
Singletons are most useful for:
 
 
 
  
stateful objects, such as configuration or counters
 
  
objects that are expensive to construct or lookup
 
  
objects that tie up resources, such as a database connection pool.
 
 
 
 
Maybe your configuration object matches the first and the second criteria. I would avoid reading the configuration from within the module. See why here.
 
I've used on-demand injection in a few unit test cases where I wanted to inject mock dependencies in the component under test and field injection was used (that's why I try to avoid field injections :-) ) AND I preferred not to use InjectMocks for certain reasons. 
 
Here is a sample:
 
Component:
 
class SomeComponent
{
    @Inject
    Dependency dep;

    void doWork()
    {
        //use dep here
    }
}
 
The test itself:
 
@RunWith(MockitoJUnitRunner.class)
public class SomeComponentTest
{
    @Mock
    private Dependency mockDependency;

    private SomeComponent componentToTest;

    @Before
    public void setUp() throws Exception
    {
        componentToTest = new SomeComponent();

        Injector injector = Guice.createInjector(new AbstractNamingModule()
        {
            @Override
            protected void configure()
            {
                bind(Dependency.class).toInstance(mockDependency);
            }
        });

        injector.injectMembers(componentToTest);
    }

    @Test
    public void test()
    {
         //test the component and/or proper interaction with the dependency
    }

}