SB-NG

Question 1

Auto-configuration

Answer 1

When configuring your Spring Boot application, it downloads all the dependencies needed to run your application

Question 2

Opinionated approach

Answer 2

Spring Boot uses a narrow approach to installing dependencies based on your application’s needs. Manual configuration is removed as it adds the packages you need for your application.

Question 3

Spring starters:

Answer 3

We can choose a list of starter dependencies to define your application’s expected needs during the initialization process. One example is Spring Web, which allows us to initialize a Spring-based web application.

Question 4

SB: Presentation/display layer

Answer 4

The presentation layer is responsible for interpreting JSON parameters as objects. This layer is the upper layer that is also responsible for handling authentication and HTTP requests. After accomplishing JSON translation and authentication, we will now move to the business layer.

Question 5

SB: Business layer:

Answer 5

The business layer, as the name suggests, handles all the business logic in the application. It is composed of service classes that perform authorization and additional validation.

Question 6

Persistence layer

Answer 6

The persistence layer is mainly responsible for storage logic that converts objects from and to database rows to insert data.

Question 7

Database layer

Answer 7

The database layer performs Create, Read, Update, and Delete (CRUD) operations. The layer can consist of multiple databases.

Question 8

Inversion of Control (IoC)

Answer 8

the concept of inverting the flow of your program, and it is used for decoupling the components in your application, making your piece of code reusable and modular

Question 9

Constructor-based dependency injection

Answer 9

can be achieved by creating an object class with a constructor, with arguments of a specific type representing the dependency we can set.

Question 10

Beans.xml

Answer 10

main configuration file for our construction-based injection, which is where we will define our beans together with their dependencies.

Question 11

Spring: @Configuration

Answer 11

used to mark a class as a source of bean definitions

Question 12

Spring: @ComponentScan

Answer 12

makes Spring scan the packages configured with it for the @Configuration classes

Question 13

Spring: @Import

Answer 13

loads additional configuration. Works even when you specify beans in XML file

Question 14

Spring: @Component

Answer 14

turns the class into a Spring bean at the auto-scan time

Question 15

Spring: @Service

Answer 15

tells Spring that it’s safe to manage @Components with more freedom than regular components

Question 16

Spring: @Autowired

Answer 16

wires the application parts together, on the fields, constructors, or methods in a component

mainly used to inject dependencies without the use of constructors and setter methods

Question 17

Spring: @Bean

Answer 17

specifies a returned bean to be managed by Spring context. Returned bean has same name as factory method

Question 18

@SpringBootApplication

Answer 18

uses @Configuration, @EnableAutoConfiguration and @ComponentScan

Question 19

SB: @EnableAutoConfiguration

Answer 19

make Spring guess the configuration based on the classpath

Question 20

SB: @Controller

Answer 20

marks the class as web controller, capable of handling the requests

Question 21

SB: @RestController

Answer 21

a convenience annotation of a @Controller and @ResponseBody

Question 22

SB: @ResponseBody

Answer 22

makes Spring bind method’s return value to the web response body

Question 23

SB: @RequestMapping

Answer 23

specify on the method in the controller to map a HTTP request to the URL to this method

Question 24

SB: @RequestParam

Answer 24

bind HTTP parameters into method arguments

Question 25

SB: @PathVarilable

Answer 25

binds placeholder from the URI to the method parameter

Question 26

field-based dependency injection

Answer 26

s a concept where we inject the object’s dependencies directly into the fields. We will not create a constructor or a setter method to inject our dependencies, but we will use the @Autowired annotation for injection.

Question 27

are essential parts of developing your Spring applications. They are considered the building blocks of Spring and make our code less boilerplate and maintainable.

Answer 27

Annotation and beans

Question 28

are used to define the different types of beans. They are simply a form of metadata that marks our code to provide information.

Answer 28

Spring annotations

Question 29

beans

Answer 29

are objects that are instantiated and created and can be injected with other beans

Question 30

SB: @Required

Answer 30

This is applied in the setter methods of a bean and implies that the bean must be injected with the dependency at configuration. Otherwise, it will throw BeanInitializationException.

Question 31

The annotation is a class-level annotation to indicate the packages we want to be scanned for beans

Answer 31

@ComponentScan

Question 32

The annotation is a class-level annotation to indicate that a class is the source of bean definitions that the Spring container will process at runtime

Answer 32

@ComponentScan

Question 33

are mainly used to create Spring beans on the fly in an application context

Answer 33

Stereotype annotations

Question 34

Name the stereotype annotations

Answer 34

@Component @Service @Repository @Controller

Question 35

@Controller

Answer 35

The annotations used for Spring controller classes. It is also a type of @Component annotation, used for Spring MVC and the methods annotated with @RequestMapping, which is used for REST.

Question 36

@Repository

Answer 36

This annotation is used for classes that directly access a database. This is an indication of a class that executes the role of a data access object.

Question 37

@Service

Answer 37

This annotation, used for the service layer, indicates that a class is used to execute business logic, perform calculations, and call external APIs. @Service is a kind of @Component annotation.

Question 38

This annotation is used to auto-configure the bean present in the classpath and then to configure it to run the methods. The annotation is now rarely used, as @SpringBootApplication has already been released in Spring 1.2.0.

Answer 38

@EnableAutoConfiguration

Question 39

@RequestMapping

Answer 39

This is used to create endpoints and map web requests. The annotations can be used in a class or a method.

Question 40

@GetMapping

Answer 40

This maps the HTTP GET requests and is used for fetching data, and it is the equivalent of @RequestMapping(method = RequestMethod.GET).

Question 41

@PostMapping

Answer 41

maps the HTTP POST requests and is used for creating data, and it is the equivalent of @RequestMapping(method = RequestMethod.POST). && maps the HTTP PUT requests and is used for updating data, and it is the equivalent of @RequestMapping(method = RequestMethod.PUT)

Question 42

@DeleteMapping

Answer 42

This maps the HTTP PUT requests and is used for deleting data, and it is the equivalent of @RequestMapping(method = RequestMethod.DELETE). && maps the HTTP PATCH requests and is used for partial updates on data, and it is the equivalent of @RequestMapping(method = RequestMethod.PATCH).

Question 43

@RequestBody

Answer 43

used to bind HTTP requests with an object in a method parameter. The Spring framework binds the HTTP request body of the parameter with this annotation

Question 44

@ResponseBody

Answer 44

This attaches the method's return value to the response body. The annotation indicates that the return object should be serialized into a JSON or XML format.

Question 45

@PathVariable

Answer 45

This is used to get the values from the URI. It is allowed to define multiple @PathVariable instances in a method.

Question 46

This is used to get the query parameters from the URL.

Answer 46

@RequestParam

Question 47

CrudRepository

Answer 47

The interface repository, which provides the basic operations to Create, Read, Update, and Delete (CRUD)

Question 48

PagingAndSortingRepository

Answer 48

Extends CrudRepostiory and adds a method named findAll, which can sort results and be retrieved in a paginated manner.

Question 49

JpaRepository

Answer 49

Adds specific JPA methods and has all the functions of CrudRepository and PagingAndSortingRepository. It also adds methods such as flush(), which flushes the persistence context, and deleteInBatch(), which deletes records in a batch.

Question 50

Entity

Answer 50

This is a simple class that defines our model. It will be used as a JPA entity, generated with a primary key

Question 51

Repository

Answer 51

This is an interface that we need to extend with JPA repositories for the entities to have built-in operations.

Question 52

Where do you configure database properties? And what are these properties?

Answer 52

These properties are the server url of the database, admin username, and password and you add them to the application.properties file: i.e. spring.datasource.username=postgres