java - 命名字符串字段上的 Guice 注入

Question

我有一堂课：

public class FizzBuzz {
    @Named("Red") private String redService;

    public static void main(String[] args) {
        GuiceTest testApp = new GuiceTest();

        testApp.run();
    }

    private void run() {
        Injector inj = Guice.createInjector(new MyModule());

        redService = (String)inj.getInstance(String.class);

        // Should print "red-service" but is instead an empty string!
        System.out.println("redService = " + redService);
    }

    // ... Rest of class omitted for brevity
}

public class MyModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(String.class).annotatedWith(Names.named("Red")).toInstance("red-service");
    }
}

在我的模块中，我指示 Guice 将所有String.class实例@Named“Red”绑定到字符串实例“red-service”，但是我在输出的 print 语句中没有看到。我如何错误地使用 Guice？

Answer 1

让我总结一下这里已经发表的一些评论......

1. 你忘记了@Inject注解
2. 我强烈建议将 Guice/Injector 保留在FizzFuzz. 使用静态 main 方法来引导您的应用程序（不是run()）。
3. 将 String 绑定到常量可以很容易地通过bindConstant.

这给你带来了这样的事情：

public class FizzFuzz {
    @Inject
    @Named("red")
    private String service;

    public static void main(String[] args) {
        FizzFuzz fizzFuzz = Guice.createInjector(new AbstractModule() {
            @Override
            protected void configure() {
                bindConstant().annotatedWith(Names.named("red")).to("red-service");
            }    
        }).getInstance(FizzFuzz.class);

        System.out.println(fizzFuzz.service);
    }
}

Answer 2

你以前忘记@Inject了@Named("Red")。对于此类事情，也可以使用 bindConstant() 。

PS为什么你String从inj而不是收到FizzBuzz？

Answer 3

我的方式应该更漂亮。
首先创建您的注释

@Retention(RetentionPolicy.RUNTIME)
public @interface InjectSetting {
     String value();
}

创建你的 guice 模块

@Slf4j
public class SettingModule extends AbstractModule {
    private final Properties properties;

    private SettingModule(Properties properties) {
        this.properties = properties;
    }

    @Override
    protected void configure() {
        binder().bindListener(Matchers.any(), listener(((type, encounter) -> {
            for (Field field : type.getRawType().getDeclaredFields()) {
                if (field.isAnnotationPresent(InjectSetting.class)) {
                    field.setAccessible(true);

                    encounter.register(injector(instance -> {
                        try {
                            Object value = properties.get(
                                    field.getAnnotation(InjectSetting.class).value());

                            field.set(instance, parse(value, field));
                        } catch (IllegalAccessException e) {
                            binder().addError(e);
                        }
                    }));
                }
            }
        })));
    }

    TypeListener listener(BiConsumer<TypeLiteral<?>, TypeEncounter<?>> consumer) {
        return consumer::accept;
    }

    MembersInjector<Object> injector(Consumer<Object> consumer) {
        return consumer::accept;
    }

    Object parse(Object value, Field field) {
        Type type = field.getType();

        if(type == boolean.class)
            value = Boolean.parseBoolean(value.toString());
        else if(type == int.class)
            value = Integer.parseInt(value.toString());

        return value;
    }

    public static Module of(String propertiesPath, String... more) {
        Properties properties = new Properties();

        try {
            properties.load(Files.newInputStream(Paths.get(propertiesPath, more)));
        } catch(Exception e) {
            log.error("can't load config file {}", propertiesPath);
            throw new RuntimeException(e);
        }

        return new SettingModule(properties);
    }
}

然后注入你的领域

@InjectSetting("database.port")
private int port;