第二章 MyBatis框架快速入门

最新推荐文章于 2024-10-08 15:01:38 发布

葡萄&

最新推荐文章于 2024-10-08 15:01:38 发布

阅读量95

点赞数

分类专栏： # MyBatis 文章标签： mybatis

本文链接：https://blog.csdn.net/abordo/article/details/119654587

版权

MyBatis 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

第二章 MyBatis框架快速入门

1.入门案例
2.主要类的介绍
3.传统dao的使用
4.动态代理的使用
5.传入参数

1.入门案例

1.1使用mybatis准备

下载mybatis
http://github.com/mybatis/mybatis-3/releases
mybatis官网文档
https://mybatis.org/mybatis-3/zh/getting-started.html

1.2实现mybatis第一个例子

（1）创建mysql数据库和表
数据库名：springdb；表名：student；
添加数据。
（2）创建maven工程
创建空工程。
创建模板
创建ressource目录。

readme.txt

ch01-hello-mybatis:第一个入门的mybatis例子

实现步骤：
1.新建的student表
2.加入maven的mybatis坐标，mysql驱动的坐标
3.创建实体类，Student--保存表中的一行数据的
4.创建持久层的dao接口，定义操作数据库的方法
5.创建一个mybatis使用的配置文件
    叫做sql映射文件：写sql语句的。一般一个表一个sql映射文件。这个文件是xml文件。
    1.在接口所在的目录中。
    2.文件名称和接口保持一致。
6.创建mybatis的主配置文件：
    一个项目就一个主配置文件。
    主配置文件提供了数据库的连接信息和sql映射文件的位置信息
7.创建使用mybatis类
    通过mybatis访问数据库

（3）加入maven的mybatis坐标，mysql驱动的坐标

<!--mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.6</version>
    </dependency>

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

（4）加入Maven插件

 <resource>
        <directory>src/main/java</directory><!--所在的目录-->
        <includes><!--包括目录下的.properties,.xml文件都会扫描到-->
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>

（5）创建student实体类（domain目录下）

package com.putao.domain;

//推荐和表名一致。容易记忆
public class Student {
    //定义属性，目前要求是属性名和列名一致。
    private Integer id;
    private String name;
    private String email;
    private Integer age;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", age=" + age +
                '}';
    }
}

（6）创建持久层的dao接口，定义操作数据库的方法

package com.putao.dao;

import com.putao.domain.Student;

import java.util.List;

//接口操作student表
public interface StudentDao {

    //查询student表的所有数据
    public List<Student> selectStudents();

    //插入方法
    //参数：student,表示要插入到数据库的数据
    //返回值：int,表示执行insert操作后的影响数据库的行数
    public int insertStudent(Student student);
}

（7）创建mapper文件,studentDap.xml

<?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">
<mapper namespace="com.putao.dao.StudentDao">

    <!--
        select:表示查询操作。
        id:你要执行的sql语句的唯一标识，mybatis会使用这个id的值自定义来找到要执行的sql语句
            可以自定义，但是要求你使用接口中的方法名称。

        resultType:表示结果类型的，是sql语句执行后得到的ResultSet,遍历这个ResultSet得到java对象的类型
            值写的类型的全限定名称
      -->
    <select id="selectStudents" resultType="com.putao.domain.Student">
        select id,name,email,age from student order by id
    </select>

<!--    插入操作-->
    <insert id="insertStudent">
        insert into student values(#{id},#{name},#{email},#{age})
    </insert>

</mapper>

<!--
    sql映射文件（sql mapper）：写sql语句的，mybatis会执行这些sql
    1.指定约束文件
    <!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">


    mybatis-3-mapper.dtd是约束文件的名称，扩展名是dtd的。
    2.约束文件作用：限制，检查在当前文件中出现的标签，属性必须符合mybatis的要求。

    3.mapper是当前文件的根标签，必须的。
      namespace:叫做命名空间，唯一值的，可以是自定义的字符串。
                要求你使用dao接口的全限定名称

    4.在当前文件中，可以使用特定的标签，表示数据库的特定操作。
        <select>:表示执行查询，select语句
        <update>:表示更新数据库的操作，就是在<update>标签中写的是updata sql语句
        <insert>:表示插入，放的是insert语句
        <delete>:表示删除，执行的delete语句

-->

（8）创建mybatis的主配置文件（resources目录下）

<?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>

<!--    settings：控制mybatis全局行为-->
    <settings>
<!--        设置mybatis输出日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <!-- 环境配置：数据库的连接信息
            default:必须和某个environment的id值一样
            告诉mybatis使用哪个数据库的连接信息。也就是访问哪个数据库
    -->
    <environments default="mydev">
        <!--   environment：一个数据库信息的配置，环境
                id:一个唯一值，自定义，表示环境的名称
           -->
        <environment id="mydev">
            <!-- transactionManager:mybatis的事物类型
                    type:JDBC(表示使用jdbc中的Connection对象的commit,rollback做事物处理)
            -->
            <transactionManager type="JDBC"/>
            <!--
                dataSource:表示数据源，连接数据库的
                type:表示数据源的类型，POOLED表示使用连接池
            -->
            <dataSource type="POOLED">
                <!--
                    driver,user,username,password是固定的，不能自定义
                -->
                <!-- 数据库的驱动类名-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!-- 连接数据库的url字符串-->
                <property name="url" value="jdbc:mysql://localhost:3306/springdb"/>
                <!-- 访问数据库的用户名-->
                <property name="username" value="root"/>
                <!-- 密码-->
                <property name="password" value="root"/>
            </dataSource>
        </environment>

        <!-- 表示线上的数据库，是项目真实使用的库-->
        <environment id="online">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/onlinedb"/>
                <property name="username" value="root"/>
                <property name="password" value="schfjbj"/>
            </dataSource>
        </environment>

    </environments>
    <!-- sql mapper（sql映射文件的位置）-->
    <mappers>
        <!-- 一个mapper标签指定一个文件的位置
                从类路径开始的路径信息。   target/classes(类路径)
        -->
        <mapper resource="com/putao/dao/StudentDao.xml"/>
<!--        <mapper resource="com/putao/dao/SchoolDao.xml"/>-->
    </mappers>
</configuration>
<!--

    mybatis的主配置文件：主要定义了数据库的配置信息，sql映射文件的位置

    1.约束文件
    <!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

     mybatis-3-config.dtd:约束文件的名称

     2.configuration 根标签

-->

（9）测试mybatis的select

package com.putao;

import com.putao.domain.Student;
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;
import java.util.List;

public class MyApp {
    public static void main(String[] args) throws IOException {
        //访问mybatis读取student数据
        //1.定义mybatis主配置文件的名称，从类路径的根开始（target/classes）
        String config="mybatis.xml";
        //2.读取这个config表示的文件
        InputStream in = Resources.getResourceAsStream(config);
        //3.创建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //4.创建对象
        SqlSessionFactory factory = builder.build(in);
        //5.【重要】获取对象，从SqlSessionFactory中获取
        SqlSession sqlSession = factory.openSession();
        //6.【重要】指定要执行的sql语句的标识。sql映射文件中的namespace+"."+标签的id值
//        String sqlId = "com.putao.dao.StudentDao"+"."+"selectStudents";
        String sqlId = "com.putao.dao.StudentDao.selectStudents";
        //7.执行sql语句，通过sqlId找到语句
        List<Student> studentList = sqlSession.selectList(sqlId);
        //8.输出结果
        studentList.forEach(System.out::println);
        //9.关闭sqlSession对象
        sqlSession.close();
    }
}

（10）创建测试类TestMyBatis,测试insert

package com.putao;

import com.putao.domain.Student;
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 org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class TestMybatis {
    //测试方法，测试功能
    @Test
    public void testInsert() throws IOException {
        //访问mybatis读取student数据
        //1.定义mybatis主配置文件的名称，从类路径的根开始（target/classes）
        String config="mybatis.xml";
        //2.读取这个config表示的文件
        InputStream in = Resources.getResourceAsStream(config);
        //3.创建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //4.创建对象
        SqlSessionFactory factory = builder.build(in);
        //5.【重要】获取对象，从SqlSessionFactory中获取
//        SqlSession sqlSession = factory.openSession();
        SqlSession sqlSession = factory.openSession(true);
        //6.【重要】指定要执行的sql语句的标识。sql映射文件中的namespace+"."+标签的id值
        String sqlId = "com.putao.dao.StudentDao.insertStudent";
        //7.执行sql语句，通过sqlId找到语句
        Student student = new Student();
        student.setId(1005);
        student.setName("关羽");
        student.setEmail("guanyu@163.com");
        student.setAge(20);
        int nums = sqlSession.insert(sqlId, student);
        //mybatis默认不是自动提交事物的，所以在insert，update，delete后要手动提交事物
//        sqlSession.commit();
        //8.输出结果
        System.out.println("执行insert结果="+nums);
        //9.关闭sqlSession对象
        sqlSession.close();
    }
}

1.3工具类的使用

1）util包下创建MyBatisUtils.java

package com.putao.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 MyBatisUtils {

    private static SqlSessionFactory factory = null;
    static {
        String config="mybatis.xml";//需要和你的项目中的文件名一样
        try {
            InputStream in = Resources.getResourceAsStream(config);
            //创建SqlSessionFactory对象，使用SqlSessionFactoryBuild
            factory = new SqlSessionFactoryBuilder().build(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //获取sqlSession的方法
    public static SqlSession getSqlSession() {
        SqlSession sqlSession = null;
        if (factory != null){
            sqlSession =factory.openSession();//非自动提交事物
        }
        return sqlSession;
    }
}

2)使用工具类

package com.putao;

import com.putao.domain.Student;
import com.putao.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import java.io.IOException;
import java.util.List;

public class MyApp2 {
    public static void main(String[] args) throws IOException {

        //5.【重要】获取对象，从SqlSessionFactory中获取
        SqlSession sqlSession = MyBatisUtils.getSqlSession() ;
        //6.【重要】指定要执行的sql语句的标识。sql映射文件中的namespace+"."+标签的id值
        String sqlId = "com.putao.dao.StudentDao.selectStudents";
        //7.执行sql语句，通过sqlId找到语句
        List<Student> studentList = sqlSession.selectList(sqlId);
        //8.输出结果
        studentList.forEach(System.out::println);
        //9.关闭sqlSession对象
        sqlSession.close();
    }
}

1.4idea代码模板

1）创建
在这里插入图片描述 2）使用

2.主要类的介绍

1）Resources：mybatis中的一个类，负责读取主配置文件
InputStream in = Resources.getResourceAsStream(“mybatis.xml”);
2）SqlSessionFactoryBuilder：创建SqlSessionFactory对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//创建对象
SqlSessionFactory factory = builder.build(in);
3）SqlSessionFactory ：重量级对象，程序创建一个对象耗时比较长，使用资源比较多。在整个项目中，有一个就够用了。
SqlSessionFactory ：接口，接口实现类：DefaultSqlSessionFactory
SqlSessionFactory作用：获取SqlSession对象。SqlSession sqlSession = factory.openSession();
openSession()方法说明：
1.openSession()：无参数的，获取是非自动提交事物的SqlSession对象
2.openSession(boolean)：openSession(true) 获取自动提交事务的openSession。
openSession(false)非自动提交事务的openSession对象。
4）SqlSession ：
SqlSession接口：定义了操作数据的方法，
例如：selectOne(),selectList(),insert(),update(),delete(),commit(),rollback()
SqlSession接口的实现类DefaultSqlSession。
使用要求：SqlSession对象不是线程安全的，需要在方法内部使用，在执行sql语句之前，使用openSession()获取SqlSession对象。在执行完sql语句后，需要关闭它，执行sqlSession.close();这样能保证他的使用是线程安全的。

3.传统dao的使用

1）创建实体类Student.java，如上案例。
2）创建dao层下StudentDao.java。

package com.putao.dao;

import com.putao.domian.Student;

import java.util.List;

public interface StudentDao {

    List<Student> selectStudents();

    int insertStudent(Student student);
}

3)创建dao层下StudentDao.xml。

<?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">
<mapper namespace="com.putao.dao.StudentDao">

    <select id="selectStudents" resultType="com.putao.domian.Student">
        select id,name,email,age from student order by id
    </select>

    <insert id="insertStudent">
        insert into student value (#{id},#{name},#{email},#{age})
    </insert>

</mapper>

4)resource下添加数据库配置文件。如上案例所示。

<?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>

    <settings>
        <!--        设置mybatis输出日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <environments default="mydev">
        <environment id="mydev">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">

                <!-- 数据库的驱动类名-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!-- 连接数据库的url字符串-->
                <property name="url" value="jdbc:mysql://localhost:3306/springdb"/>
                <!-- 访问数据库的用户名-->
                <property name="username" value="root"/>
                <!-- 密码-->
                <property name="password" value="root"/>
            </dataSource>
        </environment>

    </environments>
    <!-- sql mapper（sql映射文件的位置）-->
    <mappers>
        <mapper resource="com/putao/dao/StudentDao.xml"/>
        <!--        <mapper resource="com/putao/dao/SchoolDao.xml"/>-->
    </mappers>
</configuration>

5)创建util工具类，获取sqlSeaaion。如上案例所示。

package com.putao.util;

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 MyBatisUtils {

    private static SqlSessionFactory factory = null;
    static {
        String config="mybatis.xml";//需要和你的项目中的文件名一样
        try {
            InputStream in = Resources.getResourceAsStream(config);
            //创建SqlSessionFactory对象，使用SqlSessionFactoryBuild
            factory = new SqlSessionFactoryBuilder().build(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //获取sqlSession的方法
    public static SqlSession getSqlSession() {
        SqlSession sqlSession = null;
        if (factory != null){
            sqlSession =factory.openSession();//非自动提交事物
        }
        return sqlSession;
    }
}

6)dao.impl层下创建StudentDao的实现类StudentDaoImpl。

package com.putao.dao.impl;

import com.putao.dao.StudentDao;
import com.putao.domian.Student;
import com.putao.util.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.List;

public class StudentDaoImpl implements StudentDao {
    @Override
    public List<Student> selectStudents() {
        //获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        String sqlId = "com.putao.dao.StudentDao.selectStudents";
        //执行sql语句，使用SqlSession类的方法
        List<Student> students = sqlSession.selectList(sqlId);
        //关闭
        sqlSession.close();
        return students;
    }

    @Override
    public int insertStudent(Student student) {
        //获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        String sqlId = "com.putao.dao.StudentDao.insertStudent";
        //执行sql语句，使用SqlSession类的方法
        int nums = sqlSession.insert(sqlId, student);
        //提交事务
        sqlSession.commit();
        //关闭
        sqlSession.close();
        return nums;
    }
}

7）测试

package com.putao;

import com.putao.dao.StudentDao;
import com.putao.dao.impl.StudentDaoImpl;
import com.putao.domian.Student;
import org.junit.Test;

import java.util.List;

public class TestMyBatis {

    @Test
    public void testSelectStudents(){
        StudentDao dao = new StudentDaoImpl();
        /**
         * List<Student> students = dao.selectStudents(); 调用
         * 1.dao对象，类型是StudentDao，全限定名称是：com.putao.dao.StudentDao
         *  全限定名称 和 namespace 是一样的。
         *
         *  2.方法名称，selectStudents，这个方法就是mapper文件中的id值  selectStudents
         *
         *  3.通过dao中方法方法的返回值也可以确定MyBatis要调用的SqlSession的方法。
         *      如果返回值是list，调用的是SqlSession.selectList()方法
         *      如果返回值是int,,或是非list的，看mapper文件中的标签是<insert>,<update>就会调用
         *      SqlSession的insert,update等方法。
         *
         *  mybatis的动态代理：mybatis根据dao的方法调用，获取执行sql语句的信息。
         *      mybatis根据你的dao接口，创建出一个dao接口的实现类，并创建这个类的对象。
         *      完成SqlSession调用方法，访问数据库。
         */
        List<Student> students = dao.selectStudents();
        students.forEach(System.out::println);
    }

    @Test
    public void testInsertStudent(){
        StudentDao dao = new StudentDaoImpl();
        Student student = new Student();
        student.setId(1006);
        student.setName("盾山");
        student.setEmail("dunshan@qq.com");
        student.setAge(22);
        int nums = dao.insertStudent(student);
        System.out.println("添加对象的数量："+nums);

    }
}

4.动态代理的使用

使用mybatis的动态代理机制，使用SqlSession.getMapper(dao接口.class)获取这个dao接口的对象。

@Test
    public void testSelectStudents(){
        /**
         * 使用mybatis的动态代理机制，使用SqlSession.getMapper(dao接口)
         * getMapper能获取dao接口对应的实现类对象。
         */
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        //com.sun.proxy.$Proxy5：jdk的动态代理
        System.out.println("dao="+dao.getClass().getName());
        //调用dao的方法，执行数据库的操作
        List<Student> students = dao.selectStudents();
        students.forEach(t-> System.out.println("学生："+t));
    }

    @Test
    public void testInsertStudent(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        Student student = new Student();
        student.setId(1007);
        student.setName("李飞");
        student.setEmail("lifei@qq.com");
        student.setAge(28);
        int nums = dao.insertStudent(student);
        sqlSession.commit();
        System.out.println("添加对象的数量："+nums);

    }

    @Test
    public void testSelectStudentById(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        Student student = dao.selectStudentById(1002);
        System.out.println("student="+student);

    }

5.传入参数

从java代码中把数据传入到mapper文件的sql语句中。

5.1【掌握】一个简单参数

一个简单类型参数：
简单类型：mybatis把java的基本数据类型和String都叫简单类型
在mapper文件获取简单类型的一个参数的值，使用#{任意字符}

dao层

    public Student selectStudentById(@Param("studentID") Integer id);

dao层xml

    <select id="selectStudentById" parameterType="java.lang.Integer" resultType="com.putao.domian.Student">
        select id,name,email,age from student where id=${studentID}
    </select>

parameterType:dao接口中方法参数的数据类型
parameterType它的值是java的数据类型全限定名称或者是mybatis定义的别名
例如：parameterType=“java.lang.Integer”
parameterType=“int”
注意：parameterType不是强制的，mybatis通过反射机制能够发现接口参数的数据类型。
所以可以没有。一般我们也不写。

在#{}之后，mybatis执行sql是使用jdbc中的PreparedStatement对象
由mybatis执行下面的代码：
1.mybatis创建Connection,PreparedStatement对象
String sql =“select id,name,email,age from student where id=?”
PreparedStatement pst = conn.preparedStatement(sql);
pst.setInt(1,1001);

2.执行Sql封装为resultType="com.putao.domian.Student"这个对象
ResultSet rs = pst.executeQuery();
Student student = null;
while(rs.next()){
//从数据库取表的一行数据，存到一个java对象属性中
student = new Student();
student.setId(rs.getInt(“id”));
student.setName(rs.getString(“name”));
student.setEmail(rs.getString(“email”));
student.setAge(rs.getInt(“age”))
}
return student;//付给了dao方法调用的返回值

Test

@Test
    public void testSelectStudentById(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        Student student = dao.selectStudentById(1001);
        System.out.println("student="+student);

    }

5.2【掌握】多个参数-使用@Param

多个参数：命名参数，在形参定义的前面加入@Param(“自定义参数名称”)

dao层

List<Student> selectMulitParam(@Param("myname") String name,@Param("myage") Integer age);

dao层xml

<!--    多个参数，使用@Param命名-->
    <select id="selectMulitParam" resultType="com.putao.domian.Student">
        select id,name,email,age from student where name=#{myname} or age=#{myage}
    </select>

Test

@Test
    public void testSelectMultiParam(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);

        List<Student> students = dao.selectMulitParam("李四",20);

        students.forEach(student -> System.out.println("学生="+student));

        sqlSession.close();
    }

5.3【掌握】多个参数-使用对象

多个参数，使用java对象作为接口中方法的参数

dao层

List<Student> selectMultiObject(QueryParam param);

List<Student> selectMultiStudent(Student student);

dao层xml

<!--    <select id="selectMultiObject" resultType="com.putao.domian.Student">-->
<!--        select id,name,email,age from student where name=#{paramName,javaType=java.lang.String,jdbcType=VARCHAR}-->
<!--                                                 or age=#{paramAge,javaType=java.lang.Integer,jdbcType=INTEGER}-->
<!--    </select>-->

    <select id="selectMultiObject" resultType="com.putao.domian.Student">
        select id,name,email,age from student where name=#{paramName}
                                                 or age=#{paramAge}
    </select>
    <select id="selectMultiStudent" resultType="com.putao.domian.Student">
        select id,name,email,age from student where name=#{name} or age=#{age}
    </select>

多个参数，使用java对象的属性值，作为参数实际值
使用对象的语法：#{属性名，javaType=类型名称，jdbcType=数据库类型} 很少用。
javaType：指java中的属性数据类型
jdbcType：指数据库中的数据类型。
例如：#{paramName,javaType=java.lang.String,jdbcType=VARCHAR}
#{paramAge,javaType=java.lang.Integer,jdbcType=INTEGER}

我们使用的简化方式：#{属性名}。javaType,jdbcType的值mybatis反射能获取。不用提供

test

@Test
    public void testSelectMultiObject(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);

        QueryParam param = new QueryParam();
        param.setParamName("张三");
        param.setParamAge(28);
        List<Student> students = dao.selectMultiObject(param);

        students.forEach(student -> System.out.println("学生="+student));

        sqlSession.close();
    }

    @Test
    public void testSelectMultiStudent(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);

        Student student = new Student();
        student.setName("张三");
        student.setAge(28);
        List<Student> students = dao.selectMultiStudent(student);

        students.forEach(t -> System.out.println("学生="+t));

        sqlSession.close();
    }

5.4【了解】多个参数-按位置

多个参数-简单类型的，按位置传值
* mybatis.3.4之前，使用#{0},#{1}
* mybatis.3.4之后，使用#{arg0},#{arg1}

dao层

List<Student> selectMultiPosition(String name,Integer age);

dao层xml

<!--    多个参数使用位置-->
   <select id="selectMultiPosition" resultType="com.putao.domian.Student">
       select id,name,email,age from student where
       name = #{arg0} or age = #{arg1}
   </select>

Test

@Test
   public void testSelectMultiPosition(){
       SqlSession sqlSession = MyBatisUtils.getSqlSession();
       StudentDao dao = sqlSession.getMapper(StudentDao.class);

       List<Student> students = dao.selectMultiPosition("李四",20);

       students.forEach(t -> System.out.println("学生="+t));

       sqlSession.close();
   }

5.5【了解】多个参数-使用Map

多个参数，使用Map存放多个值

dao层

List<Student> selectMultiByMap(Map<String,Object> map);

dao层xml

<!--    多个参数使用Map,使用的语法是#{map的key}-->
    <select id="selectMultiByMap" resultType="com.putao.domian.Student">
        select id,name,email,age from student where
            name = #{myname} or age = #{age}
    </select>

Test

@Test
    public void testSelectMultiByMap(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);

        Map<String,Object> data = new HashMap<>();
        data.put("myname","张三");
        data.put("age","28");

        List<Student> students = dao.selectMultiByMap(data);

        students.forEach(t -> System.out.println("学生="+t));

        sqlSession.close();
    }

5.6【掌握】#和$

$有sql注入风险，不够安全。

dao层

List<Student> selectUse$(@Param("myname") String name);
List<Student> selectUse$Order(@Param("colName") String colName);

dao层xml

<!--    使用${}-->
    <select id="selectUse$" resultType="com.putao.domian.Student">
        select * from student where name=${myname}
    </select>

<!--    $替换列名-->
    <select id="selectUse$Order" resultType="com.putao.domian.Student">
        select * from student order by ${colName}
    </select>

Test

 @Test
    public void testSelectUse$(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);

//        List<Student> students = dao.selectUse$("'李四'");
        List<Student> students = dao.selectUse$("'李四';drop table student");

        students.forEach(t -> System.out.println("学生="+t));

        sqlSession.close();
    }

    @Test
    public void testSelectUse$Order(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);

        List<Student> students = dao.selectUse$Order("age");

        students.forEach(t -> System.out.println("学生="+t));

        sqlSession.close();
    }