使用MyBatis框架实现对表单的添加、全查、单查、修改、删除操作

 1、什么是MyBatis框架

它是一款半自动的ORM持久层框架，具有较高的SQL灵活性，支持高级映射(一对一，一对多)，动态SQL，延迟加载和缓存等特性，但它的数据库无关性较低

什么是ORM？

Object Relation Mapping，对象关系映射。对象指的是Java对象，关系指的是数据库中的关系模型，对象关系映射，指的就是在Java对象和数据库的关系模型之间建立一种对应关系，比如用一个Java的Student类，去对应数据库中的一张student表，类中的属性和表中的列一一对应。Student类就对应student表，一个Student对象就对应student表中的一行数据。

为什么mybatis是半自动的ORM框架？

用mybatis进行开发，需要手动编写SQL语句。而全自动的ORM框架，如hibernate，则不需要编写SQL语句。用hibernate开发，只需要定义好ORM映射关系，就可以直接进行CRUD操作了。由于mybatis需要手写SQL语句，所以它有较高的灵活性，可以根据需要，自由地对SQL进行定制，也因为要手写SQL，当要切换数据库时，SQL语句可能就要重写，因为不同的数据库有不同的方言(Dialect)，所以mybatis的数据库无关性低。虽然mybatis需要手写SQL，但相比JDBC，它提供了输入映射和输出映射，可以很方便地进行SQL参数设置，以及结果集封装。并且还提供了关联查询和动态SQL等功能，极大地提升了开发的效率。并且它的学习成本也比hibernate低很多。

2、如何使用mybatis

1、创建数据库

#判断存在即删除数据库
drop database if exists mydb;
#创建数据库
create database mydb;
#使用数据库
use mydb;


#创建表
create table t_user
(
	uid int primary key auto_increment,
	username varchar(20),
	password varchar(20),
	phone varchar(11),
	address varchar(50)
);


insert into t_user(username,password,phone,address) values('张三','666','18965423548','南阳');
insert into t_user(username,password,phone,address) values('李四','333','18754263548','许昌');
insert into t_user(username,password,phone,address) values('小美','123','18565234759','信阳');

2、创建一个Java项目并导入mybatis框架的jar包

3.创建跟表对应的实体类

public class User {
    private Integer uid;
    private String userName;
    private String password;
    private String phone;
    private String 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;
    }

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

4.创建针对表操作的接口类

public interface UserInterface {
    //全查
    List<User> selectAll();
    //添加
    int add(User user);
    //删除
    int dell(int uid);
    //修改
    int update(User user);
    //单查
    User select(int uid);
    //模糊查询
    List<User> mohu(String name);
}

5.在src文件夹创建properties文件 

 创建jdbc.properties文件（步骤如上图所示）：

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/mydb
username=root
password=root

引入日志文件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 

扫描二维码关注公众号，回复： 15543883 查看本文章

6.在接口的包中创建对应的mapper映射配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--声明XML文档的版本和编码-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--声明文档类型，这里使用MyBatis映射文件的DTD-->
<!--namespace是映射的dao接口-->
<mapper namespace="com.liu.dao.UserInterface">

    <!--查询所有用户-->
    <select id="selectAll" resultType="user">
        select * from t_user;
    </select>

    <!--添加用户-->
    <insert id="add" parameterType="user">
        insert into t_user(username,password,phone,address) values(#{userName},#{password},#{phone},#{address});
    </insert>

    <!--删除用户-->
    <delete id="dell" parameterType="user">
        delete from t_user where uid=#{uid}
    </delete>

    <!--更新用户-->
    <update id="update" parameterType="user">
        update t_user set username=#{userName},password=#{password},phone=#{phone},address=#{address} where uid=#{uid};
    </update>

    <!--根据id查询用户-->
    <select id="selectById" resultType="user" parameterType="int">
        select * from t_user where uid=#{uid};
    </select>

    <!--模糊查询用户-->
    <select id="mohu" resultType="user" parameterType="string">
        select * from t_user where username like concat ('%',#{name},'%')
    </select>
</mapper>

7.在src目录中创建mybatis框架的核心配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--声明XML文档的版本和编码-->
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--声明文档类型，这里使用MyBatis配置文件的DTD-->
<configuration>

    <!--引入JDBC配置文件-->
    <properties resource="jdbc.properties"/>

    <!--MyBatis全局配置-->
    <settings>
        <!--日志实现方式-->
        <setting name="logImpl" value="log4j"/>
    </settings>

    <!--类型别名-->
    <typeAliases>
        <!--扫描指定包下的Java Bean，将类名作为别名-->
        <package name="com.liu.bean"/>
    </typeAliases>

    <!--数据库环境配置-->
    <environments default="mysql">
        <!--指定数据库环境id-->
        <environment id="mysql">
            <!--事务管理器类型-->
            <transactionManager type="jdbc"></transactionManager>
            <!--数据源类型-->
            <dataSource type="pooled">
                <!--数据库驱动-->
                <property name="driver" value="${driver}"/>
                <!--数据库URL-->
                <property name="url" value="${url}"/>
                <!--数据库用户名-->
                <property name="username" value="${username}"/>
                <!--数据库密码-->
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--映射器配置-->
    <mappers>
        <!--指定映射器接口的全限定名-->
        <mapper class="com.liu.dao.UserInterface"></mapper>
    </mappers>
</configuration>

8.在测试类中进行测试

import com.liu.bean.User;
import com.liu.dao.UserInterface;
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;
import java.util.Scanner;


// 定义一个名为UserTest的类
public class UserTest {
    // 声明一些需要在测试中使用的变量，这些变量可以在@Before和@After中被初始化和关闭
    InputStream stream = null;
    SqlSessionFactoryBuilder builder = null;
    SqlSessionFactory factory = null;
    SqlSession sqlSession = null;
    UserInterface userInterface = null;

    // 在所有测试方法运行之前运行的方法，用于初始化测试所需的变量
    @Before
    public void aaaa() throws IOException {
        // 从SqlMapConfig.xml配置文件中获取数据库连接信息的输入流
        stream = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 创建SqlSessionFactoryBuilder实例，用于创建SqlSessionFactory实例
        builder = new SqlSessionFactoryBuilder();
        // 通过SqlSessionFactoryBuilder实例的build方法创建SqlSessionFactory实例
        factory = builder.build(stream);
        // 通过SqlSessionFactory实例创建SqlSession实例
        sqlSession = factory.openSession();
        // 获取UserInterface实例
        userInterface = sqlSession.getMapper(UserInterface.class);
    }

    // 测试查询所有用户的方法
    @Test
    public void testSelectAll() {
        // 调用UserInterface实例的selectAll方法查询所有用户，并将结果存储在userList中
        List<User> userList = userInterface.selectAll();
        // 遍历userList并输出每个用户
        for (User user : userList) {
            System.out.println(user);
        }
    }

    // 测试添加用户的方法
    @Test
    public void testadd() {
        // 创建一个新的User实例，并设置其属性值
        User user = new User();
        user.setUserName("wzl");
        user.setPassword("123");
        user.setPhone("12345678901");
        user.setAddress("安阳");
        // 调用UserInterface实例的add方法将新用户添加到数据库，并将受影响的行数存储在add变量中
        int add = userInterface.add(user);
        // 如果成功添加了用户，则查询并输出所有用户
        if (add > 0) {
            List<User> userList = userInterface.selectAll();
            for (User user1 : userList) {
                System.out.println(user1);
            }
        }
    }

    // 测试删除用户的方法
    @Test
    public void testdell() {
        // 定义要删除的用户的id
        int uid = 11;
        // 调用UserInterface实例的dell方法删除指定id的用户，并将受影响的行数存储在dele变量中
        int dele = userInterface.dell(uid);
        // 如果成功删除了用户，则查询并输出所有用户
        if (dele > 0) {
            List<User> userList = userInterface.selectAll();
            for (User user1 : userList) {
                System.out.println(user1);
            }
        }
    }

    // 测试更新用户的方法
    @Test
    public void testupdate() {
        // 通过id查询用户并输出
        User select = userInterface.selectById(10);
        System.out.println("修改前" + select);
        // 构造新的User对象并更新用户信息
        User user = new User();
        user.setUid(10);
        user.setUserName("王二麻子");
        user.setPassword("12345");
        user.setPhone("12345678901");
        user.setAddress("平顶山");
        int update = userInterface.update(user);
        // 如果成功更新用户，则通过id再次查询用户并输出
        if (update > 0) {
            User select2 = userInterface.selectById(10);
            System.out.println("修改后" + select2);
        }
    }

    // 测试通过id查询用户的方法
    @Test
    public void testselectById() {
        // 定义要查询的用户的id
        int uid = 1;
        // 调用UserInterface实例的selectById方法查询指定id的用户并输出
        User select = userInterface.selectById(1);
        System.out.println(select);
    }

    // 测试模糊查询用户的方法
    @Test
    public void testmohu() {
        // 通过键盘输入获取模糊查询关键字
        Scanner sc = new Scanner(System.in);
        String aa = sc.next();
        // 调用UserInterface实例的mohu方法模糊查询用户并输出
        List<User> mohu = userInterface.mohu(aa);
        for (User user : mohu) {
            System.out.println(user);
        }
    }
     // 执行测试后的善后处理

    @After
    public void bbb() throws IOException {
        // 提交事务
        sqlSession.commit();
        // 关闭输入流
        if (stream != null) {
            stream.close();
        }
        // 关闭sqlSession
        if (sqlSession != null) {
            sqlSession.close();
        }
    }
}

运行结果

全查运行结果：

 添加运行结果：

删除运行结果：

修改运行结果：

单查运行结果：

模糊查询结果：