JAVA通过JDBC连接并操作MySQL数据库中，我们知道如何通过JDBC连接并操作数据库，但是请看程序，整个程序连接数据库和关闭数据库占了很大一部分代码量，而且每次我们执行一下数据库操作都得来这么一大段重复代码，这是很烦人的。而在Spring框架中同样提供了JDBC框架，以供我们操作数据库。spring中的JDBC框架则可以为我们省去连接和关闭数据库的代码，我们只要关注我们想对数据库进行的操作即可，下面开始介绍吧。

其他 2018-06-13 05:08:31 阅读次数: 2

在前一篇博文JAVA通过JDBC连接并操作MySQL数据库中，我们知道如何通过JDBC连接并操作数据库，但是请看程序，整个程序连接数据库和关闭数据库占了很大一部分代码量，而且每次我们执行一下数据库操作都得来这么一大段重复代码，这是很烦人的。而在Spring框架中同样提供了JDBC框架，以供我们操作数据库。spring中的JDBC框架则可以为我们省去连接和关闭数据库的代码，我们只要关注我们想对数据库进行的操作即可，下面开始介绍吧。

同样的，我们需要在MySQL中创建一个table，以供我们测试使用。

[sql]  view plain  copy
  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. )  

表格效果如下图：

有了数据库之后，建好maven工程，然后需要配置数据源。在Spring的JDBC框架中，数据源配置在Beans.xml中，当然这个文件名可以随便取的。

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

[html]  view plain  copy
  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.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.     http://www.springframework.org/schema/beans/spring-beans-4.1.xsd ">  
  6.       
  7.     <bean id="datasource"  
  8.         class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
  9.         <property name="driverClassName" value="com.mysql.jdbc.Driver" />  
  10.         <!--注意一下&characterEncoding要修改为&amp;characterEncoding-->  
  11.     <property name="url" value="jdbc:mysql://localhost:3306/mysql?useUnicode=true&amp;characterEncoding=utf-8"/>        
  12.         <property name="username" value="root"/>  
  13.         <property name="password" value="snow" />  
  14.     </bean>         
  15.       
  16.     <bean id="studentDaoImp"  
  17.         class="SNOW.SpringJDBCtest.StudentDaoImp">  
  18.         <property name="datasource" ref="datasource" />  
  19.     </bean>         
  20.           
  21. </beans>  

在这里有一点要注意characterEncoding前面的 & 需要更换成 &amp; ，否则会报错。

接下来我们为数据库student创建一个类student.java

[java]  view plain  copy
  1. package SNOW.SpringJDBCtest;  
  2.   
  3. public class Student{  
  4.     private String ID;  
  5.     private String name;  
  6.     private int age;  
  7.     private String FM;  
  8.       
  9.     public Student(){         
  10.     }  
  11.       
  12.     public Student(String ID,String name,int age, String FM){  
  13.         this.ID = ID;  
  14.         this.name = name;  
  15.         this.age = age;  
  16.         this.FM = FM;  
  17.     }  
  18.       
  19.     public void setID(String ID){  
  20.         this.ID = ID;  
  21.     }  
  22.       
  23.     public String getID(){  
  24.         return this.ID;  
  25.     }  
  26.   
  27.     public void setname(String name){  
  28.         this.name = name;  
  29.     }  
  30.       
  31.     public String getname(){  
  32.         return this.name;  
  33.     }  
  34.   
  35.     public void setage(int age){  
  36.         this.age = age;  
  37.     }  
  38.       
  39.     public int getage(){  
  40.         return age;  
  41.     }  
  42.       
  43.     public void setFM(String FM){  
  44.         this.FM = FM;  
  45.     }  
  46.       
  47.     public String getFM(){  
  48.         return this.FM;  
  49.     }     
  50.       
  51.     public void display(){  
  52.         System.out.println(ID + " " + name + " " + age + " " + FM);  
  53.     }  
  54.       
  55.       
  56. }  

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

[java]  view plain  copy
  1. package SNOW.SpringJDBCtest;  
  2.   
  3. import java.sql.ResultSet;  
  4. import java.sql.SQLException;  
  5. import org.springframework.jdbc.core.RowMapper;  
  6.   
  7. public class StudentMapper implements RowMapper<Student> {  
  8.   
  9.     public Student mapRow(ResultSet rs, int rownum) throws SQLException {  
  10.         Student student = new Student();  
  11.         student.setID(rs.getString("ID"));  
  12.         student.setname(rs.getString("name"));  
  13.         student.setage(rs.getInt("age"));  
  14.         student.setFM(rs.getString("FM"));  
  15.           
  16.         return student;       
  17.     }  
  18.       
  19. }  

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

我们的接口定义如下：

[java]  view plain  copy
  1. package SNOW.SpringJDBCtest;  
  2.   
  3. import java.util.List;  
  4. import javax.sql.DataSource;  
  5.   
  6.   
  7. public interface StudentDao{  
  8.   
  9.     /**  
  10.      * This is the method to be used to initialize 
  11.      * database resources ie. connection. 
  12.      */   
  13.     public void setdatasource(DataSource ds);     
  14.       
  15.     public void addstudent(Student student);  
  16.       
  17.     public void delstudentbyID(String ID);  
  18.       
  19.     public void delstudentbyname(String name);  
  20.       
  21.     public void delallstudent();  
  22.       
  23.     public void updstudent(Student student);  
  24.       
  25.     public List<Student> allstudent();  
  26.       
  27.     public List<Student> querystudentbyID(String ID);  
  28.       
  29.     public List<Student> querystudentbyname(String name);  
  30.       
  31.     public List<Student> querystudentbyage(int age);  
  32.       
  33.       
  34. }  

接口实现定义如下：

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

实现了StudentDaoImp类之后需要装备到Beans.xml中，具体见最上面的Beans.xml代码。

写完以上代码就写完了主要的功能操作了，接下来我们写个测试程序Maintest.java

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


因为创建的Maven项目，其中pom.xml如下：

[html]  view plain  copy
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.   <modelVersion>4.0.0</modelVersion>  
  4.   
  5.   <groupId>SNOW</groupId>  
  6.   <artifactId>SpringJDBCtest</artifactId>  
  7.   <version>0.0.1-SNAPSHOT</version>  
  8.   <packaging>jar</packaging>  
  9.   
  10.   <name>SpringJDBCtest</name>  
  11.   <url>http://maven.apache.org</url>  
  12.   
  13.   <properties>      
  14.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  15.   </properties>  
  16.   
  17.   <dependencies>        
  18.     <dependency>  
  19.         <groupId>junit</groupId>  
  20.         <artifactId>junit</artifactId>  
  21.         <version>3.8.1</version>  
  22.         <scope>test</scope>  
  23.     </dependency>  
  24.       
  25.     <dependency>  
  26.         <groupId>mysql</groupId>  
  27.         <artifactId>mysql-connector-java</artifactId>  
  28.         <version>5.1.35</version>  
  29.     </dependency>  
  30.   
  31.     <dependency>  
  32.         <groupId>org.springframework</groupId>  
  33.         <artifactId>spring-context</artifactId>  
  34.         <version>4.1.6.RELEASE</version>  
  35.     </dependency>  
  36.   
  37.     <dependency>  
  38.         <groupId>org.springframework</groupId>  
  39.         <artifactId>spring-jdbc</artifactId>  
  40.         <version>4.1.6.RELEASE</version>  
  41.     </dependency>  
  42.       
  43.     <dependency>  
  44.         <groupId>org.springframework</groupId>  
  45.         <artifactId>spring-tx</artifactId>  <!--spring transaction-->  
  46.         <version>4.1.6.RELEASE</version>  
  47.     </dependency>      
  48.       
  49.   </dependencies>  
  50. </project>  

最终运行结果如下：

[plain]  view plain  copy
  1. 五月 29, 2015 8:51:29 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh  
  2. 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@384e57ba: startup date [Fri May 29 20:51:29 CST 2015]; root of context hierarchy  
  3. 五月 29, 2015 8:51:30 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions  
  4. 信息: Loading XML bean definitions from class path resource [SNOW/SpringJDBCtest/Beans.xml]  
  5. 五月 29, 2015 8:51:31 下午 org.springframework.jdbc.datasource.DriverManagerDataSource setDriverClassName  
  6. 信息: Loaded JDBC driver: com.mysql.jdbc.Driver  
  7. ---------addstudent-------------  
  8. 1990 Yuan 20 M  
  9. 2008 Wang 16 F  
  10. 2009 Hui 18 F  
  11. 2010 Yu 20 M  
  12. 2015 Yuan 22 M  
  13. 2018 Yang 21 F  
  14. ---------updatestudent-------------  
  15. 1990 Yuan 18 M  
  16. 2008 Wang 16 F  
  17. 2009 Hui 18 F  
  18. 2010 Yu 20 M  
  19. 2015 Yuan 22 M  
  20. 2018 Yang 21 F  
  21. ---------querystudentbyID-------------  
  22. 1990 Yuan 18 M  
  23. ---------querystudentbyname-------------  
  24. 1990 Yuan 18 M  
  25. 2015 Yuan 22 M  
  26. ---------querystudentbyage-------------  
  27. 2010 Yu 20 M  
  28. ---------delstudentbyage-------------  
  29. 1990 Yuan 18 M  
  30. 2008 Wang 16 F  
  31. 2009 Hui 18 F  
  32. 2010 Yu 20 M  
  33. 2015 Yuan 22 M  
  34. ---------delstudentbyname-------------  
  35. 1990 Yuan 18 M  
  36. 2008 Wang 16 F  
  37. 2010 Yu 20 M  
  38. 2015 Yuan 22 M  
  39. ---------delallstudent-------------  

本文参考文献：    

http://www.tutorialspoint.com/spring/spring_jdbc_framework.htm

http://www.tutorialspoint.com/spring/spring_jdbc_example.htm

转载自：

https://blog.csdn.net/wanghuiqi2008/article/details/46239753#0-qzone-1-57166-d020d2d2a4e8d1a374a433f596ad1440

猜你喜欢

转载自blog.csdn.net/qq_40136685/article/details/80663463
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
[编程题]学英语
[codeforces 1288A] Deadline 约数+模
Python的web开发
Docker在Centos 7上的部署
python编码
解决Ubuntu16.04 fatal error: json/json.h: No such file or directory
mysql并发插入
rest接口如何适应jsonp的方案
linux 终端上网设置
高数——等号两边同时求导、积分的解释
每日归档
更多
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022