In this post, I'm sharing interview questions answers asked in telephonic round of CandelaLabs.
You can also read my other interviews:
Question1:
What is DispatcherServlet and why it is used for?
Answer:
The DispatcherServlet is the implementation of front controller design pattern that handles all incoming web requests to a spring MVC application.
A front controller pattern is a common pattern in web applications whose job is to receive all requests and route it to different components of application for actual processing.
In Spring MVC, the DispatcherServlet routes web requests to spring MVC controllers.
DispatcherServlet uses handler mapping like @RequestMapping annotation to find correct controller to process a request.
It s also responsible for delegating logical view name to ViewResolver and then sending the rendered response to the client.
Question 2:
What is the root application context in spring MVC? How is it loaded?
Answer:
In Spring MVC, the context loaded using ContextLoaderListener is called the root application context which belongs to the whole application. While the one initialized using DispatcherServlet is actually specific to that servlet.
Technically, spring MVC allows multiple DispatcherServlet in a spring MVC web application and so are multiple contexts , each specific for the specific servlet.
Question 3:
How many types of Dependency injection types are there in Spring?
Answer:
Spring documentation strictly defines only twp types of injection : constructor and setter injection.
However there are more ways to inject a dependency like a field injection , lookup method injection.
Constructor Injection: Enforcing immutability:
In this, a dependent class has a constructor , where all dependencies are set. These will be provided by spring container according to xml, java or annotation based configuration.
e.g.:
class Service1{
}
class Service2{
}
class DependentService{
private Service1 ser1;
private Service2 ser2;
public DependentService(Service ser1, Service2 ser2){
this.ser1 = ser1;
this.ser2 = ser2;
}
}
public class Main{
public static void main(String[] args){
ApplicationContext container = new ClassPathApplicationContext("spring.xml");
(DependentService) container.getBean("dependentService");
}
}
spring.xml is:
<?xml version = "1.0" encoding = "utf-8"?>
// bean xmlns namespaces goes here.....
<bean id = "service1" classs ="eample.service1"/>
<bean id = "service2" class = "example.service2"/>
<bean id="deoenddentService" class = "example.DepenentService">
<constructor-arg type = "example.Service1" ref = "service1"/>
<constructor-arg type = "example.Service2" ref = "service2"/>
</bean>
Constructor injection using annotation:
@Service
class Service1{
}
@Service
class Service2{
}
@Service
class DependentService{
private final Service1 ser1;
private final Service2 ser2;
@Autowired
public DependentService(Service1 ser1, Service2 ser2){
this.ser1 = ser1;
this.ser2 = ser2;
}
}
public class Main{
public static void main(String[] args){
ApplicationContext container = new ClassPathAppplicationContext("spring.xml");
(DependentService) container.getBean("dependentService");
}
}
Now in spring.xml file:
we do not need to add any <bean>.
Just add <context:component-scan base-package= "example"/>
Drawback of this approach:
We need to use @Qualifier annotation to tell spring, which implementation of a specific interface to use , in case w e are using two implementations of an interface.
Higher chance to have circular dependencies.
Note: We can have many more constructors in or class, but only one of them should qualify for dependency injection.
Advantage of this approach: Can be combined with setter injection and field injection.
Setter injection:
With XML:
class Service1{
}
class Service2{
}
class DependentService{
private Service1 ser1;
private Service2 ser2;
public DependentService(){
}
public void setService1(Service1 ser1){
this.ser1 = ser1;
}
public void setService2(Service2 ser2){
this.ser2 = ser2;
}
}
XML is:
<bean id = "service1" class = "example.Service1"/>
<bean id= "service2" class = "example.Service2"/>
<bean id = "dependentService" class = "example.DependentService">
<property name="service1" ref="service1"/>
<property name="service2" ref="service2"/>
</bean>
Setter Injection with annotations:
class Service1{
}
class Service2{
}
class DependentService{
private Service1 ser1;
private Service2 ser2;
public DependentService(){
}
@Autowired
public void serService1(Service1 ser1){
this.ser1 = ser1;
}
@Autowired
public void setService2(Service2 ser2){
this.ser2 = ser2;
}
}
Note: We can combine setter injection and constructor injection.
Field Injection:
@Service
class DependentService{
@Autowired
private Service1 ser1;
@Autowired
private Service2 ser2;
}
Advantages:
- Easy to use. No constructors or setters required.
- Can be easily combined with the constructor and /or setter approach.
Disadvantages:
- A number of dependencies can reach dozens until we notice that something went wrong in the design.
Question 4:
What are java Microservices frameworks?
Answer:
There are multiple java microservices frameworks:
- Spring and Spring boot
- DropWizard
- Eclipse MicroProfile
Spring and Spring Boot:
The framework propagates building the application into a jar and running it on the embedded Tomcat server , making it a perfect combination with Docker to manage a virtualized deployment environment.
DropWizard:
Like Spring boot, DropWizard application is packages into jar file with the jetty server embedded.
DropWizard integrates the tried-and-tested java libraries into a fully functional platform: Jersey for REST, Jackson for JSON, Freemarker for template and Mustache for java based UIs.
DropWizard ships with no built-in dependency injection solution, but integrations exist for Guice and Dagger.
Thanks for reading!!.
No comments:
Post a Comment