一、介绍

　　SpringBoot框架为使用SQL数据库提供了广泛的支持，从使用JdbcTemplate的直接JDBC访问到完整的“对象关系映射”技术(如Hibernate)。Spring-data-jpa提供了额外的功能级别:直接从接口创建存储库实现，并使用约定方法名生成查询。

　　建表：

  1. CREATE TABLE `user` (
  2.   `id` int(11) NOT NULL AUTO_INCREMENT,
  3.   `name` varchar(255) DEFAULT NULL,
  4.   `age` int(11) DEFAULT NULL,
  5.   `address` varchar(255) DEFAULT NULL,
  6.   PRIMARY KEY (`id`)
  7. )；
  8. INSERT INTO `user` VALUES ('3', 'andy', '6', 'month');
  9. INSERT INTO `user` VALUES ('4', 'andy', '7', 'month');
  10. INSERT INTO `user` VALUES ('5', 'andy', '8', 'month');
  11. INSERT INTO `user` VALUES ('6', 'jack', '3', 'aaa');
  12. CREATE TABLE `student` (
  13.   `id` int(11) NOT NULL,
  14.   `age` int(11) NOT NULL,
  15.   `grade` int(11) NOT NULL,
  16.   `name` varchar(255) DEFAULT NULL,
  17.   PRIMARY KEY (`id`)
  18. )；
  19. INSERT INTO `student` VALUES ('1', '2', '3', 'jack');
  20. INSERT INTO `student` VALUES ('2', '4', '2', 'andy');

二、JdbcTemplate

　　在需要使用持久层的类中直接注入JdbcTemplate，在基本的SpringBoot配置（SpringBoot-HelloWorld）下增加配置数据库连接驱动器：

  1. <dependency>
  2.      <groupId>mysql</groupId>
  3.      <artifactId>mysql-connector-java</artifactId>
  4.      <version>5.1.21</version>
  5. </dependency>

　　配置jdbc的依赖库：

  1. <!-- jdbcTemplate -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-jdbc</artifactId>
  5. </dependency>

　　在application.properties默认属性文件中增加数据库连接信息：

  1. spring.datasource.url=jdbc:mysql://192.168.1.121:3306/test
  2. spring.datasource.username=root
  3. spring.datasource.password=admincss
  4. spring.datasource.driver-class-name=com.mysql.jdbc.Driver

　　创建实体类user:

  1. package com.cn.entity;
  2.  
  3. import java.io.Serializable;
  4.  
  5. /**
  6.  * @program: spring-boot-example
  7.  * @description: 用户类
  8.  * @author:
  9.  * @create: 2018-05-02 09:59
  10.  **/
  11. public class User implements Serializable{
  12.  
  13.     private int id;
  14.     private String name;
  15.     private int age;
  16.     private String address;
  17.  
  18.     @Override
  19.     public String toString() {
  20.         return "User{" +
  21.             "id=" + id +
  22.             ", name='" + name + '\'' +
  23.             ", age=" + age +
  24.             ", address='" + address + '\'' +
  25.             '}';
  26.     }
  27.  
  28.     public int getId() {
  29.         return id;
  30.     }
  31.  
  32.     public void setId(int id) {
  33.         this.id = id;
  34.     }
  35.  
  36.     public String getName() {
  37.         return name;
  38.     }
  39.  
  40.     public void setName(String name) {
  41.         this.name = name;
  42.     }
  43.  
  44.     public int getAge() {
  45.         return age;
  46.     }
  47.  
  48.     public void setAge(int age) {
  49.         this.age = age;
  50.     }
  51.  
  52.     public String getAddress() {
  53.         return address;
  54.     }
  55.  
  56.     public void setAddress(String address) {
  57.         this.address = address;
  58.     }
  59. }

User.java

　　创建UserService接口，UserServiceImpl(内有User映射内部类)服务实现类：

  1. package com.cn.service;
  2.  
  3. import com.cn.entity.User;
  4. import java.util.List;
  5.  
  6. /**
  7.  * @program: spring-boot-example
  8.  * @description:
  9.  * @author:
  10.  * @create: 2018-05-02 10:02
  11.  **/
  12.  
  13. public interface UserService {
  14.  
  15.     User getUserById(int id);
  16.  
  17.     List<User> getUsers();
  18.  
  19.     int deleteUserById(int id);
  20.  
  21.     int updateUserById(User user);
  22.  
  23.     int insertUser(User user);
  24.  
  25. }

UserService.java

  1. package com.cn.service;
  2.  
  3. import com.cn.entity.User;
  4. import java.sql.Connection;
  5. import java.sql.PreparedStatement;
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  8. import java.util.List;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.jdbc.core.JdbcTemplate;
  11. import org.springframework.jdbc.core.PreparedStatementCreator;
  12. import org.springframework.jdbc.core.PreparedStatementSetter;
  13. import org.springframework.jdbc.core.RowMapper;
  14. import org.springframework.jdbc.support.GeneratedKeyHolder;
  15. import org.springframework.jdbc.support.KeyHolder;
  16. import org.springframework.stereotype.Service;
  17.  
  18. /**
  19.  * @program: spring-boot-example
  20.  * @description:
  21.  * @author:
  22.  * @create: 2018-05-02 10:07
  23.  **/
  24.  
  25. @Service
  26. public class UserServiceImpl implements UserService{
  27.  
  28.     @Autowired
  29.     private JdbcTemplate jdbcTemplate;
  30.  
  31.     @Override
  32.     public User getUserById(int id) {
  33.         User user = jdbcTemplate.queryForObject("select * from user where id=?", new Object[]{id},new UserRowMapper());
  34.         return user;
  35.     }
  36.  
  37.     @Override
  38.     public List<User> getUsers() {
  39.         return jdbcTemplate.query("select * from user",new UserRowMapper());
  40.     }
  41.  
  42.     @Override
  43.     public int deleteUserById(int id) {
  44.         return jdbcTemplate.update("delete from user where id=?", new PreparedStatementSetter() {
  45.             @Override
  46.             public void setValues(PreparedStatement preparedStatement) throws SQLException {
  47.                 preparedStatement.setInt(1,id);
  48.             }
  49.         });
  50.     }
  51.  
  52.     @Override
  53.     public int updateUserById(User user) {
  54.         return jdbcTemplate.update("update user SET name=?,age=?,address=? where id=?", new PreparedStatementSetter() {
  55.             @Override
  56.             public void setValues(PreparedStatement preparedStatement) throws SQLException {
  57.                 preparedStatement.setString(1,user.getName());
  58.                 preparedStatement.setInt(2,user.getAge());
  59.                 preparedStatement.setString(3,user.getAddress());
  60.                 preparedStatement.setInt(4,user.getId());
  61.             }
  62.         });
  63.     }
  64.  
  65.     @Override
  66.     public int insertUser(User user) {
  67.         String sql = "insert into user(name,age,address) VALUES (?,?,?)";
  68.         KeyHolder keyHolder = new GeneratedKeyHolder();
  69.         jdbcTemplate.update(new PreparedStatementCreator() {
  70.             @Override
  71.             public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {
  72.                 PreparedStatement preparedStatement = connection.prepareStatement(sql,new String[]{"id"});
  73.                 preparedStatement.setString(1,user.getName());
  74.                 preparedStatement.setInt(2,user.getAge());
  75.                 preparedStatement.setString(3,user.getAddress());
  76.                 return preparedStatement;
  77.             }
  78.         },keyHolder);
  79.         return Integer.parseInt(keyHolder.getKey().toString());
  80.     }
  81. }
  82. class UserRowMapper implements RowMapper<User> {
  83.  
  84.     @Override
  85.     public User mapRow(ResultSet resultSet, int i) throws SQLException {
  86.         User user=new User();
  87.         user.setId(resultSet.getInt("id"));
  88.         user.setName(resultSet.getString("name"));
  89.         user.setAge(resultSet.getInt("age"));
  90.         user.setAddress(resultSet.getString("address"));
  91.         return user;
  92.     }
  93.  
  94. }

UserServiceImpl.java

　　创建UserController：

  1. package com.cn.controller;
  2.  
  3. import com.cn.entity.User;
  4. import com.cn.service.UserService;
  5. import java.util.List;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.PathVariable;
  8. import org.springframework.web.bind.annotation.RequestBody;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RequestMethod;
  11. import org.springframework.web.bind.annotation.RestController;
  12.  
  13. /**
  14.  * @program: spring-boot-example
  15.  * @description:
  16.  * @author:
  17.  * @create: 2018-05-02 09:58
  18.  **/
  19.  
  20. @RestController
  21. public class UserController {
  22.  
  23.     @Autowired
  24.     private UserService userService;
  25.  
  26.     @RequestMapping(value = "getUserById/{id}",method = RequestMethod.GET)
  27.     public User getUserById(@PathVariable int id) {
  28.         return userService.getUserById(id);
  29.     }
  30.  
  31.     @RequestMapping("getUsers")
  32.     public List<User> getUsers() {
  33.         return userService.getUsers();
  34.     }
  35.  
  36.     @RequestMapping(value = "updateUserById",method = RequestMethod.POST)
  37.     public int updateUserByUd(User user) {
  38.         return userService.updateUserById(user);
  39.     }
  40.  
  41.     @RequestMapping(value = "insertUser",method = RequestMethod.POST)
  42.     public int insertUser(User user) {
  43.         return userService.insertUser(user);
  44.     }
  45.  
  46.     @RequestMapping(value = "deleteUserById/{id}",method = RequestMethod.DELETE)
  47.     public int deleteUserById(@PathVariable int id) {
  48.         return userService.deleteUserById(id);
  49.     }
  50. }

UserController.java

　　使用Postman工具测试（有两种：浏览器插件版，安装版，我用的是安装版），这里简单列举几个测试结果：

　　

　　

　　

三、JpaRepository

　　Java Persistence API是一种标准技术，可以将对象“映射”到关系数据库。spring-boot-starter-data-jpa POM提供了一种快速入门的方法。它提供了以下关键依赖项:

  • Hibernate: One of the most popular JPA implementations.
  • Spring Data JPA: Makes it easy to implement JPA-based repositories.
  • Spring ORMs: Core ORM support from the Spring Framework.

　　使用方法：创建持久层实现接口，并用接口实现JpaRepository<%Bean%,%PrimaryKey%>（Bean为实体类，PrimaryKey为实体类的主键，在JpaRepository中已经有部分接口方法，视情况自加）；

　　增加pom库的依赖：

  1. <!-- spring-data-jpa -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-data-jpa</artifactId>
  5. </dependency>

　　创建实体类Student（注意要声明实体类的注解，@Entity、@Id）：

  1. package com.cn.entity;
  2.  
  3. import javax.persistence.Entity;
  4. import javax.persistence.GeneratedValue;
  5. import javax.persistence.Id;
  6.  
  7. /**
  8.  * @program: spring-boot-example
  9.  * @description: 学生实体类
  10.  * @author:
  11.  * @create: 2018-05-02 10:47
  12.  **/
  13.  
  14. @Entity
  15. public class Student {
  16.  
  17.     @Id
  18.     @GeneratedValue
  19.     private int id;
  20.  
  21.     private String name;
  22.  
  23.     private int age;
  24.  
  25.     private int grade;
  26.  
  27.     @Override
  28.     public String toString() {
  29.         return "Student{" +
  30.             "id=" + id +
  31.             ", name='" + name + '\'' +
  32.             ", age=" + age +
  33.             ", grade=" + grade +
  34.             '}';
  35.     }
  36.  
  37.     public int getId() {
  38.         return id;
  39.     }
  40.  
  41.     public void setId(int id) {
  42.         this.id = id;
  43.     }
  44.  
  45.     public String getName() {
  46.         return name;
  47.     }
  48.  
  49.     public void setName(String name) {
  50.         this.name = name;
  51.     }
  52.  
  53.     public int getAge() {
  54.         return age;
  55.     }
  56.  
  57.     public void setAge(int age) {
  58.         this.age = age;
  59.     }
  60.  
  61.     public int getGrade() {
  62.         return grade;
  63.     }
  64.  
  65.     public void setGrade(int grade) {
  66.         this.grade = grade;
  67.     }
  68. }

Student.java

　　创建StudentService接口，StudentServiceImpl实现类：

  1. package com.cn.service;
  2.  
  3. import com.cn.entity.Student;
  4.  
  5. /**
  6.  * @program: spring-boot-example
  7.  * @description:
  8.  * @author:
  9.  * @create: 2018-05-02 11:12
  10.  **/
  11. public interface StudentService {
  12.  
  13.     Student findByName(String name);
  14.  
  15.     Student findByNameAndAge(String name, Integer age);
  16.  
  17.     Student findUser(String name);
  18.  
  19. }

StudentService.java

  1. package com.cn.service;
  2.  
  3. import com.cn.dao.StudentDao;
  4. import com.cn.entity.Student;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  7.  
  8. /**
  9.  * @program: spring-boot-example
  10.  * @description:
  11.  * @author:
  12.  * @create: 2018-05-02 11:13
  13.  **/
  14. @Service
  15. public class StudentServiceImpl implements StudentService{
  16.  
  17.     @Autowired
  18.     private StudentDao studentDao;
  19.  
  20.     @Override
  21.     public Student findByName(String name) {
  22.         return studentDao.findByName(name);
  23.     }
  24.  
  25.     @Override
  26.     public Student findByNameAndAge(String name, Integer age) {
  27.         return studentDao.findByNameAndAge(name,age);
  28.     }
  29.  
  30.     @Override
  31.     public Student findUser(String name) {
  32.         return studentDao.findUser(name);
  33.     }
  34. }

StudentServiceImpl.java

　　创建StudentController：

  1. package com.cn.controller;
  2.  
  3. import com.cn.entity.Student;
  4. import com.cn.service.StudentService;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.PathVariable;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RequestParam;
  9. import org.springframework.web.bind.annotation.RestController;
  10.  
  11. /**
  12.  * @program: spring-boot-example
  13.  * @description:
  14.  * @author:
  15.  * @create: 2018-05-02 11:15
  16.  **/
  17. @RestController
  18. public class StudentController {
  19.  
  20.     @Autowired
  21.     private StudentService studentService;
  22.  
  23.     @RequestMapping("findByName/{name}")
  24.     public Student findByName(@PathVariable String name) {
  25.         return studentService.findByName(name);
  26.     }
  27.  
  28.     @RequestMapping("findByNameAndAge")
  29.     public Student findByNameAndAge(@RequestParam("name") String name,@RequestParam("age") Integer age) {
  30.         return studentService.findByNameAndAge(name,age);
  31.     }
  32.  
  33.     @RequestMapping("findUser/{name}")
  34.     public Student findUser(@PathVariable String name) {
  35.         return studentService.findUser(name);
  36.     }
  37. }

StudentController.java

　　同样适用Postman测试，结果如下：

　　

　　

完整示例：https://gitee.com/lfalex/spring-boot-example

参考官方文档：https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#boot-documentation

（三）SpringBoot基础篇- 持久层，jdbcTemplate和JpaRespository的更多相关文章

  1. （三）SpringBoot2.0基础篇- 持久层，jdbcTemplate和JpaRespository

    一.介绍 SpringBoot框架为使用SQL数据库提供了广泛的支持,从使用JdbcTemplate的直接JDBC访问到完整的“对象关系映射”技术(如Hibernate).Spring-data-jp ...

  2. （二）SpringBoot基础篇- 静态资源的访问及Thymeleaf模板引擎的使用

    一.描述 在应用系统开发的过程中,不可避免的需要使用静态资源(浏览器看的懂,他可以有变量,例:HTML页面,css样式文件,文本,属性文件,图片等): 并且SpringBoot内置了Thymeleaf ...

  3. 视频作品《springboot基础篇》上线了

    1.场景描述 第一个视频作品出炉了,<springboot基础篇>上线了,有需要的朋友可以直接点击链接观看.(如需购买,请通过本文链接购买) 2. 课程内容 课程地址:https://ed ...

  4. Python（三）基础篇之「模块&面向对象编程」

    [笔记]Python(三)基础篇之「模块&面向对象编程」 2016-12-07 ZOE    编程之魅  Python Notes: ★ 如果你是第一次阅读,推荐先浏览:[重要公告]文章更新. ...

  5. SpringBoot基础篇-SpringBoot快速入门

    SpringBoot基础 学习目标: 能够理解Spring的优缺点 能够理解SpringBoot的特点 能够理解SpringBoot的核心功能 能够搭建SpringBoot的环境 能够完成applic ...

  6. （一）SpringBoot基础篇- 介绍及HelloWorld初体验

    1.SpringBoot介绍: 根据官方SpringBoot文档描述,BUILD ANYTHING WITH SPRING BOOT (用SPRING BOOT构建任何东西,很牛X呀!),下面是官方文 ...

  7. Springboot基础篇

    Springboot可以说是当前最火的java框架了,非常适合于"微服务"思路的开发,大幅缩短软件开发周期. 概念 过去Spring充满了配置bean的xml文件,随着spring ...

  8. SpringBoot基础篇AOP之基本使用姿势小结

    一般来讲,谈到Spring的特性,绕不过去的就是DI(依赖注入)和AOP(切面),在将bean的系列中,说了DI的多种使用姿势:接下来看一下AOP的玩法 <!-- more --> I. ...

  9. 学习笔记三：基础篇Linux基础

    Linux基础 直接选择排序>快速排序>基数排序>归并排序 >堆排序>Shell排序>冒泡排序=冒泡排序2 =直接插入排序 一.Linux磁盘分区表示 Linux中 ...

随机推荐

  1. Jeff Atwood：Google的头号UI问题

    谷歌在用户界面上追求的"极简主义"是让人叹为观止的.但是,他们首页上有个问题一直让我困惑不解.要知道,这个页面可是每天都被下载几百万次哦: 真有人在使用"I'm Feel ...

  2. 【Unity Shaders】Reflecting Your World —— Unity3D中简单的Cubemap反射

    本系列主要参考<Unity Shaders and Effects Cookbook>一书(感谢原书作者),同时会加上一点个人理解或拓展. 这里是本书所有的插图.这里是本书所需的代码和资源 ...

  3. MySQL学习笔记_8_SQL语言基础复习

    SQL语言基础复习 一.概述 SQL语句注释方式 1)以"#"开头直到行尾的所有内容都是注释 2)以"--"(--后还有一个空格)开头直到行尾的所有内容都是注释 ...

  4. 小强的HTML5移动开发之路（3）——HTML5与HTML4比较

    来自:http://blog.csdn.net/dawanganban/article/details/17652873 在前面介绍了HTML5的新特性,新标签的使用,智能表单设计,引入多媒体对象,C ...

  5. 分布式进阶(十六)Zookeeper入门基础

    Zookeeper入门基础 前言 在Zookeeper中,znode是一个跟Unix文件系统路径相似的节点,可以往这个节点存储或获取数据.如果在创建znode时Flag设置为EPHEMERAL,那么当 ...

  6. android加载大图，防止oom

    高效加载大图片 我们在编写Android程序的时候经常要用到许多图片,不同图片总是会有不同的形状.不同的大小,但在大多数情况下,这些图片都会大于我们程序所需要的大小.比如说系统图片库里展示的图片大都是 ...

  7. Rust语言之HelloWorld

    Rust语言之HelloWorld 参考文档: http://doc.crates.io/guide.html 1 什么是Cargo 相当于maven/ant之于java, automake之于c, ...

  8. 通过Java进行网页抓取并生成plist创建代码

    抓取网页的方法: 抓取网页可以通过正则表达式也可以通过Java. 通过firefox浏览器,安装Firebug来查看网页的源代码. 首先将要抓取的部分保存到本地,步骤如下: 1.在要抓取的位置右键,选 ...

  9. sublime text （ST）一篇通（安装、配置、扩展、使用）

    sublime编辑器,功能插件多,可以扩展为IDE------------------------------------------- 1.安装 官网下载  http://www.sublimete ...

  10. [Python]Flask构建网站分析应用

    原文Saturday morning hacks: Building an Analytics App with Flask - 由orangleliu友情翻译 ,主要是通过埋点技术来实现web网页的 ...