今天又是被“欺负”的一天！！跪求大佬帮帮我~使用Spring

发表于

在这里插入图片描述

使用Spring JDBCTemplate简化JDBC的操作

接触过JAVA WEB开发的朋友肯定都知道Hibernate框架，虽然不否定它的强大之处，但个人对它一直无感，总感觉不够灵活，太过臃肿了。

今天来说下Spring中关于JDBC的一个辅助类(JDBC Template)，它封装了JDBC的操作，使用起来非常方便。

在这里插入图片描述

先说下”傻瓜式”的使用（不依赖于xml配置）：

直接写个测试单元：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
c复制代码 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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
c复制代码 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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
c复制代码 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
2
3
4
5
6
7
8
c复制代码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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
c复制代码 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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
c复制代码 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的灵活操作又去除了繁杂操作~

【参考文献】

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%