博客

一、新建MyBatis项目

1、新建一个空的Maven项目

2、下载Lombok插件

3、添加MyBatis依赖的Jar包

 <dependencies>
        <!-- Junit测试工具 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!-- MyBatis核心Jar包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>

        <!-- MySql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <!-- Lombok工具 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>

        <!-- Log4j测试工具 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>

二、新建实体类的包和相应的实体类

1、新建实体类包

新建包——com.tjise.entity名称最好是entity 符合规范

2、新建一个实体类User

在User实体类中添加相应的属性：实体类属性与数据库表的列名匹配

我的数据库ssm中users表



我的实体类属性userid、username、password、socre分别对应着表中的列名

package com.tjise.entity;

import lombok.Data;

//@Data是Lombok插件的注解 自动生成getter/setter方法 无参构造方法 equals与hashcode方法
//@Data = @Getter + @Setter + @ToString + @EqualsAndHashCode + @RequiredArgsConstructor
@Data
public class User {
    private int userid;
    private String username;
    private String password;
    private int score;

	//自己编写一个三个参数的构造方法，为后面的插入数据做准备
	public User(String username, String password, int score) {
        this.username = username;
        this.password = password;
        this.score = score;
    }

	//因为自己编写了构造方法，所以会覆盖掉Lombok插件自动创建的无参构造方法
	//因此需要自己再编写一个无参的构造方法
	public User() {}
}

三、准备日志工具Log4j

Log4j是MyBatis默认的日志处理方式

1、导入相应的Jar包

上面已经添加了相应的依赖Jar，所以这里不用再次添加

2、新建Log4j的配置文件

在资源文件中新建一个log4j.properties的配置文件


在配置文件中添加Log4j的基础配置属性

log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender 
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 
log4j.appender.stdout.layout.ConversionPattern=%5p %d %C: %m%n

log4j.logger.java.sql.ResultSet=INFO
log4j.logger.org.apache=INFO
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

四、MyBatis核心配置文件

注：后面会有一些优化，现在从基本一步一步的来

1、新建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>

    <!-- 配置开发环境信息 -->
    <environments default="mysql">

        <environment id="mysql">

            <!-- 使用JDBC事务管理器，目前由MyBatis管理 -->
            <transactionManager type="JDBC"/>

            <!-- 配置DataSource标准数据源，目前由MyBatis管理 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="wxc666888"/>
            </dataSource>

        </environment>

    </environments>

</configuration>

2、可能遇到的问题

1、MySQL版本问题

如果自己的MySQL版本是8.0以上，在配置driver与url需要书写如下：

driver：

com.mysql.cj.jdbc.Driver


url：

jdbc:mysql://localhost:3306/ssm?useSSL=false&useUnicode=true&characterEncoding=UTF-8


其中ssm属于自己的数据库名称，只需要修改成自己的数据库名称就行，剩余不用修改

3、对数据库的连接进行测试

在测试文件夹test下新建一个测试的包com.tjise.test



在包下新建一个测试的类



在测试类里对数据的连接进行测试

• 编写三个方法init()、destory()、testSession()
• init()方法用于获取数据库连接SqlSession，方法上方的@Before代表执行测试方法时先执行此方法，因为先获取连接才能对数据库进行操作，所以要先执行此方法
• destory()方法用于关闭连接，方法上方@After代表执行测试方法后执行此方法，因为对数据库操作完成后，为了不浪费资源，所以要关闭数据库的连接
• testSession方法是测试方法，测试数据是否连接成功，方法上方的@Test代表可以执行测测试方法，以上两个@Before、@After不能自己执行，需要@Test测试方法执行时才能执行

package com.tjise.test;

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;

public class SessionTest {

    private SqlSession session;

    @Before
    public void init() throws IOException {
        //通过Resources类加载和读取配置文件
        InputStream is = Resources.getResourceAsStream("mybatis.xml");

        //根据配置文件的信息创建SqlSessionFactory对象
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);

        //通过SqlSessionFactory获取SqlSession对象
        session = sessionFactory.openSession();
    }
    
    @Test
    public void testSession(){
        //输出session
        System.out.println(session);
        //输出session对应的Connection的连接
        System.out.println(session.getConnection());
    }
    
    @After
    public void destory(){
        //对连接进行关闭
        session.close();
    }
}

输出内容如下：


有如上的信息代表数据库连接成功！！！

4、mybatis.xml配置文件优化

把连接的主要信息driver、url、username、password进行提取出来，生成一个配置文件，这样对数据库进行修改时，可以更加方便的找出与修改，便于维护

新建一个名为jdbc-config.properties的配置文件，用户存放基础信息


在配置文件中写入基本的连接信息



其中的信息都是上方mybatis.xml配置文件中连接数据库的信息

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?useSSL=false&useUnicode=true&characterEncoding=UTF-8
jdbc.username=root
jdbc.password=wxc666888

既然将连接信息提取了出来，那么mybatis.xml配置文件中就要修改相应的信息

• 将配置文件导入到mybatis.xml中
• 修改相应的数据库连接信息
  
  

<!-- 导入属性文件 resource属性指定属性文件名 -->
	<properties resource="jdbc-config.properties"></properties>

<!-- 配置DataSource标准数据源，目前由MyBatis管理 -->
			<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>

修改完成后继续进行测试，看看是否配置成功，执行上面写的测试方法



执行结果还是上面的结果，代表配置成功

五、封装Util工具类

将获取数据库连接的操作封装在一个util类中，方便后期维护与使用

1、新建util包

名称为com.tjise.util

2、新建util类

类名为：MyBatisUtil

3、封装数据库的连接

其中都用了static（静态）的关键字

原因：在使用的时候，类加载时就初始化

package com.tjise.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 {

    private static SqlSessionFactory sessionFactory;

    static {

        try {
            //加载配置文件
            InputStream is = Resources.getResourceAsStream("mybatis.xml");

            //创建sessionFactory对象
            sessionFactory = new SqlSessionFactoryBuilder().build(is);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //获取session对象
    public static SqlSession openSession() {
        return sessionFactory.openSession();
    }
}

使用方法：每次想要获取数据库的连接时直接使用

//获取工具类的session对象（数据库连接）
SqlSession session = MyBatisUtil.openSession();

六、实现简单的增删改查操作

1、新建User类的SQL映射文件

• 创建映射文件存放的包——com.tjise.mapper
• 创建User的映射文件——UserMapper.xml
• 编写映射文件
• 将映射文件添加到mybatis.xml配置文件中

注：在resources资源文件中不能直接创建包，改为创建文件夹





注：因无法创建包，改为创建文件夹，所以要使用 / 隔开，创建多个文件夹



创建成功后，类似于包



创建UserMapper.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">

<!-- namespace属性相当于映射文件的名称 属性值任意-->
<mapper namespace="usermp">

    <!-- resultType属性指定结果的类型 -->
    <select id="findUserList" resultType="com.tjise.entity.User">
        select * from users
    </select>
    <!-- ParameType属性指定输入参数的类型
     如果参数类型是简单类型（基本 + String + date）#{xxx}里面的内容任意-->
    <select id="findUserById" resultType="com.tjise.entity.User" parameterType="int">
        select * from users where userid = #{userid}
    </select>

    <!-- 用${value}作为 里面的内容必须是value 利用的是String的存储方式（value[]数组）-->
    <select id="findUserByName" resultType="com.tjise.entity.User" parameterType="string">
        select * from users where username like '%${value}%'
    </select>

    <!-- 多条件查询利用map类型
        默认的参数类型是map-->
    <select id="findUserByScore" resultType="com.tjise.entity.User">
        select * from users where score between #{minScore} and #{maxScore}
    </select>

    <!-- pageSize 分页大小 currentPage当前页码 -->
    <select id="findUserByPage" resultType="com.tjise.entity.User">
        select * from users limit #{currentPage}, #{pageSize}
    </select>

    <!-- insert 插入数据 只有parameterType输入参数
        useGeneratedKeys属性指定开启自动填充功能
        keyProperty属性用于指定生成的主键值填充到类的哪个属性上 -->
    <insert id="insertUser" parameterType="com.tjise.entity.User" useGeneratedKeys="true" keyProperty="userid">
        insert into users values(null, #{username}, #{password}, #{score})
    </insert>

    <!-- update 同样只有输入参数parameterType-->
    <update id="updateUser" parameterType="com.tjise.entity.User">
        update users set username = #{username}, password = #{password}, score = #{score}
        where userid = #{userid}
    </update>

    <!-- delete 也是输入参数 -->
    <delete id="deleteUser" parameterType="int">
        delete from users where userid = #{userid}
    </delete>

</mapper>

注：其中resultType属性与parameterType属性的值分别为返回类型与参数类型，格式都是完整的包名


其中有一些默认的别名，可以直接使用，没有别名要使用完整的包名



注：完整包名的获取方式（可获取对象的完整包名）




将映射文件添加到mybatis.xml配置文件

<mappers>
        <mapper resource="com/tjise/mapper/UserMapper.xml"></mapper>
    </mappers>

注：同样mapper中resource属性值也是完整的包名

2、测试SQL映射文件——实现增删改查

新建增删改查的测试类


编写测试方法

package com.tjise.test;

import com.tjise.entity.User;
import com.tjise.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

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

public class CURDTest {

    private SqlSession session;

    @Before
    public void init(){
        //利用MyBatisUtil工具类获取数据库的连接
         session = MyBatisUtil.openSession();
    }

    //不带参数的查询
    @Test
    public void findUserListTest(){
        List<User> userList = session.selectList("userns.findUserList");
        System.out.println(userList);
    }

    //带一个参数
    @Test
    public void findUserByNameTest(){
        List<User> userList = session.selectList("userns.findUserByName", "user");
        System.out.println(userList);
    }

    //带多个参数
    @Test
    public void findUserByScoreTest(){
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("minScore", 60);
        map.put("maxScore", 100);
        List<User> userList = session.selectList("userns.findUserByScore", map);
        System.out.println(userList);
    }

    //实现分页效果
    @Test
    public void findUserByPage(){
        int pageSize = 2;
        int currentPage = 1;
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("pageSize", pageSize);
        map.put("currentPage", (currentPage - 1) * pageSize);
        List<User> userList = session.selectList("userns.findUserByPage", map);
        System.out.println(userList);
    }

    //插入数据
    @Test
    public void testInsertUser(){
        try {
            User user = new User("user7", "123456", 10);
            int rows = session.insert("userns.insertUser", user);
            System.out.println(rows);
            session.commit();
        } catch (Exception e) {
            session.rollback();
        }

    }

    //修改数据
    @Test
    public void testUpdateUser(){
        try {
            User user = session.selectOne("userns.findUserById", 8);
            user.setPassword("789");
            int rows = session.update("userns.updateUser", user);
            System.out.println(rows);
            session.commit();
        } catch (Exception e) {
            session.rollback();
        }
    }

    //修改数据
    @Test
    public void testDeleteUser(){
        try {
            int rows = session.delete("userns.deleteUser", 8);
            System.out.println(rows);
            session.commit();
        } catch (Exception e) {
            session.rollback();
            e.printStackTrace();
        }
    }

    @After
    public void destory(){
        //关闭连接
        session.close();
    }
}

注：selectList(“userns.findUserByName”, “user”) 第一个参数为映射文件中的namespace的属性值 . 具体SQL的id值 （中间是点连接）；第二个参数为查询时的参数值



执行测试方法


每个测试就不一一执行了，大家可以自己都试一下

3、优化映射文件——别名

返回类型值与参数类型值每次都要填写完整的包名，很麻烦，所以可以利用别名进行简化，就想系统定义的别名一样

在mybatis.xml中编写别名，一共两种方法

第一种：手动为每个实体类编写别名

<!-- 其中type为完整的包名 alias为别名 -->
    <typeAliases>
        <typeAlias type="com.tjise.entity.User" alias="user"/>
    </typeAliases>

第二种：自动为包下的所有实体类都起别名：别名的格式为类名第一个字母小写，例如：实体类为：User 对应的 别名为：user

    <typeAliases>
        <package name="com.tjise.entity"/>
    </typeAliases>

修改完别名后就可以直接使用别名


在映射文件中修改为别名



修改完后继续测试一下是否修改正确


同样利用上面的测试类，能测试成功，说明修改正确

七、Mapper接口代理开发模式

使用Mapper接口代理的好处：可以简化操作数据库的步骤，不用自己去写dao层（数据库操作工具）的实现类，只写一个操作的mapper接口即可

1、新建一个存放mapper接口的包

注：包名要与下方UserMapper的映射文件相同（重要）

2、新建一个mapper接口

注：类名要与下方UserMapper的名称相同（重要）

3、编写mapper接口

例如实现映射文件中的这个方法


需要编写为如下：


注：接口的方法名要与实现的功能id相同，参数与返回类型都要相同

4、修改相应的映射文件

因为用了Mapper接口代理方法开发，所以映射文件中的namespace属性值改为mapper接口UserMapper的完整包名

5、测试

新建一个测试类


编写测试类

package com.tjise.test;

import com.tjise.entity.User;
import com.tjise.mapper.UserMapper;
import com.tjise.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

public class MapperTest {
    //数据库连接
    private SqlSession session;
    //mapper接口
    private UserMapper userMapper;

    @Before
    public void init(){
        //利用MyBatisUtil工具类获取数据库的连接
        session = MyBatisUtil.openSession();
        //获取到UserMapper的接口
        userMapper = session.getMapper(UserMapper.class);
    }

    @Test
    public void findUserList(){
        List<User> userList = userMapper.findUserList();
        System.out.println(userList);
    }


    @After
    public void destory(){
        //关闭连接
        session.close();
    }
}

控制台显示如下信息，代表Mapper接口代理的方式实现完成

八、最后

感谢大家的查询查看，如果在实现过程中有任何问题，都可以在下方留言，我都会去看，如果想要源码的也可以留言！！！