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[]类型，默认为空数组。