mybatis-环境搭建

0 目录

image-20240219205704269

1 Maven工程

  1. 设置打包方式

    1
    2
    3
    4
    <groupId>com.xxxx.xxx</groupId>
    <artifactId>MyBatis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

  2. 引入依赖

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    <dependencies>
      <!-- Mybatis核心 -->
      <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
      </dependency>
      <!-- junit测试 -->
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
      </dependency>
      <!-- MySQL驱动 -->
      <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.23</version>
      </dependency>
    </dependencies>

2 数据库准备

1
2
3
4
5
6
7
8
9
10
CREATE TABLE `t_user` (
  `id` int NOT NULL AUTO_INCREMENT,
  `username` varchar(20) COLLATE utf8mb4_general_ci DEFAULT NULL,
  `password` varchar(20) COLLATE utf8mb4_general_ci DEFAULT NULL,
  `age` int DEFAULT NULL,
  `gender` char(1) COLLATE utf8mb4_general_ci DEFAULT NULL,
  `email` varchar(50) COLLATE utf8mb4_general_ci DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

3 创建Mybatis核心文件

核心文件取名：mybatis-config.xml，存放位置src/main/resources

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?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="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入mybatis映射文件-->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

4 实体类、mapper接口

  1. 实体类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    @Data
    public class User {

      private Integer id;

      private String username;

      private String password;

      private Integer age;

      private String gender;

      private String email;
    }

  2. mapper接口

    1
    2
    3
    4
    5
    public interface UserMapper {
        //添加用户信息
        int insertUser();
    }

5 映射文件

  1. mapper接口的全类名和映射文件的命名空间（namespace）保持一致，在resource下使用/代替.
  2. mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致

UserMapper.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?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.xxxx.xxx.mapper.UserMapper">

    <!--
        mapper接口和映射文件要保证两个一致：
        1.mapper接口的全类名和映射文件的namespace一致
        2.mapper接口中的方法的方法名要和映射文件中的sql语句的id保持一致
    -->

    <!--添加-->
    <insert id="insertUser">
        insert into t_user values(null,'张三','123',23,'男',"123@163.com")
    </insert>

</mapper>

6 测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class MyBatisTest {
  @Test
  public void testInsertUser() throws IOException {
      //获取核心配置文件的输入流
      InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
      //获取SqlSessionFactoryBuilder对象
      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      //获取SqlSessionFactory对象
      SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
      //获取sql的会话对象SqlSession(不会自动提交事务)，是MyBatis提供的操作数据库的对象
      SqlSession sqlSession = sqlSessionFactory.openSession();
      //获取sql的会话对象SqlSession(会自动提交事务)，是MyBatis提供的操作数据库的对象
      //SqlSession sqlSession = sqlSessionFactory.openSession(true);
      //获取UserMapper的代理实现对象getMapper(Class<T> var1)
      UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
      //调用mapper接口中的方法，实现添加用户信息的功能
      int result = userMapper.insertUser();
      //通过sql语句的唯一标识找到sql并执行，唯一标识是namespace.sqlId
      //int result = sqlSession.insert("com.xxxx.lln.mapper.UserMapper.insertUser");
      System.out.println("返回结果："+result);
      //提交事务
      sqlSession.commit();
      //关闭会话
      sqlSession.close();
  }

}

7 日志

  1. 引入依赖

    1
    2
    3
    4
    5
    6
    7
    <!-- log4j日志 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>

  2. log4j.xml，位置src/main/resources

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
    <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
        <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
            <param name="Encoding" value="UTF-8" />
            <layout class="org.apache.log4j.PatternLayout">
                <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS}
    %m (%F:%L) \n" />
            </layout>
        </appender>
        <logger name="java.sql">
            <level value="debug" />
        </logger>
        <logger name="org.apache.ibatis">
            <level value="info" />
        </logger>
        <root>
            <level value="debug" />
            <appender-ref ref="STDOUT" />
        </root>
    </log4j:configuration>

8 工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class SqlSessionUtil {
  public static SqlSession getSqlSession(){
      //创建sql的会话对象SqlSession
      SqlSession sqlSession = null;
      try {
          //获取核心配置文件的输入流
          InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
          //获取SqlSessionFactoryBuilder对象
          SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
          //获取SqlSessionFactory对象
          SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
          //配置sql的会话对象SqlSession(会自动提交事务)，是MyBatis提供的操作数据库的对象
          sqlSession = sqlSessionFactory.openSession(true);
      } catch (IOException e) {
          e.printStackTrace();
      }
      return sqlSession;
  }
}

9 增删改查

  1. mapper接口

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public interface UserMapper {

      //添加用户信息
      int insertUser();

      //删除用户信息
      void deleteUser();

      //修改用户信息
      void updateUser();

      //通过id查询一个实体类对象
      User getUserById();

      //查询实体类集合
      List<User> getUserList();

    }

  2. xml文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    <?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.xxxx.xxx.mapper.UserMapper">

        <!--
            mapper接口和映射文件要保证两个一致：
            1.mapper接口的全类名和映射文件的namespace一致
            2.mapper接口中的方法的方法名要和映射文件中的sql语句的id保持一致
        -->

        <!--添加用户信息-->
        <insert id="insertUser">
            insert into t_user values(null,'张三','123',23,'男',"123@163.com")
        </insert>

        <!--删除用户信息-->
        <delete id="deleteUser">
            delete from t_user where id = 2
        </delete>

        <!--修改用户信息-->
        <update id="updateUser">
            update t_user set username='ybc',password='123' where id = 3
        </update>

        <!--
            resultType：自动映射，用于属性名和表中字段名一致的情况
            resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况
        -->

        <!--通过id查询一个实体类对象-->
        <select id="getUserById" resultType="com.xxxx.lln.pojo.User">
            select * from t_user where id = 3
        </select>

        <!--查询实体类集合-->
        <select id="getUserList" resultType="com.xxxx.lln.pojo.User">
            select * from t_user
        </select>

    </mapper>

  3. 代码测试

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    public class MyBatisTest {

        /**
         * 测试添加用户信息
         * @throws IOException
         */
        @Test
        public void testInsertUser() throws IOException {
            //获取核心配置文件的输入流
            InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
            //获取SqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            //获取SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
            //获取sql的会话对象SqlSession(不会自动提交事务)，是MyBatis提供的操作数据库的对象
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //获取sql的会话对象SqlSession(会自动提交事务)，是MyBatis提供的操作数据库的对象
            //SqlSession sqlSession = sqlSessionFactory.openSession(true);
            //获取UserMapper的代理实现对象getMapper(Class<T> var1)
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            //调用mapper接口中的方法，实现添加用户信息的功能
            int result = userMapper.insertUser();
            //通过sql语句的唯一标识找到sql并执行，唯一标识是namespace.sqlId
            //int result = sqlSession.insert("com.xxxx.lln.mapper.UserMapper.insertUser");
            System.out.println("返回结果："+result);
            //提交事务
            sqlSession.commit();
            //关闭会话
            sqlSession.close();
        }


        /**
         * 测试删除用户信息
         */
        @Test
        public void testDeleteUser(){
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            userMapper.deleteUser();
            sqlSession.close();
        }


        /**
         * 测试修改用户信息
         */
        @Test
        public void testUpdateUser(){
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            userMapper.updateUser();
            sqlSession.close();
        }


        /**
         * 通过id查询一个实体类对象
         */
        @Test
        public void testGetUserById(){
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            User user = userMapper.getUserById();
            System.out.println(user);
            sqlSession.close();
        }

        /**
         * 查询实体类对象集合
         */
        @Test
        public void testGetUserList(){
            SqlSession sqlSession = SqlSessionUtil.getSqlSession();
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            List<User> userList = userMapper.getUserList();
    		userList.forEach(System.out::println);
            sqlSession.close();
        }


    }

  1. 查询的标签select必须设置属性resultType或resultMap，用于设置实体类和数据库表的映射关系

    1. resultType：自动映射，用于属性名和表中字段名一致的情况
    2. resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况

  2. 当查询的数据为多条时，不能使用实体类作为返回值，只能使用集合，否则会抛出异常

    TooManyResultsException；但是若查询的数据只有一条，可以使用实体类或集合作为返回值

10 核心文件详解

顺序：

properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,

reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
<?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>


    <!--引入properties文件，此时就可以${属性名}的方式访问属性值-->
    <properties resource="jdbc.properties"></properties>

    <settings>
        <!--将表中字段的下划线自动转换为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>



    <typeAliases>
        <!--
            typeAlias：设置某个具体的类型的别名
            属性： type：需要设置别名的类型的全类名
            alias：设置此类型的别名，若不设置此属性，该类型拥有默认的别名，即类名且不区分大小写
            若设置此属性，此时该类型的别名只能使用alias所设置的值
        -->
        <!--<typeAlias type="com.atguigu.mybatis.bean.User"></typeAlias>-->
        <!--<typeAlias type="com.atguigu.mybatis.bean.User" alias="abc"> </typeAlias>-->
        <!--以包为单位，设置改包下所有的类型都拥有默认的别名，即类名且不区分大小写-->
        <package name="com.atguigu.mybatis.bean"/>
    </typeAliases>


    <!--environments：设置多个连接数据库的环境 属性： default：设置默认使用的环境的id -->

    <environments default="mysql_test">
        <!--
            environment：设置具体的连接数据库的环境信息
            属性： id：设置环境的唯一标识，可通过environments标签中的default设置某一个环境的id， 表示默认使用的环境
        -->
        <environment id="mysql_test">
            <!--
                transactionManager：设置事务管理方式 属性：
                type：设置事务管理方式，type="JDBC|MANAGED" type="JDBC"：设置当前环境的事务管理都必须手动处理
                type="MANAGED"：设置事务被管理，例如spring中的AOP
            -->
            <transactionManager type="JDBC"/>


            <!--
                dataSource：设置数据源
                属性：type：设置数据源的类型，type="POOLED|UNPOOLED|JNDI"
                type="POOLED"：使用数据库连接池，即会将创建的连接进行缓存，下次使用可以从缓存中直接获取，不需要重新创建
                type="UNPOOLED"：不使用数据库连接池，即每次使用连接都需要重新创建
                type="JNDI"：调用上下文中的数据源
            -->
            <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>
        </environment>
    </environments>



    <!--引入映射文件-->
    <mappers>
        <mapper resource="UserMapper.xml"/>
        <!--
            以包为单位，将包下所有的映射文件引入核心配置文件
            注意：此方式必须保证mapper接口和mapper映射文件必须在相同的包下
            接口名和映射文件名字一致
            创建包的时候以斜线为分隔符
        -->
        <package name="com.atguigu.mybatis.mapper"/>
    </mappers>


</configuration>
mybatis
#mybatis
mybatis-环境搭建
https://baijianglai.cn/mybatis-环境搭建/64bafa7e8456/
作者
Lai Baijiang
发布于
2024年2月19日
许可协议