MyBatis

1、mybatis提供了哪些功能

  1. 注册驱动

  2. 创建jdbc中使用的Connection,Statement，ResultSet

  3. 执行sql语句，得到ResultSet

  4. 处理ResultSet，把记录集中的数据转为java对象，同时还能把java对象放入到List集合。

  5. 关闭资源

  6. 实现sql语句和java代码的解耦合。

2、MyBatis下载

MyBatis中文官网： mybatis – MyBatis 3 | 简介

image

MyBatis下载： GitHub - mybatis/mybatis-3: MyBatis SQL mapper framework for Java

image

image

3、MyBatis入门

3.1、第一个例子

实现步骤：

1、创建student表(id,name,email，age)

2、新建maven项目

3、修改pom.xml

  • 加入依赖 mybatis依赖,mysql驱动, junit
  • 在<build>加入资源插件

4、创建实体类Student。定义属性,属性名和列名保持一致

5、创建Dao接口,定义操作数据库的方法。

6、创建xml文件(mapper文件)，写sql语句。

  • mybatis框架推荐是把sql语句和java代码分开
  • mapper文件:定义和dao接口在同一目录，一个表一个mapper文件。

7、创建mybatis的主配置文件（xml文件）：有一个，放在resources目录下

  • 定义创建连接实例的数据源(DataSource)对象
  • 指定其他mapper文件的位置

8、创建测试的内容。

  • 使用main方法，测试mybatis访问数据库
  • 也可以使用junit访问数据库

在pom.xml中配置：

    <dependencies>
            <!-- 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>
        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <!-- 资源插件:处理src/main/java目录中的xml-->
        <resources>
            <resource>
                <directory>src/main/java</directory><!-- 所在的目录-->
                <includes><!-- 包括目录下的.properties,.xml文件都会扫描到-->
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

public class Student {
    //属性名和列名一样
    private Integer id;
    private String name;
    private String email;
    private Integer age;

public interface StudentDao {
    //查询一个学生
    Student selectStudentById(Integer id);
}

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.company.dao.StudentDao">
<!--
    查询一个学生Student
        <select>:
            id:要执行的sql语句的唯一标识，是一个自定义字符串。
                推荐使用dao接口中的方法名称
            resultType:告诉mybatis，执行sql语句，把数据赋值给那个类型的java对象。
                resultType的值现在使用的java对象的全限定名称
-->
    <select id="selectStudentById" resultType="com.company.bean.Student">
        select id,name,email,age from student where id = 1001
    </select>
</mapper>

<!--
    1、约束文件
     http://mybatis.org/dtd/mybatis-3-mapper.dtd
     约束文件作用:定义和限制当前文件中可以使用的标签和属性，以及标签出现的顺序。
    2、mapper是根标签
      namespace：命名空间，必须有值，不能为空。唯一值。
                推荐使用Dao接口的全限定名称。
      作用：参与识别sql语句的作用。
    3、在mapper里面可以写<insert> , <update> ,<delete>,<select>等标签。
       <insert>里面是insert语句，表示执行insert操作
       <update>里面是update语句
       <delete>里面是delete语句
       <select>里面是select语句
-->

在resources下建mybatis.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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
                <!--配置数据源:创建connection对象。 -->
            <dataSource type="POOLED">
                    <!--driver:驱动的内容-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 指定其他mapper文件的位置:目的是为了找到其他文件的sql语句-->
    <mappers>
            <!--使用mapper的resource属性指定mapper文件的路径。这个路径是从target/classes路径开启的-->
            <!--
                   使用注意:resource="mapper文件的路径,使用/分割路径”
                           一个mapper resource指定一个mapper文件
            -->
        <mapper resource="com/company/dao/StudentDao.xml"/>
    </mappers>
</configuration>

public class MyTest {

    @Test
    public void selectStudentById() throws IOException {
        //调用mybatis某个对象的方法，执行mapper文件中的sql语句
        //mybatis核心类:sqlSessionFactory

        //1.定义mybatis主配置文件的位置，从类路径开始的相对路径
        String config = "mybatis.xml";
        //2.读取主配置文件。使用mybatis框架中的Resources类
        InputStream inputStream = Resources.getResourceAsStream(config);
        //3.创建SqlSessionFactory对象，使用SqlSessionFactoryBuidler类
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        //4.获取SqlSession对象。
        SqlSession session = factory.openSession();
        //5.指定要执行的sql语句的id
        // sql的id = namespace+"."+ select|update |insert|delete标签的id属性值
        String sqlId = "com.company.dao.StudentDao"+"."+"selectStudentById";
        //6.通过sqlSession的方法，执行sql语句
        Student student = session.selectOne(sqlId);
        System.out.println("使用mybatis查询一个学生："+student);
        //7、关闭sqlSession对象
        session.close();
    }
}

3.2、MyBatis一些重要的对象

1、Resources：mybatis框架中的对象，一个作用读取主配置信息。

InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");

2、SqlSessionFactoryBuilder：负责创建SqlSessionFactory对象

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);

3、SqlSessionFactory：重要对象

  • SqlSessionFactory是重量级对象:创建此对象需要使用更多的资源和时间。在项目中有一个就可以了。
  • SqlSessionFactory接口:作用是SqlSession的工厂，就是创建SqlSession对象。

3、sqlSessionFactory接口中的方法

  • openSession():获取一个默认的SqlSession对象，默认是需要手工提交事务的。
  • openSession(boolean): boolean参数表示是否自动提交事务。
    • true:创建—个自动提交事务的SqISession
    • false:等同于没有参数的openSession

4、SqlSession对象

  • SqlSession对象是通过SqlSessionFactory获取的。SqlSession本身是接口

  • SqlSession作用是提供了大量的执行sql语句的方法:

    selectOne:执行sql语句,最多得到一行记录，大于1行会报错。
selectList:执行sql语句,返回多行数据
selectMap:执行sql语句,得到一个Map结果
insert：执行insert语句
update：执行update语句
delete：执行delete语句
commit：提交事务
rollback:回滚事务

    注意SqlSession对象不是线程安全的，使用的步骤:

    a: 在方法的内部，执行sql语句之前，先获取SqlSession对象

    b: 调用SqlSession的方法，执行sql语句

    c: 关闭SqlSession对象，执行SqlSession.close()

4、使用工具类

public class MyBatisUtil {

    private static SqlSessionFactory factory=null;

    static {
        String config="mybatis.xml";
        try {
            InputStream inputStream = Resources.getResourceAsStream(config);
            factory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //创建方法，获取SqlSession对象
    public static SqlSession getSqlSession(){
        SqlSession session = null;
        if(factory!=null){
            session= factory.openSession();
        }
        return session;
    }
}

<?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.company.dao.StudentDao">
    <select id="selectStudents" resultType="com.company.bean.Student">
        select id,name,email,age from student
    </select>
    <insert id="insertStudent">
        insert into student values(#{id},#{name},#{email},#{age})
    </insert>
</mapper>

    @Test
    public void testSelectStudents(){
        //1.获取sqlSession
        SqlSession session = MyBatisUtil.getSqlSession();
        //2、指定SqlId
        String sqlId="com.company.dao.StudentDao.selectStudents";
        //3、执行sqlSession的方法，表示执行sql语句
        List<Student> list = session.selectList(sqlId);
        for (Student stu : list) {
            System.out.println("student--->"+stu);
        }
        //4.关闭sqlSession对象
        session.close();
    }

    @Test
    public void testInsertStudents(){
        //1.获取sqlSession
        SqlSession session = MyBatisUtil.getSqlSession();
        //2、指定SqlId
        String sqlId="com.company.dao.StudentDao.insertStudent";
        //3、执行sqlSession的方法，表示执行sql语句
        Student student = new Student();
        student.setId(1003);
        student.setName("曹操");
        student.setEmail("caocao@qq.com");
        student.setAge(18);
        int i = session.insert(sqlId, student);
        session.commit();
        System.out.println("影响的行数---》"+i);
        //4.关闭sqlSession对象
        session.close();
    }

5、dao代理

5.1、mybatis提供代理:

mybatis创建Dao接口的实现类对象，完成对sql语句的执行。mybatis创建一个对象代替你的dao实现类功能。

5.2、使用mybatis代理要求

1、mapper文件中的namespace一定dao接口的全限定名称

2、mapper文件中标签的id是dao接口方法名称

5.3、mybatis代理实现方式

使用SqlSession对象的方法getMapper(dao.class)

例如:现在有StudentDao接口。

SqlSession session = MyBatisUtil.getSqlSession();
StudentDao dao = session.getMapper(StudentDao.class);
Student student =dao.selectById(1001);

//上面代码中
StudentDao dao = session.getMapper(StudentDao.class);
//等同于
StudentDao dao = new StudentDaoImpl();

6、理解参数

理解参数是:通过java程序把数据传入到mapper文件中的sql语句。参数主要是指dao接口方法的形参

6.1、parameterType

parameterType:表示参数的类型，指定dao方法的形参数据类型。这个形参的数据类型是给mybatis使用。mybatis在给sql语句的参数赋值时使用。PreparedStatement.setXXX(位置，值)

<!--
	第一个用法:java类型的全限定类型名称parameterType="java.lang.Integer"
	第二个用法:mybatis定义的java类型的别名parameterType="int"
-->
<select id="selectById" parameterType="integer" resultType="com.company.bean.Student">
        select id,name,email,age from student where id=#{studentId}
    </select>

6.2、dao接口方法是一个简单类型的参数

    //简单类型:java基本数据类型和String
    Student selectByEmail(String email);

    <!--
    dao接口是一个简单类型的参数
     mapper文件，获取这个参数值，使用#{任意字符]
     -->
    <select id="selectByEmail"  resultType="com.company.bean.Student">
        select id,name,email,age from student where email=#{studentEmail}
    </select>

    @Test
    public void testOneParameter(){
        SqlSession session = MyBatisUtil.getSqlSession();
        StudentDao dao = session.getMapper(StudentDao.class);
        Student student = dao.selectByEmail("ww@123");
        System.out.println("email:==="+student);
        session.close();
    }

6.3、dao接口方法有多个简单类型的参数

@Param:命名参数，在方法的形参前面使用的，定义参数名。这个名称可以用在mapper文件中。

    /*
        多个简单类型的参数
        使用@Param命名参数,注解是mybatis提供的
        位置:在形参定义的前面
        属性: value自定义的参数名称
     */
    List<Student> selectByNameOrAge(@Param("myname") String name,@Param("myage") Integer age);

    <!--
    多个简单类型的参数.
    当使用了@Par am命名后，例如@Par am ("myname").
    在mapper中，使用#{命名的参数}，例如#{myname}
    -->
    <select id="selectByNameOrAge"  resultType="com.company.bean.Student">
        select id,name,email,age from student where name=#{myname} or age=#{myage}
    </select>


    @Test
    public void testSelectByNameOrAge(){
        SqlSession session = MyBatisUtil.getSqlSession();
        StudentDao dao = session.getMapper(StudentDao.class);
        List<Student> student = dao.selectByNameOrAge("李四", 15);
        student.forEach(student1 -> System.out.println("stu->"+student1));
        session.close();
    }

6.4、dao接口方法使用一个对象作为参数

方法的形参是一个java对象。这个java对象表示多个参数。使用对象的属性值作为参数使用

    //一个java对象作为参数(对象由属性，每个属性有set，get方法)
    List<Student> selectByObject(Student student);

    <!--
        一个java对象作为方法的参数，使用对象的属性作为参数值使用
        简单的语法:#{属性名},mybatis调用此属性的getxxx()方法获取属性值
    -->
    <select id="selectByObject"  resultType="com.company.bean.Student">
        select id,name,email,age from student where name=#{name} or age=#{age}
    </select>

    @Test
    public void testSelectByObject(){
        SqlSession session = MyBatisUtil.getSqlSession();
        StudentDao dao = session.getMapper(StudentDao.class);

        Student student = new Student();
        student.setName("李四");
        student.setAge(15);
        List<Student> students = dao.selectByObject(student);
        students.forEach(student1 -> System.out.println("stu->"+student1));
        session.close();
    }

7、#和$的区别

7.1、#占位符

mybatis处理#{}使用jdbc对象是PrepareStatment对象

    <select id="selectById"  resultType="com.company.bean.Student">
        select id,name,email,age from student where id=#{studentId}
    </select>
<!--
	mybatis出创建prepar eStatement对象，执行sq1语向
	String sql = "select id,name,email,age from student where id=?";
	PrepareStatement pst = conn.prepareStatement(sq1);
	pst.setInt(1,1001);//传递参数
	ResultSet rs = pst.executeQuery();//执行sql
-->

#{}特点：

  • 使用的PrepareStatement对象，执行sql语句，效率高。
  • 使用的PrepareStatement对象，能避免sql注入，sql语句执行更安全。
  • #{}常常作为列值使用的，位于等号的右侧，#{}位置的值和数据类型有关的。

7.2、$占位符

mybatis执行${}占位符的sql语句

    <select id="selectById"  resultType="com.company.bean.Student">
        select id,name,email,age from student where id=${studentId}
    </select>
<!--
	${}表示字符串连接，把sq1语句的其他内容和${}内容使用字符串（+)连接的方式连在一起
	String sql = "select id,name,email,age from student where id="+"1001";
	mybatis创建Statement对象，执行sq1语句。
	Statement stmt = conn.createStatement(sq1);
	ResultSet rs = stmt.executeQuery();
-->

${}的特点：

  • 使用Statement对象，执行sql语句，效率低
  • ${}占位符的值，使用的字符串连接方式，有sql注入的风险。有代码安全的问题
  • ${}数据是原样使用的，不会区分数据类型。
  • ${}常用作 表名或者 列名，在能保证数据安全的情况下使用${}

8、封装MyBatis输出结果

封装输出结果: MyBatis执行sql语句，得到ResultSet,转为java对象。

讲两个resultType, resultMap

8.1、resultType

resultType属性：在执行select时使用，作为<select>标签的属性出现的。

resultType:表示结果类型，mysql执行sql语句，得到java对象的类型。它的值有两种

  • (1) java类型的全限定名称。(2) 使用别名
    <select id="selectById"  resultType="com.company.bean.Student">
        select id,name,email,age from student where id=${studentId}
    </select>
<!--
	resultType:现在使用java类型的全限定名称。表示的意思mybatis执行sql，把Resultset中的数据转为student类型的对象，mybatis会做一下操作：
	1、调用com.company.bean.Student的无参数构造方法，创建对象。
		Student student = new Student（）;//使用反射创建对象
	2、同名的列赋值给同名的属性。
		student.setId(rs.getInt("id"));
		student.setName(rs.getString("name"));
	3、得到java对象，如果dao接口返回值是List集合，mybatis把student对象放入到List集合。
-->

8.2、resultMap

resultMap：结果映射。自定义列名和java对象属性的对应关系。常用在列名和属性名不同的情况。

用法：

1、.先定义resultMap标签，指定列名和属性名称对应关系

2、在select标签使用resultMap属性，指定上面定义的resultMap的id值

<!--使用resultMap定义列和属性的关系-->
<!--
	定义resultMap
	id:给resultMap的映射关系起个名称,唯一值
	type :java类型的全限定名称
-->
    <resultMap id="customMap" type="com.company.bean.customObject">
        <!-- 定义列名和属性名的对应-->
        <!--主键类型使用id标签-->
        <id column="id" property="cid"></id>
        <!-- 非主键类型使用result标签-->
        <result column="name" property="cname"></result>
        <!-- 列名和属性名相同不用定义-->
    </resultMap>
    <select id="selectById"  resultMap="customMap">
        select id,name,email,age from student where id =#{stuid}
    </select>

列名和java对象属性名称不一样解决方式

  • 使用resultMap:自定义列名和属性名称对应关系
  • 使用resultType:使用列别名，让别名和java对象属性名称一样

9、自定义别名

mybatis提供的对java类型定义简短，好记名称。

自定义别名的步骤:

1、在mybatis主配置文件，使用typeAliases标签声明别名

2、在mapper文件中, resultType="别名""

mybatis.xml:(第一种方式)

    <!-- 声明别名-->
    <typeAliases>
        <!-- 第一种语法格式
                type:java类型的全限定名称（自定义类型)
                alias:自定义别名
			优点：可以自定义别名
			缺点：每个类型必须单独定义
        -->
        <typeAlias type="com.company.bean.Student" alias="stu"></typeAlias>
    </typeAliases>

    <select id="selectStudents"  resultType="stu">
        select id,name,email,age from student
    </select>

第二种方式：

    <!-- 声明别名-->
    <typeAliases>
        <!-- 第二种方式
            name:包名，mybatis会把这个包中所有类名作为别名（不用区分大小写>
			优点：使用方便，一次给多个类定义别名
			缺点：别名不能自定义，必须是类名。
        -->
        <package name="com.company.bean"/>
    </typeAliases>

    <select id="selectStudents"  resultType="student">
        select id,name,email,age from student
    </select>

10、模糊查询like

第—种方式:在java程序中，把like的内容组装好。把这个内容传入到sql语句

    List<Student> selectLikeOne(@Param("name") String name);

    <select id="selectLikeOne"  resultType="com.company.bean.Student">
        select * from student where name like #{name}
    </select>

    @Test
    public void testLikeOne(){
        SqlSession session = MyBatisUtil.getSqlSession();
        StudentDao dao = session.getMapper(StudentDao.class);
        String name= "李%";
        List<Student> students = dao.selectLikeOne(name);
        session.close();
        students.forEach(student -> System.out.println(student));
    }

11、动态sql

什么是动态sql:同一个dao的方法，根据不同的条件可以表示不同的sql语句，主要是where部分有变化

使用mybatis提供的标签，实现动态sql的能力，主要讲if ,where, foreach，sql,

使用动态sql的时候, dao方法的形参使用java对象。

什么时候用动态sql：

image

11.1、if

    List<Student> selectIf(Student student);

    <select id="selectIf"  resultType="com.company.bean.Student">
        select * from student
        where id=-1
        <if test="name !=null and name!=''">
            or name = #{name}
        </if>
        <if test="age>0">
            or age = #{age}
        </if>
    </select>

    @Test
    public void testSelectIf(){
        SqlSession session = MyBatisUtil.getSqlSession();
        StudentDao dao = session.getMapper(StudentDao.class);
        Student student = new Student();
        student.setName("李四");
        student.setAge(20);
        List<Student> students = dao.selectIf(student);
        students.forEach(student1 -> System.out.println("stu-->"+student1));
        session.close();
    }

11.2、where标签

使用if标签时，容易引起sql语句语法错误。使用where标签解决if产生的语法问题。

使用时where ,里面是一个或多个if标签，当有一个if标签判断条件为true,where标签会转为WHERE关键字附加到sql语句的后面。如果if没有一个条件为true，忽略where和里面的if。

where标签删除和他最近的or或者and。

    List<Student> selectWhere(Student student);

    <select id="selectWhere"  resultType="com.company.bean.Student">
        select * from student
        <where>
            <if test="name !=null and name!=''">
                or name = #{name}
            </if>
            <if test="age>0">
                or age = #{age}
            </if>
        </where>
    </select>

    @Test
    public void testSelectWhere(){
        SqlSession session = MyBatisUtil.getSqlSession();
        StudentDao dao = session.getMapper(StudentDao.class);
        Student student = new Student();
        student.setName("李四");
        student.setAge(20);
        List<Student> students = dao.selectWhere(student);
        students.forEach(student1 -> System.out.println("stu-->"+student1));
        session.close();
    }

11.3、foreach循环

使用foreach可以循环数组，list集合，一般使用在in语句中。

语法：

<foreach collection="集合类型" open="开始的字符" close="结束的字符"
         item="集合中的成员" separator="集合成员之间的分隔符">
    #{item 值}
</foreach>
<!--
	标签属性：
		collection：表示，循环的对象是数组，还是1ist集合。
					如果dao接口方法的形参是数组，collection="array”
					如果dao接口形参是List,col1ection="list"
-->

demo：(简单类型)

    List<Student> selectForEachOne(List<Integer> idList);

    <select id="selectForEachOne"  resultType="com.company.bean.Student">
        select * from student
        <if test="list !=null and list.size>0">
            where id in
            <foreach collection="list" open="(" close=")" separator="," item="myid">
                #{myid}
            </foreach>
        </if>
    </select>

    @Test
    public void testselectForEachOne(){
        SqlSession session = MyBatisUtil.getSqlSession();
        StudentDao dao = session.getMapper(StudentDao.class);
        ArrayList<Integer> idList = new ArrayList<>();
        idList.add(1001);
        idList.add(1002);
        idList.add(1003);
        List<Student> students = dao.selectForEachOne(idList);
        students.forEach(student1 -> System.out.println("stu-->"+student1));
        session.close();
    }

demo（对象类型）：

    List<Student> selectForEachTwo(List<Student> studentList);

    <select id="selectForEachTwo"  resultType="com.company.bean.Student">
        select * from student
        <if test="list !=null and list.size>0">
            where id in
            <foreach collection="list" open="(" close=")" separator="," item="stu">
                #{stu.id}
            </foreach>
        </if>
    </select>

    @Test
    public void testselectForEachTwo(){
        SqlSession session = MyBatisUtil.getSqlSession();
        StudentDao dao = session.getMapper(StudentDao.class);
        ArrayList<Student> list = new ArrayList<>();
        Student stu1 = new Student();
        stu1.setId(1001);
        Student stu2 = new Student();
        stu2.setId(1002);
        list.add(stu1);
        list.add(stu2);
        List<Student> students = dao.selectForEachTwo(list);
        students.forEach(student1 -> System.out.println("stu-->"+student1));
        session.close();
    }

11.4、sql标签

sql标签标示一段sql代码，可以是表名，几个字段,where条件都可以，可以在其他地方复用sql标签的内容。

使用方式：

1、在mapper文件中定义sql代码片段<sq1 id="唯一字符串">部分sq1语句</sq1>
2、在其他的位置，使用include标签引用某个代码片段

例如：

<!--定义代码片段-->
<sql id="selectStudent">
    select * from student
</sql>

    <select id="selectForEachTwo"  resultType="com.company.bean.Student">
        <include refid="selectStudent"></include>
        <if test="list !=null and list.size>0">
            where id in
            <foreach collection="list" open="(" close=")" separator="," item="stu">
                #{stu.id}
            </foreach>
        </if>
    </select>

12、使用数据库属性配置文件

需要把数据库的配置信息放到一个单独文件中，独立管理。这个文件扩展名是properties.在这个文件中，使用自定义的key=value的格式表示数据

步骤：

1、在resources目录中，创建xxx.properties

2、在文件中，使用key=value的格式定义数据。

  • 例如jdbc.url=jdbc:mysq://localhost:3306/mybatis

3、在mybatis主配置文件，使用properties标签引用外部的属性配置文件

4、在使用值的位置，使用${key}获取key对应的value(等号右侧的值)

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=123456

mybatis.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>
    <properties resource="jdbc.properties"></properties>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
                <!--配置数据源:创建connection对象。 -->
            <dataSource type="POOLED">
                    <!--driver:驱动的内容-->
                <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>
    <!-- 指定其他mapper文件的位置:目的是为了找到其他文件的sql语句-->
    <mappers>
            <!--使用mapper的resource属性指定mapper文件的路径。这个路径是从target/classes路径开启的-->
            <!--
                   使用注意:resource="mapper文件的路径,使用/分割路径”
                           一个mapper resource指定一个mapper文件
            -->
        <mapper resource="com/company/dao/StudentDao.xml"/>
    </mappers>
</configuration>

13、PageHelper

PageHelper做数据分页。在你的select语句后面加入分页的sql内容，如果你使用的mysql数据库，它就是在select * from student后面加入limit语句。

使用步骤：

1.加入依赖pagehelper依赖

<!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.2.0</version>
</dependency>

2.在mybatis主配置文件，加入plugin声明(在<environments>之前加入)

<plugins>
    <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

3.在select语句之前，调用PageHelper.startPage(页码，每页大小)

demo:

List<Student> selectAllStudent();

    <select id="selectAllStudent"  resultType="com.company.bean.Student">
        select * from student order by id
    </select>

    @Test
    public void testPage(){
        SqlSession session = MyBatisUtil.getSqlSession();
        StudentDao dao = session.getMapper(StudentDao.class);
        PageHelper.startPage(1,3);
        List<Student> students = dao.selectAllStudent();
        students.forEach(student1 -> System.out.println("stu-->"+student1));
        session.close();
    }
posted @   飞翔奥尔良烤翅  阅读(94)  评论(0)  编辑  收藏  举报
相关博文：
·  SpringMVC-上
·  SpringMVC-中
·  Mybatis学习笔记
·  MyBatis基础
·  mybatis学习
阅读排行：
· winform 绘制太阳，地球，月球 运作规律
· AI与.NET技术实操系列（五）：向量存储与相似性搜索在 .NET 中的实现
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
点击右上角即可分享
微信分享提示
AI IDE Trae