MyBatis与简单增删改查

Love The Way You Lie 2022-11-27 01:58 308阅读 0赞

selcet

在我们之前说过的权限系统中，我们需要使用到查询功能来查询用户、角色和权限等数据。在使用纯粹的JDBC时，需要写查询语句，并且对结果集进行手动处理，将结果集映射到对象的属性中。使用MyBatis时，只需要在XML中添加一个select元素，写一个SQL，再做一些简单的配置，就可以将结果直接映射到对象中。总结一下操作方法：

  1. 在接口类中写查询的方法，常见的如selectById()、selectAll()等
  2. 在与接口类对应的XML文件中写SQL语句
  3. 写测试类文件进行接口中方法的测试

接下来我们按照上述过程先写一个简单的查询测试一下。我们写一个按照用户ID查询用户信息的select语句吧。

首先，在UserMapper接口类文件中写一个查询方法：

  1. package Interface;
  3. import pojo.User;
  5. public interface UserMapper {
  6.     //根据ID查找用户
  7.     User selectById(Long id);
  9. }

然后我们在与UserMapper接口对应的UserMapper.xml文件中添加该查询方法的SQL代码：

  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">
  6. <mapper namespace="Interface.UserMapper">
  7.     <!--根据用户ID查找用户-->
  8.     <resultMap id="userMap" type="pojo.User">
  9.         <id property="id" column="id"/>
  10.         <result property="userName" column="user_name"/>
  11.         <result property="userPassword" column="user_password"/>
  12.         <result property="userEmail" column="user_email"/>
  13.         <result property="userInfo" column="user_info"/>
  14.         <result property="headImg" column="head_Img" jdbcType="BLOB"/>
  15.         <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
  16.     </resultMap>
  17.     <select id="selectById" resultMap="userMap">
  18.         select * from t_user where id = #{id}
  19.     </select>
  20. </mapper>

之前我们创建接口和XML文件时说过，接口和XML是通过将namespace的值设置为接口的全限定名称来进行关联的，那么接口中的方法和XML又是怎么关联的呢？通过观察上述代码，我们发现，XML文件中的select标签里的id属性值和接口类中的方法名是一样的。MyBatis正是通过这种方式将接口方法和XML中的SQL语句关联到一起的，如果接口方法没有和XML中的id属性值相对应，启动程序的话就会报错。接口中定义的返回值的类型必须和XML中配置的resultType类型一致，否则会因为类型不一致抛出异常。返回值的类型是由XML中的resultType（或resultMap中的type）来决定的。UserMapper接口中定义的selectById()方法，通过Id值来查找用户，最多只有一条数据，所以我们定义的返回值类型是User的类类型。

接下来，我们便可以编写测试类进行测试了。为了后续测试方便，提高代码的复用，我们先写一个基本的测试类，然后让其他的测试文件去继承这个基本测试类。在test目录下，新建一个TestMapper的包，来存放各种测试文件。

  1. //BaseTest.java
  2. package TestMapper;
  4. import org.apache.ibatis.io.Resources;
  5. import org.apache.ibatis.session.SqlSession;
  6. import org.apache.ibatis.session.SqlSessionFactory;
  7. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  8. import org.junit.BeforeClass;
  10. import java.io.IOException;
  11. import java.io.Reader;
  13. public class BaseMapperTest {
  14.     private static SqlSessionFactory sqlSessionFactory;
  15.     @BeforeClass
  16.     public static void init() {
  17.         try {
  18.             String resource = "Mybatis-config.xml";
  19.             Reader reader = Resources.getResourceAsReader(resource);
  20.             sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
  21.             reader.close();
  22.         } catch (IOException e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  26.     public SqlSession getSqlSession() {
  27.         return sqlSessionFactory.openSession();
  28.     }
  29. }

上述代码具体说明如下：

  • 通过Resurces工具类将Mybatis-config.xml配置文件读入Reader
  • 再通过SqlSessionFactoryBuilder建造类使用Reader创建SqlSessionFactory工厂对象。在创建SqlSessionFactory对象的过程中，首先解析Mybatis-config.xml配置文件，读取配置文件中的mappers配置后会读取全部的xxxMapper.xml进行具体方法的解析，在这些解析完成后，SqlSessionFactory就包含了所有的属性配置和执行SQL的信息
  • 使用时，通过SqlSessionFactory工厂对象获取一个SqlSession

然后我们就可以写刚才的selectById()方法的测试类了，命名为UserMapperTest.java，存放在TestMapper下：

  1. package TestMapper;
  3. import Interface.UserMapper;
  4. import org.apache.ibatis.session.SqlSession;
  5. import org.junit.Test;
  6. import pojo.User;
  8. import java.util.*;
  10. public class UserMapperTest extends BaseMapperTest {
  11.     @Test
  12.     public void testSelectById() {
  13.         SqlSession sqlSession = getSqlSession();
  14.         try {
  15.             UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  16.             User user = userMapper.selectById(1001L);
  17.             System.out.println(user);
  18.         } finally {
  19.             sqlSession.close();
  20.         }
  21.     }
  22. }

UserMapperTest继承自BaseTest，结合刚才分析过的基础测试文件，现在对UserMapperTest.java进行分析：

  • 使用时，通过调用getSqlSession()方法获取一个SqlSession对象
  • 通过SqlSession的getMapper()方法找到UserMapper，即通过UserMapper接口的class对象来获取接口方法，然后再通过UserMapper来执行selectById()方法，这一步就相当于执行SQL语句
  • 之后将查询结果输出即可
  • 最后一定不要忘记关闭sqlSession，不然会因为连接没有关闭而导致数据库连接数过多，造成系统崩溃

执行此测试文件，输出结果如下：

2020081310492496.png

和我们插入的数据完全一样。此时，第一次查询成功进行。接下来我们考虑一下如何进行全部数据的查询与输出。首先我们需要明白的是：按照用户Id查询的时候最多只有一条数据，所以我们的方法返回值类型是User类类型，可以直接使用println()打印输出。但是当我们查询全部数据的时候，查询结果往往不止一条，那么我们就需要使用List<>来存储查询结果，然后循环输出。操作过程和selectById()方法的操作过程一样，先在UserMapper接口类文件中写selectAll()方法，然后在UserMapper.xml文件中写SQL查询代码：

  1. package Interface;
  3. import pojo.User;
  4. import java.util.List;
  6. public interface UserMapper {
  7.     //查询所有用户
  8.     List<User> selectAll();
  10. }
  12. <?xml version="1.0" encoding="UTF-8" ?>
  13. <!DOCTYPE mapper
  14.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  15.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  17. <mapper namespace="Interface.UserMapper">
  18.    <!--查找所有用户-->
  19.     <select id="selectAll" resultType="pojo.User">
  20.         select id,user_name userName,user_password userPassword,
  21.         user_email userEmail,user_info userInfo,head_Img headImg,create_time createTime
  22.         from t_user
  23.     </select>
  24. </mapper>

其实仔细观察一下UserMapper.xml文件中的selectById()方法和selectAll()方法的代码书写就会发现：selectById()中使用了resultMap来设置结果映射，而selectAll()中通过resultType来直接指定了返回结果的类型。也由此可以发现，如果使用resultType来设置返回结果的类型的时候，需要在SQL中为所有列名和属性名不一致的列设置别名，通过设置别名可以使最终的查询结果列和resultType指定对象的属性名保持一致，进而实现自动映射。

然后我们写selectAll()方法的测试类，其大致和selectById()方法一样。还是写在UserMapperTest.java文件中：

  1. package TestMapper;
  3. import Interface.UserMapper;
  4. import org.apache.ibatis.session.SqlSession;
  5. import org.junit.Test;
  6. import pojo.User;
  8. import java.util.*;
  10. public class UserMapperTest extends BaseMapperTest {
  11.     @Test
  12.     public void testSelectAll() {
  13.         SqlSession sqlSession = getSqlSession();
  14.         try {
  15.             UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  16.             List<User> userList = userMapper.selectAll();
  17.             for ( User user : userList) {
  18.                 System.out.println(user);
  19.             }
  20.         } finally {
  21.             sqlSession.close();
  22.         }
  23.     }
  24. }

请注意结果的输出方法。执行该测试方法，得到如下结果：

20200813110715189.png

之前我们说过，当使用resultType来指定返回结果的类型的时候，需要注意在SQL中为所有列名和属性名不一致的列设置别名，通过设置的别名来使最终的查询结果列和resultType指定对象的属性名保持一致。（个人理解为需要将数据库中表的各个字段与实体类中的各个属性一一对应）当然，如果我们不想这样设置别名的话也可以通过其他方法达到目标。第一种方法就是之前我们说过的在设计数据库表和在实体类中写实体属性的时候，将两者写成一样的，就避免了这种麻烦。还有一种方法就是在Mybatis-config.xml配置文件中增加一行配置内容：

  1. <settings>
  2.     <setting name="mapUnderscoreToCamelCase" value="true"/>
  3. </settings>

添加之后的新的Mybatis-config.xml文件为：

  1. <?xml version="1.0" encoding="UTF8" ?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  6. <configuration>
  7.     <settings>
  8.         <setting name="mapUnderscoreToCamelCase" value="true"/>
  9.     </settings>
  10.     <environments default="development">
  11.         <environment id="development">
  12.             <transactionManager type="JDBC"/>
  13.             <dataSource type="POOLED">
  14.                 <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
  15.                 <property name="url" value="jdbc:mysql://localhost:3306/study"/>
  16.                 <property name="username" value="root"/>
  17.                 <property name="password" value="123456"/>
  18.             </dataSource>
  19.         </environment>
  20.     </environments>
  21.     <mappers>
  22.         <mapper resource="mapper/UserMapper.xml"/>
  23.         <mapper resource="mapper/RoleMapper.xml"/>
  24.         <mapper resource="mapper/PrivilegeMapper.xml"/>
  25.         <mapper resource="mapper/UserRoleMapper.xml"/>
  26.         <mapper resource="mapper/RolePrivilegeMapper.xml"/>
  27.     </mappers>
  28. </configuration>

这样设置的原因在于：在数据库中，由于大多数数据库设置不区分大小写，因此下划线方式的命名很常见。但是在Java中，一般都是用驼峰式命名，因为数据库和Java中的这两种命名方式很常见，因此MyBatis提供了一个全局的这样的一个属性，可以自动将以下划线方式命名的数据库列映射到Java对象的驼峰式命名属性中。我们写一个selectAll2()方法才测试一下。（selectAll2()命名方法并不规范，在此只为测试使用，无实际意义）

UserMapper接口类中的方法为：

  1. package Interface;
  3. import pojo.User;
  4. import java.util.List;
  6. public interface UserMapper {
  7.     //查询所有用户
  8.     List<User> selectAll2();
  10. }

UserMapper.xml中的SQL代码为：

  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">
  6. <mapper namespace="Interface.UserMapper">
  7.    <!--查找所有用户2-->
  8.     <select id="selectAll2" resultType="pojo.User">
  9.         select id,user_name,user_password,user_email,user_info,head_Img,create_time
  10.         from t_user
  11.     </select>
  12. </mapper>

测试文件中的该方法测试代码为：

  1. @Test
  2.     public void testSelectAll2() {
  3.         SqlSession sqlSession = getSqlSession();
  4.         try {
  5.             UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  6.             List<User> userList = userMapper.selectAll2();
  7.             for ( User user : userList) {
  8.                 System.out.println(user);
  9.             }
  10.         } finally {
  11.             sqlSession.close();
  12.         }
  13.     }

我们将两种selectAll()方法一起运行，看一下输出结果是否一样：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70

查询结果一样，selectAll2()与selectAll()方法相比只不过就是UserMapper.xml文件中的SQL语句少写了Java中的属性而已。

接下来我们看一下多表联合查询的操作方法和输出方法。其实SQL代码并不难写，难的是要想好如何输出查询结果。我们假设要查询用户id为1001的张三的角色都有哪些。根据我们之前插入的数据，我们知道，张三不仅是管理员，也是普通用户，所以输出结果肯定是一个List类型的。而且此次查询关联到的表有3个，即t_user用户表、t_role角色表和t_user_role用户角色联系表。还是和之前的处理方法一样，先写接口方法，再写查询的SQL语句，之后再编写测试方法。和之前不同的是，我们需要一些继承和属性的添加。

先在UserMapper接口中写方法，其实我们也可以在RoleMapper接口文件中写：

  1. package Interface;
  3. import pojo.User;
  4. import pojo.Role;
  5. import java.util.List;
  7. public interface UserMapper {
  8.     //根据用户ID查询用户角色
  9.     List<Role> selectRoleByUserId(Long UserId);
  11. }

如果只考虑输出Role的内容，那么我们就不能很快捷的知道用户名，所以我们必须得输出一下用户名。那么针对这种情况，很明显我们的返回值类型List不能满足我们的需求。此时我们就要考虑另外的方法了。

在角色表中新增一个属性，为User对象类型，字段名为user。其实此处还需要更改Role实体中的get()和set()方法，以及toString()方法。

  1. private Long id;                //角色ID
  2. private String roleName;        //角色名
  3. private int enabled;            //有效标志
  4. private Long createAuthor;      //创建者
  5. private Date createTime;        //创建时间
  6. private User user;

然后，角色实体类Role中的属性和方法就变成了这样：

  1. package pojo;
  3. import java.util.Date;
  5. public class Role {
  6.     private Long id;                //角色ID
  7.     private String roleName;        //角色名
  8.     private int enabled;            //有效标志
  9.     private Long createAuthor;      //创建者
  10.     private Date createTime;        //创建时间
  11.     private User user;
  13.     public Long getId() {
  14.         return id;
  15.     }
  17.     public void setId(Long id) {
  18.         this.id = id;
  19.     }
  21.     public String getRoleName() {
  22.         return roleName;
  23.     }
  25.     public void setRoleName(String roleName) {
  26.         this.roleName = roleName;
  27.     }
  29.     public int getEnabled() {
  30.         return enabled;
  31.     }
  33.     public void setEnabled(int enabled) {
  34.         this.enabled = enabled;
  35.     }
  37.     public Long getCreateAuthor() {
  38.         return createAuthor;
  39.     }
  41.     public void setCreateAuthor(Long createAuthor) {
  42.         this.createAuthor = createAuthor;
  43.     }
  45.     public Date getCreateTime() {
  46.         return createTime;
  47.     }
  49.     public void setCreateTime(Date createTime) {
  50.         this.createTime = createTime;
  51.     }
  53.     public User getUser() {
  54.         return user;
  55.     }
  57.     public void setUser(User user) {
  58.         this.user = user;
  59.     }
  61.     @Override
  62.     public String toString() {
  63.         return "Role{" +
  64.                 "id=" + id +
  65.                 ", roleName='" + roleName + '\'' +
  66.                 ", enabled=" + enabled +
  67.                 ", createAuthor=" + createAuthor +
  68.                 ", createTime=" + createTime +
  69.                 ", user=" + user +
  70.                 '}';
  71.     }
  72. }

然后，在UserMapper.xml文件中写查询的SQL代码。注意，我们把方法写在了UserMapper接口类中，所以就尽量让XML文件和接口文件对应也写在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">
  6. <mapper namespace="Interface.UserMapper">
  7.    <!--根据用户ID查找用户角色-->
  8.     <select id="selectRoleByUserId" resultType="pojo.Role">
  9.         select r.id,r.role_name roleName,r.enabled,
  10.         r.create_author createAuthor,r.create_time createTime,
  11.         u.user_name as "user.userName",
  12.         u.user_email as "user.userEmail"
  13.         from t_user u
  14.         inner join t_user_role ur on u.id = ur.user_id
  15.         inner join t_role r on ur.role_id = r.id
  16.         where u.id = #{userId}
  17.     </select>
  18. </mapper>

这里我们在设置列的别名的时候使用的是”user.属性名”，user就是Role实体中增加的User类型的对象。我们通过这种方式可以直接将值赋给user字段中的属性。然后在UserMapperTest.java中编写该方法的测试方法：

  1. @Test
  2.     public void testSelectRoleByUserId() {
  3.         SqlSession sqlSession = getSqlSession();
  4.         try {
  5.             UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  6.             List<Role> roleList = userMapper.selectRoleByUserId(1001L);
  7.             for (Role role : roleList) {
  8.                 System.out.println(role);
  9.             }
  10.         } finally {
  11.             sqlSession.close();
  12.         }
  13.     }

之后，调试运行即可：

20200813132322994.png

运行结果和我们插入的数据一样，即张三既是管理员，也是普通员工。

Insert

有了此前我们select的经验后，insert就显得特别简单了。还是和之前一样，我们依然在User上进行插入操作。先从插入一个用户开始。方法和之前一样，先在UserMapper接口类中定义一个方法。

  1. package Interface;
  3. import pojo.User;
  5. public interface UserMapper {
  6.     //插入一个用户
  7.     int addUser(User user);
  9. }

然后在UserMapper.xml文件中写插入用户的SQL代码：

  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">
  6. <mapper namespace="Interface.UserMapper">
  7.    <!--新增一个用户-->
  8.     <insert id="addUser">
  9.         insert into t_user(id,user_name,user_password,user_email,user_info,head_img,create_time)
  10.         value (#{id},#{userName},#{userPassword},#{userEmail},#{userInfo},#{headImg,jdbcType=BLOB},#{createTime,jdbcType=TIMESTAMP})
  11.     </insert>
  12. </mapper>

然后我们就看可以编写测试方法进行测试了

  1. @Test
  2.     public void testAddUser() {
  3.         SqlSession sqlSession = getSqlSession();
  4.         try {
  5.             UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  6.             User user = new User();
  7.             user.setUserName("王五");
  8.             user.setUserPassword("789000");
  9.             user.setUserEmail("000000@study");
  10.             user.setUserInfo("我是王五");
  11.             user.setHeadImg(new byte[]{1,2,3});
  12.             user.setCreateTime(new Date());
  13.             int res = userMapper.addUser(user);
  14.             if(res > 0) {
  15.                 System.out.println(res);
  16.                 System.out.println("插入成功！");
  17.             }
  18.         } finally {
  19.             sqlSession.commit();
  20.             sqlSession.close();
  21.         }
  22.     }

我们插入了一个叫王五的，id为1003的用户。执行测试之后：

20200813134208869.png

该用户插入成功。我们设置的res可以把它看作一个插入是否成功的标记，addUser()方法返回的是插入数据的条数，所以我们看到最后res返回了1。除此之外还需要注意最后的sqlSession.commit()方法，代表提交事务，我们进行了insert的操作之后，需要将该事务提交，否则虽然只是显示插入成功，但是数据库表中却找不到这条数据。如果我们怕影响其他操作，也可使用sqlSession.rollback()方法，来使该事务回滚，不会影响到其他操作。

除了像上述方法那样通过打印出的受影响的行数来判断插入是否成功之外还可以通过返回插入数据的主键来判断插入成功。我们写一个addUser2()方法，来打印插入数据的主键。

  1. package Interface;
  3. import pojo.User;
  5. public interface UserMapper {
  6.     //插入一个用户
  7.     int addUser2(User user);
  9. }
  11. <?xml version="1.0" encoding="UTF-8" ?>
  12. <!DOCTYPE mapper
  13.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  14.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  16. <mapper namespace="Interface.UserMapper">
  17.    <!--新增一个用户-->
  18.     <insert id="addUser2" useGeneratedKeys="true" keyProperty="id">
  19.         insert into t_user(id,user_name,user_password,user_email,user_info,head_img,create_time)
  20.         value (#{id},#{userName},#{userPassword},#{userEmail},#{userInfo},#{headImg,jdbcType=BLOB},#{createTime,jdbcType=TIMESTAMP})
  21.     </insert>
  22. </mapper>

我们发现，addUser2()与addUser()相比，其实就只是在insert的标签上配置了两个属性而已。将useGeneratedKeys设置为true之后，MyBatis会使用JDBC的getGeneratedKeys方法来取出由数据库内部生成的主键。获得主键值后将其赋值给keyProperty配置的id属性。

然后我们编写测试类进行测试：

20200813135556351.png

  1. @Test
  2.     public void testAddUser2() {
  3.         SqlSession sqlSession = getSqlSession();
  4.         try {
  5.             UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  6.             User user = new User();
  7.             user.setUserName("李明");
  8.             user.setUserPassword("789000");
  9.             user.setUserEmail("000000@study");
  10.             user.setUserInfo("我是李明");
  11.             user.setHeadImg(new byte[]{1,2,3});
  12.             user.setCreateTime(new Date());
  13.             int res = userMapper.addUser2(user);
  14.             System.out.println(user.getId());
  15.         } finally {
  16.             sqlSession.commit();
  17.             sqlSession.close();
  18.         }
  19.     }

因为我们之前插入的王五使用了1003的id号，所以此时李明的id号为1004。

除了使用JDBC的方式返回主键之外，我们还可以使用selectKey来返回主键的值。编写addUser3()方法。

  1. package Interface;
  3. import pojo.User;
  5. public interface UserMapper {
  6.     //插入一个用户
  7.     int addUser3(User user);
  9. }
  11. <?xml version="1.0" encoding="UTF-8" ?>
  12. <!DOCTYPE mapper
  13.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  14.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  16. <mapper namespace="Interface.UserMapper">
  17.     <!--新增一个用户-->
  18.     <insert id="addUser3">
  19.         insert into t_user(id,user_name,user_password,user_email,user_info,head_img,create_time)
  20.         value (#{id},#{userName},#{userPassword},#{userEmail},#{userInfo},#{headImg,jdbcType=BLOB},#{createTime,jdbcType=TIMESTAMP})
  21.         <selectKey keyColumn="id" resultType="long" keyProperty="id" order="AFTER">
  22.             select LAST_INSERT_ID()
  23.         </selectKey>
  24.     </insert>
  25. </mapper>

select标签的keyColumn、keyProperty和useGeneratedKeys的用法含义相同，resultType用于设置返回值类型。order属性的设置和使用的数据库有关，在MySQL中，order属性设置为AFTER，因为当前记录的主键值是在insert语句执行成功之后才获取到的，而在Oracle中，order要设置为BEFORE，因为Oracle中需要先从序列获取值，然后将值作为主键插入到数据库中。

  1. @Test
  2.     public void testAddUser3() {
  3.         SqlSession sqlSession = getSqlSession();
  4.         try {
  5.             UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  6.             User user = new User();
  7.             user.setUserName("李大明");
  8.             user.setUserPassword("789000");
  9.             user.setUserEmail("000000@study");
  10.             user.setUserInfo("我是李大明");
  11.             user.setHeadImg(new byte[]{1,2,3});
  12.             user.setCreateTime(new Date());
  13.             int res = userMapper.addUser3(user);
  14.             System.out.println(user.getId());
  15.         } finally {
  16.             sqlSession.commit();
  17.             sqlSession.close();
  18.         }
  19.     }

20200813140512504.png

此时，插入的李大明的id号为1005。

update

update的更新操作相比插入和查询就简单的多了。常见的就是根据某个条件来更新其他数据。例如，现在我们要更新1004号李明的密码、邮箱等信息。操作方法和以前一样，分三步走。写方法→写SQL→测试。

  1. package Interface;
  3. import pojo.User;
  5. public interface UserMapper {
  6.     //根据用户ID更新数据
  7.     int updateById(User user);
  9. }
  11. <?xml version="1.0" encoding="UTF-8" ?>
  12. <!DOCTYPE mapper
  13.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  14.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  16. <mapper namespace="Interface.UserMapper">
  17.     <!--根据用户ID更新数据-->
  18.     <update id="updateById">
  19.         update t_user
  20.         set user_password = #{userPassword},user_email = #{userEmail},
  21.         head_Img = #{headImg,jdbcType = BLOB},create_time = #{createTime,jdbcType = TIMESTAMP}
  22.         where id = #{id}
  23.     </update>
  24. </mapper>
  26. @Test
  27.     public void testUpdateById() {
  28.         SqlSession sqlSession = getSqlSession();
  29.         try {
  30.             UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  31.             User user = userMapper.selectById(1004L);
  32.             user.setUserPassword("999999");
  33.             user.setUserEmail("999999@study");
  34.             user.setHeadImg(new byte[]{9,9,9});
  35.             user.setCreateTime(new Date());
  36.             int res = userMapper.updateById(user);
  37.             System.out.println("更新成功" + res + "条信息！");
  38.         } finally {
  39.             sqlSession.commit();
  40.             sqlSession.close();
  41.         }
  42.     }

20200813141426189.png

20200813141517771.png

更新数据成功！需要注意的是，执行update操作之后也需要提交。不然不会生效。

delete

delete操作和update操作一样简单，都只是需要一句SQL就能完成，现在我们删除刚才插入的1005号李大明的信息。

  1. package Interface;
  3. import pojo.User;
  5. public interface UserMapper {
  6.     //根据ID删除用户
  7.     int deleteById(Long id);
  9. }
  11. <?xml version="1.0" encoding="UTF-8" ?>
  12. <!DOCTYPE mapper
  13.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  14.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  16. <mapper namespace="Interface.UserMapper">
  17.     <!--根据ID删除用户-->
  18.     <delete id="deleteById">
  19.         delete from t_user where id = #{id}
  20.     </delete>
  21. </mapper>
  23. @Test
  24.     public void testDeleteById() {
  25.         SqlSession sqlSession = getSqlSession();
  26.         try {
  27.             UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  28.             int res = userMapper.deleteById(1005L);
  29.             System.out.println(res);
  30.             System.out.println("删除成功！");
  31.         } finally {
  32.             sqlSession.commit();
  33.             sqlSession.close();
  34.         }
  35.     }

202008131422390.png

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 1

1005号用户删除成功！

至此我们对于简单的增删改查工作就到此为止吧，后续我们会进行一些动态的SQL查询。

发表评论

表情：
评论列表 （有 0 条评论，308人围观）

还没有评论，来说两句吧...

相关阅读

    相关 MyBatis与简单增删改查

    selcet 在我们之前说过的权限系统中，我们需要使用到查询功能来查询用户、角色和权限等数据。在使用纯粹的JDBC时，需要写查询语句，并且对结果集进行手动处理，将结果集映射到

    Love The Way You LieLove The Way You Lie/ 0 赞/ 309 阅读