The document discusses dependency injection (DI) with programmatic configuration. It defines DI as a mechanism where dependencies between objects are not directly created but instead satisfied by a third party - a DI container. The document outlines reasons for using DI including loose coupling and inversion of control. It provides examples of DI in Java using annotations and explains concepts such as scopes, producers and programmatic configuration. It also discusses integrating DI into Vaadin applications using CDI extensions.

1. Dependency Injection
with Programmatic Configuration
Peter Lehto
Senior Vaadin Expert
@peter_lehto

2. Dependency Injection (DI) is a runtime mechanism

3. Dependency Injection (DI) is a runtime mechanism

4. Dependency Injection (DI) is a runtime mechanism
where dependency between the client object and the
dependent object does not occur directly.

5. Dependency Injection (DI) is a runtime mechanism
where dependency between the client object and the
dependent object does not occur directly.

6. Dependency Injection (DI) is a runtime mechanism
where dependency between the client object and the
dependent object does not occur directly.
With DI the client object does not necessarily manage
the lifecycle of the dependent object.

7. Dependency Injection (DI) is a runtime mechanism
where dependency between the client object and the
dependent object does not occur directly.
With DI the client object does not necessarily
manage the lifecycle of the dependent object.

8. Dependency Injection (DI) is a runtime mechanism
where dependency between the client object and the
dependent object does not occur directly.
With DI the client object does not necessarily
manage the lifecycle of the dependent object.
Instead with DI a special DI container takes care of
the object lifecycle management

9. Dependency Injection (DI) is a runtime mechanism
where dependency between the client object and the
dependent object does not occur directly.
With DI the client object does not necessarily
manage the lifecycle of the dependent object.
Instead with DI a special DI container takes care of
the object lifecycle management

10. Dependency Injection (DI) is a runtime mechanism
where dependency between the client object and the
dependent object does not occur directly.
With DI the client object does not necessarily
manage the lifecycle of the dependent object.
Instead with DI a special DI container takes care of
the object lifecycle management where clients
reference managed and possibly shared objects.

11. Dependency Injection (DI) is a runtime mechanism
where dependency between the client object and the
dependent object does not occur directly.
With DI the client object does not necessarily
manage the lifecycle of the dependent object.
Instead with DI a special DI container takes care of
the object lifecycle management where clients
reference managed and possibly shared objects.

14. Why…?

16. •
Loose coupling

17. •
Loose coupling
•
Dependency inversion

18. •
Loose coupling
•
Dependency inversion
•
High Abstraction

19. •
Loose coupling
•
Dependency inversion
•
High Abstraction
•
Highly cohesive modules

20. •
Loose coupling
•
Dependency inversion
•
High Abstraction
•
Highly cohesive modules
•
Deployment time config

22. How…?

23. CDI
Context and Dependency Injection

24. JSR-299
JavaEE specification

25. Spring
Framework
SpringBeans

27. •
@Inject

28. •
@Inject
•
@Autowired

29. •
@Inject
•
@Autowired
•
@Qualifier

30. •
@Inject
•
@Autowired
•
@Qualifier
•
@Produces

31. •
@Inject
•
@Autowired
•
@Qualifier
•
@Produces
•
@Bean

32. •
@Inject
•
@Autowired
•
@Qualifier
•
@Produces
•
@Bean
•
@Component

35. Example?

36. public interface VehicleService {
void performService(Vehicle vehicle);
}

37. @Named("Audi")
public class AudiService implements VehicleService {
@Override
public void performService(Vehicle vehicle) {
System.out.println("Performing Audi service");
}
}

38. @Named("BMW")
public class BMWService implements VehicleService {
@Override
public void performService(Vehicle vehicle) {
System.out.println("Performing BMW service");
}
}

39. @Named("VW")
public class VWService implements VehicleService {
@Override
public void performService(Vehicle vehicle) {
System.out.println("Performing VW service");
}
}

40. public class VehicleOperator {
@Inject
@Named("Audi")
private VehicleService audiService;
}

41. public class VehicleOperator {
@Inject
@Named("Audi")
private VehicleService audiService;
@Inject
@Named("BMW")
private VehicleService bmwService;
}

42. public class VehicleOperator {
@Inject
@Named("Audi")
private VehicleService audiService;
@Inject
@Named("BMW")
private VehicleService bmwService;
@Inject
@Named("VW")
private VehicleService vwService;
}

43. public class VehicleOperator {
@Inject
@Named("Audi")
private VehicleService audiService;
@Inject
@Named("BMW")
private VehicleService bmwService;
@Inject
@Named("VW")
private VehicleService vwService;
public void operate(Vehicle vehicle) {
audiService.performService(vehicle);
}
}

44. Setter
Injection
For interfering purposes

45. public class VehicleOperator {
private VehicleService audiService;
private VehicleService bmwService;
private VehicleService vwService;

46. public class VehicleOperator {
private VehicleService audiService;
private VehicleService bmwService;
private VehicleService vwService;
@Inject
public void setAudiService(@Named("Audi") VehicleService audiService) {
this.audiService = audiService;
}

47. public class VehicleOperator {
private VehicleService audiService;
private VehicleService bmwService;
private VehicleService vwService;
@Inject
public void setAudiService(@Named("Audi") VehicleService audiService) {
this.audiService = audiService;
}
@Inject
public void setBMWService(@Named("BMW") VehicleService bmwService) {
this.bmwService = bmwService;
}

48. public class VehicleOperator {
private VehicleService audiService;
private VehicleService bmwService;
private VehicleService vwService;
@Inject
public void setAudiService(@Named("Audi") VehicleService audiService) {
this.audiService = audiService;
}
@Inject
public void setBMWService(@Named("BMW") VehicleService bmwService) {
this.bmwService = bmwService;
}
@Inject
public void setVWService(@Named("VW") VehicleService vwService) {
this.vwService = vwService;
}

49. Constructor
Injection
For injecting at initialisation time

50. public class VehicleOperator {
private VehicleService audiService;
private VehicleService bmwService;
private VehicleService vwService;

51. public class VehicleOperator {
private VehicleService audiService;
private VehicleService bmwService;
private VehicleService vwService;
@Inject
public VehicleOperator(@Named("Audi") VehicleService audiService,
@Named("BMW") VehicleService bmwService,
@Named("VW") VehicleService vwService) {
this.audiService = audiService;
…
}

52. Producer
method
For programmatic bean manipulation

53. public class VehicleServiceFactory {
}

54. public class VehicleServiceFactory {
@Produces
@Named("VW")
protected VehicleService produceVWService() {
}
}

55. public class VehicleServiceFactory {
@Produces
@Named("VW")
protected VehicleService produceVWService() {
VehicleService vwService = ServiceProvider.provideVWService();
vwService.enableEmissionManipulation(true);
return vwService;
}
}

56. Avoid
ambiguity
with @Vetoed, @Alternative or @Primary

57. Programmatic
Injection
With Instance<T>

58. public class VehicleOperator {
}

59. public class VehicleOperator {
@Inject
@Named("BMW")
private Instance<VehicleService> serviceInstantiator;
}

60. public class VehicleOperator {
@Inject
@Named("BMW")
private Instance<VehicleService> serviceInstantiator;
public void operate(Vehicle vehicle) {
VehicleService service = serviceInstantiator.get();
}
}

61. public class VehicleOperator {
@Inject
@Named("BMW")
private Instance<VehicleService> serviceInstantiator;
public void operate(Vehicle vehicle) {
VehicleService service = serviceInstantiator.get();
service.performService(vehicle);
}
}

62. Programmatic
Configuration!
As promised :)

63. public class Vehicle {
public String getMake() {
return "BMW";
}
}

64. public class NamedLiteral extends
AnnotationLiteral<Named> implements Named

65. public class VehicleOperater {

66. public class VehicleOperater {
@Inject
@Any
private Instance<VehicleService> serviceInstantiator;
}

67. public class VehicleOperater {
@Inject
@Any
private Instance<VehicleService> serviceInstantiator;
public void operate(Vehicle vehicle) {
NamedLiteral named = new NamedLiteral(vehicle.getMake());
}
}

68. public class VehicleOperater {
@Inject
@Any
private Instance<VehicleService> serviceInstantiator;
public void operate(Vehicle vehicle) {
NamedLiteral named = new NamedLiteral(vehicle.getMake());
VehicleService service = serviceInstantiator.select(named).get();
}
}

69. public interface TaskProcessor {
void processTask(Task task);
}

70. @AsynchronousProcessing
public class ReportingTask implements Task {
}

71. @AsynchronousProcessing
public class ReportingTask implements Task {
}
@SynchronousProcessing
public class SaveDataTask implements Task {
}

72. @AsynchronousProcessing
public class AsynchronousTaskProcessor implements TaskProcessor {
@Override
public void processTask(Task task) {
}
}

73. @AsynchronousProcessing
public class AsynchronousTaskProcessor implements TaskProcessor {
@Override
public void processTask(Task task) {
}
}
@SynchronousProcessing
public class SynchronousTaskProcessor implements TaskProcessor {
@Override
public void processTask(Task task) {
}
}

74. public class TaskHandler {
@Inject
@Any
private Instance<TaskProcessor> processorInstantiator;
}

75. public class TaskHandler {
@Inject
@Any
private Instance<TaskProcessor> processorInstantiator;
public void handleTasks(List<Task> tasks) {
tasks.forEach(task -> {
processorInstantiator.select(task.getClass().getAnnotations()).get().
processTask(task);
});
}
}

77. Vaadin with
CDI

78. public class MyVaadinUI extends UI {
}

79. @CDIUI("")
public class MyVaadinUI extends UI {
}

80. @CDIUI("")
public class MyVaadinUI extends UI {
@Inject
private MainMenu mainMenu;
@Inject
private ViewArea viewArea;
}

81. @CDIUI("")
public class MyVaadinUI extends UI {
@Inject
private MainMenu mainMenu;
@Inject
private ViewArea viewArea;
@Override
protected void init(VaadinRequest request) {
HorizontalLayout hl =
new HorizontalLayout(mainMenu, viewArea);
…
setContent(hl);
}
}

82. UI as managed bean

83. Entry point
UI as managed bean

84. Entry point
Context aware
UI as managed bean

85. Entry point
Context aware
Accesible through URI
UI as managed bean

86. @CDIUI("")
public class MyVaadinUI extends UI {
@Inject
private MainMenu mainMenu;
@Inject
private ViewArea viewArea;
@Override
protected void init(VaadinRequest request) {
HorizontalLayout hl =
new HorizontalLayout(mainMenu, viewArea);
…
setContent(hl);
}
}

87. @CDIUI("anotherUI")
public class MyVaadinUI extends UI {
@Inject
private MainMenu mainMenu;
@Inject
private ViewArea viewArea;
@Override
protected void init(VaadinRequest request) {
HorizontalLayout hl =
new HorizontalLayout(mainMenu, viewArea);
…
setContent(hl);
}
}

88. http://localhost:8080/app/
http://localhost:8080/app/anotherUI
app: context
anotherUI : UI name

89. Scope UI specific beans with
@UIScoped

90. @UIScoped
public class MainMenuBean extends CssLayout
implements MainMenu

91. @UIScoped

92. Bean associated with UI instance
@UIScoped

93. Bean associated with UI instance
Bean associated with Web browser tab
@UIScoped

94. Bean associated with UI instance
Bean associated with Web browser tab
@CDIUI is by default @UIScoped
@UIScoped

95. @CDIUI
MyVaadinUI
_____________________________
@Inject
private MainMenu menu;
@Inject
private User currentUser;
@UIScoped
MyVaadinUI
MainMenu
@SessionScoped
User

96. @CDIUI
MyVaadinUI
_____________________________
@Inject
private MainMenu menu;
@Inject
private User currentUser;
@UIScoped
MyVaadinUI
MainMenu
@SessionScoped
User
@CDIUI
MyVaadinUI
_____________________________
@Inject
private MainMenu menu;
@Inject
private User currentUser;
@CDIUI
MyVaadinUI
_____________________________
@Inject
private MainMenu menu;
@Inject
private User currentUser;
@UIScoped
MyVaadinUI
MainMenu
@UIScoped
MyVaadinUI
MainMenu

97. What about Views?

98. View

99. Component composition
View

100. Component composition
Active view switched by Navigator
View

101. Component composition
Active view switched by Navigator
Positioned inside ViewDisplay
View

102. HorizontalLayoutContentAreaMenu
View1
View2
View3

103. HorizontalLayoutView1Menu
View1
View2
View3

104. HorizontalLayoutView2Menu
View1
View2
View3

105. HorizontalLayoutView3Menu
View1
View2
View3

106. View as managed bean with
@CDIView

107. public class CustomerViewBean

108. public class CustomerViewBean extends VerticalLayout

109. @CDIView("customers")
public class CustomerViewBean extends VerticalLayout
implements View

110. http://localhost:8080/app/#!customers
#! : Navigator identifier
customers : View name

111. Scope View specific beans with
@ViewScoped

112. @ViewScoped

113. Beans associated with View
@ViewScoped

114. Beans associated with View
@CDIView by default @ViewScoped
@ViewScoped

115. @ApplicationScoped

116. @ApplicationScoped@ApplicationScoped
@SessionScoped @SessionScoped @SessionScoped

117. @ApplicationScoped
@SessionScoped @SessionScoped @SessionScoped
@UI
Scoped
@UI
Scoped
@UI
Scoped
@UI
Scoped
@UI
Scoped
@UI
Scoped

118. @ApplicationScoped
@
View
@
View
@
View
@
View
@
View
@
View
@
View
@
View
@
View
@
View
@
View
@
View
@SessionScoped @SessionScoped @SessionScoped
@UI
Scoped
@UI
Scoped
@UI
Scoped
@UI
Scoped
@UI
Scoped
@UI
Scoped

119. Lessons learned

120. Lessons learned
1. Depend on abstractions through Dependency Inversion

121. Lessons learned
1. Depend on abstractions through Dependency Inversion
2. Beans need to be managed by (CDI) container

122. Lessons learned
1. Depend on abstractions through Dependency Inversion
2. Beans need to be managed by (CDI) container
3. Inject to Fields, Methods and Constructor

123. Lessons learned
1. Depend on abstractions through Dependency Inversion
2. Beans need to be managed by (CDI) container
3. Inject to Fields, Methods and Constructor
4. Producer method allows programmatic bean creation and non-default
constructor

124. Lessons learned
1. Depend on abstractions through Dependency Inversion
2. Beans need to be managed by (CDI) container
3. Inject to Fields, Methods and Constructor
4. Producer method allows programmatic bean creation and non-default
constructor
5. Instance<T> provides on-demand instantiation with candidate selection

125. Lessons learned
1. Depend on abstractions through Dependency Inversion
2. Beans need to be managed by (CDI) container
3. Inject to Fields, Methods and Constructor
4. Producer method allows programmatic bean creation and non-default
constructor
5. Instance<T> provides on-demand instantiation with candidate selection
6. Use CDIUI and CDIView for making core Vaadin concepts managed beans

126. I would NOT start a single new
Vaadin project without
Dependency
Injection!

127. Thank you!