Spring

Question 1

What is a Spring Bean?

Answer 1

a Spring bean is an object which Spring framework manages at runtime. It is the basic building block of any Spring application.

Question 2

What is involved in Spring managing a Spring Bean?

Answer 2

Creating an object,
Providing dependencies (e.g. other beans, configuration properties)
Intercepting object method calls to provide additional framework features
Destroying an object

Question 3

How does Spring know what beans to create?

Answer 3

Spring has to create beans, you provide the recipe in BEAN DEFINITIONS (which classes to use as beans)

Question 4

How do you define a Spring Bean?

Answer 4

1 - @Component on the class (usu. if you have access to the source code)
2 - @Bean in a custom config class (if you don’t own the code)
3 - declare a bean in an XML config file (not common anymore)

Question 5

What are 3 common derivatives of @Component?

Answer 5

@Service
@Controller
@Repository
These are all @Component, but with info about what jobs they do

Question 6

You don’t want your class to be dependent on Spring, but you still want Spring to create a bean. What do you do?

Answer 6

Use @Bean in a custom config class.

Question 7

What is @Configuration?

Answer 7

Also @Component, but it marks the class as the holder of bean definitions

Question 8

What are Spring Bean properties?

Answer 8

Properties give details about HOW Spring should create objects. Spring creates default properties, but you can customize.

Question 9

Name some Spring Bean properties.

Answer 9

class
name
dependencies
scope
initialization mode
initialization callback
destruction callback

Question 10

Explain Bean class.

Answer 10

When you define a bean, you connect to a single concrete class in your application. The class is the main property of the bean.

Question 11

Explain Bean name

Answer 11

A custom string that Spring uses to identify beans. Unlike Bean class, bean names are unique across the application. (Spring makes up its own names at runtime by default, so this is optional)
WHY? Mostly for when you have several beans for the same class defined with @Bean. (still pretty rare)

Question 12

Define 2 beans of the same class type

Answer 12

@Configuration
class MyConfigurationClass {

   @Bean(name = "myBeanClass")
   MyBeanClass myBeanClass() {
       return new MyBeanClass();
   }

   @Bean(name = "anotherMyBeanClass")
   MyBeanClass anotherMyBeanClass() {
       return new MyBeanClass();
   }
}

Question 13

Explain Bean dependencies

Answer 13

Sometimes beans need other beans to do their jobs. Spring needs to create them in the right order (dependencies first), but you don’t have to worry about it as long as you specify the dependencies.

Question 14

How do you define Bean dependencies?

Answer 14

If you have a class marked @Component and there is a constructor with parameters, Spring will use the parameters as dependencies.

Question 15

@Autowired on the constructor. When is it not necessary?

Answer 15

When there is only one constructor in the class marked with @Component. If you have multiple constructors, you need to mark one with @Autowired so Spring can find the right dependencies.

Question 16

Explain bean scope

Answer 16

The scope of a Spring bean defines HOW MANY instances of a particular class the framework creates at runtime (singleton? prototype?). Also, it defines when new instances are created.

Question 17

What is the default bean scope?

Answer 17

Singleton. Spring creates only one instance and shares it across the whole application

Question 18

How do you set the scope of a spring bean?

Answer 18

Use the @Scope annotation and its string attribute. e.g.
@Component
@Scope("prototype")
class MyPrototypeClass {
    //...
}

Question 19

Spring has scopes just for web applications. What are some examples and how do you define them?

Answer 19

request (@RequestScope)
session (@SessionScope)
global session
application (@ApplicationScope)

Question 20

What is bean initialization mode?

Answer 20

How Spring creates the beans. Eager = when application starts, Spring eagerly creates all singleton beans at startup (slow).
Or LAZY waits until the bean is needed. Ex:
@Component
@Lazy
class MyLazyClass {
//…
}

Question 21

What is Bean initialization?

Answer 21

Spring creates a new instance based on the bean definition, then needs to get it into a usable state. To make sure that the logic happens AFTER initialization, use initialization callback.

Question 22

How do you set bean initialization callback?

Answer 22

Make the bean class (marked with @Component) implement InitializingBean. For factory methods (@Bean) use initMethod:

@Bean(initMethod = "someInitMethodName")
MySpringBeanClass meBeanClass() {
   return new MySpringBeanClass();
}

Question 23

What is a bean destruction callback?

Answer 23

a method that Spring should call when a bean object is destroyed (not common)
Implement DisposableBean interface, or:

@Bean(name = "myBeanClass", destroyMethod = "cleanUpMethod")
MySpringBeanClass meBeanClass() {
   return new MySpringBeanClass();
}

Question 24

What is the application context?

Answer 24

The special object that Spring creates at startup, AKA IoC container. It’s the container where your beans exist. It sniffs out and creates your bean objects for you.

Question 25

How does @Value work?

Answer 25

Define a property in application.properties, then inject it into beans by adding @Value to the contructor or bean fields. You can define: 
a property placeholder (${…})
an expression (#{…}).

Question 26

How do you add a default value with @Value (in case the first one is missing?)

Answer 26

Define as usual, then colon, default value:

@Value(“${sbpg.init.welcome-message:Hello world}”)

Question 27

Why does this code print null?
@Service
class DontDoItService {

   @Value("${sbpg.init.welcome-message:Hello world}")
   private String message;
   // ...

InitService() {
log.info(message); // prints: null
}
}

Answer 27

Because Spring creates the bean from the constructor first, THEN injects values. The value is defined in the field, not the constructor, so it doesn’t exist at the time the bean is created.

Code in the constructor is executed first. The injection happens next.

Question 28

What is Spring Boot?

Answer 28

An extension of the Spring Framework with sensible defaults and configurations, but you can also define your own custom configurations.