Java回顧之Spring基礎

　　第一篇：Java回顧之I/O

　　第二篇：Java回顧之網絡通信

　　第三篇：Java回顧之多線程

　　第四篇：Java回顧之多線程同步

　　第五篇：Java回顧之集合

　　第六篇：Java回顧之序列化

　　第七篇：Java回顧之反射

　　第八篇：Java回顧之一些基礎概念

　　第九篇：Java回顧之JDBC

　　第十篇：Java回顧之ORM框架

 

　　我計划分兩到三篇文章來描述Spring，這一篇主要講Spring一些基礎的內容。

　　概述

　　我印象4、5年前，我還做java開發的時候，Spring是一個非常火的框架，尤其是在Web開發領域，和Struts以及Hibernate構成了SSH三劍客。當時Web開發的另一個組合是LAMP，即Linux+Apache+MySQL+PHP。我在前端方面基本沒有實戰經驗，對js等技術也還是停留在概念和語法方面，所以揚長避短，我對Spring以及Hibernate特別感興趣。

　　當年Spring是作為EJB的“替代者”橫空出世的，其創始人Rod Johnson還寫了一本《J2EE development without EJB》來推行這個框架，這也是一本關於Spring很經典的書，不過最好是在接觸Spring一段時間后再去閱讀，效果會好一點。

　　Spring最主要的特點有兩個：IoC和AOP，這也是J2EE開發企業軟件時經常碰到的問題：1）對象太多如何管理；2）共同邏輯和業務邏輯糾纏在一起，錯綜復雜，如何解耦。

　　這篇文章主要關注3個方面：IoC、AOP和數據庫訪問。這里我們假設所有需要的jar都已經准備就緒。

　　IoC

　　IoC的全稱是Inversion of Control，中文稱為控制反轉， Martin Flower由根據它創造了一個新詞：Dependency Injection，中文稱為依賴注入。這兩個詞講的是一回事兒。

　　IoC的實質是如何管理對象，傳統意義上我們使用new方式來創建對象，但在企業應用開發的過程中，大量的對象創建都在程序中維護很容易造成資源浪費，並且不利於程序的擴展。

　　實現IoC通常有三種方式：

　　1）利用接口或者繼承，一般以接口較多。這種實現方式和我們平時提到的lazy load有異曲同工之妙。

　　2）構造函數注入。

　　3）屬性注入。

　　　IoC是Spring框架的核心，接下來我們來探索一下Spring中IoC的風采。

　　IoC簡單示例

　　我們先來定義一個簡單的接口和實現：

public interface UserDao {
    void save();
}

public class UserDaoImpl implements UserDao
{

    public void save() {
        System.out.println("save() is called.");
    }

}

　　然后是在classpath下創建一個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:context="http://www.springframework.org/schema/context"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <bean id="userDaoImpl" class = "sample.spring.ioc.UserDaoImpl"/>
</beans>    

　　接下來是測試代碼：

private static void test1()
{
    ApplicationContext ctx = new ClassPathXmlApplicationContext("sample/spring/ioc/beans.xml");
    UserDao userDao = (UserDao)ctx.getBean("userDaoImpl");
    userDao.save();
}

　　輸出結果如下：

save() is called.

　　我們還可以通過工廠方式來創建對象。

　　通過靜態工廠創建Bean

　　添加一個類，如下：

public class UserDaoFactory {

    public static UserDao getUserDao()
    {
        return new UserDaoImpl();
    }
}

　　在beans.xml中，添加如下內容：

<bean id="userDaoImpl2" class = "sample.spring.ioc.UserDaoFactory" factory-method = "getUserDao"/>

　　測試代碼和執行結果和上面類似，不再贅述。

　　通過實例工廠創建Bean

　　添加如下類：

public class UserDaoFactory2 
{
    public UserDao getUserDao()
    {
        return new UserDaoImpl();
    }
}

　　這個類和UserDaoFactory唯一的區別是這里的getUserDao是實例方法，而不是靜態方法。

　　在beans.xml中追加如下內容：

<bean id="factory" class="sample.spring.ioc.UserDaoFactory2"/>
<bean id="userDaoImpl3" factory-bean="factory" factory-method="getUserDao"/>

　　測試方法和結果同上。

　　對象的生命周期

　　我們可以通過設置bean節點的scope屬性來控制對象的聲明周期，它包含兩個可選值：

　　1）singleton，表明系統中對於同一個對象，只保留一個實例。

　　2）prototype，表明系統中每次獲取bean時，都新建一個對象。

　　我們修改beans.xml文件：

<bean id="userDaoImpl" class = "sample.spring.ioc.UserDaoImpl" scope="singleton"/>
<bean id="userDaoImpl2" class = "sample.spring.ioc.UserDaoImpl" scope="prototype"/>

　　這兩個bean指向同一個類型，但是scope的設置不同。

　　下面是測試方法：

private static void scopeTest()
{
    ApplicationContext ctx = new ClassPathXmlApplicationContext("sample/spring/ioc/scope.xml");
    System.out.println("=====Singleton test=====");
    UserDao userDao1A = (UserDao)ctx.getBean("userDaoImpl");
    UserDao userDao1B = (UserDao)ctx.getBean("userDaoImpl");
    System.out.println("userDao1A == userDao1B:" + (userDao1A==userDao1B));
    System.out.println("=====Prototype test=====");
    UserDao userDao2A = (UserDao)ctx.getBean("userDaoImpl2");
    UserDao userDao2B = (UserDao)ctx.getBean("userDaoImpl2");
    System.out.println("userDao2A == userDao2B:" + (userDao2A==userDao2B));
}

　　執行結果如下：

=====Singleton test=====
userDao1A == userDao1B:true
=====Prototype test=====
userDao2A == userDao2B:false

　　如何設置對象屬性

　　上面的示例中，我們的對象中沒有包含屬性，對於業務對象來說，這一般是不現實。實際中的對象或多或少都會有一些屬性。

　　Spring支持兩種方式對屬性賦值：set方式和構造函數。

　　下面我們會分別描述兩種方式，但首先我們需要展示業務對象：

public class UserServiceBean 
{
    private int userID;
    private String userName;
    private UserDao userDao;
    private List<String> hobbies;
    private Map<String, Integer> scores;
    
    public UserServiceBean(int userID, String userName, UserDao userDao, List hobbies,Map scores)
    {
        this.userID = userID;
        this.userName = userName;
        this.userDao = userDao;
        this.hobbies = hobbies;
        this.scores = scores;
    }
    
    public UserServiceBean(){}
    
    public void setUserID(int userID) {
        this.userID = userID;
    }
    public int getUserID() {
        return userID;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public UserDao getUserDao() {
        return userDao;
    }
    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }
    public List<String> getHobbies() {
        return hobbies;
    }
    public void setScores(Map<String, Integer> scores) {
        this.scores = scores;
    }
    public Map<String, Integer> getScores() {
        return scores;
    }
}

　　這是一個典型的學生信息，包括學號、姓名、愛好和成績。

　　通過Set方式為對象屬性賦值

　　我們在beans.xml中追加如內容：

<bean id="userService" class="sample.spring.ioc.UserServiceBean">
    <property name="userID" value="1"/>
    <property name="userName" value="張三"/>
    <property name="userDao" ref="userDaoImpl"/>
    <property name="hobbies">
        <list>
            <value>羽毛球</value>
            <value>看電影</value>
            <value>彈吉他</value>
        </list>
    </property>
    <property name="scores">
        <map>
            <entry key="數據結構" value="90"/>
            <entry key="編譯原理" value="85"/>
            <entry key="離散數學" value="82"/>
        </map>
    </property>
</bean>

　　上面是典型的為屬性賦值的示例，其中屬性不僅包括簡單屬性（整數、字符串），也包含了復雜屬性（List、Map），還有其他的bean。

　　下面是測試代碼：

private static void propertyTest1()
{
    ApplicationContext ctx = new ClassPathXmlApplicationContext("sample/spring/ioc/beans.xml");
    UserServiceBean userService = (UserServiceBean)ctx.getBean("userService");
    printUserService(userService);
}

private static void printUserService(UserServiceBean userService)
{
    System.out.println("編號：" + userService.getUserID());
    System.out.println("姓名：" + userService.getUserName());
    System.out.println("愛好：");
    for(String hobby:userService.getHobbies())
    {
        System.out.println(hobby);
    }
    System.out.println("學習成績：");
    for(Entry<String,Integer> entry:userService.getScores().entrySet())
    {
        System.out.println(entry.getKey() + "\t" + entry.getValue());
    }
    userService.getUserDao().save();
}

　　輸出結果如下：

編號：1
姓名：張三
愛好：
羽毛球
看電影
彈吉他
學習成績：
數據結構    90
編譯原理    85
離散數學    82
save() is called.

　　通過構造函數為對象屬性賦值

　　我們也可以通過構造函數來為對象賦值，在上面定義UserServiceBean時，我們已經添加了一個構造函數。下面來看beans.xml中的配置：

<bean id="userService2" class="sample.spring.ioc.UserServiceBean">
    <constructor-arg index="0" value="1"/>
    <constructor-arg index="1" value="張三"/>
    <constructor-arg index="2" ref="userDaoImpl"/>
    <constructor-arg index="3">
        <list>
            <value>羽毛球</value>
            <value>看電影</value>
            <value>彈吉他</value>
        </list>
    </constructor-arg>
    <constructor-arg index="4">
        <map>
            <entry key="數據結構" value="90"/>
            <entry key="編譯原理" value="85"/>
            <entry key="離散數學" value="82"/>
        </map>
    </constructor-arg>
</bean>

　　測試代碼和輸出結果同上。

　　需要注意：我們定義的業務對象應該保留默認的構造函數。

　　使用Annotation來定位Bean

　　在Spring中，除了在xml配置文件中定義對象，我們還可以使用Annotation來定位，這位我們提供了很大的方便。

　　這里我們使用的Annotation主要包括：@Resource/@Autowried/@Qualifier。

　　來看下面的示例：

public class UserServiceBean2 
{
    private String userID;
    private String userName;
    @Resource(name="userDaoImpl")
    private UserDao userDao1;
    private UserDao userDao2;
    
    @Autowired(required=false)
    @Qualifier("userDaoImpl")
    private UserDao userDao3;
    
    @Autowired(required=false)
    @Qualifier("userDaoImpl3")
    private UserDao userDao4;
    
    public void setUserID(String userID) {
        this.userID = userID;
    }
    public String getUserID() {
        return userID;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserName() {
        return userName;
    }
    @Resource
    public void setUserDao2(UserDao userDao2) {
        this.userDao2 = userDao2;
    }
    public UserDao getUserDao2() {
        return userDao2;
    }
    
    public void test()
    {
        userDao1.save();
        userDao2.save();
        System.out.println(userDao3.getClass().getName());
        userDao3.save();
    }
}

　　測試方法：

private static void annotationTest()
{
    ApplicationContext ctx = new ClassPathXmlApplicationContext("sample/spring/ioc/annotation.xml");
    UserServiceBean2 userService = (UserServiceBean2)ctx.getBean("userService");
    
    userService.test();
}

　　輸出結果如下：

save() is called.
save() is called.
sample.spring.ioc.UserDaoImpl
save() is called.

　　我們來對上面示例中出現的Annotation來進行說明。

@Resource(name="userDaoImpl")
private UserDao userDao1;

　　這是定義在字段上的Annotation，是指userDao1使用xml配置文件中定義的名為“userDaoImpl”的bean進行填充。

@Autowired(required=false)
@Qualifier("userDaoImpl")
private UserDao userDao3;

　　這是第二種類型的Annotation，它把Autowired和Qualifier組合在一起使用，Qualifier來設置bean的名稱，Autowired來設置bean找不到時的行為，required為true時會拋出異常，required為false時會返回null。

@Resource
public void setUserDao2(UserDao userDao2) {
     this.userDao2 = userDao2;
}

　　這是作用在setter上的Annotation，@Resource 可以不寫明name參數，這時Spring會首先按照名字然后按照數據類型的方式去定位bean。

　　自動加載對象定義

　　對於大型系統來說，我們可能會創建大量的類，如果這些類的聲明都需要寫在xml文件里的話，會產生額外大量的工作。

　　Spring提供了一種簡單的機制讓我們的對象可以自動注冊。

　　我們可以在beans.xml中添加如下內容：

<context:component-scan base-package="sample.spring.ioc"/>

　　然后我們可以在sample.spring.ioc包下的對象，添加@Component/@Service/@Controller/@repository，這樣Spring會自動將帶有這些Annotation的類進行注冊。

　　下面是一個示例：

@Service("userService")
public class UserServiceBean3 
{
    private String userID;
    private String userName;
    @Resource(name="userDaoImpl")
    private UserDao userDao1;
    
    @Autowired(required=true)
    @Qualifier("userDaoImpl")
    private UserDao userDao3;
    
    public void setUserID(String userID) {
        this.userID = userID;
    }
    public String getUserID() {
        return userID;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserName() {
        return userName;
    }
//    @Resource
//    public void setUserDao2(UserDao userDao2) {
//        this.userDao2 = userDao2;
//    }
//    public UserDao getUserDao2() {
//        return userDao2;
//    }
    
    public void test()
    {
        userDao1.save();
//        userDao2.save();
        System.out.println(userDao3.getClass().getName());
        userDao3.save();
    }
}

　　這個類和上面定義的UserServiceBean2非常相似，需要注意在類前面添加的Annotation信息。

　　我們不需要在xml文件中手動定義這個bean，Spring會進行自動注冊，注冊的bean名稱是userService。

　　AOP

　　我們在Java回顧之反射中已經設計了一個簡單的AOP框架，通常情況下，對於AOP，我們有兩種方式來實現。

　　使用DynamicProxy實現AOP

　　下面是一個簡單的示例，首先定義業務對象：

public interface UserDao {

    void save();
}

public class UserDaoImpl implements UserDao
{
    private String name;
    
    public void save() {
        System.out.println("save() is called for " + name);
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

　　下面是一個實現了InvocationHandler的類：

public class ProxyFactory implements InvocationHandler
{
    private Object target;

    public Object createUserDao(Object target)
    {
        this.target = target;
        return Proxy.newProxyInstance(this.target.getClass().getClassLoader(),
                this.target.getClass().getInterfaces(), this);
    }
    
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        
        UserDaoImpl userDao = (UserDaoImpl)target;
        Object result = null;
        if(userDao.getName() != null)
        {
            result = method.invoke(target, args);
        } 
        else
        {
            System.out.println("The name is null.");
        }
        return result;
    }
}

　　接下來是測試代碼：

private static void test1()
{
    ProxyFactory pf = new ProxyFactory();
    UserDao userDao = (UserDao)pf.createUserDao(new UserDaoImpl());
    userDao.save();
}

　　執行結果如下：

The name is null.

　　這是因為userDao的類型是UserDao，它是一個接口，並沒有定義name字段，因此name=null。

　　使用Cglib實現AOP

　　同樣是上面的需求，我們假設並沒有繼承的接口，這我們可以使用cglib來實現。

　　首先我們重新定義一個UserDaoImpl2，它不會實現任何接口：

public class UserDaoImpl2
{
    private String name;
    
    public void save() throws InterruptedException {
        Thread.sleep(3000);
        System.out.println("save() is called for " + name);
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
    
    public void raiseException()
    {
        throw new RuntimeException("This is test.");
    }
}

　　然后是創建CglibFactory：

public class CglibFactory implements MethodInterceptor
{
    private Object target;
    public Object createUserDao(Object target)
    {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    public Object intercept(Object proxy, Method method, Object[] args,
            MethodProxy methodProxy) throws Throwable {
        UserDaoImpl2 userDao = (UserDaoImpl2)target;
        if (userDao.getName() != null)
        {
            return method.invoke(target, args);
        }
        else
        {
            System.out.println("The name is null.");
        }
        return null;
    }
}

　　它實現了MethodInterceptor接口，其中包括intercept方法，這個方法就會通過反射的方式來觸發目標方法，同時還可以添加一些其他處理。

　　下面是測試方法：

private static void test2() throws InterruptedException
{
    CglibFactory cf = new CglibFactory();
    UserDaoImpl2 temp = new UserDaoImpl2();
    UserDaoImpl2 userDao = (UserDaoImpl2)cf.createUserDao(temp);
    userDao.save();
    temp.setName("Zhang San");
    userDao = (UserDaoImpl2)cf.createUserDao(temp);
    userDao.save();
}

　　輸出結果如下：

The name is null.
save() is called for Zhang San

　　使用Spring實現AOP

　　Spring框架集合了ProxyFactory和Cglib兩種方式來實現AOP。

　　我們來看一個示例，還是使用上面定義的UserDaoImpl以及UserDaoImpl2。

　　首先需要定義一個interceptor：

@Aspect
public class MyInterceptor {

    @Pointcut("execution (* sample.spring.aop.*.*(..))")
    public void anyMethod(){}
    
    @Before("anyMethod()")
    public void before()
    {
        System.out.println("Before");
    }
    
    @After("anyMethod()")
    public void after()
    {
        System.out.println("After");
    }
    
    @Around("anyMethod()")
    public void Around(ProceedingJoinPoint pjp) throws Throwable
    {
        long start = System.currentTimeMillis();
        pjp.proceed();
        long end = System.currentTimeMillis();
        System.out.println("執行時間：" + (end - start));
    }
    
    @Before("anyMethod() && args(name)")
    public void before(String name)
    {
        System.out.println("The name is " + name);
    }
    
    @AfterReturning(pointcut="anyMethod()", returning="result")
    public void afterReturning(String result)
    {
        System.out.println("The value is " + result);
    }
    
    @AfterThrowing(pointcut="anyMethod()", throwing="e")
    public void afterThrowing(Exception e)
    {
        e.printStackTrace();
    }
}

　　我們可以看到上面的代碼中包含了一些Annotation，這些Annotation是用來實現AOP的關鍵。

　　然后需要修改beans.xml，添加如下內容：

<aop:aspectj-autoproxy />
<bean id="userDaoImpl" class = "sample.spring.aop.UserDaoImpl"/>
<bean id="userDaoImpl2" class = "sample.spring.aop.UserDaoImpl2"/>
<bean id="myInterceptor" class="sample.spring.aop.MyInterceptor"/>

　　其中第一行是讓Spring打開AOP的功能，下面三行定義了三個bean，這里我們把interceptor也看做是一個bean對象。

　　接下來是測試代碼：

private static void test3() throws InterruptedException
{
    ApplicationContext ctx = new ClassPathXmlApplicationContext("sample/spring/aop/beans.xml");
    UserDao userDao = (UserDao)ctx.getBean("userDaoImpl");
    userDao.save();
    UserDaoImpl2 userDao2 = (UserDaoImpl2)ctx.getBean("userDaoImpl2");
    userDao2.save();
    userDao2.setName("Zhang San");
    String name = userDao2.getName();
//        userDao2.raiseException();
}

　　這里我們可以看到，測試方法中既使用了UserDaoImpl1（這里是UserDao接口），也是用了UserDaoImpl2。正如我們上面所言，在Spring中，如果類實現了接口，Spring會按照ProxyFactory的方式來處理；如果沒有實現接口，Spring會按照Cglib的方式來處理。

　　上面測試方法的輸出如下：

Before
Before
save() is called for null
執行時間：1
The value is null
After
After
執行時間：1
The value is null
Before
Before
save() is called for null
執行時間：3001
The value is null
After
After
執行時間：3002
The value is null
Before
The name is Zhang San
Before
執行時間：26
The value is null
After
After
執行時間：27
The value is null
Before
Before
執行時間：0
The value is null
After
After
執行時間：1
The value is null

　　使用Spring配置文件來配置AOP

　　上面的示例中，我們使用Annotation來配置AOP的信息，同樣我們也可以使用xml文件的方式來配置AOP。

　　還是以上面定義的interceptor為基礎，我們去掉里面所有的Annotation，然后在beans.xml中添加如下內容：

<bean id="myInterceptor2" class="sample.spring.aop.MyInterceptor2"/>
<aop:config>
    <aop:aspect id="asp" ref="myInterceptor2">
        <aop:pointcut id="anyMethod" expression="execution (* sample.spring.aop.*.*(..))"/>
        <aop:before pointcut-ref="anyMethod" method="before"/>
        <aop:after pointcut-ref="anyMethod" method="after"/>
        <aop:around pointcut-ref="anyMethod" method="around"/>
        <aop:after-returning pointcut-ref="anyMethod" method="afterReturning" returning="result"/>
        <aop:after-throwing pointcut-ref="anyMethod" method="afterThrowing" throwing="e"/>
    </aop:aspect>
</aop:config>

　　測試方法和輸出結果同上。

　　Spring和JDBC

　　Spring中也包含了對JDBC數據訪問的支持，它有一個JdbcTemplate的機制，其中提供了大量的API，對ResultSet進行了封裝，可以大大簡化我們的工作量。

　　同時Spring還提供了針對事務的支持，包含了一些Annotation，既可以作用在類上，也可以作用在方法上。

　　下面是一個簡單的示例，我們還是連接MySQL數據庫中的user表，實現對其CRUD操作。

　　首先是定義業務對象以及DAO接口：

public class User {

    private int userID;
    private String userName;
    public void setUserID(int userID) {
        this.userID = userID;
    }
    public int getUserID() {
        return userID;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserName() {
        return userName;
    }
}

public interface UserDao {

    void insertUser(User user);
    void updateUser(User user);
    void deleteUser(User user);
    List<User> getAllUser();
    User getUser(int id);
}

　　然后是建立一個Dao的實現類，這里使用了一些JdbcTemplate API：

@Transactional
public class UserDaoImpl implements UserDao
{
    private JdbcTemplate jdbcTemplate;
    
    public void setDataSource(DataSource dataSource) throws SQLException
    {
        jdbcTemplate = new JdbcTemplate(dataSource);
        System.out.println(dataSource.getConnection().getMetaData().getDriverName());
    }
    
    public void deleteUser(User user) {
        jdbcTemplate.update("delete from user where id=?", 
                    new Object[]{user.getUserID()}, 
                    new int[]{java.sql.Types.INTEGER});
    }

    @SuppressWarnings("unchecked")
    public List<User> getAllUser() {
        return (List<User>)jdbcTemplate.query("select * from user", 
                    new RowMapper()
                    {
                        public Object mapRow(ResultSet rs, int arg) throws SQLException
                        {
                            User user = new User();
                            user.setUserID(rs.getInt("ID"));
                            user.setUserName(rs.getString("NAME"));
                            
                            return user;
                        }
                    });
    }

    public User getUser(int id) {
        try
        {
            return (User)jdbcTemplate.queryForObject("select * from user where id=?", 
                    new Object[]{id}, 
                    new int[]{java.sql.Types.INTEGER},
                    new RowMapper()
                    {
                        public Object mapRow(ResultSet rs, int arg) throws SQLException
                        {
                            User user = new User();
                            user.setUserID(rs.getInt("id"));
                            user.setUserName(rs.getString("name"));
                            return user;
                        }
                    });
        }
        catch(Exception ex)
        {
            System.out.println(ex.getMessage());
        }
        return null;
        
    }

    public void insertUser(User user) {
        jdbcTemplate.update("insert into user (id,name) values(?,?)", 
                new Object[]{user.getUserID(), user.getUserName()},
                new int[]{java.sql.Types.INTEGER, java.sql.Types.VARCHAR});
    }

    public void updateUser(User user) {
        jdbcTemplate.update("update user set name=? where id=?", 
                new Object[]{user.getUserName(), user.getUserID()}, 
                new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});
    }

}

　　JdbcTemplate還提供了一些其他的API，也非常實用。

　　接下來需要修改beans.xml：

<bean id="theDatasource"  class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver" /> 
    <property name="url" value="jdbc:mysql://localhost/test" /> 
    <property name="username" value="root" /> 
    <property name="password" value="123" /> 
    <property name="initialSize" value="2" /> 
    <property name="maxActive" value="100" /> 
    <property name="maxIdle" value="2" /> 
    <property name="minIdle" value="1" /> 
</bean>

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

<tx:annotation-driven transaction-manager="txManager" /> 

<bean id="userDao" class="sample.spring.jdbc.UserDaoImpl">
    <property name="dataSource" ref="theDatasource"/>
</bean>

　　這里theDataSource用來配置數據庫連接信息；txManager來配置事務管理器的信息；userDao是我們的Dao實現類信息。

　　下面是測試方法：

public static void test1()
{
    ApplicationContext ctx = new ClassPathXmlApplicationContext("sample/spring/jdbc/beans.xml");
    UserDao userDao = (UserDao)ctx.getBean("userDao");
    System.out.println("=====get all user=====");
    List<User> users = userDao.getAllUser();
    for(User user:users)
    {
        System.out.println("ID:" + user.getUserID() + ";Name:" + user.getUserName());
    }
    System.out.println("=====insert user=====");
    User user = new User();
    user.setUserID(10);
    user.setUserName("Zhang Fei");
    userDao.insertUser(user);
    user = userDao.getUser(10);
    System.out.println("ID:" + user.getUserID() + ";Name:" + user.getUserName());
    System.out.println("=====update user=====");
    user.setUserName("Devil");
    userDao.updateUser(user);
    user = userDao.getUser(10);
    System.out.println("ID:" + user.getUserID() + ";Name:" + user.getUserName());
    System.out.println("=====delete user=====");
    userDao.deleteUser(user);
    user = userDao.getUser(10);
    if (user == null)
    {
        System.out.println("delete successfully.");
    }
}

　　輸出結果如下：

MySQL-AB JDBC Driver
=====get all user=====
ID:1;Name:Zhang San
ID:2;Name:TEST
=====insert user=====
ID:10;Name:Zhang Fei
=====update user=====
ID:10;Name:Devil
=====delete user=====
Incorrect result size: expected 1, actual 0
delete successfully.

　　說到數據庫事務，我們在上面的UserDaoImpl中可以看到，這個類的前面有一個名為@Transcational的Annotation聲明，這是Spring實現事務的關鍵點，它既可以作用在類上，也可以作用在方法上。

　　@Transactional包含以下參數：

• propagation參數，Propagation類型（枚舉），默認值為Propogation.REQUIRED，支持的值有REQUIRED、MANDATORY、NESTED、NEVER、NOT_SUPPORTED、REQUIRE_NEW、SUPPORTS。
• isolation參數，Isolation類型（枚舉），默認值為Isolation.DEFAULT，支持的值有DEFAULT、READ_COMMITTED、READ_UNCOMMITTED、REPEATABLE_READ、SERIALIZABLE。
• timeout參數，int類型，事務的超時時間，默認值為-1，即不會超時。
• readOnly參數，boolean類型，true表示事務為只讀，默認值為false。
• rollbackFor參數，Class<? extends Throwable>[]類型，默認為空數組。
• rollbackForClassName參數，String[]類型，默認為空數組。
• noRollbackFor參數，Class<? extends Throwable>[]類型，默認為空數組。
• noRollbackForClassName參數，String[]類型，默認為空數組。