上一节学习了注入Bean的生命周期,今天再来看看另一个话题: Bean的生产(@Produces)及销毁(@Disposes),这有点象设计模式中的工厂模式。在正式学习这个之前,先来看一个场景:
基于web的db应用开发中,经常要在一个页面上连接db,然后干点啥,最后关闭连接。下面用之前二节前到的CDI技能来演练一下:
1、先建一个Connection的接口
1 package conn;
2
3 public interface Connection {
4
5 void connect();
6
7 void closeConnection();
8
9 String doSomething();
10
11 }
2、再来一个实现
1 package conn;
2
3 import javax.annotation.PostConstruct;
4 import javax.annotation.PreDestroy;
5
6 public class ConnectionImpl implements Connection {
7 /**
8 * Servlet构造函数调用后,会自动执行带有@PostConstruct的方法
9 */
10 @PostConstruct
11 private void initConn(){
12 System.out.println("initConn is called...");
13 connect();
14 }
15
16 /**
17 * Servlet卸载前,会自动执行带有@PreDestroy的方法
18 */
19 @PreDestroy
20 private void destroyConn(){
21 System.out.println("destroyConn is called...");
22 closeConnection();
23 }
24
25 @Override
26 public void connect() {
27 System.out.println("Connecting...");
28
29 }
30
31 @Override
32 public void closeConnection() {
33 System.out.println("Closing connection...");
34
35 }
36
37 @Override
38 public String doSomething() {
39 String msg = "do something...";
40 System.out.println(msg);
41 return msg;
42
43 }
44
45 }
注:留意一下@PostConstruct与@PreDestroy这二个特殊的注解。我们知道所有jsf/jsp页面,最终运行时,实际上执行的是背后对应的Servlet,整个Servlet的生命周期在加入了这二个注解后,其执行顺序如下:
所以,当ConnectionImpl最终被注入到Controller中时,会自动先调用initConn方法建立连接,在整个Request结束前,自动调用destroyConn关闭连接。
3、创建Controller类
1 package controller;
2
3 import javax.inject.Inject;
4 import javax.inject.Named;
5
6 import conn.Connection;
7 import conn.TestConnection;
8
9 @Named("Conn")
10 public class ConnectionController {
11
12 @Inject
13 private Connection connection;
14
15 public Connection getConnection() {
16 return connection;
17 }
18
19 }
4、新建conn.xhtml用于显示
1 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
2 <html xmlns="http://www.w3.org/1999/xhtml"
3 xmlns:h="http://java.sun.com/jsf/html"
4 xmlns:f="http://java.sun.com/jsf/core"
5 xmlns:ui="http://java.sun.com/jsf/facelets">
6
7 <h:head>
8 <title>Connection Test</title>
9 </h:head>
10 <body>
11 #{Conn.connection.doSomething()}
12 </body>
13 </html>
eclipse里部署到jboss下,浏览http://localhost:8080/cdi-scope-sample/conn.jsf,观察console的输出:
跟预想的完全一样! 条条道路通罗马,解决问题的途径往往不止一条,或许有些人不喜欢在ConnectionImpl里参杂太多其它的职责(比如:自动打开连接、自动关闭连接),可以考虑用CDI的produces及disposes.
5、创建ConnectionFactory
回想一下设计模式中的工厂模式,对象的创建(销毁)通常放在一个单独的工厂类来处理(单一职责原则),我们也来建一个工厂:
1 package conn;
2
3 import javax.enterprise.context.RequestScoped;
4 import javax.enterprise.inject.*;
5
6 public class ConnectionFactory {
7
8 @Produces
9 @RequestScoped
10 @MyConnection
11 public Connection getConn() {
12 System.out.println("ConnectionFactory.getConn is called...");
13 Connection conn = new ConnectionImpl();
14 conn.connect();
15 return conn;
16
17 }
18
19
20 public void closeConn(@Disposes @MyConnection Connection conn) {
21 System.out.println("ConnectionFactory.closeConn is called...");
22 conn.closeConnection();
23 }
24
25 }
注:关注一下@Produces这个注解,这表示应用该注解的方法,是一个Bean的生成器(或理解成工厂的某些产品生产流水线),在需要Inject的时候,会自动通过该方法产生对象实例;而@Disposes注解,正好与@Produces对应,用于人道毁灭@Produces产生的对象,此消彼涨,这样世界才会遵从守恒定律!
@RequestScoped不用多解释了,表示工厂里产生的Bean其生命周期仅存在于单次Http请求中。
but,just wait a minute,@MyConnection ? what is this ? why we need it ?
让我们将思维方式,从人类大脑切换成计算机电脑的模式,ConnectionImpl继承自Connection,对于系统来讲,这二个是都是兼容Connection类型的,在产生对象时,这还好说,因为目前Connection只有一个实现类ConnectionImpl,计算机可以足够智能的推断出应该用ConnectionImpl来创建对象实例,但是对象销毁的时候呢?这时传入的参数类型是Connection接口类型,这时它并不知道该对象具体是何种实现?
所以,我们自己创建了一个@MyConnection注解,在@Produces与@Disposes上都应用该注解,这样对象销毁时,就能根据该注解精确的知道是要销毁何种类型的哪个对象.
6、@MyConnection代码如下:
1 package conn;
2
3 import java.lang.annotation.Retention;
4 import java.lang.annotation.Target;
5
6 import static java.lang.annotation.ElementType.FIELD;
7 import static java.lang.annotation.ElementType.TYPE;
8 import static java.lang.annotation.ElementType.METHOD;
9 import static java.lang.annotation.ElementType.PARAMETER;
10 import static java.lang.annotation.RetentionPolicy.RUNTIME;
11
12 import javax.inject.Qualifier;
13
14 @Qualifier
15 @Retention(RUNTIME)
16 @Target({ FIELD, TYPE, METHOD, PARAMETER })
17 public @interface MyConnection {
18
19 }
7、修改ConnectionController
1 @Inject
2 @MyConnection
3 private Connection connection;
在原来的@Inject下,增加@MyConnection,否则Controller感受不到Factory的存在(系统将只是简单的注入一个ConnectionImpl实例而已,不会自动创建连接/关闭连接),感兴趣的同学可以先不加这个注释,然后运行试试,体会一下
编译、部署、运行,观察Console的输出:
Perfect!
8、@Produces当成资源池使用
@Produces还有一个用途,可以把一些其它地方需要用到的注入对象,统一放在一起先“生产”好,形成一个"资源池",在需要使用的地方,直接从池里拿来用即可.
下面演示了这种用法:
8.1 先定义一个Product POJO类:
1 package model;
2
3 public class Product {
4
5 private String productName;
6
7 private String productNo;
8
9 public String getProductName() {
10 return productName;
11 }
12
13 public void setProductName(String productName) {
14 this.productName = productName;
15 }
16
17 public String getProductNo() {
18 return productNo;
19 }
20
21 public void setProductNo(String productNo) {
22 this.productNo = productNo;
23 }
24
25 @Override
26 public String toString() {
27 return productNo + "," + productName;
28 }
29
30 }
8.2 再创建一个Resocues.java,用来统一管理需要用到的资源
1 package resource;
2
3 import javax.enterprise.inject.Produces;
4 import javax.inject.Named;
5
6 import model.Product;
7
8 public class Resouces {
9
10 @Produces
11 @Named
12 public Product getNewProduct() {
13 Product product = new Product();
14 product.setProductName("new product");
15 product.setProductNo("000000");
16 return product;
17 }
18
19 }
8.3 然后在页面上就可以直接使用了
1 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
2 <html xmlns="http://www.w3.org/1999/xhtml"
3 xmlns:h="http://java.sun.com/jsf/html"
4 xmlns:f="http://java.sun.com/jsf/core"
5 xmlns:ui="http://java.sun.com/jsf/facelets"
6 xmlns:c="http://java.sun.com/jsp/jstl/core">
7
8 <h:head>
9 <title>CDI Sample Test</title>
10 </h:head>
11 <body>#{newProduct.toString()}
12 </body>
13 </html>
注意:这里我们并没有任何的Controller,Resouces类本身也没有使用@Named之类的注解,只是在方法getNewProduct上使用了 @Produces、 @Named,页面上就可以直接使用资源池中的对象了.