Java：方法链接和依赖注入

Question

使用依赖注入框架（比如HK2）管理的服务时，使用方法链接是否可以接受？

我不确定是否允许它“缓存”实例，即使它只在注入范围内。

创建比萨饼的示例服务：

@Service
public class PizzaService {

    private boolean peperoni = false;
    private boolean cheese = false;
    private boolean bacon = false;

    public PizzaService withPeperoni() {
        peperoni = true;
        return this;
    }

    public PizzaService withCheese() {
        cheese = true;
        return this;
    }

    public PizzaService withBacon() {
        bacon = true;
        return this;
    }

    public Pizza bake() {
        // create the instance and return it
    }
}

在这里，服务被注入到JAX-RS资源中：

@Path('pizza')
public class PizzaResource {

    @Inject
    PizzaService pizzaService;

    @GET
    public Response getPizza() {
        Pizza pizza = pizzaService
            .withPeperoni()
            .withCheese()
            .bake();

        return Response.ok(pizza).build();
    }
}

Answer 1

基于@JinKwon的答案及其评论，这是我的解决方案：

• 该服务被标记为@PerLookup，因为@Singleton是默认值。（谢谢@M.Deinum）

按照这种方法，我可以使用方法链接，返回this。而且，这对我来说很重要，实例由DI内核管理，并且可以访问依赖性注入本身。

服务：

@Service
@PerLookup
public class PizzaService {

    Pizza pizza = new Pizza(); // naked pizza by default

    @Inject
    OvenService    oven; // just to show that I can use @Inject here

    public PizzaService withPeperoni() {
        pizza.peperoni = true;
        return this;
    }

    public PizzaService withCheese() {
        pizza.cheese = true;
        return this;
    }

    public PizzaService withBacon() {
        pizza.bacon = true;
        return this;
    }

    public Pizza bake() {
        return oven.bake(pizza);
    }
}

资源：

@Path('pizza')
public class PizzaResource {

    @Inject
    PizzaService pizzaService;

    @GET
    public Response getPizza() {
        Pizza pizza = pizzaService
            .withPeperoni()
            .withCheese()
            .bake();

        return Response.ok(pizza).build();
    }
}

Unittest（通过javax.inject.提供程序注入的示例）：

@HK2
@Test
public class PizzaServiceNGTest {

    @Inject
    PizzaService pizzaService;

    @Inject
    Provider<PizzaService> pizzaServiceProvider;

    public void testProviderInjection() {
        Pizza pizza;

        // pizza with the works
        pizza = pizzaServiceProvider.get()
            .withPeperoni()
            .withBacon()
            .withCheese()
            .bake();

        assertTrue(pizza.peperoni);
        assertTrue(pizza.bacon);
        assertTrue(pizza.cheese);

        // naked pizza
        pizza = pizzaServiceProvider.get()
            .bake();

        assertFalse(pizza.peperoni);
        assertFalse(pizza.bacon);
        assertFalse(pizza.cheese);
    }

    public void testDirectInjection() {
        Pizza pizza;

        // pizza with the works
        pizza = pizzaService
            .withPeperoni()
            .withBacon()
            .withCheese()
            .bake();

        assertTrue(pizza.peperoni);
        assertTrue(pizza.bacon);
        assertTrue(pizza.cheese);

        // naked pizza
        pizza = pizzaService
            .bake();

        // this is where it goes wrong: the pizzaService hasn't been reset and
        // is messing up the order!
        assertFalse(pizza.peperoni);    // will fail
        assertFalse(pizza.bacon);   // will fail
        assertFalse(pizza.cheese);  // will fail
    }

}

Answer 2

这取决于JAX-RS资源的范围和服务的无状态。

通常，每次请求时都会创建每个JAX-RS资源实例。

默认情况下，将为对该资源的每个请求创建一个新的资源类实例。首先调用构造函数（参见第3.1.2节），然后注入任何请求的依赖项（参见第3.2节），然后调用适当的方法（参见第3.3节），最后使对象可用于垃圾收集。

对于以下HTTP请求，

GET /pizza HTTP/1.1

创建了一个新的PizzaResources实例，并在其中注入了一个可用的PizzaService实例。

现在，您要寻找的答案取决于容器可能维护的PizzaService的无状态性和生命周期。

希望我现在找不到规范，但是，即使PizzaService是@无状态的，容器也不会为不同的会话同时共享实例。

我将使用生命周期侦听器方法重置服务。

@Path("/pizza")
public class PizzaResource {

    @PostConstruct
    private void resetPizzaService() { // invoked after the injection
        pizzaService.reset();
    }

    @Inject
    private PizzaService pizzaService;
}

其中重置（）将执行

public void reset() {
    peperoni = false;
    cheese = false;
    bacon = false;
}

我刚刚为@Service找到了一个好的线程，它似乎是Spring框架的一部分。单例Bean如何处理并发请求？

Answer 3

您所做的对服务的所有其他用户都有副作用。它们都共享同一个服务实例，因此如果您使用peperoni调用，，它将为所有引用该服务的用户更改该布尔值。

您似乎想要的是使用Builder。也许你的服务可以实例化一个新的建设者，负责为你打造完美的比萨饼。这样可以避免所有可能的副作用：

@GET
public Response getPizza() {
    Pizza pizza = pizzaService.newPizzaBuilder()
        .withPeperoni()
        .withCheese()
        .bake();

    return Response.ok(pizza).build();
}

和比萨饼制造商：

public class PizzaBuilder {

    private boolean peperoni = false;
    private boolean cheese = false;
    private boolean bacon = false;

    public PizzaBuilder withPeperoni() {
        peperoni = true;
        return this;
    }

    public PizzaBuilder withCheese() {
        cheese = true;
        return this;
    }

    public PizzaBuilder withBacon() {
        bacon = true;
        return this;
    }

    public Pizza bake() {
        // create the instance and return it
    }
}

和比萨服务：

@Service
public class PizzaService {

    public PizzaBuilder newPizzaBuilder() {
        return new PizzaBuilder();
    }
}

这个解决方案并不完美，因为只实例化构建器的服务没有太多用处，但是它至少可以防止您的解决方案会遇到的副作用。