MyBatis的使用总结XML方式---------------MyBatis接口代理方式实现dao层

环境（导入依赖或jar包）

不使用spring框架

导入MyBatis-3.4.5.jar和mysql-connector-java-5.1.37-bin.jar

使用Spring框架

在pom.xml里面添加一下内容

<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.2</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.3.1</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.5.0</version>
		</dependency>

LOG4J

在日常开发过程中,排查问题时难免需要输出MyBatis真正执行的SQL语询、参数、结果等信息,我们就可以借助LOG4J的功能来实现执行信息的输出。

<!--    配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>

使用XML方式

MyBatis接口代理方式实现dao层

1.往项目导入jar包或pom.xml依赖

2.编写核心配置文件。

使用标签

jdbc.properties文件内容，这个文件就是用来读取并使用的

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db0809pm
username=root
password=2184021338

核心配置文件包含了MyBatis最核心的设置和属性信息。如数据库的连接、事务、连接池信息等。

<configuration>核心根标签。

1. <properties>: 引入数据库连接信息配置文件标签。基本上引入的是jdbc.properties
2. <typeAliases>: 起别名标签。也就是给实体类起一个更加简单的名字，不需要再使用com.yy.Bean.Student，可以直接使用student
3. <environments>:配置数据库环境标签。即数据库的相关配置

1. <environment>:配置数据库信息标签。

1. <transactionManager>:事务管理标签。
2. <dataSource>: 数据源标签。

1. <property>:数据库连接信息标签。

4. <mappers>:引入映射配置文件标签。也就是引入所编写的映射配置文件的地址

实现代码(通过类比便可知道上面的标签具体是什么意思)

<?xml version="1.0" encoding="UTF-8"   ?><!--XML文档说明-->
<!--MyBatis的DTD约束：对标签的约束以及相应的提示的功能-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration：核心根标签-->
<configuration>

    <!--    引入数据库连接的配置文件-->
    <properties resource="jdbc.properties"/>
<!--    配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>
<!--    起别名-->
    <typeAliases>
       <typeAlias type="com.yy.Bean.Student" alias="student"/>
<!--        <package name="com.yy.Bean"/>-->
    </typeAliases>
    <!--    分页插件-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>

    
<!-- environments   配置数据库环境 ，环境可以有多高 default属性指定使用的是哪一个  -->
    <environments default="mysql"><!--default:指定是下面的哪一个数据库 -->
<!--     environment 配置数控环境 id属性代表唯一标识  -->
        <environment id="mysql">
<!--           transactionManager代表事务的管理 type属性，采用JDBC默认的事务处理 -->
            <transactionManager type="JDBC"></transactionManager>
<!--            dataSource 数据源的信息 type属性代表连接池-->
            <dataSource type="POOLED">
<!--             property 获取数据库连接的信息   -->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
<!--   mappers 代表引入映射配置文件 -->
    <mappers>
<!--        引入指定的映射配置文件  resource 属性指定映射配置文件的名称（路径），多表操作的映射配置文件路径-->
        <mapper resource="com/yy/one_to_one/OneToOneMapper.xml"/>
        <mapper resource="com/yy/one_to_many/OneToManyMapper.xml"/>
        <mapper resource="com/yy/many_to_many/ManyToManyMapper.xml"/>
        <!--        引入指定的映射配置文件  resource 属性指定映射配置文件的名称（路径），这个映射配置文件是在src目录下，所以没有目录-->
        <mapper resource="StudentMapper.xml"/>
    </mappers>

</configuration>

3.编写映射配置文件。

映射配置文件包含了数据和对象之间的映射关系以及要执行的SQL语句。

<mapper>: 核心根标签。即要将mapper里面的sql语句映射到对应的哪一个接口中，类似于之前使用dao和daoImpl时，dao里面的接口

namespace属性:名称空间；即接口的位置com.yy.mapper.StudentMapper

1. <select>:查询功能标签。
2. <insert>:新增功能标签。
3. <update>:修改功能标签。
4. <delete>:删除功能标签。

id属性:唯一标识,配合名称空间使用，最好与StudentMapper接口里面的方法名一样
parameterType属性:指定参数映射的对象类型；也就是传递的参数，如在parameterType里面传递过滤一个student学生对象，如何从学生对象里面获取id、name、age等参数
resultType属性:指定结果映射的对象类型；将查询所得的内容进行封装的位置，在这里写的是com.yy.Bean.Student，意思便是将数据封装到这个实体类中，如果返回的是int数值，所以resultType可以不用写。

5. SQL获取参数
   #{属性名} N
   

<?xml version="1.0" encoding="UTF-8" ?>

<!--MyBatis的DTD约束-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
    mapper：核心根标签
    namespace属性：名称空间    要想执行里面的sql语句必须
                            要借助与名称空间配合上id才能找到这条sql语句
                   即要将mapper里面的sql语句映射到对应的哪一个接口中，
                   类似于之前使用dao和daoImpl时，dao里面的接口
-->
<mapper namespace="com.yy.mapper.StudentMapper">
    <sql id="select">SELECT * FROM student</sql>
<!--
    select：查询功能的标签
    id属性：唯一标识，与名称空间配合使用
    resultType属性：指定结果映射对象类型，即要将查询到的数据封装到那个里面
                    执行完下面的查询的sql语句会用一些数据，
                    而这些数据我们想要将他们封装到那个对象中，
                    就通过这个属性来进行指定
    parameterType属性：指定参数映射对象类型，也就是代表传递的参数
                    如果有where这些条件的话，就通过parameterType来指定所需要的参数类型
-->
    <select id="selectAll" resultType="student">
        <include refid="select"/>
    </select>
    <select id="selectById" resultType="student" parameterType="int">
        <include refid="select"/> WHERE id = #{id}
    </select>
<!--    在parameterType里面传递过滤一个学生对象，如何从学生对象里面获取id、name、age等参数-->
<!--    因为它返回的是int数值，所以resultType可以不用写-->
    <insert id="insert" parameterType="student">
        INSERT INTO student VALUES (#{id},#{name},#{age},#{gender},#{score})
    </insert>

    <update id="update" parameterType="student">
        UPDATE student SET name=#{name},age=#{age},gender=#{gender},score=#{score} WHERE id = #{id}
    </update>

    <delete id="delete" parameterType="int">
        DELETE FROM student WHERE id = #{id}
    </delete>

    <select id="selectCondition" resultType="student" parameterType="student">
        SELECT * FROM student
        <where>
            <if test="id != null">
                id = #{id}
            </if>
            <if test="name != null">
                AND name = #{name}
            </if>
            <if test="age != null">
                AND age = #{age}
            </if>
        </where>
    </select>

    <select id="selectByIds" resultType="student" parameterType="list">
        <include refid="select"/>
        <where>
            <foreach collection="list" open="id IN (" close=")" item="id" separator=",">
                #{id}
            </foreach>
        </where>
    </select>
</mapper>

使用相应的API来完成编码。

在这里我只是拿出两个例子

• 不使用接口代理方式

 //查询全部
    @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        //2.获取Sq1SessionI厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        //3.通过SqISession. I厂对象获取Sq1Session对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //4.执行映射配置文件中的sq1语句，并接收结果
        List<Student> list = sqlSession.selectList("StudentMapper.selectAll");
        //5.处理结果
        for(Student stu : list){
            System.out.println(stu);
        }
        //6.释放资源
        sqlSession.close();
        is.close();
    }
//    根据id查询
    @Test
    public void selectById() throws Exception{
        //加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        //获取sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        //通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行映射配置文件的sql语句，并接受结果
        Student stu = sqlSession.selectOne("StudentMapper.selectById",3);
        //处理结果
        System.out.println(stu);
        sqlSession.close();
        is.close();
    }

• 使用接口代理方式实现

//查询全部
 @Test
    public void selectCondition() throws Exception{
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        Student stu = new Student();
        stu.setId(3);
        stu.setAge(26);
//        stu.setName("赵六");

        List<Student> list = mapper.selectCondition(stu);
        for (Student student : list){
            System.out.println(student);
        }
        sqlSession.close();
        is.close();

    }
    @Test
    public void selectByIds() throws Exception{
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Integer> ids = new ArrayList<>();
        ids.add(1);
        ids.add(2);
        ids.add(3);

        List<Student> list = mapper.selectByIds(ids);
        for (Student student : list){
            System.out.println(student);
        }
        sqlSession.close();
        is.close();

    }