Spring对JDBC的支持

最新推荐文章于 2019-09-20 10:24:00 发布

更好的自己520

最新推荐文章于 2019-09-20 10:24:00 发布

阅读量285

点赞数

分类专栏： spring框架文章标签： spring jdbc

本文链接：https://blog.csdn.net/a3060858469/article/details/78059751

版权

spring框架专栏收录该内容

12 篇文章 3 订阅

订阅专栏

概述
在Spring JDBC模块中，所有的类可以被分到四个单独的包：

1）core
即核心包，它包含了JDBC的核心功能。此包内有很多重要的类，包括：JdbcTemplate类、SimpleJdbcInsert类，SimpleJdbcCall类，以及NamedParameterJdbcTemplate类。
2）datasource
即数据源包，访问数据源的实用工具类。它有多种数据源的实现，可以在JavaEE容器外部测试JDBC代码。
3）object
即对象包，以面向对象的方式访问数据库。它允许执行查询并返回结果作为业务对象。它可以在数据表的列和业务对象的属性之间映射查询结果。
4）support
即支持包，是core包和object包的支持类。例如提供了异常转换功能的SQLException类。

JdbcTemplate主要提供以下五类方法：

execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；

update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；

query方法及queryForXXX方法：用于执行查询相关语句；

call方法：用于执行存储过程、函数相关语句。

简化JDBC模板查询
由于每次使用都创建一个 JdbcTemplate 的新实例, 这种做法效率很低下。
JdbcTemplate 类被设计成为线程安全的, 所以可以再 IOC 容器中声明它为单例, 并将这一个实例注入到所有的 DAO 实例中。
Spring JDBC 框架还提供了一个 JdbcDaoSupport 类来简化 DAO 实现. 该类声明了 jdbcTemplate 属性, 它可以从 IOC 容器中注入, 或者自动从数据源中创建。

简化JDBC模板查询
这里写图片描述

扩展JdbcDaoSupport 示例代码
这里写图片描述

在JDBC模板中使用具名参数
在经典的 JDBC 用法中, SQL 参数是用占位符 ? 表示,并且受到位置的限制. 定位参数的问题在于, 一旦参数的顺序发生变化, 就必须改变参数绑定.
在 Spring JDBC 框架中, 绑定 SQL 参数的另一种选择是使用具名参数(named parameter).
具名参数: SQL 按名称(以冒号开头)而不是按位置进行指定. 具名参数更易于维护, 也提升了可读性. 具名参数由框架类在运行时用占位符取代
具名参数只在 NamedParameterJdbcTemplate 中得到支持

在 SQL 语句中使用具名参数时, 可以在一个 Map 中提供参数值, 参数名为键。
也可以使用 SqlParameterSource 参数。
批量更新时可以提供 Map 或 SqlParameterSource 的数组。

这里写图片描述

JdbcTemplate用法
为了使 JDBC 更加易于使用, Spring 在 JDBC API 上定义了一个抽象层, 以此建立一个 JDBC 存取框架.

作为 Spring JDBC 框架的核心, JDBC模板的设计目的是为不同类型的 JDBC 操作提供模板方法. 每个模板方法都能控制整个过程, 并允许覆盖过程中的特定任务. 通过这种方式, 可以在尽可能保留灵活性的情况下, 将数据库存取的工作量降到最低。

这里写图片描述

案例实现：
我们需要在MySQL中创建一个table，以供我们测试使用。

1.CREATE TABLE student(  
2.    ID VARCHAR(5),  
3.    name VARCHAR(20),  
4.    age int(3),  
5.    FM VARCHAR(1),  
6.    PRIMARY KEY(ID)  
7.)

在Spring的JDBC框架中，数据源配置在Beans.xml中，当然这个文件名可以随便取的。

整个Beans.xml配置文件如下所示：

1.<bean id="datasource"  
2.        class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
3.        <property name="driverClassName" value="com.mysql.jdbc.Driver" />  
4.        <!--注意一下&characterEncoding要修改为&amp;characterEncoding-->  
5.    <property name="url" value="jdbc:mysql://localhost:3306/mysql?useUnicode=true&amp;characterEncoding=utf-8"/>        
6.        <property name="username" value="root"/>  
7.        <property name="password" value="snow" />  
8.    </bean>         
9.      
10.    <bean id="studentDaoImp"  
11.        class="NetEase.SpringJDBCtest.StudentDaoImp">  
12.        <property name="datasource" ref="datasource" />  
13.    </bean>

为数据库student创建一个类student.java

1.public class Student{  
2.    private String ID;  
3.    private String name;  
4.    private int age;  
5.    private String FM;  
6.      
7.    public Student(){         
8.    }  
9.      
10.    public Student(String ID,String name,int age, String FM){  
11.        this.ID = ID;  
12.        this.name = name;  
13.        this.age = age;  
14.        this.FM = FM;  
15.    } 
16.}
17.

有了Student类之后，还需要一个将SQL数据与student对象映射的类StudentMapper.java

1.public class StudentMapper implements RowMapper<Student> {  
2.  
3.    public Student mapRow(ResultSet rs, int rownum) throws SQLException {  
4.        Student student = new Student();  
5.        student.setID(rs.getString("ID"));  
6.        student.setname(rs.getString("name"));  
7.        student.setage(rs.getInt("age"));  
8.        student.setFM(rs.getString("FM"));  
9.          
10.        return student;       
11.    }  
12.      
13.}

Spring JDBC框架是通过DAO（Data Access Object）来实现对数据库的读写数据操作的，并且在实现过程中应该由应用程序implements interface 来完成数据库的读写操作。

1.public interface StudentDao{  
2.  
7.    public void setdatasource(DataSource ds);        
9.    public void addstudent(Student student);    
11.    public void delstudentbyID(String ID);       
13.    public void delstudentbyname(String name);     
15.    public void delallstudent();       
17.    public void updstudent(Student student);       
19.    public List<Student> allstudent();        
21.    public List<Student> querystudentbyID(String ID);       
23.    public List<Student> querystudentbyname(String name);       
25.    public List<Student> querystudentbyage(int age);  

28.}

接口实现定义如下：

1.public class StudentDaoImp implements StudentDao{  
2.  
3.    private DataSource datasource;  
4.    private JdbcTemplate jdbcTemplateObject;      
7.    public void setdatasource(DataSource ds) {  
8.        this.datasource = ds;  
9.        this.jdbcTemplateObject = new JdbcTemplate(datasource);       
10.    }  
11.  
12.    public void addstudent(Student student) {  
13.        String sql = "INSERT INTO class.student(ID,name,age,FM)VALUES(?,?,?,?)";  
14.          
15.        jdbcTemplateObject.update(sql, student.getID(),  
16.                student.getname(),student.getage(),student.getFM());  
17.        return ;  
18.    }  
19.  
20.    public void delstudentbyID(String ID) {  
21.        String sql = "DELETE FROM class.student WHERE ID=?";  
22.        jdbcTemplateObject.update(sql,ID);  
23.        return ;  
24.    }  
25.  
26.    public void delstudentbyname(String name) {  
27.        String sql = "DELETE FROM class.student WHERE name=?";  
28.        jdbcTemplateObject.update(sql,name);  
29.        return ;          
30.    }  
31.  
32.    public void delallstudent() {  
33.        String sql = "DELETE FROM class.student";  
34.        jdbcTemplateObject.update(sql);  
35.        return ;      
36.    }  
37.  
38.    public void updstudent(Student student) {  
39.        String sql = "UPDATE class.student set name=?,age=?,FM=? WHERE ID=?";  
40.        jdbcTemplateObject.update(sql,student.getname(),  
41.                student.getage(),student.getFM(),student.getID());  
42.        return ;  
43.    }  
44.  
45.    public List<Student> allstudent() {  
46.        List<Student> students = null;  
47.        String sql = "SELECT * FROM class.student";  
48.        students = jdbcTemplateObject.query(sql, new StudentMapper());  
49.        return students;  
50.    }  
51.  
52.    public List<Student> querystudentbyID(String ID) {  
53.        List<Student> students = null;  
54.        String sql = "SELECT * FROM class.student WHERE ID=?";  
55.        students = jdbcTemplateObject.query(sql, new Object[]{ID}, new StudentMapper());  
56.        return students;  
57.    }  
58.  
59.    public List<Student> querystudentbyname(String name) {  
60.        List<Student> students = null;  
61.        String sql = "SELECT * FROM class.student WHERE name=?";  
62.        students = jdbcTemplateObject.query(sql, new Object[]{name}, new StudentMapper());  
63.        return students;  
64.    }  
65.  
66.    public List<Student> querystudentbyage(int age) {  
67.        List<Student> students = null;  
68.        String sql = "SELECT * FROM class.student WHERE age=?";  
69.        students = jdbcTemplateObject.query(sql, new Object[]{age}, new StudentMapper());  
70.        return students;  
71.    }     
73.    public void displayall(){  
74.        List<Student> students = allstudent();  
75.        for(Student s : students){  
76.            s.display();  
77.        }  
78.    }       
81.}

测试代码

1.public class Maintest{  
2.    public static void main(String [] args){  
3.        ApplicationContext context =   
4.                new ClassPathXmlApplicationContext("NetEase/SpringJDBCtest/Beans.xml");  
5.        StudentDaoImp studentDaoImp = (StudentDaoImp)context.getBean("studentDaoImp");  
6.          
7.          
8.        String[] ID = { "2008", "2009", "2010", "1990", "2015","2018" };  
9.        String[] name = { "Wang", "Hui", "Yu", "Yuan", "Yuan", "Yang"};  
10.        int[] age = { 16, 18, 20, 20, 22, 21 };  
11.        String[] FM = {"F", "F", "M", "M", "M", "F"};         
12.        Student student = null;  
13.        List<Student> students = null;  
14.          
15.        System.out.println("---------addstudent-------------");  
16.        for(int i=0; i<ID.length; i++){  
17.            student = new Student(ID[i],name[i],age[i],FM[i]);  
18.            studentDaoImp.addstudent(student);            
19.        }  
20.        studentDaoImp.displayall();          
22.        System.out.println("---------updatestudent-------------");  
23.        student = new Student("1990","Yuan",18,"M");  
24.        studentDaoImp.updstudent(student);  
25.        studentDaoImp.displayall();           
27.        System.out.println("---------querystudentbyID-------------");  
28.        students = studentDaoImp.querystudentbyID("1990");  
29.        for(Student s : students){  
30.            s.display();  
31.        }          
33.        System.out.println("---------querystudentbyname-------------");  
34.        students = studentDaoImp.querystudentbyname("Yuan");  
35.        for(Student s : students){  
36.            s.display();  
37.        }           
39.        System.out.println("---------querystudentbyage-------------");  
40.        students = studentDaoImp.querystudentbyage(20);  
41.        for(Student s : students){  
42.            s.display();  
43.        }              
45.        System.out.println("---------delstudentbyage-------------");  
46.        studentDaoImp.delstudentbyID("2018");  
47.        studentDaoImp.displayall();           
49.        System.out.println("---------delstudentbyname-------------");  
50.        studentDaoImp.delstudentbyname("Hui");  
51.        studentDaoImp.displayall();       
52.          
53.        System.out.println("---------delallstudent-------------");  
54.        studentDaoImp.delallstudent();           
57.    }  
58.      
59.}

参考博客：
http://blog.csdn.net/chszs/article/details/43971981
http://www.cnblogs.com/xinsheng/p/3898107.html
http://blog.csdn.net/wanghuiqi2008/article/details/46239753

更好的自己520

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring对JDBC的支持

概述在Spring JDBC模块中，所有的类可以被分到四个单独的包： 1）core 即核心包，它包含了JDBC的核心功能。此包内有很多重要的类，包括：JdbcTemplate类、SimpleJdbcInsert类，SimpleJdbcCall类，以及NamedParameterJdbcTemplate类。 2）datasource 即数据源包，访问数据源的实用工具类。它有多
复制链接

扫一扫

专栏目录