J2EE系列之Spring4学习笔记（九）--Spring对JDBC的支持

最新推荐文章于 2020-08-12 10:39:14 发布

Java小飞侠

最新推荐文章于 2020-08-12 10:39:14 发布

阅读量595

点赞数

分类专栏： Java程序开发文章标签： Spring对JDBC的支持 Spring对DAO的支持

本文链接：https://blog.csdn.net/feidie436/article/details/72840985

版权

Java程序开发专栏收录该内容

83 篇文章 0 订阅

订阅专栏

JDBC是最原始的操作数据库的一种技术，现在讲一下Spring对JDBC 的支持，Spring把对数据库的各种操作封装在了JdbcTemplate类中。

一、配置数据源dbcp

所谓的配置数据源就是把数据库的地址、用户名、密码以及要操作的数据库告知Spring。Spring使用数据库连接池完成对数据库的连接。

1.新建工程Spring404；

2.首先看一下Spring给出的配置数据源实例，打开Spring中的实例网页，在下载的Spring安装包的位置为：spring-framework-4.0.6.RELEASE\docs\spring-framework-reference\htmlsingle\index.html。在这个网页中找到配置数据源部分：

这个是官方示例给出的配置数据源方法（3），要想配置数据源还需要引入新的命名空间以及文件（1、2）

按照上面的配置文件，把命名空间配置到我们工程的Spring配置文件中。

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
        
    <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>
    <context:property-placeholder location="jdbc.properties"/>
	
	
</beans>

这里面destroy-method属性的意义是当连接用完后，把连接重新放回连接池。配置连接池用到了Apache的BasicDataSource类，所以工程中加入新的jar包：

配置文件中BasicDataSource类中的各个属性使用属性赋值进行了赋值，这里不同的是它并没有直接赋值，而是采用了EL表达式的形式。下面有个<context>标签用来加载指定的文件。在工程src目录下新建jdbc.properties文件：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db_spring
jdbc.username=root
jdbc.password=123456

我这里安装的是mysql数据库，这里面配置好数据库的驱动以及数据库的地址、用户名和密码。

这里用到的mysql的驱动，工程中新添加jar包：

在mysql数据库中新建一个db_spring数据表，并新建一个t_student表格：

二、使用JdbcTemplate

1.上面完成了数据源的配置，接下来就开始对数据库中的数据进行操作。Spring把对数据库的各种操作封装在了JdbcTemplate类中，首先工程中引入新的jar包：

2.配置Spring，引入JdbcTemplate类的实例：

 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    	<property name="dataSource" ref="dataSource"></property>
    </bean>

这里使用引用方法给JdbcTemplate的属性dataSrouce属性注入值。

3.新建类Student：

package com.test.model;

public class Student {

	private int id;
	private String name;
	private int age;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}


	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	
	
}

3.Spring推荐使用基于接口的编程，新建接口StudentDao：

package com.test.dao;

import java.util.List;

import com.test.model.Student;

public interface StudentDao {

	public int addStudent(Student student);
	public int updateStudent(Student student);
	public int deleteStudent(int id);
	public List<Student> findStudents();
}

4.新建StudentDao接口的实现类：

package com.test.dao.impl;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;

import com.test.dao.StudentDao;
import com.test.model.Student;

public class StudentDaoImpl implements StudentDao{

	private JdbcTemplate jdbcTemplate;
	
	
	
	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}

	@Override
	public int addStudent(Student student) {
		
		return 0;
		 
	}

	@Override
	public int updateStudent(Student student) {
		
		return 0;
	}

	@Override
	public int deleteStudent(int id) {
		
		return 0;
	}

	@Override
	public List<Student> findStudents() {
		
		return Null;
	}

}

5.新建StudentService接口：

package com.test.service;

import java.util.List;

import com.test.model.Student;

public interface StudentService {

	public int addStudent(Student student);
	public int updateStudent(Student student);
	public int deleteStudent(int id);
	public List<Student> findStudents();
}

因为这个工程的业务比较简单，这里StudentService接口和StudentDao接口是相同的。

6.新建StudentService接口的实现类：

package com.test.service.impl;

import java.util.List;

import com.test.dao.StudentDao;
import com.test.model.Student;
import com.test.service.StudentService;

public class StudentServiceImpl implements StudentService{

	private StudentDao studentDao;
	
	
	
	public void setStudentDao(StudentDao studentDao) {
		this.studentDao = studentDao;
	}

	@Override
	public int addStudent(Student student) {
		// TODO Auto-generated method stub
		return studentDao.addStudent(student);
	}

	@Override
	public int updateStudent(Student student) {
		// TODO Auto-generated method stub
		return studentDao.updateStudent(student);
	}

	@Override
	public int deleteStudent(int id) {
		// TODO Auto-generated method stub
		return studentDao.deleteStudent(id);
	}

	@Override
	public List<Student> findStudents() {
		// TODO Auto-generated method stub
		return studentDao.findStudents();
	}

}

7.写测试方法：

package com.test.test;

import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.test.model.Student;
import com.test.service.StudentService;


public class T {

	private ApplicationContext ac;

	@Before
	public void setUp() throws Exception {
		ac=new ClassPathXmlApplicationContext("beans.xml");
	}

	@Test
	public void addStudent(){
		
	}
	
	

}

8.配置Spring文件，添加自己的bean：

<bean id="studentDao" class="com.test.dao.impl.StudentDaoImpl">
		<property name="jdbcTemplate" ref="jdbcTemplate"></property>
	</bean>
	<bean id="studentService" class="com.test.service.impl.StudentServiceImpl">
		<property name="studentDao" ref="studentDao"></property>
	</bean>

这里使用引用的方式给里面的类对象进行赋值。

9.上面已经把Spring使用jdbc的框架搭建完成。接下来写实现数据库操作的代码。首先实现以下添加学生，修改StudentDaoImpl类中addStudent方法：

@Override
	public int addStudent(Student student) {
		String sql = "insert into t_student values(null,?,?)";
		Object []params = new Object[]{student.getName(),student.getAge()};
		return jdbcTemplate.update(sql,params);
		 
	}

这里要写操作的sql语句，把sql语句中要添加的值放在params数组中。然后调用JdbcTemplate类中的update方法即可。

这里使用Spring操作数据库也简单了，只要写好sql语句，写好参数然后直接调用JdbcTemplate类中封装好的方法即可。

测试方法中需要新建Student类的对象，给Student类添加构造方法为：

public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

添加学生的时候只需要添加学生的姓名和年龄，id由mysql自动添加。这里只生成默认的构造函数和有两个参数的构造函数。

修改测试方法为：

@Test
	public void addStudent(){
		StudentService studentService = (StudentService) ac.getBean("studentService");
		int addNums = studentService.addStudent(new Student("张三",20));
		if(addNums == 1){
			System.out.println("添加成功");
		}
	}

运行测试方法，控制台输出添加成功，查看数据库中的表格：

数据添加成功。

10.更新学生信息：修改StudentDaoImpl类中updateStudent方法

@Override
	public int updateStudent(Student student) {
		String sql = "update t_student set name=?,age=? where id=?";
		Object []params = new Object[]{student.getName(),student.getAge(),student.getId()};
		return jdbcTemplate.update(sql,params);
	}

写好sql语句后直接调用JdbcTemplate类的方法即可。这里更新操作方法和添加操作方法相同，都是update方法。

更新学生信息需要学生的id，Student类中新建构造函数：

public Student(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}

写测试方法为：

@Test
	public void updateStudent(){
		StudentService studentService = (StudentService) ac.getBean("studentService");
		int updateNums = studentService.updateStudent(new Student(1,"李四",10));
		if(updateNums == 1){
			System.out.println("修改成功");
		}
	}

运行测试方法：

11.删除操作

StudentDaoImpl类中写删除操作函数：

@Override
	public int deleteStudent(int id) {
		String sql = "delete from t_student where id=?";
		Object []params = new Object[]{id};
		return jdbcTemplate.update(sql,params);
	}

这里写好sql语句后调用JdbcTemplate类中的update方法。

写个测试方法：

@Test
	public void deleteStudent(){
		StudentService studentService = (StudentService) ac.getBean("studentService");
		int deleteNums = studentService.deleteStudent(1);
		if(deleteNums == 1){
			System.out.println("删除成功");
		}
	}

这边只要传入一个id即可。

运行测试方法：

可以看到李四被删掉了。

12.遍历所有学生：首先在数据库中添加如下学生信息

修改数据库操作方法：

@Override
	public List<Student> findStudents() {
		String sql = "select * from t_student";
		final List<Student> studentList = new ArrayList<Student>();
		jdbcTemplate.query(sql, new RowCallbackHandler(){

			@Override
			public void processRow(ResultSet rs) throws SQLException {
				Student student = new Student();
				student.setId(rs.getInt("id"));
				student.setName(rs.getString("name"));
				student.setAge(rs.getInt("age"));
				studentList.add(student);
			}
			
		});
		return studentList;
	}

这里遍历学生要复杂一些，调用的是JdbcTemplate类的query方法，还要写这个方法中的回调方法。这里studentList变量要定义成final类型，否则的话会报错，这涉及到底层编译内部类的时候访问共享这个对象。

写测试方法：

@Test
	public void findStudents(){
		StudentService studentService = (StudentService) ac.getBean("studentService");
		List<Student> studentList = studentService.findStudents();
		for(Student s:studentList){
			System.out.println(s);
		}
	}

运行测试方法：