Java Springboot Microservices FAQs

  • 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-security

start by creating a Spring Security configuration class that extends WebSecurityConfigurerAdapter . By adding @EnableWebSecurity, we get Spring Security and MVC integration support.

rest 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.



  • How do we resolve cyclic dependency issues in Springboot? 
By using @Lazy annotation on the dependency we can resolve
or avoid constructor based injection in SB and use setter based injection 
  • Tomcat Max Threads settings in Springboot application? 
server.tomcat.max-connections
8192
Maximum number of connections that the server accepts and processes at any given time. Once the limit has been reached, the operating system may still accept connections based on the "acceptCount" property.
server.tomcat.max-http-form-post-size
2MB
Maximum size of the form content in any HTTP post request.
server.tomcat.max-swallow-size
2MB
Maximum amount of request body to swallow.
server.tomcat.max-threads
200
Maximum amount of worker threads.
server.tomcat.mbeanregistry.enabled
false
Whether Tomcat's MBean Registry should be enabled.
server.tomcat.min-spare-threads
10
Minimum amount of worker threads.
server.tomcat.port-header
X-Forwarded-Port
Name of the HTTP header used to override the original port value.
server.tomcat.processor-cache
200
Maximum number of idle processors that will be retained in the cache and reused with a subsequent request. When set to -1 the cache will be unlimited with a theoretical maximum size equal to the maximum number of connections.
server.tomcat.protocol-header
Header that holds the incoming protocol, usually named "X-Forwarded-Proto".
Reference:
https://docs.spring.io/spring-boot/docs/current/reference/html/appendix-application-properties.html

  • Sort Employee salary using Java Streams and display salary which is greater than X amount? Java 8 --streams, lambda expression

// find employees whose salaries are above 10000
        empList.stream().filter(emp->emp.getSalary() > 10000).forEach(System.out::println);

Reference:
https://www.java2novice.com/java-8/streams/filter-method-example/

  • Spring boot --Dependency injection types? 

There are basically three types of dependency injection:
constructor injection: the dependencies are provided through a class constructor.
setter injection: the client exposes a setter method that the injector uses to inject the dependency.
Interface injection: the dependency provides an injector method that will Clients must implement an interface that exposes a setter method that accepts the dependency.

So now its the dependency injection's responsibility to:
  • Create the objects
  • Know which classes require those objects
  • And provide them all those objects
Reference : https://java2blog.com/introduction-to-spring-framework/#Spring_Boot
  • How do we do monitoring of REST APIS ? 
Appdynamics like tools helps to do this monitoring

  • How do we call External Microservices in Springboot REST APIS ?

Using Rest Template or Feign clients 

Resttemplate : getForEntity(gets full responseEntity) vs getForObject (only object we get)

  exchange also do the same


  • What are status codes for DELETE API ?


Right Status codes for delete - 204 - content not found

                                          200 - OK 


  • Why Do we need Timeout setting in REST APIs ? 

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


  • What is content negotiation in the REST ? 

 mediatype : Produces or consumes is nothing but content negotiation.



  • What are cross-cutting concerns?

 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.

  •  REST Controller

 @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);


}

  • @autowire Vs @Inject

 @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.
@Service: It is also used at the class level. It tells the Spring that the class contains the business logic.

@Repository: It is a class-level annotation. The repository is a DAOs (Data Access Object) that access the database directly. The repository does all the operations related to the database.

@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.




Sunday, February 26, 2017 // Labels: , , // 0 comments //

0 comments to "Java Springboot Microservices FAQs"

Post a Comment

Whoever writes Inappropriate/Vulgar comments to context, generally want to be anonymous …So I hope U r not the one like that?
For lazy logs, u can at least use Name/URL option which doesn’t even require any sign-in, The good thing is that it can accept your lovely nick name also and the URL is not mandatory too.
Thanks for your patience
~Krishna(I love "Transparency")

Popular Posts

Enter your email address:

Buffs ...

Tags


Powered by WidgetsForFree