SpringJdbcTemplate模板类使用小记

最新推荐文章于 2020-12-30 18:08:25 发布

曲健磊的个人博客

最新推荐文章于 2020-12-30 18:08:25 发布

阅读量432

点赞数

分类专栏：【spring】 Spring历程文章标签： spring jdbc

本文链接：https://blog.csdn.net/a909301740/article/details/78640779

版权

【spring】同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

Spring历程

9 篇文章 2 订阅

订阅专栏

1.环境搭建

导入所需jar包:

commons-logging-1.2.jar
aopalliance-1.0.jar
spring-aop.4.2.1.RELEASE.jar
spring-beans.4.2.1.RELEASE.jar
spring-core.4.2.1.RELEASE.jar
spring-context.4.2.1.RELEASE.jar
spring-expression.4.2.1.RELEASE.jar
spring-jdbc.4.2.1.RELEASE.jar
spring-tx.4.2.1.RELEASE.jar
mysql-connector-java-5.0.8-bin.jar
junit-4.7.jar
hamcrest-core-1.3.jar（与junit-4.7.jar配套）

2.配置文件

开启注解扫描，注册通过注解方式声明的dao和service类
加载jdbc.properties配置文件
注册spring自带的数据源
注册spring的jdbc模板类，并注入数据源（因为模板类需要在增删改查前开连接，之后关连接，依赖数据源）

jdbc配置文件的内容：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/test
jdbc.username=root
jdbc.password=123

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:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	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/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd"> 
	
	<!-- 通过注解的方式注册的bean（dao,service） -->
	<context:component-scan base-package="com.lyu.template" />
	
	<!-- 加载编译路径下的jdbc配置文件(驱动,url,username,password) -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	
	<!-- 注册Spring自带的数据源：用于开连接，关连接 -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="${jdbc.driver}"></property>
		<property name="url" value="${jdbc.url}"></property>
		<property name="username" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
	
	<!-- 注册jdbc模板类，并注入数据源 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
</beans>

3.实体类

package com.lyu.template.entity;

import java.io.Serializable;

public class User implements Serializable {

	private static final long serialVersionUID = 8608786494105727736L;
	
	private Long userId;
	private String userName;
	private String loginName;
	private String password;
	
	public Long getUserId() {
		return userId;
	}
	public void setUserId(Long userId) {
		this.userId = userId;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getLoginName() {
		return loginName;
	}
	public void setLoginName(String loginName) {
		this.loginName = loginName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	
}

4.dao

dao接口：增加用户，删除用户，修改用户，查询用户列表，查询用户列表（以map的形式返回）

package com.lyu.template.dao;

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

import com.lyu.template.entity.User;

public interface IUserDao {
	
	// 增加用户
	boolean addUser(User user);
	
	// 删除用户
	boolean delUser(User user);
	
	// 更新用户
	boolean updateUser(User user);
	
	// 查询用户列表
	List<User> listUser();
	
	// 将用户信息以 "字段-值" 的方式查询出来
	List<Map<String, Object>> listUserMap();
	
}

dao实现类-jdbcTemplate的几个方法：

int update(String sql, Object…args) 增删改
List< T> query(String sql, RowMapper rowMapper, Object…args) 查询用户列表，rowMapper是一个接口，作用是将一条结果集映射成一个对象，可以通过new匿名内部类的形式来创建RowMapper也可以直接使用子类BeanPropertyRowMapper直接映射，详见代码。
List< Map< String, Object>> queryForList(String sql) 同样是返回用户列表，不过返回的是map结构的列表（字段-值的形式）

package com.lyu.template.dao.impl;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import com.lyu.template.dao.IUserDao;
import com.lyu.template.entity.User;

@Repository("userDao")
public class UserDaoImpl implements IUserDao {
	
	@Autowired
	private JdbcTemplate jdbcTemplate;
	
	@Override
	public boolean addUser(User user) {
		boolean flag = false;
		String addSql = "insert into user(user_name, login_name, password) values(?,?,?)";
		int rows = jdbcTemplate.update(addSql, user.getUserName(), user.getLoginName(), user.getPassword());
		if (rows > 0) {
			flag = true;
		}
		return flag;
	}

	@Override
	public boolean delUser(User user) {
		boolean flag = false;
		String delSql = "delete from user where user_id = ?";
		int rows = jdbcTemplate.update(delSql, user.getUserId());
		if (rows > 0) {
			flag = true;
		}
		return flag;
	}

	@Override
	public boolean updateUser(User user) {
		boolean flag = false;
		String updateSql = "update user set user_name = ? where user_id = ?";
		int rows = jdbcTemplate.update(updateSql, user.getUserName(), user.getUserId());
		if (rows > 0) {
			flag = true;
		}
		return flag;
	}

	@Override
	public List<User> listUser() {
		List<User> userList = null;
		String listUserSql = "select user_id, user_name, login_name from user";
		// new一个匿名内部类实现结果集到对象的映射
		userList = jdbcTemplate.query(listUserSql, new RowMapper<User>(){

			@Override
			public User mapRow(ResultSet result, int rows) throws SQLException {
				User user = new User();
				user.setUserId(result.getLong("user_id"));
				user.setUserName(result.getString("user_name"));
				user.setLoginName(result.getString("login_name"));
				return user;
			}
			
		});
		
		// 可以使用RowMapper的子类BeanPropertyRowMapper来直接映射
		userList = jdbcTemplate.query(listUserSql, new BeanPropertyRowMapper<User>(User.class));
		return userList;
	}

	@Override
	public List<Map<String, Object>> listUserMap() {
		List<Map<String, Object>> userListMap = null;
		String listUserMapSql = "select user_id, user_name, login_name from user";
		userListMap = jdbcTemplate.queryForList(listUserMapSql);
		return userListMap;
	}

}

List< User>形式的返回：

这里写图片描述

List< Map< Sting,Object>>形式的返回：

这里写图片描述

5.Service

接口

package com.lyu.template.service;

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

import com.lyu.template.entity.User;

public interface IUserService {

	// 增加用户
	boolean addUser(User user);
	
	// 删除用户
	boolean delUser(User user);
	
	// 更新用户
	boolean updateUser(User user);
	
	// 查询用户列表
	List<User> listUser();
	
	// 将用户信息以 "字段-值" 的方式查询出来
	List<Map<String, Object>> listUserMap();
	
}

实现类

package com.lyu.template.service.impl;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.lyu.template.dao.IUserDao;
import com.lyu.template.entity.User;
import com.lyu.template.service.IUserService;

@Service("userService")
public class UserServiceImpl implements IUserService {
	
	@Autowired
	private IUserDao userDao;
	
	@Override
	public boolean addUser(User user) {
		return userDao.addUser(user);
	}

	@Override
	public boolean delUser(User user) {
		return userDao.delUser(user);
	}

	@Override
	public boolean updateUser(User user) {
		return userDao.updateUser(user);
	}

	@Override
	public List<User> listUser() {
		return userDao.listUser();
	}

	@Override
	public List<Map<String, Object>> listUserMap() {
		return userDao.listUserMap();
	}

}

6.Test测试

package com.lyu.template.test;

import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

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

import com.lyu.template.entity.User;
import com.lyu.template.service.IUserService;

public class JdbcTemplateTest {

	ApplicationContext ac = null;
	
	@Before
	public void init() {
		ac = new ClassPathXmlApplicationContext("applicationContext.xml");
	}
	
	// 测试增加用户
	@Test
	public void testAddUser() {
		IUserService userService = (IUserService) ac.getBean("userService");
		User user = new User();
		user.setUserName("eee");
		user.setLoginName("bolg");
		user.setPassword("helloaaa");
		boolean flag = userService.addUser(user);
		System.out.println(flag?"增加用户成功":"增加用户失败");
	}
	
	// 测试删除用户
	@Test
	public void testDelUser() {
		IUserService userService = (IUserService) ac.getBean("userService");
		User user = new User();
		user.setUserId(27L);
		boolean flag = userService.delUser(user);
		System.out.println(flag?"删除用户成功":"删除用户失败");
	}
	
	// 测试更新用户
	@Test
	public void testUpdateUser() {
		IUserService userService = (IUserService) ac.getBean("userService");
		User user = new User();
		user.setUserId(15L);
		user.setUserName("小菜");
		boolean flag = userService.updateUser(user);
		System.out.println(flag?"更新用户成功":"更新用户失败");
	}
	
	// 测试查询用户列表
	@Test
	public void testListUser() {
		IUserService userService = (IUserService) ac.getBean("userService");
		List<User> userList  = userService.listUser();
		for (User user : userList) {
			System.out.println(user.getUserId() + "\t" + user.getUserName() + "\t" + user.getLoginName());
		}
	}
	
	// 测试查询用户列表（用map返回）
	@Test
	public void testListUserMap() {
		IUserService userService = (IUserService) ac.getBean("userService");
		List<Map<String, Object>> userListMap = userService.listUserMap();
		for (Map<String, Object> map : userListMap) {
			for (Entry<String, Object> entry  : map.entrySet()) {
				System.out.println(entry.getKey() + "-" + entry.getValue());
			}
			System.out.println();
		}
	}
}

注：在实现dao层的时候也可以不注入JdbcTemplate，让dao直接继承JdbcDaoSupport，然后直接向dao注入dataSource即可（实际上是注入到了JdbcDaoSupport中），spring在调用setDataSource( )向其中注入数据源的时候在setDataSource方法内会判断是否创建了JdbcTemplate，如果没有创建模板类，就会自动创建一个模板类，在dao层只需要通过this.getJdbcTemplate()获取模板类调用增删改查方法即可。不过这样做的话spring就具有了侵入性，所以不推荐这么做。
这里写图片描述

其他：我们一般在开发中不使用spring自带的数据源，而是使用第三方的数据源例如：

c3p0 com.mchange.v2.c3p0.ComboPooledDataSource
连接数据库的四要素（属性）：
driverClass
jdbcUrl
user
password
druid（阿里） com.alibaba.druid.pool.DruidDataSource
连接数据库的四要素（属性）：
driverClassName
url
username
password
dbcp（阿帕奇） org.apache.commons.dbcp.BasicDataSource
连接数据库的四要素（属性）：
driverClassName
url
username
password

可以看出c3p0是比较特立独行的：驱动，url，用户名都与其他两个不同，在使用c3p0的时候要注意，需要导入c3p0-0.9.0.jar
dbcp数据源在1.0版本之前性能很差，但是1.4版本之后还是可以一用的，使用的时候要导入两个包（commons-dbcp-1.4.jar, commons-pool-1.6.jar）。
druid是阿里的数据源，可以用来监控SQL的执行时间，有效的优化SQL，是一款不错的数据源，需要导入druid-1.1.5.jar。

总结：这是spring自己的jdbc模块，用的不多，仅作为了解，一般使用hibernate或者MyBatis来访问数据库。

曲健磊的个人博客

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringJdbcTemplate模板类使用小记

81.环境搭建导入所需jar包:commons-logging-1.2.jaraopalliance-1.0.jarspring-aop.4.2.1.RELEASE.jarspring-beans.4.2.1.RELEASE.jarspring-core.4.2.1.RELEASE.jarspring-context.4.2.1.RELEASE.jarspring-expression
复制链接

扫一扫

专栏目录