• Mybatis入门

     详细的Mybatis介绍/使用，可以访问：

      地址：mybatis – MyBatis 3 | 简介

    目录

    一、Mybatis介绍

    二、依赖

    三、什么是rowmapper

    四、Mybatis demo 演示

    4.1 背景

    4.2 JDBC执行sql的流程 &Mybatis 关键要素

    4.3  项目的整体结构：

    4.4 Mybatis XML简单配置

    4.5  数据库表及对应的实体类

    4.6 mapper（封装sql）

    4.7 运行入口

    五、Mybatis 总配置

    5.1 多数据库配置

    5.2 数据库表中的字段与自定义类的属性对应关系。

    5.3 xml配置文件，使用变量properties

    六、sql注解版 mapper

    七、xml 配置 mapper ，增删改查

    7.1 xml 配置 mapper ，中sql 参数传递&查

    7.1.1 通过变量传递sql参数&查

    7.1.2 通过对象传递sql参数

    7.2 增删改

    八、注解版mapper ，增删改查

    九、获取自增主键的值

    9.1 注解mapper ，获取自增主键的值

    9.2 xml mapper ，获取自增主键的值

    十、动态sql

    10.1 背景

    10.2 xml mapper动态sql

    10.3 注解版mapper 动态sql

    十一、批量插入

    11.1 xml 批量插入

    11.2 sql注解批量插入

    十二、批量删除

    12.1 xml 批量删除

    12.2 sql注解删除

    一、Mybatis介绍

    MyBatis 可能是当前互联网公司数据库持久层框架的首页。为啥？因为Mybatis比JDBC方便。

    1、MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。

    2、MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录。 

    二、依赖

    1.     <dependencies>
    2.         <dependency>
    3.             <groupId>org.mybatis</groupId>
    4.             <artifactId>mybatis</artifactId>
    5.             <version>3.5.6</version>
    6.         </dependency>
    7.         <dependency>
    8.             <groupId>mysql</groupId>
    9.             <artifactId>mysql-connector-java</artifactId>
    10.             <version>8.0.20</version>
    11.         </dependency>

    三、什么是rowmapper

    这里强行插一下rowmapper的解释，因为我总是忘了它是干嘛的。

    row，行。数据库的中一行数据，也就是一条数据。

    mapper，映射。将一条数据，组装成一个实体类。

    我们在执行查询sql的时候，返回结果是以什么形式存在的呢？我们将返回结果组装成了我们自定义类的实例。

    rowmapper里面，就是写的我们具体组装的逻辑。如下

    1.         List tbUsers1 = testRowMapper(sql, null, new RowMapper() {
    2.  
    3.             // 重写map
    4.             @Override
    5.             public TbUser map(ResultSet rs) throws SQLException {
    6.                 TbUser tbUser = new TbUser();
    7.                 // 给tbUser赋值
    8.                 tbUser.setId(rs.getLong(1));
    9.                 tbUser.setName(rs.getString(2));
    10.                 return tbUser;
    11.             }
    12.         });

    传参中，需要传一个rowmapper，mapper就是我们具体将一条数据封装到我们自定义类里的详细逻辑。（我们将返回结果/一条数据，）组装到了我们自定义类里。

    return的时候，不是return的一大堆字符串，而是一个对象。

    四、Mybatis demo 演示

    4.1 背景

    表MyStudent

    1. CREATE TABLE `MyStudent` (
    2.   `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
    3.   `name` varchar(64) NOT NULL,
    4.   `age` int(11) NOT NULL,
    5.   PRIMARY KEY (`id`)
    6. ) ENGINE=InnoDB AUTO_INCREMENT=201200000 DEFAULT CHARSET=utf8;

    在表里插入数据

    insert into MyStudent values(201215121,'李勇',20),(201215122,'刘晨',19),(201215123,'王敏',18);

     执行查询SQL，select * from MyStudent，收集查询结果。

    4.2 JDBC执行sql的流程 &Mybatis 关键要素

    当我们使用jdbc 执行sql时，流程是这样的

    1、配置数据库的相关信息（url、username、password）等

    2、与数据库建立连接

    3、执行sql

    4、将执行sql的返回结果进行封装，返回。

    使用 Mybatis 执行sql，这几个关键步骤都是要有的，但是具体形式是不一样的。

    1、XML 配置文件中包含了对 MyBatis 系统的核心设置，包括获取数据库连接实例的数据源

    2、mapper，这些映射器的 XML 映射文件包含了 SQL 代码和映射定义信息。（啥是映射？就是将sql执行后，得到的数据，组装成我们自定义的类的实例）。

    我对mapper的理解，就是1、封装要执行的sql 2、将封装好的sql与mapper的类的方法做关联。

    当具体要执行sql的时候，我们调用mapper的某个方法，这个方法的本质就是去调用了我们封装的sql。

    4.3  项目的整体结构：

    4.4 Mybatis XML简单配置

    XML 配置文件中包含了对 MyBatis 系统的核心设置，包括获取数据库连接实例的数据源（DataSource）以及决定事务作用域和控制方式的事务管理器（TransactionManager）。后面会再探讨 XML 配置文件的详细内容，这里先给出一个简单的示例：

    xml模版：

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE configuration
    3.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.   "https://mybatis.org/dtd/mybatis-3-config.dtd">
    5. <configuration>
    6.   <environments default="development">
    7.     <environment id="development">
    8.       <transactionManager type="JDBC"/>
    9.       <dataSource type="POOLED">
    10.         <property name="driver" value="${driver}"/>
    11.         <property name="url" value="${url}"/>
    12.         <property name="username" value="${username}"/>
    13.         <property name="password" value="${password}"/>
    14.       </dataSource>
    15.     </environment>
    16.   </environments>
    17.   <mappers>
    18.     <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    19.   </mappers>
    20. </configuration>

    手动将模版中数据库相关信息，替换成自己的数据库信息。我们需要修改2个点。

    1、其中 内，配置的是数据库连接信息。

    2、 mappers 元素则包含了一组映射器（mapper），这些映射器的 XML 映射文件包含了 SQL 代码和映射定义信息。（啥是映射？就是将sql执行后，得到的数据，组装成我们自定义的类的实例）

    在resources文件夹下，新建mytatis-config.xml文件。配置我们自己的相关信息。

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE configuration
    3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.         "https://mybatis.org/dtd/mybatis-3-config.dtd">
    5. <configuration>
    6.     <environments default="development">
    7.         <environment id="development">
    8.             <transactionManager type="JDBC"/>
    9.             <dataSource type="POOLED">
    10.                 <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
    11.                 <property name="url" value="jdbc:mysql://124.70.87.136/chen?useUnicode=true&characterEncoding=UTF-8"/>
    12.                 <property name="username" value="root"/>
    13.                 <property name="password" value="$123456"/>
    14.             </dataSource>
    15.         </environment>
    16.     </environments>
    17.     <mappers>
    18.         <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    19.     </mappers>
    20. </configuration>
    21.

    注意：我们在写url时，url中符号&在xml文件中，需要转义，使用&

    如原来url

    jdbc:mysql://124.70.87.16/chen?useUnicode=true&characterEncoding=UTF-8

    转义后：

    jdbc:mysql://124.70.87.16/chen?useUnicode=true&amp;characterEncoding=UTF-8

    4.5  数据库表及对应的实体类

    在我们的项目代码中，要有一个对应的类。MyStudent类

    设置无参构造器、所有参数的构造器

    1. package beans;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6.  
    7. @Data
    8. @NoArgsConstructor
    9. @AllArgsConstructor
    10. public class MyStudent {
    11.     private long id;
    12.     private String name;
    13.     private int age;
    14.  
    15.     public MyStudent(String name, int age) {
    16.         this.name = name;
    17.         this.age = age;
    18.     }
    19. }

    4.6 mapper（封装sql）

     mappers 元素则包含了一组映射器（mapper），这些映射器的 XML 映射文件包含了 SQL 代码和映射定义信息。（啥是映射？就是将sql执行后，得到的数据，组装成我们自定义的类的实例）

    我对mapper的理解，就是1、封装要执行的sql 2、将封装好的sql与mapper的类的方法做关联。

    当具体要执行sql的时候，我们调用mapper的某个方法，这个方法的本质就是去调用了我们封装的sql。

    我们执行的是select * 的sql语句，返回结果是一个list。

    编写mapper接口----MyStudentMapper（里面就是将sql封装成了方法）

    1. package mapper;
    2.  
    3. import beans.MyStudent;
    4.  
    5. import java.util.List;
    6.  
    7. public interface MyStudentMapper {
    8.     List findAll();
    9.     MyStudent findById(long id);
    10.  
    11. }

    然后在MyStudentMapper.xml中，配置MyStudentMapper接口中的sql相关信息。

    MyStudentMapper.xml

    1. "1.0" encoding="UTF-8" ?>
    2. mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
    6. <mapper namespace="mapper.MyStudentMapper">
    7.     
    8.     
    9.     <select id="findAll" resultType="beans.MyStudent">
    10.         select * from MyStudent
    11.     select>
    12.     <select id="findById" resultType="beans.MyStudent">
    13.         select * from MyStudent where id = #{id}
    14.     select>
    15. mapper>

    解释：

    1、namespace 与mapper接口的全类名保持一致。这样将来调用mapper类方法的时候，才能找我我们这个映射

    2、id要和mapper接口的方法名保持一致，这样将来调用mapper类方法的时候，才能找我我们这个方法

    3、resultType 与sql返回值对应的类的全类名保持一致。这样才能将返回结果组装成我们自定义的实体类。（这里是通过反射实现的，通过类名，得到实例）

    4、里面有具体的sql语句。select * from MyStudent

    5、sql中的参数传递，使用#{xx}

    4.7 运行入口

    app

    1. package main;
    2.  
    3. import beans.MyStudent;
    4. import mapper.MyStudentMapper;
    5. import org.apache.ibatis.io.Resources;
    6. import org.apache.ibatis.session.SqlSession;
    7. import org.apache.ibatis.session.SqlSessionFactory;
    8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    9.  
    10. import java.io.IOException;
    11. import java.io.InputStream;
    12. import java.util.List;
    13.  
    14. public class App {
    15.     public static void main(String[] args) throws IOException {
    16.         InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
    17.         // 选择不同的数据库，指定数据库
    18.         // SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in,"test");
    19.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
    20.         SqlSession sqlSession = sqlSessionFactory.openSession();
    21.         // 得到MyStudent表的mapper    
    22.         MyStudentMapper myStudentMapper = sqlSession.getMapper(MyStudentMapper.class);
    23.         // 调用mapper的方法
    24.         List all = myStudentMapper.findAll();
    25.         System.out.println("all = " + all);
    26.         MyStudent byId = myStudentMapper.findById(201215121);
    27.         System.out.println("byId = " + byId);
    28.         sqlSession.close();
    29.  
    30.  
    31.  
    32.     }
    33. }

    解释：

    1、连接数据库，建立连接。（读取数据库配置文件，然后建立连接）

    1.         InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
    2.         // 选择不同的数据库，指定数据库
    3.         // SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in,"test");
    4.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
    5.         SqlSession sqlSession = sqlSessionFactory.openSession();

    2、(通过mapper）执行sql

    1. // 得到MyStudent表的mapper    
    2. MyStudentMapper myStudentMapper = sqlSession.getMapper(MyStudentMapper.class);
    3. // 调用mapper的方法
    4.         List all = myStudentMapper.findAll();

    3、关闭连接，千万别忘了关闭连接

    sqlSession.close();

    五、Mybatis 总配置

    我们接着第四节讲。

    5.1 多数据库配置

    数据库连接，在mybatis-config.xml中，进行配置。

    1、修改默认库

    同一个库，有一个开发库，一个测试库。如下

    1. "1.0" encoding="UTF-8" ?>
    3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.         "https://mybatis.org/dtd/mybatis-3-config.dtd">
    6.     
    7.         
    8.         "mapUnderscoreToCamelCase" value="true"/>
    9.     
    10.     default="development">
    11.         "development">
    12.             "JDBC"/>
    13.             "POOLED">
    14.                 "driver" value="com.mysql.cj.jdbc.Driver"/>
    15.                 "url" value="jdbc:mysql://124.70.87.136/chen?useUnicode=true&characterEncoding=UTF-8"/>
    16.                 "username" value="root"/>
    17.                 "password" value="123456"/>
    18.             
    19.         
    20.         "test">
    21.             "JDBC"/>
    22.             "POOLED">
    23.                 "driver" value="com.mysql.cj.jdbc.Driver"/>
    24.                 "url" value="jdbc:mysql://124.70.87.136/chen?useUnicode=true&characterEncoding=UTF-8"/>
    25.                 "username" value="root"/>
    26.                 "password" value="123456"/>
    27.             
    28.         
    29.     
    30.     
    31.         "mapper/MyStudentMapper.xml"/>
    32.     
    34.

     id就是数据库的名字，

    default="development">

    设置，默认使用的数据库。可以更换成test库。

    则我们在生成SqlSessionFactory的时候，生成的就是我们默认的那个数据库。

    1.         InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
    2.         // 选择不同的数据库，指定数据库
    3.         // SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in,"test");
    4.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);

    2、在生成SqlSessionFactory的时候，指定对应的数据库

    我们不同的业务模块，连接的是不同的数据库。在生成SqlSessionFactory的时候，指定对应的数据库id。

    1.         InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
    2.         // 选择不同的数据库，指定数据库
    3.          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in,"test");

    5.2 数据库表中的字段与自定义类的属性对应关系。

    在第四节中，数据库的表。

     

     数据库中的列名，与我们的自定义类属性名，一摸一样。这样框架就会自动的把数据给我们组装成一个实体类。

    那我们表的列名与类的属性名称不一致，咋整？

    情况一：开启驼峰命名自动映射

    数据库命名与java命名规范是不一致的。

    如，Your Student表，列名为下划线，user_id

     但是依照我们java命名规范，对应的实体类属性为驼峰格式，userId，userName。

    1. package beans;
    2.  
    3. import lombok.Data;
    4.  
    5. @Data
    6. public class YourStudent {
    7.     private long userId;
    8.     private String userName;
    9.     private int userAge;
    10. }

    两边列名是不一致的。我们可以在Mybatis的总配置文件mybatis-config.xml中，开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。

    mapUnderscoreToCamelCase是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。

     在mybatis-config.xml中，配置setting模块就好。

    情况二：表的列名与自定义类的属性名称不一致，且也不是驼峰映射的情况。

    如表中的列名，id 对应 类中的myId，name对应类中的designation。

    我们需要手动的，去写列名与类属性名的一一对应关系。应该去哪里写呢？

    正常情况下，这个映射实在row mapper里完成的。mybatis里的mapper，是一个xml配置文件。

    我们需要去MyStudentMapper.xml 中配置。

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5.  
    6. <mapper namespace="mapper.YourStudentMapper">
    7.     <resultMap id="yourStudent" type="beans.YourStudent">
    8.         <id column="id" property="myId"/>
    9.         <result column="name" property="designation"/>
    10.         <result column="age" property="year"/>
    11.     </resultMap>
    12.  
    13.     <select id="findAll" resultMap ="yourStudent">
    14.         select * from MyStudent
    15.     </select>
    16. </mapper>

     在resultMap中，编写列名与属性名的映射关系。

    type=，写的对应的实体类的全类名

    中，写的具体映射关系，column表的列名，property实体类的属性名。

    表的主键， 表中普通的列。

    注意，写完Map后，写到sql语句的resultMap上。注意（这里是resultMap，不是resultType=）

    5.3 xml配置文件，使用变量properties

    方式一：在xml中设置变量property （这种方式不常用。）

    在  中，设置变量，引用变量时，${xxx}

    方式二：在xml配置文件中，引入数据库配置文件

    我们习惯性的将数据库配置mysql.properties中。

    mysql.properties

    1. driver=com.mysql.cj.jdbc.Driver
    2. url=jdbc:mysql://124.70.87.136/chen?useUnicode=true&characterEncoding=UTF-8
    3. userName=root
    4. password=123456

    然后在mybatis-config.xml配置文件中，引入mysql.properties。

    然后设置变量。

    六、sql注解版 mapper

    以上，我们讲的使用mapper来构造执行sql语句的方法，由2部分组成。

    1部分是接口，里面有用户行为的方法

    2部分就是xml的mapper配置文件，里面写了具体执行的sql，以及对应的类，类的方法，返回数据类型。

    然后在mybatis主配置文件mybatis-config.xml中，mappers模块下，配置这个我们mapper xml文件的路径。

    mapper注解版，就是讲1与2，合二为一。我们在接口的方法中，通过注解，来写对应的sql。

    举例，上面那个查询全部的行为。

    1. package mapper;
    2.  
    3. import beans.MyStudent;
    4. import org.apache.ibatis.annotations.Select;
    5.  
    6. import java.util.List;
    7.  
    8. public interface MyStudentMapper {
    9.     @Select("select * from MyStudent")
    10.     List findAll();
    11.  
    12. }

    我们只需要在mapper接口，对应的行为上，注解对应的sql语句就可以了。

    这样，类方法与sql对应的关系、sql返回的数据类型，框架都可以识别到，不需要我们再去xml文件中配置了。

    然后我们再修改mybatis主配置文件mybatis-config.xml中，mappers模块下，将原来的resource=xml的路径，改成class = 接口的全类名，这样我们就可以找到对应的接口了。

    当我们使用xml 配置mapper 时，有多个xml文件时，需要配置多个xml文件。

    当我们使用注解接口时，有多个接口，也要分别写多个接口的class。

     "mapper.MyStudentMapper" />

    我们还可以写这些接口所在的包，框架会去扫描包下所有的接口。

            <package name="mapper"/>
    1.     
    2.         
    3.         
    4.         <package name="mapper"/>
    5.

    项目结构：

    七、xml 配置 mapper ，增删改查

    7.1 xml 配置 mapper ，中sql 参数传递&查

    7.1.1 通过变量传递sql参数&查

    1、在接口，有三个方法，分别需要传0个，1个，2个参数。

    1. package mapper;
    2.  
    3. import beans.MyStudent;
    4.  
    5. import java.util.List;
    6.  
    7. public interface MyStudentMapper {
    8.     List findAll();
    9.     MyStudent findById(long id);
    10.     MyStudent findByName(String name,int age);
    11.     
    12. }

    2、对应的xml配置，sql 参数

    1. "1.0" encoding="UTF-8" ?>
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
    6. "mapper.MyStudentMapper">
    7.     
    8.     
    9.     
    10.  
    11.     
    12.  
    13.

    规则：

    1、方法中，只需要一个参数时，sql语句中的变量名，可以任意命名。

    如 id= #{id}，可以任意命名 id= #{abcd}，

    2、方法中，需要多个参数时，sql语句中的变量名，需要与方法中的变量名保持一致。

    如在方法中，

        MyStudent findByName(String name,int age);

    则sql语句中的变量就要为 #{name} #{age}

    select * from MyStudent where name = #{name} and age = #{age}

    如果想要sql语句中的变量，与方法中的变量名称不一致，我们需要在方法中使用@Parm注解，来指定sql中的变量名称。

    如

    1. public interface MyStudentMapper {
    2.     List findAll();
    3.     MyStudent findById(long id);
    4.     MyStudent findByName(@Param("myName") String name, @Param("myAge") int age);
    5.  
    6. }

    方法中的变量name 对应sql中的myName变量

    1.

    7.1.2 通过对象传递sql参数

    sql中，我们需要传递多个参数。我们可以new一个对象，然后传递这个对象。

    接口的方法，传参为一个对象

    具体的sql语句中，还是一个个变量，系统会去我们传递的对象中，找对应的属性，来填充sql中的变量。

    举例：

    MyStudent实体类，有三个属性，我们根据name、age这两个属性去做查询。

    先改造MyStudent，给它一个无参构造器和name、age这两个属性的构造器。

    1. package beans;
    2.  
    3. import lombok.Data;
    4. import lombok.NoArgsConstructor;
    5.  
    6. @Data
    7. @NoArgsConstructor
    8. public class MyStudent {
    9.     private long id;
    10.     private String name;
    11.     private int age;
    12.  
    13.     public MyStudent(String name, int age) {
    14.         this.name = name;
    15.         this.age = age;
    16.     }
    17. }

    然后在接口中，新增一个传参为MyStudent实体类的方法。

    MyStudent findByObject(MyStudent myStudent);

    1. public interface MyStudentMapper {
    2.     List findAll();
    3.     MyStudent findById(long id);
    4.     MyStudent findByName(@Param("myName") String name, @Param("myAge") int age);
    5.     MyStudent findByObject(MyStudent myStudent);
    6. }

    在mapper xml中配置这个方法

    1.

    parameterType="beans.MyStudent" ,传参对象的类型

    name = #{name} and age = #{age}，#{name} 会去对象中，匹配属性。

    方法使用，我们在调用这个方法时，直接传一个对象就好了。

    1.         MyStudent byObject = myStudentMapper.findByObject(new MyStudent("王敏", 18));
    2.         System.out.println("byObject = " + byObject);

    7.2 增删改

    接口

    1. package mapper;
    2.  
    3. import beans.MyStudent;
    4. import org.apache.ibatis.annotations.Param;
    5.  
    6. import java.util.List;
    7.  
    8. public interface MyStudentMapper {
    9.     List findAll();
    10.     MyStudent findById(long id);
    11.     MyStudent findByName(@Param("myName") String name, @Param("myAge") int age);
    12.     MyStudent findByObject(MyStudent myStudent);
    13.     // 增
    14.     int add(MyStudent myStudent);
    15.     // 改
    16.     int update(MyStudent myStudent);
    17.     // 删除
    18.     int delete(long id);
    19. }

    mapper xml 配置

    1. "1.0" encoding="UTF-8" ?>
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
    6. "mapper.MyStudentMapper">
    7.     
    8.     
    9.     
    10.  
    11.     
    12.  
    13.     
    14.  
    15.     
    16.  
    17.     "add" parameterType="beans.MyStudent">
    18.         insert into MyStudent (name,age) values (#{name},#{age})
    19.     
    20.  
    21.     "update" parameterType="beans.MyStudent">
    22.         update MyStudent set name = #{name},age = #{age} where id = #{id}
    23.     
    24.  
    25.     "delete">
    26.         delete from MyStudent where id = #{id}
    27.     
    28.  
    29.

    add 方法为增

    update 方法为改

    delete 方法为删

    注意：

    1、在xml配置文件中，我们的增 与 改，传参都是对象。需要设置对象类型parameterType="beans.MyStudent"

    删，是根据long类型的id，进行删除的，传参为基本类型时，不需要设置传参的类型

    2、delete 删除，我们很少使用，一般是逻辑删除。

    方法的调用

    1. package main;
    2.  
    3. import beans.MyStudent;
    4. import mapper.MyStudentMapper;
    5. import org.apache.ibatis.io.Resources;
    6. import org.apache.ibatis.session.SqlSession;
    7. import org.apache.ibatis.session.SqlSessionFactory;
    8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    9.  
    10. import java.io.IOException;
    11. import java.io.InputStream;
    12. import java.util.List;
    13.  
    14. public class App {
    15.     public static void main(String[] args) throws IOException {
    16.         InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
    17.         // 选择不同的数据库，指定数据库
    18.          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in,"development");
    19.         SqlSession sqlSession = sqlSessionFactory.openSession(true);
    20.         // 得到MyStudent表的mapper
    21.         MyStudentMapper myStudentMapper = sqlSession.getMapper(MyStudentMapper.class);
    22.         // 调用mapper的方法
    23.         MyStudent byId = myStudentMapper.findById(201215121);
    24.         System.out.println("byId = " + byId);
    25.         MyStudent byName = myStudentMapper.findByName("王敏", 18);
    26.         System.out.println("byName = " + byName);
    27.         MyStudent byObject = myStudentMapper.findByObject(new MyStudent("王敏", 18));
    28.         System.out.println("byObject = " + byObject);
    29.  
    30.         int i = myStudentMapper.add(new MyStudent("张三", 19));
    31.         System.out.println("i = " + i);
    32.  
    33.         int update = myStudentMapper.update(new MyStudent(201215125, "李四", 19));
    34.         System.out.println("update = " + update);
    35.  
    36.         int delete = myStudentMapper.delete(201215125);
    37.         System.out.println("delete = " + delete);
    38.  
    39. //        sqlSession.commit();
    40.         sqlSession.close();
    41.  
    42.  
    43.     }
    44. }

    1、增、删、改行为，执行sql，都需要提交事物。

    方法一，在创建sqlSession 时，添加true，开启自动提交事物

            SqlSession sqlSession = sqlSessionFactory.openSession(true);

    方法二，我们在执行sql后，手动提交事物。

    1.  
    2.         int delete = myStudentMapper.delete(201215125);
    3.         System.out.println("delete = " + delete);
    4.  
    5.         sqlSession.commit();

    八、注解版mapper ，增删改查

    mapper接口，MyStudentMapper，方法与sql写一起

    1. package mapper;
    2.  
    3. import beans.MyStudent;
    4. import org.apache.ibatis.annotations.*;
    5.  
    6. import java.util.List;
    7.  
    8. public interface MyStudentMapper {
    9.     @Select("select * from MyStudent")
    10.     List findAll();
    11.  
    12.     @Select("select * from MyStudent where id = #{id}")
    13.     MyStudent findById(long id);
    14.  
    15.     @Select("select * from MyStudent where name = #{myName} and age = #{myAge}")
    16.     MyStudent findByName(@Param("myName") String name, @Param("myAge") int age);
    17.  
    18.     @Select("select * from MyStudent where name = #{name} and age = #{age}")
    19.     MyStudent findByObject(MyStudent myStudent);
    20.  
    21.     // 增
    22.     @Insert("insert into MyStudent (name,age) values (#{name},#{age})")
    23.     int add(MyStudent myStudent);
    24.  
    25.     // 改
    26.     @Update("update MyStudent set name = #{name},age = #{age} where id = #{id}")
    27.     int update(MyStudent myStudent);
    28.  
    29.     // 删除
    30.     @Delete("delete from MyStudent where id = #{id}")
    31.     int delete(long id);
    32.  
    33. }

    方法调用

    1. package main;
    2.  
    3. import beans.MyStudent;
    4. import mapper.MyStudentMapper;
    5. import org.apache.ibatis.io.Resources;
    6. import org.apache.ibatis.session.SqlSession;
    7. import org.apache.ibatis.session.SqlSessionFactory;
    8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    9.  
    10. import java.io.IOException;
    11. import java.io.InputStream;
    12. import java.util.List;
    13.  
    14. public class App {
    15.     public static void main(String[] args) throws IOException {
    16.         InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
    17.         // 选择不同的数据库，指定数据库
    18.          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in,"test");
    19.         SqlSession sqlSession = sqlSessionFactory.openSession(true);
    20.         // 得到MyStudent表的mapper
    21.         MyStudentMapper myStudentMapper = sqlSession.getMapper(MyStudentMapper.class);
    22.         // 调用mapper的方法
    23.         List all = myStudentMapper.findAll();
    24.         System.out.println("all = " + all);
    25.  
    26.         // 调用mapper的方法
    27.         MyStudent byId = myStudentMapper.findById(201215121);
    28.         System.out.println("byId = " + byId);
    29.         MyStudent byName = myStudentMapper.findByName("王敏", 18);
    30.         System.out.println("byName = " + byName);
    31.         MyStudent byObject = myStudentMapper.findByObject(new MyStudent("王敏", 18));
    32.         System.out.println("byObject = " + byObject);
    33.  
    34.         int i = myStudentMapper.add(new MyStudent("张三", 19));
    35.         System.out.println("i = " + i);
    36.  
    37.         int update = myStudentMapper.update(new MyStudent(201215126, "李四", 19));
    38.         System.out.println("update = " + update);
    39.  
    40.         int delete = myStudentMapper.delete(201215126);
    41.         System.out.println("delete = " + delete);
    42.         sqlSession.close();
    43.  
    44.  
    45.  
    46.     }
    47. }

    九、获取自增主键的值

    背景：

    表MyStudent，id是自增主键。

     当我们插入数据时，（一共3个字段），name与age是我们手动插入的，id是系统自动生成的。

    我们如何取到系统生成的id的值呢？

    insert into MyStudent (name,age) values (#{name},#{age}

    9.1 注解mapper ，获取自增主键的值

    接口配置

    1.  
    2.     // 增
    3.     @Insert("insert into MyStudent (name,age) values (#{name},#{age})")
    4.     @Options(useGeneratedKeys = true,keyProperty = "id")
    5.     int add(MyStudent myStudent);

    使用注解@Options。keyProperty="id"，MyStudent 实体类中的属性值。

    调用：

    1.         MyStudent myStudent = new MyStudent("张三", 19);
    2.         int i = myStudentMapper.add(myStudent);
    3.         System.out.println("i = " + i);
    4.         System.out.println("myStudent = " + myStudent);

    9.2 xml mapper ，获取自增主键的值

    xml mapper配置文件 

    1.     "add" parameterType="beans.MyStudent" useGeneratedKeys="true" keyProperty="id">
    2.         insert into MyStudent (name,age) values (#{name},#{age})
    3.

    useGeneratedKeys="true" keyProperty="id"

    keyProperty="id"，MyStudent 实体类中的属性值。

    调用

    1.  
    2.         MyStudent myStudent = new MyStudent("张三", 19);
    3.         int i = myStudentMapper.add(myStudent);
    4.         System.out.println("i = " + i);
    5.         System.out.println("myStudent = " + myStudent);

    十、动态sql

    10.1 背景

    动态sql，就是给sql赋予一段处理逻辑。

    如我们原来的sql

    select * from MyStudent where name = #{name} and age = #{age}

    根据name and age 去做查询。当我们只需要一个条件name或者age去查询的时候如何做处理？ 

    没有必要再写一个新的sql,我们给它加一段逻辑。当name与age 都不为空时，用这两个条件去查询。当有一个条件为空时，用另一个条件去查询。 

    10.2 xml mapper动态sql

    方式一：

    修改mapper xml sql语句，使用

    1.     <select id="findByList" resultType="beans.MyStudent" parameterType="beans.MyStudent">
    2.         select * from MyStudent
    3.         <where>
    4.             <if test="name != null">
    5.                 and name = #{name}
    6.             </if>
    7.             <if test="age != null">
    8.                 and age = #{age}
    9.             </if>
    10.         </where>
    11.     </select>

    注意，这里每个条件前边，都加了一个and。

    为啥要加and？ 因为当我们多个条件同时查询时，需要用and连接。 这个 应该是对只用一个条件查询时，做了特殊处理，比如方式二，用了1=1做了处理。

    方式二：

    修改mapper xml sql语句,使用1=1

    1.     <select id="findByList" resultType="beans.MyStudent" parameterType="beans.MyStudent">
    2.         select * from MyStudent where  1=1
    3.         <if test="name != null">
    4.             and name = #{name}
    5.         </if>
    6.         <if test="age != null">
    7.             and age = #{age}
    8.         </if>
    9.     </select>

    注意，这里每个条件前边，都加了一个and。

    为啥要加and？ 因为当我们多个条件同时查询时，需要用and连接。 

    为啥要加1=1？因为当我们只用一个条件查询时，sql就变成了这样

    select * from MyStudent where  and name = #{name}

    条件里，多了一个and，我们在前边加一个1=1，sql就变成了正常sql了。

    select * from MyStudent where  1=1 and name = #{name}

    10.3 注解版mapper 动态sql

    修改，接口方法上的sql注解。

    1.     @Select("")
    2.             
    3.     List<MyStudent> findByList(MyStudent myStudent);

    有个简便的方法，就是我们先在xml里写好了sql，在复制到这个接口上。

    复制这个：

    然后粘贴到 接口的注解上

     注意，这里多了一个

    十一、批量插入

    11.1 xml 批量插入

    在接口中，增加批量插入的方法

    1.     // 批量插入
    2.     int insertAll(List list);

    修改xml文件

    1.     <insert id="insertAll" parameterType="beans.MyStudent">
    2.         insert into MyStudent (name,age) values
    3.         <foreach collection="list" separator="," item="item">
    4.             (#{item.name},#{item.age})
    5.         </foreach>
    6.     </insert>

    解释：

    正常情况下，批量插入的sql语句，格式为

    insert into MyStudent (name,age) values (name1,age1)，(name2,age2)，(name3,age3)

    我们这里也是使用函数，来拼成这个格式。

    collection="list"，我们传入的是一个list集合，List

    separator="," 我们sql中，多个元素之间，使用逗号进行分割的

    item="xx", xx指代集合中的每一个元素。

    #{item.name} 集合中，每个元素的name值

    调用：

    1.         ArrayList students = Lists.newArrayList(new MyStudent("张三三", 19), new MyStudent("李思思", 19));
    2.         int all = myStudentMapper.insertAll(students);
    3.         System.out.println("all = " + all);

    11.2 sql注解批量插入

     在接口中，增加批量插入的方法

    1.     // 批量插入
    2.     int insertAll(List list);

    给方法增加sql注解

    1.     // 批量插入
    2.     @Insert("")
    3.     int insertAll(List list);

    这个注解，看起来有点复杂，我们还是直接复制xml版本的sql语句，

    复制到这个@Insert("")里面就可以

    调用

    1.         ArrayList students = Lists.newArrayList(new MyStudent("张三三", 19), new MyStudent("李思思", 19));
    2.         int all = myStudentMapper.insertAll(students);
    3.         System.out.println("all = " + all);

    十二、批量删除

    12.1 xml 批量删除

     在接口中，增加批量删除的方法

    1.     // 批量删除,long... 可变长参数
    2.     int deleteAll(long... ids);

    解释：

    ...表示 可变参数，我们进行删除时，（根据id进行删除）sql大概这个格式

    delete from MyStudent where id in （20112,202223,20334）

    传入的参数是一个可变长度的数组，数组的每个元素是long类型。

    修改xml文件

    1.     "deleteAll">
    2.         delete from MyStudent where id in 
    3.         "array" open="(" close=")" item="id" separator=",">
    4.             #{id}
    5.         
    6.

    解释：

    我们最终要拼成的sql,大概是这个格式

    delete from MyStudent where id in （20112,202223,20334）

    collection="array" 我们传入的参数就是一个数组，array

    open="(" close=")" ，sql中，我们的参数在一个括号（） 中。这个是来拼接这个（）的

    item="id" 数组中，每个元素

    separator="," 数组中，每个元素用逗号分割

    调用：

    1.         int deleteAll = myStudentMapper.deleteAll(201215137, 201215138);
    2.         System.out.println("deleteAll = " + deleteAll);

    12.2 sql注解删除

     在接口中，增加批量删除的方法

        int deleteAll(long... ids);

    给方法增加sql注解

    1.     // 批量删除,long... 可变长参数
    2.     @Delete("")
    3.     int deleteAll(long... ids);

    这个注解，看起来有点复杂，我们还是直接复制xml版本的sql语句，

    复制到这个@Insert("")里面就可以

    调用：

    1.         int deleteAll = myStudentMapper.deleteAll(201215137, 201215138);
    2.         System.out.println("deleteAll = " + deleteAll);

  • 相关阅读:
    代码随想录算法训练营第二十四天| 77 组合
    C专家编程 --- 书中案例汇编与分析（持续更新中）
    小学期实训-智慧电子时钟
    OpenCV 在ImShow窗体上选择感兴趣的区域
    Rsa加密原理与简单实现
    【数据结构】排序（1）
    计算机网络-局域网和城域网（二）
    大型医院容灾备份平台建设与应用实践
    Surpass Day27——Java 反射机制、注解
    一行代码修复100vh bug | 京东云技术团队
  • 原文地址：https://blog.csdn.net/qq_39208536/article/details/128139813