对于一个基本的JDBC存取，Connection的取得，Statement的建立，异常处理，Statement的关闭，Connection的关闭这些流程大致在不同的数据库技术上大致是相同的。Spring提供的JdbcTemplate类，被设计为线程安全，当中所提供的一些操作方法封装了类似上面的流程。

●     对于UserDAO.java的JdbcTemplate改进

只需要改进相应的方法就可以了，其它的程序与文件不用变动。

package com.kela.spring.jdbc;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;

import com.kela.spring.util.Util;

public class Test implements IUserDAO {

    private JdbcTemplate jdbcTemplate;

    public void setDataSource(DataSource dataSource) {

        jdbcTemplate = new JdbcTemplate(dataSource);

    }

    public void insert(User user) {

        String name = user.getName();

        int age = user.getAge().intValue();

        String sql = "INSERT INTO user (name, age) VALUES ('" + name + "', " + age + ")";

        // 转码

        sql = Util.GBKToISO(sql);

        jdbcTemplate.update(sql);

    }

    public User find(Integer id) {

        String sql = "SELECT * FROM user WHERE id = " + id.intValue();

        List rs = jdbcTemplate.queryForList(sql);

        Iterator it = rs.iterator();

        if(it.hasNext()) {

            Map userMap = (Map)it.next();

            Integer i = new Integer(userMap.get("id").toString());

            String name = Util.getStr(userMap.get("name").toString());// 转码

            Integer age  = new Integer(userMap.get("age").toString());

            User user = new User();

            user.setId(i);

            user.setAge(age);

            user.setName(name);

            return user;

        }

        return null;

    }

}

●     几种JdbcTemplate执行与更新，查询的演示

A．  使用JdbcTemplate的execute（）方法执行SQL陈述。

jdbcTemploat.execute(sql);

B．  如果是Update或insert，使用update（）方法。

… … …

使用预编译SQL，

public void insert(User user) {

        final String name = user.getName();

        final int age = user.getAge().intValue();

        jdbcTemplate.update(new PreparedStatementCreator() {

            public PreparedStatement createPreparedStatement(Connection conn) throws SQLException {

                String sql = "INSERT INTO user (name, age) VALUES (?, ?)";

                PreparedStatement ps = conn.prepareStatement(sql);

                ps.setString(1, name);

                ps.setInt(2, age);

                return ps;

            }

        }

        );

    }

… … …

public void insert(User user) {

        final String name = user.getName();

        final int age = user.getAge().intValue();

        String sql = "INSERT INTO user (name, age) VALUES (?, ?)";

        jdbcTemplate.update(sql, new PreparedStatementSetter() {

            public void setValues(PreparedStatement ps) throws SQLException {

                ps.setString(1, name);

                ps.setInt(2, age);

            }

        });

    }

… … …

public void insert(User user) {

    String sql = "INSERT INTO user (name, age) VALUES (?, ?)";

    jdbcTemplate.update(sql, new Object[] {user.getName(), user.getAge()});

}

… … …

C．  使用JdbcTemplate进行查询时，可是使用queryForXXX（）等方法。

// 返回一个整型

jdbcTemplate.queryForInt(“select count （*） from user“)；

// 返回一个查询后的结果对象

jdbcTemplate.queryForObject(“select name from user where id = ?”,

new Object[] {id},

java.lang.String.class);

// 返回多笔资料的列表

jdbcTemplate.queryForList （“select * from user”）;

List 中包括的事Map对象，每个Map对象代表查询结果的一行记录。

摘要：Spring的JDBC支持，Spring提供了DAO框架，提供了对数据库存取时异常的封装，提供的JdbcTemplate类大大简化了JDBC在API上的操作等。

一个传统DAO的例子。

如，现在有一个数据库表user，该表有id，name，age三个字段。对该表抽象得出User对象，在进行数据库操作时（find，insert，update，delete）应用程序不应依赖于一个实际的类实现，而是可以让它依赖一个接口，在应用程序中通过对接口的声明来操作。

●     User.java

这是User对象

package com.kela.spring.jdbc;

public class User {

    private Integer id;

    private String name;

    private Integer age;

    public Integer getAge() {

        return age;

    }

    public void setAge(Integer age) {

        this.age = age;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

●     IUserDAO.java

这是IUserDAO接口，负责声明对User对象的操作。

package com.kela.spring.jdbc;

public interface IUserDAO {

    public void insert(User user);

    public User find(Integer id);

public void update(User user);

public void delete(User user);

}

●     UserDAO.java

具体的数据库存取类，实现了IUserDAO接口。

package com.kela.spring.jdbc;

public class UserDAO implements IUserDAO {

public void insert(User user) {

    Connnection conn = null;

    Statement stmt = null;

    try {

        // 执行数据库插入操作

    } catch (SQLException e) {

        //…

    } finally{

        //…

}

}

    public User find(Integer id) {

        // 查询

        return user;

}

public void update(User user) {

    //…

}

public void delete(User user) {

    //…

}

}

●     Test.java

在应用程序中进行数据存取时，可以使用IUserDAO来声明接口，进行数据操作。

… …

User user = new User();

user.setId(new Integer(2));

user.setName(“kela”);

user.setAge(new Integer(28));

IUserDAO userDao = new UserDAO();

userDao.insert(user);

… …

●     学习小结

由于依赖于接口，所以可以随时替换IUserDAO的实现类，在IUserDAO接口声明的操作方法上并没有任何于底层数据库存取的技术细节，Spring的DAO框架这是基于这样的原理，将应用程序与底层存取技术隔离开来。

在JDK1.3之后加入了可协助开发动态代理功能的API，你不必为特定对象与方法编写特定的代理对象，使用动态代理，可以使用一个处理者（Handler）服务于各个对象。

●     LogHandler.java

package com.kela.spring.aop;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import org.apache.log4j.Logger;

public class LogHandler implements InvocationHandler {

    private Logger log = Logger.getLogger(this.getClass().getName());

    private Object delegate;

    public Object bind(Object delegate) {

        this.delegate = delegate;

        return Proxy.newProxyInstance(delegate.getClass().getClassLoader(), delegate.getClass().getInterfaces(), this);

    }

    public Object invoke(Object arg0, Method method, Object[] args)

            throws Throwable {

        Object result = null;

        try {

            log.info("hello 方法开始执行... ...");

            result = method.invoke(delegate, args);

            log.info("hello 方法执行完毕");

        } catch (Exception e) {

            System.out.println("[ERROR]" + e.getMessage());

        }

        return result;

    }

}

●     IHell.java

package com.kela.spring.aop;

public interface IHello {

    public void hello(String name);

}

●     HelloSpeaker.java

package com.kela.spring.aop;

public class HelloSpeaker implements IHello {

    public void hello(String name) {

        System.out.println(" 你好，" + name);

    }

}

●     ProxyDemo.java

package com.kela.spring.aop;

public class ProxyDemo {

    public void method_2() {

        LogHandler logHandler = new LogHandler();

        IHello helloProxy = (IHello)logHandler.bind(new HelloSpeaker());

        helloProxy.hello("kela");

    }

    public static void main(String[] args) {

        ProxyDemo proxyDemo = new ProxyDemo();

        proxyDemo.method_2();

    }

}

●     学习小结

使用代理对象将记录等于业务逻辑无关的动作或任务提取出来，设计为一个服务对象，如LogHandler和上一小节中的HelloProxy，这样的对象称之为切面（Aspect）。

在一个服务的流程中插入与业务逻辑无关的系统服务逻辑（比如 Logging、Security），这样的逻辑称为Cross-cutting concerns，将Cross-cutting concerns独立出来设计为一个对象，这样的特殊对象称之为Aspect，Aspect-oriented programming着重在Aspect的设计及与应用程序的织入（Weave）。

●     静态代理

在静态代理的实现中，代理对象与被代理对象都必须实现同一个接口，在代理对象中可以实现日志记录等相关服务，并在需要的时候再呼叫被代理的对象，如此代理对象当中就可以仅保留业务相关职责。

●     IHello.java

package com.kela.spring.aop;

public interface IHello {

    public void hello(String name);

}

●     HelloSpeaker.java

package com.kela.spring.aop;

public class HelloSpeaker implements IHello {

    public void hello(String name) {

        System.out.println(" 你好，" + name);

    }

}

●     HelloProxy.java

package com.kela.spring.aop;

import org.apache.log4j.Logger;

public class HelloProxy implements IHello {

    private Logger log = Logger.getLogger(this.getClass().getName());

    private IHello helloObject;

    public HelloProxy(IHello helloObject) {

        this.helloObject = helloObject;

    }

    public void hello(String name) {

        // 日志记录

        log.info("hello 方法开始执行... ...");

        // 执行业务逻辑

        helloObject.hello(name);

        // 日志记录

        log.info("hello 方法执行完毕");

    }

}

●     ProxyDemo.java

package com.kela.spring.aop;

public class ProxyDemo {

    public static void main(String[] args) {

        HelloProxy proxy = new HelloProxy(new HelloSpeaker());

        proxy.hello("KELA");

    }

}

●     运行结果

HelloProxy - hello 方法开始执行 ... ...

  你好， KELA

HelloProxy - hello 方法执行完毕

●     学习小结

静态代理中，代理对象的一个接口只服务于一种类型的对象，而且如果要代理的方法很多，势必要为每个方法进行代理，静态代理在程序规模稍大时就无法胜任。

●     Bean 的建立

由BeanFactory读取Bean定义文件，并生成各个Bean实例。

在Spring中，默认取得的实例为Singleton模式，即每一次context.getBean(“beanName”)取得的对象都是同一个，而不是每次都产生一个新的对象。大部分情况下Singleton是能够满足要求的，如果考虑到线程安全等的问题，需使用Prototype模式，即每次取得的对象都是一个独立的对象，只需要将singleton=”false”即可。

如：

<bean id= "someBean" class= "com.kela.spring.ioc.SomeBean" singleton= "false" >

●     属性注入

执行相关的Bean属性依赖注入

●     BeanNameAware 的setBeanName（）

如果Bean类有实现org.springframework.beans.factory.BeanNameAware接口，则执行它的setBaenName（）方法。

实现BeanNameAware接口的Bean类，在依赖关系设定完成后，初始化方法之前，将Bean的定义文件中的名称设定给Bean。

注：Spring中提供了一些Aware相关接口，实现这些Aware接口的Bean类在被初始化之后，可以取得一些Spring所提供的资源或使用某些功能。

一旦实现了提供的相关接口，则应用程序就会使用到Spring的相关API，而与Spring产生耦合关系。

●     BeanFactoryAware 的setBeanFactory（）

如果bean类有实现org.springframework.beans.factory.BeanFactoryAware接口，则执行它的setBeanFactory。

实现BeanFactoryAware接口的Bean类，在依赖关系设定完成后，初始化方法之前，Spring容器将会注入BeanFactory的实例。

●     BeanPostProcessor 的postProcessBeforeInitialization（）

如果任何的org.springfaramwork.beans.factory.config.BeanPostProcessor实例与Bean实例关联，则执行BeanPostProcessors实例的postProcessBeforeInitialization（）方法。

●     InitializingBean 的afterPropertiesSet（）

如果Bean类以实现org.springfaramwork.beans.factory.InitializingBean接口，则执行它的afterPropertiesSet（）方法。

●     Bean 定义文件中定义init-method

可以在Bean定义文件使用“init-method”属性设定方法名称，例如：

<bean id= "someBean" class= "com.kela.spring.ioc.SomeBean" init-method= "initBean" >

如果有以上设定的话，则进行至这个阶段时，就会执行initBean（）方法。

●     BeanPostProcessor 的postProcessAfterInitialization（）

如果任何的org.springfaramwork.beans.factory.config.BeanPostProcessor实例与Bean实例关联，则执行BeanPostProcessors实例的postProcessAfterInitialization（）方法。

●     DisposableBean 的destroy（）

在容器关闭时，如果Bean类有实现org.springframework.beans.factory.DisposableBean接口，则执行它的destroy（）方法。

●     Bean 定义文件中定义destroy-method

在容器关闭时，可以在Bean定义文件中使用“destroy-method”属性设定方法名称，例如：

…

<bean id= "someBean" class= "com.kela.spring.ioc.SomeBean" destroy-method= "destroyBean" >

如果有以上设定的话，则进行至这个阶段时，就会执行destroyBean（）方法。

注意：如果是使用ApplicationContext来生成并管理Bean的话则稍有不同，使用ApplicationContext来生成及管理Bean实例的话，在执行BeanFactoryAware的setBeanFactory（）阶段之后，若Bean类上有实现org.springframework.context.ApplicationContextAware接口，则执行其setApplicationContext（）方法，接着才继续进行BeanPostProcessor的postProcessBeforeInitialization（）及之后的流程。

●     StrudentBean.java

package com.kela.spring.ioc;

public class StudentBean {

    private String name;

    private AddressBean addressBean;

    public AddressBean getAddressBean() {

        return addressBean;

    }

    public void setAddressBean(AddressBean addressBean) {

        this.addressBean = addressBean;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

●     AddressBean.java

package com.kela.spring.ioc;

public class AddressBean {

    private String addressName;

    public String getAddressName() {

        return addressName;

    }

    public void setAddressName(String addressName) {

        this.addressName = addressName;

    }

}

●     beans-config_2.xml

<?xml version= "1.0" encoding= "GB2312" ?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd" >

<beans>

    <bean id= "addressBean" class= "com.kela.spring.ioc.AddressBean" >

       <property name= "addressName" >

           <value> 团结大街向阳路 123 号 </value>

       </property>

    </bean>

    <bean id= "studentBean" class= "com.kela.spring.ioc.StudentBean" >

       <property name= "name" >

           <value> KangFeng </value>

       </property>

       <property name= "addressBean" >

           <!-- 注意这里已不是 value 了，改为 ref -->

           <ref bean= "addressBean" ></ref>

       </property>

    </bean>

</beans>

●     TestClass.java

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.FileSystemXmlApplicationContext;

public class TestClass {

    public void method_2() {

        try {

            ApplicationContext context = new FileSystemXmlApplicationContext("bin\\com\\kela\\spring\\ioc\\beans-config_2.xml");

            StudentBean studentBean = (StudentBean)context.getBean("studentBean");

            System.out.println(" 姓名：" + studentBean.getName() + ";地址：" + studentBean.getAddressBean().getAddressName());

        } catch (Exception e) {

            System.out.println("[ERROR]" + e.getMessage());

        }

    }

    public static void main(String[] args) {

        TestClass testClass = new TestClass();

        testClass.method_2();

    }

}

●     学习小结

“Don’t Call Me，I‘ll Call You”。

●     HelloBean.java

package com.kela.spring.ioc;

public class HelloBean {

    private String name;

    private String helloWord;

    public HelloBean() {

    }

    public HelloBean(String name, String helloWord) {

        this.name = name;

        this.helloWord = helloWord;

    }

    public String getHelloWord() {

        return helloWord;

    }

    public void setHelloWord(String helloWord) {

        this.helloWord = helloWord;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

该程序文件中讲两种常用的注入方式写在了一起。

●     Beans-config_1.xml

<?xml version= "1.0" encoding= "GB2312" ?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd" >

<beans>

    <!-- Type 3 Injection 通过构造方法（这里注意构造方法中参数的顺序保持一致） -->

    <bean id= "helloBean_1" class= "com.kela.spring.ioc.HelloBean" >

       <constructor-arg index= "0" >

           <value> KangFeng </value>

       </constructor-arg>

       <constructor-arg index= "1" >

           <value> 你好！ </value>

       </constructor-arg>

    </bean>

    <!-- Type2 Injection 通过 set 注入法 -->

    <bean id= "helloBean_2" class= "com.kela.spring.ioc.HelloBean" >

       <property name= "name" >

           <value> Kela </value>

       </property>

       <property name= "helloWord" >

           <value> hello ！ </value>

       </property>

    </bean>

</beans>

●     TestClass.java

package com.kela.spring.ioc;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.FileSystemXmlApplicationContext;

public class TestClass {

    public void method_1() {

        try {

            ApplicationContext context = new

                                       FileSystemXmlApplicationContext("bin\\com\\kela\\spring\\ioc\\beans-config_1.xml");

            HelloBean helloBean_1 = (HelloBean)context.getBean("helloBean_1");

            System.out.println(" 构造方法注入（欢迎词）：" + helloBean_1.getName() + ";" + helloBean_1.getHelloWord());

            HelloBean helloBean_2 = (HelloBean)context.getBean("helloBean_2");

            System.out.println("set 方法注入（欢迎词）：" + helloBean_2.getName() + ";" + helloBean_2.getHelloWord());

        } catch (Exception e) {

            System.out.println("[ERROR]" + e.getMessage());

        }

    }

    public static void main(String[] args) {

        TestClass testClass = new TestClass();

        testClass.method_1();

    }

}

●     学习小结

关于Constructor和Setter注入的区别其实就是说，是要在对象建时是就准备好资源还是在对象建立好之后，再使用Setter方法来进行设定。

从实际使用角度来看，一个适用于较短的属性列，一个适用于较长的属性列。

1.       准备工作

从下载的 spring 开发包 bin 目录下将相关 lib 加入至项目的 ClassPath 中。

我加入的 lib 文件有：

spring.jar （这个文件包括了所有 Spring 支持的功能所需要的类，而不再需要加入个别的 jar 文件，关于 Spring 各个具体的 jar 包的使用范围，可查询 Spring 的中文文档）

commons-logging.jar ； log4j.jar （ log 日志所需）

编写 log4j 配置文件 log4j.properties ，将其放入 src 下， log4j.properties 内容如下：

log4j.rootLogger= ERROR, stdout

log4j.appender.stdout= org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout= org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern= %c {1} - %m%n

我的工程目录结构如下：

    SpringProject（工程名称）
       src
          log4j.properties
       lib
          commons-logging.jar
          log4j-1.2.9.jar
          spring.jar
          

2.       编写第一个 Spring 程序

这是一个简单的 JavaBean ，用来打声招呼。

●     HelloBean.java

package com.kela.spring.helloword;

public class HelloBean {

       private String helloWord;

       public String getHelloWord() {

              return helloWord;

       }

       public void setHelloWord(String helloWord) {

              this.helloWord = helloWord;

       }

}

●     beans-config.xml

<?xml version= "1.0" encoding= "GB2312" ?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd" >

<beans>

      <bean id= "helloBean"

class= "com.kela.spring.helloword.HelloBean" >

           <property name= "helloWord" >

               <value> 你好， Spring 爱好者！ </value>

           </property>

        </bean>

</beans>

●     TestClass.java

    package com.kela.spring.helloword;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.FileSystemXmlApplicationContext;

public class TestClass {

           public static void main(String[] args) {

                  try {

                         ApplicationContext context = new

FileSystemXmlApplicationContext("bin\\com\\kela\\spring\\helloword\\beans-config.xml");

                         HelloBean helloBean = (HelloBean)context.getBean("helloBean");

                         System.out.println(" 打印欢迎词： " + helloBean.getHelloWord());

                  } catch (Exception e) {

                         System.out.println("[ERROR]" + e.getMessage());

                  }

           }

}

3.       测试

运行 TestClass.java 文件，内容如下：

打印欢迎词：你好， Spring 爱好者！

4.        学习小结

通过配置的形式，对 HelloBean.java 文件中属性 helloWord 注入了一段文件（你好， spring 爱好者）， HelloBean.java 文件中没有任何与 Spring 有关的东西，在测试类中对 HelloBean 的声明是由 Spring 自动完成的。