devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Springboot整合Mybatis增删查改、连接MYSQL数据库及配置druid连接池_项目搭建:创建建一个名称为mybatiscrud的项目,并在项目中引入 mysql 驱动包、 jun

作者：花生_TL007 | 2024-03-14 09:08:51

赞

踩

项目搭建:创建建一个名称为mybatiscrud的项目,并在项目中引入 mysql 驱动包、 jun

为了帮助初学者学习（毕竟当初也是这么过来，在网上就想找一篇傻瓜式教程，一步步地照着去学习），我们从零开始一步一步整合Mybatis、连接MYSQL数据库及配置druid连接池。

开始吧！

首先，创建一个springboot项目，在依赖勾选时，如下：

接着点next，next，创建springboot项目结束，以下为创建完成后的pom.xml文件：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.1.3.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.test</groupId>
  12.     <artifactId>mybatis</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>mybatis</name>
  15.     <description>Demo project for Spring Boot</description>
  16.  
  17.     <properties>
  18.         <java.version>1.8</java.version>
  19.     </properties>
  20.  
  21.     <dependencies>
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter-jdbc</artifactId>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>org.springframework.boot</groupId>
  28.             <artifactId>spring-boot-starter-web</artifactId>
  29.         </dependency>
  30.         <dependency>
  31.             <groupId>org.mybatis.spring.boot</groupId>
  32.             <artifactId>mybatis-spring-boot-starter</artifactId>
  33.             <version>2.0.0</version>
  34.         </dependency>
  35.  
  36.         <dependency>
  37.             <groupId>mysql</groupId>
  38.             <artifactId>mysql-connector-java</artifactId>
  39.             <scope>runtime</scope>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>org.springframework.boot</groupId>
  43.             <artifactId>spring-boot-starter-test</artifactId>
  44.             <scope>test</scope>
  45.         </dependency>
  46.     </dependencies>
  47.  
  48.     <build>
  49.         <plugins>
  50.             <plugin>
  51.                 <groupId>org.springframework.boot</groupId>
  52.                 <artifactId>spring-boot-maven-plugin</artifactId>
  53.             </plugin>
  54.         </plugins>
  55.     </build>
  56.  
  57. </project>

ok，在整合mybatis之前，我们先把连接MYSQL相关的给配置好，因为我们这里顺便用到了 druid连接池，一并配置这两玩意先。

到这，你可能会想，配置连接池做啥？有啥用？ 这里简单做个介绍（来自网文）：

连接池的意义及阿里Druid

 建立数据库连接是相当耗时和耗费资源的，而且一个数据库服务器能够同时建立的连接数也是有限的，在大型的Web应用中，可能同时会有成百上千个访问数据库的请求，如果Web应用程序为每一个客户请求分配一个数据库连接，将导致性能的急剧下降。为了能够重复利用数据库连接，提高对请求的响应时间和服务器的性能，可以采用连接池技术。连接池技术预先建立多个数据库连接对象，然后将连接对象保存到连接池中，当客户请求到来时，从池中取出一个连接对象为客户服务，当请求完成后，客户程序调用close（）方法，将连接对象放回池中。

     在普通的数据库访问程序中，客户程序得到的连接对象是物理连接，调用连接对象的close()方法将关闭连接，而采用连接池技术，客户程序得到的连接对象是连接池中物理连接的一个句柄，调用连接对象的close（）方法，物理连接并没有关闭，数据源的实现只是删除了客户程序中的连接对象和池中的连接对象之间的联系。

 好了，不废话，我们马上行动。

惯例，先导入相关依赖包（由于mysql及数据库操作等依赖在项目开始创建时已经勾选，这里我们仅需要加入druid连接池的依赖包）：

  1. <!-- druid数据源驱动 1.1.10解决springboot从1.0——2.0版本问题-->
  2. <dependency>
  3.     <groupId>com.alibaba</groupId>
  4.     <artifactId>druid-spring-boot-starter</artifactId>
  5.     <version>1.1.10</version>
  6. </dependency>

OK，接下来，依赖导入完毕了，那当然是要编写配置文件了，这里我们使用yml格式，因为个人感觉看起来清晰些。

 

  1. spring:
  2.   datasource:
  3.     druid:
  4.       username: root
  5.       password: 123456
  6.       url: jdbc:mysql://localhost:3306/world?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&zeroDateTimeBehavior=convertToNull
  7.       #      driver-class-name: com.mysql.jdbc.Driver
  8.       initialSize: 5
  9.       minIdle: 5
  10.       maxActive: 20
  11.       maxWait: 60000
  12.       timeBetweenEvictionRunsMillis: 60000
  13.       minEvictableIdleTimeMillis: 300000
  14.       validationQuery: SELECT 1 FROM DUAL
  15.       testWhileIdle: true
  16.       testOnBorrow: false
  17.       testOnReturn: false
  18.       poolPreparedStatements: true
  19.       maxPoolPreparedStatementPerConnectionSize: 20
  20.       useGlobalDataSourceStat: true
  21.       connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

配置完后，我们先运行下项目，

可以看到，完美运行，那意思是数据库连接没有问题，  druid连接池也配置完毕了。

当然我们也可以进入druid的监控页面看看（现在还没对数据库进行增删改查~大家可以随便点点，可以看到只有关于连接的监控日志数据），http://localhost:8080/druid/

数据连接池，就先放着吧，我们来来来，整合mybatis！

依赖包已经在创建项目的时候，勾选了，那么我们仅需要做相关配置了。

事不宜迟，我们先创建一个用于放mybatis的xml配置文件的文件夹：

文件夹创建好了，我们需要弄啥配置文件呢？  除了编写sql语句的mapper.xml，我们仅需编写一个配置文件，

那就是mybatis-config.xml：

（如果想了解更多配置项，可以看看我的这篇博客mybatis-config配置文件各项简单介绍_默默不代表沉默-CSDN博客）

这里我们做了简单点的配置，就是驼峰命名的开启，允许jdbc操作主键的生成，允许取别名。

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.  
  7.         <settings>
  8.                 <setting name="useGeneratedKeys" value="true"/>
  9.                 <setting name="useColumnLabel" value="true"/>
  10.                 <setting name="mapUnderscoreToCamelCase" value="true"/>
  11.         </settings>
  12.         </configuration>
  13.  
  14.

然后是在yml配置文件里加上配置（一定得加上！！！ 否则配置文件读取不了，那还配置做啥！）， 

  1. mybatis:
  2.   config-location: classpath:mybatis/mybatis-config.xml
  3.   mapper-locations: classpath:mybatis/mapper/*.xml

好了，到这里，基本配置的都七七八八了，那么接下来就是在springboot项目里面，使用mybatis对mysql数据做增删改查了（顺便可以利用druid连接池看看监控日志） 

 我们先在本地的mysql数据库创个简单的表（主键别忘记勾选自增，在mysql里就是那个“AI”），

 

好了，一切准备就绪，我们开始CRUD操作，简单使用下。

 先创建下目录文件夹，

然后开始编码！ （终于到写代码了！！）

首先，先从实体类pojo开始，对照着数据，我们创建一个实体类User.java（把set、get方法，tostring方法、构造方法都搞下）：

 这里需要注意的是，因为数据库字段有下划线“_”，所以我们也在mybatis-config文件中特意开启了驼峰命名，所以字段对应的编写方式要注意了。

  1. package com.test.mybatis.pojo;
  2.  
  3. /**
  4.  * @Author : JCccc
  5.  * @CreateTime : 2019-3-1
  6.  * @Description :
  7.  * @Point: Keep a good mood
  8.  **/
  9. public class User {
  10.  
  11.     private Integer id;
  12.     private String  userName;
  13.     private String  userAge;
  14.  
  15.     @Override
  16.     public String toString() {
  17.         return "User{" +
  18.                 "id=" + id +
  19.                 ", userName='" + userName + '\'' +
  20.                 ", userAge='" + userAge + '\'' +
  21.                 '}';
  22.     }
  23.  
  24.     public User() {
  25.         
  26.     }
  27.  
  28.     public User(Integer id, String userName, String userAge) {
  29.         this.id = id;
  30.         this.userName = userName;
  31.         this.userAge = userAge;
  32.     }
  33.     
  34.     
  35.  
  36.     public Integer getId() {
  37.         return id;
  38.     }
  39.  
  40.     public void setId(Integer id) {
  41.         this.id = id;
  42.     }
  43.  
  44.     public String getUserName() {
  45.         return userName;
  46.     }
  47.  
  48.     public void setUserName(String userName) {
  49.         this.userName = userName;
  50.     }
  51.  
  52.     public String getUserAge() {
  53.         return userAge;
  54.     }
  55.  
  56.     public void setUserAge(String userAge) {
  57.         this.userAge = userAge;
  58.     }
  59. }

 好了，实体类，简简单单创建完了，接下来是mapper层。

在mapper层，创建一个UserMapper.java（因为是该篇是介绍如何整合，所以增删改查我就一次性都写了，调用的时候分开调用给大家展示下）：

这里注意了，@Mapper注解别忘了。

  1. package com.test.mybatis.mapper;
  2.  
  3. import com.test.mybatis.pojo.User;
  4. import org.apache.ibatis.annotations.Mapper;
  5.  
  6. import java.util.List;
  7.  
  8. /**
  9.  * @Author : JCccc
  10.  * @CreateTime : 2019-3-1
  11.  * @Description :
  12.  * @Point: Keep a good mood
  13.  **/
  14. @Mapper
  15. public interface UserMapper {
  16.  
  17.     /**
  18.      * 添加user信息
  19.      * @param user
  20.      * @return
  21.      */
  22.     int insertUser(User user);
  23.  
  24.     /**
  25.      * 根据ID查询经销商信息
  26.      * @param id
  27.      * @return
  28.      */
  29.     User getUserInfoById(int id);
  30.  
  31.     /**
  32.      * 查询所有用户信息
  33.      * @return
  34.      */
  35.     List<User> queryUserInfo();
  36.  
  37.     /**
  38.      * 更新用户信息
  39.      * @param user
  40.      * @return
  41.      */
  42.     int updateUserInfoById(User user);
  43.  
  44.     /**
  45.      * 删除用户信息
  46.      * @param id
  47.      * @return
  48.      */
  49.     int deleteUserInfoById(int id);
  50. } 

好了mapper层接口也已经写好了，下面是编写对应的SQL语句了，创建一个userMapper.xml：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.test.mybatis.mapper.UserMapper">
  6.  
  7.  
  8. </mapper>

这里需要注意的是， mapper的命名空间路径一定要写对了，这样写在这里的数据库语句才能根据对应的名称去路径下的mapper文件里适配对应的增删改查方法。

接下来，我们补全对应的增删改查方法：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.test.mybatis.mapper.UserMapper">
  6.  
  7.  
  8.     <!-- 添加用户信息-->
  9.     <insert id="insertUser" useGeneratedKeys="true" keyProperty="id" keyColumn="id"
  10.             parameterType="com.test.mybatis.pojo.User">
  11.         insert into
  12.         user(id,user_name,user_age)
  13.         values (#{id},#{userName},#{userAge})
  14.     </insert>
  15.  
  16.     <!--通过iD查找用户信息-->
  17.     <select id="getUserInfoById" resultType="com.test.mybatis.pojo.User" parameterType="int">
  18.        select *
  19.        from user
  20.        where id=#{id}
  21.     </select>
  22.  
  23.     <!--查询所有用户信息-->
  24.     <select id="queryUserInfo" resultType="com.test.mybatis.pojo.User">
  25.        select *
  26.        from user
  27.     </select>
  28.  
  29.  
  30.     <!--修改用户信息-->
  31.     <update id="updateUserInfoById" parameterType="com.test.mybatis.pojo.User">
  32.       update user
  33.       set id=#{id},user_name=#{userName},user_age=#{userAge}
  34.       where id=#{id}
  35.     </update>
  36.  
  37.     <!--删除用户信息-->
  38.     <delete id="deleteUserInfoById" parameterType="int">
  39.         delete 
  40.         from user
  41.         where id=#{id}
  42.     </delete>
  43. </mapper>

好了，mapper这边的算是全部完毕，紧接着到service业务层：

UserService.java：

  1. package com.test.mybatis.service;
  2.  
  3.  
  4. import com.test.mybatis.pojo.User;
  5.  
  6. import java.util.List;
  7.  
  8. /**
  9.  * @Author : JCccc
  10.  * @CreateTime : 2019-3-1
  11.  * @Description :
  12.  * @Point: Keep a good mood
  13.  **/
  14.  
  15. public interface UserService {
  16.     //添加
  17.     boolean insertUser(User user);
  18.  
  19.     //按id查找
  20.     User getUserInfoById(int id);
  21.  
  22.     //查询所有
  23.     List<User> queryUserInfo();
  24.  
  25.     //更新
  26.     boolean updateUserInfoById(User user);
  27.  
  28.     //删除
  29.     boolean deleteUserInfoById(int id);
  30. }

UserSerciceImpl.java:

(@Service 注解不能忘记！而且记得注入对于的mapper接口，也就是@Autowired
    UserMapper userMapper；认真看代码的话，你会发现我在增加和修改的方法都开启了事务注解)

  1. package com.test.mybatis.service.impl;
  2.  
  3. import com.test.mybatis.mapper.UserMapper;
  4. import com.test.mybatis.pojo.User;
  5. import com.test.mybatis.service.UserService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  8. import org.springframework.transaction.annotation.Transactional;
  9.  
  10. import java.util.List;
  11.  
  12. /**
  13.  * @Author : JCccc
  14.  * @CreateTime : 2019-3-1
  15.  * @Description :
  16.  * @Point: Keep a good mood
  17.  **/
  18. @Service
  19. public class UserServiceImpl implements UserService {
  20.  
  21.     @Autowired
  22.     UserMapper userMapper;
  23.  
  24.     /**
  25.      * 添加
  26.      * @param user
  27.      * @return
  28.      */
  29.     @Transactional
  30.     @Override
  31.     public boolean insertUser(User user) {
  32.  
  33.         if(user.getUserName()!=null&&!"".equals(user.getUserName())){
  34.  
  35.             try{
  36.                 //对mysql数据库做增加操作后，影响的行数effecteNum
  37.                 int effectNum= userMapper.insertUser(user);
  38.  
  39.                 if(effectNum>0){
  40.                     //如果影响行数大于0，那么就是增加成功
  41.                     System.out.println("增加成功，主键为："+user.getId());
  42.                     return true;
  43.                 }else {
  44.                     throw  new RuntimeException("插入信息失败,插入行数有误");
  45.                 }
  46.             }catch (Exception e){
  47.                 throw  new RuntimeException("插入信息失败了:"+e.getMessage());
  48.             }
  49.  
  50.         }else{
  51.             throw new RuntimeException("信息不能为空！！！！");
  52.         }
  53.  
  54.  
  55.     }
  56.  
  57.     /**
  58.      * 按id查找
  59.      * @param id
  60.      * @return
  61.      */
  62.     @Override
  63.     public User getUserInfoById(int id) {
  64.         return userMapper.getUserInfoById(id);
  65.     }
  66.  
  67.     /**
  68.      * 查询所有
  69.      * @return
  70.      */
  71.     @Override
  72.     public List<User> queryUserInfo() {
  73.         return userMapper.queryUserInfo();
  74.     }
  75.  
  76.     /**
  77.      * 更新
  78.      * @param user
  79.      * @return
  80.      */
  81.     @Transactional
  82.     @Override
  83.     public boolean updateUserInfoById(User user) {
  84.         if(user.getId()!=null&&!"".equals(user.getId())){
  85.  
  86.             try{
  87.                 //对mysql数据库做更新操作后，影响的行数effecteNum
  88.                 int effectNum= userMapper.updateUserInfoById(user);
  89.  
  90.                 if(effectNum>0){
  91.                     //如果影响行数大于0，那么就是更新成功
  92.                     System.out.println("更新成功，主键为："+user.getId());
  93.                     return true;
  94.                 }else {
  95.                     throw  new RuntimeException("更新信息失败,插入行数有误");
  96.                 }
  97.             }catch (Exception e){
  98.                 throw  new RuntimeException("更新信息失败了:"+e.getMessage());
  99.             }
  100.  
  101.         }else{
  102.             throw new RuntimeException("信息不能为空！！！！");
  103.         }
  104.  
  105.     }
  106.  
  107.     /**
  108.      * 删除
  109.      * @param id
  110.      * @return
  111.      */
  112.     @Override
  113.     public boolean deleteUserInfoById(int id) {
  114.  
  115.  
  116.         try {
  117.             //对mysql数据库做删除操作后，影响的行数effecteNum
  118.             int effectNum= userMapper.deleteUserInfoById(id);
  119.             if (effectNum>0){
  120.                 return true;
  121.             }else {
  122.                 return false;
  123.             }
  124.  
  125.         } catch (Exception e) {
  126.             e.printStackTrace();
  127.             return false;
  128.         }
  129.     }
  130. }

 servcie层写完了，到最后的controller控制层，写调试接口了，UserController.java：

（注意了。@RestController注解不能忘，而且需要注入调用的serviceImpl，也就是@Autowired
    UserServiceImpl userService）

  1. package com.test.mybatis.controller;
  2.  
  3. import com.test.mybatis.pojo.User;
  4. import com.test.mybatis.service.impl.UserServiceImpl;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.*;
  7.  
  8. import java.util.List;
  9. import java.util.Map;
  10.  
  11. /**
  12.  * @Author : JCccc
  13.  * @CreateTime : 2019-3-1
  14.  * @Description :
  15.  * @Point: Keep a good mood
  16.  **/
  17. @RestController
  18. public class UserController {
  19.  
  20.     @Autowired
  21.     UserServiceImpl userService;
  22.  
  23.     /**
  24.      * 增加
  25.      * @param userMap
  26.      * @return
  27.      */
  28.     @PostMapping("/insertUserInfo")
  29.     public  String insertUserInfo(@RequestBody Map<String,String> userMap){
  30.         User user=new User();
  31.         user.setUserName(userMap.get("userName"));
  32.         user.setUserAge(userMap.get("userAge"));
  33.        boolean result= userService.insertUser(user);
  34.        if (result){
  35.            return "success";
  36.        }else {
  37.            return "fail";
  38.        }
  39.     }
  40.  
  41.     /**
  42.      * 按id查找
  43.      * @param id
  44.      * @return
  45.      */
  46.     @GetMapping("/getUserInfoById/{id}")
  47.     public  String getUserInfoById(@PathVariable("id") int id){
  48.  
  49.         User user= userService.getUserInfoById(id);
  50.         return user.toString();
  51.     }
  52.  
  53.     /**
  54.      * 查询所有
  55.      * @return
  56.      */
  57.     @GetMapping("/queryUserInfo")
  58.     public  String getAllUserInfo(){
  59.  
  60.         List<User> userList= userService.queryUserInfo();
  61.         return userList.toString();
  62.     }
  63.  
  64.     /**
  65.      * 更新
  66.      * @param userMap
  67.      * @return
  68.      */
  69.     @PostMapping("/updateUserInfoById")
  70.     public  String updateUserInfoById(@RequestBody Map<String,String> userMap){
  71.         User user=new User();
  72.         user.setId(Integer.valueOf(userMap.get("id")));
  73.         user.setUserName(userMap.get("userName"));
  74.         user.setUserAge(userMap.get("userAge"));
  75.         boolean result= userService.updateUserInfoById(user);
  76.         if (result){
  77.             return "success";
  78.         }else {
  79.             return "fail";
  80.         }
  81.     }
  82.  
  83.     /**
  84.      * 删除
  85.      * @param id
  86.      * @return
  87.      */
  88.     @DeleteMapping("/deleteUserInfoById/{id}")
  89.     public  String deleteUserInfoById(@PathVariable("id") int id){
  90.  
  91.         boolean result= userService.deleteUserInfoById(id);
  92.         if (result){
  93.             return "success";
  94.         }else {
  95.             return "fail";
  96.         }
  97.     }
  98.  
  99.  
  100. }

好了，用postman工具简单调试下，看看整体效果：

 ①先调用一下增加用户信息接口，

再看看数据库，

 

 ②接下来我们试试按照id查找用户信息（重复调用多几次插入多几个用户信息，方便数据操作）：

③接着试下按照id查找用户信息：

④查询所有用户信息：

 

⑤更新（修改）用户信息：


 

⑥最后是试下删除接口（删除掉id为3的用户信息）：

 

好了，到这里，对于springboot连接mysql数据，整合mybatis框架进行增删查改已经介绍完毕了。

没错，我们还配置了 druid连接池，刚刚操作了这么就数据库，不妨进去看看监控日志（http://localhost:8080/druid）：

好了，这边从零整合mybatis就到这里了，完整看完的你，已经可以去搬砖了，增删改查哈哈哈（当然想要了解高级一点的，可以看我的springboot博客栏目，里面我也写了很多springboot从零整合的技术实用介绍）。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/232859
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号