【Spring】Spring JDBC原理与应用实例讲解

林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka

一、概述

使用Spring进行基本的JDBC访问数据库有多种选择。Spring至少提供了三种不同的工作模式：Spring JDBC抽象框架core包提供了JDBC模板类，其中JdbcTemplate是core包的核心类，所以其他模板类都是基于它封装完成的，JDBC模板类是第一种工作模式。三种模式如下：

  • JdbcTemplate：是Spring中最基本的JDBC模板， 利用JDBC和简单的索引参数查询对数据库进行简单访问
  • NamedParameterJdbcTemplate：能够在查询的时候把值绑定到SQL里的命名参数，而不是索引参数   NamedParameterJdbcTemplate内部包含了一个JdbcTemplate，所以JdbcTemplate能做的事情NamedParameterJdbcTemplate都能干    NamedParameterJdbcTemplate相对于JdbcTemplate主要增加了参数可以命名的功能。
  • SimpleJdbcTemplate：利用Java5的特性，比如自动装箱、通用和可变参数列表来简化JDBC模板的使用SimpleJdbcTemplate内部包含了一个NamedParameterJdbcTemplate;所以NamedParameterJdbcTemplate能做的事情SimpleJdbcTemplate都能干，SimpleJdbcTemplate相对于NamedParameterJdbcTemplate主要增加了JDK5.0的泛型和可变长度参数支持。

下面主要来讲 JdbcTemplate：

JdbcTemplate类通过模板设计模式帮助我们消除了冗长的代码，只做需要做的事情（即可变部分），并且帮我们做哪些固定部分，如连接的创建及关闭。 JdbcTemplate类对可变部分采用回调接口方式实现，如ConnectionCallback通过回调接口返回给用户一个连接，从而可以使用该连 接做任何事情、StatementCallback通过回调接口返回给用户一个Statement，从而可以使用该Statement做任何事情等等，还 有其他一些回调接口如图所示。

JdbcTemplate支持的回调接口

Spring JDBC抽象框架所带来的价值将在以下几个方面得以体现：（注：使用了Spring JDBC抽象框架之后，应用开发人员只需要完成斜体字部分的编码工作。）

  • 定义数据库连接参数
  • 打开数据库连接
  • 声明SQL语句
  • 预编译并执行SQL语句
  • 遍历查询结果（如果需要的话）
  • 处理每一次遍历操作
  • 处理抛出的任何异常
  • 处理事务
  • 关闭数据库连接

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

二、使用步骤

1、使用JdbcTemplate来访问数据

只需要配置DataSource就能够让JdbcTemplate工作，如下配置：

	<!-- 配置数据源 -->
	<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="[email protected]" />
	</bean>

	<!--配置一个JdbcTemplate实例，并将这个“共享的”，“安全的”实例注入到不同的DAO类中去 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource" />
	</bean>

2、现在我们可以把JdbcTemplate装配到DAO，使用它来访问数据库

	@Autowired
	private JdbcTemplate jdbcTemplate;

3、开始操作数据库，如下面的插入

	@Override
	public void insert(Student student) {
		jdbcTemplate.update("INSERT INTO student VALUES(‘" + student.getId()
				+ "‘, ‘" + student.getName() + "‘, ‘" + student.getAge()
				+ "‘, ‘" + student.getSex() + "‘)");
	}

三、使用范例

这里我们要实例Spring Jdbc和Mysql数据库连接，建表、执行插入、查找、删除等功能。

1、新建一个JavaProject工程，导入包mysql-connector-java-5.1.22-bin.jar+spring3.2+commons-logging-1.2.jar

2、首先先建好数据库对应的Model:

package com.mucfc.model;
/**
*数据库传输类
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.5.24
*/
public class Student {
	private int id;
	private String name;
	private int age;
	private String sex;
	public Student(){

	}
	public Student(int id,String name,int age,String sex){
		this.id=id;
		this.name=name;
		this.age=age;
		this.sex=sex;
	}
	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;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}

}

然后还有一个数据库每一行的封装

package com.mucfc.model;
import java.sql.ResultSet;
/**
*封装数据中的一行
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.5.24
*/
import java.sql.SQLException;
/**
 * RowMapper可以将数据中的每一行封装成用户定义的类
 */
import org.springframework.jdbc.core.RowMapper;
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"));
		      student.setSex(rs.getString("sex"));
		      return student;
	   }
	}

3、DAO层：

接口类：

package com.mucfc.dao;
import java.util.List;
import com.mucfc.model.Student;
/**
*DAO接口类
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.5.24
*/
public interface StudentDao {
	/**
	 * 创建数据库表结构
	 * @param sql
	 */
	public void create();
	/**
	 * 插入一条学生数据
	 * @param student
	 */
	public void insert(Student student);
	/**
	 * 通过主键取得对象
	 * @param id
	 * @return student
	 */
	public Student getStudent(Integer id);
	/**
	 * 取得表中所有的学生
	 * @param id
	 * @return student
	 */
	public List<Student> listStudents();
	/**
	 * 通过主键删除对象
	 * @param id
	 */
	public void delete(Integer id);
	/**
	 * 通过主键更改对象
	 * @param id
	 */
	public void update(Student student);

}

实现类：

package com.mucfc.dao;

import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

import com.mucfc.model.Student;
import com.mucfc.model.StudentMapper;
/**
*DAO实现类
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.5.24
*/
@Component
public class StudentDaoImpl implements StudentDao {
	@Autowired
	private JdbcTemplate jdbcTemplate;

	@Override
	public void create() {
		System.out.println("执行建表操作");
		jdbcTemplate
		.execute("DROP TABLE IF EXISTS  student");
		jdbcTemplate
				.execute("CREATE TABLE student (id int primary key, name varchar(100),age int,sex varchar(2))");
	}

	@Override
	public void insert(Student student) {
		System.out.println("================执行插入操作================");
		jdbcTemplate.update("INSERT INTO student VALUES(‘" + student.getId()
				+ "‘, ‘" + student.getName() + "‘, ‘" + student.getAge()
				+ "‘, ‘" + student.getSex() + "‘)");
	}

	@Override
	public Student getStudent(Integer id) {
		System.out.println("================执行查找单个数据操作================");
		String SQL = "select * from Student where id = ?";
	      Student student = jdbcTemplate.queryForObject(SQL,new Object[]{id},new StudentMapper());
	      return student;
	}

	@Override
	public List<Student> listStudents() {
		System.out.println("================执行查找全部操作================");
	    List rows = jdbcTemplate.queryForList("SELECT * FROM student");
	    Iterator it = rows.iterator();
	    while(it.hasNext()) {
	        Map studentMap = (Map) it.next();
	        System.out.print("学生id:"+studentMap.get("id") + "; ");
	        System.out.print("学生name:"+studentMap.get("name") + "; ");
	        System.out.print("学生age:"+studentMap.get("age") + "; ");
	        System.out.println("学生sex:"+studentMap.get("sex"));
	    }
		return rows;
	}

	@Override
	public void delete(Integer id) {
		System.out.println("================执行删除单个数据操作================");
		  String SQL = "delete from Student where id = ?";
		  jdbcTemplate.update(SQL, id);
	      System.out.println("Deleted Record with ID = " + id );
	      return;
	}

	@Override
	public void update(Student student) {
		System.out.println("================执行更新单个数据操作================");
		jdbcTemplate.update(
				"UPDATE student SET name = ?,age=?,sex=? WHERE id = ?",
				new Object[] { student.getName(), student.getAge(),
						student.getSex(), student.getId() });

	}

}

4、Spring配置

新建一个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:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd">
	<!-- 配置数据源 -->
	<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="[email protected]" />
	</bean>

	<!--配置一个JdbcTemplate实例，并将这个“共享的”，“安全的”实例注入到不同的DAO类中去 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 自动扫描注解的bean -->
	<context:component-scan base-package="com.mucfc.dao" />

</beans>

5、测试：

package com.mucfc.service;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.mucfc.dao.StudentDaoImpl;
import com.mucfc.model.Student;

public class Test {

	public static void main(String[] args) {
		 ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
		 StudentDaoImpl studentDaoImpl=(StudentDaoImpl)context.getBean("studentDaoImpl");
		 studentDaoImpl.create();
		 Student student1=new Student(1,"红红",12,"女");
		 studentDaoImpl.insert(student1);
		 studentDaoImpl.insert(new Student(2,"明明",16,"男"));
		 studentDaoImpl.insert(new Student(3,"小王",22,"男"));
		 studentDaoImpl.insert(new Student(4,"小刘",15,"男"));
		 studentDaoImpl.insert(new Student(5,"张三",23,"男"));
		 studentDaoImpl.listStudents();
		System.out.println(studentDaoImpl.getStudent(2));
		studentDaoImpl.update(new Student(2,"大明",15,"男"));
		System.out.println(studentDaoImpl.getStudent(2));
		studentDaoImpl.delete(2);
		 studentDaoImpl.listStudents();
	}

}

输出结果：

林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka

时间： 2024-08-28 04:24:48

【Spring】Spring JDBC原理与应用实例讲解的相关文章

一文解析Spring编程式和声明式事务实例讲解

接上一篇:一文解析Spring事务管理详解:通俗易懂,轻松掌握! Spring事务管理 Spring支持两种方式的事务管理: 编程式事务管理:?通过Transaction Template手动管理事务,实际应用中很少使用, 使用XML配置声明式事务:?推荐使用(代码侵入性最小),实际是通过AOP实现 实现声明式事务的四种方式: 基于 TransactionInterceptor 的声明式事务:?Spring 声明式事务的基础,通常也不建议使用这种方式,但是与前面一样,了解这种方式对理解 Spri

Echache整合Spring缓存实例讲解

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 摘要:本文主要介绍了EhCache,并通过整合Spring给出了一个使用实例. 一.EhCache 介绍 EhCache 是一个纯Java的进程内缓存框架,具有快速.精干等特点,是Hibernate中默认的CacheProvider.Ehcache是一种广泛使用的开源Java分布式缓存.主要面向通用缓存,Java EE和轻量级容器.它具有内存和磁盘存储,缓存加载器,缓存扩展,缓存异常处理程序

Spring Boot 运作原理

Spring Boot 运作原理 1.Spring Boot 简介 SpringBoot是由Pivotal团队提供的全新框架,其设计目的是用来简化新Spring应用的初始搭建以及开发过程.该框架使用了特定的方式来进行配置,从而使开发人员不再需要定义样板化的配置.通过这种方式,Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者.SpringBoot并不是要成为Spring平台里面众多"Foundation"层项目的替代者.S

Spring（二）：AOP(面向切面编程)，Spring的JDBC模板类

1 AOP概述 1.2 什么是AOP 在软件业,AOP为Aspect Oriented Programmig的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型.利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率. AOP解决了OOP遇到一些问题,采取横向抽取机制,取代了传统

Spring?IOC设计原理解析:本文乃学习整理参考而来

Spring IOC设计原理解析:本文乃学习整理参考而来 一. 什么是Ioc/DI? 二. Spring IOC体系结构 (1) BeanFactory (2) BeanDefinition 三. IoC容器的初始化 1. XmlBeanFactory(屌丝IOC)的整个流程 2. FileSystemXmlApplicationContext 的IOC容器流程 1.高富帅IOC解剖 2. 设置资源加载器和资源定位 3.AbstractApplicationContext的refresh函数载入

Spring Boot启动原理解析

Spring Boot启动原理解析http://www.cnblogs.com/moonandstar08/p/6550758.html 前言 前面几章我们见识了SpringBoot为我们做的自动配置,确实方便快捷,但是对于新手来说,如果不大懂SpringBoot内部启动原理,以后难免会吃亏.所以这次博主就跟你们一起一步步揭开SpringBoot的神秘面纱,让它不在神秘. 正文 我们开发任何一个Spring Boot项目,都会用到如下的启动类 从上面代码可以看出,Annotation定义(@Sp

flex3+struts 1.3+spring+ibatis 2.x整合代码实例

原创整理不易,转载请注明出处:flex3+struts 1.3+spring+ibatis 2.x整合代码实例 代码下载地址:http://www.zuidaima.com/share/1778657261997056.htm 经过两天工作闲余时间的奋战,终于flex3+struts 1.3+spring +ibatis 2.x 整合成功,下面介绍下详细的步骤和核心代码: IDE:myeclipse (当然:前提是FLEX+java整合成功的情况下,关于flex+java整合的文章就比较多,go

8、Spring+Struts2+MyBaits(Spring注解+jdbc属性文件+log4j属性文件)

一.注解理论 使用注解来构造IoC容器 用注解来向Spring容器注册Bean.需要在applicationContext.xml中注册<context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>. 如:在base-package指明一个包 1 <context:component-scan base-package="cn.gacl.java"/> 表明cn.gacl.java包

【转】Spring+Mybatis+SpringMVC+Maven+MySql搭建实例

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 摘要:本文主要讲了如何使用Maven来搭建Spring+Mybatis+SpringMVC+MySql的搭建实例,文章写得很详细,有代码有图片,最后也带有运行的效果. 本文工程免费下载 一.准备工作 1. 首先创建一个表: CREATE TABLE `t_user` ( `USER_ID` int(11) NOT NULL AUTO_INCREMENT, `USER_NAME` char(3