Web || Spring || Springboot || Reactive - ashish-ghub/docs GitHub Wiki

Web:

Session and JWT:

https://ponyfoo.com/articles/json-web-tokens-vs-session-cookies

Spring core

Spring Core docs:

Spring Boot docs:

https://docs.spring.io/spring-boot/docs/2.7.3/reference/htmlsingle/#getting-started

Spring Basics

difference between @Inject and @Autowired in Spring

Assuming here you're referring to the javax.inject.Inject annotation. @Inject is part of the Java CDI (Contexts and Dependency Injection) standard introduced in Java EE 6 (JSR-299), read more. Spring has chosen to support using the @Inject annotation synonymously with their own @Autowired annotation.

So, to answer your question, @Autowired is Spring's own annotation. @Inject is part of a Java technology called CDI that defines a standard for dependency injection similar to Spring. In a Spring application, the two annotations works the same way as Spring has decided to support some JSR-299 annotations in addition to their own.

Spring injection

3 types of injection supported

constructor
property or class member
setter of property

https://www.programmergirl.com/spring-dependency-injection/

Automated Java-Based Configuration

To support automated Java-based configuration, Spring provides additional annotations. While there are numerous, rich annotations that we can use, there are three foundational annotations:

@Component: Registers as a class as being managed by Spring.

@Autowired: Instructs Spring that a dependency should be injected.

@ComponentScan: Instructs Spring where to look for classes annotated with @Component

What are Stereotype annotations?

The Spring Framework provides you with some special annotations. These annotations are used to create Spring beans automatically in the application context. The main stereotype annotation is @Component. By using this annotation, Spring provides more Stereotype meta annotations such as @Service, used to create Spring beans at the Service layer, @Repository, which is used to create Spring beans for the repositories at the DAO layer, and @Controller, which is used to create Spring beans at the controller layer. This is depicted in the following diagram:

define @Bean :

ThreadPoolTaskExecutor is a java bean that allows for configuring a ThreadPoolExecutor in a bean style as below

 @Bean
 public TaskExecutor threadPoolTaskExecutor() {
   ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
   executor.setCorePoolSize(5);
   executor.setMaxPoolSize(10);
   executor.initialize();
   return executor;

}

All Annotation is spring:

https://dzone.com/articles/a-guide-to-spring-framework-annotations

bean-lifecycle https://reflectoring.io/spring-bean-lifecycle/

Spring Circular dependencies https://www.baeldung.com/circular-dependencies-in-spring

Resolved using Use Setter/Field Injection

@Component

public class CircularDependencyA {

private CircularDependencyB circB;

@Autowired
public void setCircB(CircularDependencyB circB) {
    this.circB = circB;
}

public CircularDependencyB getCircB() {
    return circB;
}

}

@Component

public class CircularDependencyB {

private CircularDependencyA circA;

private String message = "Hi!";

@Autowired
public void setCircA(CircularDependencyA circA) {
    this.circA = circA;
}

public String getMessage() {
    return message;
}

}

-> How to create Factory for payment service to choose right service based on user selection parameter

@Service public class LazyPaymentServiceFactory implements PaymentServiceFactory {

@Autowired
@Lazy
private PayPalPaymentService payPalPaymentService;

@Autowired
@Lazy
private StripePaymentService stripePaymentService;

@Override
public PaymentService createPaymentService(String paymentServiceName) {
    if ("paypal".equals(paymentServiceName)) {
        return payPalPaymentService;
    } else if ("stripe".equals(paymentServiceName)) {
        return stripePaymentService;
    }
    // Handle other payment services as needed
    throw new IllegalArgumentException("Unsupported payment service: " + paymentServiceName);
}

}

Spring boot design pattern.

https://jackynote.medium.com/top-5-design-patterns-in-java-spring-boot-best-practices-and-examples-002c45d3d331

Spring Session: (cloud or distributed way of session management)

Spring Session has the simple goal of free up session management from the limitations of the HTTP session stored in the server.

The solution makes it easy to share session data between services in the cloud without being tied to a single container (i.e. Tomcat). Additionally, it supports multiple sessions in the same browser and sending sessions in a header.

@ConfigurationProperties vs. @Value