40. What is SQLExceptionTranslator ?
SQLExceptionTranslator, is an interface to be implemented by classes that can translate
between SQLExceptions and Spring's own data-access-strategy-agnostic org.springframework.dao.DataAccessException.
41. What is Spring's JdbcTemplate ?
Spring's JdbcTemplate is central
class to interact with a database through JDBC. 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.
JdbcTemplate template = new JdbcTemplate(myDataSource);
42. What is PreparedStatementCreator ?
PreparedStatementCreator:
- Is one of the most common used interfaces for writing data to database.
- Has one
method –
createPreparedStatement(Connection) - Responsible
for creating a
PreparedStatement. - Does not
need to handle
SQLExceptions.
43. What is SQLProvider ?
SQLProvider:
- Has one
method –
getSql() - Typically
implemented by
PreparedStatementCreatorimplementers. - Useful for debugging.
44. What is RowCallbackHandler ?
The
RowCallbackHandler interface extracts values from each row of a ResultSet. - Has one
method –
processRow(ResultSet) - Called for
each row in
ResultSet. - Typically stateful.
45. What are the differences between EJB and Spring ?
Spring and EJB feature
comparison.
|
Feature
|
EJB
|
Spring
|
|
Transaction management
|
|
|
|
Declarative transaction support
|
|
|
|
Persistence
|
Supports programmatic bean-managed
persistence and declarative container managed persistence.
|
Provides a framework for integrating with
several persistence technologies, including JDBC, Hibernate, JDO, and iBATIS.
|
|
Declarative security
|
|
|
|
Distributed computing
|
Provides container-managed remote method
calls.
|
Provides proxying for remote calls via
RMI, JAX-RPC, and web services.
|
Spring Interview Questions
what is dependency injection ??
Latest
Answer: Here
before going to Dependency injection I want mention lilttle bit about
DependencyLookup l. - If the main application or object serches for
getting dependent values require for it then it is called dependency
lookup.Example: The way you ...
Latest
Answer: IOC
Container conceptorg.springframework.beans || ||--->|The BeanFactory
interface advanced configuration mechanism capable of managing objects of any
nature. ...
1) Explain about spring applications framework?Spring architecture helps you to manage your business objects. Implementation part of the spring is easy because it helps you to introduce it in the middle of the objects. This framework is easy to implement in testing conditions. This is used by many large vendors.
2) State some benefits and advantages of spring framework?
Some of the benefits which spring can offer you are as follows: -
• It is very beneficial for middle tier applications and it can be used in various run time environments.
• Various custom properties need not be used in applications.
• Cost can be reduced by reducing the programming to interface cost ratio.
• Applications built on spring framework are easy to test.
3) Explain about portability of spring?
Spring applications and framework are portable between different servers. This framework and applications are portable between many different servers such as Tomcat, Jetty, Web Logic, Web Sphere, Resin, Geronimo, etc. Environment features can be implemented without affecting portability.
4) Explain about Bean factory?
Spring is designed to work with Java Beans and this forms the core part of the Spring Framework. This is a generic factory and it lets users and developers to enable objects by name. This helps to manage relationships between objects.
5) Explain about the two models of the object which Bean Factory supports?
Two models of object which bean factory supports are: -
1) Single ton and prototype.
Singleton has one instance (shared) with an object and it is assigned a specific name which can be retrieved on lookup.
Prototype results in creation of an independent object.
6) Explain about Bean definition Reader interface?
Bean definition reader interface separates Bean factory implementations from metadata format. This is very useful if the application needs different metadata implementations. This framework or interface can be implemented in different ways.
7) State about the commonly used Bean Factory definitions?
The most commonly used bean factory definitions are as follows: -
1) XML bean factory and 2) DefaultListable beanfactory.
XMLbean factory is used to parse XML structure to define classes and properties of objects (named).
DefaultListablebeanfactory is useful to program bean factories and parse definitions.
8) Explain about inversion control behavior?
Inversion control behavior is obtained through bean factory concept. The best part about this container is it can be coded in a single line and has simple deployment steps. Inversion of control behavior is very useful to avoid heavy containers such as EJB.
9) Explain about dependency injection?
Dependency injection is used to remove dependence of explicit coding on container. It resembles to a form of IoC. Java methods are chiefly used to inject dependencies into an object. It is used to collaborate and configure values into an object.
10) Explain why an organization needs to implement spring framework?
Spring framework is essential because it touches important aspects such as
1) It is very useful to manage business objects
2) Spring architecture is very flexible it regains its architecture even when you can take some parts of it.
3) Testing part is very efficient and east to use.
4) Vendors recognized its importance and they are using it for enterprise Java development.
11) Explain about how to deploy applications using POJOs?
Spring helps you to develop components using POJOs. Spring Framework takes care of your need to build enterprise applications. Infrastructure of your application should be away from the business logic because it can improve the pace of your business logic changes. This is provided by Springs Framework.
12) Explain about auto wire support?
When auto wire is used as an optional attribute it reduces the volume of configuration. Auto wire should be used on the root element and this is used to activate auto wiring for all beans. If you would like to add an additional constructor it can be populates without the need to change configuration.
13) Explain the three different methods which are provided by the Namespace Handler interface?
The three different methods which are provided by the name space handler interface are: -
1) Init() is used to allow initialization for name space handler.
2) BeanDefinition parse is used when a Spring encounters a top level element.
3) BeanDefinitionHandler is used when spring encounters an attribute.
14) Explain about the different ways in which Spring JDBC can help you?
There are several ways in which a spring JDBC can help you they are: -
1) Connection leaks can be avoided.
2) Code can be focused on necessary SQL and it is very low.
3) Applications will never have to depend on RDBMS error specification handling.
4) You can easily implement DAO pattern without business logic.
15) Explain about exception wrapping?
Wrapping can be effectively done using spring. It makes the proprietary code to run in the ORM layer to a set of abstracted run time exceptions. Persistence exceptions can be easily handled. Handling of exceptions can be done very easily.
16) Explain about transaction management in spring?
Spring uses its own abstract for transaction management. It uses to deliver
1) Programmatic transaction management through SimpleJdbcTemplate.
2) Declarative transaction management is similar to EJB. It is compatible with superset of EJB CMT with some unique features.
17) Explain about integration of spring with AspectJ?
Spring integrates comfortably with AspectJ and this aspect makes it very poular. It makes it possible to include AspectJ aspects into Spring applications. Using Spring IoC container it is possible for dependency inject AspectJ. AspectJ is also used to inject non spring managed POJO using spring. It is uses XML and annotation driven pointcuts.
A) Spring provides a custom JavaServer Faces VariableResolver implementation that extends the standard Java Server Faces managed beans mechanism which lets you use JSF and Spring together. This variable resolver is called as DelegatingVariableResolver
Q) How to integrate Java Server Faces (JSF) with Spring?
A) JSF and Spring do share some of the same features, most noticeably in the area of IOC services. By declaring JSF managed-beans in the faces-config.xml configuration file, you allow the FacesServlet to instantiate that bean at startup. Your JSF pages have access to these beans and all of their properties.We can integrate JSF and Spring in two ways:
–>DelegatingVariableResolver: Spring comes with a JSF variable resolver that lets you use JSF and Spring together.
<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN”
“http://www.springframework.org/dtd/spring-beans.dtd”>
<faces-config>
<application>
<variable-resolver>
org.springframework.web.jsf.DelegatingVariableResolver
</variable-resolver>
</application>
</faces-config>
The DelegatingVariableResolver will first delegate value lookups to the default resolver of the underlying JSF implementation, and then to Spring’s ‘business context’ WebApplicationContext. This allows one to easily inject dependencies into one’s JSF-managed beans.
–> FacesContextUtils:custom VariableResolver works well when mapping one’s properties to beans in faces-config.xml, but at times one may need to grab a bean explicitly. The FacesContextUtils class makes this easy. It is similar to WebApplicationContextUtils, except that it takes a FacesContext parameter rather than a ServletContext parameter.
ApplicationContext ctx = FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance());
Q) What is Java Server Faces (JSF) – Spring integration mechanism?
A) Spring provides a custom JavaServer Faces VariableResolver implementation that extends the standard JavaServer Faces managed beans mechanism. When asked to resolve a variable name, the following algorithm is performed:
Does a bean with the specified name already exist in some scope (request, session, application)? If so, return it
Is there a standard JavaServer Faces managed bean definition for this variable name? If so, invoke it in the usual way, and return the bean that was created.
Is there configuration information for this variable name in the Spring WebApplicationContext for this application? If so, use it to create and configure an instance, and return that instance to the caller.
If there is no managed bean or Spring definition for this variable name, return null instead.
BeanFactory also takes part in the life cycle of a bean, making calls to custom initialization and destruction methods.
As a result of this algorithm, you can transparently use either JavaServer Faces or Spring facilities to create beans on demand.
Q) What is Significance of JSF- Spring integration ?
A) Spring – JSF integration is useful when an event handler wishes to explicitly invoke the bean factory to create beans on demand, such as a bean that encapsulates the business logic to be performed when a submit button is pressed.
Q) How to integrate your Struts application with Spring?
A) To integrate your Struts application with Spring, we have two options:
Configure Spring to manage your Actions as beans, using the ContextLoaderPlugin, and set their dependencies in a Spring context file.
Subclass Spring’s ActionSupport classes and grab your Spring-managed beans explicitly using a getWebApplicationContext() method.
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) How to integrate Spring and Hibernate ?
A) Spring and Hibernate can integrate using Spring’s SessionFactory called LocalSessionFactory. The integration process is of 3 steps.
–> Configure Hibernate mappings.
–> Configure Hibernate properties.
–> Wire dependant object to SessionFactory.
Q) What are the ways to access Hibernate using Spring ?
A) There are two ways to access Hibernate from Spring:
–> Through Hibernate Template.
–> Subclassing HibernateDaoSupport
–> Extending HibernateDaoSupport and Applying an AOP Interceptor
Q) What are Bean scopes in Spring Framework ?
A) The Spring Framework supports exactly five scopes (of which three are available only if you are using a web-aware ApplicationContext). The scopes supported are listed below:
Scope and Description of the Bean scopes in Spring Framework.
–>singleton : Scopes a single bean definition to a single object instance per Spring IoC container.
–>prototype : Scopes a single bean definition to any number of object instances.
–>request : Scopes a single bean definition to the lifecycle of a single HTTP request; that is each and every HTTP request will have its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.
–>session : Scopes a single bean definition to the lifecycle of a HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.
–>global session : Scopes a single bean definition to the lifecycle of a global HTTP Session. Typically only valid when used in a portlet context. Only valid in the context of a web-aware Spring ApplicationContext.
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) How the AOP used in Spring?
A) AOP is used in the Spring Framework:To provide declarative enterprise services, especially as a replacement for EJB declarative services. The most important such service is declarative transaction management, which builds on the Spring Framework’s transaction abstraction.To allow users to implement custom aspects, complementing their use of OOP with AOP.
Q) What do you mean by Aspect ?
A) A modularization of a concern that cuts across multiple objects. Transaction management is a good example of a crosscutting concern in J2EE applications. 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 do you mean by JointPoint?
A) A point during the execution of a program, such as the execution of a method or the handling of an exception. In Spring AOP, a join point always represents a method execution.
Q) What do you mean by Advice?
A) Action taken by an aspect at a particular join point. Different types of advice include “around,” “before” and “after” advice. Many AOP frameworks, including Spring, model an advice as an interceptor, maintaining a chain of interceptors “around” the join point.
1) What is Spring?
Spring is a
lightweight inversion of control and aspect-oriented container framework.
2) Explain Spring?
- 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.
- Framework : Spring provides most of the intra functionality leaving rest of the coding to the developer.
3) What are the different modules
in Spring framework?
- The Core container module
- Application context module
- AOP module (Aspect Oriented Programming)
- JDBC abstraction and DAO module
- O/R mapping integration module (Object/Relational)
- Web module
- MVC framework module
4) What is the structure of
Spring framework?
5) What is the Core container
module?
This module is provides the fundamental functionality of
the spring framework. In this module BeanFactory is the heart of any
spring-based application. The entire framework was built on the top of this
module. This module makes the Spring container.
6) What is Application context
module?
The Application context module makes spring a framework.
This module extends the concept of BeanFactory, providing support
for internationalization (I18N) messages, application lifecycle events, and
validation. This module also supplies many enterprise services such JNDI
access, EJB integration, remoting, and scheduling. It also
provides support to other framework.
7) What is AOP module?
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. Using Spring’s metadata support, we will
be able to add annotations to our source code
that instruct Spring on where and how to apply
aspects.
8) What is JDBC abstraction and
DAO module?
Using this module we can keep up the database code clean
and simple, and prevent problems that result from a
failure to close database resources. A new layer of meaningful exceptions on
top of the error messages given by several database servers is bought in this
module. In addition, this module uses Spring’s AOP module to
provide transaction management services for objects in a Spring application.
9) What are object/relational
mapping integration module?
Spring also supports for using of an object/relational
mapping (ORM) tool over straight JDBC by providing the ORM module. Spring
provide 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.
10) What is web module?
This 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.
11) What is web module?
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 for
a clean separation of controller logic from business objects. It also allows
you to declaratively bind request parameters to your business objects. It also
can take advantage of any of Spring’s other services,
such as I18N messaging and validation.
12) What is a BeanFactory?
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.
13) What is AOP Alliance?
AOP Alliance is an open-source project whose goal is to
promote adoption of AOP and interoperability among different AOP
implementations by defining a common set of interfaces and components.
14) What is Spring configuration
file?
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.
15) What does a simple spring
application contain?
These applications are like any Java application. They are
made up of several classes, each performing a specific purpose within the
application. But these classes are configured and introduced to each other
through anXML file. This XML file describes how to configure the classes, known
as the Spring configuration file.
16) What is XMLBeanFactory?
BeanFactory has many
implementations in Spring. But one of the most useful one is org.springframework.beans.factory.xml.XmlBeanFactory,
which loads its beans based on the definitions contained in an XML file. To
create an XmlBeanFactory, pass a java.io.InputStream to the
constructor. The InputStream will provide the XML to the factory.
For example, the following code snippet uses a java.io.FileInputStream
to provide a bean definition XML file to XmlBeanFactory. BeanFactory factory = new XmlBeanFactory(new FileInputStream("beans.xml")); MyBean myBean = (MyBean) factory.getBean("myBean");
17) What are important
ApplicationContext implementations in spring framework?
- ClassPathXmlApplicationContext – This context loads a context definition from an XML file located in the class path, treating context definition files as class path resources.
- FileSystemXmlApplicationContext – This context loads a context definition from an XML file in the filesystem.
- XmlWebApplicationContext – This context loads the context definitions from an XML file contained within a web application.
18) Explain Bean lifecycle in
Spring framework?
- The spring container finds the bean’s definition from the XML file and instantiates the bean.
- Using the dependency injection, spring populates all of the properties as specified in the bean definition.
- If the bean implements the BeanNameAware interface, the factory calls setBeanName() passing the bean’s ID.
- If the bean implements the BeanFactoryAware interface, the factory calls setBeanFactory(), passing an instance of itself.
- If there are any BeanPostProcessors associated with the bean, their post- ProcessBeforeInitialization() methods will be called.
- If an init-method is specified for the bean, it will be called.
- Finally, if there are any BeanPostProcessors associated with the bean, their postProcessAfterInitialization() methods will be called.
19) What is bean wiring?
Combining together beans within the Spring container is
known as bean wiring or wiring. When wiring beans, you should tell the
container what beans are needed and how the container should use dependency
injection to tie them together.
20) How do add a bean in spring
application?
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <bean id="foo" class="com.act.Foo"/> <bean id="bar" class="com.act.Bar"/> </beans>
21) What are singleton beans and
how can you create prototype beans?
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. <beans> <bean id="bar" class="com.act.Foo" singleton=”false”/> </beans>
22) What are the important beans
lifecycle methods?
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.
23) How can you override beans
default lifecycle methods?
The bean tag has two more important attributes with which
you can define your own custom initialization and destroy methods. Here I have
shown a small demonstration. Two new methods fooSetup and fooTeardown are to be
added to your Foo class. <beans> <bean id="bar" class="com.act.Foo" init-method=”fooSetup” destroy=”fooTeardown”/> </beans>
24) What are Inner Beans?
When wiring beans, if a bean element is embedded to a
property tag directly, then that bean is said to the Inner Bean. The drawback
of this bean is that it cannot be reused anywhere else.
25) What are the different types
of bean injections?
There are two types of bean injections. - By
setter
- By
constructor
26) What is Auto wiring?
You can wire the beans as you wish. But spring framework
also does this work for you. It can auto wire the related beans together. All
you have to do is just set the autowire attribute of bean tag to an autowire
type. <beans> <bean id="bar" class="com.act.Foo" Autowire=”autowire type”/> </beans>
27) What are different types of
Autowire types?
There are four different types by which autowiring can be
done.- byName
- byType
- constructor
- autodetect
28) What are the different types
of events related to Listeners?
There are a lot of events related to ApplicationContext
of spring framework. All the events are subclasses of org.springframework.context.Application-Event.
They are- ContextClosedEvent – This is fired when the context is closed.
- ContextRefreshedEvent – This is fired when the context is initialized or refreshed.
- RequestHandledEvent – This is fired when the web context handles any request.
29) What is an Aspect?
An aspect is the cross-cutting functionality that you are
implementing. It is the aspect of your application you are modularizing. An
example of an aspect is logging. Logging is something that is required
throughout an application. However, because applications tend to be broken down
into layers based on functionality, reusing a logging module through
inheritance does not make sense. However, you can create a logging aspect and
apply it throughout your application using AOP.
30) What is a Jointpoint?
A joinpoint is a point in the execution of the application
where an aspect can be plugged in. This point could be a method being called,
an exception being thrown, or even a field being modified. These are the points
where your aspect’s code can be inserted into the normal flow of your
application to add new behavior.
31) What is an Advice?
Advice is the implementation of an aspect. It is something like
telling your application of a new behavior. Generally, and advice is inserted
into an application at joinpoints.
32) What is a Pointcut?
A pointcut is something that defines at what joinpoints an
advice should be applied. Advices can be applied at any joinpoint that is
supported by the AOP framework. These Pointcuts allow you to specify where the
advice can be applied.
33) What is an Introduction in
AOP?
An introduction allows the user to add new methods or
attributes to an existing class. This can then be introduced to an existing
class without having to change the structure of the
class, but give them the new behavior and state.
34) What is a Target?
A target is the class that is being advised. The class can
be a third party class or your own class to which you want to add your own
custom behavior. By using the concepts of AOP, the target class is free to
center on its major concern, unaware to any advice that is being applied.
35) What is a Proxy?
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.
36) What is meant by Weaving?
The process of applying aspects to a target object to
create a new proxy object is called as Weaving. The aspects are woven into the
target object at the specified joinpoints.
37) What are the different points
where weaving can be applied?
- Compile Time
- Classload Time
- Runtime
38) What are the different advice
types in spring?
- Around : Intercepts the calls to the target method
- Before : This is called before the target method is invoked
- After : This is called after the target method is returned
- Throws : This is called when the target method throws and exception
- Around : org.aopalliance.intercept.MethodInterceptor
- Before : org.springframework.aop.BeforeAdvice
- After : org.springframework.aop.AfterReturningAdvice
- Throws : org.springframework.aop.ThrowsAdvice
39) What are the different types
of AutoProxying?
- BeanNameAutoProxyCreator
- DefaultAdvisorAutoProxyCreator
- Metadata autoproxying
40) What is the Exception class
related to all the exceptions that are thrown in spring applications?
DataAccessException - org.springframework.dao.DataAccessException
41) What kind of exceptions those
spring DAO classes throw?
The spring’s DAO class does not throw any technology
related exceptions such as SQLException. They throw exceptions which are
subclasses of DataAccessException.
42) What is DataAccessException?
DataAccessException is a RuntimeException. This is an
Unchecked Exception. The user is not forced to handle
these kinds of exceptions.
43) How can you configure a bean
to get DataSource from JNDI?
<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName"> <value>java:comp/env/jdbc/myDatasource</value> </property> </bean>
44) How can you create a
DataSource connection pool?
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driver"> <value>${db.driver}</value> </property> <property name="url"> <value>${db.url}</value> </property> <property name="username"> <value>${db.username}</value> </property> <property name="password"> <value>${db.password}</value> </property> </bean>
45) How JDBC can be used more
efficiently in spring framework?
JDBC can be used more efficiently with the help of a
template class provided by spring framework called as JdbcTemplate.
46) How JdbcTemplate can be used?
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 template = new JdbcTemplate(myDataSource); public class StudentDaoJdbc implements StudentDao { private JdbcTemplate jdbcTemplate; public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { this.jdbcTemplate = jdbcTemplate; } more.. } <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource"> <ref bean="dataSource"/> </property> </bean> <bean id="studentDao" class="StudentDaoJdbc"> <property name="jdbcTemplate"> <ref bean="jdbcTemplate"/> </property> </bean> <bean id="courseDao" class="CourseDaoJdbc"> <property name="jdbcTemplate"> <ref bean="jdbcTemplate"/> </property> </bean>
47) How do you write data to
backend in spring using JdbcTemplate?
The JdbcTemplate uses several of these callbacks when
writing data to the database. The usefulness you will find in each of these
interfaces will vary. There are two simple interfaces. One is PreparedStatementCreator
and the other interface is BatchPreparedStatementSetter.
48) Explain about
PreparedStatementCreator?
PreparedStatementCreator is one of the most common used
interfaces for writing data to database. The interface has one method
createPreparedStatement(). PreparedStatement createPreparedStatement(Connection conn) throws SQLException;
49) Explain about
BatchPreparedStatementSetter?
If the user what to update more than one row at a shot then
he can go for BatchPreparedStatementSetter. This interface provides two
methods setValues(PreparedStatement ps, int i) throws SQLException; int getBatchSize();
50) Explain about
RowCallbackHandler and why it is used?
In order to navigate through the records we generally go
for ResultSet. But spring provides an interface that handles this entire burden
and leaves the user to decide what to do with each row. The interface provided
by spring is RowCallbackHandler. There is a method processRow() which
needs to be implemented so that it is applicable for each and everyrow. void processRow(java.sql.ResultSet rs);
No comments:
Post a Comment