Spring JDBC入门

Spring将替我们完成所有使用JDBC API进行开发的单调乏味的、底层细节处理工作。

操作JDBC时Spring可以帮我们做这些事情：

定义数据库连接参数，打开数据库连接，处理异常，关闭数据库连接

我们仅需要关注：

声明SQL语句，处理每一次得到的结果

一个较为简单的例子与讲解

JdbcTemplate类

JdbcTemplate是core包的核心类。它替我们完成了资源的创建以及释放工作，从而简化了我们对JDBC的使用。它还可以帮助我们避免一些常见的错误，比如忘记关闭数据库连接。JdbcTemplate将完成JDBC核心处理流程，比如SQL语句的创建、执行，而把SQL语句的生成以及查询结果的提取工作留给我们的应用代码。它可以完成SQL查询、更新以及调用存储过程，可以对ResultSet进行遍历并加以提取。它还可以捕获JDBC异常并将其转换成org.springframework.dao包中定义的，通用的，信息更丰富的异常。

代码分为三部分

第一部是利用Spring处理业务，第二部分创建Spring相关的XML，第三部分将XML和Context结合到一起。

package com.jiaozg.dao;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.springframework.jdbc.core.JdbcTemplate;

import com.jiaozg.model.Dept;
import com.jiaozg.util.SpringUtil;

主要类：
public class DeptDao {
    
    private JdbcTemplate jdbcT;
    
    public void setJdbcT(JdbcTemplate jdbcT) {
        this.jdbcT = jdbcT;
    }

    public  List findALL() {
        String sql = "select * from dept";
        return jdbcT.queryForList(sql);
    }
    
    public List<Dept> findALLDepts() {
        List<Dept> depts = new ArrayList<Dept>();;
        String sql = "select * from Dept";
        List list = jdbcT.queryForList(sql); 
        Iterator iterator = list.iterator();
        Dept dept = null;
        while (iterator.hasNext()) {
            Map map4dept = (Map) iterator.next();
            dept = new Dept();       
            dept.setDeptNo(((BigDecimal) map4dept.get("DEPTNO")).intValue());
            dept.setDName((String)map4dept.get("DNAME"));
            dept.setLoc((String)map4dept.get("LOC"));        
            depts.add(dept);
        }
        return depts;
    }    
    public int delete(int bid){
        String sql = "delete from DeptInfo where bid =?";
        return jdbcT.update(sql, new Object[]{bid});
    }     
    
    public static void main(String[] args) {      
        DeptDao dao = (DeptDao) SpringUtil.getBean("deptDao");
        List<Dept> depts = dao.findALLDepts();;
        for(Dept dept:depts){
            System.out.println(dept.getDeptNo()+","+dept.getDName()+","+dept.getLoc());
        }
        System.out.println("---------------------------------");
        
        List list = dao.findALL();
        for(Iterator it = list.iterator(); it.hasNext(); ) {
            System.out.println(it.next());
        }
    }
}

public class SpringUtil {
     private static ApplicationContext  ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        public static Object getBean(String beanName){
             return ctx.getBean(beanName);
        }    
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="springDSN"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName"
            value="oracle.jdbc.driver.OracleDriver">
        </property>
        <property name="url"
            value="jdbc:oracle:thin:@127.0.0.1:1521:orcl">
        </property>
        <property name="username" value="scott"></property>
        <property name="password" value="Qwer1234"></property>
    </bean>

    <bean id="jdbcTemplate"
        class="org.springframework.jdbc.core.JdbcTemplate" abstract="false"
        lazy-init="false" autowire="default" dependency-check="default">
        <property name="dataSource">
            <ref bean="springDSN" />
        </property>
    </bean>
    
    <bean id="deptDao" class="com.jiaozg.dao.DeptDao">
       <property name="jdbcT">
          <ref bean="jdbcTemplate" />
       </property>
    </bean>
    
</beans>

总结：

JAVA逻辑部分还能看懂，但XML就有些迷糊：XML第一部分是配置到数据库的连接信息，第二三部分就不知道了。

还有DAO是什么意思？

应该还缺少数据库中表的定义，这个定义应该对应着DEBT的javabean.

一个更加详细的例子

CREATE TABLE Student(
   ID   INT NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(20) NOT NULL,
   AGE  INT NOT NULL,
   PRIMARY KEY (ID)
);

Student表，有ID, NAME, AGE三项

对应的JAVABEAN

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }

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

   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

StudentMapper.java的内容

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

将搜索结果ResultSet转化为Object

StudentJDBCTemplate.java

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }

   public void create(String name, Integer age) {
      String SQL = "insert into Student (name, age) values (?, ?)";
      
      jdbcTemplateObject.update( SQL, name, age);
      System.out.println("Created Record Name = " + name + " Age = " + age);
      return;
   }

   public Student getStudent(Integer id) {
      String SQL = "select * from Student where id = ?";
      Student student = jdbcTemplateObject.queryForObject(SQL, 
                        new Object[]{id}, new StudentMapper());
      return student;
   }

   public List<Student> listStudents() {
      String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, 
                                new StudentMapper());
      return students;
   }

   public void delete(Integer id){
      String SQL = "delete from Student where id = ?";
      jdbcTemplateObject.update(SQL, id);
      System.out.println("Deleted Record with ID = " + id );
      return;
   }

   public void update(Integer id, Integer age){
      String SQL = "update Student set age = ? where id = ?";
      jdbcTemplateObject.update(SQL, age, id);
      System.out.println("Updated Record with ID = " + id );
      return;
   }

}

Spring和JAVABEAN的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <bean id="dataSource" 
      class="org.springframework.jdbc.datasource.DriverManagerDataSource">
      <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
      <property name="url" value="jdbc:mysql://localhost:3306/TEST"/>
      <property name="username" value="root"/>
      <property name="password" value="password"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id="studentJDBCTemplate" 
      class="com.yiibai.StudentJDBCTemplate">
      <property name="dataSource"  ref="dataSource" />    
   </bean>
      
</beans>

main.java

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
             new ClassPathXmlApplicationContext("Beans.xml");

      StudentJDBCTemplate studentJDBCTemplate = 
      (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      System.out.println("------Records Creation--------" );
      studentJDBCTemplate.create("Zara", 11);
      studentJDBCTemplate.create("Nuha", 2);
      studentJDBCTemplate.create("Ayan", 15);

      System.out.println("------Listing Multiple Records--------" );
      List<Student> students = studentJDBCTemplate.listStudents();
      for (Student record : students) {
         System.out.print("ID : " + record.getId() );
         System.out.print(", Name : " + record.getName() );
         System.out.println(", Age : " + record.getAge());
      }

      System.out.println("----Updating Record with ID = 2 -----" );
      studentJDBCTemplate.update(2, 20);

      System.out.println("----Listing Record with ID = 2 -----" );
      Student student = studentJDBCTemplate.getStudent(2);
      System.out.print("ID : " + student.getId() );
      System.out.print(", Name : " + student.getName() );
      System.out.println(", Age : " + student.getAge());
      
   }
}

还有一个带有用法的main.java，我就不贴了

总结

1. 将JAVA的类与数据库中的表项绑定到一起，这样更加方便操作

2. 表到类的转换过程需要rawMapper,它起作用体现在query或queryForObject

3. SQL语句用到了(name, age) (?, ?)的东西，这个倒是有点像C++11中的bind用法，QueryForObject也用到了类似的写法，但是稍微复杂点

queryForObject(SQL, new Object[]{id}, new StudentMapper()}; 这里的id被填充到一个数组中，数组为SQL提供数据

4. Context读取XML文件，Template依靠Context获得Bean,这个bean不是数据的定义，而是操作的定义。

一些细节：

1. ResultSet就是执行SQL语句返回的结果集

2. ResultSetMetaData 用于返回记录集的自身信息

3. DataSource 这个的介绍有点复杂，总体来看还是为了安全性与封装

连接数据库通常需要实现以下几个步骤：

1. 注册数据库驱动程序（driver）。可以通过调用java.sql.DriverManager类的registerDriver方法显式注册驱动程序，也可以通过加载数据库驱动程序类隐式注册驱动程序。
2．建立连接。调用java.sql.DriverManager类的getConnection（）方法可以建立与数据库的连接。

从实际应用的角度出发，我们可以看出采取这种方式连接到数据库存在几个问题。
第一是安全性问题，由于程序代码中包含用户名和密码，其他人如果能得到bytecode，可以通过反编译工具获得用户名和密码。第二是代码的可移植性问题。如果希望连接的数据库名称或用户名有所更改，程序员需要修改源程序，然后把修改过的程序发送给用户。也就是说，软件无法脱离数据库独立存在。这样不仅会大大提高软件的成本，也不利于软件本身的发展。还可能出现这样的情况：在某些情况下，提供数据的机构不希望数据库的用户名和密码让编写程序的程序员知道知道。
这样就提出了一个问题，如何使Java和数据库之间建立连接时隐藏一些敏感的信息。

数据源（Data Source）及JNDI数据源是在JDBC 2.0中引入的一个概念。

在JDBC 2.0扩展包中定义了javax.sql.DataSource接口来描述这个概念。

如果用户希望建立一个数据库连接，通过查询在JNDI服务中的数据源，可以从数据源中获取相应的数据库连接。
这样用户就只需要提供一个逻辑名称（Logic Name），而不是数据库登录的具体细节。

在这里有必要简单介绍一下JNDI。JNDI的全称是Java Naming and Directory Interface，可以理解为Java名称和目录服务接口。JNDI向应用程序提供了一个查询和使用远程服务的机制。这些服务可以是任何企业服务。对于JDBC应用程序来说，JNDI提供的是数据库连接服务。当然JNDI也可以向数据库提供其他服务，但是这超出了本文范围，在此不做论述。其实JNDI并不难理解。简单来说，名称服务提供了一个把文件，打印机，服务器等实体映射到一个逻辑名称的机制。例如在操作系统中的名称服务就把打印机映射到一个I/O端口。而目录服务可以理解为名称服务的一个扩展，它允许在服务中的各项拥有自己的属性。又以打印机为例，打印机可以是彩色打印机，支持双面打印，支持网络打印，支持高速打印等。所有这些打印机的属性都可以储存在目录服务中，和相应的打印机联系起来。一些常见的目录服务有NIS，NIS+，LDAP和Novell的NDS等。JNDI使应用程序通过使用逻辑名称获取对象和对象提供的服务，从而使程序员可以避免使用与提供对象的机构有关联的代码。例如在下面的例子中使用了在JNDI中的数据源，程序员就不需要提供Oracle8i驱动程序的名称，这样代码的移植能力就更强。

下面详细介绍一下数据源和javax.sql.DataSource接口。

在数据源中存储了所有建立数据库连接的信息。就象通过指定文件名你可以在文件系统中找到文件一样，通过提供正确的数据源名称，你可以找到相应的数据库连接。javax.sql.DataSource接口定义了如何实现数据源。

在该接口中定义了九个属性。
dataSourceName String 数据源接口实现类的名称。
description String 对数据源的描述。
networkProtocol String 和服务器通讯使用的网络协议名。
password String 用户登录密码。
portNumber Int 数据库服务器使用的端口，缺省值为1521。
serverName String 数据库服务器名称。
user String 用户登录名。

在javax.sql.DataSource接口中定义了很多方法通过这些方法，程序员可以获得建立连接需要的所有信息。
需要注意的是，程序员不可以获取登陆密码，这就在一定程度上保证了安全性。需要注意的另一点是所有的方法都是synchronized方法，这是为了保证应用程序的线程安全（Thread-safe）。
如果在调用该方法时，即使数据源实例发生变化不会影响程序的正确运行。
然后通过该数据源对象进行数据库操作。在这个例子中，程序和名称服务环境都是在同一台计算机上运行。
在实际的应用中，程序可以通过RMI或CORBA向名称服务环境注册或查询对象。例如在一个服务器-客户机结构中,客户机上的应用程序只需要知道数据源对象在服务器名称服务环境中的逻辑名称,就可以通过RMI向服务器查询数据源,然后通过建立与数据库的连接.这样就可以解决本文最开始提出的问题。