- Is Spingboot thread-safe?
It depends. The main factor which determines the thread-safety of a component is its scope.
In a standard servlet-based Spring web application, every new HTTP request generates a new thread. If the container creates. a new bean instance just for that particular request, we can say this bean is thread-safe.
Is Spring singleton thread-safe?
The short answer is: no, it isn't.
Reference: http://dolszewski.com/spring / spring-bean-thread-safety-guide /
- Different scopes of beans ?
- singleton : Singleton is the default scope for a Bean
- prototype
- request
- session
- application
- websocket
- What are the disadvantages of Springboot?
Usually, it loads unwanted dependencies sometimes not of any use also, so it will create bulky jars for no use. - What are different design patterns you use in the Microservices ?
Decomposition Patterns:
Decompose by Business Capability
Decompose by Subdomain
Strangler Pattern
Integration Patterns:
API Gateway Pattern
Aggregator Pattern
Client-Side UI Composition Pattern
Database Patterns
Database per Service
One database per microservice must be designed; it must be private to that service only. It should be accessed by the microservice API only. It cannot be accessed by other services directly. For example, for relational databases, we can use private-tables- Each microservice should have a separate database id so that separate access can be given to put up a barrier and prevent it from using other service tables. per-service, schema-per-service, or database-server-per-service.
Shared Database per Service
A shared database per service is not ideal, but that is the working solution for the above scenario. Most people consider this an anti-pattern for microservices, but for brownfield applications, this is a good start to break the application into smaller logical pieces. This should not be applied for greenfield applications. In this pattern, one database can be aligned with more than one microservice, but it has to be restricted to 2-3 maximum, otherwise scaling, autonomy, and independence will be challenging to execute.
Command Query Responsibility Segregation (CQRS)
CQRS suggests splitting the application into two parts — the command side and the query side. The command side handles the Create, Update, and Delete requests. The query side handles the query part by using the materialized views. The event sourcing pattern is generally used Materialized views are kept updated by subscribing to the stream of events.
Saga Pattern
A Saga represents a high-level business process that consists of several sub requests, which each update data within a single service. Each request has a compensating request that is executed when the request fails. It can be implemented in two ways:
Choreography — When there is no central coordination, each service produces and listens to another service's events and decides if an action should be taken or not.
Orchestration — An orchestrator (object) takes responsibility for a saga's decision making and sequencing business logic.
Observability Patterns
Log Aggregation
Performance Metrics: AppDynamics, Prometheus, Grafana
Distributed Tracing: Zipkins, Slueth
Health Check: Spring Boot Actuator
Cross-Cutting Concern Patterns:
External Configuration:
Externalize all the configuration, including endpoint URLs and credentials. The application should load them either at startup or on the fly.
Service Discovery Pattern
Circuit Breaker Pattern
Blue-Green Deployment Pattern
- How do we implement spring security?
Dependency:
org.springframework.boot
spring-boot-starter-securityrest security
security config class-
basic auth
authentication filter-> authentication object-> not validated-> authentication manager builder->
finds authetication providers-> like DAO or custom authentication provider
we can pass JWT token in header for authentication.
server validates if it is generated by itself.
session-based vs token based security.
tokens are stateless
requests can go to any node which doesn't understand previous session settings.
What is Bearer (ur the owner of the token) Vs Basic
after authentication is done only we get JWT token which is used for authorization
JWT --OAUTH Grant Types:
implicit --Implicit Grant
authorization_code --Authorization Code Grant- This grant type flow is also called "three-legged" OAuth.
You've seen this flow anytime your app opens a browser to the resource server's login page and invites you log in to your actual account (for example, Facebook or Twitter).
If you successfully log in, the app will receive an authorization code that it can use to negotiate an access token with the authorization server.
client_credentials --Client Credentials Grant
password --Resource Owner Password Grant
refresh_token --Use Refresh Tokens
urn: ietf: params: oauth: grant-type: device_code --Device Authorization Grant
Reference: https://developer.okta.com/blog/2018/10/05/build-a-spring-boot-app-with-user-authentication
3. How to cancel an order for user-specific settings at the spring level?
3b. Multi calls between ms to ms?
Using discovery services like Eureka we can route calls between internal microservices effectively. For each request, a thread is blocked.
at one point in time threads will be out. so time out is needed to release threads. Default is 200 threads in thread pool.
Ex :Read time out(not able to complete reading data) , server time out (not able to get connection)
- Versioning in REST APIs ?
the new functionality will be rolled with new version apis
using request param or path param
also using headers
uri @Getmapping
AOP - for logging purposes,
security setup using Request Filters, and Interceptors for managing requests and response data
- How do you create custom annotation in spring boot?
STEP1: Create an interface with the annotation name
STEP2: Create an Aspect
STEP3: Add the annotation
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Traceable {
}
- Pagination and Sorting using Spring Data JPA
public interface ProductRepository extends PagingAndSortingRepository<Product, Integer> {
List<Product> findAllByPrice(double price, Pageable pageable);
}
Conversely, we could have chosen to extend JpaRepository instead, as it extends PagingAndSortingRepository too.
HATEOAS constraint of REST means enabling the client of the API to discover the next and previous pages based on the current page in the navigation.
we're going to use the Link HTTP header, coupled with the “next“, “prev“, “first” and “last” link relation types.
In the case of pagination, the event – PaginatedResultsRetrievedEvent – is fired in the controller layer. Then we'll implement discoverability with a custom listener for this event.
@Api
@RequestMapping("/v1")
public interface ProfileV1Interface{
@ApiOperation(value = "Api to Get a specific setting for a cluster", notes = "Get a specific setting for a Cluster")
@GetMapping(value = "/cluster/{name}/settings", produces = MediaType.APPLICATION_JSON_VALUE)
Map<String, String> getClusterSetting(@RequestParam(required = true) String clusterId,@PathVariable(required = true) String name);
}
@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 work the same way as Spring has decided to support some JSR-299 annotations in addition to their own.
- Tell me some important annotations in springboot?
@SpringBootApplication: It is a combination of three annotations @EnableAutoConfiguration, @ComponentScan, and @Configuration.
@Controller
@RequestMapping("books") :
@Controller: The @Controller is a class-level annotation. It is a specialization of @Component. It marks a class as a web request handler. It is often used to serve web pages. By default, it returns a string that indicates which route to redirect. It is mostly used with @RequestMapping annotation.
It is also used at the class level. It tells the Spring that the class contains the business logic.
@ConditionalOnClass and @ConditionalOnMissingClass
Using these conditions, Spring will only use the marked auto-configuration bean if the class in the annotation's argument is present/absent:
@ConditionalOnBean and @ConditionalOnMissingBean
We can use these annotations when we want to define conditions based on the presence or absence of a specific bean:
@ConditionalOnProperty
With this annotation, we can make conditions on the values of properties:
@ConditionalOnProperty
The @ConditionalOnProperty annotation is, in my experience, the most commonly used conditional annotation in Spring Boot projects. It allows to load beans conditionally depending on a certain environment property:
@Configuration
@ConditionalOnProperty(
value="module.enabled",
havingValue = "true",
matchIfMissing = true)
@Required : This annotation is applied to bean setter methods. It indicates that the required property must be filled at the configuration time in the affected bean, or else it throws an exception: BeanInitializationException.
@Qualifier :
It is used along with @Autowired annotation. It is used when more control is required over the dependency injection process. Individual constructor arguments or method parameters can be specified by using this annotation. Confusion arises when more than one bean of the same type is created, and only one of them is to be wired with a property, @Qualifier is used to get rid of the confusion.
@CookieValue :
It is used at the method parameter level as an argument of the request mapping method. For a given cookie name, the HTTP cookie is bound to a @CookieValue parameter.
@Lazy
It is used in the component class. At startup, all auto-wired dependencies are created and configured. But a @Lazy annotation can be created if a bean is to be initialized lazily. This means that only if it is requested for a bean will be created. It can also be used on @Configuartion classes. It’s an indication that all @Bean methods within that @Configuration should be lazily initialized.
@Configuration
@ComponentScan(basePackages="org.mavin.krishna")
public class Config {
}
@Primary
we use @Primary to give higher preference to a bean when there are multiple beans of the same type.
@Order
The @Order annotation defines the sorting order of an annotated component or bean.
supports the ordering of injected components to a collection. As a result, Spring will inject the auto-wired beans of the same type based on their order value.
Ordered.LOWEST_PRECEDENCE.
Ordered.HIGHEST_PRECEDENCE
@Order(1)
@Component
@Order(Ordered.LOWEST_PRECEDENCE)
@EnableAsync
With this annotation, we can enable asynchronous functionality in Spring.
We must use it with @Configuration:
@EnableScheduling
With this annotation, we can enable scheduling in the application.
We also have to use it in conjunction with @Configuration:
@Async
We can define methods we want to execute on a different thread, hence run them asynchronously.
To achieve this, we can annotate the method with @Async:
@Scheduled
If we need a method to execute periodically, we can use this annotation:
@Scheduled(fixedRate = 10000)
@PostConstruct
Spring calls methods annotated with @PostConstruct only once, just after the initialization of bean properties.
@PreDestroy
A method annotated with @PreDestroy runs only once, just before Spring removes our bean from the application context.
