使用mybatis完成单表的增删改查操作（动态sql）

wangzhigang0926

已于 2023-03-20 18:35:38 修改

阅读量1.2k

点赞数 1

文章标签： java 数据库架构 Powered by 金山文档

于 2023-03-06 22:03:38 首次发布

本文链接：https://blog.csdn.net/wangzhigang0926/article/details/129371518

版权

什么是mybatis

MyBatis 是一个可以自定义 SQL、存储过程和高级映射的持久层框架。

2.能简述一下动态sql 的执行原理不？

其执行原理为，使用OGNL 从sql 参数对象中计算表达式的值，根据表达式的值动态拼接sql，以此来完成动态sql 的功能。

3.MyBatis 的好处是什么？

a、MyBatis 把 sql 语句从 Java 源程序中独立出来，放在单独的 XML 文件中编写，给程序的维护带来了很大便利。

b、MyBatis 封装了底层 JDBC API 的调用细节，并能自动将结果集转换成 Java Bean 对象，大大简化了 Java 数据库编程的重复工作。

c、因为 MyBatis 需要程序员自己去编写 sql 语句，程序员可以结合数据库自身的特点灵活控制 sql 语句，因此能够实现比 Hibernate 等全自动 orm 框架更高的查询效率，能够完成复杂查询。

MySQL数据库

drop database if exists web1;
create database web1;
#使用数据库
use web1;
#创建表
create table w_user(
uid int primary key auto_increment,
username varchar(20),
password varchar(20),
phone varchar(11),
address varchar(50)
)
#新增
insert into w_user(username,password,phone,address) values('张三','123','18537452315','河南');
insert into w_user(username,password,phone,address) values('小红','321','15978388536','河北');
insert into w_user(username,password,phone,address) values('小明','213','13913094291','上海');
select * from w_user where username='张三' and password='123'
#新增
insert into w_user(username,password) values(?,?);

创建mybatis01项目在里面调用jar包

创建包

在com.wang.bean包在里面创建User实体类

package com.wang.bean;

public class User {
    private Integer uid;
    private String username;
    private String password;
    private String phone;
    private String address;

    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", phone='" + phone + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

创建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>
<!--配置环境信息===就是配置连接数据库的参数
default:指定配置的环境信息的id。表示默认连接该环境-->
    <environments default="mysql">
        <environment id="mysql">
            <!--配置事务的处理方式：模式使用jdbc的事务处理-->
            <transactionManager type="jdbc"></transactionManager>
            <!--数据源的默认type设置为pooled，表示使用连续池-->
            <dataSource type="pooled">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/web1"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--加载mapper配置文件-->
        <mapper class="com.wang.dao.UserDao"/>
    </mappers>
</configuration>

一，全查1.在com.wang.dao包中创建UserDao接口，在里面编写全查的代码

package com.wang.dao;

import com.wang.bean.User;

import java.util.List;

public interface UserDao {
    //查询
    List<User> selectAll();
}

2.在com.wang.dao包中创建UserDao.xml文件在里面设置映射和通过select标签进行查询

<?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.wang.dao.UserDao">
    <!--通过select标签进行查寻
    id:映射接口的方法名
    parameterType:指定参数的类型只需要指定集合元素的类型即可
    resultType:指定返回值的类型-->
    <select id="selectAll" resultType="com.wang.bean.User">
        select*from w_user;
    </select>
</mapper>

3.在com.wang.test包中创建测试类Test,测试查询

package com.wang.test;

import com.wang.bean.User;
import com.wang.dao.UserDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

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

public class UserTest {
    @Test
    public void testSelectAll() throws IOException {
        //1.加载核心配置文件的字节输入流
        InputStream stream= Resources.getResourceAsStream("mybatis.xml");
        //2.创建SqlSessionFactoryBuilder的构建对象--框架使用的是构建者模式
        SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
        //3.通过构建对象加载配置文件的输入流获取SqlSessionFactory
        SqlSessionFactory factory= builder.build(stream);
        //4.通过工厂对象获取SqlSession对象
        SqlSession sqlSession=factory.openSession();
        //5.通过sqlSession对象获取接口对应的代理对象
        UserDao userDao=sqlSession.getMapper(UserDao.class);
        ///6.通过代理对象执行查询方法
        List<User> userList=userDao.selectAll();
        //7.遍历集合
        for (User user:userList){
            System.out.println(user);
        }
    }
}

运行效果：

二，新增1.在com.wang.dao包中的接口类UserDao中创建新增的接口


import com.wang.bean.User;

import java.util.List;

public interface UserDao {
    //查询
    List<User> selectAll();
    //新增
    int add(User user);
}

2.在com.wang.dao包中的UserDao.xml文件中设置新增的映射和编写sql语句

<?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.wang.dao.UserDao">
    <!--通过select标签进行查寻
    id:映射接口的方法名
    parameterType:指定参数的类型只需要指定集合元素的类型即可
    resultType:指定返回值的类型-->
    <select id="selectAll" resultType="com.wang.bean.User">
        select*from w_user;
    </select>
    <insert id="add" parameterType="com.wang.bean.User">
        insert into w_user(username,password,phone,address) values(#{username},#{password},#{phone},#{address});
    </insert>
</mapper>

3.在com.wang.test包中的测试类设置新增的测试代码，并编写@Before和@After代码

package com.wang.test;

import com.wang.bean.User;
import com.wang.dao.UserDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

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

public class UserTest {
    InputStream stream=null;
    SqlSessionFactoryBuilder builder=null;
    SqlSessionFactory factory=null;
    SqlSession sqlSession=null;
    UserDao userDao=null;
    @Before
    public void init() throws IOException {
        //1.加载核心配置文件的字节输入流
        stream= Resources.getResourceAsStream("mybatis.xml");
        //2.创建SqlSessionFactoryBuilder的构建对象--框架使用的是构建者模式
        builder=new SqlSessionFactoryBuilder();
        //3.通过构建对象加载配置文件的输入流获取SqlSessionFactory
        factory= builder.build(stream);
        //4.通过工厂对象获取SqlSession对象
        sqlSession=factory.openSession();
        //5.通过sqlSession对象获取接口对应的代理对象
        userDao=sqlSession.getMapper(UserDao.class);
    }
    @Test
    public void testSelectAll() throws IOException {
        //6.通过代理对象执行查询方法
        List<User> userList=userDao.selectAll();
        //7.遍历集合
        for (User user:userList){
            System.out.println(user);
        }
    }
    @Test
    public void testAdd() throws IOException {
        //定义User对象，封装数据
        User user=new User();
        user.setUsername("饶正");
        user.setPassword("355");
        user.setPhone("166");
        user.setAddress("河南");

        int n=userDao.add(user);
        if (n>0){
            System.out.println("cg");
        }else {
            System.out.println("shibai");
        }
    }
 @After
    public void distroy() throws IOException {
        sqlSession.commit();
        sqlSession.close();
        stream.close();
    }
}

运行效果：

三，删除1.在com.wang.dao包中的UserDao接口中编写删除的接口

package com.wang.dao;

import com.wang.bean.User;

import java.util.List;

public interface UserDao {
    //查询
    List<User> selectAll();
    //新增
    int add(User user);
    //删除
    int del(int uid);
}

2.在com.wang.dao包中的UserDao.xml文件中编写删除的接口映射和sql语句

<?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.wang.dao.UserDao">
    <!--通过select标签进行查寻
    id:映射接口的方法名
    parameterType:指定参数的类型只需要指定集合元素的类型即可
    resultType:指定返回值的类型-->
    <select id="selectAll" resultType="com.wang.bean.User">
        select*from w_user;
    </select>
    <insert id="add" parameterType="com.wang.bean.User">
        insert into w_user(username,password,phone,address) values(#{username},#{password},#{phone},#{address});
    </insert>
    <delete id="del" parameterType="int">
        delete from w_user where uid=#{uid};
    </delete>
</mapper>

3.在com.wang.test包中的测试类UserTest中编写删除的测试代码

package com.wang.test;

import com.wang.bean.User;
import com.wang.dao.UserDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

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

public class UserTest {
    InputStream stream=null;
    SqlSessionFactoryBuilder factoryBuilder=null;
    SqlSessionFactory factory=null;
    SqlSession session=null;
    UserDao userDao=null;
    @Before
    public void init() throws IOException {
        stream= Resources.getResourceAsStream("mybatis.xml");
        factoryBuilder=new SqlSessionFactoryBuilder();
        factory=factoryBuilder.build(stream);
        session=factory.openSession();
        userDao=session.getMapper(UserDao.class);
    }
    @Test
    public void selectAll(){
        List<User> userList = userDao.selectAll();
        for (User user:userList){
            System.out.println(user);
        }
    }
    @Test
    public void add(){
        User user=new User();
        user.setUsername("牛牛");
        user.setPassword("123456");
        user.setPhone("1852323");
        user.setAddress("东北");
        int n = userDao.add(user);
        if (n>0){
            System.out.println("cg");
        }
    }
    @Test
    public void delete(){
        int n = userDao.del(14);
        if (n>0){
            System.out.println("cg");
        }
    }

运行效果：

四，修改1.在com.wang.dao包中的UserDao接口类中定义修改的接口方法。

首先定义根据id查询的接口，其次定义修改的接口

package com.wang.dao;

import com.wang.bean.User;

import java.util.List;

public interface UserDao {
    List<User> selectAll();
    int add(User user);
    int del(int uid);
    User selectById(int id);
    int update(User user);
}

2.在com.wang.dao包中的UserDao.xml文件中编写查询和修改的sql语句

<?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.wang.dao.UserDao">
    <select id="selectAll" resultType="com.wang.bean.User">
        select*from w_user;
    </select>
    <insert id="add" parameterType="com.wang.bean.User">
        insert into w_user(username,password,phone,address) values(#{username},#{password},#{phone},#{address});
    </insert>
    <delete id="del" parameterType="int">
        delete from w_user where uid=#{uid};
    </delete>
    <select id="selectById" resultType="com.wang.bean.User" parameterType="int">
        select*from w_user where uid=#{uid};
    </select>
    <update id="update" parameterType="com.wang.bean.User">
        update w_user set username=#{username},password=#{password},phone=#{phone},address=#{address} where uid=#{uid};
    </update>
</mapper>

3.在com.wang.test包中的UserTest测试类中编写修改的测试方法

思路：首先将原来的用户信息查询出来展示，在进行修改后展示

package com.wang.test;

import com.wang.bean.User;
import com.wang.dao.UserDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

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

public class UserTest {
    InputStream stream=null;
    SqlSessionFactoryBuilder factoryBuilder=null;
    SqlSessionFactory factory=null;
    SqlSession session=null;
    UserDao userDao=null;
    @Before
    public void init() throws IOException {
        stream= Resources.getResourceAsStream("mybatis.xml");
        factoryBuilder=new SqlSessionFactoryBuilder();
        factory=factoryBuilder.build(stream);
        session=factory.openSession();
        userDao=session.getMapper(UserDao.class);
    }
    @Test
    public void selectAll(){
        List<User> userList = userDao.selectAll();
        for (User user:userList){
            System.out.println(user);
        }
    }
    @Test
    public void add(){
        User user=new User();
        user.setUsername("牛牛");
        user.setPassword("123456");
        user.setPhone("1852323");
        user.setAddress("东北");
        int n = userDao.add(user);
        if (n>0){
            System.out.println("cg");
        }
    }
    @Test
    public void delete(){
        int n = userDao.del(14);
        if (n>0){
            System.out.println("cg");
        }
    }
    @Test
    public void selectById(){
        User user = userDao.selectById(13);
        System.out.println(user);
    }
    @Test
    public void update(){
        User old = userDao.selectById(13);
        System.out.println("修改前:"+old);
        old.setUsername("赵六");
        old.setPassword("789123");
        old.setPhone("15971234");
        old.setAddress("河南信阳");
        userDao.update(old);
        User ne=userDao.selectById(13);
        System.out.println("修改后:"+ne);
    }
   @After
    public void destroy() throws IOException {
        session.commit();
        session.close();
        stream.close();
    }
}

运行效果：

五，模糊查询1.在com.wang.dao包中的UserDao接口中定义模糊查询的接口

package com.wang.dao;

import com.wang.bean.User;

import java.util.List;

public interface UserDao {
    List<User> selectAll();
    int add(User user);
    int del(int uid);
    User selectById(int id);
    int update(User user);
    List<User> mohuselect(String keyname);
}

2.在com.wang.dao包中的UserDao.xml文件中编写模糊查询的sql语句

<?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.wang.dao.UserDao">
    <select id="selectAll" resultType="com.wang.bean.User">
        select*from w_user;
    </select>
    <insert id="add" parameterType="com.wang.bean.User">
        insert into w_user(username,password,phone,address) values(#{username},#{password},#{phone},#{address});
    </insert>
    <delete id="del" parameterType="int">
        delete from w_user where uid=#{uid};
    </delete>
    <select id="selectById" resultType="com.wang.bean.User" parameterType="int">
        select*from w_user where uid=#{uid};
    </select>
    <update id="update" parameterType="com.wang.bean.User">
        update w_user set username=#{username},password=#{password},phone=#{phone},address=#{address} where uid=#{uid};
    </update>
    <select id="mohuselect" resultType="com.wang.bean.User" parameterType="String">
        select *from w_user where username like concat('%',#{keyname},'%');
    </select>
</mapper>

3.在com.wang.test包中的测试类UserTest中编写模糊查询的测试方法

package com.wang.test;

import com.wang.bean.User;
import com.wang.dao.UserDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

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

public class UserTest {
    InputStream stream=null;
    SqlSessionFactoryBuilder factoryBuilder=null;
    SqlSessionFactory factory=null;
    SqlSession session=null;
    UserDao userDao=null;
    @Before
    public void init() throws IOException {
        stream= Resources.getResourceAsStream("mybatis.xml");
        factoryBuilder=new SqlSessionFactoryBuilder();
        factory=factoryBuilder.build(stream);
        session=factory.openSession();
        userDao=session.getMapper(UserDao.class);
    }
    @Test
    public void selectAll(){
        List<User> userList = userDao.selectAll();
        for (User user:userList){
            System.out.println(user);
        }
    }
    @Test
    public void add(){
        User user=new User();
        user.setUsername("牛牛");
        user.setPassword("123456");
        user.setPhone("1852323");
        user.setAddress("东北");
        int n = userDao.add(user);
        if (n>0){
            System.out.println("cg");
        }
    }
    @Test
    public void delete(){
        int n = userDao.del(14);
        if (n>0){
            System.out.println("cg");
        }
    }
    @Test
    public void selectById(){
        User user = userDao.selectById(13);
        System.out.println(user);
    }
    @Test
    public void update(){
        User old = userDao.selectById(13);
        System.out.println("修改前:"+old);
        old.setUsername("老七");
        old.setPassword("789123");
        old.setPhone("1597987");
        old.setAddress("河南南阳");
        userDao.update(old);
        User ne=userDao.selectById(13);
        System.out.println("修改后:"+ne);
    }
    @Test
    public void mohu(){
        List<User> userList = userDao.mohuselect("小");
        System.out.println(userList);
    }
    @After
    public void destroy() throws IOException {
        session.commit();
        session.close();
        stream.close();
    }
}

运行效果：

六，打印日志信息

1.创建两个properties文件

2.在log4j.properties文件中放入写好的代码

log4j.rootLogger=TRACE,stdout  

log4j.appender.stdout=org.apache.log4j.ConsoleAppender   
#log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout   


log4j.appender.logfile=org.apache.log4j.FileAppender   
log4j.appender.logfile.File=wocao.log   
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout   
log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %F %p %m%n   
log4j.logger.mapperNS =TRACE

log4j.logger.com.mybatis=DEBUG  
log4j.logger.com.mybatis.common.jdbc.SimpleDataSource=DEBUG   
log4j.logger.com.mybatis.common.jdbc.ScriptRunner=DEBUG   
log4j.logger.com.mybatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG   
log4j.logger.java.sql.Connection=DEBUG  
log4j.logger.java.sql.Statement=DEBUG  
log4j.logger.java.sql.PreparedStatement=DEBUG  
log4j.logger.java.sql.ResultSet=DEBUG  

log4j.logger.org.springframework=error 
log4j.logger.org.apache=ERROR  
log4j.logger.org.mybatis=DEBUG

3.在jdbc.properties文件中连接数据库

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/web1?useSSL=false&serverTimezone=UTC
jdbc.username=root
jdbc.password=root
mapper.dao=com.wang.dao.UserDao

4.在mybatis.xml文件中更改配置

打印效果：

八，补充：1动态sql语句模糊查询，修改，多删

UserDao类（多删要创建一个DelVO实体类）

package com.wang.dao;

import com.wang.bean.DelVO;
import com.wang.bean.User;

import java.util.List;

public interface UserDao {
    List<User> search(User user);
    int update(User user);
    int del(DelVO delVO);
}

UserDao.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.wang.dao.UserDao">
    <select id="search" resultType="com.wang.bean.User" parameterType="com.wang.bean.User">
        select *from w_user where 1=1
        <if test="username!=null and username!=''">
            and username like concat('%',#{username},'%')
        </if>
        <if test="address!=null and address!=''">
            and address like concat('%',#{address},'%')
        </if>
    </select>
    <update id="update" parameterType="com.wang.bean.User">
        update w_user
        <set>
            <if test="username!=null and username!=''">
                username=#{username},
            </if>
            <if test="address!=null and address!=''">
                address=#{address},
            </if>
        </set>
            where uid=#{uid}
    </update>
    <!--foreach标签可以对一个集合变量进行迭代  常用与-->
    <delete id="del" parameterType="com.wang.bean.DelVO">
            delete from w_user where uid in
        <foreach item="id" collection="ids" open="(" close=")" separator=",">
            #{id}
        </foreach>
    </delete>
</mapper>

JDBCTest类

package com.wang.test;

import com.wang.bean.DelVO;
import com.wang.bean.User;
import com.wang.dao.UserDao;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

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

public class JDBCTest {
    InputStream stream=null;
    SqlSessionFactoryBuilder builder=null;
    SqlSessionFactory factory=null;
    SqlSession sqlSession=null;
    UserDao userDao=null;
    @Before
    public void init() throws IOException {
        stream= Resources.getResourceAsStream("mybatis.xml");
        builder=new SqlSessionFactoryBuilder();
        factory=builder.build(stream);
        sqlSession=factory.openSession();
        userDao=sqlSession.getMapper(UserDao.class);
    }
    @Test
    public void testsearch(){
        User user=new User();
        user.setUsername("小");
        user.setAddress("河南");
        List<User> userList = userDao.search(user);
        for (User user1:userList)
            System.out.println(user1);
    }

    @Test
    public void testUpdate(){
        User user=new User();
        user.setUsername("小花");
        user.setAddress("上海");
        user.setUid(13);
        int n = userDao.update(user);
        if (n>0){
            System.out.println("成功");
        }
    }
    @Test
    public void testDel(){
        DelVO delVO=new DelVO();
        List<Integer> integerList=new ArrayList<>();
        integerList.add(6);
        integerList.add(7);
        integerList.add(8);
        integerList.add(15);
        delVO.setIds(integerList);
        userDao.del(delVO);
        for (Integer integer : integerList) {
            System.out.println(integer);
        }
    }
    @After
    public void distroy() throws IOException {
        sqlSession.commit();
        sqlSession.close();
        stream.close();
    }
}

wangzhigang0926

关注

1
点赞
踩
9

收藏

觉得还不错? 一键收藏
2
评论
使用mybatis完成单表的增删改查操作（动态sql）

MyBatis 是一个可以自定义 SQL、存储过程和高级映射的持久层框架。2.能简述一下动态sql 的执行原理不？其执行原理为，使用OGNL 从sql 参数对象中计算表达式的值，根据表达式的值动态拼接sql，以此来完成动态sql 的功能。
复制链接

扫一扫