JdbcTemplate应用学习

一、Spring对不同的持久化支持：

Spring为各种支持的持久化技术，都提供了简单操作的模板和回调

ORM持久化技术	模板类
JDBC	org.springframework.jdbc.core.JdbcTemplate
Hibernate5.0	org.springframework.orm.hibernate5.HibernateTemplate
IBatis(MyBatis)	org.springframework.orm.ibatis.SqlMapClientTemplate
JPA	org.springfrmaework.orm.jpa.JpaTemplate

其实Spring的JDBCTemplate有点像DBUtils，但是有时候还没有DBUitls好用。这里来学习一下使用Spring的JDBCTemplate来玩一下CRUD。

二、使用JdbcTemplate需要的jar包

在这里使用Spring的JDBCTemplate的时候先要把轮子拿过来：

除此之外，在Java中操作数据库怎么能不要对应的驱动包呢：

三、JdbcTemplate使用的基本步骤

然后再看看Spring的JDBCTemplate的使用大体步骤，这里有一个小例子：

  1 package com.spring.test;

  2

  3 import org.junit.Test;

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

  5 import org.springframework.jdbc.datasource.DriverManagerDataSource;

  6

  7 public class TestJDBCTemplate {

  8

  9     @Test

 10     public void test1() {

 11

 12         // JDBC模板依赖于连接池来获得数据的连接，所以必须先要构造连接池

 13         DriverManagerDataSource dataSource = new DriverManagerDataSource();

 14         dataSource.setDriverClassName("com.mysql.jdbc.Driver");

 15         dataSource.setUrl("jdbc:mysql://localhost:3306/spring");

 16         dataSource.setUsername("root");

 17         dataSource.setPassword("123456");

 18

 19         // 创建JDBC模板

 20         JdbcTemplate jdbcTemplate = new JdbcTemplate();

 21         // 这里也可以使用构造方法

 22         jdbcTemplate.setDataSource(dataSource);

 23

 24         // sql语句

 25         String sql = "select count(*)  from user";

 26         Long num = (long) jdbcTemplate.queryForObject(sql, Long.class);

 27

 28         System.out.println(num);

 29

 30     }

 31

 32 }

四、进一步的考虑

其实这个例子本身没有什么的，只是演示了一下，其实在学Spring之后，感觉应该形成一种习惯，在new对象的时候我要想到IOC，在使用Set方法的时候，我要想到DI，再去要方便面（哦，不，是切面），我们应该想到用AOP的。这里可以在Spring中配置如下的引用链：

1. 我要有DataSource，DataSource的属性可以通过注入数据库的一些配置属性添加

2. 我要有JdbcTemplate，而Template依赖与DataSource，我要以ref的方式为我的JdbcTemplate注入引用

3. 有了JdbcTemplate之后，我要有Dao，此时我应该在Dao添加一个JdbcTemplate的成员，然后以ref的方式将JdbcTemplate引入到Dao中

4. 我在Action或者是Servlet中都会调用的是Serivce，所以，我在Serivce中要添加一个Dao作为成员，然后由ref在注入Dao到Service中

DataSource --> JdbcTemplate --> Dao --> Service --> Action/Servlet

"-->"表示将左边的对象注入到右边的对象当中

配置文件如下：

  1 <?xml version="1.0" encoding="UTF-8"?>

  2 <beans xmlns="http://www.springframework.org/schema/beans"

  3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  4     xmlns:context="http://www.springframework.org/schema/context"

  5     xmlns:aop="http://www.springframework.org/schema/aop"

  6     xmlns:tx="http://www.springframework.org/schema/tx"

  7     xsi:schemaLocation="http://www.springframework.org/schema/beans

  8     http://www.springframework.org/schema/beans/spring-beans.xsd

  9     http://www.springframework.org/schema/context

 10     http://www.springframework.org/schema/context/spring-context.xsd

 11     http://www.springframework.org/schema/aop

 12     http://www.springframework.org/schema/aop/spring-aop.xsd

 13     http://www.springframework.org/schema/tx

 14     http://www.springframework.org/schema/tx/spring-tx.xsd">

 15

 16     <!-- IOC和DI的注解扫描 -->

 17     <context:component-scan base-package="com.spring" ></context:component-scan>

 18

 19     <!-- 打开AOP的注解 -->

 20     <!-- 这里用的是中间的横线而不是下划线 -->

 21     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

 22

 23     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >

 24         <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_03"></property>

 25         <property name="driverClass" value="com.mysql.jdbc.Driver"></property>

 26         <property name="user" value="root"></property>

 27         <property name="password" value="123456"></property>

 28     </bean>

 29

 30     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

 31         <property name="dataSource" ref="dataSource"></property>

 32     </bean>

 33

 34     <bean id="userDao" class="com.spring.dao.UserDao">

 35         <property name="jdbcTemplate" ref="jdbcTemplate"></property>

 36     </bean>

 37

 38     <bean id="userService" class="com.spring.service.UserService">

 39         <property name="userDao" ref="userDao"></property>

 40     </bean>

 41

 42 </beans>

其中dataSource和jdbcTemplate都是直接配置的，不用写啥。

然后是UserDao.java

  1 package com.spring.dao;

  2

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

  4

  5 import com.spring.domain.User;

  6

  7 public class UserDao {

  8

  9     private JdbcTemplate jdbcTemplate;

 10

 11     public JdbcTemplate getJdbcTemplate() {

 12         return jdbcTemplate;

 13     }

 14

 15     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

 16         this.jdbcTemplate = jdbcTemplate;

 17     }

 18

 19     public void addUser(User user) {

 20

 21         String sql = "insert into user (username, password) values (?, ?)";

 22

 23         jdbcTemplate.update(sql, user.getUsername(), user.getPassword());

 24

 25     }

 26

 27 }

UserSerice.java

  1 package com.spring.service;

  2

  3 import com.spring.dao.UserDao;

  4 import com.spring.domain.User;

  5

  6 public class UserService {

  7

  8     // 加入userDao作为成员变变量

  9     private UserDao userDao;

 10

 11     // 注意这里要增加get和set方法

 12     public UserDao getUserDao() {

 13         return userDao;

 14     }

 15

 16     public void setUserDao(UserDao userDao) {

 17         this.userDao = userDao;

 18     }

 19

 20     public void addUser(User user) {

 21         userDao.addUser(user);

 22     }

 23 }

上面的文件都是用的配置文件来获得对象的，而没有使用注解。

测试类：

  1 package com.spring.test;

  2

  3 import org.junit.Test;

  4 import org.springframework.context.ApplicationContext;

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

  6 import com.spring.domain.User;

  7 import com.spring.service.UserService;

  8

  9 public class TestJDBCTemplate {

 10

 11     @Test

 12     public void test2() {

 13

 14         ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");

 15         UserService userService = (UserService) ctx.getBean("userService");

 16

 17         User user = new User();

 18         user.setPassword("111");

 19         user.setUsername("小王");

 20

 21         userService.addUser(user);

 22

 23     }

 24

 25 }

哦，对了其中配置的数据源是C3P0的数据源，还要导入C3P0的包：

五、JdbcTemplate的CRUD方法

1. 插入数据

  1 public void addUser(User user) {

  2

  3     String sql = "insert into user (username, password) values (?, ?)";

  4

  5     jdbcTemplate.update(sql, user.getUsername(), user.getPassword());

  6

  7 }

如上，插入代码用的是update方法，其实增删改用的都是update方法，而查询则是和query相关的方法。

2. 删除操作

  1 public void deleteUser( ) {

  2     String sql = "delete from user where username= ?";

  3     jdbcTemplate.update(sql, "小王");

  4 }

3. 修改操作

  1 public void updateUser(User user) {

  2     String sql = "update user set username=? where username= ?";

  3     jdbcTemplate.update(sql,  user.getUsername() + "_new", user.getUsername());

  4 }

4. 查询操作

上面三个都比较简单，查询倒是有些复杂。在使用比较基础的持久化工具的时候，比如DBUtils都会针对查询结果给我们提供一些封装的接口和类，但是JdbcTemplate只给我们提供了接口，并没有可用的类，所以我们需要自己写实现类来进行封装。这里会学习使用JdbcTemplate进行三种查询操作：

4.a. 查询表的记录数

  1 @Test

  2 public void test5() {

  3     ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");

  4     JdbcTemplate jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");

  5     String sql = "select count(*) from user";

  6     Long row = jdbcTemplate.queryForObject(sql, Long.class);

  7     System.out.println("查询出来的记录数为：" + row);

  8 }

4.b. 查询返回对象

  1 @Test

  2 public void test6() {

  3     // 获得jdbcTemplate对象

  4     ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");

  5     JdbcTemplate jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");

  6     String sql = "select username, password from user where username = ?";

  7     // 设定参数

  8     Object[] object = {"mary_new"};

  9     // 进行查询

 10     User user = jdbcTemplate.queryForObject(sql, object,  new UserMapper());

 11     System.out.println(user);

 12 }

除此之外要实现结构RowMapper来新建一个映射类：

  1 package com.spring.test;

  2

  3 import java.sql.ResultSet;

  4 import java.sql.SQLException;

  5

  6 import org.springframework.jdbc.core.RowMapper;

  7

  8 import com.spring.domain.User;

  9

 10 public class UserMapper implements RowMapper<User>{

 11

 12     @Override

 13     public User mapRow(ResultSet resultSet, int rows) throws SQLException {

 14         User user = new User();

 15         user.setUsername(resultSet.getString(1));

 16         user.setPassword(resultSet.getString(2));

 17

 18         return user;

 19     }

 20

 21 }

要注意这个UserMapper.java应该要和具体的Sql语句对应。

4.c. 查询并返回List集合

  1 @Test

  2 public void test7() {

  3     // 获得jdbcTemplate对象

  4     ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");

  5     JdbcTemplate jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");

  6

  7     // sql语句

  8     String sql = "select * from user";

  9     List<User> users = jdbcTemplate.query(sql, new UserMapper());

 10

 11     for(User u: users) {

 12         System.out.println(u);

 13     }

 14 }

总结：

1. Spring全套管理各种组件，注入、控制反转等，将组件之间的关系以配置文件的形式串联起来，最大程度的对应用解耦和

2. Spring的JdbcTemplate中的CRUD操作还好，比较常规，但是也只对JDBC的持久化操作的演示，还没用其他的呢

3. 多练习下配置文件编写，注入的方式、写法还不是很熟

巴特西

JdbcTemplate应用学习

最新文章

热门文章