mybatis复习02,简单的增删改查，@Param注解多个参数，resultType与resultMap的区别，#{}预编译参数

创建数据表 user_info

user_info:

在项目中创建数据表对应的实体类 UserInfo.java

在项目根目录下新建包 com/gothic/sunset/pojo ，然后在其中创建对应的UserInfo.java.
数据表中的每一条记录对应着实体类的一个对象，数据表中的每一个字段与成员变量对应。然后这里MyBatis默认遵循的是“下划线转驼峰”，所以创建实体类中对应的成员变量时，采用这种方式。（很简单，接着创建对应的getter和setter方法，以及有参无参构造器，和重写toString方法）。

package com.gothic.sunset.pojo;

public class UserInfo {
   
    private int id; // 主键
    private String userName;// 用户名
    private String password;//密码
    private String userSex;//用户性别
    private String userAddress;//用户地址

    public UserInfo(int id, String userName, String password, String userSex, String userAddress) {
   
        this.id = id;
        this.userName = userName;
        this.password = password;
        this.userSex = userSex;
        this.userAddress = userAddress;
    }

    public UserInfo() {
   
    }

    public int getId() {
   
        return id;
    }

    public void setId(int id) {
   
        this.id = id;
    }

    public String getUserName() {
   
        return userName;
    }

    public void setUserName(String userName) {
   
        this.userName = userName;
    }

    public String getPassword() {
   
        return password;
    }

    public void setPassword(String password) {
   
        this.password = password;
    }

    public String getUserSex() {
   
        return userSex;
    }

    public void setUserSex(String userSex) {
   
        this.userSex = userSex;
    }

    public String getUserAddress() {
   
        return userAddress;
    }

    public void setUserAddress(String userAddress) {
   
        this.userAddress = userAddress;
    }

    @Override
    public String toString() {
   
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", userSex='" + userSex + '\'' +
                ", userAddress='" + userAddress + '\'' +
                '}';
    }
}

在pom.xml文件中引入依赖

导入依赖后，记得更新依赖。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.gothic.sunset</groupId>
    <artifactId>mybatisReview</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <packaging>jar</packaging>


    <dependencies>
        <!--mybatis核心-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>

        <!--junit 测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!--MySql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.3</version>
        </dependency>

        <!--log4j 日志-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>
</project>

创建核心配置文件mybatis-config.xml并且创建jdbc.properties数据驱动配置文件

在resources目录下创建核心配置文件,mybaits-config.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--MyBatis核心配置文件的标签必须按照指定的顺序去配置
        properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,
        objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?
    -->
    <properties resource="jdbc.properties"></properties>

    <settings>
        <!--将下划线映射为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <typeAliases>
        <package name="com.gothic.sunset.pojo"/>
    </typeAliases>
    <!--配置链接数据库的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <package name="com.gothic.sunset.mapper"/>
    </mappers>
</configuration>

在resources目录下，创建jdbc.properties文件：
这里，需要将用户名和密码改成自己的，以及url所对应的数据库也是。

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8
jdbc.username=root
jdbc.password=root

创建Mapper接口以及编写Mapper接口对应的xml文件

创建一个新的包 com/gothic/sunset/mapper 然后在里面创建 UserInfoMapper.java,（这里的命名遵循见名知意思，并且也是一个习惯），实体类对应的Mapper接口，并且以Mapper作为后缀。
然后Mapper接口对应的XML文件，一般都与Mapper接口文件保持一致，并且在resource目录下创建和Mapper接口一致的包。

Mapper接口：

这里为了简单，就只写最基础的增删改查，一切都围绕着用户id来进行。

package com.gothic.sunset.mapper;

import com.gothic.sunset.pojo.UserInfo;

import java.util.List;

public interface UserInfoMapper {
   

    /**
     * 添加用户信息
     * @param userInfo
     */
    int insertUserInfo(UserInfo userInfo);

    /**
     * 查询所有用户信息
     * @return
     */
    List<UserInfo> selectAllUser();

    /**
     * 根据用户id进行查询
     * @param id
     * @return
     */
    UserInfo selectUserById(int id);

    /**
     * 根据用户id来进行删除
     * @param id
     * @return
     */
    int deleteUserById(int id);

    /**
     * 根据用户id来进行更新用户信息
     * @param userInfo
     * @return
     */
    int updateUserById(UserInfo userInfo);

    /**
     * 多条件查询根据用户名和性别来查询某一个用户
     * @param userName
     * @param userSex
     * @return
     */
    List<UserInfo> selectByConditions(@Param("userName") String userName, @Param("userSex") String userSex);
}

创建并配置Mapper接口对应的XML文件

创建Mapper.XML文件

在resources目录下，创建一个新的包 com/gothic/sunset/mapper ，然后在里面创建UserInfoMapper.xml文件：
值得注意的是，mapper标签中的namespace，即Mapper接口和对应的XML文件关联，namespace中的值是对应Mapper接口的全限定名称（包名加类名）。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace中配置对应Mapper接口的全限定名称-->
<mapper namespace="com.gothic.sunset.mapper.UserInfoMapper">

</mapper>

配置Mapper.XML文件,在mapper标签中编写sql代码：

增 insert 和 #{}占位符：

这里使用了#{}来预编译参数，它和PreparedStatement类似。#{}也是占位值赋值，等同于PreparedStatement中的？占位符。

     <insert id="insertUserInfo" >
        insert into user_info
        (id,user_name,password,user_sex,user_address)
        values (#{id},#{userName},#{password},#{userSex},#{userAddress})
    </insert>

对了，说到这里，同样在mybatis中也有字符串拼接sql，它就是使用${},它最终会转换成为单引号，用于拼接一些复杂的sql，这个后面再详细展开例子。

删delete：

    <!--int deleteUserById(int id);-->
    <delete id="deleteUserById">
        delete from user_info where id = #{id}
    </delete>

改update：

    <!-- int updateUserById(UserInfo userInfo);-->
    <update id="updateUserById">
        update user_info
        set user_name = #{userName},
            password = #{password},
            user_sex = #{userSex},
            user_address = #{userAddress}
        where id = #{id}
    </update>

查select,resultType和reultMap：

错误的例子
如下面的代码，势必会报错，因为UserInfo里面的成员变量是驼峰命名，而数据库字段是下划线命名。

    <!-- List<UserInfo> selectAllUser();-->
    <select id="selectAllUser" resultType="UserInfo">
        select id,user_name,password,user_sex,user_address from user_info
    </select>


    <!--UserInfo selectUserById(int id);-->
    <select id="selectUserById" resultType="UserInfo">
        select user_name,password,user_sex,user_address from user_info where id = #{id}
    </select>

有两种解决方案：

• 第一种还是使用resultType 的方式。
  使用resultType对查询部分的sql进行改进：

    <!-- List<UserInfo> selectAllUser();-->
    <select id="selectAllUser" resultType="UserInfo">
        select id id,
               user_name userName,
               password password,
               user_sex userSex,
               user_address userAddress
        from user_info
    </select>

就是在写sql的时候，同时将其实体类中的成员属性名跟在后面，这里我就只改一个，另一个可以自行修改。

• 第二种使用resultMap，以key-value的方式将property映射到对应的数据表字段。
  使用resultMap来对成员变量和数据字段的映射：
  首先，需要添加一个resultMap标签，然后其id值为自定义不可重复的就行，然后type就是返回值类型。
  其中，暂且只用到id标签和result标签来进行，成员变量名到数据表字段的映射。后面涉及到复杂的一对多，或者多对一的映射关系，还会使用到collection和association…,下图是resultMap中包括的子标签。
  

    <resultMap id="userInfoMap" type="UserInfo">
        <id property="id" column="id"></id>
        <result property="userName" column="user_name"></result>
        <result property="password" column="password"></result>
        <result property="userSex" column="user_sex"></result>
        <result property="userAddress" column="user_address"></result>
    </resultMap>
    <!--UserInfo selectUserById(int id);-->
    <select id="selectUserById" resultMap="userInfoMap">
        select user_name,password,user_sex,user_address from user_info where id = #{id}
    </select>

多条件查询，使用@Param注解

Mapper接口部分：
使用@Param注解以后，mybatis会自动将参数封装成Map类型，@Param注解值会作为Map中的key，因此sql就可以使用配置的注解值来使用参数。
简单来说，就是使用@Param以后，你就不需要关心你的sql中的对应字段名称和成员变量名是否一致。

    /**
     * 多条件查询根据用户名和性别来查询某一个用户
     * @param userName
     * @param userSex
     * @return
     */
    List<UserInfo> selectByConditions(@Param("userName") String userName, @Param("userSex") String userSex);

<!--List<UserInfo> selectByConditions(@Param("user_name") String userName, @Param("user_sex") String sex);-->
    <select id="selectByConditions" resultType="UserInfo">
        select  id,user_name,password,user_sex,user_address from user_info where user_name = #{userName} and user_sex = #{userSex}
    </select>

创建SqlsessionUtil类来获取Sqlsession对象

在包com/gothic/sunset/utils 下新建SqlsessionUtil.java文件

package com.gothic.sunset.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class SqlSessionUtil {
   
    public static SqlSession getSqlSession(){
   
        SqlSession sqlSession = null;
        try {
   
            //获取核心配置文件输入流
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            //获取sqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder =new SqlSessionFactoryBuilder();
            //获取sqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
            //获取sqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);
        } catch (IOException e) {
   
            e.printStackTrace();
        }
        return sqlSession;
    }
}

创建log4j.xml日志记录

在resources目录下，创建log4j.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

编写测试用例测试输出

test包下编写：

import com.gothic.sunset.mapper.CountryMapper;
import com.gothic.sunset.mapper.UserInfoMapper;
import com.gothic.sunset.pojo.Country;
import com.gothic.sunset.pojo.UserInfo;
import com.gothic.sunset.utils.SqlSessionUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class test {
   
    /*@Test
    public void testSelectAllCt(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        CountryMapper mapper = sqlSession.getMapper(CountryMapper.class);
        List<Country> countryList = mapper.selectAll();
        countryList.forEach(System.out::println);
    }*/


    @Test
    public void testInsertUser(){
   
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserInfoMapper mapper = sqlSession.getMapper(UserInfoMapper.class);
        UserInfo userInfo = new UserInfo(1,"白云飞","2020040416byf","男","380xxgtcqq.com");
        mapper.insertUserInfo(userInfo);
        UserInfo userInfo2 = new UserInfo(2,"叶问","2020040490byw","男","xx街道办事处");
        mapper.insertUserInfo(userInfo2);
        UserInfo userInfo3 = new UserInfo(3,"憨豆","2020040473hd","男","大不列颠xxx");
        mapper.insertUserInfo(userInfo3);
    }

    @Test
    public void testDeleteUser(){
   
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserInfoMapper mapper = sqlSession.getMapper(UserInfoMapper.class);
        mapper.deleteUserById(1);
    }

    @Test
    public void testSelectAllUsers(){
   
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserInfoMapper mapper = sqlSession.getMapper(UserInfoMapper.class);
        List<UserInfo> userInfos = mapper.selectAllUser();
        userInfos.forEach(System.out::println);
    }


    @Test
    public void testSelectUsersById(){
   
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserInfoMapper mapper = sqlSession.getMapper(UserInfoMapper.class);
        System.out.println(mapper.selectUserById(2));
    }

    @Test
    public void testSelectUsersByCd(){
   
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserInfoMapper mapper = sqlSession.getMapper(UserInfoMapper.class);
        System.out.println(mapper.selectByConditions("叶问", "男"));
    }
}

逐个测试：





今天的复习就到此结束啦！！！