DI Frameworks - hidden pearls

prepare for…
DI - Frameworks
..some hidden pearls

@SvenRuppert
has been coding java since 1996
Head of R&D / Fellow
reply
Germany - Munich
2

@SvenRuppert
3

@SvenRuppert
Projects in the ﬁeld of:
•Automobile-industry
•Energy
•Finance / Leasing
•Space- Satellit-
•Government / UN / World-bank
Where?
•Europe
•Asia - from India up to Malaysia
3

4
Save harbor statement
The following is intended for information purposes only. I
can not be held responsible for the overuse of effects and
animations in this presentation. If any person in this room
has a medical condition that is triggered by fast moving
objects on the screen and/or explosions, he/she should
probably better leave now…
(I got carried away by the topic.)

5
The Basics @SvenRuppert
targets we want to reach

5
divide a system into modules

5
decouple contract and implementations

5
decrease complexity

5
decrease complexity
but… lets start with the basics

6
public List<Data> execute() {
//....
return result;
}

6
//....
return result;
}
import java.util.List;

6
//....
return result;
}
ﬁnal List<Data> result = new ArrayList<>();

6
//....
return result;
}
import java.util.ArrayList;

6
//....
return result;
}
if we don´t need a method like trimToSize()

6
//....
return result;
}
we want to get rid of the dep. ArrayList

7
this will lead to some questions

7
what will be the right Implementation?

7
what is the right time to decide?

7
what is the right freq. to decide?

8

9
with default Java SE

9
public class ListFactory { 
 
 
 
 
public static void main(String[] args) { 
 
 
 
} 
}

9
 
 
 
 
 
 
 
} 
}

9
 
 
 
 
 
 
 
} 
}
public static List createArrayList() { return new ArrayList(); }

9
 
 
 
 
 
 
 
} 
}
ﬁnal List arrayList = createArrayList();

9
 
 
 
 
 
 
 
} 
}

9
 
 
 
 
 
 
 
} 
}
public static List createLinkedList() { return new LinkedList(); }

9
 
 
 
 
 
 
 
} 
}
ﬁnal List linkedList = createLinkedList();

9
 
 
 
 
 
 
 
} 
}
import java.util.LinkedList;

9
 
 
 
 
 
 
 
} 
}
public static List createList() { return new ArrayList(); }

9
 
 
 
 
 
 
 
} 
}
ﬁnal List list = createList();

9
 
 
 
 
 
 
 
} 
}
ﬁnal List list = createList();
What goals we
reached?

10
//....
return result;
}
//....
return result;
}
import org.rapidpm.ListFactory;
ﬁnal List<Data> result = ListFactory.createArrayList();

11
Scopes:

11
Scopes:
Application / Singleton

11
Scopes:
Session

11
Scopes:
Session
Request

11
Scopes:
Session
Request
Method

12
public interface Service { 
String doWork(); 
}

12
String doWork(); 
} public static class Service2Inject implements Service { 
public String doWork() { 
return null; 
} 
}

12
String doWork(); 
return null; 
} 
}
public static class BusinessModulA { 
private Service service; 
 
public BusinessModulA(ﬁnal Service service) { 
this.service = service; 
} 
public void work() { 
service.doWork(); 
} 
}

12
String doWork(); 
return null; 
} 
}
public static class BusinessModulA { 
 
public BusinessModulA(ﬁnal Service service) { 
} 
} 
}
constructor

13
String doWork(); 
return null; 
} 
}

13
String doWork(); 
return null; 
} 
}
public static class BusinessModulB { 
 
public void setService(ﬁnal Service service) { 
} 
 
} 
}

13
String doWork(); 
return null; 
} 
}
public static class BusinessModulB { 
 
public void setService(ﬁnal Service service) { 
} 
 
} 
}
expl. setter

14
String doWork(); 
return null; 
} 
}

14
String doWork(); 
return null; 
} 
}
public static class BusinessModulC { 
 
} 
}

14
String doWork(); 
return null; 
} 
}
public static class BusinessModulC { 
 
} 
}
reﬂection

15
BusinessModulA businessModulA  
= new BusinessModulA(new Service2Inject()); 
businessModulA.work();

15
T1: create the instance of the Service

15
T2: create the instance of the BusinessModul

15
T3: method invoke

16
ﬁnal BusinessModulB businessModulB = new BusinessModulB(); 
businessModulB.setService(new Service2Inject()); 
businessModulB.work();

16

16
T3: set the Service

16
T3: set the Service
T4: invoke method

17
ﬁnal BusinessModulC businessModulC = new BusinessModulC(); 
try { 
ﬁnal Field serviceField = BusinessModulC.class 
.getDeclaredField("service"); 
serviceField.set(businessModulC, new Service2Inject()); 
} catch (NoSuchFieldException | IllegalAccessException e) { 
e.printStackTrace(); 
} 
businessModulC.work();

17
try { 
} 
T1: create the instance of the BusinessModule

17
try { 
} 

17
try { 
} 
T3: set the Service

17
try { 
} 
T3: set the Service
T4: invoke method

Dependency Injection
18
@SvenRuppert
every framework will have a strategy how to

18
@SvenRuppert
resolve the Implementation

18
@SvenRuppert
create/set the instance

18
@SvenRuppert
create/set the instance
manage the timeline

A short view on WELD-SE - CDI
19
@SvenRuppert
website : http://weld.cdi-spec.org/
the following features are available ( SE )

19
@SvenRuppert
@PostConstruct and @PreDestroy lifecycle callbacks

19
@SvenRuppert
Dependency injection with qualiﬁers and alternatives

19
@SvenRuppert
@Application, @Dependent and @Singleton scopes

19
@SvenRuppert
Interceptors and decorators

19
@SvenRuppert
Stereotypes - combined Qualiﬁer

19
@SvenRuppert
Events

19
@SvenRuppert
Portable extension support
Events

20
@SvenRuppert

20
@SvenRuppert
String doWork(String txt); 
}

20
@SvenRuppert
} public class ServiceDefault implements Service { 
public String doWork(ﬁnal String txt) { 
return this.getClass().getSimpleName() + " " + txt; 
} 
}

20
@SvenRuppert
} 
}
@Inject Service serviceDefault;

20
@SvenRuppert
} 
}
@Inject Service serviceDefault; OK

20
@SvenRuppert
} 
}
public class Service_A implements Service { 
@Override 
public String doWork(String txt) { 
} 
}
OK

20
@SvenRuppert
} 
}
@Override 
} 
}
WELD-001409: Ambiguous dependencies

20
@SvenRuppert
} 
}
@Override 
} 
}
@Prod
WELD-001409: Ambiguous dependencies

20
@SvenRuppert
} 
}
@Override 
} 
}
@Prod
OK

20
@SvenRuppert
} 
}
@Override 
} 
}
@Prod
@Inject @Prod Service serviceProd;
OK

21
@SvenRuppert
}

21
@SvenRuppert
}
public static class ServiceProducer{ 
@Produces @WithProducer 
public Service create(){ 
return txt -> Service.class.getSimpleName() + " " + txt; 
} 
}

21
@SvenRuppert
}
public static class ServiceProducer{ 
@Produces @WithProducer 
public Service create(){ 
return txt -> Service.class.getSimpleName() + " " + txt; 
} 
}
@Inject @WithProducer Service serviceProd;

22
@SvenRuppert
}

22
@SvenRuppert
}
@Alternative 
public class ServiceAlternative implements Service { 
@Override 
} 
}

22
@SvenRuppert
}
@Alternative 
@Override 
} 
}
@Inject Service serviceProd;

22
@SvenRuppert
}
@Alternative 
@Override 
} 
}
@Inject Service serviceProd;
<beans ... > 
<alternatives> 
<class>org.rapidpm.ServiceAlternative</class> 
</alternatives> 
</beans>

23
@SvenRuppert

23
@SvenRuppert
@Inject Service service;

23
@SvenRuppert
Service service = container.select(Service.class).get();

23
@SvenRuppert
@Inject Instance<Service> serviceDefaultProxy;

23
@SvenRuppert
Service serviceDevProxy = container 
.instance() 
.select(Service.class) 
.select(new AnnotationLiteral<DEV>(){}) 
.get();

23
@SvenRuppert
@Inject @WithProducer Service serviceProd;
Service serviceDevProxy = container 
.instance() 
.select(Service.class) 
.select(new AnnotationLiteral<DEV>(){}) 
.get();

24
@SvenRuppert
programmatically injection

24
@SvenRuppert

24
@SvenRuppert
@Inject Service service; Service service = container.select(Service.class).get();

24
@SvenRuppert
public <T> T activateCDI(T t) {

24
@SvenRuppert
ﬁnal Class aClass = t.getClass();

24
@SvenRuppert
ﬁnal BeanManager beanManager = CDI.current().getBeanManager();

24
@SvenRuppert
ﬁnal AnnotatedType annotationType 
= beanManager.createAnnotatedType(aClass);

24
@SvenRuppert
ﬁnal InjectionTarget injectionTarget 
= beanManager.createInjectionTarget(annotationType);

24
@SvenRuppert
ﬁnal CreationalContext creationalContext 
= beanManager.createCreationalContext(null);

24
@SvenRuppert
= beanManager.createCreationalContext(null); 
injectionTarget.inject(t, creationalContext);

24
@SvenRuppert
injectionTarget.postConstruct(t);

24
@SvenRuppert
return t; 
}
injectionTarget.postConstruct(t);

BoonDI - Project bootstrapping
25
@SvenRuppert
website :  
https://github.com/boonproject/boon/wiki/Boon-DI

25
@SvenRuppert
<dependency> 
<groupId>io.fastjson</groupId> 
<artifactId>boon</artifactId> 
<version>0.33</version> 
</dependency>
website :  

25
@SvenRuppert
<dependency> 
<groupId>javax.enterprise</groupId> 
<artifactId>cdi-api</artifactId> 
</dependency> 
<dependency> 
<groupId>io.fastjson</groupId> 
<artifactId>boon</artifactId> 
</dependency>
website :  

BoonDI - not a replacement for …..
26
@SvenRuppert
website :  

26
@SvenRuppert
website :  
@In (old from Seam)

26
@SvenRuppert
website :  
@PostConstruct @In (old from Seam)

26
@SvenRuppert
website :  
@PostConstruct @In (old from Seam)
@Autowired (from Spring)

26
@SvenRuppert
website :  
@PostConstruct
@Inject
@In (old from Seam)

26
@SvenRuppert
website :  
@PostConstruct
@Inject
@Named
@In (old from Seam)

26
@SvenRuppert
website :  
@PostConstruct
@Inject
@Named
@In (old from Seam)
@Required (from Spring)

26
@SvenRuppert
website :  
@PostConstruct
@Inject
@Named
@In (old from Seam)
@Qualiﬁer (from Spring)

26
@SvenRuppert
website :  
@PostConstruct
@Inject
@Named
@In (old from Seam)
@Qualiﬁer (from Spring)
no Scopes

27
@SvenRuppert
website :  
Boon is not using
- AnnotationProcessing
- ByteCode - Manipulation

27
@SvenRuppert
website :  
Boon is not using
- AnnotationProcessing
- ByteCode - Manipulation
OK, this will lead
to Reﬂection or?

28
BoonDI - Hello World @SvenRuppert

28
public class Service { 
 
@Inject SubService subService; 
 
@PostConstruct 
public void printInfoPostconstruct() { 
System.out.println("printInfoPostconstruct() " 
+ this.getClass().getSimpleName()); 
} 
}

28
public class Service { 
 
@Inject SubService subService; 
 
@PostConstruct 
} 
}
public class SubService { 
@PostConstruct 
} 
}

29

29
ﬁnal Module module = DependencyInjection.classes(Service.class);

29
ﬁnal Service service1 = module.get(Service.class);

30

30
SubService == null

30
SubService == null
ﬁnal Module module = DependencyInjection 
.classes(Service.class, SubService.class);

30
SubService == null
ﬁnal Context context = DependencyInjection.context(module);

30
SubService == null
ﬁnal Service service2 = context.get(Service.class);

30
SubService == null
SubService != null

31

31
public class ServiceModule { 
 
 
}

31
 
 
}
public Service provideService(){ return new Service(); }

31
 
 
}
public SubService provideSubService() { return new SubService(); }

31
 
 
}
.module(new ServiceModule());

31
 
 
}

32
 
 
}

32
 
 
}
naming conventions

32
 
 
}
naming conventions
not refactoring safe

33
BoonDI - Modules @SvenRuppert
at runtime you can
addModule() removeModule()

34
BoonDI - Modules - be careful :-) @SvenRuppert

34
public class ServiceModuleA {

34
public Service provideServiceA() { out.println("provideServiceAA ...");

34
public Service provideServiceB() { out.println("provideServiceAB ...");

34
public Service provideServiceC() { out.println("provideServiceAC ...");

34
public class ServiceModuleB {

34
public Service provideServiceA() { out.println("provideServiceBA ...");

34
public Service provideServiceB() { out.println("provideServiceBB ...");

34
public Service provideServiceC() { out.println("provideServiceBC ...");

34
public Service provideServiceC() { out.println("provideServiceBC ...");
ﬁnal Module moduleA = DependencyInjection.module(new ServiceModuleA()); 
ﬁnal Module moduleB = DependencyInjection.module(new ServiceModuleB());

35
public class ServiceModuleA { public Service provideServiceA() { "provideServiceAA ...");
public Service provideServiceB() {"provideServiceAB ...");
public Service provideServiceC() {"provideServiceAC ...");
public class ServiceModuleB { public Service provideServiceA() { "provideServiceBA ...");
public Service provideServiceB() { "provideServiceBB ...");
public Service provideServiceC() {"provideServiceBC ...");

35
ﬁnal Context context = DependencyInjection.context(moduleA);

35
context.get(Service.class);

35
context.get(Service.class); provideServiceAB

35
ﬁnal Context add = context.add(moduleB);

35

35
add.get(Service.class);
provideServiceAB

35
provideServiceAB
provideServiceAB

35
provideServiceAB
provideServiceAB
ﬁnal Context context = DependencyInjection.context(moduleA,moduleB);

35
provideServiceAB
provideServiceAB

36

36
ﬁnal Context context = DependencyInjection.context(moduleB);

36

36
context.get(Service.class); provideServiceBB

36
ﬁnal Context add = context.add(moduleA);

36

36
provideServiceBB

36
provideServiceBB
provideServiceBB

36
provideServiceBB
provideServiceBB
ﬁnal Context context = DependencyInjection.context(moduleB,moduleA);

36
provideServiceBB
provideServiceBB

36
provideServiceBB
provideServiceBB
So far so good….
but what could
happen??

37
public class ServiceModuleA { public Service provideServiceB() {"provideServiceAB ...");
public class ServiceModuleB { public Service provideServiceB() {"provideServiceBB ...");

37
ﬁnal Module moduleA1 = DependencyInjection.module(new ServiceModuleA());

37

37
ﬁnal Module moduleB1 = DependencyInjection.module(new ServiceModuleB());

37

37
ﬁnal Context context = DependencyInjection

37
.context(moduleA1)

37
.context(moduleA1).context(moduleB1)

37
.context(moduleA2)

37
.context(moduleA2).context(moduleB2);

37

37
context.remove(moduleA1);
provideServiceAB

37
context.remove(moduleA1); context.get(Service.class);
provideServiceAB

37
provideServiceAB
provideServiceBB

37
context.remove(moduleB1);
provideServiceAB
provideServiceBB

37
context.remove(moduleB1); context.get(Service.class);
provideServiceAB
provideServiceBB

37
provideServiceAB
provideServiceBB
provideServiceAB

37
context.remove(moduleA2);
provideServiceAB
provideServiceBB
provideServiceAB

37
provideServiceAB
provideServiceBB
provideServiceAB

DI Frameworks - hidden pearls

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a DI Frameworks - hidden pearls

Similar a DI Frameworks - hidden pearls (20)

Más de Sven Ruppert

Más de Sven Ruppert (15)

Último

Último (20)

DI Frameworks - hidden pearls