Spring Interview Questions

Spring Interview Questions have been designed specially to get you acquainted with the nature of questions you may encounter during your interview for the subject of Spring. As per my experience good interviewers hardly plan to ask any particular question during your interview, normally questions start with some basic concept of the subject and later they continue based on further discussion and what you answer:

Q: What is Spring?

A: Spring is an open source development framework for enterprise Java. The core features of the Spring Framework can be used in developing any Java application, but there are extensions for building web applications on top of the Java EE platform. Spring framework targets to make J2EE development easier to use and promote good programming practice by enabling a POJO-based programming model.

Q: what are benefits of using spring?

A: Following is the list of few of the great benefits of using Spring Framework:

·         Lightweight: Spring is lightweight when it comes to size and transparency. The basic version of spring framework is around 2MB.

·         Inversion of control (IOC): Loose coupling is achieved in spring using the technique Inversion of Control. The objects give their dependencies instead of creating or looking for dependent objects.

·         Aspect oriented (AOP): Spring supports Aspect oriented programming and enables cohesive development by separating application business logic from system services.

·         Container: Spring contains and manages the life cycle and configuration of application objects.

·         MVC Framework: Spring's web framework is a well-designed web MVC framework, which provides a great alternative to web frameworks such as Struts or other over engineered or less popular web frameworks.

·         Transaction Management: Spring provides a consistent transaction management interface that can scale down to a local transaction (using a single database, for example) and scale up to global transactions (using JTA, for example).

·         Exception Handling: Spring provides a convenient API to translate technology-specific exceptions (thrown by JDBC, Hibernate, or JDO, for example) into consistent, unchecked exceptions.

Q: What are the different modules in Spring framework?

A: Following are the modules of the Spring framework:

·         Core module

·         Bean module

·         Context module

·         Expression Language module

·         JDBC module

·         ORM module

·         OXM module

·         Java Messaging Service(JMS) module

·         Transaction module

·         Web module

·         Web-Servlet module

·         Web-Struts module

·         Web-Portlet module

Q: What is Spring configuration file?

A: Spring configuration file is an XML file. This file contains the classes information and describes how these classes are configured and introduced to each other.

Q: What is Dependency Injection?

A: Inversion of Control (IoC) is a general concept, and it can be expressed in many different ways and Dependency Injection is merely one concrete example of Inversion of Control.

This concept says that you do not create your objects but describe how they should be created. You don't directly connect your components and services together in code but describe which services are needed by which components in a configuration file. A container (the IOC container) is then responsible for hooking it all up.

Q: What are the different types of IoC (dependency injection)?

A: Types of IoC are:

·         Constructor-based dependency injection: Constructor-based DI is accomplished when the container invokes a class constructor with a number of arguments, each representing a dependency on other class.

·         Setter-based dependency injection: Setter-based DI is accomplished by the container calling setter methods on your beans after invoking a no-argument constructor or no-argument static factory method to instantiate your bean.

Q: Which DI would you suggest Constructor-based or setter-based DI?

A: Since you can mix both, Constructor- and Setter-based DI, it is a good rule of thumb to use constructor arguments for mandatory dependencies and setters for optional dependencies. Note that the use of a @Required annotation on a setter can be used to make setters required dependencies.

Q: What are the benefits of IOC?

A: The main benefits of IOC or dependency injection are:

·         It minimizes the amount of code in your application.

·         It makes your application easy to test as it doesn't require any singletons or JNDI lookup mechanisms in your unit test cases.

·         Loose coupling is promoted with minimal effort and least intrusive mechanism.

·         IOC containers support eager instantiation and lazy loading of services.

Q: What is AOP?

A: Aspect-oriented programming, or AOP, is a programming technique that allows programmers to modularize crosscutting concerns, or behavior that cuts across the typical divisions of responsibility, such as logging and transaction management. The core construct of AOP is the aspect, which encapsulates behaviors affecting multiple classes into reusable modules.

Q: What is Spring IoC container?

A: The Spring IoC creates the objects, wire them together, configure them, and manage their complete lifecycle from creation till destruction. The Spring container uses dependency injection (DI) to manage the components that make up an application.

Q: What are types of IoC containers? Explain them.

A: There are two types of IoC containers:

·         Bean Factory container: This is the simplest container providing basic support for DI .The BeanFactory is usually preferred where the resources are limited like mobile devices or applet based applications

·         Spring ApplicationContext Container: This container adds more enterprise-specific functionality such as the ability to resolve textual messages from a properties file and the ability to publish application events to interested event listeners.

Q: Give an example of BeanFactory implementation.

A: The most commonly used BeanFactory implementation is the XmlBeanFactory class. This container reads the configuration metadata from an XML file and uses it to create a fully configured system or application.

Q: What are the common implementations of the ApplicationContext?

A: The three commonly used implementation of 'Application Context' are:

·         FileSystemXmlApplicationContext: This container loads the definitions of the beans from an XML file. Here you need to provide the full path of the XML bean configuration file to the constructor.

·         ClassPathXmlApplicationContext: This container loads the definitions of the beans from an XML file. Here you do not need to provide the full path of the XML file but you need to set CLASSPATH properly because this container will look bean configuration XML file in CLASSPATH.

·         WebXmlApplicationContext: This container loads the XML file with definitions of all beans from within a web application.

Q: What is the difference between Bean Factory and ApplicationContext?

A: Following are some of the differences:

·         Application contexts provide a means for resolving text messages, including support for i18n of those messages.

·         Application contexts provide a generic way to load file resources, such as images.

·         Application contexts can publish events to beans that are registered as listeners.

·         Certain operations on the container or beans in the container, which have to be handled in a programmatic fashion with a bean factory, can be handled declaratively in an application context.

·         The application context implements MessageSource, an interface used to obtain localized messages, with the actual implementation being pluggable.

Q: What are Spring beans?

A: The objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. These beans are created with the configuration metadata that you supply to the container, for example, in the form of XML <bean/> definitions.

Q: What does a bean definition contain?

A: The bean definition contains the information called configuration metadata which is needed for the container to know the followings:

·         How to create a bean

·         Bean's lifecycle details

·         Bean's dependencies

Q: How do you provide configuration metadata to the Spring Container?

A: There are following three important methods to provide configuration metadata to the Spring Container:

·         XML based configuration file.

·         Annotation-based configuration

·         Java-based configuration

Q: How do add a bean in spring application?

A: Check the following example:

<?xml version="1.0"encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id="helloWorld" class="com.tutorialspoint.HelloWorld">

       <property name="message" value="Hello World!"/>

   </bean>

</beans>

Q: How do you define a bean scope?

A: When defining a <bean> in Spring, you have the option of declaring a scope for that bean. For example, to force Spring to produce a new bean instance each time one is needed, you should declare the bean's scope attribute to be prototype. Similar way if you want Spring to return the same bean instance each time one is needed, you should declare the bean's scope attribute to besingleton.

Q: What bean scopes does Spring support? Explain them.

A: The Spring Framework supports following five scopes, three of which are available only if you use a web-aware ApplicationContext.

·         singleton: This scopes the bean definition to a single instance per Spring IoC container.

·         prototype: This scopes a single bean definition to have any number of object instances.

·         request: This scopes a bean definition to an HTTP request. Only valid in the context of a web-aware Spring ApplicationContext.

·         session: This scopes a bean definition to an HTTP session. Only valid in the context of a web-aware Spring ApplicationContext.

·         global-session: This scopes a bean definition to a global HTTP session. Only valid in the context of a web-aware Spring ApplicationContext.

Q: What is default scope of bean in Spring framework?

A: The default scope of bean is Singleton for Spring framework.

Q: Are Singleton beans thread safe in Spring Framework?

A: No, singleton beans are not thread-safe in Spring framework.

Q: Explain Bean lifecycle in Spring framework?

A: Following is sequence of a bean lifecycle in Spring:

·         Instantiate - First the spring container finds the bean's definition from the XML file and instantiates the bean..

·         Populate properties - Using the dependency injection, spring populates all of the properties as specified in the bean definition..

·         Set Bean Name - If the bean implements BeanNameAware interface, spring passes the bean's id to setBeanName() method.

·         Set Bean factory - If Bean implements BeanFactoryAware interface, spring passes the beanfactory to setBeanFactory() method.

·         Pre Initialization - Also called postprocess of bean. If there are any bean BeanPostProcessors associated with the bean, Spring calls postProcesserBeforeInitialization() method.

·         Initialize beans - If the bean implements IntializingBean,its afterPropertySet() method is called. If the bean has init method declaration, the specified initialization method is called.

·         Post Initialization - If there are any BeanPostProcessors associated with the bean, their postProcessAfterInitialization() methods will be called.

·         Ready to use - Now the bean is ready to use by the application.

·         Destroy - If the bean implements DisposableBean , it will call the destroy() method .

Q: What are inner beans in Spring?

A: A <bean/> element inside the <property/> or <constructor-arg/> elements defines a so-called inner bean. An inner bean definition does not require a defined id or name; the container ignores these values. It also ignores the scope flag. Inner beans are always anonymous and they are always scoped as prototypes.

Q: How can you inject Java Collection in Spring?

A: Spring offers four types of collection configuration elements which are as follows:

·         <list>: This helps in wiring i.e. injecting a list of values, allowing duplicates.

·         <set>: This helps in wiring a set of values but without any duplicates.

·         <map>: This can be used to inject a collection of name-value pairs where name and value can be of any type.

·         <props>: This can be used to inject a collection of name-value pairs where the name and value are both Strings.

Q: What is bean auto wiring?

A: The Spring container is able to autowire relationships between collaborating beans. This means that it is possible to automatically let Spring resolve collaborators (other beans) for your bean by inspecting the contents of the BeanFactory without using <constructor-arg> and <property> elements.

Q: What are different Modes of auto wiring?

A: The autowiring functionality has five modes which can be used to instruct Spring container to use autowiring for dependency injection:

·         no: This is default setting which means no autowiring and you should use explicit bean reference for wiring. You have nothing to do special for this wiring. This is what you already have seen in Dependency Injection chapter.

·         byName: Autowiring by property name. Spring container looks at the properties of the beans on which autowire attribute is set to byName in the XML configuration file. It then tries to match and wire its properties with the beans defined by the same names in the configuration file.

·         byType: Autowiring by property datatype. Spring container looks at the properties of the beans on which autowire attribute is set to byType in the XML configuration file. It then tries to match and wire a property if its type matches with exactly one of the beans name in configuration file. If more than one such beans exist, a fatal exception is thrown.

·         constructor: Similar to byType, but type applies to constructor arguments. If there is not exactly one bean of the constructor argument type in the container, a fatal error is raised.

·         autodetect: Spring first tries to wire using autowire by constructor, if it does not work, Spring tries to autowire by byType.

Q: What are the limitations with autowiring?

A: Limitations of autowiring are:

·         Overriding possibility: You can still specify dependencies using <constructor-arg> and <property> settings which will always override autowiring.

·         Primitive data types: You cannot autowire so-called simple properties such as primitives, Strings, and Classes.

·         Confusing nature: Autowiring is less exact than explicit wiring, so if possible prefer using explicit wiring.

Q: Can you inject null and empty string values in Spring?

A: Yes.

Q: What is Annotation-based container configuration?

A: An alternative to XML setups is provided by annotation-based configuration which relies on the bytecode metadata for wiring up components instead of angle-bracket declarations. Instead of using XML to describe a bean wiring, the developer moves the configuration into the component class itself by using annotations on the relevant class, method, or field declaration.

Q: How do you turn on annotation wiring?

A: Annotation wiring is not turned on in the Spring container by default. So, before we can use annotation-based wiring, we will need to enable it in our Spring configuration file by configuring <context:annotation-config/>.

Q: What does @Required annotation mean?

A: This annotation simply indicates that the affected bean property must be populated at configuration time, through an explicit property value in a bean definition or through autowiring. The container throws BeanInitializationException if the affected bean property has not been populated.

Q: What does @Autowired annotation mean?

A: This annotation provides more fine-grained control over where and how autowiring should be accomplished. The @Autowired annotation can be used to autowire bean on the setter method just like @Required annotation, constructor, a property or methods with arbitrary names and/or multiple arguments.

Q: What does @Qualifier annotation mean?

A: There may be a situation when you create more than one bean of the same type and want to wire only one of them with a property, in such case you can use @Qualifier annotation along with @Autowired to remove the confusion by specifying which exact bean will be wired.

Q: What are the JSR-250 Annotations? Explain them.

A: Spring has JSR-250 based annotations which include @PostConstruct, @PreDestroy and @Resource annotations.

·         @PostConstruct: This annotation can be used as an alternate of initialization callback.

·         @PreDestroy: This annotation can be used as an alternate of destruction callback.

·         @Resource : This annotation can be used on fields or setter methods. The @Resource annotation takes a 'name' attribute which will be interpreted as the bean name to be injected. You can say, it follows by-name autowiring semantics.

Q: What is Spring Java Based Configuration? Give some annotation example.

A: Java based configuration option enables you to write most of your Spring configuration without XML but with the help of few Java-based annotations.

For example: Annotation @Configuration indicates that the class can be used by the Spring IoC container as a source of bean definitions. The @Bean annotation tells Spring that a method annotated with @Bean will return an object that should be registered as a bean in the Spring application context.

Q: How is event handling done in Spring?

A: Event handling in the ApplicationContext is provided through the ApplicationEvent class andApplicationListener interface. So if a bean implements the ApplicationListener, then every time anApplicationEvent gets published to the ApplicationContext, that bean is notified.

Q: Describe some of the standard Spring events.

A: Spring provides the following standard events:

·         ContextRefreshedEvent: This event is published when the ApplicationContext is either initialized or refreshed. This can also be raised using the refresh() method on the ConfigurableApplicationContext interface.

·         ContextStartedEvent: This event is published when the ApplicationContext is started using the start() method on the ConfigurableApplicationContext interface. You can poll your database or you can re/start any stopped application after receiving this event.

·         ContextStoppedEvent: This event is published when the ApplicationContext is stopped using the stop() method on the ConfigurableApplicationContext interface. You can do required housekeep work after receiving this event.

·         ContextClosedEvent: This event is published when the ApplicationContext is closed using the close() method on the ConfigurableApplicationContext interface. A closed context reaches its end of life; it cannot be refreshed or restarted.

·         RequestHandledEvent: This is a web-specific event telling all beans that an HTTP request has been serviced.

Q: What is Aspect?

A: A module which has a set of APIs providing cross-cutting requirements. For example, a logging module would be called AOP aspect for logging. An application can have any number of aspects depending on the requirement. In Spring AOP, aspects are implemented using regular classes (the schema-based approach) or regular classes annotated with the @Aspect annotation (@AspectJ style).

Q: What is the difference between concern and cross-cutting concern in Spring AOP?

A: Concern: Concern is behavior which we want to have in a module of an application. Concern may be defined as a functionality we want to implement. Issues in which we are interested define our concerns.

Cross-cutting concern: It's a concern which is applicable throughout the application and it affects the entire application. e.g. logging , security and data transfer are the concerns which are needed in almost every module of an application, hence are cross-cutting concerns.

Q: What is Join point?

A: This represents a point in your application where you can plug-in AOP aspect. You can also say, it is the actual place in the application where an action will be taken using Spring AOP framework.

Q: What is Advice?

A: This is the actual action to be taken either before or after the method execution. This is actual piece of code that is invoked during program execution by Spring AOP framework.

Q: What is Pointcut?

A: This is a set of one or more joinpoints where an advice should be executed. You can specify pointcuts using expressions or patterns as we will see in our AOP examples.

Q: What is Introduction?

A: An introduction allows you to add new methods or attributes to existing classes.

Q: What is Target object?

A: The object being advised by one or more aspects, this object will always be a proxy object. Also referred to as the advised object.

Q: What is Weaving?

A: Weaving is the process of linking aspects with other application types or objects to create an advised object.

Q: What are the different points where weaving can be applied?

A: Weaving can be done at compile time, load time, or at runtime.

Q: What are the types of advice?

A: Spring aspects can work with five kinds of advice mentioned below:

·         before: Run advice before the a method execution.

·         after: Run advice after the a method execution regardless of its outcome.

·         after-returning: Run advice after the a method execution only if method completes successfully.

·         after-throwing: Run advice after the a method execution only if method exits by throwing an exception.

·         around: Run advice before and after the advised method is invoked.

Q: What is XML Schema based aspect implementation?

A: Aspects are implemented using regular classes along with XML based configuration.

Q: What is @AspectJ? based aspect implementation?

A: @AspectJ refers to a style of declaring aspects as regular Java classes annotated with Java 5 annotations.

Q: How JDBC can be used more efficiently in spring framework?

A: JDBC can be used more efficiently with the help of a template class provided by spring framework called as JdbcTemplate.

Q: How JdbcTemplate can be used?

A: With use of Spring JDBC framework the burden of resource management and error handling is reduced a lot. So it leaves developers to write the statements and queries to get the data to and from the database. JdbcTemplate provides many convenience methods for doing things such as converting database data into primitives or objects, executing prepared and callable statements, and providing custom database error handling.

Q: What are the types of the transaction management Spring supports?

A: Spring supports two types of transaction management:

·         Programmatic transaction management: This means that you have managed the transaction with the help of programming. That gives you extreme flexibility, but it is difficult to maintain.

·         Declarative transaction management: This means you separate transaction management from the business code. You only use annotations or XML based configuration to manage the transactions.

Q: Which of the above transaction management type is preferable?

A: Declarative transaction management is preferable over programmatic transaction management though it is less flexible than programmatic transaction management, which allows you to control transactions through your code.

Q: What is Spring MVC framework?

A: The Spring web MVC framework provides model-view-controller architecture and ready components that can be used to develop flexible and loosely coupled web applications. The MVC pattern results in separating the different aspects of the application (input logic, business logic, and UI logic), while providing a loose coupling between these elements.

Q: What is a DispatcherServlet?

A: The Spring Web MVC framework is designed around a DispatcherServlet that handles all the HTTP requests and responses.

Q: What is WebApplicationContext ?

A: The WebApplicationContext is an extension of the plain ApplicationContext that has some extra features necessary for web applications. It differs from a normal ApplicationContext in that it is capable of resolving themes, and that it knows which servlet it is associated with.

Q: What are the advantages of Spring MVC over Struts MVC ?

A: Following are some of the advantages of Spring MVC over Struts MVC:

·         Spring's MVC is very versatile and flexible based on interfaces but Struts forces Actions and Form object into concrete inheritance.

·         Spring provides both interceptors and controllers, thus helps to factor out common behavior to the handling of many requests.

·         Spring can be configured with different view technologies like Freemarker, JSP, Tiles, Velocity, XLST etc. and also you can create your own custom view mechanism by implementing Spring View interface.

·         In Spring MVC Controllers can be configured using DI (IOC) that makes its testing and integration easy.

·         Web tier of Spring MVC is easy to test than Struts web tier, because of the avoidance of forced concrete inheritance and explicit dependence of controllers on the dispatcher servlet.

·         Struts force your Controllers to extend a Struts class but Spring doesn't, there are many convenience Controller implementations that you can choose to extend.

·         In Struts, Actions are coupled to the view by defining ActionForwards within a ActionMapping or globally. SpringMVC has HandlerMapping interface to support this functionality.

·         With Struts, validation is usually performed (implemented) in the validate method of an ActionForm. In SpringMVC, validators are business objects that are NOT dependent on the Servlet API which makes these validators to be reused in your business logic before persisting a domain object to a database.

Q: What is Controller in Spring MVC framework?

A: Controllers provide access to the application behavior that you typically define through a service interface. Controllers interpret user input and transform it into a model that is represented to the user by the view. Spring implements a controller in a very abstract way, which enables you to create a wide variety of controllers.

Q: Explain the @Controller annotation.

A: The @Controller annotation indicates that a particular class serves the role of a controller. Spring does not require you to extend any controller base class or reference the Servlet API.

Q: Explain @RequestMapping annotation.

A: @RequestMapping annotation is used to map a URL to either an entire class or a particular handler method.

Q: What are the ways to access Hibernate by using Spring?

A: There are two ways to access hibernate using spring:

·         Inversion of Control with a Hibernate Template and Callback.

·         Extending HibernateDAOSupport and Applying an AOP Interceptor node.

Q: What are ORM's Spring supports ?

A: Spring supports the following ORM's :

·         Hibernate

·         iBatis

·         JPA (Java Persistence API)

·         TopLink

·         JDO (Java Data Objects)

·         OJB

Q: What is Spring Framework?

A: Spring is one of the most widely used Java EE framework. Spring framework core concepts are “Dependency Injection” and “Aspect Oriented Programming”.

Spring framework can be used in normal java applications also to achieve loose coupling between different components by implementing dependency injection and we can perform cross cutting tasks such as logging and authentication using spring support for aspect oriented programming.

I like spring because it provides a lot of features and different modules for specific tasks such as Spring MVC and Spring JDBC. Since it’s an open source framework with a lot of online resources and active community members, working with Spring framework is easy and fun at same time.

Q: What are some of the important features and advantages of Spring Framework

A: Spring Framework is built on top of two design concepts – Dependency Injection and Aspect Oriented Programming.

Some of the features of spring framework are:

Lightweight and very little overhead of using framework for our development.

Dependency Injection or Inversion of Control to write components that are independent of each other, spring container takes care of wiring them together to achieve our work.

Spring IoC container manages Spring Bean life cycle and project specific configurations such as JNDI lookup.

Spring MVC framework can be used to create web applications as well as restful web services capable of returning XML as well as JSON response.

Support for transaction management, JDBC operations, File uploading, Exception Handling etc with very little configurations, either by using annotations or by spring bean configuration file.

Some of the advantages of using Spring Framework are:

Reducing direct dependencies between different components of the application, usually Spring IoC container is responsible for initializing resources or beans and inject them as dependencies.

Writing unit test cases are easy in Spring framework because our business logic doesn’t have direct dependencies with actual resource implementation classes. We can easily write a test configuration and inject our mock beans for testing purposes.

Reduces the amount of boiler-plate code, such as initializing objects, open/close resources. I like JdbcTemplate class a lot because it helps us in removing all the boiler-plate code that comes with JDBC programming.

Spring framework is divided into several modules, it helps us in keeping our application lightweight. For example, if we don’t need Spring transaction management features, we don’t need to add that dependency in our project.

Spring framework support most of the Java EE features and even much more. It’s always on top of the new technologies, for example there is a Spring project for Android to help us write better code for native android applications. This makes spring framework a complete package and we don’t need to look after different framework for different requirements.

Q: What do you understand by Dependency Injection?

A: Dependency Injection design pattern allows us to remove the hard-coded dependencies and make our application loosely coupled, extendable and maintainable. We can implement dependency injection pattern to move the dependency resolution from compile-time to runtime.

Some of the benefits of using Dependency Injection are: Separation of Concerns, Boilerplate Code reduction, Configurable components and easy unit testing.

Read more at Dependency Injection Tutorial. We can also use Google Guice for Dependency Injection to automate the process of dependency injection. But in most of the cases we are looking for more than just dependency injection and that’s why Spring is the top choice for this.

Q: How do we implement DI in Spring Framework?

A: We can use Spring XML based as well as Annotation based configuration to implement DI in spring applications. For better understanding, please read Spring Dependency Injection example where you can learn both the ways with JUnit test case. The post also contains sample project zip file, that you can download and play around to learn more.

Q: What are the benefits of using Spring Tool Suite?

A: We can install plugins into Eclipse to get all the features of Spring Tool Suite. However STS comes with Eclipse with some other important stuffs such as Maven support, Templates for creating different types of Spring projects and tc server for better performance with Spring applications.

I like STS because it highlights the Spring components and if you are using AOP pointcuts and advices, then it clearly shows which methods will come under the specific pointcut. So rather than installing everything on our own, I prefer using STS when developing Spring based applications.

Q: Name some of the important Spring Modules?

A: Some of the important Spring Framework modules are:

Spring Context – for dependency injection.

Spring AOP – for aspect oriented programming.

Spring DAO – for database operations using DAO pattern

Spring JDBC – for JDBC and DataSource support.

Spring ORM – for ORM tools support such as Hibernate

Spring Web Module – for creating web applications.

Spring MVC – Model-View-Controller implementation for creating web applications, web services etc.

Q: What do you understand by Aspect Oriented Programming?

A: Enterprise applications have some common cross-cutting concerns that is applicable for different types of Objects and application modules, such as logging, transaction management, data validation, authentication etc. In Object Oriented Programming, modularity of application is achieved by Classes whereas in AOP application modularity is achieved by Aspects and they are configured to cut across different classes methods.

AOP takes out the direct dependency of cross-cutting tasks from classes that is not possible in normal object oriented programming. For example, we can have a separate class for logging but again the classes will have to call these methods for logging the data. Read more about Spring AOP support at Spring AOP Example.

Q: What is Aspect, Advice, Pointcut, JointPoint and Advice Arguments in AOP?

A: Aspect: Aspect is a class that implements cross-cutting concerns, such as transaction management. Aspects can be a normal class configured and then configured in Spring Bean configuration file or we can use Spring AspectJ support to declare a class as Aspect using @Aspect annotation.

Advice: Advice is the action taken for a particular join point. In terms of programming, they are methods that gets executed when a specific join point with matching pointcut is reached in the application. You can think of Advices as Spring interceptors or Servlet Filters.

Pointcut: Pointcut are regular expressions that is matched with join points to determine whether advice needs to be executed or not. Pointcut uses different kinds of expressions that are matched with the join points. Spring framework uses the AspectJ pointcut expression language for determining the join points where advice methods will be applied.

Join Point: A join point is the specific point in the application such as method execution, exception handling, changing object variable values etc. In Spring AOP a join points is always the execution of a method.

Advice Arguments: We can pass arguments in the advice methods. We can use args() expression in the pointcut to be applied to any method that matches the argument pattern. If we use this, then we need to use the same name in the advice method from where argument type is determined.

These concepts seems confusing at first, but if you go through Spring Aspect, Advice Example then you can easily relate to them.

Q: What is the difference between Spring AOP and AspectJ AOP?

A: AspectJ is the industry-standard implementation for Aspect Oriented Programming whereas Spring implements AOP for some cases. Main differences between Spring AOP and AspectJ are:

Spring AOP is simpler to use than AspectJ because we don’t need to worry about the weaving process.

Spring AOP supports AspectJ annotations, so if you are familiar with AspectJ then working with Spring AOP is easier.

Spring AOP supports only proxy-based AOP, so it can be applied only to method execution join points. AspectJ support all kinds of pointcuts.

One of the shortcoming of Spring AOP is that it can be applied only to the beans created through Spring Context.

Q: What is Spring IoC Container?

A: Inversion of Control (IoC) is the mechanism to achieve loose-coupling between Objects dependencies. To achieve loose coupling and dynamic binding of the objects at runtime, the objects define their dependencies that are being injected by other assembler objects. Spring IoC container is the program that injects dependencies into an object and make it ready for our use.

Spring Framework IoC container classes are part of org.springframework.beans and org.springframework.context packages and provides us different ways to decouple the object dependencies.

Some of the useful ApplicationContext implementations that we use are;

AnnotationConfigApplicationContext: For standalone java applications using annotations based configuration.

ClassPathXmlApplicationContext: For standalone java applications using XML based configuration.

FileSystemXmlApplicationContext: Similar to ClassPathXmlApplicationContext except that the xml configuration file can be loaded from anywhere in the file system.

AnnotationConfigWebApplicationContext and XmlWebApplicationContext for web applications.

Q: What is a Spring Bean?

A: Any normal java class that is initialized by Spring IoC container is called Spring Bean. We use Spring ApplicationContext to get the Spring Bean instance.

Spring IoC container manages the life cycle of Spring Bean, bean scopes and injecting any required dependencies in the bean.

Q: What is the importance of Spring bean configuration file?

A: We use Spring Bean configuration file to define all the beans that will be initialized by Spring Context. When we create the instance of Spring ApplicationContext, it reads the spring bean xml file and initialize all of them. Once the context is initialized, we can use it to get different bean instances.

Apart from Spring Bean configuration, this file also contains spring MVC interceptors, view resolvers and other elements to support annotations based configurations.

Q: What are different ways to configure a class as Spring Bean?

A: There are three different ways to configure Spring Bean.

XML Configuration: This is the most popular configuration and we can use bean element in context file to configure a Spring Bean. For example:

<bean name="myBean" class="com.journaldev.spring.beans.MyBean"></bean>

Java Based Configuration: If you are using only annotations, you can configure a Spring bean using @Bean annotation. This annotation is used with @Configuration classes to configure a spring bean. Sample configuration is:

@Configuration

@ComponentScan(value="com.journaldev.spring.main")

public class MyConfiguration {

    @Bean

    public MyService getService(){

        return new MyService();

    }

}

To get this bean from spring context, we need to use following code snippet:

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MyConfiguration.class);

MyService service = ctx.getBean(MyService.class);

Annotation Based Configuration: We can also use @Component, @Service, @Repository and @Controller annotations with classes to configure them to be as spring bean. For these, we would need to provide base package location to scan for these classes. For example:

<context:component-scan base-package="com.journaldev.spring" />

Q: What are different scopes of Spring Bean?

A:  There are five scopes defined for Spring Beans.

singleton: Only one instance of the bean will be created for each container. This is the default scope for the spring beans. While using this scope, make sure spring bean doesn’t have shared instance variables otherwise it might lead to data inconsistency issues because it’s not thread-safe.

prototype: A new instance will be created every time the bean is requested.

request: This is same as prototype scope, however it’s meant to be used for web applications. A new instance of the bean will be created for each HTTP request.

session: A new bean will be created for each HTTP session by the container.

global-session: This is used to create global session beans for Portlet applications.

Spring Framework is extendable and we can create our own scopes too, however most of the times we are good with the scopes provided by the framework.

To set spring bean scopes we can use “scope” attribute in bean element or @Scope annotation for annotation based configurations.

Q: What is Spring Bean life cycle?

A: Spring Beans are initialized by Spring Container and all the dependencies are also injected. When context is destroyed, it also destroys all the initialized beans. This works well in most of the cases but sometimes we want to initialize other resources or do some validation before making our beans ready to use. Spring framework provides support for post-initialization and pre-destroy methods in spring beans.

We can do this by two ways – by implementing InitializingBean and DisposableBean interfaces or using init-method and destroy-method attribute in spring bean configurations. For more details, please read Spring Bean Life Cycle Methods.

Q: How to get ServletContext and ServletConfig object in a Spring Bean?

A: There are two ways to get Container specific objects in the spring bean.

Implementing Spring *Aware interfaces, for these ServletContextAware and ServletConfigAware interfaces, for complete example of these aware interfaces, please read Spring Aware Interfaces

Using @Autowired annotation with bean variable of type ServletContext and ServletConfig. They will work only in servlet container specific environment only though.

@Autowired

ServletContext servletContext;

Q: What is Bean wiring and @Autowired annotation?

A: The process of injection spring bean dependencies while initializing it called Spring Bean Wiring.

Usually it’s best practice to do the explicit wiring of all the bean dependencies, but spring framework also supports autowiring. We can use @Autowired annotation with fields or methods for autowiring byType. For this annotation to work, we also need to enable annotation based configuration in spring bean configuration file. This can be done by context:annotation-config element.

For more details about @Autowired annotation, please read Spring Autowire Example.

Q: What are different types of Spring Bean autowiring?

A: There are four types of autowiring in Spring framework.

autowire byName

autowire byType

autowire by constructor

autowiring by @Autowired and @Qualifier annotations

Prior to Spring 3.1, autowire by autodetect was also supported that was similar to autowire by constructor or byType. For more details about these options, please read Spring Bean Autowiring.

Q: Does Spring Bean provide thread safety?

A: The default scope of Spring bean is singleton, so there will be only one instance per context. That means that all the having a class level variable that any thread can update will lead to inconsistent data. Hence in default mode spring beans are not thread-safe.

However we can change spring bean scope to request, prototype or session to achieve thread-safety at the cost of performance. It’s a design decision and based on the project requirements.

Q: What is a Controller in Spring MVC?

A: Just like MVC design pattern, Controller is the class that takes care of all the client requests and send them to the configured resources to handle it. In Spring MVC, org.springframework.web.servlet.DispatcherServlet is the front controller class that initializes the context based on the spring beans configurations.

A Controller class is responsible to handle different kind of client requests based on the request mappings. We can create a controller class by using @Controller annotation. Usually it’s used with @RequestMapping annotation to define handler methods for specific URI mapping.

Q: What’s the difference between @Component, @Controller, @Repository & @Service annotations in Spring?

A: @Componentis used to indicate that a class is a component. These classes are used for auto detection and configured as bean, when annotation based configurations are used.

@Controller is a specific type of component, used in MVC applications and mostly used with RequestMapping annotation.

@Repository annotation is used to indicate that a component is used as repository and a mechanism to store/retrieve/search data. We can apply this annotation with DAO pattern implementation classes.

@Service is used to indicate that a class is a Service. Usually the business facade classes that provide some services are annotated with this.

We can use any of the above annotations for a class for auto-detection but different types are provided so that you can easily distinguish the purpose of the annotated classes.

Q: What is DispatcherServlet and ContextLoaderListener?

A: DispatcherServlet is the front controller in the Spring MVC application and it loads the spring bean configuration file and initialize all the beans that are configured. If annotations are enabled, it also scans the packages and configure any bean annotated with @Component, @Controller, @Repository or @Service annotations.

ContextLoaderListener is the listener to start up and shut down Spring’s root WebApplicationContext. It’s important functions are to tie up the lifecycle of ApplicationContext to the lifecycle of the ServletContext and to automate the creation of ApplicationContext. We can use it to define shared beans that can be used across different spring contexts.

Q: What is ViewResolver in Spring?

A: ViewResolver implementations are used to resolve the view pages by name. Usually we configure it in the spring bean configuration file. For example:

<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->

<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">

    <beans:property name="prefix" value="/WEB-INF/views/" />

    <beans:property name="suffix" value=".jsp" />

</beans:bean>

InternalResourceViewResolver is one of the implementation of ViewResolver interface and we are providing the view pages directory and suffix location through the bean properties. So if a controller handler method returns “home”, view resolver will use view page located at /WEB-INF/views/home.jsp.

Q: What is a MultipartResolver and when its used?

A: MultipartResolver interface is used for uploading files – CommonsMultipartResolver and StandardServletMultipartResolver are two implementations provided by spring framework for file uploading. By default there are no multipart resolvers configured but to use them for uploading files, all we need to define a bean named “multipartResolver” with type as MultipartResolver in spring bean configurations.

Once configured, any multipart request will be resolved by the configured MultipartResolver and pass on a wrapped HttpServletRequest. Then it’s used in the controller class to get the file and process it. For a complete example, please read Spring MVC File Upload Example.

Q: How to handle exceptions in Spring MVC Framework?

A: Spring MVC Framework provides following ways to help us achieving robust exception handling.

Controller Based – We can define exception handler methods in our controller classes. All we need is to annotate these methods with @ExceptionHandler annotation.

Global Exception Handler – Exception Handling is a cross-cutting concern and Spring provides @ControllerAdvice annotation that we can use with any class to define our global exception handler.

HandlerExceptionResolver implementation – For generic exceptions, most of the times we serve static pages. Spring Framework provides HandlerExceptionResolver interface that we can implement to create global exception handler. The reason behind this additional way to define global exception handler is that Spring framework also provides default implementation classes that we can define in our spring bean configuration file to get spring framework exception handling benefits.

For a complete example, please read Spring Exception Handling Example.

Q: How to create ApplicationContext in a Java Program?

A: There are following ways to create spring context in a standalone java program.

AnnotationConfigApplicationContext: If we are using Spring in standalone java applications and using annotations for Configuration, then we can use this to initialize the container and get the bean objects.

ClassPathXmlApplicationContext: If we have spring bean configuration xml file in standalone application, then we can use this class to load the file and get the container object.

FileSystemXmlApplicationContext: This is similar to ClassPathXmlApplicationContext except that the xml configuration file can be loaded from anywhere in the file system.

Q: Can we have multiple Spring configuration files?

A: For Spring MVC applications, we can define multiple spring context configuration files through contextConfigLocation. This location string can consist of multiple locations separated by any number of commas and spaces. For example;

<servlet>

    <servlet-name>appServlet</servlet-name>

    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <init-param>

        <param-name>contextConfigLocation</param-name>

        <param-value>/WEB-INF/spring/appServlet/servlet-context.xml,/WEB-INF/spring/appServlet/servlet-jdbc.xml</param-value>

    </init-param>

    <load-on-startup>1</load-on-startup>

</servlet>

We can also define multiple root level spring configurations and load it through context-param. For example;

<context-param>

    <param-name>contextConfigLocation</param-name>

    <param-value>/WEB-INF/spring/root-context.xml /WEB-INF/spring/root-security.xml</param-value>

</context-param>

Another option is to use import element in the context configuration file to import other configurations, for example:

<beans:import resource="spring-jdbc.xml"/>

Q: What is ContextLoaderListener?

A: ContextLoaderListener is the listener class used to load root context and define spring bean configurations that will be visible to all other contexts. It’s configured in web.xml file as:

<context-param>

    <param-name>contextConfigLocation</param-name>

    <param-value>/WEB-INF/spring/root-context.xml</param-value>

</context-param>

<listener>

    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

Q: What are the minimum configurations needed to create Spring MVC application?

A: For creating a simple Spring MVC application, we would need to do following tasks.

Add spring-context and spring-webmvc dependencies in the project.

Configure DispatcherServlet in the web.xml file to handle requests through spring container.

Spring bean configuration file to define beans, if using annotations then it has to be configured here. Also we need to configure view resolver for view pages.

Controller class with request mappings defined to handle the client requests.

Above steps should be enough to create a simple Spring MVC Hello World application.

Q: How would you relate Spring MVC Framework to MVC architecture?

A: As the name suggests Spring MVC is built on top of Model-View-Controller architecture. DispatcherServlet is the Front Controller in the Spring MVC application that takes care of all the incoming requests and delegate it to different controller handler methods.

Model can be any Java Bean in the Spring Framework, just like any other MVC framework Spring provides automatic binding of form data to java beans. We can set model beans as attributes to be used in the view pages.

View Pages can be JSP, static HTMLs etc. and view resolvers are responsible for finding the correct view page. Once the view page is identified, control is given back to the DispatcherServlet controller. DispatcherServlet is responsible for rendering the view and returning the final response to the client.

Q: How to achieve localization in Spring MVC applications?

A: Spring provides excellent support for localization or i18n through resource bundles. Basis steps needed to make our application localized are:

Creating message resource bundles for different locales, such as messages_en.properties, messages_fr.properties etc.

Defining messageSource bean in the spring bean configuration file of type ResourceBundleMessageSource or ReloadableResourceBundleMessageSource.

For change of locale support, define localeResolver bean of type CookieLocaleResolver and configure LocaleChangeInterceptor interceptor. Example configuration can be like below:

<beans:bean id="messageSource"

    class="org.springframework.context.support.ReloadableResourceBundleMessageSource">

    <beans:property name="basename" value="classpath:messages" />

    <beans:property name="defaultEncoding" value="UTF-8" />

</beans:bean>

<beans:bean id="localeResolver"

    class="org.springframework.web.servlet.i18n.CookieLocaleResolver">

    <beans:property name="defaultLocale" value="en" />

    <beans:property name="cookieName" value="myAppLocaleCookie"></beans:property>

    <beans:property name="cookieMaxAge" value="3600"></beans:property>

</beans:bean>

<interceptors>

    <beans:bean

        class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">

        <beans:property name="paramName" value="locale" />

    </beans:bean>

</interceptors>

Use spring:message element in the view pages with key names, DispatcherServlet picks the corresponding value and renders the page in corresponding locale and return as response.

For a complete example, please read Spring Localization Example.

Q: How can we use Spring to create Restful Web Service returning JSON response?

A: We can use Spring Framework to create Restful web services that returns JSON data. Spring provides integration with Jackson JSON API that we can use to send JSON response in restful web service.

We would need to do following steps to configure our Spring MVC application to send JSON response:

Adding Jackson JSON dependencies, if you are using Maven it can be done with following code:

<!-- Jackson -->

<dependency>

    <groupId>com.fasterxml.jackson.core</groupId>

    <artifactId>jackson-databind</artifactId>

    <version>${jackson.databind-version}</version>

</dependency>

Configure RequestMappingHandlerAdapter bean in the spring bean configuration file and set the messageConverters property to MappingJackson2HttpMessageConverter bean. Sample configuration will be:

<!-- Configure to plugin JSON as request and response in method handler -->

<beans:bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">

    <beans:property name="messageConverters">

        <beans:list>

            <beans:ref bean="jsonMessageConverter"/>

        </beans:list>

    </beans:property>

</beans:bean>

 

<!-- Configure bean to convert JSON to POJO and vice versa -->

<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">

</beans:bean>

In the controller handler methods, return the Object as response using @ResponseBody annotation. Sample code:

@RequestMapping(value = EmpRestURIConstants.GET_EMP, method = RequestMethod.GET)

public @ResponseBody Employee getEmployee(@PathVariable("id") int empId) {

    logger.info("Start getEmployee. ID="+empId);

     

    return empData.get(empId);

}

You can invoke the rest service through any API, but if you want to use Spring then we can easily do it using RestTemplate class.

For a complete example, please read Spring Restful Webservice Example.

Q: What are some of the important Spring annotations you have used?

A: Some of the Spring annotations that I have used in my project are:

@Controller – for controller classes in Spring MVC project.

@RequestMapping – for configuring URI mapping in controller handler methods. This is a very important annotation, so you should go through Spring MVC RequestMapping Annotation Examples

@ResponseBody – for sending Object as response, usually for sending XML or JSON data as response.

@PathVariable – for mapping dynamic values from the URI to handler method arguments.

@Autowired – for autowiring dependencies in spring beans.

@Qualifier – with @Autowired annotation to avoid confusion when multiple instances of bean type is present.

@Service – for service classes.

@Scope – for configuring scope of the spring bean.

@Configuration, @ComponentScan and @Bean – for java based configurations.

AspectJ annotations for configuring aspects and advices, @Aspect, @Before, @After, @Around, @Pointcut etc.

Q: Can we send an Object as the response of Controller handler method?

A: Yes we can, using @ResponseBody annotation. This is how we send JSON or XML based response in restful web services.

Q: How to upload file in Spring MVC Application?

A: Spring provides built-in support for uploading files through MultipartResolver interface implementations. It’s very easy to use and requires only configuration changes to get it working. Obviously we would need to write controller handler method to handle the incoming file and process it. For a complete example, please refer Spring File Upload Example.

Q: How to validate form data in Spring Web MVC Framework?

A: Spring supports JSR-303 annotation based validations as well as provide Validator interface that we can implement to create our own custom validator. For using JSR-303 based validation, we need to annotate bean variables with the required validations.

For custom validator implementation, we need to configure it in the controller class. For a complete example, please read Spring MVC Form Validation Example.

Q: What is Spring MVC Interceptor and how to use it?

A: Spring MVC Interceptors are like Servlet Filters and allow us to intercept client request and process it. We can intercept client request at three places – preHandle, postHandle and afterCompletion.

We can create spring interceptor by implementing HandlerInterceptor interface or by extending abstract class HandlerInterceptorAdapter.

We need to configure interceptors in the spring bean configuration file. We can define an interceptor to intercept all the client requests or we can configure it for specific URI mapping too. For a detailed example, please refer Spring MVC Interceptor Example.

Q: What is Spring JdbcTemplate class and how to use it?

A: Spring Framework provides excellent integration with JDBC API and provides JdbcTemplate utility class that we can use to avoid bolier-plate code from our database operations logic such as Opening/Closing Connection, ResultSet, PreparedStatement etc.

For JdbcTemplate example, please refer Spring JDBC Example.

Q: How to use Tomcat JNDI DataSource in Spring Web Application?

A: For using servlet container configured JNDI DataSource, we need to configure it in the spring bean configuration file and then inject it to spring beans as dependencies. Then we can use it with JdbcTemplate to perform database operations.

Sample configuration would be:

<beans:bean id="dbDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">

    <beans:property name="jndiName" value="java:comp/env/jdbc/MyLocalDB"/>

</beans:bean>

For complete example, please refer Spring Tomcat JNDI Example.

Q: How would you achieve Transaction Management in Spring?

A: Spring framework provides transaction management support through Declarative Transaction Management as well as programmatic transaction management. Declarative transaction management is most widely used because it’s easy to use and works in most of the cases.

We use annotate a method with @Transactional annotation for Declarative transaction management. We need to configure transaction manager for the DataSource in the spring bean configuration file.

<bean id="transactionManager"

    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

    <property name="dataSource" ref="dataSource" />

</bean>

Q: What is Spring DAO?

A: Spring DAO support is provided to work with data access technologies like JDBC, Hibernate in a consistent and easy way. For example we have JdbcDaoSupport, HibernateDaoSupport, JdoDaoSupport and JpaDaoSupport for respective technologies.

Spring DAO also provides consistency in exception hierarchy and we don’t need to catch specific exceptions.

Q: How to integrate Spring and Hibernate Frameworks?

A: We can use Spring ORM module to integrate Spring and Hibernate frameworks, if you are using Hibernate 3+ where SessionFactory provides current session, then you should avoid using HibernateTemplate or HibernateDaoSupport classes and better to use DAO pattern with dependency injection for the integration.

Also Spring ORM provides support for using Spring declarative transaction management, so you should utilize that rather than going for hibernate boiler-plate code for transaction management.

For better understanding you should go through following tutorials:

Spring Hibernate Integration Example

Spring MVC Hibernate Integration Example

Q: What is Spring Security?

A: Spring security framework focuses on providing both authentication and authorization in java applications. It also takes care of most of the common security vulnerabilities such as CSRF attack.

It’s very beneficial and easy to use Spring security in web applications, through the use of annotations such as @EnableWebSecurity. You should go through following posts to learn how to use Spring Security framework.

Spring Security in Servlet Web Application

Spring MVC and Spring Security Integration Example

Q: How to inject a java.util.Properties into a Spring Bean?

A: We need to define propertyConfigurer bean that will load the properties from the given property file. Then we can use Spring EL support to inject properties into other bean dependencies. For example;

<bean id="propertyConfigurer"

  class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer">

    <property name="location" value="/WEB-INF/application.properties" />

</bean>

<bean class="com.journaldev.spring.EmployeeDaoImpl">

    <property name="maxReadResults" value="${results.read.max}"/>

</bean>

If you are using annotation to configure the spring bean, then you can inject property like below.

@Value("${maxReadResults}")

private int maxReadResults;

Q: Name some of the design patterns used in Spring Framework?

A: Spring Framework is using a lot of design patterns, some of the common ones are:

Singleton Pattern: Creating beans with default scope.

Factory Pattern: Bean Factory classes

Prototype Pattern: Bean scopes

Adapter Pattern: Spring Web and Spring MVC

Proxy Pattern: Spring Aspect Oriented Programming support

Template Method Pattern: JdbcTemplate, HibernateTemplate etc

Front Controller: Spring MVC DispatcherServlet

Data Access Object: Spring DAO support

Dependency Injection and Aspect Oriented Programming

Q: What are some of the best practices for Spring Framework?

A: Some of the best practices for Spring Framework are:

Avoid version numbers in schema reference, to make sure we have the latest configs.

Divide spring bean configurations based on their concerns such as spring-jdbc.xml, spring-security.xml.

For spring beans that are used in multiple contexts in Spring MVC, create them in the root context and initialize with listener.

Configure bean dependencies as much as possible, try to avoid autowiring as much as possible.

For application level properties, best approach is to create a property file and read it in the spring bean configuration file.

For smaller applications, annotations are useful but for larger applications annotations can become a pain. If we have all the configuration in xml files, maintaining it will be easier.

Use correct annotations for components for understanding the purpose easily. For services use @Service and for DAO beans use @Repository.

Spring framework has a lot of modules, use what you need. Remove all the extra dependencies that gets usually added when you create projects through Spring Tool Suite templates.

If you are using Aspects, make sure to keep the join pint as narrow as possible to avoid advice on unwanted methods. Consider custom annotations that are easier to use and avoid any issues.

Use dependency injection when there is actual benefit, just for the sake of loose-coupling don’t use it because it’s harder to maintain.

Q: What is IOC (or Dependency Injection)?

A: The basic concept of the Inversion of Control pattern (also known as dependency injection) is that you do not create your objects but describe how they should be created. You don't directly connect your components and services together in code but describe which services are needed by which components in a configuration file. A container (in the case of the Spring framework, the IOC container) is then responsible for hooking it all up.

i.e., Applying IoC, objects are given their dependencies at creation time by some external entity that coordinates each object in the system. That is, dependencies are injected into objects. So, IoC means an inversion of responsibility with regard to how an object obtains references to collaborating objects.

Q: What are the different types of IOC (dependency injection) ?

A: There are three types of dependency injection:

Constructor Injection (e.g. Pico container, Spring etc): Dependencies are provided as constructor parameters.

Setter Injection (e.g. Spring): Dependencies are assigned through JavaBeans properties (ex: setter methods).

Interface Injection (e.g. Avalon): Injection is done through an interface.

Note: Spring supports only Constructor and Setter Injection

Q: What are the benefits of IOC (Dependency Injection)?

A: Benefits of IOC (Dependency Injection) are as follows:

Minimizes the amount of code in your application. With IOC containers you do not care about how services are created and how you get references to the ones you need. You can also easily add additional services by adding a new constructor or a setter method with little or no extra configuration.

Make your application more testable by not requiring any singletons or JNDI lookup mechanisms in your unit test cases. IOC containers make unit testing and switching implementations very easy by manually allowing you to inject your own objects into the object under test.

Loose coupling is promoted with minimal effort and least intrusive mechanism. The factory design pattern is more intrusive because components or services need to be requested explicitly whereas in IOC the dependency is injected into requesting piece of code. Also some containers promote the design to interfaces not to implementations design concept by encouraging managed objects to implement a well-defined service interface of your own.

IOC containers support eager instantiation and lazy loading of services. Containers also provide support for instantiation of managed objects, cyclical dependencies, life cycles management, and dependency resolution between managed objects etc.

Q: What is Spring ?

A: Spring is an open source framework created to address the complexity of enterprise application development. One of the chief advantages of the Spring framework is its layered architecture, which allows you to be selective about which of its components you use while also providing a cohesive framework for J2EE application development.

Q: What are the advantages of Spring framework?

A: The advantages of Spring are as follows:

Spring has layered architecture. Use what you need and leave you don't need now.

Spring Enables POJO Programming. There is no behind the scene magic here. POJO programming enables continuous integration and testability.

Dependency Injection and Inversion of Control Simplifies JDBC

Open source and no vendor lock-in.

Q: What are features of Spring ?

A: Lightweight:

spring is lightweight when it comes to size and transparency. The basic version of spring framework is around 1MB. And the processing overhead is also very negligible.

Inversion of control (IOC):

Loose coupling is achieved in spring using the technique Inversion of Control. The objects give their dependencies instead of creating or looking for dependent objects.

Aspect oriented (AOP):

Spring supports Aspect oriented programming and enables cohesive development by separating application business logic from system services.

Container:

Spring contains and manages the life cycle and configuration of application objects.

MVC Framework:

Spring comes with MVC web application framework, built on core Spring functionality. This framework is highly configurable via strategy interfaces, and accommodates multiple view technologies like JSP, Velocity, Tiles, iText, and POI. But other frameworks can be easily used instead of Spring MVC Framework.

Transaction Management:

Spring framework provides a generic abstraction layer for transaction management. This allowing the developer to add the pluggable transaction managers, and making it easy to demarcate transactions without dealing with low-level issues. Spring's transaction support is not tied to J2EE environments and it can be also used in container less environments.

JDBC Exception Handling:

The JDBC abstraction layer of the Spring offers a meaningful exception hierarchy, which simplifies the error handling strategy. Integration with Hibernate, JDO, and iBATIS: Spring provides best Integration services with Hibernate, JDO and iBATIS

Q: How many modules are there in Spring? What are they?

A: Spring comprises of seven modules. They are..

The core container:

The core container provides the essential functionality of the Spring framework. A primary component of the core container is the BeanFactory, an implementation of the Factory pattern. The BeanFactory applies the Inversion of Control (IOC) pattern to separate an application's configuration and dependency specification from the actual application code.

Spring context:

The Spring context is a configuration file that provides context information to the Spring framework. The Spring context includes enterprise services such as JNDI, EJB, e-mail, internalization, validation, and scheduling functionality.

Spring AOP:

The Spring AOP module integrates aspect-oriented programming functionality directly into the Spring framework, through its configuration management feature. As a result you can easily AOP-enable any object managed by the Spring framework. The Spring AOP module provides transaction management services for objects in any Spring-based application. With Spring AOP you can incorporate declarative transaction management into your applications without relying on EJB components.

Spring DAO:

The Spring JDBC DAO abstraction layer offers a meaningful exception hierarchy for managing the exception handling and error messages thrown by different database vendors. The exception hierarchy simplifies error handling and greatly reduces the amount of exception code you need to write, such as opening and closing connections. Spring DAO's JDBC-oriented exceptions comply to its generic DAO exception hierarchy.

Spring ORM:

The Spring framework plugs into several ORM frameworks to provide its Object Relational tool, including JDO, Hibernate, and iBatis SQL Maps. All of these comply to Spring's generic transaction and DAO exception hierarchies.

Spring Web module:

The Web context module builds on top of the application context module, providing contexts for Web-based applications. As a result, the Spring framework supports integration with Jakarta Struts. The Web module also eases the tasks of handling multi-part requests and binding request parameters to domain objects.

Spring MVC framework:

The Model-View-Controller (MVC) framework is a full-featured MVC implementation for building Web applications. The MVC framework is highly configurable via strategy interfaces and accommodates numerous view technologies including JSP, Velocity, Tiles, iText, and POI.

Q: What are the types of Dependency Injection Spring supports?>

A: Setter Injection:

Setter-based DI is realized by calling setter methods on your beans after invoking a no-argument constructor or no-argument static factory method to instantiate your bean.

Constructor Injection:

Constructor-based DI is realized by invoking a constructor with a number of arguments, each representing a collaborator.

Q: What is Bean Factory ?

A: A BeanFactory is like a factory class that contains a collection of beans. The BeanFactory holds Bean Definitions of multiple beans within itself and then instantiates the bean whenever asked for by clients.

BeanFactory is able to create associations between collaborating objects as they are instantiated. This removes the burden of configuration from bean itself and the beans client.

BeanFactory also takes part in the life cycle of a bean, making calls to custom initialization and destruction methods.

Q: What is Application Context?

A: A bean factory is fine to simple applications, but to take advantage of the full power of the Spring framework, you may want to move up to Springs more advanced container, the application context. On the surface, an application context is same as a bean factory.Both load bean definitions, wire beans together, and dispense beans upon request. But it also provides:

A means for resolving text messages, including support for internationalization.

A generic way to load file resources.

Events to beans that are registered as listeners.

Q: What is the difference between Bean Factory and Application Context ? 

A: On the surface, an application context is same as a bean factory. But application context offers much more..

Application contexts provide a means for resolving text messages, including support for i18n of those messages.

Application contexts provide a generic way to load file resources, such as images.

Application contexts can publish events to beans that are registered as listeners.

Certain operations on the container or beans in the container, which have to be handled in a programmatic fashion with a bean factory, can be handled declaratively in an application context.

ResourceLoader support: Spring’s Resource interface us a flexible generic abstraction for handling low-level resources. An application context itself is a ResourceLoader, Hence provides an application with access to deployment-specific Resource instances.

MessageSource support: The application context implements MessageSource, an interface used to obtain localized messages, with the actual implementation being pluggable

Spring overview

Q: What is Spring?

A: Spring is an open source development framework for Enterprise Java. The core features of the Spring Framework can be used in developing any Java application, but there are extensions for building web applications on top of the Java EE platform. Spring framework targets to make Java EE development easier to use and promote good programming practice by enabling a POJO-based programming model.

Q: What are benefits of Spring Framework?

A: Lightweight: Spring is lightweight when it comes to size and transparency. The basic version of spring framework is around 2MB.

Inversion of control (IOC): Loose coupling is achieved in Spring, with the Inversion of Control technique. The objects give their dependencies instead of creating or looking for dependent objects.

Aspect oriented (AOP): Spring supports Aspect oriented programming and separates application business logic from system services.

Container: Spring contains and manages the life cycle and configuration of application objects.

MVC Framework: Spring’s web framework is a well-designed web MVC framework, which provides a great alternative to web frameworks.

Transaction Management: Spring provides a consistent transaction management interface that can scale down to a local transaction and scale up to global transactions (JTA).

Exception Handling: Spring provides a convenient API to translate technology-specific exceptions (thrown by JDBC, Hibernate, or JDO) into consistent, unchecked exceptions.

Q: Which are the Spring framework modules?

A: The basic modules of the Spring framework are :

Core module

Bean module

Context module

Expression Language module

JDBC module

ORM module

OXM module

Java Messaging Service(JMS) module

Transaction module

Web module

Web-Servlet module

Web-Struts module

Web-Portlet module

Q: Explain the Core Container (Application context) module?

A: This is the basic Spring module, which provides the fundamental functionality of the Spring framework. BeanFactory is the heart of any spring-based application. Spring framework was built on the top of this module, which makes the Spring container.

Q: BeanFactory – BeanFactory implementation example.

A: A BeanFactory is an implementation of the factory pattern that applies Inversion of Control to separate the application’s configuration and dependencies from the actual application code.

The most commonly used BeanFactory implementation is the XmlBeanFactory class.

Q: XMLBeanFactory.

A: The most useful one is org.springframework.beans.factory.xml.XmlBeanFactory, which loads its beans based on the definitions contained in an XML file. This container reads the configuration metadata from an XML file and uses it to create a fully configured system or application.

Q: Explain the AOP module.

A: The AOP module is used for developing aspects for our Spring-enabled application. Much of the support has been provided by the AOP Alliance in order to ensure the interoperability between Spring and other AOP frameworks. This module also introduces metadata programming to Spring.

Q: Explain the JDBC abstraction and DAO module.

A: With the JDBC abstraction and DAO module we can be sure that we keep up the database code clean and simple, and prevent problems that result from a failure to close database resources. It provides a layer of meaningful exceptions on top of the error messages given by several database servers. It also makes use of Spring’s AOP module to provide transaction management services for objects in a Spring application.

Q: Explain the object/relational mapping integration module.

A: Spring also supports for using of an object/relational mapping (ORM) tool over straight JDBC by providing the ORM module. Spring provides support to tie into several popular ORM frameworks, including Hibernate, JDO, and iBATIS SQL Maps. Spring’s transaction management supports each of these ORM frameworks as well as JDBC.

Q: Explain the web module.

A: The Spring web module is built on the application context module, providing a context that is appropriate for web-based applications. This module also contains support for several web-oriented tasks such as transparently handling multipart requests for file uploads and programmatic binding of request parameters to your business objects. It also contains integration support with Jakarta Struts.

Q: Explain the Spring MVC module.

A: MVC framework is provided by Spring for building web applications. Spring can easily be integrated with other MVC frameworks, but Spring’s MVC framework is a better choice, since it uses IoC to provide for a clean separation of controller logic from business objects. With Spring MVC you can declaratively bind request parameters to your business objects.

Q: Spring configuration file

A: Spring configuration file is an XML file. This file contains the classes information and describes how these classes are configured and introduced to each other.

Q: What is Spring IoC container?

A: The Spring IoC is responsible for creating the objects,managing them (with dependency injection (DI)), wiring them together, configuring them, as also managing their complete lifecycle.

Q: What are the benefits of IOC?

A: IOC or dependency injection minimizes the amount of code in an application. It makes easy to test applications, since no singletons or JNDI lookup mechanisms are required in unit tests. Loose coupling is promoted with minimal effort and least intrusive mechanism. IOC containers support eager instantiation and lazy loading of services.

Q: What are the common implementations of the ApplicationContext?

A: The FileSystemXmlApplicationContext container loads the definitions of the beans from an XML file. The full path of the XML bean configuration file must be provided to the constructor.

The ClassPathXmlApplicationContext container also loads the definitions of the beans from an XML file. Here, you need to set CLASSPATH properly because this container will look bean configuration XML file in CLASSPATH.

The WebXmlApplicationContext: container loads the XML file with definitions of all beans from within a web application.

Q: What is the difference between Bean Factory and ApplicationContext?

A: Application contexts provide a means for resolving text messages, a generic way to load file resources (such as images), they can publish events to beans that are registered as listeners. In addition, operations on the container or beans in the container, which have to be handled in a programmatic fashion with a bean factory, can be handled declaratively in an application context. The application context implements MessageSource, an interface used to obtain localized messages, with the actual implementation being pluggable.

Q: What does a Spring application look like?

A: An interface that defines the functions.

The implementation that contains properties, its setter and getter methods, functions etc.,

Spring AOP

The Spring configuration XML file.

Client program that uses the function

Dependency Injection

Q: What is Dependency Injection in Spring?

A: Dependency Injection, an aspect of Inversion of Control (IoC), is a general concept, and it can be expressed in many different ways.This concept says that you do not create your objects but describe how they should be created. You don’t directly connect your components and services together in code but describe which services are needed by which components in a configuration file. A container (the IOC container) is then responsible for hooking it all up.

Q: What are the different types of IoC (dependency injection)?

A: Constructor-based dependency injection: Constructor-based DI is accomplished when the container invokes a class constructor with a number of arguments, each representing a dependency on other class.

Setter-based dependency injection: Setter-based DI is accomplished by the container calling setter methods on your beans after invoking a no-argument constructor or no-argument static factory method to instantiate your bean.

Q: Which DI would you suggest Constructor-based or setter-based DI?

A: You can use both Constructor-based and Setter-based Dependency Injection. The best solution is using constructor arguments for mandatory dependencies and setters for optional dependencies.

Spring Beans

Q: What are Spring beans?

A: The Spring Beans are Java Objects that form the backbone of a Spring application. They are instantiated, assembled, and managed by the Spring IoC container. These beans are created with the configuration metadata that is supplied to the container, for example, in the form of XML <bean/> definitions.

Beans defined in spring framework are singleton beans. There is an attribute in bean tag named "singleton" if specified true then bean becomes singleton and if set to false then the bean becomes a prototype bean. By default it is set to true. So, all the beans in spring framework are by default singleton beans.

Q: What does a Spring Bean definition contain?

A: A Spring Bean definition contains all configuration metadata which is needed for the container to know how to create a bean, its lifecycle details and its dependencies.

Q: How do you provide configuration metadata to the Spring Container?

A: There are three important methods to provide configuration metadata to the Spring Container:

XML based configuration file.

Annotation-based configuration

Java-based configuration

Q: How do you define the scope of a bean?

A: When defining a <bean> in Spring, we can also declare a scope for the bean. It can be defined through the scope attribute in the bean definition. For example, when Spring has to produce a new bean instance each time one is needed, the bean’s scope attribute to be prototype. On the other hand, when the same instance of a bean must be returned by Spring every time it is needed, the the bean scope attribute must be set to singleton.

Q: Explain the bean scopes supported by Spring

A: There are five scoped provided by the Spring Framework supports following five scopes:

In singleton scope, Spring scopes the bean definition to a single instance per Spring IoC container.

In prototype scope, a single bean definition has any number of object instances.

In request scope, a bean is defined to an HTTP request. This scope is valid only in a web-aware Spring ApplicationContext.

In session scope, a bean definition is scoped to an HTTP session. This scope is also valid only in a web-aware Spring ApplicationContext.

In global-session scope, a bean definition is scoped to a global HTTP session. This is also a case used in a web-aware Spring ApplicationContext.

The default scope of a Spring Bean is Singleton.

Q: Are Singleton beans thread safe in Spring Framework?

A: No, singleton beans are not thread-safe in Spring framework.

Q: Explain Bean lifecycle in Spring framework

A: The spring container finds the bean’s definition from the XML file and instantiates the bean.

Spring populates all of the properties as specified in the bean definition (DI).

If the bean implements BeanNameAware interface, spring passes the bean’s id to setBeanName() method.

If Bean implements BeanFactoryAware interface, spring passes the beanfactory to setBeanFactory() method.

If there are any bean BeanPostProcessors associated with the bean, Spring calls postProcesserBeforeInitialization() method.

If the bean implements IntializingBean, its afterPropertySet() method is called. If the bean has init method declaration, the specified initialization method is called.

If there are any BeanPostProcessors associated with the bean, their postProcessAfterInitialization() methods will be called.

If the bean implements DisposableBean, it will call the destroy() method.

Q: Which are the important beans lifecycle methods? Can you override them?

A: There are two important bean lifecycle methods. The first one is setup which is called when the bean is loaded in to the container. The second method is the teardown method which is called when the bean is unloaded from the container.

The bean tag has two important attributes (init-method and destroy-method) with which you can define your own custom initialization and destroy methods. There are also the correspondive annotations(@PostConstruct and @PreDestroy).

Q: What are inner beans in Spring?

A: When a bean is only used as a property of another bean it can be declared as an inner bean. Spring’s XML-based configuration metadata provides the use of <bean/> element inside the <property/> or <constructor-arg/> elements of a bean definition, in order to define the so-called inner bean. Inner beans are always anonymous and they are always scoped as prototypes.

Q: How can you inject a Java Collection in Spring?

A: Spring offers the following types of collection configuration elements:

The <list> type is used for injecting a list of values, in the case that duplicates are allowed.

The <set> type is used for wiring a set of values but without any duplicates.

The <map> type is used to inject a collection of name-value pairs where name and value can be of any type.

The <props> type can be used to inject a collection of name-value pairs where the name and value are both Strings.

Q: What is bean wiring?

A: Wiring, or else bean wiring is the case when beans are combined together within the Spring container. When wiring beans, the Spring container needs to know what beans are needed and how the container should use dependency injection to tie them together.

Q: What is bean auto wiring?

A: The Spring container is able to autowire relationships between collaborating beans. This means that it is possible to automatically let Spring resolve collaborators (other beans) for a bean by inspecting the contents of the BeanFactory without using <constructor-arg> and <property> elements.

Q: Explain different modes of auto wiring?

A: The autowiring functionality has five modes which can be used to instruct Spring container to use autowiring for dependency injection:

no: This is default setting. Explicit bean reference should be used for wiring.

byName: When autowiring byName, the Spring container looks at the properties of the beans on which autowire attribute is set to byName in the XML configuration file. It then tries to match and wire its properties with the beans defined by the same names in the configuration file.

byType: When autowiring by datatype, the Spring container looks at the properties of the beans on which autowire attribute is set to byType in the XML configuration file. It then tries to match and wire a property if its type matches with exactly one of the beans name in configuration file. If more than one such beans exist, a fatal exception is thrown.

constructor: This mode is similar to byType, but type applies to constructor arguments. If there is not exactly one bean of the constructor argument type in the container, a fatal error is raised.

autodetect: Spring first tries to wire using autowire by constructor, if it does not work, Spring tries to autowire by byType.

Q: Are there limitations with autowiring?

A: Limitations of autowiring are:

Overriding: You can still specify dependencies using <constructor-arg> and <property> settings which will always override autowiring.

Primitive data types: You cannot autowire simple properties such as primitives, Strings, and Classes.

Confusing nature: Autowiring is less exact than explicit wiring, so if possible prefer using explicit wiring.

Q: Can you inject null and empty string values in Spring?

A: Yes, you can.

Spring Annotations

Q: What is Spring Java-Based Configuration? Give some annotation example.

A: Java based configuration option enables you to write most of your Spring configuration without XML but with the help of few Java-based annotations.

An example is the @Configuration annotation, that indicates that the class can be used by the Spring IoC container as a source of bean definitions. Another example is the@Bean annotated method that will return an object that should be registered as a bean in the Spring application context.

Q: What is Annotation-based container configuration?

A: An alternative to XML setups is provided by annotation-based configuration which relies on the bytecode metadata for wiring up components instead of angle-bracket declarations. Instead of using XML to describe a bean wiring, the developer moves the configuration into the component class itself by using annotations on the relevant class, method, or field declaration.

Q: How do you turn on annotation wiring?

A: Annotation wiring is not turned on in the Spring container by default. In order to use annotation based wiring we must enable it in our Spring configuration file by configuring <context:annotation-config/> element.

Q: @Required annotation

A: This annotation simply indicates that the affected bean property must be populated at configuration time, through an explicit property value in a bean definition or through autowiring. The container throws BeanInitializationException if the affected bean property has not been populated.

Q: @Autowired annotation

A: The @Autowired annotation provides more fine-grained control over where and how autowiring should be accomplished. It can be used to autowire bean on the setter method just like @Required annotation, on the constructor, on a property or pn methods with arbitrary names and/or multiple arguments.

Q: @Qualifier annotation

A: When there are more than one beans of the same type and only one is needed to be wired with a property, the @Qualifier annotation is used along with @Autowired annotation to remove the confusion by specifying which exact bean will be wired.

Spring Data Access

Q: How can JDBC be used more efficiently in the Spring framework?

A: When using the Spring JDBC framework the burden of resource management and error handling is reduced. So developers only need to write the statements and queries to get the data to and from the database. JDBC can be used more efficiently with the help of a template class provided by Spring framework, which is the JdbcTemplate (example here).

Q: JdbcTemplate

A: JdbcTemplate class provides many convenience methods for doing things such as converting database data into primitives or objects, executing prepared and callable statements, and providing custom database error handling.

Q: Spring DAO support

A: The Data Access Object (DAO) support in Spring is aimed at making it easy to work with data access technologies like JDBC, Hibernate or JDO in a consistent way. This allows us to switch between the persistence technologies fairly easily and to code without worrying about catching exceptions that are specific to each technology.

Q: What are the ways to access Hibernate by using Spring?

A: There are two ways to access Hibernate with Spring:

Inversion of Control with a Hibernate Template and Callback.

Extending HibernateDAOSupport and Applying an AOP Interceptor node.

Q: ORM’s Spring support

A: Spring supports the following ORM’s:

Hibernate

iBatis

JPA (Java Persistence API)

TopLink

JDO (Java Data Objects)

OJB

Q: How can we integrate Spring and Hibernate using HibernateDaoSupport?

A: Use Spring’s SessionFactory called LocalSessionFactory. The integration process is of 3 steps:

Configure the Hibernate SessionFactory

Extend a DAO Implementation from HibernateDaoSupport

Wire in Transaction Support with AOP

Q: Types of the transaction management Spring support

A: Spring supports two types of transaction management:

Programmatic transaction management: This means that you have managed the transaction with the help of programming. That gives you extreme flexibility, but it is difficult to maintain.

Declarative transaction management: This means you separate transaction management from the business code. You only use annotations or XML based configuration to manage the transactions.

Q: What are the benefits of the Spring Framework’s transaction management?

A: It provides a consistent programming model across different transaction APIs such as JTA, JDBC, Hibernate, JPA, and JDO.

It provides a simpler API for programmatic transaction management than a number of complex transaction APIs such as JTA.

It supports declarative transaction management.

It integrates very well with Spring’s various data access abstractions.

Q: Which Transaction management type is more preferable?

A: Most users of the Spring Framework choose declarative transaction management because it is the option with the least impact on application code, and hence is most consistent with the ideals of a non-invasive lightweight container. Declarative transaction management is preferable over programmatic transaction management though it is less flexible than programmatic transaction management, which allows you to control transactions through your code.

Spring Aspect Oriented Programming (AOP)

Q: Explain AOP

A: Aspect-oriented programming, or AOP, is a programming technique that allows programmers to modularize crosscutting concerns, or behavior that cuts across the typical divisions of responsibility, such as logging and transaction management.

Q: Aspect

A: The core construct of AOP is the aspect, which encapsulates behaviors affecting multiple classes into reusable modules. It ia a module which has a set of APIs providing cross-cutting requirements. For example, a logging module would be called AOP aspect for logging. An application can have any number of aspects depending on the requirement. In Spring AOP, aspects are implemented using regular classes annotated with the @Aspect annotation (@AspectJ style).

Q: What is the difference between concern and cross-cutting concern in Spring AOP.

A: The Concern is behavior we want to have in a module of an application. A Concern may be defined as a functionality we want to implement.

The cross-cutting concern is a concern which is applicable throughout the application and it affects the entire application. For example, logging, security and data transfer are the concerns which are needed in almost every module of an application, hence they are cross-cutting concerns.

Q: Join point

A: The join point represents a point in an application where we can plug-in an AOP aspect. It is the actual place in the application where an action will be taken using Spring AOP framework.

Q: Advice

A: The advice is the actual action that will be taken either before or after the method execution. This is actual piece of code that is invoked during the program execution by the Spring AOP framework.

Spring aspects can work with five kinds of advice:

before: Run advice before the a method execution.

after: Run advice after the a method execution regardless of its outcome.

after-returning: Run advice after the a method execution only if method completes successfully.

after-throwing: Run advice after the a method execution only if method exits by throwing an exception.

around: Run advice before and after the advised method is invoked.

Q: Pointcut

A: The pointcut is a set of one or more joinpoints where an advice should be executed. You can specify pointcuts using expressions or patterns.

Q: What is Introduction?

A: An Introduction allows us to add new methods or attributes to existing classes.

Q: What is Target object?

A: The target object is an object being advised by one or more aspects. It will always be a proxy object. It is also referred to as the advised object.

Q: What is a Proxy?

A: A proxy is an object that is created after applying advice to a target object. When you think of client objects the target object and the proxy object are the same.

Q: What are the different types of AutoProxying?

A: BeanNameAutoProxyCreator

DefaultAdvisorAutoProxyCreator

Metadata autoproxying

Q: What is Weaving? What are the different points where weaving can be applied?

A: Weaving is the process of linking aspects with other application types or objects to create an advised object.

Weaving can be done at compile time, at load time, or at runtime.

Q: Explain XML Schema-based aspect implementation?

A: In this implementation case, aspects are implemented using regular classes along with XML based configuration.

Q: Explain annotation-based (@AspectJ based) aspect implementation

A: This implementation case (@AspectJ based implementation) refers to a style of declaring aspects as regular Java classes annotated with Java 5 annotations.

Spring Model View Controller (MVC)

Q: What is Spring MVC framework?

A: Spring comes with a full-featured MVC framework for building web applications. Although Spring can easily be integrated with other MVC frameworks, such as Struts, Spring’s MVC framework uses IoC to provide a clean separation of controller logic from business objects. It also allows to declaratively bind request parameters to business objects.

Q: DispatcherServlet

A: The Spring Web MVC framework is designed around a DispatcherServlet that handles all the HTTP requests and responses.

Q: WebApplicationContext

A: The WebApplicationContext is an extension of the plain ApplicationContext that has some extra features necessary for web applications. It differs from a normal ApplicationContext in that it is capable of resolving themes, and that it knows which servlet it is associated with.

Q: What is Controller in Spring MVC framework?

A: Controllers provide access to the application behavior that you typically define through a service interface. Controllers interpret user input and transform it into a model that is represented to the user by the view. Spring implements a controller in a very abstract way, which enables you to create a wide variety of controllers.

Q: @Controller annotation

A: The @Controller annotation indicates that a particular class serves the role of a controller. Spring does not require you to extend any controller base class or reference the Servlet API.

Q: @RequestMapping annotation

A: @RequestMapping annotation is used to map a URL to either an entire class or a particular handler method.

Q: What is IOC or inversion of control?

A: This Spring interview question is first step towards Spring framework and many interviewer starts Spring interview from this question. As the name implies Inversion of control means now we have inverted the control of creating the object from our own using new operator to container or framework. Now it’s the responsibility of container to create object as required. We maintain one xml file where we configure our components, services, all the classes and their property. We just need to mention which service is needed by which component and container will create the object for us. This concept is known as dependency injection because all object dependency (resources) is injected into it by framework.

Example:

  <bean id="createNewStock" class="springexample.stockMarket.CreateNewStockAccont">

        <property name="newBid"/>

  </bean>

In this example CreateNewStockAccont class contain getter and setter for newBid and container will instantiate newBid and set the value automatically when it is used. This whole process is also called wiring in Spring and by using annotation it can be done automatically by Spring, refereed as auto-wiring of bean in Spring.

Q: Explain Bean-LifeCycle.

A: Spring framework is based on IOC so we call it as IOC container also So Spring beans reside inside the IOC container. Spring beans are nothing but Plain old java object (POJO).

Following steps explain their life cycle inside container.

1. Container will look the bean definition inside configuration file (e.g. bean.xml).

2 using reflection container will create the object and if any property is defined inside the bean definition then it will also be set.

3. If the bean implements the BeanNameAware interface, the factory calls setBeanName() passing the bean’s ID.

4. If the bean implements the BeanFactoryAware interface, the factory calls setBeanFactory(), passing an instance of itself.

5. If there are any BeanPostProcessors associated with the bean, their post- ProcessBeforeInitialization() methods will be called before the properties for the Bean are set.

6. If an init() method is specified for the bean, it will be called.

7. If the Bean class implements the DisposableBean interface, then the method destroy() will be called when the Application no longer needs the bean reference.

8. If the Bean definition in the Configuration file contains a 'destroy-method' attribute, then the corresponding method definition in the Bean class will be called.

Q: What is Bean Factory, have you used XMLBeanFactory?

A: BeanFactory is factory Pattern which is based on IOC design principles.it is used to make a clear separation between application configuration and dependency from actual code.

XmlBeanFactory is one of the implementation of bean Factory which we have used in our project.

org.springframework.beans.factory.xml.XmlBeanFactory is used to create bean instance defined in our xml file.

BeanFactory factory = new XmlBeanFactory(new FileInputStream("beans.xml"));

Or

ClassPathResource resorce = new ClassPathResource("beans.xml");

XmlBeanFactory factory = new XmlBeanFactory(resorce);

Q: What are the difference between BeanFactory and ApplicationContext in spring?

A: This one is very popular spring interview question and often asks in entry level interview. ApplicationContext is preferred way of using spring because of functionality provided by it and interviewer wanted to check whether you are familiar with it or not.

ApplicationContext.

BeanFactory

Here we can have more than one config files possible

In this only one config file or .xml file

Application contexts can publish events to beans that are registered as listeners

Doesn’t support.

Support internationalization (I18N) messages

It’s not

Support application life-cycle events, and validation.

Doesn’t support.

Support  many enterprise services such JNDI access, EJB integration, remoting

Doesn’t support.

Q: What are different modules in spring?

A: spring have seven core modules

1.      The Core container module

2.      Application context module

3.      AOP module (Aspect Oriented Programming)

4.      JDBC abstraction and DAO module

5.      O/R mapping integration module (Object/Relational)

6.      Web module

7.      MVC framework module

Q: What is difference between singleton and prototype bean?

A: This is another popular spring interview questions and an important concept to understand. Basically a bean has scopes which defines their existence on the application

Singleton: means single bean definition to a single object instance per Spring IOC container.

Prototype: means a single bean definition to any number of object instances.

Whatever beans we defined in spring framework are singleton beans. There is an attribute in bean tag named ‘singleton’ if specified true then bean becomes singleton and if set to false then the bean becomes a prototype bean. By default it is set to true. So, all the beans in spring framework are by default singleton beans.

  <bean id="createNewStock"     class="springexample.stockMarket.CreateNewStockAccont" singleton=”false”>

        <property name="newBid"/>

  </bean>

Q: What type of transaction Management Spring support?

A: This spring interview questions is little difficult as compared to previous questions just because transaction management is a complex concept and not every developer familiar with it. Transaction management is critical in any applications that will interact with the database. The application has to ensure that the data is consistent and the integrity of the data is maintained.  Two type of transaction management is supported by spring

1. Programmatic transaction management

2. Declarative transaction management.

Q: What is AOP?

A: The core construct of AOP is the aspect, which encapsulates behaviors affecting multiple classes into reusable modules. AOP is a programming technique that allows developer to modularize crosscutting concerns,  that cuts across the typical divisions of responsibility, such as logging and transaction management. Spring AOP, aspects are implemented using regular classes or regular classes annotated with the @Aspect annotation

Q: Explain Advice?

A: It’s an implementation of aspect; advice is inserted into an application at join points. Different types of advice include “around,” “before” and “after” advice

Q: What is joint Point and point cut?

A: This is not really a spring interview questions I would say an AOP one.  Similar to Object oriented programming, AOP is another popular programming concept which complements OOPS. Join point is an opportunity within code for which we can apply an aspect. In Spring AOP, a join point always represents a method execution.

Pointcut: a predicate that matches join points. A point cut is something that defines at what join-points an advice should be applied

Q: How will provide LDAP authentication using Spring?

A: LDAP authentication is one of the most popular authentication mechanism around the world for enterprise application and Active directory (an LDAP implementation by Microsoft for Windows) is another widely used ldap server. In many project we need to authenticate against active directory using ldap by credentials provided in login screen. Some time this simple task gets tricky because of various issues faced during implementation and integration and no standard way of doing ldap authentication. Java provides ldap support but in this article I will mostly talk about spring security because its my preferred Java framework for authentication, authorization and security related stuff. you can do same thing in Java by writing your own program for doing LDAP search and than LDAP bind but as I said its much easier and cleaner when you use spring security for LDAP authentication.

Along with LDAP Support, Spring Security also provides several other feature which is required by enterprise java application including SSL Security, encryption of passwords and session timeout facilities.

LDAP Authentication Basics

Before getting deep into LDAP authentication on Active Directory, let's get familiar with some LDAP term because most of the time user is doing it first time and they are not very familiar with typical LDAP glossary such as Dn , Ou , Bind or search etc.

Dn - Distinguished name, a unique name which is used to find user in LDAP server e.g. Microsoft Active Directory.

Ou - Organization Unit

Bind - LDAP Bind is an operation in which ldap clients sends bindRequest to ldap user including username and password and if LDAP server able to find user and password correct, it allows access to ldap server.

Search - LDAP search is an operation which is performed to retrieve Dn of user by using some user credential.

Root - LDAP directory's top element, like Root of a tree.

BaseDn - a branch in LDAP tree which can be used as base for ldap search operation e.g. dc=Microsoft,dc=org"

If you want to know more about LDAP check this link it has detailed information on LDAP.

LDAP Authentication Active Directory Spring

Active Directory Authentication in Spring Security

ldap authentication active directory spring

There are two ways to implement active directory authentication using LDAP protocol in spring security, first way is programmatic and declarative way which requires some coding and some configuration and second way is an out of box solution from spring security which just require to configure ActireDirectoryAuthentication provider and you are done. we will see both approach but I suggest using second one because of its simplicity and easy to use feature.

Active Directory Authentication using LDAP in Spring Security -1

Configuration

Add following configuration into your spring application-context.xml file, I would suggest to put this configuration in a separate application-context-security.xml file along with other security related stuff.

1) Configuring LDAP Server

<s:ldap-server url="ldap://stockmarket.com"   //ldap url

port="389"                              //ldap port

manager-dn="serviceAcctount@sotckmarket.com" //manager username

manager-password="AD83DgsSe"/>             //manager password

This configuration is self explanatory but briefly few lines about manager-dn and password, Ldap authentication on active directory or any other ldap directory is performed in two steps first an LDAP search is performed to locate Dn(Distinguised Name) of user and than this Dn is used to perform LDAP Bind , if bind is successful than usre authentication is successful other wise it fails. Some people prefer remote compare of password  than LDAP bind, but LDAP bind is what you mostly end of doing. most of Active directory doesn't allow Anonymous Search operation , so to perform an ldap search your service must have an LDAP account which is what we have provided here in manager-dn and manager-password.

In Summary now LDAP login will be done on these step

1) Your Service or application bind itself with LDAP using manager-dn and manager-password.

2) LDAP search for user to find UserDn

3) LDAP bind using UserDn

2) Configuring LDAP Authentication Provider

<s:authentication-manager erase-credentials="true">

<s:ldap-authentication-provider

user-search-base="dc=stockmarketindia,dc=trader"

user-search-filter="userPrincipalName={0}"

/>

<s:authentication-provider ref="springOutOfBoxActiveDirecotryAuthenticationProvider"/>

</s:authentication-manager>

Second approach is much simpler and cleaner because it comes out of box , you just need to configure ldap server url and domain name and it will work like cream.

<s:authentication-manager erase-credentials="true">

<s:authentication-provider ref="ldapActiveDirectoryAuthProvider"/>

</s:authentication-manager>

<bean id="ldapActiveDirectoryAuthProvider" class="org.springframework.security.ldap.authentication.ad.ActiveDirectoryLdapAuthenticationProvider">

<constructor-arg value="stockmarket.com" />  //your domain

<constructor-arg value="ldap://stockmarket.com/" />  //ldap url

</bean>

Dependency

This example is based on spring security 3.0 and I was using spring-ldap-1.3.1.RELEASE-all.jar and spring-security-ldap-3.1.0.RC3.jar

Ldap Active directory Authentication over SSL

This works perfectly to implement ldap authentication against microsoft active directory. but one thing you might want to put attention is that with ldap username and password travel to ldap server as clear text and anyone who has access to ldap traffic can sniff user credential so its not safe. one solution is to use ldaps( LDAP over ssl) protocol which will encrypt the traffic travels between ldap client and server. this is easy to do in spring-security what you need to change is the url instead of "ldap://stockmarket.com/" you need ot use ""ldaps://stockmarket.com/". actually port for ldap is 339 and for ldaps is 636 but that's been taken care by spring in second approach, in first approach you need to provide this information.

AOP

@AspectJ refers to a style of declaring aspects as regular Java classes annotated with Java 5 annotations. The @AspectJ support is enabled by including the following element inside your XML Schema-based configuration file.

<aop:aspectj-autoproxy/>

You will also need following AspectJ libraries on the classpath of your application. These libraries are available in the 'lib' directory of an AspectJ installation, otherwise you can download them from the internet.

• aspectjrt.jar
• aspectjweaver.jar
• aspectj.jar

Declaring an aspect

Aspects classes are like any other normal bean and may have methods and fields just like any other class, except that they will be annotated with @Aspect as follows:

package org.xyz;

import org.aspectj.lang.annotation.Aspect;

@Aspect

public class AspectModule {

}

They will be configured in XML like any other bean as follows:

<bean id="myAspect" class="org.xyz.AspectModule">

   <!-- configure properties of aspect here as normal -->

</bean>

Declaring a pointcut

A pointcut helps in determining the join points (ie methods) of interest to be executed with different advices. While working with @AspectJ based configuration, pointcut declaration has two parts:

A pointcut expression that determines exactly which method executions we are interested in.

A pointcut signature comprising a name and any number of parameters. The actual body of the method is irrelevant and in fact should be empty.

The following example defines a pointcut named 'businessService' that will match the execution of every method available in the classes under the package com.xyz.myapp.service:

import org.aspectj.lang.annotation.Pointcut;

@Pointcut("execution(* com.xyz.myapp.service.*.*(..))") // expression

private void businessService() {}  // signature

The following example defines a pointcut named 'getname' that will match the execution of getName() method available in Student class under the package com.tutorialspoint:

import org.aspectj.lang.annotation.Pointcut;

@Pointcut("execution(* com.tutorialspoint.Student.getName(..))")

private void getname() {}

Declaring advices

You can declare any of the five advices using @{ADVICE-NAME} annotations as given below. This assumes that you already have defined a pointcut signature method businessService():

@Before("businessService()")

public void doBeforeTask(){

 ...

}

@After("businessService()")

public void doAfterTask(){

 ...

}

@AfterReturning(pointcut = "businessService()", returning="retVal")

public void doAfterReturnningTask(Object retVal){

  // you can intercept retVal here.

  ...

}

@AfterThrowing(pointcut = "businessService()", throwing="ex")

public void doAfterThrowingTask(Exception ex){

  // you can intercept thrown exception here.

  ...

}

@Around("businessService()")

public void doAroundTask(){

 ...

}

You can define you pointcut inline for any of the advices. Below is an example to define inline pointcut for before advice:

@Before("execution(* com.xyz.myapp.service.*.*(..))")

public doBeforeTask(){

 ...

}

@AspectJ Based AOP Example

To understand above mentioned concepts related to @AspectJ based AOP, let us write an example which will implement few of the advices. To write our example with few advices, let us have working Eclipse IDE in place and follow the following steps to create a Spring application:

Step	Description
1	Create a project with a name SpringExample and create a package com.tutorialspoint under the src folder in the created project.
2	Add required Spring libraries using Add External JARs option as explained in the Spring Hello World Example chapter.
3	Add Spring AOP specific libraries aspectjrt.jar, aspectjweaver.jar and aspectj.jar in the project.
4	Create Java classes Logging, Student and MainApp under the com.tutorialspoint package.
5	Create Beans configuration file Beans.xml under the src folder.
6	The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below.

Here is the content of Logging.java file. This is actually a sample of aspect module which defines methods to be called at various points.

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Pointcut;

import org.aspectj.lang.annotation.Before;

import org.aspectj.lang.annotation.After;

import org.aspectj.lang.annotation.AfterThrowing;

import org.aspectj.lang.annotation.AfterReturning;

import org.aspectj.lang.annotation.Around;

@Aspect

public class Logging {

   /** Following is the definition for a pointcut to select

    *  all the methods available. So advice will be called

    *  for all the methods.

    */

   @Pointcut("execution(* com.tutorialspoint.*.*(..))")

   private void selectAll(){}

   /**

    * This is the method which I would like to execute

    * before a selected method execution.

    */

   @Before("selectAll()")

   public void beforeAdvice(){

      System.out.println("Going to setup student profile.");

   }

   /**

    * This is the method which I would like to execute

    * after a selected method execution.

    */

   @After("selectAll()")

   public void afterAdvice(){

      System.out.println("Student profile has been setup.");

   }

   /**

    * This is the method which I would like to execute

    * when any method returns.

    */

   @AfterReturning(pointcut = "selectAll()", returning="retVal")

   public void afterReturningAdvice(Object retVal){

      System.out.println("Returning:" + retVal.toString() );

   }

   /**

    * This is the method which I would like to execute

    * if there is an exception raised by any method.

    */

   @AfterThrowing(pointcut = "selectAll()", throwing = "ex")

   public void AfterThrowingAdvice(IllegalArgumentException ex){

      System.out.println("There has been an exception: " + ex.toString());   

   }

  

}

Following is the content of the Student.java file:

package com.tutorialspoint;

public class Student {

   private Integer age;

   private String name;

   public void setAge(Integer age) {

      this.age = age;

   }

   public Integer getAge() {

          System.out.println("Age : " + age );

      return age;

   }

   public void setName(String name) {

      this.name = name;

   }

   public String getName() {

      System.out.println("Name : " + name );

      return name;

   }

   public void printThrowException(){

      System.out.println("Exception raised");

      throw new IllegalArgumentException();

   }

}

Following is the content of the MainApp.java file:

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {

   public static void main(String[] args) {

      ApplicationContext context =

             new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getName();

      student.getAge();

     

      student.printThrowException();

   }

}

Following is the configuration file Beans.xml:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

    http://www.springframework.org/schema/aop

    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

    <aop:aspectj-autoproxy/>

   <!-- Definition for student bean -->

   <bean id="student" class="com.tutorialspoint.Student">

      <property name="name"  value="Zara" />

      <property name="age"  value="11"/>     

   </bean>

   <!-- Definition for logging aspect -->

   <bean id="logging" class="com.tutorialspoint.Logging"/>

     

</beans>

Once you are done with creating source and bean configuration files, let us run the application. If everything is fine with your application, this will print the following message:

Going to setup student profile.

Name : Zara

Student profile has been setup.

Returning:Zara

Going to setup student profile.

Age : 11

Student profile has been setup.

Returning:11

Going to setup student profile.

Exception raised

Student profile has been setup.

There has been an exception: java.lang.IllegalArgumentException

.....

Spring Web MVC

The Spring web MVC framework provides model-view-controller architecture and ready components that can be used to develop flexible and loosely coupled web applications. The MVC pattern results in separating the different aspects of the application (input logic, business logic, and UI logic), while providing a loose coupling between these elements.

• The Model encapsulates the application data and in general they will consist of POJO.
• The View is responsible for rendering the model data and in general it generates HTML output that the client's browser can interpret.
• The Controller is responsible for processing user requests and building appropriate model and passes it to the view for rendering.

The DispatcherServlet

The Spring Web model-view-controller (MVC) framework is designed around a DispatcherServlet that handles all the HTTP requests and responses. The request processing workflow of the Spring Web MVC DispatcherServlet is illustrated in the following diagram:

Following is the sequence of events corresponding to an incoming HTTP request to DispatcherServlet:

1.     After receiving an HTTP request, DispatcherServlet consults the HandlerMapping to call the appropriate Controller.

2.     The Controller takes the request and calls the appropriate service methods based on used GET or POST method. The service method will set model data based on defined business logic and returns view name to the DispatcherServlet.

3.     The DispatcherServlet will take help from ViewResolver to pickup the defined view for the request.

4.     Once view is finalized, The DispatcherServlet passes the model data to the view which is finally rendered on the browser.

All the above mentioned components ie. HandlerMapping, Controller and ViewResolver are parts of WebApplicationContext which is an extension of the plain ApplicationContext with some extra features necessary for web applications.

Required Configuration

You need to map requests that you want the DispatcherServlet to handle, by using a URL mapping in the web.xml file. The following is an example to show declaration and mapping for HelloWeb DispatcherServlet example:

<web-app id="WebApp_ID" version="2.4"

    xmlns="http://java.sun.com/xml/ns/j2ee"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee

    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

    <display-name>Spring MVC Application</display-name>

   <servlet>

      <servlet-name>HelloWeb</servlet-name>

      <servlet-class>

         org.springframework.web.servlet.DispatcherServlet

      </servlet-class>

      <load-on-startup>1</load-on-startup>

   </servlet>

   <servlet-mapping>

      <servlet-name>HelloWeb</servlet-name>

      <url-pattern>*.jsp</url-pattern>

   </servlet-mapping>

</web-app>

The web.xml file will be kept WebContent/WEB-INF directory of your web application. OK, upon initialization of HelloWeb DispatcherServlet, the framework will try to load the application context from a file named [servlet-name]-servlet.xml located in the application's WebContent/WEB-INF directory. In this case our file will be HelloWeb-servlet.xml.

Next, <servlet-mapping> tag indicates what URLs will be handled by the which DispatcherServlet. Here all the HTTP requests ending with .jsp will be handled by the HelloWeb DispatcherServlet.

If you do not want to go with default filename as [servlet-name]-servlet.xml and default location as WebContent/WEB-INF, you can customize this file name and location by adding the servlet listener ContextLoaderListener in your web.xml file as follows:

<web-app...>

<!-------- DispatcherServlet definition goes here----->

....

<context-param>

   <param-name>contextConfigLocation</param-name>

   <param-value>/WEB-INF/HelloWeb-servlet.xml</param-value>

</context-param>

<listener>

   <listener-class>

      org.springframework.web.context.ContextLoaderListener

   </listener-class>

</listener>

</web-app>

Now, let us check the required configuration for HelloWeb-servlet.xml file, placed in your web application's WebContent/WEB-INF directory:

<beans xmlns="http://www.springframework.org/schema/beans"

   xmlns:context="http://www.springframework.org/schema/context"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="

   http://www.springframework.org/schema/beans    

   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

   http://www.springframework.org/schema/context

   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:component-scan base-package="com.tutorialspoint" />

   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">

      <property name="prefix" value="/WEB-INF/jsp/" />

      <property name="suffix" value=".jsp" />

   </bean>

</beans>

Following are the important points about HelloWeb-servlet.xml file:

• The [servlet-name]-servlet.xml file will be used to create the beans defined, overriding the definitions of any beans defined with the same name in the global scope.
• The <context:component-scan...> tag will be use to activate Spring MVC annotation scanning capability which allows to make use of annotations like @Controller and @RequestMapping etc.
• The InternalResourceViewResolver will have rules defined to resolve the view names. As per the above defined rule, a logical view named hello is delegated to a view implementation located at /WEB-INF/jsp/hello.jsp .

Next section will show you how to create your actual components ie. Controller, Model and View.

Defining a Controller

DispatcherServlet delegates the request to the controllers to execute the functionality specific to it. The @Controller annotation indicates that a particular class serves the role of a controller. The @RequestMapping annotation is used to map a URL to either an entire class or a particular handler method.

@Controller

@RequestMapping("/hello")

public class HelloController{

   @RequestMapping(method = RequestMethod.GET)

   public String printHello(ModelMap model) {

      model.addAttribute("message", "Hello Spring MVC Framework!");

      return "hello";

   }

}

The @Controller annotation defines the class as a Spring MVC controller. Here, the first usage of @RequestMapping indicates that all handling methods on this controller are relative to the /hello path. Next annotation @RequestMapping(method = RequestMethod.GET) is used to declare the printHello()method as the controller's default service method to handle HTTP GET request. You can define another method to handle any POST request at the same URL.

You can write above controller in another form where you can add additional attributes in @RequestMappingas follows:

@Controller

public class HelloController{

   @RequestMapping(value = "/hello", method = RequestMethod.GET)

   public String printHello(ModelMap model) {

      model.addAttribute("message", "Hello Spring MVC Framework!");

      return "hello";

   }

}

The value attribute indicates the URL to which the handler method is mapped and the method attribute defines the service method to handle HTTP GET request. There are following important points to be noted about the controller defined above:

• You will defined required business logic inside a service method. You can call another methods inside this method as per requirement.
• Based on the business logic defined, you will create a model within this method. You can setter different model attributes and these attributes will be accessed by the view to present the final result. This example creates a model with its attribute "message".
• A defined service method can return a String which contains the name of the view to be used to render the model. This example returns "hello" as logical view name.

Creating JSP Views

Spring MVC supports many types of views for different presentation technologies. These include - JSPs, HTML, PDF, Excel worksheets, XML, Velocity templates, XSLT, JSON, Atom and RSS feeds, JasperReports etc. But most commonly we use JSP templates written with JSTL. So let us write a simple hello view in /WEB-INF/hello/hello.jsp:

<html>

   <head>

   <title>Hello Spring MVC</title>

   </head>

   <body>

   <h2>${message}</h2>

   </body>

</html>

Here ${message}is the attribute which we have setup inside the Controller. You can have multiple attributes to be displayed inside your view.