Java 如何使用guice注入在具有静态方法的类中注入类？

我对Guice Injection不熟悉。如何将一个类注入静态方法中使用的静态变量中

这是我希望在doLocalize（）方法中使用注入变量b的类

这是我想要在其上执行guice注入的模块类

注意：我不能更改MyModule和B类，因为它来自另一个依赖项

public class MyModule extends AbstractModule {
   public void configure() {
       bind(B.class);
       // some other binds
   }

}

我想在我的A班被注入的班级

public class B {
    public String localize(String word) {
        //does some stuff
        //returns a modified string
    }
}

使用。这在中进行了描述

注意：我不能更改MyModule和B类，因为它来自另一个依赖项

public class MyModule extends AbstractModule {
   public void configure() {
       bind(B.class);
       // some other binds
   }

}

然后你需要一个新模块

class A {
    @Inject
    public static B b;
    static void a(){b.b();}
}
class B {
    @Inject public PrintStream out;
    void b() { out.println("Value: b"); }
}

class MyModule extends AbstractModule {
    public void configure() {
        bind(B.class);
        bind(PrintStream.class).toInstance(System.out);
    }
}

class AModule extends AbstractModule {
    public void configure() {
        requestStaticInjection(A.class);
    }
}

@Test
public void test() {
    Guice.createInjector(new AModule(), new MyModule()); // Can be in any order
    A.a();
    assertThat(A.b, is(not(nullValue())));
}

使用。这在中进行了描述

注意：我不能更改MyModule和B类，因为它来自另一个依赖项

public class MyModule extends AbstractModule {
   public void configure() {
       bind(B.class);
       // some other binds
   }

}

然后你需要一个新模块

class A {
    @Inject
    public static B b;
    static void a(){b.b();}
}
class B {
    @Inject public PrintStream out;
    void b() { out.println("Value: b"); }
}

class MyModule extends AbstractModule {
    public void configure() {
        bind(B.class);
        bind(PrintStream.class).toInstance(System.out);
    }
}

class AModule extends AbstractModule {
    public void configure() {
        requestStaticInjection(A.class);
    }
}

@Test
public void test() {
    Guice.createInjector(new AModule(), new MyModule()); // Can be in any order
    A.a();
    assertThat(A.b, is(not(nullValue())));
}

---

出于几个原因，我建议将

A

上的方法设置为非静态

• 很难对调用引用外部服务的静态方法的代码进行单元测试
• 使用静态会使代码更难保证线程安全
• 静态字段有时会导致内存泄漏

我建议：

public class A {
   private final B b;

   @Inject
   private A(B b) {
     this.b = b;
   }

   public String doLocalize(String word) {
       return b.localize(word);
   }
}

请注意，

b

是final，这很好，因为您不希望它被更改，而且final字段在多线程环境中有一定的保证

---

写完这篇文章后，我想知道为什么需要

A

类。相反，任何调用

A.doLocalize（）

的代码都可以注入

B

实例吗？

出于以下几个原因，我建议将

A

上的方法设置为非静态

• 很难对调用引用外部服务的静态方法的代码进行单元测试
• 使用静态会使代码更难保证线程安全
• 静态字段有时会导致内存泄漏

我建议：

public class A {
   private final B b;

   @Inject
   private A(B b) {
     this.b = b;
   }

   public String doLocalize(String word) {
       return b.localize(word);
   }
}

请注意，

b

是final，这很好，因为您不希望它被更改，而且final字段在多线程环境中有一定的保证

---

写完这篇文章后，我想知道为什么需要

A

类。相反，任何调用

A.doLocalize（）

的代码都可以注入

B

实例吗？

heh。因此，在应用程序启动期间，基本上与

A.b=injector.get（b）

相同。这会完成所有注入（在本例中，仅一个项目），这就是它所属的位置（在模块中，而不是在启动期间）。嘿嘿。因此，在应用程序启动期间，基本上与

A.b=injector.get（b）

相同。这将完成所有注入（在本例中，仅一项），并且是它所属的位置（在模块中，而不是在启动期间）。嘿。我的回答回答了这个问题还是你还在犹豫？嘿。我的回答回答了这个问题，还是你还在犹豫？