Mybatis框架

目录

• 三层架构
• Mybatis
• • Mybatis作用
  • Mybatis的安装
  • Mybatis的传统使用
  • SqlSessionFactory和SqlSession
  • 动态代理getMapper
  • Mybatis深入理解参数
  • • 一个简单类型的传参
    • 多个参数传值@Param
    • 使用对象传参
    • • 按位置传参
      • Map传参
    • #{}和${}
  • 封装mybatis的输出结果
  • • resultType
    • 返回简单类型
    • 定义别名
    • 查询结果返回Map
  • resultMap结果映射
  • like模糊查询参数
  • 动态sql
  • • if标签
    • where
    • foreach
    • sql代码片段
  • mybatis配置文件
  • 扩展

三层架构

1：界面层——controller包（servlet）
接收用户的请求参数，处理请求结果（jsp，html，servlet）
2：业务逻辑层——service包（service类）
接收了界面层传递的数据，计算逻辑，调用数据库，获取数据
3：数据访问层——dao包（Dao类）
就是访问数据库，执行对数据的增删查看（CRUD）等

三层中类的交互：
用户使用界面层——>业务逻辑层——>数据访问层（持久层）——>数据库（mysql）

三层对应的处理框架：
界面层：——servlet——springmvc（框架）
业务逻辑层：——service——spring（框架）
数据访问层：——dao类——mybatis（框架）

Mybatis Mybatis作用

Mybatis类似于增强版的JDBC

1：sql mapper：sql映射
可以把数据库中的一行数据 映射为一个java对象
一行数据可以看做是一个java对象，操作这个对象，就相当于操作表中的数据
2：Data Access Objects（DAOs）
数据访问，对数据库执行增删改查（CRUD）

提供的功能

1：提供了创建Connection，Statement，ResultSet的能力
2：提供了执行sql语句的能力
3：提供了循环sql，把sql的结果转为java对象，集合的能力
4：提供了关闭资源（Connection，Statement，ResultSet）的能力

Mybatis的安装

Mybatis下载地址：Github官网下载地址

Mybatis中文帮助官网：mybatis中文网

Mybatis的传统使用

1：加入Mybatis坐标，mysql的驱动
2：创建sql映射的配置文件
在dao目录中和接口同级，文件名和接口保持一致
sql映射文件，写sql语句，一个表对应一个sql映射文件，后缀.xml
3：创建mybatis的主配置文件
一个项目只有一个主配置文件
主配置文件提供了数据库的连接信息和sql映射文件的位置信息
4：使用SqlSession调用操作数据库的操作

创建Maven的普通javaSE的项目：

准备dao目录，mysql表，普通的类（类的数据和表中的数据类型保持一致）

StudentDao文件的内容：

package com.javase.dao;

import com.javase.entity.student;
import java.util.List;

public interface StudentDao {
    List SelectStudents();
}

创建普通的类

打开pom.xml加入依赖
加入依赖：mybatis，mysql
打开mybatis中文网

    
      org.mybatis
      mybatis
      3.5.7
    
    
     
      mysql
      mysql-connector-java
      8.0.27
    
    


 

    
      
        
        src/main/java
        
          
          ***.xml
        
        false
      

      
        
        src/main/resources
        
          
          ***.xml
        
        false
      
    

创建映射sql的配置文件

在dao目录下创建文件file：

配置文件复制mybatis中文网的内容：

  
  
    select * from usertable
  

 
创建主配置文件mybatis
 mybatis的中文网
 
 在resources配置文件内创建文件：mybatis.xml
 
 




	
	
	
    
        
    

    
		
        

			
            
			
			
            
                
                
                
                
            

        
    

    
    
        
    


 
SqlSessionFactory和SqlSession 
主要的类的介绍：
 
 
 
Resources类：
 负责读取Mybatis的主配置文件
 
 
 
 
SqlSessionFactoryBuilder：
 创建SqlSessionFactory对象：
 SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
 builder.build(Resources类读取主配置文件);
 
 
 
 
SqlSessionFactory：
 重量级对象，整个项目中有一个就够用了
 这个对象本身是个接口，里面有两个openSession方法：带参数/无参数
 带布尔类型参数的表示是否自动提交sql事务
 不带参数默认不自动提交事务
 获取SqlSession对象需要调用
 SqlSessionFactory对象调用openSession方法返回值是SqlSession
 
 
 
 
SqlSession：
 SqlSession是个接口，提供了操作数据库的各种功能
 要求：
 SqlSession不是线程安全的，在sql语句执行之前需要openSession获取SqlSession
 执行完sql语句之后，需要关闭它，SqlSession.close();
 
 
 
 
代码实现：
 
public class App {
    public static void main(String[] args) throws IOException {
        //主配置文件名
        String config = "mybatis.xml";
        //获取主配置文件
        InputStream in = Resources.getResourceAsStream(config);
        //创建builder对象准备获取SqlSessionFactory对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //获取SqlSessionFactory对象准备获取SqlSession
        SqlSessionFactory factory = builder.build(in);
        //调用openSession方法（自动提交事务）获取SqlSession对象
        SqlSession SqlSession = factory.openSession(true);
        //指定要执行的sql语句标识，sql映射文件中的namespace和sql语句标签的id中间加个.
        String sqlId = "com.javase.dao.StudentDao" + "." + "selectStudent";
        //调用查询方法接收返回值
        List students = SqlSession.selectList(sqlId);
        //输出结果
        students.forEach( student -> System.out.println(student.toString()));
        //关闭对象
        SqlSession.close();
    }
}
 
SqlSession的封装
 创建util包和工具类
 
 
package com.javase.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 MyBatisUtil {
    //创建SqlSessionFactory对象，因为项目只需要一个所以写在静态块中
    private static SqlSessionFactory factory = null;
    static {
        try {
            //获取主配置文件
            InputStream in = Resources.getResourceAsStream("mybatis.xml");
            //创建SqlSessionFactory对象
            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;
    }
}
 
创建接口实现类
 
 
package com.javase.dao.impl;

import com.javase.dao.StudentDao;
import com.javase.entity.student;
import com.javase.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import java.util.List;

public class StudentDaoImpl implements StudentDao {
    @Override
    public List SelectStudents() {
        //获取SqlSession对象
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        //创建根据sql映射文件的标识
        String sqlId = "com.javase.dao.StudentDao.SelectStudents";
        //执行sql语句，获取返回结果
        List studentList = sqlSession.selectList(sqlId);
        //关闭SqlSession
        sqlSession.close();
        return studentList;
    }
}
 
测试代码结果
 创建测试类
 
 
package com.javase;


import com.javase.dao.StudentDao;
import com.javase.dao.impl.StudentDaoImpl;
import com.javase.entity.student;
import org.junit.Test;
import java.io.IOException;
import java.util.List;

public class TestMybatis {
    @Test
    public void testSelect() throws IOException {
        //创建dao实体类
        StudentDao studentDao = new StudentDaoImpl();
        //得到查询结果
        List studentsList = studentDao.SelectStudents();
        //显示查询结果
        for (student stu:studentsList) {
            System.out.println(stu.toString());
        }
    }
}
 
结果：
 
 
动态代理getMapper 
动态代理的作用：
 更方便的调用dao接口的方法来操作数据库
 SqlSession对象执行操作数据库的方法时，sql映射文件的namespace是和接口的全限定名称一样
 如com.javase.dao.StudentDao
 而sql语句标签的id是和接口的方法名一样
 通过接口的全限定名称和实体类的方法的调用就可以知道sql映射文件内的sql语句标签的类型
 
 动态代理可以通过全限定名和方法的名称获取到sql映射文件的标签类型，通过标签确定来调用SqlSession的哪个操作数据库的方法
 
如果标签是select返回值是集合那调用的是SqlSession.selectList()
 如果标签是insert返回值是Int那调用的是SqlSession.insert();
 
mybatis的动态代理：mybatis根据接口实体类方法的调用，获取执行sql语句的信息
 mybatis动态代理是通过jdk反射机制内部创建接口的实现类，完成SqlSession调用方法，访问数据库
 
使用动态代理优化项目：
 删除实体类impl
 
 在测试中使用Mybatis动态代理：
 
package com.javase;

import com.javase.dao.StudentDao;
import com.javase.entity.student;
import com.javase.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.io.IOException;
import java.util.List;

public class TestMybatis {
    @Test
    public void testSelect() throws IOException {
        //使用动态代理机制的方法，SqlSession.getMapper(接口)
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        
        List studentList = dao.SelectStudents();
        //输出结果
        for (student stu:studentList) {
            System.out.println(stu.toString());
        }
    }
}
 
结果：
 
 
Mybatis深入理解参数 
执行对sql映射文件的参数传递，比如JDBC的sql语句条件where = ?
 需要进行传参，而在Mybatis中是where = #{字符串}
 
parameterType（不写也可以）：
 根据传入参数的数据类型来表示，比如传入的编号参数是Integer那就可以写成Mybatis规定表示的int
 
    
        select * from usertable where id = #{id}
    

Mybatis对数据类型全限定名称对比表：左边是Mybatis规定名称，右边是数据类型名称

一个简单类型的传参

简单类型：基本数据类型（包括包装类）和String字符串
在sql映射文件中简单类型的参数是用#{字符串}来表示

    
        select * from usertable where id = #{id}
    
 
测试：
 
    @Test
    public void testSelectStudentById(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        student stu = dao.SelectStudentById(69);
        System.out.println(stu.toString());
    }
 
结果：
 
 原理：
 
在使用#{}之后，Mybatis执行JBDC中的PreparedStatement对象
String sql = "select * from usertable where id = ?"
PreparStatement ps = con.preparedStatement(sql);
ps.setInt(0,69);
执行完毕后封装为resultType="com.javase.entity.student"
ResultSet rs = ps.executeQuery();
while(rs.next()){
	从数据库取数据存到student对象中并返回
}
 
多个参数传值@Param 
多个参数是用@Param命名参数
 在接口中方法的参数是用@Param
 
student SelectStudentByIdAndSex(@Param("ById") Integer id, @Param("BySex") String sex);
 
在sql映射文件中使用
 
    
        select * from usertable where id = #{ById} and sex = #{BySex}
    

测试：

    @Test
    public void testSelectStudentByIdAndSex(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        student stu = dao.SelectStudentByIdAndSex(69,"男");
        System.out.println(stu.toString());
    }

结果：

使用对象传参

传多个参数，使用java对象的属性值作为参数
创建接口方法：

student SelectStudentsByObject(student stu);

sql映射文件：

语法：#{属性名，javaType=类型名，jdbcType=数据类型}
javaType是java中的对象属性数据类型
jdbcType是数据库中表结构字段的属性类型
    
        select * from usertable where id = #{id,javaType=java.lang.Integer,jdbcType=BIGINT} and
                                      username = #{username,javaType=java.lang.String,jdbcType=VARCHAR}
    
简化版本写法：
    
        select * from usertable where id = #{id} and username = #{username}
    

测试：

    @Test
    public void testSelectStudentByObject(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        student stu = dao.SelectStudentsByObject(new student(69,"艾伦",null,null,null));
        System.out.println(stu.toString());
    }

结果：

mybatis支持的数据库中的类型

按位置传参

接口：

student SelectStudentByPosition(Integer id,String name);

sql映射文件：

    
        select * from usertable where id = #{arg0} and username = #{arg1}
    
 
测试：
 
    @Test
    public void testSelectStudentByPosition(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        student stu = dao.SelectStudentByPosition(69,"艾伦");
        System.out.println(stu.toString());
    }
 
Map传参 
使用map的key进行传参
 接口：
 
student SelectStudentByMap(Map map);
 
创建map测试：
 
    @Test
    public void testSelectStudentByMap(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        Map map = new HashMap<>();
        map.put("mapId",69);
        map.put("mapName","艾伦");
        student stu = dao.SelectStudentByMap(map);
        System.out.println(stu.toString());
    }
 
sql映射文件：
 
    
        select * from usertable where id = #{mapId} and username = #{mapName}
    

#{}和${}

#{}和${}区别

#{}底层使用了PrepareStatement对象执行sql语句#{}代表sql语句的?这样更安全，更迅速
${}底层使用了Statement对象执行sql语句使用了字符串的连接和替换，有sql注入现象，效率低，不安全

封装mybatis的输出结果 resultType

resultType结果类型，执行完sql语句后将数据转为的结果类型
resultType转为的结果类型是任意的，不需要实体类

    
        select * from usertable
    
    
    sql语句执行完毕后会把结果转为java对象（com.javase.entity.student）
    查询结果为id username password sex email
    相当于new student(id,username,password,sex,email);
    如果有多个对象则生成List集合储存
 
返回简单类型 
接口：
 
int SelectStudentsCount();
 
sql映射文件：
 建议resultType写类型的全限定名称
 
    
        select count(username) from usertable
    

测试：

    @Test
    public void testSelectsCount(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        int result = dao.SelectStudentsCount();
        System.out.println("总人数为：" + result);
    }

结果：

定义别名

可以在mybatis主配置文件中定义别名

将全限定名com.javase.entity.student定义为stu
第一种定义方式：
    
        
    
第二种定义方式：
将包内的所有类不需要写全限定名称，比如entity包下的student只需要在sql映射文件中写stuent就可以
    
        
    

"注：两个包下的类名有可能重复，谨慎使用，建议用全限定名"

sql映射文件：

    
        select * from usertable
    
 
测试：
 
    @Test
    public void testSelect() throws IOException {
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        List studentList = dao.SelectStudents();
        for (student stu:studentList) {
            System.out.println(stu.toString());
        }
    }
 
结果：
 
 
查询结果返回Map 
接口：
 
Map SelectStudentByResultTypeMap(Integer id);
 
sql映射文件：
 
    
        select * from usertable where id = #{id}
    

测试：

    @Test
    public void testSelectByResultTypeMap(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        Map studentMap = dao.SelectStudentByResultTypeMap(69);
        System.out.println(studentMap);
    }

resultMap结果映射

resultMap结果映射是用来指定你的列名和java对象的属性对应关系
当列名和属性名不一样时需要使用resultMap
resultType和resultMap不能一起用
接口：

List SelectStudentsByResultMap();

sql映射文件：

    
    
        
        
        
        
        
        
    
    
        select id,username,password,sex,email from usertable
    
 
测试：
 
    @Test
    public void testSelectByResultMap() {
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        List studentList = dao.SelectStudentsByResultMap();
        for (student stu:studentList) {
            System.out.println(stu.toString());
        }
    }
 
结果：
 
 也可以自己指定列名赋值
 
    
    
        
        
        
        
        
        
    
    
        select id,username,password,sex,email from usertable
    

结果：

resultType解决列名和属性名不一致的第二种解决方案
设一个普通类

package com.javase.entity;

public class NewStudent {
    private Integer id;
    private String name;
    private String psw;
    private String sex;
    private String email;

    public NewStudent() {
    }

    public NewStudent(Integer id, String name, String psw, String sex, String email) {
        this.id = id;
        this.name = name;
        this.psw = psw;
        this.sex = sex;
        this.email = email;
    }

    @Override
    public String toString() {
        return "NewStudent{" +
                "id=" + id +
                ", name='" + name + ''' +
                ", psw='" + psw + ''' +
                ", sex='" + sex + ''' +
                ", email='" + email + ''' +
                '}';
    }

    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 getPsw() {
        return psw;
    }

    public void setPsw(String psw) {
        this.psw = psw;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getEmail() {
        return email;
    }

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

sql映射文件：
sql语句内的列名与转为的结果类型的属性名不一样时可以使用sql语句的别名as

    
        select id,username as name,password as psw,sex,email from usertable
    
 
like模糊查询参数 
模糊查询语法：
 接口：
 
List SelectStudentsByLike(String name);
 
sql映射文件：
 
第一种写法：
    
        select * from usertable where username like #{name}
    
第二种写法：
    
        select * from usertable where username like "%" #{name} "%"
    
 
测试：
 
    @Test
    public void testSelectByLike() {
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        
        第一种sql映射文件写法的传参：
        List studentList = dao.SelectStudentsByLike("%张%");
        
        第二种传参
        List studentList = dao.SelectStudentsByLike("张");
        
        for (student stu:studentList) {
            System.out.println(stu.toString());
        }
    }
 
结果：
 
 
动态sql 
if标签 
使用动态sql时需要使用java对象作为参数
 接口：
 
List SelectSql(student stu);
 
sql映射文件：
 
    
        select * from usertable
        where
        
        
            username = #{username}
        
        
        
            or id < #{id}
        
    
如果第一个if不成立而第二个if成立的话sql会变成select * from usertable where or id < ?
这样会语法错误，改进代码where 1=1：
    
        select * from usertable
        where 1=1
        
            username = #{username}
        
        
            or id < #{id}
        
    

> 以上代码中or id < #{}中的<表示小于的意思，因为直接写<会造成标签冲突

mybatis的对应符号：

原符号	对应符号
<	<
>	>
<>	<>
&	&
’	'
"	"

测试：

    @Test
    public void testSelectSql(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        student stu = new student();
        stu.setId(69);
        stu.setUsername("艾伦");
        List studentList = dao.SelectSql(stu);
        for (student stuList:studentList) {
            System.out.println(stuList.toString());
        }
    }

where

接口：

List SelectSqlWhere(student stu);

sql映射文件：

语法格式：  


    
        select * from usertable
        
            
                username = #{username}
            
            
                or id < #{id}
            
        
    

如果条件成立则会组装成select * from usertable WHERe username = ? or id < ?
注：如果第一个if不成立那where标签会自动删除第二个if的or[自动删除无效条件]
如果所有的if都不满足则where也没有
 
foreach 
foreach标签主要是用在sql语句中in的语法
 
比如select * from usertable where id in (69,68,67)

foreach的底层原理：
目标语句：select * from usertable where id in(69,68,67);
		//使用List集合存储in里面的参数
		List list = new ArrayList();
		list.add(69);
		list.add(68);
		list.add(67);
		//创建基本语句用来字符串拼接的方式完成
		String sql = "select * from usertable where id in";
		StringBuilder builder = new StringBuilder();
        //添加开始时的小括号
        builder.append("(");
        for(Integer i:list){
            //这个i就是集合中的值69 68 67每个数字后面需要加，就是69,68,67,
            builder.append(i).append(",");
        }
        //删除最后一个逗号
        builder.deleteCharAt(builder.length()-1);
        //添加结束的小括号
        builder.append(")");
        //执行字符串拼接
        sql += builder;
        System.out.println(sql);
 
结果：
 
 foreach的语法：
 接口：
 
//参数基础类型的写法：
List SelectForeach(List list);

//参数对象类型的写法：
List SelectForeach(List list);
 
sql映射文件：
 
list集合中是基础类型的写法：
    
        select * from usertable where id in
        
            #{id}
        
    
list集合是对象类型的写法：
    
        select * from usertable where username in
        
            #{stu.username}
        
    
conllection：表示接口中的方法的参数的类型,如果是数组使用array,如果是集合使用list（小写）
item:自定义，表示数组和集合的成员的变量
open:循环开始的符号 比如原理中的拼接字符串开始字符是(
close:循环结束的符号 结束字符是)
这两个是(69,68,67)中的小括号()
separator:表示循环每一个数据中分割的符号 在(69,68,67)中的逗号,
 
测试：
 
    @Test
    public void testForeach(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        
        //基础类型的写法：
        List list = new ArrayList<>();
        list.add(69);
        list.add(68);
        list.add(67);

		//对象类型的写法：
        List stuList = new ArrayList<>();
        stuList.add(new student(null,"爱丽丝",null,null,null));
        stuList.add(new student(null,"艾伦",null,null,null));
        stuList.add(new student(null,"张三",null,null,null));
        
        List studentList = dao.SelectForeach(list);//对象类型是stuList
        for (student stu:studentList) {
            System.out.println(stu.toString());
        }
    }
 
基础类型的结果：
 
 对象类型的结果：
 
 
sql代码片段 
代码片段是用来复用语句的
 语法：
 
先使用sql语句
在使用
 
sql映射文件：
 
    select * from usertable
    
    
    	
        
        
            
                username = #{username}
            
            
                or id < #{id}
            
        
    

测试：

    @Test
    public void testSelectSqlWhere(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        student stu = new student();
        stu.setUsername("艾伦");
        stu.setId(69);
        List studentList = dao.SelectSqlWhere(stu);
        for (student stuList:studentList) {
            System.out.println(stuList.toString());
        }
    }

结果：

mybatis配置文件

数据库连接配置文件properties
把数据库的连接信息单独写到一个文件中，方便管理连接数据库的信息
在resources配置文件夹下创建文件：自定义文件名.properties

文件中写入连接数据库的信息
格式：key=value

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

在主配置文件下导入文件位置并修改连接信息（使用${文件的key值}）：

指定多个sql映射文件（mapper）
假如有多个mapper文件

需要在主配置文件下添加sql映射文件

第一种写法：
    
        
        
    
第二种写法：
    
        
    

扩展

数据展示的翻页插件：
在pom.xml文件中加入pagehelper的依赖：

    com.github.pagehelper
    pagehelper
    5.3.0

在mybatis的主配置文件加入插件：
在environments标签之前

测试：

	@Test
    public void testSelect() {
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        //加入PageHelper的方法，分页
        //参数pageNum：从第几页开始
        //PageSize：一页中有多少数据
        PageHelper.startPage(1,3);

        List studentList = dao.SelectStudents();

        for (student stu:studentList) {
            System.out.println(stu.toString());
        }
        sqlSession.close();
    }