# Review No. 6

By

Paul Tomoiu

●

Published 2024-01-14

This page contains Java concepts (but not only) briefly explained.

The Spring container is a place where the Bean are created and lives (concept). Application Context is the Spring implementation of IoC container (ApplicationContext is also an interface).

Methode #1

private ApplicationContext context;
... 
((ConfigurableApplicationContext) context).close();

Methode #2 Using Actuator /shutdown endpoint (if Actuator is used).

eagerly - for Singleton

lazily - for Prototype

BeanFactoryPostProcessor (interface) - used when we want to modify a class definition just before the Bean is created.

BeanPostProcessor (interface) - used when we want to modify a Bean after the Bean is created.

A proxy object is an objects which control the access to the real object it represents.

An object of this type keeps information about profiles and properties.

• Java bean configuration : a method must return a DataSource reference type.

@Configuration
public class JpaConfig {

    @Bean
    public DataSource dataSource()
    {
        DataSourceBuilder dataSourceBuilder = DataSourceBuilder.create();
        dataSourceBuilder.driverClassName("org.h2.Driver");
        dataSourceBuilder.url("jdbc:h2:file:C:/temp/test");
        dataSourceBuilder.username("sa");
        dataSourceBuilder.password("");
        return dataSourceBuilder.build();
    }

    //...
}

• Properties configuration

spring.datasource.url=jdbc:postgresql://localhost:5432/my_db
spring.datasource.username=user1
spring.datasource.password=user1_pass
spring.datasource.driver-class-name=org.postgresql.Driver

• JNDI configuration - the configuration is on the Application Server

A callback is a code or reference to the code that can be passed as an argument to the method. This method will execute passed callback during execution.

• Global transaction -> spans multiple transactional resources (databases, queues)
• Local transaction -> spans 1 transactional resource (database, queue)

JDBC Template is able to participate in existing transaction, in a transaction defined programmatically, or defined with @Transactional annotation.

We can access it using @Value annotation, using @ConfigurationProperties (@EnableConfigurationProperties enable this feature) or using an Environment object.

A fat jar is an "executable jar". It contains the compiled code for your application and also all the dependencies. The "original" jar is not executable and has no dependencies.

MANIFEST.MF file describes the Java Archive (JAR). It is located in META-INF directory. For an executable jar it contains "Main-Class" and "Class-Path". MANIFEST.MF file is created when the jar file is created.

When we use spring-boot-starter-web starter we can have:

• Tomcat (the default): the standards, used for small applications.
• Jetty : better performance for large application.
• Undertow : consumes less memory and CPU resources.

When we use spring-boot-starter-webflux we can use Reactor Netty (created more for real-time applications).

Spring Boot Actuator provides the following features:

• Monitoring
• Health-checks
• Metrics
• Audit Events

Spring Boot Actuator supports two protocols: HTTP & JMX.

REST (Representational State Transfer) isn't always linked to HTTP. You can use other transfer protocols, such as FTP, SMTP, etc. But, typically REST APIs employs HTTP.

• Stateless : The server does not retain any session information about the client between requests => each request must contain all the information required for the server to process the request.

• uniform interface : The set of interfaces is well-defined (HTTP methods like GET, POST, PUT, DELETE,etc).

• resource-based architecture : Each call is done on a resource (identified by a unique URI (Uniform Resource Identifier))

CRUD stands for: Create, Read, Update, Delete.

• Informational (1xx): Indicates that the request was received and the process is continuing.
• Successful (2xx): Indicates that the request was successfully received, understood, and accepted.
• Redirection (3xx): Indicates that further action must be taken to complete the request.
• Client Errors (4xx): Indicates that an error occurred during the request processing and it is the client who caused the error.
• Server Errors (5xx): Indicates that an error occurred during request processing but that it was by the server.

Mockito, EasyMock

If you are using JUnit version < 5, you have to use @RunWith(SpringRunner.class) or @RunWith(MockitoJUnitRunner.class) etc.

If you are using JUnit version = 5, you have to use @ExtendWith(SpringExtension.class) or @ExtendWith(MockitoExtension.class) etc.

Inner beans in Spring are beans that are defined within the scope of another bean.

We can use a thread dump tool to inspect the state of the threads in your program.

Proxy wrap an object, Facade hide more objects. Proxy generally add functionality (logging, security, etc), Facade generally will not add functionality.

BeanFactory provides basic IoC and Dependency Injection (DI) features, while ApplicationContext provides advanced features like:

• Internationalization (i18n) -> you can create an application using multiple languages

• Event publishing -> for instance, you can publish a ContextStartedEvent when the context is started

The use of the Interceptor design pattern is to add actions before or/and after a request/call to an object without modifying that object.

Bridge design pattern

DAO (Data Access Object) Design Pattern is used to separate the data persistence logic from the service which need the persistence.

int result = expression.interpret(context);

where,

"expression" is an implementation of an interface (we can have many implementations).

"context" is a context which keeps information used for interpreting.

by type, by name

The HEAP size of a JVM can be changed by setting the -Xms and -Xmx parameters on the command line when we start the JVM.

It is allowed, but the main method is not overridden anyway.