mybatis框架(操作数据库)

文章目录

Mybatis框架的使用步骤
MyBatis 使用传统 Dao 开发方式
- - 传统 Dao 开发方式的分析
动态sql
主配置文件说明
- - - 包含mapper文件的两种方式
    - 自动提交事务
pageHelper数据分页
- - 实现步骤：
其他零碎知识

mybatis框架是对JDBC的一个封装

jdbc的缺点

代码比较多，开发效率低
需要关注 Connection ,Statement, ResultSet 对象创建和销毁
对 ResultSet 查询的结果，需要自己封装为 List
重复的代码比较多些
业务代码和数据库的操作混在一起

MyBatis 解决的主要问题
减轻使用 JDBC 的复杂性，不用编写重复的创建 Connetion , Statement ; 不用编写关闭资源代码。
直接使用 java 对象，表示结果数据。让开发者专注 SQL 的处理。其他分心的工作由 MyBatis 代劳。

Mybatis框架的使用步骤

前期准备

mybatis框架是对表实现增删查改操作，不会创建表，所以需要先创建出一个表

 CREATE TABLE `student` (
 `id` int(11) NOT NULL ,
 `name` varchar(255) DEFAULT NULL,
 `email` varchar(255) DEFAULT NULL,
 `age` int(11) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

在这里插入图片描述

mysql的简单操作参考

1. 创建Maven工程

在这里插入图片描述
创建Maven工程选择archetype创建，选择图中的组件，next

输入包名和文件名，next
在这里插入图片描述
finish创建完成

2. 加入相关的依赖

加入mybatis依赖和JDBC依赖和单元测试依赖

 	 <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.28</version>
    </dependency>

在build标签中加入

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

用于构建文件结构
完整的配置文件如下：

 <?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.changsha</groupId>
  <artifactId>Mybatis</artifactId>
  <version>1.0-SNAPSHOT</version>
 
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>
 
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.24</version>
    </dependency>
 
  </dependencies>
 
  <build>
    <resources>
      <resource>
        <directory>src/main/java</directory><!--所在的目录-->
        <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
  </build>
 
 
</project>

创建文件结构如下
在这里插入图片描述

3. 创建实体类，保存表中一行的数据

 package com.changsha.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 +
                '}';
    }
}

4. 创建持久层的dao接口

 package com.changsha.dao;
 
import com.changsha.domain.Student;
import org.apache.ibatis.annotations.Param;
 
import java.util.List;
import java.util.Map;
 
public interface StudentDao {
    public List<Student> selectStudent();
    /*
    * 1.如果参数是对象：
    *   对象属性名字必须和列的名字对应，不然需要进行重命名
    * */
    public Integer insertStudent(Student student);
    /*
    * 2.多参数的情况下：
    *   (1).用@Param注解来指定参数的名字，以便在mapper文件中可以访问到参数
    * */
    public Integer deleteStudent(@Param("argID") Integer id,@Param("argName") String name);
 
    /*
    * 多参数情况下：
    *   (2). 用Map传递参数,key是参数名字，value是参数对应的值
    * */
    public Integer updateStudent(Map<String,Object> args);
}

在这里插入图片描述

5. 创建mapper配置文件

mapper文件的名称要和dao接口的名字一样要和对应的dao接口放在同一个目录下

namespace的值是dao接口的全限定名称
id 是dao方法的名字

内容如下：

 <?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：必须有值，自定义的唯一字符串
 推荐使用：dao 接口的全限定名称
-->
<mapper namespace="com.changsha.dao.StudentDao">
    <!--
    <select>: 查询数据， 标签中必须是 select 语句
    id: sql 语句的自定义名称，推荐使用 dao 接口中方法名称，
    使用名称表示要执行的 sql 语句
    resultType: 查询语句的返回结果数据类型，使用全限定类名
    -->
    <select id="selectStudent" resultType="com.changsha.domain.Student">
        <!--要执行的 sql 语句-->
        select * from student
    </select>
 
    <insert id="insertStudent">
        insert into student (id,name,email,age) values(#{id}, #{name}, #{email}, #{age})
    </insert>
 
    <delete id="deleteStudent">
        delete from student where id = #{argID} and name = #{argName}
    </delete>
 
    <update id="updateStudent">
        update student set id = #{newArg} where id = #{oldArg}
    </update>
 
</mapper>

mapper文件主要是保存了sql语句

在这里插入图片描述

6.创建主配置文件和数据库信息配置文件

主配置文件主要是数据库信息，和一些mapper文件的位置信息。
项目 src/main 下创建 resources 目录，设置 resources 目录为 resources root

创建数据库信息配置文件：

在resources目录下创建jdbc.properties文件， key：一般使用 . 做多级目录的。
内容如下：

 jdbc.driver = com.mysql.cj.jdbc.Driver
jdbc.url =  jdbc:mysql://localhost:3306/study
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文件的位置，从类路径根开始找文件-->
    <properties resource="jdbc.properties"/>
 
    <!--打印日志的设置-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING" />
    </settings>
    <!--配置 mybatis 环境-->
 
    <environments default="mysql">
        <!--id:数据源的名称-->
        <environment id="mysql">
            <!--配置事务类型：使用 JDBC 事务（使用 Connection 的提交和回滚）-->
            <transactionManager type="JDBC"/>
            <!--数据源 dataSource：创建数据库 Connection 对象
            type: POOLED 使用数据库的连接池
            -->
            <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>
        <!--告诉 mybatis 要执行的 sql 语句的位置-->
        <!--有几个mapper文件就写几个mapper标签-->
        <mapper resource="com/changsha/dao/StudentDao.xml"/>
    </mappers>
</configuration>

其中打印日志的设置为

     <settings>
        <setting name="logImpl" value="STDOUT_LOGGING" />
    </settings>

7. 创建获取SqlSession对象的工具类

这个类主要是为了快速获取SqlSession的对象，减少代码冗余。

 public class StudentUtil {
    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 sqlSession = null;
        if (factory != null){
            sqlSession = factory.openSession();
        }
        return sqlSession;
    }
}

8. 通过mybatis的动态代理获取dao对象

 package com.changsha;
 
import com.changsha.dao.StudentDao;
import com.changsha.domain.Student;
import com.changsha.util.StudentUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
public class test {
    @Test
    public void myTest(){
        //1. 通过工具类获取SqlSession对象
        SqlSession session = StudentUtil.getSqlSession();
        //2.通过mybatis框架的动态代理获取mybatis实现的对象
        StudentDao studentDao = session.getMapper(StudentDao.class);
        //3. 功能
 
        //1).增加(对象传递参数)
        Student student = new Student();
        student.setId(100);
        student.setName("王五");
        student.setEmail("wangwu@");
        student.setAge(111);
        studentDao.insertStudent(student);//调用动态代理生成的对象
        session.commit();//提交事务
 
 
        // 2）查找
        List<Student> studentList;
        studentList = studentDao.selectStudent();
        studentList.forEach( stu -> System.out.println(stu));
 
//        //3)删除(注解Param传递参数)
        studentDao.deleteStudent(100,"王五");
        session.commit();
 
        //4) 更新(Map传递多参数)
        Map<String,Object> map = new HashMap<>();
        map.put("oldArg",10);
        map.put("newArg",13);
        studentDao.updateStudent(map);
        session.commit();
 
        // 2）查找
        studentList = studentDao.selectStudent();
        studentList.forEach( stu -> System.out.println(stu));
 
 
        //4.关闭 SqlSession，释放资源
        session.close();
 
    }
}

MyBatis 使用传统 Dao 开发方式

以上方法是调用getMapper方法获取MyBatis框架中动态代理生成的对象。传统的方法

执行sql语句需要定位到mapper文件中对应语句的id。
namespace.id的方式需要到sql语句

（1）创建 Dao 接口实现类

 public class StudentDaoImpl implements StudentDao

（2）实现接口中 select 方法

 public List<Student> selectStudent() {
	 SqlSession session = MyBatisUtil.getSqlSession();
	 List<Student> studentList = session.selectList(
	"com.changsha.dao.StudentDao.selectStudent");
	 session.close();
	 return studentList;
}

测试查询操作
MyBatisTest 类中创建 StudentDaoImpl 对象

 public class MyBatisTest {
 	StudentDao studentDao = new StudentDaoImpl();
	@Test
	public void testSelect() throws IOException {
	 final List<Student> studentList = studentDao.selectStudents();
	 studentList.forEach( stu -> System.out.println(stu));
	}
}

（3）实现接口中 insert 方法

 public int insertStudent(Student student) {
	 SqlSession session = MyBatisUtil.getSqlSession();
	 int nums = session.insert(
	 "com.changsha.dao.StudentDao.insertStudent",student);
	 session.commit();
	 session.close();
	 return nums;
}

测试 insert

 @Test
public void testInsert() throws IOException {
	 Student student = new Student();
	 student.setId(1006);
	 student.setName("林浩");
	 student.setEmail("linhao@163.com");
	 student.setAge(26);
	 int nums = studentDao.insertStudent(student);
	 System.out.println("使用 Dao 添加数据:"+nums);
}

（4）实现接口中 update 方法

 public int updateStudent(Student student) {
	 SqlSession session = MyBatisUtil.getSqlSession();
	 int nums = session.insert(
	 "com.changsha.dao.StudentDao.updateStudent",student);
	 session.commit();
	 session.close();
	 return nums;
}

测试 update

 @Test
public void testUpdate() throws IOException {
	 Student student = new Student();
	 student.setId(1006);
	 student.setAge(28);
	 int nums = studentDao.updateStudent(student);
	 System.out.println("使用 Dao 修改数据:"+nums);
}

（5）实现接口中 delete 方法

 public int deleteStudent(int id) {
	 SqlSession session = MyBatisUtil.getSqlSession();
	 int nums = session.insert(
	 "com.bjpowernode.dao.StudentDao.deleteStudent",1006);
	 session.commit();
	 session.close();
	 return nums;
}

测试 delete

 @Test
public void testDelete() throws IOException {
	 int nums = studentDao.deleteStudent(1006);
	 System.out.println("使用 Dao 修改数据:"+nums);
}

使用方法

直接使用接口的实现类就行

传统 Dao 开发方式的分析

在前面例子中自定义 Dao 接口实现类时发现一个问题：Dao 的实现类其实并没有干什么实质性的工作，它仅仅就是通过 SqlSession 的相关 API 定位到映射文件 mapper 中相应 id 的 SQL 语句，真正对 DB 进行操作的工作其实是由框架通过 mapper 中的 SQL 完成的。所以，MyBatis 框架就抛开了 Dao 的实现类，直接定位到映射文件 mapper 中的相应 SQL 语句，对DB 进行操作。这种对 Dao 的实现方式称为 Mapper 的动态代理方式。Mapper 动态代理方式无需程序员实现 Dao 接口。接口是由 MyBatis 结合映射文件自动生成的动态代
理实现的。

动态sql

相当于使用判断，循环等方式拼接出需要的SQL语句

动态 SQL，通过 MyBatis 提供的各种标签对条件作出判断以实现动态拼接 SQL 语句。这里的条件判
断使用的表达式为 OGNL 表达式。常用的动态 SQL 标签有<if>、<where>、<choose/>、<foreach>等。
MyBatis 的动态 SQL 语句，与 JSTL 中的语句非常相似。
动态 SQL，主要用于解决查询条件不确定的情况：在程序运行期间，根据用户提交的查询条件进行
查询。提交的查询条件不同，执行的 SQL 语句不同。若将每种可能的情况均逐一列出，对所有条件进行
排列组合，将会出现大量的 SQL 语句。此时，可使用动态 SQL 来解决这样的问题

动态 SQL 之 < if >

对于该标签的执行，当 test 的值为 true 时，会将其包含的 SQL 片断拼接到其所在的 SQL 语句中。
语法：<if test=”条件”> sql 语句的部分 </if>

接口方法

     public List<Student> selectIf(@Param("name") String myName,@Param("age") Integer myAge);

这里参数的使用和前面是一样的
mapper文件

 <mapper namespace="com.changsha.dao.StudentDao">
    <select id="selectIf" resultType="com.changsha.domain.Student">
        select * from student where 1 = 1
        <if test="name != null and name != ''">
            and name = #{name}
        </if>
        <if test="age > 100">
            and age > 100;
        </if>
    </select>
</mapper>

测试

     @Test
    public void myTest(){
        //1. 通过工具类获取SqlSession对象
        SqlSession session = StudentUtil.getSqlSession();
        //2.通过mybatis框架的动态代理获取mybatis实现的对象
        StudentDao studentDao = session.getMapper(StudentDao.class);
        //3. 功能
        List<Student> students = new ArrayList<>();
        students = studentDao.selectIf("章",111);
        students.forEach(stu -> System.out.println(stu));
        //4.关闭 SqlSession，释放资源
        session.close();
    }

动态 SQL 之< where >

<if/>标签的中存在一个比较麻烦的地方：需要在 where 后手工添加 1=1 的子句。因为，若 where 后的所有<if/>条件均为 false，而 where 后若又没有 1=1 子句，则 SQL 中就会只剩下一个空的 where，SQL出错。所以，在 where 后，需要添加永为真子句 1=1，以防止这种情况的发生。但当数据量很大时，会严重影响查询效率。
使用<where/>标签，在有查询条件时，可以自动添加上 where 子句；没有查询条件时，不会添加where 子句。需要注意的是，第一个<if/>标签中的 SQL 片断，可以不包含 and。不过，写上 and 也不错，系统会将多出的 and 去掉。但其它中 SQL 片断的 and，必须要求写上。否则 SQL 语句将拼接出错。
语法：<where> 其他动态 sql </where>

接口方法

     public List<Student> selectIf(@Param("name") String myName,@Param("age") Integer myAge);

mapper文件

 <mapper namespace="com.changsha.dao.StudentDao">
    <select id="selectIf" resultType="com.changsha.domain.Student">
        select * from student
        <where>
            <if test="name != null and name != ''">
                and name = #{name}
            </if>
            <if test="age > 100">
                and age > 100;
            </if>
        </where>
    </select>
</mapper>

测试

     @Test
    public void myTest(){
        //1. 通过工具类获取SqlSession对象
        SqlSession session = StudentUtil.getSqlSession();
        //2.通过mybatis框架的动态代理获取mybatis实现的对象
        StudentDao studentDao = session.getMapper(StudentDao.class);
        //3. 功能
        List<Student> students = new ArrayList<>();
        students = studentDao.selectIf("章",1);
        students.forEach(stu -> System.out.println(stu));
        //4.关闭 SqlSession，释放资源
        session.close();
    }

动态 SQL 之 < foreach >

标签用于实现对于数组与集合的遍历。对其使用，需要注意：

➢ collection 表示要遍历的集合类型, list ，array 等。
➢ open、close、separator 为对遍历内容的 SQL 拼接。

语法：

 <foreach collection="集合类型" open="开始需要拼接的字符" close="结束需要拼接的字符" 
item="集合中的成员临时名称" separator="集合成员之间的分隔符">
 #{item 的值}
</foreach>

（1）遍历 List<简单类型>

表达式中的 List 使用 list 表示，其大小使用 list.size 表示。
需求：查询学生 id 是 1002,1005,1006
接口方法：

 List<Student> selectStudentForList(List<Integer> idList)

mapper文件

 <select id="selectStudentForList" resultType="com.bjpowernode.domain.Student">
 select id,name,email,age from student
 	<if test="list !=null and list.size > 0 ">
 		where id in
 		<foreach collection="list" open="(" close=")" item="stuid" separator=",">
			 #{stuid}
		</foreach>
 	</if>
</select>

测试方法：

 @Test
public void testSelectForList() {
	 List<Integer> list = new ArrayList<>();
	 list.add(1002);
	 list.add(1005);
	 list.add(1006);
	 List<Student> studentList = studentDao.selectStudentForList(list);
	 studentList.forEach( stu -> System.out.println(stu));
}

（2）遍历 List<对象类型>

接口方法：

 List<Student> selectStudentForList2(List<Student> stuList);

mapper 文件：

 <select id="selectStudentForList2" resultType="com.bjpowernode.domain.Student">
	select id,name,email,age from student
 	<if test="list !=null and list.size > 0 ">
 		where id in
 		<foreach collection="list" open="(" close=")" item="stuobject" separator=",">
 			#{stuobject.id}
		</foreach>
 	</if>
</select>

测试方法：

 @Test
public void testSelectForList2() {
	 List<Student> list = new ArrayList<>();
	 Student s1 = new Student();
	 s1.setId(1002);
	 list.add(s1);
	 s1 = new Student();
	 s1.setId(1005);
	 list.add(s1);
	 List<Student> studentList = studentDao.selectStudentForList2(list);
	 studentList.forEach( stu -> System.out.println(stu));
}

动态 SQL 之代码片段

<sql/>标签用于定义 SQL 片断，以便其它 SQL 标签复用。而其它标签使用该 SQL 片断，需要使用
<include/>子标签。该<sql/>标签可以定义 SQL 语句中的任何部分，所以<include/>子标签可以放在动态 SQL
的任何位置。

接口方法：

 List<Student> selectStudentSqlFragment(List<Student> stuList);

mapper 文件：

 <!--创建 sql 片段 id:片段的自定义名称-->
<sql id="studentSql">
 	select id,name,email,age from student
</sql>
<select id="selectStudentSqlFragment" resultType="com.bjpowernode.domain.Student">
 	<!-- 引用 sql 片段 -->
 	<include refid="studentSql"/>
 	<if test="list !=null and list.size > 0 ">
 		where id in
 		<foreach collection="list" open="(" close=")" item="stuobject" separator=",">
 			#{stuobject.id}
 		</foreach>
 	</if>
</select>

测试方法：

 @Test
public void testSelectSqlFragment() {
 List<Student> list = new ArrayList<>();
 Student s1 = new Student();
 s1.setId(1002);
 list.add(s1);
 s1 = new Student();
 s1.setId(1005);
 list.add(s1);
 List<Student> studentList = studentDao.selectStudentSqlFragment(list);
 studentList.forEach( stu -> System.out.println(stu));
}

动态sql总结

在这里插入图片描述

主配置文件说明

 <?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文件的位置，从类路径根开始找文件-->
    <properties resource="jdbc.properties" />
 
    <!--settings：控制mybatis全局行为-->
    <settings>
        <!--设置mybatis输出日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
 
    <!--配置插件-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor" />
    </plugins>
 
    <environments default="mydev">
        <environment id="mydev">
            <!--
              transactionManager:mybatis提交事务，回顾事务的方式
                 type: 事务的处理的类型
                     1）JDBC : 表示mybatis底层是调用JDBC中的Connection对象的，commit， rollback
                     2）MANAGED : 把mybatis的事务处理委托给其它的容器（一个服务器软件，一个框架（spring））
            -->
            <transactionManager type="JDBC"/>
            <!--
               dataSource:表示数据源，java体系中，规定实现了javax.sql.DataSource接口的都是数据源。
                          数据源表示Connection对象的。
 
               type:指定数据源的类型
                  1）POOLED: 使用连接池， mybatis会创建PooledDataSource类
                  2）UPOOLED: 不使用连接池， 在每次执行sql语句，先创建连接，执行sql，在关闭连接
                              mybatis会创建一个UnPooledDataSource，管理Connection对象的使用
                  3）JNDI：java命名和目录服务（windows注册表）
            -->
            <dataSource type="POOLED">
                <!--数据库的驱动类名-->
                <property name="driver" value="${jdbc.driver}"/>
                <!--连接数据库的url字符串-->
                <property name="url" value="${jdbc.url}"/>
                <!--访问数据库的用户名-->
                <property name="username" value="${jdbc.user}"/>
                <!--密码-->
                <property name="password" value="${jdbc.passwd}"/>
            </dataSource>
        </environment>
    </environments>
 
    <!-- sql mapper(sql映射文件)的位置-->
    <mappers>
        <!--第一种方式：指定多个mapper文件-->
        <!--<mapper resource="com/bjpowernode/dao/StudentDao.xml"/>
        <mapper resource="com/bjpowernode/dao/OrderDao.xml" />-->
 
        <!--第二种方式： 使用包名
            name: xml文件（mapper文件）所在的包名, 这个包中所有xml文件一次都能加载给mybatis
            使用package的要求：
             1. mapper文件名称需要和接口名称一样， 区分大小写的一样
             2. mapper文件和dao接口需要在同一目录
        -->
        <package name="com.bjpowernode.dao"/>
       <!-- <package name="com.bjpowernode.dao2"/>
        <package name="com.bjpowernode.dao3"/>-->
    </mappers>
</configuration>

包含mapper文件的两种方式

第一种方式：指定多个mapper文件

     <mappers>
        <mapper resource="com/changsha/dao/StudentDao.xml"/>
        <mapper resource="com/changsha/dao/OrderDao.xml" />
	</mappers>

第二种方式：使用包名
name参数为xml文件（mapper文件）所在的包名, 这个包中所有xml文件一次都能加载给mybatis
使用package的要求：
1. mapper文件名称需要和接口名称一样，区分大小写的一样
2. mapper文件和dao接口需要在同一目录

     <mappers>
        <package name="com.changsha.dao"/>
    </mappers>

自动提交事务

自动提交事务
设置自动提交的方式，factory 的 openSession() 分为有参数和无参数的。
在这里插入图片描述
有参数为 true，使用自动提交，可以修改 MyBatisUtil 的 getSqlSession()方法。
session = factory.openSession(true);
再执行 insert 操作，无需执行 session.commit(),事务是自动提交的

pageHelper数据分页

Mybatis 通用分页插件

实现步骤：

（1） maven 坐标

 <dependency>
	 <groupId>com.github.pagehelper</groupId>
	 <artifactId>pagehelper</artifactId>
	 <version>5.1.10</version>
</dependency>

（2）加入 plugin 配置

在主配置文件<environments>标签之前加入

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

（3） PageHelper 对象

查询语句之前调用 PageHelper.startPage 静态方法。
除了 PageHelper.startPage 方法外，还提供了类似用法的 PageHelper.offsetPage 方法。
在你需要进行分页的 MyBatis 查询方法前调用 PageHelper.startPage 静态方法即可，紧跟在这个
方法后的第一个 MyBatis 查询方法会被进行分页。

     @Test
    public void myTest(){
        //1. 通过工具类获取SqlSession对象
        SqlSession session = StudentUtil.getSqlSession();
        //2.通过mybatis框架的动态代理获取mybatis实现的对象
        StudentDao studentDao = session.getMapper(StudentDao.class);
        //3. 功能
        //pageNum参数表示第几页,PageSize表示每页有几条数据
        PageHelper.startPage(1,2);
        List<Student> students = new ArrayList<>();
        students = studentDao.selectPage();
        students.forEach(stu -> System.out.println(stu));
        //4.关闭 SqlSession，释放资源
        session.close();
    }

startPage函数中，第一个参数pageNum参数表示第几页,第二个PageSize表示每页有几条数据

其他零碎知识

在mapper文件中能用#{}的地方都能用${}

     5) # 和  $
 
      select id,name, email,age from student where id=#{studentId}
	  # 的结果： select id,name, email,age from student where id=? 
 
 
	   select id,name, email,age from student where id=${studentId}
	  $ 的结果：select id,name, email,age from student where id=1001
 
	  String sql="select id,name, email,age from student where id=" + "1001";
	  使用的Statement对象执行sql， 效率比PreparedStatement低。
 
 
	  $:可以替换表名或者列名， 你能确定数据是安全的。可以使用$
 
 
	  # 和 $区别
	  1. #使用 ？在sql语句中做站位的， 使用PreparedStatement执行sql，效率高
	  2. #能够避免sql注入，更安全。
	  3. $不使用占位符，是字符串连接方式，使用Statement对象执行sql，效率低
	  4. $有sql注入的风险，缺乏安全性。
	  5. $:可以替换表名或者列名

在这里插入图片描述

posted @ 2022-04-26 21:10 墨镜一戴谁也不爱阅读(126) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Spring框架中集成myBatis框架

· 创建SpringBoot工程，使用mybatis-plus框架

· MyBatis

· MyBatis基础

· Mybatis进阶

阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 单元测试从入门到精通
· winform 绘制太阳，地球，月球运作规律
· 上周热点回顾（3.3-3.9）

公告

Live2D

欢迎阅读『mybatis框架(操作数据库)』

昵称：墨镜一戴谁也不爱
园龄： 2年10个月
粉丝： 0
关注： 1

+加关注

2025年3月

日

一

二

三

四

五

六

	CREATE TABLE `student` (
	`id` int(11) NOT NULL ,
	`name` varchar(255) DEFAULT NULL,
	`email` varchar(255) DEFAULT NULL,
	`age` int(11) DEFAULT NULL,
	PRIMARY KEY (`id`)
	) ENGINE=InnoDB DEFAULT CHARSET=utf8;

	<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.11</version>
	<scope>test</scope>
	</dependency>
	<!--mybatis依赖-->
	<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis</artifactId>
	<version>3.5.1</version>
	</dependency>
	<!--mysql驱动-->
	<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>8.0.28</version>
	</dependency>

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

	<?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.changsha</groupId>
	<artifactId>Mybatis</artifactId>
	<version>1.0-SNAPSHOT</version>

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

	<dependencies>
	<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.11</version>
	<scope>test</scope>
	</dependency>
	<!--mybatis依赖-->
	<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis</artifactId>
	<version>3.5.1</version>
	</dependency>
	<!--mysql驱动-->
	<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>8.0.24</version>
	</dependency>

	</dependencies>

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


	</project>

	package com.changsha.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 +
	'}';
	}
	}

	package com.changsha.dao;

	import com.changsha.domain.Student;
	import org.apache.ibatis.annotations.Param;

	import java.util.List;
	import java.util.Map;

	public interface StudentDao {
	public List<Student> selectStudent();
	/*
	* 1.如果参数是对象：
	* 对象属性名字必须和列的名字对应，不然需要进行重命名
	* */
	public Integer insertStudent(Student student);
	/*
	* 2.多参数的情况下：
	* (1).用@Param注解来指定参数的名字，以便在mapper文件中可以访问到参数
	* */
	public Integer deleteStudent(@Param("argID") Integer id,@Param("argName") String name);

	/*
	* 多参数情况下：
	* (2). 用Map传递参数,key是参数名字，value是参数对应的值
	* */
	public Integer updateStudent(Map<String,Object> args);
	}

	<?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：必须有值，自定义的唯一字符串
	推荐使用：dao 接口的全限定名称
	-->
	<mapper namespace="com.changsha.dao.StudentDao">
	<!--
	<select>: 查询数据，标签中必须是 select 语句
	id: sql 语句的自定义名称，推荐使用 dao 接口中方法名称，
	使用名称表示要执行的 sql 语句
	resultType: 查询语句的返回结果数据类型，使用全限定类名
	-->
	<select id="selectStudent" resultType="com.changsha.domain.Student">
	<!--要执行的 sql 语句-->
	select * from student
	</select>

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

	<delete id="deleteStudent">
	delete from student where id = #{argID} and name = #{argName}
	</delete>

	<update id="updateStudent">
	update student set id = #{newArg} where id = #{oldArg}
	</update>

	</mapper>

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

	<?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文件的位置，从类路径根开始找文件-->
	<properties resource="jdbc.properties"/>

	<!--打印日志的设置-->
	<settings>
	<setting name="logImpl" value="STDOUT_LOGGING" />
	</settings>
	<!--配置 mybatis 环境-->

	<environments default="mysql">
	<!--id:数据源的名称-->
	<environment id="mysql">
	<!--配置事务类型：使用 JDBC 事务（使用 Connection 的提交和回滚）-->
	<transactionManager type="JDBC"/>
	<!--数据源 dataSource：创建数据库 Connection 对象
	type: POOLED 使用数据库的连接池
	-->
	<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>
	<!--告诉 mybatis 要执行的 sql 语句的位置-->
	<!--有几个mapper文件就写几个mapper标签-->
	<mapper resource="com/changsha/dao/StudentDao.xml"/>
	</mappers>
	</configuration>

	public class StudentUtil {
	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 sqlSession = null;
	if (factory != null){
	sqlSession = factory.openSession();
	}
	return sqlSession;
	}
	}

	package com.changsha;

	import com.changsha.dao.StudentDao;
	import com.changsha.domain.Student;
	import com.changsha.util.StudentUtil;
	import org.apache.ibatis.session.SqlSession;
	import org.junit.Test;

	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	public class test {
	@Test
	public void myTest(){
	//1. 通过工具类获取SqlSession对象
	SqlSession session = StudentUtil.getSqlSession();
	//2.通过mybatis框架的动态代理获取mybatis实现的对象
	StudentDao studentDao = session.getMapper(StudentDao.class);
	//3. 功能

	//1).增加(对象传递参数)
	Student student = new Student();
	student.setId(100);
	student.setName("王五");
	student.setEmail("wangwu@");
	student.setAge(111);
	studentDao.insertStudent(student);//调用动态代理生成的对象
	session.commit();//提交事务


	// 2）查找
	List<Student> studentList;
	studentList = studentDao.selectStudent();
	studentList.forEach( stu -> System.out.println(stu));

	// //3)删除(注解Param传递参数)
	studentDao.deleteStudent(100,"王五");
	session.commit();

	//4) 更新(Map传递多参数)
	Map<String,Object> map = new HashMap<>();
	map.put("oldArg",10);
	map.put("newArg",13);
	studentDao.updateStudent(map);
	session.commit();

	// 2）查找
	studentList = studentDao.selectStudent();
	studentList.forEach( stu -> System.out.println(stu));


	//4.关闭 SqlSession，释放资源
	session.close();

	}
	}

	public List<Student> selectStudent() {
	SqlSession session = MyBatisUtil.getSqlSession();
	List<Student> studentList = session.selectList(
	"com.changsha.dao.StudentDao.selectStudent");
	session.close();
	return studentList;
	}

	public class MyBatisTest {
	StudentDao studentDao = new StudentDaoImpl();
	@Test
	public void testSelect() throws IOException {
	final List<Student> studentList = studentDao.selectStudents();
	studentList.forEach( stu -> System.out.println(stu));
	}
	}

	public int insertStudent(Student student) {
	SqlSession session = MyBatisUtil.getSqlSession();
	int nums = session.insert(
	"com.changsha.dao.StudentDao.insertStudent",student);
	session.commit();
	session.close();
	return nums;
	}

	@Test
	public void testInsert() throws IOException {
	Student student = new Student();
	student.setId(1006);
	student.setName("林浩");
	student.setEmail("linhao@163.com");
	student.setAge(26);
	int nums = studentDao.insertStudent(student);
	System.out.println("使用 Dao 添加数据:"+nums);
	}

	public int updateStudent(Student student) {
	SqlSession session = MyBatisUtil.getSqlSession();
	int nums = session.insert(
	"com.changsha.dao.StudentDao.updateStudent",student);
	session.commit();
	session.close();
	return nums;
	}

	@Test
	public void testUpdate() throws IOException {
	Student student = new Student();
	student.setId(1006);
	student.setAge(28);
	int nums = studentDao.updateStudent(student);
	System.out.println("使用 Dao 修改数据:"+nums);
	}

	public int deleteStudent(int id) {
	SqlSession session = MyBatisUtil.getSqlSession();
	int nums = session.insert(
	"com.bjpowernode.dao.StudentDao.deleteStudent",1006);
	session.commit();
	session.close();
	return nums;
	}

	@Test
	public void testDelete() throws IOException {
	int nums = studentDao.deleteStudent(1006);
	System.out.println("使用 Dao 修改数据:"+nums);
	}

	public List<Student> selectIf(@Param("name") String myName,@Param("age") Integer myAge);

hnuzmh

mybatis框架(操作数据库)

文章目录

Mybatis框架的使用步骤

前期准备

1. 创建Maven工程

2. 加入相关的依赖

3. 创建实体类，保存表中一行的数据

4. 创建持久层的dao接口

5. 创建mapper配置文件

6.创建主配置文件和数据库信息配置文件

创建数据库信息配置文件：

创建主配置文件：

7. 创建获取SqlSession对象的工具类

8. 通过mybatis的动态代理获取dao对象

MyBatis 使用传统 Dao 开发方式

（1） 创建 Dao 接口实现类

（2）实现接口中 select 方法

（3）实现接口中 insert 方法

（4）实现接口中 update 方法

（5）实现接口中 delete 方法

使用方法

传统 Dao 开发方式的分析

动态sql

动态 SQL 之 < if >

动态 SQL 之< where >

动态 SQL 之 < foreach >

（1） 遍历 List<简单类型>

（2） 遍历 List<对象类型>

动态 SQL 之代码片段

动态sql总结

主配置文件说明

包含mapper文件的两种方式

自动提交事务

pageHelper数据分页

实现步骤：

（1） maven 坐标

（2） 加入 plugin 配置

（3） PageHelper 对象

其他零碎知识

公告

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

（1）创建 Dao 接口实现类

（1）遍历 List<简单类型>

（2）遍历 List<对象类型>

（2）加入 plugin 配置

	<mapper namespace="com.changsha.dao.StudentDao">
	<select id="selectIf" resultType="com.changsha.domain.Student">
	select * from student where 1 = 1
	<if test="name != null and name != ''">
	and name = #{name}
	</if>
	<if test="age > 100">
	and age > 100;
	</if>
	</select>
	</mapper>

	<foreach collection="集合类型" open="开始需要拼接的字符" close="结束需要拼接的字符"
	item="集合中的成员临时名称" separator="集合成员之间的分隔符">
	#{item 的值}
	</foreach>

	<select id="selectStudentForList" resultType="com.bjpowernode.domain.Student">
	select id,name,email,age from student
	<if test="list !=null and list.size > 0 ">
	where id in
	<foreach collection="list" open="(" close=")" item="stuid" separator=",">
	#{stuid}
	</foreach>
	</if>
	</select>

	@Test
	public void testSelectForList() {
	List<Integer> list = new ArrayList<>();
	list.add(1002);
	list.add(1005);
	list.add(1006);
	List<Student> studentList = studentDao.selectStudentForList(list);
	studentList.forEach( stu -> System.out.println(stu));
	}

	<select id="selectStudentForList2" resultType="com.bjpowernode.domain.Student">
	select id,name,email,age from student
	<if test="list !=null and list.size > 0 ">
	where id in
	<foreach collection="list" open="(" close=")" item="stuobject" separator=",">
	#{stuobject.id}
	</foreach>
	</if>
	</select>

	@Test
	public void testSelectForList2() {
	List<Student> list = new ArrayList<>();
	Student s1 = new Student();
	s1.setId(1002);
	list.add(s1);
	s1 = new Student();
	s1.setId(1005);
	list.add(s1);
	List<Student> studentList = studentDao.selectStudentForList2(list);
	studentList.forEach( stu -> System.out.println(stu));
	}

	<!--创建 sql 片段 id:片段的自定义名称-->
	<sql id="studentSql">
	select id,name,email,age from student
	</sql>
	<select id="selectStudentSqlFragment" resultType="com.bjpowernode.domain.Student">
	<!-- 引用 sql 片段 -->
	<include refid="studentSql"/>
	<if test="list !=null and list.size > 0 ">
	where id in
	<foreach collection="list" open="(" close=")" item="stuobject" separator=",">
	#{stuobject.id}
	</foreach>
	</if>
	</select>

	@Test
	public void testSelectSqlFragment() {
	List<Student> list = new ArrayList<>();
	Student s1 = new Student();
	s1.setId(1002);
	list.add(s1);
	s1 = new Student();
	s1.setId(1005);
	list.add(s1);
	List<Student> studentList = studentDao.selectStudentSqlFragment(list);
	studentList.forEach( stu -> System.out.println(stu));
	}

	<mappers>
	<mapper resource="com/changsha/dao/StudentDao.xml"/>
	<mapper resource="com/changsha/dao/OrderDao.xml" />
	</mappers>

	<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>5.1.10</version>
	</dependency>