CDI

★JavaEE 6のアノテーションに関する使い分け

シングルトン関連

@javax.ejb.Singleton（JSR-318、EJB3.1仕様）

セッションBeanの一種、EJBコンテナのトランザクションや同時実行制御の機能を使う

@javax.inject.Singleton(JSR-330、DI仕様)

@javax.enterprise.inject.ApplicationScoped（JSR-299、CDI仕様)

通常のEJBコンテナ

@javax.faces.bean.ApplicationScoped （JSR-314、JSF2.0仕様)

Tomcat+Springなどの環境（CDIを利用しない）でシングルトン的な管理Beanを定義する

管理Bean関連

@javax.annotation.ManagedBean（JSR-250、JSR-316)

サービス層で利用、EL式と互換性がない

@javax.faces.bean.ManagedBean（JSR-314、JSF2.0仕様)

JSFの管理Bean

スコープ関連

@javax.faces.bean.CustomScoped

@javax.faces.bean.RequestScoped

@javax.faces.bean.ViewScoped

@javax.faces.bean.SessionScoped

@javax.faces.bean.ApplicationScoped

※JSF2.0仕様の管理Bean

@javax.enterprise.context.RequestScoped

@javax.faces.view.ViewScoped

@javax.enterprise.context.ConversationScoped

@javax.faces.flow.FlowScoped

@javax.enterprise.context.SessionScoped

@javax.enterprise.context.ApplicationScoped

※CDI仕様の管理Bean

@RequestScoped

//@SessionScoped

//@ApplicationScoped

public class MyBean implements Serializable {

@PostConstruct

private void init(){

...

}

@PreDestroy

private void destroy(){

...

}

}

@Named

@ConversationScoped

public class MyController implements Serializable {

@Inject

private Conversation conversation;

public void begin() {

...

conversation.begin();

}

public void end() {

...

conversation.end();

}

}

ApplicationScoped ⇒ SessionScoped ⇒ RequestScopedの順で出力：

ApplicationScoped(PostConstruct)

SessionScoped(PostConstruct)

RequestScoped(PostConstruct)

RequestScoped(PreDestroy)

Server shutdown initiated

SessionScoped(PreDestroy)

ApplicationScoped(PreDestroy)

インジェクション関連

EJBのインジェクションについて、@EJBと@Injectを使う

@javax.annotation.ManagedBeanで定義された管理Beanに対して、@Resourceと@Injectを使う

CDIを利用するなら、@Injectに統一する

@EJBの用途はリモートインターフェースをインジェクションする

★Instanceについて

@Qualifier

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)

public @interface MyQualifier {

}

public interface MyInterface {

void execute();

}

public class MyClass1 implements MyInterface {

@Override

public void execute() {

System.out.println("MyClass1");

}

}

@MyQualifier

public class MyClass2 implements MyInterface {

@Override

public void execute() {

System.out.println("MyClass2");

}

}

import javax.enterprise.inject.Any;

import javax.enterprise.inject.Instance;

import javax.inject.Inject;

@Inject

@Any

Instance<MyInterface> instance1;

@Inject

Instance<MyInterface> instance2;

public void execute() {

MyInterface obj;

// @Any あり

obj = instance1.select(MyClass1.class).get();

obj.execute(); //MyClass1

obj = instance1.select(MyClass2.class).get();

obj.execute(); //MyClass2

// @Any なし

obj = instance2.select(MyClass1.class).get();

obj.execute(); //MyClass1

obj = instance2.select(MyClass2.class).get();

obj.execute(); //例外

}

@Anyを付ける場合、Qualifierを無視

@Anyを付けない場合、Qualifierのないインスタンスのみが選択される

public interface MyService { ... }

public class MyImpl1 implements MyService { ... }

@Custom

public class MyImpl2 implements MyService { ... }

@Inject

MyService myService;

@Inject @Default

MyService myService;

@Inject @Any ×

MyService myService;

@Inject @Any @Custom

MyService myService;

@Inject @Any @Default

MyService myService;

@Inject @Custom

MyService myService;

他のメソッド

@Inject

@Any

Instance<MyInterface> instance;

if (instance.isUnsatisfied()) {

...

} else if (instance.isAmbiguous()) {

for (MyInterface i : instance) {

System.out.println("%s%n", i);

}

} else {

System.out.println(instance.get());

}

リスト

@Inject

public void listImplementations(

@Any Instance<Service> serviceList) {

for(Service service : serviceList){

System.out.println(service.getClass().getCanonicalName());

}

...

}

★BeanManagerについて

import javax.enterprise.inject.spi.BeanManager;

import javax.enterprise.inject.spi.Bean;

try {

BeanManager bm = InitialContext.doLookup("java:comp/BeanManager");

Set<Bean<?>> beans = bm.getBeans(MyInterface.class);

Bean<?> bean = bm.resolve(beans); // 一意の場合

CreationalContext<?> cc = bm.createCreationalContext(bean);

MyInterface i = (MyInterface) bm.getReference(bean, MyInterface.class, cc);

...

} catch (NamingException e) {

...

}

@Resource

private BeanManager beanManager;

Class<? extends XXX> type = ...;

Set<Bean<?>> beans = beanManager.getBeans(type);

Bean<?> bean = beanManager.resolve(beans);

CreationalContext<?> creationalContext = beanManager

.createCreationalContext(bean);

MyClass c = (MyClass) beanManager.getReference(bean, type, creationalContext);

★InjectionPointについて

サンプル１

@Retention(RUNTIME)

@Target(FIELD)

public @interface FtpHostname {

String value();

}

import javax.enterprise.inject.Produces;

import javax.enterprise.inject.spi.Annotated;

import javax.enterprise.inject.spi.InjectionPoint;

import org.apache.commons.net.ftp.FTPClient;

public class NetProducer {

@Produces

public FTPClient createFtpClient(InjectionPoint ip)

throws SocketException, IOException{

Annotated annotated = ip.getAnnotated();

FtpHostname hostname =

annotated.getAnnotation(FtpHostname.class);

FTPClient ftpClient = new FTPClient();

if(hostname != null){

ftpClient.connect(hostname.value());

}

return ftpClient;

}

}

@Inject

@FtpHostname(value = "ftp.domain.com")

private FTPClient ftpClient;

サンプル２

@Retention(RUNTIME)

@Target({FIELD, TYPE, METHOD})

public @interface NotificationServiceType {

ServiceType value();

public enum ServiceType{

EMAIL(EmailNotificationService.class),

SMS(SmsNotificationService.class);

Class<? extends NotificationService> clazz;

private ServiceType(Class<? extends NotificationService> clazz){

this.clazz = clazz;

}

public Class<? extends NotificationService> getClazz() {

return clazz;

}

}

}

import javax.enterprise.inject.Any;

import javax.enterprise.inject.Instance;

import javax.enterprise.inject.Produces;

import javax.enterprise.inject.spi.Annotated;

import javax.enterprise.inject.spi.InjectionPoint;

public class ServiceFactory {

@Produces

@MyService

public NotificationService createService(

@Any Instance<NotificationService> instance, InjectionPoint ip){

Annotated annotated = ip.getAnnotated();

NotificationServiceType type =

annotated.getAnnotation(NotificationServiceType.class);

Class<? extends NotificationService> clazz =

type.value().getClazz();

return instance.select(clazz).get();

}

}

@Qualifier

@Retention(RUNTIME)

@Target({FIELD, TYPE, METHOD})

public @interface MyService { }

@Inject

@MyService

@NotificationServiceType(ServiceType.SMS)

private NotificationService notificationService;

サンプル３ (Log)

import javax.enterprise.inject.Produces;

import javax.enterprise.inject.spi.InjectionPoint;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class Resources {

@Produces

public Logger loggerProducer(InjectionPoint ip){

return LoggerFactory.getLogger(

ip.getMember().getDeclaringClass().getName());

}

}

@Inject

private Logger logger;

// 従来

private Logger logger = LoggerFactory.getLogger(getClass().getName());

サンプル４ （JSF）

@HttpParam("username")

@Inject

private String username;

@HttpParam("password")

@Inject

private String password;

@Produces

@HttpParam("")

public String getParamValue(InjectionPoint ip) {

ServletRequest request =

(ServletRequest) FacesContext.getCurrentInstance()

.getExternalContext().getRequest();

return request.getParameter(

ip.getAnnotated().getAnnotation(HttpParam.class).value());

}

サンプル5 (Primitives)

@Singleton

@Startup

public class HitsTimer {

@Inject

private int hitsRate;

...

}

@Singleton

@Startup

public class Configuration {

private Map configuration;

private Set unconfiguredFields;

@PostConstruct

public void init() {

this.configuration = new HashMap();

this.unconfiguredFields = new HashSet();

}

@Produces

public String getString(InjectionPoint point) {

String fieldName = point.getMember().getName();

String value = configuration.get(fieldName);

if (value == null) {

this.unconfiguredFields.add(fieldName);

}

return value;

}

@Produces

public int getInteger(InjectionPoint point) {

String value = getString(point);

if (value == null) {

return 0;

}

return Integer.parseInt(value);

}

...

}