栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

MyBatis详细入门教程教程!idea版本

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

MyBatis详细入门教程教程!idea版本

来源:动力节点MyBatis教程实战精讲视频及文档,再次表示感谢!!

https://www.bilibili.com/video/BV185411s7Ry?spm_id_from=333.999.0.0&vd_source=75a98c11a89e81de728ed7f28e735d32

本文PDF版下载链接,以及相关资料链接:
链接: https://pan.baidu.com/s/1e4SiPgKqrrv7ekOiX727pA 提取码: wl55

第一章 框架概述 1.1 软件开发常用的结构 1.1.1 三层架构

三层架构包含的三层: 界面层(User Interface layer)、业务逻辑层(Business Logic Layer)、数据访问层(Data access layer)

  1. 界面层(表示层,视图层):主要功能是接受用户的数据,显示请求的处理结果。使用 web 页面和 用户交互,手机 app 也就是表示层的,用户在 app 中操作,业务逻辑在服务器端处理。-----> jsp html

  2. 业务逻辑层:接收表示传递过来的数据,检查数据,计算业务逻辑,调用数据访问层获取数据。 -----> service

  3. 数据访问层:与数据库打交道。主要实现对数据的增、删、改、查。将存储在数据库中的数据提交 给业务层,同时将业务层处理的数据保存到数据库. -----> dao

三层对应的包:

  • controller包 (servlet)

  • service包 (xxxService)

  • dao包(xxxDao)

三层类的交互关系:

​ 用户—> 界面层—>业务逻辑层—>数据访问层—>DB 数据库

为什么要使用三层架构:

  1. 结构清晰、耦合度低, 各层分工明确

  2. 可维护性高,可扩展性高

  3. 有利于标准化

  4. 开发人员可以只关注整个结构中的其中某一层的功能实现

  5. 有利于各层逻辑的复用

三层对应的处理框架

界面层 — servlet — springmvc

业务逻辑层----service—spring

数据访问层— dao ---- mybatis

1.2 框架是什么 1.2.1 框架定义

​ 框架(Framework)是整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法 另一种认为,框架是可被应用开发者定制的应用骨架、模板。

​ 简单的说,框架其实是半成品软件,就是一组组件,供你使用完成你自己的系统。从另一个角度来 说框架一个舞台,你在舞台上做表演。在框架基础上加入你要完成的功能。

​ 框架是安全的,可复用的,不断升级的软件。

1.2.2 框架特点
  1. 不是全能的
  2. 框架是针对某一个邻域有效,特长在某一个方面
  3. 框架是别人写好的程序
1.2.3 框架解决要解决的问题

​ 框架要解决的最重要的一个问题是技术整合,在 J2EE 的 框架中,有着各种各样的技术,不同的应 用,系统使用不同的技术解决问题。需要从 J2EE 中选择不同的技术,而技术自身的复杂性,有导致更大的风险。企业在开发软件项目时,主要目的是解决业务问题。 即要求企业负责技术本身,又要求解决业务问题。这是大多数企业不能完成的。框架把相关的技术融合在一起,企业开发可以集中在业务领 域方面。

​ 另一个方面可以提高开发的效率。

1.3 为什么要用MyBatis

​ 首先先来回顾一下 JDBC 以及 JDBC 存在的问题

1.3.1 JDBC编程方式

​ 使用JDBC做一个查询

//STEP 1. 导入相关包
import java.sql.*;

public class SelectRecords {
  //JDBC驱动 和 地址
  static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
  static final String DB_URL = "jdbc:mysql://localhost/jdbc_db";

	//数据库用户名和密码
  static final String USER = "root";
  static final String PASS = "123456";

  public static void main(String[] args) {
    Connection conn = null;
    Statement stmt = null;
    try{
      //STEP 2: 注册JDBC驱动
      Class.forName("com.mysql.jdbc.Driver");

      //STEP 3: 打开一个连接
      System.out.println("Connecting to a selected database...");
      conn = DriverManager.getConnection(DB_URL, USER, PASS);
      System.out.println("Connected database successfully...");

      //STEP 4: 执行一个查询语句
      System.out.println("Creating statement...");
      stmt = conn.createStatement();

      String sql = "SELECT id, name, email, age FROM student";
      ResultSet rs = stmt.executeQuery(sql);
      //STEP 5: 遍历查询结果
      while(rs.next()){
        int id  = rs.getInt("id");
        int age = rs.getInt("age");
        String first = rs.getString("first");
        String last = rs.getString("last");
        System.out.print("ID: " + id);
        System.out.print(", Age: " + age);
        System.out.print(", First: " + first);
        System.out.println(", Last: " + last);
      }
      rs.close();
    }catch(SQLException se){
      //Handle errors for JDBC
      se.printStackTrace();
    }catch(Exception e){
      //Handle errors for Class.forName
      e.printStackTrace();
    }finally{
      //关闭资源
      try{
        if(stmt!=null)
          conn.close();
      }catch(SQLException se){
      }// do nothing
      try{
        if(conn!=null)
          conn.close();
      }catch(SQLException se){
        se.printStackTrace();
      }//end finally try
    }//end try
    System.out.println("Goodbye!");
  }//end main
}//end JDBCExample
1.3.2 JDBC的缺陷
  1. 代码冗余,开发效率低

  2. 需要关注 Connection ,Statement, ResultSet 对象创建和销毁

  3. 对 ResultSet 查询的结果,需要自己封装为 List

  4. 业务代码和数据库的操作混在一起

1.4 MyBatis框架概述

MyBatis 框架: MyBatis 本是 apache 的一个开源项目 iBatis, 2010 年这个项目由 apache software foundation 迁移到了 google code,并且改名为 MyBatis 。2013 年 11 月迁移到 Github。 iBATIS 一词来源于“internet”和“abatis”的组合,是一个基于 Java 的持久层框架。iBATIS 提供的 持久层框架包括 SQL Maps 和 Data Access Objects(DAOs)

1.4.1 MyBatis框架解决的问题

​ 针对JDBC的缺陷,MyBatis减轻使用 JDBC 的复杂性,不用编写重复的创建 Connetion , Statement ; 不用编写关闭资源代码, 直接使用 java 对象;直接表示结果数据,让开发者专注 SQL 的处理。

MyBatis 可以完成:

  1. 注册数据库的驱动,例如 Class.forName(“com.mysql.jdbc.Driver”))

  2. 创建 JDBC 中必须使用的 Connection , Statement, ResultSet 对象

  3. 从 xml 中获取 sql,并执行 sql 语句,把 ResultSet 结果转换 java 对象,省略以下语句

List list = new ArrayLsit<>();
ResultSet rs = state.executeQuery(“select * from student”); 
while(rs.next){
	Student student = new Student(); 
	student.setName(rs.getString(“name”)); 
  student.setAge(rs.getInt(“age”)); 
  list.add(student);
}
  1. 关闭资源

ResultSet.close() , Statement.close() , Conenection.close()

第二章MyBatis框架入门 2.1 入门案例

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

实现步骤:

  1. 新建一个student表
  2. 加入Maven的MyBatis坐标 mysql驱动的坐标
  3. 创建实体类 Student —>对应的表中一行数据
  4. 创建持久层的dao接口,定义操作数据库的方法
  5. 创建一个mybatis使用的配置文件

​ 叫做sql映射文件:写sql语句的 一般一个表一个sql映射文件 这个文件是xml文件

​ 1) 这个xml写在接口所在的目录中

​ 2) 文件名称和接口保持一致

  1. 创建mybatis的主配置文件

​ 一个项目就是一个主配置文件

​ 主配置文件提供了数据库的连接信息和SQL映射的文件位置信息

  1. 创建使用mybatis类,

​ 通过mybatis访问数据库

接下来进行演示:先看一下项目结构

(1)在数据库中新建一个student表 , springdb库中

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;

向数据库随便添加两行数据,如图:

(2)加入Maven的MyBatis坐标 mysql驱动的坐标


    
    
        org.mybatis
        mybatis
        3.5.9
    

    
    
        mysql
        mysql-connector-java
        8.0.29
    

    
    
        junit
        junit
        4.12
        test
    

(3)创建实体类 Student —>对应的表中一行数据

创建domain.Student

package com.st.domain;
import jdk.nashorn.internal.objects.annotations.Setter;

//推荐实体类名和表名一样, 方便记忆
@Data  //使用Lombok
public class Student {

    //属性和表数据一样
    private Integer id;
    private String name;
    private String email;
    private Integer age;

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

(4)创建持久层的dao接口,定义操作数据库的方法

创建dao.StudentDao接口,接口中有一个查询方法

package com.st.dao;
import com.st.domain.Student;
import java.util.List;

//接口操作 student表
public interface StudentDao {
    //查询student表的所有数据
    public List selectStudents();

}

(5)创建一个mybatis的配置文件

​ 该文件叫做sql映射文件:写sql语句的 ,一般一个表一个sql映射文件,在此处为StudentDao.xml

​ 1.这个xml写在接口所在的目录中

​ 2.文件名称和接口保持一致


  

    
  select id, name, email, age from student order by id;

测试代码:

@Test
public void selectStudents() throws IOException {
  String config = "mybatis.xml";
  InputStream in = Resources.getResourceAsStream(config);
  SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
  SqlSessionFactory factory = builder.build(in);
  SqlSession sqlSession = factory.openSession();

  String sqlId = "com.st.dao.StudentDao" + "." + "selectStudents";
  List studentList = sqlSession.selectList(sqlId);

  studentList.forEach(student -> System.out.println(student));
  sqlSession.close();
}

结果:

2.2.2 insert

在StudentDao中添加方法:

public int insertStudent(Student student);

在StudentDao.xml中添加:


  insert into student values (#{id}, #{name}, #{email}, #{age});

测试代码:

    @Test
    public void insertStudent() throws IOException {
        String config = "mybatis.xml";
        InputStream in = Resources.getResourceAsStream(config);
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession sqlSession = factory.openSession();
        //创建要插入的数据
        Student student = new Student();
        student.setId(2001);
        student.setName("孙悟空");
        student.setEmail("swk@xiyou.com");
        student.setAge(500);

        String sqlId = "com.st.dao.StudentDao" + "." + "insertStudent";
        int row = sqlSession.insert(sqlId, student);
        System.out.println("影响行数:" + row);

        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }
}

结果:

数据库中确实插入成功:

2.2.3 update

在StudentDao中添加方法:

public int updateStudent(Student student);

在StudentDao.xml中添加:


  update student set age = #{age} where id = #{id}

测试代码:

@Test
public void updateStudent() throws IOException {
  String config = "mybatis.xml";
  InputStream in = Resources.getResourceAsStream(config);
  SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
  SqlSessionFactory factory = builder.build(in);
  SqlSession sqlSession = factory.openSession();

  Student student = new Student();
  student.setId(2001);
  student.setAge(1000);//将年龄更新为1000岁

  String sqlId = "com.st.dao.StudentDao" + "." + "updateStudent";
  int row = sqlSession.update(sqlId, student);
  System.out.println("影响行数:" + row);

  //提交事务
  sqlSession.commit();
  sqlSession.close();
}

测试结果:

数据库中确实更新成功:

2.2.4 delete

在StudentDao中添加方法:

public int insertStudent(Student student);

在StudentDao.xml中添加:


  insert into student values (#{id}, #{name}, #{email}, #{age});

测试代码:

@Test
public void deleteStudent() throws IOException {
  String config = "mybatis.xml";
  InputStream in = Resources.getResourceAsStream(config);
  SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
  SqlSessionFactory factory = builder.build(in);
  SqlSession sqlSession = factory.openSession();

  String sqlId = "com.st.dao.StudentDao" + "." + "deleteStudent";
  int row = sqlSession.update(sqlId, 2001);
  System.out.println("影响行数:" + row);
}

测试结果:

数据库中确实删除成功:

2.3 日志

​ 一个语句是否执行成功,在idea中只能获取影响行数来判断,不能详细的看到每个sql语句执行的具体语句是什么,如果发生错误,不容易排查,为此,可使用日志功能来详细的查看每次运行执行的sql语句信息。

在主配置文件中对增加setting标签,位置在标签内部


  

未使用日志:

使用日志:会给出具体的sql语句,方便查找错误

2.4 主要类的介绍 2.4.1 Resources类

​ MyBatis中的一个类,主要负责读取主配置文件或资源文件等,其有很多方法通过加载并解析资源文件,可返回不同类型的 IO 流对象。

2.4.2 SqlSessionFactoryBuilder类

​ 通过创建SqlSessionFactoryBuilder,使用SqlSessionFactoryBuilder对象的build() 方法,来进一步创建SqlSessionFactory对象。

​ 由于SqlSessionFactoryBuilder 对象在创建完工厂对象后,就完成了其历史使命,即可被销毁。所以,一般会将 该 SqlSessionFactoryBuilder 对象创建为一个方法内的局部对象,方法结束,对象销毁。

2.4.3 SqlSessionFactory接口

​ 重量级对象,重量级对象是创建对象耗时比较长,使用资源比较多,在整个项目中,有一个就够用了。

​ SqlSessionFactory:本身是一个接口,接口的实现类 DefaultSqlSessionFactory

​ SqlSessionFactory作用:通过openSession方法,获取SqlSession对象

openSession方法说明:

  1. openSession():无参数的,默认是false,获取的是非自动提交事务的SqlSession对象
  2. openSession(true):根据参数,获取能否自动提交事务的SqlSession对象
2.4.4 SqlSession接口

​ 定义了操作数据的方法,例如selectOne() selectList() insert() update()

SqlSession接口的实现类:DefaultSqlSession

​ 使用要求:SqlSession对象不是线程安全的,需要在方法内部使用, 在执行sql语句后需要执行SqlSession.close()来关闭它,避免线程不安全

2.5 创建工具类

​ 可以从上文看出,在测试代码中很多代码是重复的,因此可以创建一个工具类,方便代码复用。

2.5.1 创建MyBatisUtil类

​ 简而言之,就是将一些公共代码单独做成一个类:

创建一个utils包,在包下创建MyBatisUtils

public class MyBatisUtils {
  
    private static SqlSessionFactory sessionFactory = null;
    static { //静态代码块,先执行。 创建出sessionFactory
        String config = "mybatis.xml";
        try {
            InputStream in = Resources.getResourceAsStream(config);
            sessionFactory = new SqlSessionFactoryBuilder().build(in);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    //获取SqlSession的方法
    public static SqlSession getSqlSession(){
        SqlSession sqlSession = null;
        if(sessionFactory != null){
            sqlSession = sessionFactory.openSession();
        }
        return sqlSession;
    }
}
2.5.1 使用MyBatisUtils类

​ 在测试代码中:

    @Test
    public void selectStudents() throws IOException {
//        String config = "mybatis.xml";
//        InputStream in = Resources.getResourceAsStream(config);
//        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//        SqlSessionFactory factory = builder.build(in);
        
        SqlSession sqlSession = MyBatisUtils.getSqlSession();  //使用一句即可

        String sqlId = "com.st.dao.StudentDao" + "." + "selectStudents";
        List studentList = sqlSession.selectList(sqlId);

        studentList.forEach(student -> System.out.println(student));
        sqlSession.close();
    }
第三章 MyBatis框架Dao代理

​ 分析前文的代码执行流程,对于一个StudentDao接口中的方法,在测试类中需要先组装好sqlId(1),再通过sqlSession中对应的方法(2)来调用StudentDao.xml中写好的sql语句。

@Test
public void selectStudents() throws IOException 
  SqlSession sqlSession = MyBatisUtils.getSqlSession();
  String sqlId = "com.st.dao.StudentDao" + "." + "selectStudents";  //(1)
  List studentList = sqlSession.selectList(sqlId);        //(2)
  studentList.forEach(student -> System.out.println(student));
  sqlSession.close();
}

​ 这个过程,使用者需要知道:①组装sqlid这个字符串 ②需要知道sqlSession中包含什么方法,将sqlid传入对应的方法中。 而我们期望的是,使用者通过StudentDao定义中的方法,并调用该方法就能实现对应的操作。

​ 为了实现这个目的,一般传统的Dao开发方式如下文。

3.1 MyBatis使用传统的Dao开发方式

​ 传统的开发方式步骤:

  1. 创建一个StudentDao接口
  2. 实现这个SudentDao类 --> StudentDaoImpl,通过SqlSession调用StudentDao.xml
  3. 编写StudentDao.xml方法

接下来,以selectStudents()方法为主:

(1)在StudentDao接口创建selectStudents()方法

public List selectStudents();

(2)在Dao中创建impl包,在impl包中实现Dao接口类 StudentDaoImpl

public class StudentDaoImpl implements StudentDao {
    @Override
    public List selectStudents() {
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
      	//将test中的代码放入到impl类中
        String sqlId = "com.st.dao.StudentDao.selectStudents";
        List students = sqlSession.selectList(sqlId);
        sqlSession.close();
        return students;
    }
}

(3)StudentDao.xml是相同的


    
        select id, name, email, age from student where id = #{id};
    

​ parameterType来告诉mybatis传入的 id是Integer类型

3.3.2 传入一个简单类型参数

一个简单类型参数:基本数据类型和String叫做简单类型,注意这种方法的限定 ① 一个 ②简单类型参数

接口代码:

public Student selectStudentById(Integer id)

在mapper文件中获取简单类型的一个参数的值,使用#{任意字符},所以在xml文件中id改为其他字符也可以:

select id, name, email, age from student where id = #{studentId}; 

​

​ 使用#{}之后,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, 1002);
  1. 执行sql 封装为resultType="com.st.domain.Student"这个对象
ResultSet rs = ps.executeQuery();
Student student = null
while(rs.next()){
  //从数据库取表的一行数据,存到java对象属性中
  Student student = new Student();
  student.setId(rs.getInt("id"));
  student.setName(rs.getInt("name"));
  student.setEmail(rs.getInt("email"));
  student.setAge(rs.getInt("age"));
}
return student; 

注意事项:

​ 使用#号是占位符,能够避免sql注入,在 3.3.7 中有提到

3.3.3 多个参数-使用@Param

​ 使用@Param命名参数,给参数起名字。

举例:

Dao接口:

public List selectMulitParam(String name, Integer age)

使用@Param(“参数名”) String name

public List selectMulitParam(@Param("myname")String name,@Param("myage")Integer age)

可以在mapper文件中:

select id, name, email, age from student where name = #{myname} or age= #{myage};
3.3.4 多个参数-使用对象

​ 使用java对象传递参数,属性值就是sql需要的参数值,一个属性就是一个参数。

使用对象语法:

​ #{属性名,javaType=类型名称,jdbcType=数据类型}

​ - javaType:指java中的属性数据类型

​ - jdbcType:在数据库中的数据类型


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 id, name, email, age from student where name=#{paramName} or age=#{paramAge};

使用对象进行参数传递有两种方式:1)新建类方式 2)实体类方式

第一种方法举例:

(1)新建一个QueryParam类,用于传递参数:

package com.st.vo;
@Data
public class QueryParam {
    private String paramName;
    private Integer paramAge;
}

(2)Dao接口:

//多个参数:使用java对象作为接口中方法的参数
public List selectMultiObject(QueryParam queryParam);

(3)xml文件:


  select id, name, email, age from student where name=#{name} or age=#{age};

(4)测试代码:

@Test
public void selectMultiStudent() {
  SqlSession sqlSession = MyBatisUtils.getSqlSession();
  StudentDao mapper = sqlSession.getMapper(StudentDao.class);
	//通过Student类实例完成参数传递
  Student zs = new Student();
  zs.setName("张三");
  zs.setAge(10);
  List studentList = mapper.selectMultiStudent(zs);
  studentList.forEach(System.out::println);
  sqlSession.close();
}
3.3.5 多个参数-按位置的

​ 参数位置从 0 开始, 引用参数语法#{ arg 位置 } ,第一个参数是#{arg0}, 第二个是#{arg1}

注意:mybatis-3.3 版本和之前的版本使用#{0},#{1}方式, 从 mybatis3.4 开始使用#{arg0}方式。

举例:

(1)Dao接口

//多个参数-按位置
public List selectByIndex(String name,Integer age);

(2)xml文件:


  
  select id, name, email, age from student where name=#{myname} or age=#{myage};

(3)测试代码:

@Test
public void selectByMap() {
  SqlSession sqlSession = MyBatisUtils.getSqlSession();
  StudentDao mapper = sqlSession.getMapper(StudentDao.class);
  //在这里构建map, key是xml中的#{}中的名字
  //因此使用者需要知道xml中的源码,因此不常用使用
  Map map = new HashMap();
  map.put("myname", "张飞");
  map.put("myage",15);
  
  List studentList = mapper.selectByMap(map);
  studentList.forEach(System.out::println);
  sqlSession.close();
}

​ 存在问题:

  1. 只能在测试类中,才能给map赋值的问题。

  2. 可读性差,从Dao中并不能获取需要传入什么信息。

3.3.7 #和$的区别
select id,name, email,age from student where id=#{studentId}

===> #号后的结果: select id,name, email,age from student where id=?

​ #使用的是PreparedStatement执行sql

select id,name, email,age from student where id=#{studentId}

===> $号后的结果: 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. $:可以替换表名或者列名
3.4 封装MyBatis输出结果 3.4.1 resultType

​ mybatis执行了sql语句,得到ResultSet转换的类型。

处理方式:

  1. mybatis执行sql语句, 然后mybatis调用类的无参数构造方法,创建对象。
  2. mybatis把ResultSet列中的值赋给类中同名的属性

resultType结果类型的值可以是:

  1. 类型的全限定名称
  2. 类型的别名, 例如 java.lang.Integer别名是int

注意:

  • 如果返回的是集合,那应该设置为集合包含的类型,而不是集合本身。
  • resultType可以返回不是一个实体类的对象, 但返回值需要和xml中resultType一样

①新建一个ViewStudent类:

@Data
@ToString
public class ViewStudent {
    private String name;
    private Integer age;
}

②向Dao中添加方法:

//resultType返回给不是一个实体类的对象, 返回值需要和xml中resultType一样
ViewStudent selectStudetnReturnViewStudent(@Param("sid") Integer id);

③xml文件


  select count(*) from student;

使用自带别名:



  select count(*) from student;

3)使用自定义别名第二种方式:

​ name是包名,这个包中的所有类,类名就是别名(别名不区分大小写)

举例:

(1)主配置文件加入:


  
  

(2)在dao的xml文件中修改


  select id, name, email, age from student

(3)测试代码:

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

  List studentList = mapper.selectAllStudent();
  studentList.forEach(System.out::println);
  sqlSession.close();
}

(4)运行结果:name 和 email完成互换

举例 场景2:当列名和属性名不一样时,一定要使用resultMap

(1)在domain中新建一个MyStudent类,属性和Student相同,但是属性名不同。制造出列名和属性名不一样的场景

@Data
public class MyStudent {
    private Integer stuid;
    private String stuname;
    private String stuemail;
    private Integer stuage;
  
    @Override
    public String toString() {
        return "MyStudent{" +
                "stuid=" + stuid +
                ", stuname='" + stuname + ''' +
                ", stuemail='" + stuemail + ''' +
                ", stuage=" + stuage +
                '}';
    }
}

(2)xml方法: 通过标签定义方法对应赋值


  
    
    
    
    



  select id, name, email, age from student where name like #{name}

(3)测试代码:

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

  String name = "%张%";
  //将要查询的内容通过参数传递
  List studentList = mapper.selectLinkeOne(name);  
  studentList.forEach(System.out::println);
  sqlSession.close();
}

(4)运行结果:name中含有 张 的行记录被找到

3.5.2 模糊查询第二种方法

在mapper 文件中拼接 like的内容

(1)Dao接口:

List selectLinkeTwo(String name);

(2)xml代码:


  
  where 1 = 1      							
  
    and name = #{name}
  
  
    or age > #{age}
  

(3)测试代码:

@Test
public void selectStudentIf() {
  SqlSession sqlSession = MyBatisUtils.getSqlSession();
  StudentDao mapper = sqlSession.getMapper(StudentDao.class);
  Student student1 = new Student();
  student1.setName("张飞");
  student1.setAge(15);
  List students = mapper.selectStudentIf(student1);
  students.forEach(student -> System.out.println(student));
  sqlSession.close();

}

(4)运行结果,满足条件的被查找到

4.2 where标签

用来包含 多个的, 当多个if有一个成立的, 会自动增加一个where关键字,
并去掉 if中多余的 and ,or等。

​ 语法 …

举例:

(1)Dao接口:

//where的使用
List selectStudentWhere(Student student);

(2)xml文件:



  select id, name, email, age from student where id in 
  
    #{myid}
  

(3)测试代码:

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

  List list = new ArrayList<>();
  list.add(1001);
  list.add(1002);
  list.add(1003);

  List students = mapper.selectForeach(list);
  students.forEach(student -> System.out.println(student));
  sqlSession.close();
}

(4)运行结果:

举例2:传入的是类,Student类,用类中的id

(1)Dao接口:

//foreach的使用2
public List selectForeach2(List stuList);

(2)xml代码:



  
  
  where 1 =1
  
    and name = #{name}

  
    or age > #{age}

  
第五章 MyBatis 配置文件 5.1 数据库的属性配置文件

数据库的属性配置文件: 把数据库连接信息放到一个单独的文件中。 和mybatis主配置文件分开。
目的是便于修改,保存,处理多个数据库的信息。

1)在resources目录中定义一个属性配置文件, xxxx.properties ,例如 jdbc.properties
在属性配置文件中, 定义数据,格式是 key=value
key: 一般使用 “.” 做多级目录的。
例如: jdbc.mysql.driver , jdbc.driver, mydriver

​ jdbc.driver=com.mysql.jdbc.Driver
​ jdbc.url=jdbc:mysql//…
​ jdbc.username=root
​ jdbc.password=123456

2)在mybatis的主配置文件,使用 指定文件的位置
在需要使用值的地方, ${key}

5.2 主配置文件的一些标签

​ 看一份主配置文件都有什么






    
  
    
        
    

    
        
    

    
        
    
    
    
        
            
            
                
                
                
                
            
        
    

    
        
    

  1. xml文件,需要在头部使用约束文件
  2. 根元素
  3. 文件主要包含内容:
  • 定义别名
  • 数据源
  • mapper文件
5.2.1 transactionManager

MyBatis提交事务 回滚事务的方式

​ type:事务的处理类型

​ 1)JDBC:表示mybatis底层使用jdbc中Connection对象 commit rollback

​ 2)MANAGED:把mybatis事务处理委托给其他的容器 (一个服务器软件 一个框架spring)

5.2.2 dataSource

dataSource:表示数据源,Mybatis 中访问数据库,可以连接池技术,但它采用的是自己的连接池技术。在 Mybatis 的 mybatis.xml 配置文件中,通过来实现 Mybatis 中连接池的配置。

​ type:指定数据源的类型

​ 1)POOLED:使用连接池,mybatis会创建PooledDataSource类

​ 2)UPOOLED:不适用连接池,在每次执行sql语句,先创建连接,执行sql,再关闭连接

​ mybatis会创建一个UnpooledDataSource来管理连接池

​ 3)JNDI:java命名和目录服务(Windows注册表)

5.2.3 typeAliases 别名
Mybatis 支持默认别名,我们也可以采用自定义别名方式来开发,主要使用在