使用Spring JDBCTemplate简化JDBC的操作
使用Spring JDBCTemplate简化JDBC的操作
接触过JAVA WEB开发的朋友肯定都知道Hibernate框架,虽然不否定它的强大之处,但个人对它一直无感,总感觉不够灵活,太过臃肿了。
今天来说下Spring中关于JDBC的一个辅助类(JDBC Template),它封装了JDBC的操作,使用起来非常方便。
先说下"傻瓜式"的使用(不依赖于xml配置):
直接写个测试单元:
1 package com.lcw.spring.jdbc;
2
3 import org.junit.Test;
4 import org.springframework.jdbc.core.JdbcTemplate;
5 import org.springframework.jdbc.datasource.DriverManagerDataSource;
6
7 public class JDBCTemplate {
8
9 @Test
10 public void demo(){
11 DriverManagerDataSource dataSource=new DriverManagerDataSource();
12 dataSource.setDriverClassName("com.mysql.jdbc.Driver");
13 dataSource.setUrl("jdbc:mysql:///spring");
14 dataSource.setUsername("root");
15 dataSource.setPassword("");
16
17 JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);
18 jdbcTemplate.execute("create table temp(id int primary key,name varchar(32))");
19
20 }
21
22 }
很简单吧,再来看下使用结合配置文件,完整的实现对一个类的增删改查
首先DEMO目录结构:
appliactionContext.xml
1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3 xmlns:p="http://www.springframework.org/schema/p"
4 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5 xsi:schemaLocation="
6 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
7
8 <!--数据源的配置 -->
9 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
10 <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
11 <property name="url" value="jdbc:mysql:///spring"></property>
12 <property name="username" value="root"></property>
13 <property name="password" value=""></property>
14 </bean>
15
16
17
18 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
19 <property name="dataSource" ref="dataSource"></property>
20 </bean>
21
22
23 <bean id="userDao" class="com.curd.spring.impl.UserDAOImpl">
24 <property name="jdbcTemplate" ref="jdbcTemplate"></property>
25 </bean>
26
27
28
29 </beans>
接口:IUserDAO.java
1 package com.curd.spring.dao;
2
3 import java.util.List;
4
5 import com.curd.spring.vo.User;
6
7 public interface IUserDAO {
8
9 public void addUser(User user);
10
11 public void deleteUser(int id);
12
13 public void updateUser(User user);
14
15 public String searchUserName(int id);
16
17 public User searchUser(int id);
18
19 public List<User> findAll();
20
21 }
接口实现类:UserDAOImpl.java
按照以往Spring的依赖注入,我们需要在接口实现类中利用构造器去获取JdbcTemplate
Spring早就帮我们想到了这点,它为我们提供了JdbcDaoSupport支持类,所有DAO继承这个类,就会自动获得JdbcTemplate(前提是注入DataSource)。
1 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
2 <property name="dataSource" ref="dataSource"></property>
3 </bean>
4
5
6 <bean id="userDao" class="com.curd.spring.impl.UserDAOImpl">
7 <property name="jdbcTemplate" ref="jdbcTemplate"></property>
8 </bean>
在我们的实现类中直接利用getJdbcTemplate就可以获取操作对象了。
JdbcTemplate主要提供下列方法:
1、execute方法:可以用于执行任何SQL语句,一般用于执行DDL语句;
2、update方法及batchUpdate方法:update方法用于执行新增、修改、删除等语句;batchUpdate方法用于执行批处理相关语句;
3、query方法及queryForXXX方法:用于执行查询相关语句;
4、call方法:用于执行存储过程、函数相关语句。
1 package com.curd.spring.impl;
2
3 import java.sql.ResultSet;
4 import java.sql.SQLException;
5 import java.util.List;
6
7 import org.springframework.jdbc.core.RowMapper;
8 import org.springframework.jdbc.core.support.JdbcDaoSupport;
9 import com.curd.spring.dao.IUserDAO;
10 import com.curd.spring.vo.User;
11
12 public class UserDAOImpl extends JdbcDaoSupport implements IUserDAO {
13
14 public void addUser(User user) {
15 String sql = "insert into user values(?,?,?)";
16 this.getJdbcTemplate().update(sql, user.getId(), user.getUsername(),
17 user.getPassword());
18 }
19
20 public void deleteUser(int id) {
21 String sql = "delete from user where id=?";
22 this.getJdbcTemplate().update(sql, id);
23
24 }
25
26 public void updateUser(User user) {
27 String sql = "update user set username=?,password=? where id=?";
28 this.getJdbcTemplate().update(sql, user.getUsername(),
29 user.getPassword(), user.getId());
30 }
31
32 public String searchUserName(int id) {// 简单查询,按照ID查询,返回字符串
33 String sql = "select username from user where id=?";
34 // 返回类型为String(String.class)
35 return this.getJdbcTemplate().queryForObject(sql, String.class, id);
36
37 }
38
39 public List<User> findAll() {// 复杂查询返回List集合
40 String sql = "select * from user";
41 return this.getJdbcTemplate().query(sql, new UserRowMapper());
42
43 }
44
45 public User searchUser(int id) {
46 String sql="select * from user where id=?";
47 return this.getJdbcTemplate().queryForObject(sql, new UserRowMapper(), id);
48 }
49
50 class UserRowMapper implements RowMapper<User> {
51 //rs为返回结果集,以每行为单位封装着
52 public User mapRow(ResultSet rs, int rowNum) throws SQLException {
53
54 User user = new User();
55 user.setId(rs.getInt("id"));
56 user.setUsername(rs.getString("username"));
57 user.setPassword(rs.getString("password"));
58 return user;
59 }
60
61 }
62
63 }
测试类:UserTest.java
1 package com.curd.spring.test;
2
3 import java.util.List;
4
5 import org.junit.Test;
6 import org.springframework.context.ApplicationContext;
7 import org.springframework.context.support.ClassPathXmlApplicationContext;
8
9 import com.curd.spring.dao.IUserDAO;
10 import com.curd.spring.vo.User;
11
12 public class UserTest {
13
14 @Test//增
15 public void demo1(){
16 User user=new User();
17 user.setId(3);
18 user.setUsername("admin");
19 user.setPassword("123456");
20
21 ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
22 IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao");
23 dao.addUser(user);
24
25 }
26
27 @Test//改
28 public void demo2(){
29 User user=new User();
30 user.setId(1);
31 user.setUsername("admin");
32 user.setPassword("admin");
33
34 ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
35 IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao");
36 dao.updateUser(user);
37 }
38
39 @Test//删
40 public void demo3(){
41 ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
42 IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao");
43 dao.deleteUser(3);
44 }
45
46 @Test//查(简单查询,返回字符串)
47 public void demo4(){
48 ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
49 IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao");
50 String name=dao.searchUserName(1);
51 System.out.println(name);
52 }
53
54 @Test//查(简单查询,返回对象)
55 public void demo5(){
56 ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
57 IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao");
58 User user=dao.searchUser(1);
59 System.out.println(user.getUsername());
60 }
61
62 @Test//查(复杂查询,返回对象集合)
63 public void demo6(){
64 ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
65 IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao");
66 List<User> users=dao.findAll();
67 System.out.println(users.size());
68 }
69
70
71
72 }
怎么样,很简单吧,在不缺JDBC里SQL的灵活操作又去除了繁杂操作~
附:
1、Spring 为每种持久化技术 提供一个支持类,在DAO 中注入 模板工具类
(1)JDBC : org.springframework.jdbc.core.support.JdbcDaoSupport
(2)Hibernate 3.0 :org.springframework.orm.hibernate3.support.HibernateDaoSupport
(3)iBatis :org.springframework.orm.ibatis.support.SqlMapClientDaoSupport
用户自己编写DAO 只需要继承 JdbcDaoSupport, 就可以注入 JdbcTemplate
2、 通过jdbcTemplate 提供 int update(String sql, Object... args) 实现增加 、修改 、删除
3、简单查询,返回原始数据类型, String类型
String sql = "select count(*) from user"; // int queryForInt(String sql)
String sql = "select name from user where id = ? "; // <T> T queryForObject(String sql, Class<T> requiredType, Object... args)
4、 复杂查询
JdbcTemplate 没有handler, 手动完成对象封装
编写实体类 RowMapper
class UserRowMapper implements RowMapper<User> {
@Override
public User mapRow(ResultSet rs, int rowNum) throws SQLException {
// rs 已经指向每一条数据,不需要自己调用 next,将rs指向数据 转换 User对象
User user = new User();
user.setId(rs.getInt("id"));
user.setName(rs.getString("name"));
return user;
}
}
查询单个对象 <T> T queryForObject(String sql, RowMapper<T> rowMapper, Object... args)
return this.getJdbcTemplate().queryForObject(sql, new UserRowMapper(),id);
查询所有对象List集合 <T> List<T> query(String sql, RowMapper<T> rowMapper, Object... args)
return this.getJdbcTemplate().query(sql, new UserRowMapper());
以上提供的方法基本可以满足我们的日常需要了。
QQ群:762080163