数据库操作之整合Mybaties和事务讲解 5节课

Posted 2021-02-02 116970u

1、SpringBoot2.x持久化数据方式介绍
    
     简介：介绍近几年常用的访问数据库的方式和优缺点

        1、原始java访问数据库
             开发流程麻烦
             1、注册驱动/加载驱动
                 Class.forName("com.mysql.jdbc.Driver")
             2、建立连接
                 Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/dbname","root","root");
             3、创建Statement

             4、执行SQL语句

             5、处理结果集

             6、关闭连接，释放资源

        2、apache dbutils框架
             比上一步简单点
             官网:https://commons.apache.org/proper/commons-dbutils/
         3、jpa框架
             spring-data-jpa
             jpa在复杂查询的时候性能不是很好
        
         4、Hiberante   解释：ORM：对象关系映射Object Relational Mapping
             企业大都喜欢使用hibernate
        
         5、Mybatis框架  
             互联网行业通常使用mybatis
             不提供对象和关系模型的直接映射,半ORM
        

2、SpringBoot2.x整合Mybatis3.x注解实战
     简介：SpringBoot2.x整合Mybatis3.x注解配置实战

        1、使用starter, maven仓库地址：http://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter

        2、加入依赖(可以用 http://start.spring.io/ 下载)
                    
             <!-- 引入starter-->
                     <dependency>
                         <groupId>org.mybatis.spring.boot</groupId>
                         <artifactId>mybatis-spring-boot-starter</artifactId>
                         <version>1.3.2</version>
                         <scope>runtime</scope>               
                     </dependency>
                     
              <!-- MySQL的JDBC驱动包    -->   
                      <dependency>
                         <groupId>mysql</groupId>
                         <artifactId>mysql-connector-java</artifactId>
                         <scope>runtime</scope>
                     </dependency>
             <!-- 引入第三方数据源 -->       
                     <dependency>
                         <groupId>com.alibaba</groupId>
                         <artifactId>druid</artifactId>
                         <version>1.1.6</version>
                     </dependency>

        3、加入配置文件
             #mybatis.type-aliases-package=net.xdclass.base_project.domain
             #可以自动识别
             #spring.datasource.driver-class-name =com.mysql.jdbc.Driver

            spring.datasource.url=jdbc:mysql://localhost:3306/movie?useUnicode=true&characterEncoding=utf-8
             spring.datasource.username =root
             spring.datasource.password =password
             #如果不使用默认的数据源 （com.zaxxer.hikari.HikariDataSource）
             spring.datasource.type =com.alibaba.druid.pool.DruidDataSource

        加载配置，注入到sqlSessionFactory等都是springBoot帮我们完成

        4、启动类增加mapper扫描
             @MapperScan("net.xdclass.base_project.mapper")

             技巧：保存对象，获取数据库自增id
              @Options(useGeneratedKeys=true, keyProperty="id", keyColumn="id")

              说明：keyProperty java对象的属性；keyColumn表示数据库的字段

        4、开发mapper
             参考语法 http://www.mybatis.org/mybatis-3/zh/java-api.html

        5、sql脚本
             CREATE TABLE `user` (
               `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
               `name` varchar(128) DEFAULT NULL COMMENT ‘名称‘,
               `phone` varchar(16) DEFAULT NULL COMMENT ‘用户手机号‘,
               `create_time` datetime DEFAULT NULL COMMENT ‘创建时间‘,
               `age` int(4) DEFAULT NULL COMMENT ‘年龄‘,
               PRIMARY KEY (`id`)
             ) ENGINE=InnoDB AUTO_INCREMENT=18 DEFAULT CHARSET=utf8;

controller——存放api

domain——存放实体类

mapper/dao——访问数据库接口

service——业务层

utils——工具类

代码实例：

controller/UserController.java：

  1 package net.xdclass.base_project.controller;
  2 
  3 
  4 import java.util.Date;
  5 
  6 import net.xdclass.base_project.domain.JsonData;
  7 import net.xdclass.base_project.domain.User;
  8 import net.xdclass.base_project.service.UserService;
  9 
 10 import org.springframework.beans.factory.annotation.Autowired;
 11 import org.springframework.web.bind.annotation.GetMapping;
 12 import org.springframework.web.bind.annotation.RequestMapping;
 13 import org.springframework.web.bind.annotation.RestController;
 14 
 15 @RestController
 16 @RequestMapping("/api/v1/user")
 17 public class UserController {
 18 
 19 
 20 	@Autowired
 21 	private UserService userService;
 22 
 23 
 24 	/**
 25 	 * 功能描述: user 保存接口
 26 	 * @return
 27 	 */
 28 	@GetMapping("add")
 29 	public Object add(){
 30 
 31 		User user = new User();
 32 		user.setAge(11);
 33 		user.setCreateTime(new Date());
 34 		user.setName("xdclass");
 35 		user.setPhone("10010000");
 36 		int id = userService.add(user);
 37 
 38        return JsonData.buildSuccess(id);
 39 	}
 40 
 41 //	@Autowired
 42 //	private UserMapper userMapper;
 43 //	
 44 //	
 45 //	
 46 //	@GetMapping("findAll")
 47 //	public Object findAll(){
 48 //		
 49 //       return JsonData.buildSuccess(userMapper.getAll());
 50 //	}
 51 //	
 52 //	
 53 //	
 54 //	@GetMapping("findById")
 55 //	public Object findById(long id){
 56 //       return JsonData.buildSuccess(userMapper.findById(id));
 57 //	}
 58 //	
 59 //	
 60 //	@GetMapping("del_by_id")
 61 //	public Object delById(long id){
 62 //	userMapper.delete(id);
 63 //       return JsonData.buildSuccess();
 64 //	}
 65 //	
 66 //	@GetMapping("update")
 67 //	public Object update(String name,int id){
 68 //		User user = new User();
 69 //		user.setName(name);
 70 //		user.setId(id);
 71 //		userMapper.update(user);
 72 //	    return JsonData.buildSuccess();
 73 //	}
 74 //	
 75 
 76 //	//测试事务
 77 //	@GetMapping("transac")
 78 //	public Object transac(){
 79 //		int id = userService.addAccount();
 80 //	    return JsonData.buildSuccess(id);
 81 //	}
 82 //	
 83 //	
 84 
 85 }
 86 

实体类User.java：

  1 package net.xdclass.base_project.domain;
  2 
  3 import java.util.Date;
  4 
  5 public class User {
  6 
  7 	private int id;
  8 
  9 	private String name;
 10 
 11 	private String phone;
 12 
 13 	private int age;
 14 
 15 	private Date createTime;
 16 
 17 	public int getId() {
 18 		return id;
 19 	}
 20 
 21 	public void setId(int id) {
 22 		this.id = id;
 23 	}
 24 
 25 	public String getName() {
 26 		return name;
 27 	}
 28 
 29 	public void setName(String name) {
 30 		this.name = name;
 31 	}
 32 
 33 	public String getPhone() {
 34 		return phone;
 35 	}
 36 
 37 	public void setPhone(String phone) {
 38 		this.phone = phone;
 39 	}
 40 
 41 	public int getAge() {
 42 		return age;
 43 	}
 44 
 45 	public void setAge(int age) {
 46 		this.age = age;
 47 	}
 48 
 49 	public Date getCreateTime() {
 50 		return createTime;
 51 	}
 52 
 53 	public void setCreateTime(Date createTime) {
 54 		this.createTime = createTime;
 55 	}
 56 
 57 
 58 
 59 
 60 }
 61 

UserMapper.java：

  1 package net.xdclass.base_project.mapper;
  2 
  3 import net.xdclass.base_project.domain.User;
  4 
  5 import org.apache.ibatis.annotations.Insert;
  6 import org.apache.ibatis.annotations.Options;
  7 
  8 public interface UserMapper {
  9 
 10 
 11 	//推荐使用#{}取值，不要用${},因为存在注入的风险
 12 	 @Insert("INSERT INTO user(name,phone,create_time,age) VALUES(#{name}, #{phone}, #{createTime},#{age})")
 13 	 @Options(useGeneratedKeys=true, keyProperty="id", keyColumn="id")   //keyProperty java对象的属性；keyColumn表示数据库的字段
 14 	 int insert(User user);
 15 
 16 
 17 
 18 
 19 //
 20 //    @Select("SELECT * FROM user")
 21 //    @Results({
 22 //        @Result(column = "create_time",property = "createTime")  //javaType = java.util.Date.class        
 23 //    })
 24 //    List<User> getAll();
 25 //  
 26 //    
 27 //
 28 //    @Select("SELECT * FROM user WHERE id = #{id}")
 29 //    @Results({
 30 //    	 @Result(column = "create_time",property = "createTime")
 31 //    })
 32 //    User findById(Long id);
 33 //
 34 //   
 35 //
 36 //    @Update("UPDATE user SET name=#{name} WHERE id =#{id}")
 37 //    void update(User user);
 38 //
 39 //    @Delete("DELETE FROM user WHERE id =#{userId}")
 40 //    void delete(Long userId);
 41 //
 42 }

UserService.java：

  1 package net.xdclass.base_project.service;
  2 
  3 import net.xdclass.base_project.domain.User;
  4 
  5 public interface UserService {
  6 
  7 	public int add(User user);
  8 
  9 
 10 
 11 	//public int addAccount();
 12 
 13 }
 14 

UserServiceImpl.java：

  1 package net.xdclass.base_project.service.impl;
  2 
  3 import java.util.Date;
  4 
  5 import net.xdclass.base_project.domain.User;
  6 import net.xdclass.base_project.mapper.UserMapper;
  7 import net.xdclass.base_project.service.UserService;
  8 
  9 import org.springframework.beans.factory.annotation.Autowired;
 10 import org.springframework.stereotype.Service;
 11 import org.springframework.transaction.annotation.Transactional;
 12 
 13 @Service
 14 public class UserServiceImpl implements UserService{
 15 
 16 	@Autowired
 17 	private UserMapper userMapper;
 18 
 19 	@Override
 20 	public int add(User user) {
 21 		userMapper.insert(user);
 22 		int id = user.getId();
 23 		return id;
 24 	}
 25 
 26 
 27 
 28 
 29 
 30 
 31 }
 32 

浏览器输入：http://localhost:8080/api/v1/user/add

数据库查看：

添加成功

         相关资料：
         http://www.mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/#Configuration

        https://github.com/mybatis/spring-boot-starter/tree/master/mybatis-spring-boot-samples

        整合问题集合：
             https://my.oschina.net/hxflar1314520/blog/1800035
             https://blog.csdn.net/tingxuetage/article/details/80179772

3、SpringBoot2.x整合Mybatis3.x增删改查实操和控制台打印SQL语句
     讲解:SpringBoot2.x整合Mybatis3.x增删改查实操, 控制台打印sql语句
    
     1、控制台打印sql语句       
         #增加打印sql语句，一般用于本地开发测试
         mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

    2、增加mapper代码       
         @Select("SELECT * FROM user")
         @Results({
             @Result(column = "create_time",property = "createTime")  //javaType = java.util.Date.class       
         })
         List<User> getAll();
      
         @Select("SELECT * FROM user WHERE id = #{id}")
         @Results({
              @Result(column = "create_time",property = "createTime")
         })
         User findById(Long id);

        @Update("UPDATE user SET name=#{name} WHERE id =#{id}")
         void update(User user);

        @Delete("DELETE FROM user WHERE id =#{userId}")
         void delete(Long userId);
     
      3、增加API

        @GetMapping("find_all")
         public Object findAll(){
            return JsonData.buildSuccess(userMapper.getAll());
         }
        
         @GetMapping("find_by_Id")
         public Object findById(long id){
            return JsonData.buildSuccess(userMapper.findById(id));
         }
        
         @GetMapping("del_by_id")
         public Object delById(long id){
         userMapper.delete(id);
            return JsonData.buildSuccess();
         }
        
         @GetMapping("update")
         public Object update(String name,int id){
             User user = new User();
             user.setName(name);
             user.setId(id);
             userMapper.update(user);
             return JsonData.buildSuccess();
         }

4、事务介绍和常见的隔离级别，传播行为
    
     简介：讲解什么是数据库事务，常见的隔离级别和传播行为

    1、介绍什么是事务，单机事务，分布式事务处理等

    2、讲解场景的隔离级别
         Serializable： 最严格，串行处理，消耗资源大
         Repeatable Read：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据
         Read Committed：大多数主流数据库的默认事务等级
         Read Uncommitted：保证了读取过程中不会读取到非法数据。

     3、讲解常见的传播行为
         PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务,最常见的选择。

        PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。

        PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。

        PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起, 两个事务之间没有关系，一个异常，一个提交，不会同时回滚

        PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

        PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常

5、SpringBoot整合mybatis之事务处理实战
     简介：SpringBoot整合Mybatis之事务处理实战
     1、service逻辑引入事务 @Transantional(propagation=Propagation.REQUIRED)

    2、service代码
         @Override
         @Transactional
         public int addAccount() {
             User user = new User();
             user.setAge(9);
             user.setCreateTime(new Date());
             user.setName("事务测试");
             user.setPhone("000121212");
            
             userMapper.insert(user);
             int a = 1/0;

            return user.getId();
         }