Week 7 Spring Framework Overview

Question 1

What are the goals of the Spring Framework?

Answer 1

Lightweight Development with POJOs (Plain Java Objects)

Dependency Injection

- Promotes loose coupling
- Loose coupling: Basically, when you're developing, you might use a bunch of different dependencies within a certain class, and you might want to be able to switch out different implementations, so we can utilize DI to achieve this to inject objects that we want to have our IoC container manage
        o "Switching out dependencies"
        o Not having to hardcode the instantiation of objects

Minimization of boiler code

Question 2

What does IoC stand for?

Answer 2

Inversion of Control

Question 3

What does IoC do?

Answer 3

Inverts control of object creation and application flow to a framework

Question 4

What is Dependency Injection?

Answer 4

Dependency Injection (DI) is a pattern to implement IoC

"behavior is injected into your classes"
Achieves "Loose Coupling"

Question 5

Describe Dependency Injection

Answer 5

Implementation of inversion of control

• Dependency: some object another object needs in order to function properly
• Injection: passing dependency to a dependent object
• When a Spring bean is instantiated, any dependencies that it requires will be provided (given that those dependencies are also configured as Spring beans)
• Decouples configuration from implementation

Question 6

Describe Spring Bean

Answer 6

Any object whose lifecycle is managed by Spring (the IoC container)

We specify through configuration what should be a Spring Bean

Question 7

What is a Core container?

Answer 7

Core container: The core of Spring for creating beans, and also for managing bean dependencies

Beans: spring-beans module
Core: spring-core module
Context: spring-context module
SpEL: Spring Expression Language module

Question 8

What is a BeanFactory?

Answer 8

BeanFactory is an implementation of the factory design pattern, which removes the need to create programmatic singletons and enables the decoupling of configuration and specification of dependencies from the program logic itself.

Question 9

What do the Core and Bean modules provide?

Answer 9

The Core and Beans modules provide the fundamental parts of the Spring framework, such as IoC (inversion of control) and DI (dependency injection).

Question 10

What does the Context build on top of?

Answer 10

The Context builds on top of the Core and Beans modules and allows access to objects in a framework-style manner. Context is what provides us with ApplicationContext, which extends BeanFactory.

Question 11

List some modules.

Answer 11

Additional modules:

Web module
AOP module
ORM module
Test module
JDBC module
etc

Question 12

What are Spring Projects?

Answer 12

Spring projects are built on top of different modules that make up Spring framework. These are “boiler-plate” projects that help us to easily build Spring applications.

Spring Boot
Spring Data
Spring Security
Etc

Question 13

What is the similarity between a BeanFactory and ApplicationContext?

Answer 13

Both represent an IoC container, which manages the lifecycle of Spring beans

Question 14

What are some features of BeanFactory?

Answer 14

Older
It lazily instantiates Spring Beans
Must provide a resource object configured for our beans.xml

Example implementation: XmlBeanFactory

XmlBeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource(“beans.xml”));

Question 15

What are some features of ApplicationContext?

Answer 15

Newer

It eagerly instantiates Spring Beans

Provides support for annotations

Naming convention changed from beans.xml to applicationContext.xml

Sub-interface of BeanFactory (meaning this interface extends the BeanFactory interface)

Easier integration with Spring AOP

Event publication

Internationalization features

Support for application-layer specific contexts such as WebApplicationContext

Example implementations:

ClassPathXmlApplicationContext
FileSystemXmlApplicationContext
XmlWebApplicationContext
Etc.

Question 16

Where is the XML configuration defined? Can you specify your beans inside of the XML file?

Answer 16

Our configuration is defined in applicationContext.xml

We can specify our beans inside of this file, whether we want component scanning (annotation scanning), etc.

Question 17

How do you configure Annotation?

Answer 17

Enable “Component Scanning” in our applicationContext.xml

Question 18

What are some Annotation classes?

Answer 18

Annotate classes w/ “stereotype annotations”

@Component: general Spring bean
@Repository: for our DAOs
@Controller: for our HTTP controllers
@Service: for various services in our service layer

Question 19

Where can we specify beans that we would like for Spring to instantiate and populate inside of?

Answer 19

a special configuration bean

Question 20

How would you handle Java Configuration?

Answer 20

We can utilize the @Configuration annotation in order to designate this class as our configuration class

We then would use @Bean on each method inside of this class that should be instantiating a bean

- the method name is the bean name itself
- @Bean is a special annotation that will actually intercept this method call, check to see if the bean already exists or not inside of the container, and if not, actually instantiate the object inside the method and return that new object. Otherwise, the new SomeObject() logic inside the method will not even run at all, and the already existing bean will simply be returned to us.

Question 21

What do Scopes determine?

Answer 21

Scopes determine how many instances of a particular Spring bean we should create and have at any particular time. This depends on the context in which they are used, which is why this is referred to as “scope”.

Question 22

What are the Universal Scopes?

Answer 22

Singleton (default): There is only 1 instance of the Bean

Prototype: There will be a new Bean instantiated each time it is called for

Question 23

What are the Web-Aware Scopes?

Answer 23

Request: One Per HTTP request
Session: One Per HTTP session
New as of Spring 5
- Application: One per ServletContext (Per Web Container)
- WebSocket: One per websocket
Now deprecated as of Spring 5
- Global session: was used for Portlets for global session

Question 24

What is Bean Wiring?

Answer 24

Bean wiring is the process of connecting our beans using dependency injection (DI)

Question 25

What are the Dependency Injection Types?

Answer 25

Setter Injection
Constructor Injection
Field Injection

Question 26

Describe the Setter injection.

Answer 26

Uses setter methods to provide dependencies

Does not ensure DI because an instance could be created without configuring a particular field

• no issue would be raised if we did not successfully provide a dependency to this object, because in order to make use of the setter, you would have already had to have instantitated this bean
• one way around this issue could be to use the @Required annotation to make sure that there is actually a dependency provided
  - Would prevent NullPointerException issues down the road

Question 27

Describe the Constructor Injector

Answer 27

Uses a constructor (this is what we saw already with Angular)

We provide to the constructor the necessary dependencies as parameters

The bean cannot be instantiated without the proper dependencies being injected

Question 28

Describe Field Injector

Answer 28

@Autowired directly on top of the field itself (property)

-example:
@Autowired
private IMyService myService;

Utilizes reflection under the hood, not constructors or setters

Question 29

What is Autowiring?

Answer 29

Autowiring in general uses the @Autowired annotation. You can place this on fields directly, in which case we would be utilizing field injection, or on constructors, setters for constructor/setter injection.