If AutoCommit is off, then any update or insert operation
perforned on database will not be reflected just after the 
query is executed.Though the operation has been 
successfully completed.
 We will have to commit the transaction manually, to view 
the incurred changes.
  This also keeps user on the safer side, if some 
undesirable row has been inserted,updated or deleted in the 
database then it can be rollback.

While if the AutoCommit is on any update,insert or delete 
are at once reflected onto the database.

We can implement connection pooling in weblogic as follows.
1. OPen weblogic console.on the top right hand side corner 
of the window click on services tab.
2.Expand it and select JDBC.
3.Create a connection pool
4.Create a DataSource.
5.Create a JNDI.

In the programs make use of the following code to get the 
connection from ConnectionPool

Context ic=null;
DataSource ds;
Connection con=null;
Hashtable ht=new Hashtable();
ht.put
(Context.INITIAL_CONTEXT_FACTORY,"Weblogic.jndi.WLInitialCon
textFactory");
ht.put(Context.PROVIDER_URL,"t3://localhost:7001");
ic=new InitialContext(ht);
ds=(DataSource)ic.lookup("jndi name given in weblogic");
con=ds.getConnection();

Here is the defination and example in case of spring:

Local Vs Global Transaction:

Local transactions are transactions associated with a
particalar data source (means they are resource-specific).
the most common example would be a transaction associated
with a JDBC connection. While Global Transactions provide
the ability to work with multiple transactional resources
(typically relational databases and message queues).

Example of Local transaction :

<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName"
value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

<bean id="txManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>

DataSourceTransactionManager : takes the datasource as one
of its properties.

even HibarnateTransactionManager  takes sessionfactory which
in turn uses datasource as a property or it also takes
datasource as one of the property.


Example of Global transaction : 

If we use JTA in a J2EE container, as in the
'dataAccessContext-jta.xml' file from the same sample
application, we use a container DataSource, obtained via
JNDI, in conjunction with Spring's
JtaTransactionManager. The JtaTransactionManager doesn't
need to know about the DataSource, or any
other specific resources, as it will use the container's
global transaction management infrastructure.


<?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:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/jee
http://www.springframework.org/schema/jee/spring-jee-2.5.xsd">
<jee:jndi-lookup id="dataSource" jndi-name="jdbc/jpetstore"/>
<bean id="txManager"
class="org.springframework.transaction.jta.JtaTransactionManager"
/>
<!-- other <bean/> definitions here -->
</beans>

1.Driver Manager 
2.Connection

The two major components of JDBC are
1.Driver
2.DriverManager

1.connection pool 
2.Data source

JDBC Driver  and  JDBC  API 

JDBC DRIVER  is  different  for  each  db , API  is  same 
for  all the  DB . API  is  the  one  Application 
programmers  can  use and  which  will communicate  to the 
underlaying  Db  through Driver

native protocol

type 4 uses thin protocol of specified vendor say oracle is
jdbc:oracle:thin:@systemname:1521:oracleservicename

Both these drivers are used to connect your java program to
database(oracle).

Thin drivers (comes under type 4 drivers)  are completely
written in java.You can connect to oracle without oracle
client installed on ur pc.
Thick drivers(comes under type 1 or i think 2,3 also)are not
 written completely in java.You need oracle client(like odbc
driver,jdbc-odbc bridge drivers etc)for communication
between java program and oracle.

As thin driver's implementation is smaller as compared to
thick drivers,so they are are called as such i think.

Batch updates is a facility given by the JDBC to the 
application developers to submit a set of SQL update 
statements as batch to the database.

st.addBatch("Update statement1");
st.addBatch("Update statement2");
st.addBatch("Update statement3");

int updated[]=st.executeBatch();// This methods throws 
BatchUpdateException and SQLException

Batch Update provide the functionality of executing a group 
of sql statement at single timing.

Steps:

1.set autocommit as false for connection .
       connectionObject.setAutoCommit(false);
2.create sql statement and add to statement object.
       statementObj.addBatch("sql1");
       statementObj.addBatch("sql2");
       statementObj.addBatch("sql3");
3.execute the batch of statement using executeBatch().
      statementObj.executebatch();
4. commit the connection.
            connectionObj.commit();

Parameters used in Connection Pooling are:-
Min Pool Size,
Max Pool Size,
Connection Lifetime ,
Connection Timeout,
Incr Pool Size ,
Decr Pool Size ,

In real time project,We can use type-4 driver.This is fully 
java based driver.Prepared statement:This is pre-compiled 
sql query.

There are three types of statements
1.statement
2.preparted statement
3.callable statement.

1.statement:like as sql query.
2.prepared statement:pre-compiled sql query.
3.callable statement-to call the stored procedure.

We can use CallableStatement interface to call a stored 
procedure.Use the following steps.

1. crate the escape syntax like
String sql="{call procname(?,?,?);
2.CallableStatement cst=con.prepareCall(sql);
3.Set the inparameters using setXXX methods like
cst.setInt(1,10);
cst.setString(2,"abc");
4.Register the out parameter
cst.registerOutParameter(1,Types.Float);
5.Submit the statement using
cst.execute();
6. We can get the data from stored procedure using getXXX 
methods

use callableStatment