Play Framework IV 依赖注入(DI)

亦凉 2022-09-27 04:53 22阅读 0赞

### 1.Play框架依赖注入介绍 ###

Play框架提供基于[JSR 330][]的依赖注入。Play默认的JSR 330的实现是用[Guice][]实现的，但是其它的JSR 330实现也可以用。

### 2.声明依赖 ###

如果你有个组件（例如Controller）需要依赖其它组件，那么你就可以通过使用@Inject注解来声明。@Inject注解可以在属性或者构造方法上使用。例如，注入一个属性：

import javax.inject.*;
    import play.libs.ws.*;
    
    public class MyComponent {
        @Inject WSClient ws;
    
        // ...
    }

注意这些是实例变量，通常情况下注入一个静态属性是没有意义的，因为它会失去封装的意义。

另一个例子，注入一个构造方法：

import javax.inject.*;
    import play.libs.ws.*;
    
    public class MyComponent {
        private final WSClient ws;
    
        @Inject
        public MyComponent(WSClient ws) {
            this.ws = ws;
        }
    
        // ...
    }

虽然属性注入更短，但比较推荐使用构造方法注入的方式。这样更可测试，由于在单元测试中你需要传入所有的构造方法参数来创建一个对象实例，编译器需要确保依赖存在。且由于没有setter的存在，构造方法注入的方式也更易于理解。

### 3.组件的生命周期 ###

依赖注入系统管理注入组件的生命周期，当需要时创建它们然后将其注入到其它组件中。以下是组件生命周期如何工作的介绍：

*  **在任何时候，当某个组件被需要时就被创建。**如果一个组件不止一次的被用到，默认情况下，将会创建多个组件实例。如果你只想创建一个该组件的单例，你需要用@Singleton注解将其标记为一个单例。
 *  **实例在它们被需要时会懒加载。**如果一个组件从来都未被其它组件使用，那么它根本不会被创建。这通常情况下是有意义的，但是在一些情况下，你希望组件被立即加载哪怕它们从未被使用。举例来说，你可能要向一个远端系统发送一个信息或者在系统启动时预加载一个缓存。你可以通过使用[eager binding][]的方式强制创建一个组件。
 *  **实例不会被自动清理，**除了正常的垃圾回收。当组件不再被引用时，将会被GC回收，但是Play框架不会做任何特殊的事情来关闭组件，例如close方法。无论如何，Play提供了一类叫做closeApplicationLifecycly的特殊的组件，你可以将其注册进去以在系统停止的时候关闭它们。

### 4.单例 ###

有时你或许想让组件保持一些状态，例如缓存或者一个连向外部资源的链接，或者一个创建成本很高的组件。在这些情况下，创建一个该组件的单例是非常重要的。这些需求可以通过使用@Singleton注解来实现。例如：

import javax.inject.*;
    
    @Singleton
    public class CurrentSharePrice {
        private volatile int price;
    
        public void set(int p) {
            price = p;
        }
    
        public int get() {
            return price;
        }
    }

### 5.停止/清理 ###

当Play框架关闭时，一些组件需要被清理，例如停止线程池。Play框架提供了ApplicationLifecycle组件来注册这些需要在Play关闭时清理的组件：

import javax.inject.*; import play.inject.ApplicationLifecycle; import java.util.concurrent.Callable; import java.util.concurrent.CompletableFuture; @Singleton public class MessageQueueConnection { private final MessageQueue connection; @Inject public MessageQueueConnection(ApplicationLifecycle lifecycle) { connection = MessageQueue.connect(); lifecycle.addStopHook(() -> { connection.stop(); return CompletableFuture.completedFuture(null); }); } // ... }

ApplicationLifecycle将会按与创建顺序相反的顺序来停止所有组件。这意味着任何你所依赖的组件都将会被安全的引用，因为你依赖它们，它们必须在你的组件创建之前被创建，且直到该组件停止为止才能被清理。

注意，确保每个注册到销毁机制中的组件一定要是单例。任何非单例都可能是一个内存泄漏的隐患，因为新的组件在创建时都会注册到销毁机制中。

### 6.提供自定义绑定 ###

实践证明，通过接口来定义一个组件是非常好的，好于直接注入实现类本身。这样一来，你可以注册不同的实现类。若你声明的是接口，那这时依赖注入系统就需要知道需要在这个接口下绑定哪个实现类。最简单的方式就是通过@ImplementedBy注解来绑定实现类。以下是实现方式：

import com.google.inject.ImplementedBy;
    
    @ImplementedBy(EnglishHello.class)
    public interface Hello {
    
        String sayHello(String name);
    }

public class EnglishHello implements Hello {
    
        public String sayHello(String name) {
            return "Hello " + name;
        }
    }

在一些更复杂的情况下，你可能想要提供更复杂的绑定，例如当一个接口下有许多实现类需要注入时，可以通过@Nmed注解来区别。在下例中，你可以实现一个Guice Module：

import com.google.inject.AbstractModule;
    import com.google.inject.name.Names;
    
    public class Module extends AbstractModule {
        protected void configure() {
    
            bind(Hello.class)
                    .annotatedWith(Names.named("en"))
                    .to(EnglishHello.class);
    
            bind(Hello.class)
                    .annotatedWith(Names.named("de"))
                    .to(GermanHello.class);
        }
    }

如果你调用了Module并且将其置于根目录，它会自动地注册到Play框架中。亦或，你想起一个其它名字或者将其放置到其它包中，你可以在application.conf文件中的play.modules.enabled清单中追加它的全类名：

play.modules.enabled += "modules.HelloModule"

你也可以禁用根目录中Module的自动注册，通过将其加到disabled modules中来实现：

play.modules.disabled += "Module"

### 7.可配置的绑定 ###

有时你或许想在配置Guice绑定的时候读取Play框架的Configuration或者使用一个ClassLoader。你可以通过将其加入到你的module构造方法中的方式获取入口。

在下例中，Hello绑定需要读取configuration文件中的内容。

import com.google.inject.AbstractModule;
    import com.google.inject.ConfigurationException;
    import com.google.inject.name.Names;
    import play.Configuration;
    import play.Environment;
    
    public class Module extends AbstractModule {
    
        private final Environment environment;
        private final Configuration configuration;
    
        public Module(
              Environment environment,
              Configuration configuration) {
            this.environment = environment;
            this.configuration = configuration;
        }
    
        protected void configure() {
            // Expect configuration like:
            // hello.en = "myapp.EnglishHello"
            // hello.de = "myapp.GermanHello"
            Configuration helloConf = configuration.getConfig("hello");
            // Iterate through all the languages and bind the
            // class associated with that language. Use Play's
            // ClassLoader to load the classes.
            for (String l: helloConf.subKeys()) {
                try {
                    String bindingClassName = helloConf.getString(l);
                    Class<? extends Hello> bindingClass =
                      environment.classLoader().loadClass(bindingClassName)
                      .asSubclass(Hello.class);
                    bind(Hello.class)
                            .annotatedWith(Names.named(l))
                            .to(bindingClass);
                } catch (ClassNotFoundException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

举个实际应用中的例子，假设现在需要在配置文件中配置一个属性，然后在程序中读取。在application.conf中这么写：

test {
      content.test1 = "test content1"
    }

在Module类中这么写：

String content = configuration.getConfig("test").getString("content.test1")

其中，getConfic("test")中的test是那个组名。getString("content.test1")中的content.test1是那个属性名。最终得到的content变量的值就是test content1。

[JSR 330]: https://jcp.org/en/jsr/detail?id=330
[Guice]: https://github.com/google/guice
[eager binding]: https://www.playframework.com/documentation/2.5.x/JavaDependencyInjection#Eager-bindings