您的位置: 首页  >  文章  >  spring boot下使用jdbcTemplate操作数据库MySQL

spring boot下使用jdbcTemplate操作数据库MySQL

分类: 文章 • 2023-10-11 19:01:11

操作步骤:

1）pom.xml文件中添加mysql-connector-java,spring-boot-starter-jdbc

但是如果已经添加spring-boot-starter-data-jpa依赖，则无需添加spring-boot-starter-jdbc依赖。

2）配置application.properties(包括数据库等配置)

3）创建一个实体类，比如Cat

4）创建一个Dao,包含jdbcTemplate详细使用，比如CatDao

5）创建一个service，比如CatService

6）创建一个Controller,比如CatController

7）测试

实例:

项目结构:

spring boot下使用jdbcTemplate操作数据库MySQL

1）. pom.xml加入依赖

[html] view plain copy
  1. <!-- 添加spring-data-jpa依赖 -->  
  2.     <dependency>  
  3.         <groupId>org.springframework.boot</groupId>  
  4.         <artifactId>spring-boot-starter-data-jpa</artifactId>  
  5.     </dependency>  
  6.     <!--   
  7.         添加spring boot jdbcTemplate依赖，  
  8.         如果已经添加了spring-boot-starter-data-jpa依赖，  
  9.         则无需添加spring-boot-starter-jdbc依赖。  
  10.     -->  
  11.     <!-- <dependency>  
  12.         <groupId>org.springframework.boot</groupId>  
  13.         <artifactId>spring-boot-starter-jdbc</artifactId>  
  14.     </dependency> -->  

关于mysql,spring boot相关依赖pom.xm完整配置文件:

[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>com.lanhuigu</groupId>  
  6.   <artifactId>spring-boot</artifactId>  
  7.   <version>0.0.1-SNAPSHOT</version>  
  8.   <packaging>jar</packaging>  
  9.   
  10.   <name>spring-boot</name>  
  11.   <url>http://maven.apache.org</url>  
  12.   
  13.   <parent>  
  14.     <groupId>org.springframework.boot</groupId>  
  15.     <artifactId>spring-boot-starter-parent</artifactId>  
  16.     <version>1.4.1.RELEASE</version>  
  17.   </parent>  
  18.     
  19.   <properties>  
  20.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  21.     <!-- 配置jdk版本，默认为1.6 -->  
  22.     <java.version>1.8.0_66</java.version>  
  23.   </properties>  
  24.     <!-- spring boot热部署插件springloaded -->  
  25.   <build>  
  26.     <plugins>  
  27.         <plugin>  
  28.             <groupId>org.springframework.boot</groupId>  
  29.             <artifactId>spring-boot-maven-plugin</artifactId>  
  30.             <dependencies>  
  31.                 <dependency>  
  32.                     <groupId>org.springframework</groupId>  
  33.                     <artifactId>springloaded</artifactId>  
  34.                     <version>1.2.4.RELEASE</version>  
  35.                 </dependency>  
  36.             </dependencies>  
  37.             <executions>  
  38.                 <execution>  
  39.                     <goals>  
  40.                         <goal>repackage</goal>  
  41.                     </goals>  
  42.                     <configuration>  
  43.                         <classifier>exec</classifier>  
  44.                     </configuration>  
  45.                 </execution>  
  46.             </executions>  
  47.         </plugin>  
  48.     </plugins>  
  49.   </build>  
  50.     
  51.   <dependencies>  
  52.     <dependency>  
  53.       <groupId>junit</groupId>  
  54.       <artifactId>junit</artifactId>  
  55.       <version>3.8.1</version>  
  56.       <scope>test</scope>  
  57.     </dependency>  
  58.     <!-- spring boot引入相关web开发jar包，包括spring,spring mvc,spring boot,json框架等等 -->  
  59.     <dependency>  
  60.       <groupId>org.springframework.boot</groupId>  
  61.       <artifactId>spring-boot-starter-web</artifactId>  
  62.       <!-- 这个地方不需要指定jar包版本，根据parent配置自动选择 -->  
  63.       <!-- <version>1.4.1.RELEASE</version> -->  
  64.     </dependency>  
  65.       
  66.     <dependency>  
  67.       <groupId>com.alibaba</groupId>  
  68.       <artifactId>fastjson</artifactId>  
  69.       <version>1.2.15</version>  
  70.     </dependency>  
  71.     <!-- 添加MySQL数据库驱动依赖 -->  
  72.     <dependency>  
  73.         <groupId>mysql</groupId>  
  74.         <artifactId>mysql-connector-java</artifactId>  
  75.     </dependency>  
  76.     <!-- 添加spring-data-jpa依赖 -->  
  77.     <dependency>  
  78.         <groupId>org.springframework.boot</groupId>  
  79.         <artifactId>spring-boot-starter-data-jpa</artifactId>  
  80.     </dependency>  
  81.     <!--   
  82.         添加spring boot jdbcTemplate依赖，  
  83.         如果已经添加了spring-boot-starter-data-jpa依赖，  
  84.         则无需添加spring-boot-starter-jdbc依赖。  
  85.     -->  
  86.     <!-- <dependency>  
  87.         <groupId>org.springframework.boot</groupId>  
  88.         <artifactId>spring-boot-starter-jdbc</artifactId>  
  89.     </dependency> -->     
  90.   </dependencies>  
  91. </project> 
2）配置application.properties(包括数据库等配置)
[java] view plain copy
  1. # spring boot绑定默认端口为8080，这里修改为9000  
  2. server.port=9000  
  3. #############################################  
  4. ######datasource --指定MySQL数据库连接信息  
  5. #############################################  
  6. spring.datasource.url = jdbc:mysql://192.168.200.222:3306/dongxihui_web  
  7. spring.datasource.username = root  
  8. spring.datasource.password = root  
  9. spring.datasource.driverClassName = com.mysql.jdbc.Driver  
  10. spring.datasource.max-active = 20  
  11. spring.datasource.max-idle = 8  
  12. spring.datasource.min-idle = 8  
  13. spring.datasource.initial-size = 10  
  14.   
  15. #############################################  
  16. ######Java Persistence Api -- Spring jpa 的配置信息  
  17. #############################################  
  18. # 指定数据库管理系统  
  19. spring.jpa.database = MYSQL  
  20. # 是否打印sql到控制台  
  21. spring.jpa.show-sql = true  
  22. # Hibernate ddl auto  
  23. spring.jpa.hibernate.ddl-auto = update  
  24. # 指定命名策略  
  25. #[org.hibernate.cfg.ImprovedNamingStrategy #org.hibernate.cfg.Default]  
  26. spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy  
  27. # 指定hibernate方言  
  28. spring.jpa.propeties.hibernate.dialect = org.hibernate.dialect.MYSQL  
3）创建一个实体类，比如Cat

[java] view plain copy
  1. package com.lanhuigu.demo.bean;  
  2.   
  3. import javax.persistence.Entity;  
  4. import javax.persistence.GeneratedValue;  
  5. import javax.persistence.GenerationType;  
  6. import javax.persistence.Id;  
  7.   
  8. /** 
  9.  * 创建一个实体 
  10.  *  
  11.  * 1、如何持久化？ 
  12.  * 使用@Entity注解进行实体类的持久化操作，当JPA检测到我们的实体类有 
  13.  * @Entity注解的时候，会在数据库表中生成对应的表结构信息。 
  14.  *  
  15.  * 2、如何指定主键以及主键的生成策略？ 
  16.  * 使用@Id指定主键 
  17.  */  
  18.   
  19. @Entity  
  20. public class Cat {  
  21.     /** 
  22.      * 主键: 
  23.      * 使用@Id指定主键。 
  24.      *  
  25.      * 生成策略: 
  26.      * 使用代码@GeneratedValue(strategy=GenerationType.AUTO) 
  27.      * 指定主键的生成策略,MySQL默认为自增长。 
  28.      */  
  29.     @Id @GeneratedValue(strategy=GenerationType.AUTO)  
  30.     private int id;// 主键  
  31.       
  32.     private String catName;// 姓名，默认生成字段名cat_name  
  33.       
  34.     private int catAge;// 年龄，默认生成字段名cat_age  
  35.   
  36.     public int getId() {  
  37.         return id;  
  38.     }  
  39.   
  40.     public void setId(int id) {  
  41.         this.id = id;  
  42.     }  
  43.   
  44.     public String getCatName() {  
  45.         return catName;  
  46.     }  
  47.   
  48.     public void setCatName(String catName) {  
  49.         this.catName = catName;  
  50.     }  
  51.   
  52.     public int getCatAge() {  
  53.         return catAge;  
  54.     }  
  55.   
  56.     public void setCatAge(int catAge) {  
  57.         this.catAge = catAge;  
  58.     }  
  59. }  
4）创建一个Dao,包含jdbcTemplate详细使用，比如CatDao
[java] view plain copy
  1. package com.lanhuigu.demo.dao;  
  2.   
  3. import javax.annotation.Resource;  
  4.   
  5. import org.springframework.jdbc.core.BeanPropertyRowMapper;  
  6. import org.springframework.jdbc.core.JdbcTemplate;  
  7. import org.springframework.jdbc.core.RowMapper;  
  8. import org.springframework.stereotype.Repository;  
  9.   
  10. import com.lanhuigu.demo.bean.Cat;  
  11. /** 
  12.  * 通过@Repository注解标注该类为持久化操作对象 
  13.  */  
  14. @Repository  
  15. public class CatDao {  
  16.       
  17.     // 通过@Resource注解引入JdbcTemplate对象  
  18.     @Resource  
  19.     private JdbcTemplate jdbcTemplate;  
  20.       
  21.     /** 
  22.      * 使用JdbcTemplate查询数据步骤: 
  23.      * 1. 定义一个sql语句 
  24.      * 2. 定义一个RowMapper 
  25.      * 3. 执行查询方法 
  26.      */  
  27.     public Cat queryByCatName(String catName) {  
  28.         // 1. 定义一个sql语句  
  29.         String querySQL = "select * from cat where cat_name = ?";  
  30.         // 2. 定义一个RowMapper  
  31.         RowMapper<Cat> rowMapper = new BeanPropertyRowMapper<Cat>(Cat.class);  
  32.         // 3. 执行查询方法  
  33.         Cat cat = jdbcTemplate.queryForObject(querySQL, new Object[]{catName}, rowMapper);  
  34.           
  35.         return cat;  
  36.     }  
  37. }  
5）创建一个service，比如CatService

[java] view plain copy
  1. package com.lanhuigu.demo.service;  
  2.   
  3. import javax.annotation.Resource;  
  4. import javax.transaction.Transactional;  
  5.   
  6. import org.springframework.stereotype.Service;  
  7.   
  8. import com.lanhuigu.demo.bean.Cat;  
  9. import com.lanhuigu.demo.dao.CatDao;  
  10. import com.lanhuigu.demo.repository.CatRepository;  
  11.   
  12. @Service  
  13. public class CatService {  
  14.   
  15.     @Resource  
  16.     private CatDao catDao;  
  17.       
  18.     public Cat queryByCatName(String catName) {  
  19.           
  20.         return catDao.queryByCatName(catName);  
  21.     }  
  22. }  
6）创建一个Controller,比如CatController

[java] view plain copy
  1. package com.lanhuigu.demo.controller;  
  2.   
  3. import javax.annotation.Resource;  
  4.   
  5. import org.springframework.web.bind.annotation.RequestMapping;  
  6. import org.springframework.web.bind.annotation.RestController;  
  7.   
  8. import com.lanhuigu.demo.bean.Cat;  
  9. import com.lanhuigu.demo.service.CatService;  
  10.   
  11. @RestController  
  12. @RequestMapping("/cat")  
  13. public class CatController {  
  14.       
  15.     @Resource  
  16.     private CatService catService;  
  17.   
  18.     // jdbcTemplate查询数据使用  
  19.     @RequestMapping("/queryByCatName")  
  20.     public Cat queryByCatName(String catName) {  
  21.           
  22.         return catService.queryByCatName(catName);  
  23.     }  
  24.   
  25. }  
7）测试（启动应用类）
[java] view plain copy
  1. package com.example.demo;  
  2.   
  3. import org.springframework.boot.SpringApplication;  
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;  
  5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;  
  6.   
  7.   
  8. /** 
  9.  * Hello world! 
  10.  * 启动类 
  11.  */  
  12. @SpringBootApplication  
  13. public class Demo1Application extends WebMvcConfigurerAdapter {  
  14.       
  15.       
  16.     public static void main( String[] args ) {  
  17.         /*System.out.println( "Hello World!" );*/  
  18.         SpringApplication.run(Demo1Application.class, args);  
  19.     }  
  20. }  
8）访问服务（默认端口为8080）

http://localhost:9000/cat/queryByCatName?catName=tom
浏览器效果:

spring boot下使用jdbcTemplate操作数据库MySQL

相关推荐