JavaSSM-Mybatis框架使用

最新推荐文章于 2023-04-02 22:12:41 发布

怡人蝶梦

最新推荐文章于 2023-04-02 22:12:41 发布

阅读量810

点赞数

分类专栏： JAVA 文章标签： 1024程序员节 java ssm

本文链接：https://blog.csdn.net/yirenDM/article/details/127491656

版权

JAVA 专栏收录该内容

14 篇文章 2 订阅

订阅专栏

Mybatis

官方地址

mybatis中文文档
 mybatis Github地址

Mybatis简介

MyBatis 是一款优秀的持久层框架
它支持自定义 SQL、存储过程以及高级映射。
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

Maven POM

<!--maven仓库最新-->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.11</version>
</dependency>

为什么需要Mybatis?

内存断电即失,数据持久化存储到数据库中
简化JDBC代码
SQl和代码分离,解耦,提高可维护性
提供映射标签，支持对象与数据库的ORM字段关系映射。
提供对象关系映射标签，支持对象关系组建维护。
提供xml标签，支持编写动态sql
最近主流持久层框架

Mybatis CRUD操作

导入Maven依赖

<!--mysql driver-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.46</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>
    <!--junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

创建数据库与表

create database mybatis;
use mybatis;
create table user(
    id int(20) not null primary key,
    name varchar(30) default null,
    pwd varchar(30) default null
)ENGINE=INNODB DEFAULT CHARSET=utf8;

mybatis-config.xml

<configuration>
    <environments default="development">
        <!--配置mysql数据库-->
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="****"/>
                <property name="password" value="****"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

获得SqlSession对象

/**
 * @author zbq
 * @date 2022/10/3 14:16
 * 每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。
 * 而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。
 * 从 XML 文件中构建 SqlSessionFactory 的实例非常简单，建议使用类路径下的资源文件进行配置。 但也可以使用任意的输入流（InputStream）实例，比如用文件路径字符串或 file:// URL 构造的输入流。MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易。
 */
//sqlSessionFactory -- sqlSession
public class MybatisUtils {
    public static SqlSessionFactory sqlSessionFactory=null;
    static{
        try {
            //获取sqlSessionFactory对象
            //下面代码来自官方文档,读取xml文件创建输入流,用sqlSessionFactoryBuilder创建sqlSessionFactory
            String resource = "mybatis-config.xml";
            InputStream inputStream = null;
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例.
    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

创建pojo实体类

package com.zhang.pojo;

/**
 * @author zbq
 * @date 2022/10/3 14:28
 * 实体类
 */
public class User {
    private int id;
    private String name;
    private String pwd;

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

创建dao层 UserMapper

package com.zhang.dao;

import com.zhang.pojo.User;
import java.util.List;
import java.util.Map;

/**
 * @author zbq
 * @date 2022/10/3 14:31
 */
public interface UserMapper {
    //获取全部用户
    List<User> getUserList();
    User getUserById(int id);
    int addUser(User user);
    int updateUser(User user);
    int deleteUser(int id);
}

编写UserMapper.xml

namespace
- namespace中的包名要和mapper接口的包名一致
属性
- id对应namespace中的方法名
- resultType: sql语句执行返回值
- parameterType: 传递参数类型
  - 当参数类型为普通类型如User getUserById(int id);获取参数#{id}
  - 当参数类型为对象类型 int updateUser(User user);获取参数写对象的属性 #{id},#{name},#{pwd}
增删改需要提交事务 :sqlSession.commit();

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.zhang.dao.UserMapper">
    <!--id对应方法  resultType:sql语句返回值 parameterType-->
    <select id="getUserList" resultType="com.zhang.pojo.User">
        select * from mybatis.user
    </select>

    <select id="getUserById" parameterType="int" resultType="com.zhang.pojo.User">
        <!--函数参数为id 所以写作#{id}-->
        select * from mybatis.user where id = #{id}
    </select>

    <insert id="addUser" parameterType="com.zhang.pojo.User">
        insert into mybatis.user(id,name,pwd) values(#{id},#{name},#{pwd});
    </insert>
    <update id="updateUser" parameterType="com.zhang.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id =#{id};
    </update>
    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id =#{id}
    </delete>
</mapper>

在Mybatis核心配置文件中注册 UserMapper.xml

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/zhang/dao/UserMapper.xml"/>
    </mappers>

测试

package com.zhang.dao;

import com.zhang.pojo.User;
import com.zhang.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

/**
 * @author zbq
 * @date 2022/10/4 15:15
 * 第一步通过MybatisUtils工具类获取SqlSession对象
 * 第二步通过sqlSession.getMapper()获得指定接口映射器
 * 第三步通过接口映射器执行方法,mybatis会自动执行xml中的对应sql
 */
public class UserDaoTest {
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        for (User user : mapper.getUsers()) {
            System.out.println(user);
        }
        sqlSession.close();
    }

    @Test
    public void getUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);
        sqlSession.close();
    }

    @Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.addUser(new User(5,"zzz","123456"));
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void updateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.updateUser(new User(5,"aaa","hhh"));
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void deleteUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.deleteUser(1);
        sqlSession.commit();
        sqlSession.close();
    }
}

maven静态资源过滤

<build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

万能的Map

实体类,字段或者参数过多,应当考虑使用map

int addUser2(Map<String,Object> map);

<select id="addUser2" parameterType="map">
    insert into mybatis.user (id,name,pwd) values (#{userid},#{username},#{password})
</select>

    @Test
    public void addUser2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map=new HashMap<String,Object>();
        map.put("userid",10);
        map.put("username","alex");
        map.put("password","123456");
        mapper.addUser2(map);
        sqlSession.commit();
        sqlSession.close();
    }

考虑当数据库表字段有100多个,只需要修改其中一个时候,使用map,传递id和要修改的字段名即可完成
通过map实现分页操作

配置解析

核心配置文件 mybatis-config.xml

configuration（配置）
- properties（属性）
- settings（设置）
- typeAliases（类型别名）
- typeHandlers（类型处理器）
- objectFactory（对象工厂）
- plugins（插件）
- environments（环境配置）
  - environment（环境变量）
    - transactionManager（事务管理器）
    - dataSource（数据源）
- databaseIdProvider（数据库厂商标识）
- mappers（映射器）

environments（环境配置）

MyBatis 可以配置成适应多种环境
尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
事务管理器（transactionManager）:
- JDBC(默认)
- MANAGED
dataSource（数据源）
- UNPOOLED
- POOLED(默认)
- JNDI

属性（properties）

通过properties属性引用外部配置文件
创建db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8
username=****
password=****

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--引入外部配置文件-->
    <properties resource="db.properties"/>
    <environments default="development">
        <!--配置mysql数据库-->
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--读取外部配置文件,实现解耦-->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

类型别名（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。它仅用于 XML 配置，意在降低冗余的全限定类名书写。

第一种,为每个类起别名

<!--起别名,减轻全限定类名的冗余-->
<typeAliases>

    <typeAlias alias="User" type="com.zhang.pojo.User"></typeAlias>
</typeAliases>

第二种指定一个包名

<typeAliases>
    <!--在没有注解的情况下，会使用Java Bean 的首字母小写的非限定类名来作为它的别名-->
    <package name="com.zhang.pojo"/>
</typeAliases>

常见的java内建类型别名
| 别名 | 映射名 |
使用注解
```
@Alias("user")
public class User(){}
```

设置（settings）

cacheEnabled
lazyLoadingEnabled
logImpl

映射器（mappers）

第一种

<!-- 使用相对于类路径的资源引用 可以放到任意位置-->
<mappers>
<mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
<mapper resource="org/mybatis/builder/BlogMapper.xml"/>
<mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

第二种

<!-- 使用映射器接口实现类的完全限定类名  mapper和mapper.xml在同一包下下 接口和xml文件同名-->
<mappers>
<mapper class="org.mybatis.builder.AuthorMapper"/>
<mapper class="org.mybatis.builder.BlogMapper"/>
<mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

第三种

<!-- 将包内的映射器接口全部注册为映射器 同包 同名-->
<mappers>
<package name="org.mybatis.builder"/>
</mappers>

生命周期和作用域

作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder

* 这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了

SqlSessionFactory

* 类似数据库连接池
* SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
* SqlSessionFactory 的最佳作用域是应用作用域
* 最简单的就是使用单例模式或者静态单例模式。

SqlSession

* 连接到连接池的一个请求.
* SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域
* 用完后需要关闭,否则会造成资源浪费

解决属性名和数据库字段名不一致问题

数据库字段名 id,name,pwd
实体类属性名 uid,uname,upwd.

通过sql语句起别名解决

    <select id="getUserById" parameterType="int" resultType="User">
        select id as uid,name as uname,pwd as upwd from mybatis.user where id = #{id}
    </select>

ResultMap

resultMap 元素是 MyBatis 中最重要最强大的元素
ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
Now if only the world was always that simple.

    <resultMap id="UserMap" type="User">
        <!--column对应数据库字段 property对应实体类属性-->
        <result column="id" property="uid"/>
        <result column="name" property="uname"/>
        <result column="pwd" property="upwd"/>
    </resultMap>
    <select id="getUserById" resultMap="UserMap">
        select * from mybatis.user where id= #{id}
    </select>

日志使用

log4j

导入依赖

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

log4j.properties

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/zhang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd HH:mm:ss}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

配置

<settings>
    <!--SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING-->
    <!--标准的日志工厂实现-->
    <!--<setting name="logImpl" value="STDOUT_LOGGING"/>-->
    <!--log4j-->
    <setting name="logImpl" value="LOG4J"/>
</settings>

注解开发

导入pom依赖
编写mybatis-config.xml

dao层 BeanMapper 注解开发

package com.zhang.dao;

import com.zhang.pojo.User;
import org.apache.ibatis.annotations.*;

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

/**
* @author zbq
* @date 2022/10/3 14:31
*/
public interface UserMapper {
    @Select("select id as uid,name as uname,pwd as upwd from user")
    List<User> getUsers();

    //#{id}中的id从@Param中取
    @Select("select * from user where id =#{id}")
    User getUserById(@Param("id") int id);

    @Insert("insert into user values(#{uid},#{uname},#{upwd})")
    int addUser(User user);

    @Update("update user set name=#{uname},pwd=#{upwd} where id=#{uid}")
    int updateUser(User user);

    @Delete("delete from user where id =#{uid}")
    int deleteUser(@Param("uid") int id);
}

去核心配置文件中注册mapper
测试使用
SqlSession openSession(boolean autoCommit); 在获取sqlSession时可以调用重载方法传递true实现自动commit
@Param注解用于给方法参数起一个名字。以下是总结的使用原则：
- 基本类型参数或者String类型,需要加上
- 引用类型不用加
- 在方法只接受一个参数的情况下，可以不使用@Param,建议写上
- SQL中引用的就是@Param()中设定的属性名

多对一处理

场景: 多个学生只有一个老师
pojo类:

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private int id;
    private String name;
    private Teacher teacher;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Teacher {
    private int id;
    private String name;
    
}

StudentMapper

public interface StudentMapper {
    public List<Student> getStudent();
}

StudentMapper.xml

<!--全部查询完后封装为Student-->
<select id="getStudent" resultMap="StudentTeacher">
        select s.id sid,s.name sname,t.id tid,t.name tname
        from student s,teacher t
        where s.tid=t.id;
    </select>
    <resultMap id="StudentTeacher" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"/>
            <result property="id" column="tid"/>
        </association>
    </resultMap>

一对多处理

场景: 一个老师有多个学生
pojo

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private int id;
    private String name;
    private int tid;

}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Teacher {
    private int id;
    private String name;
    private List<Student> students;

}

TeacherMapper

public interface TeacherMapper {
    Teacher getTeacher(@Param("tid") int id);
}

TeahcerMapper.xml

    <select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid,s.name sname,t.name tname,t.id tid from student s,teacher t
        where s.tid=t.id and t.id=#{tid}
    </select>
    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <collection property="students" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

动态SQL

<select id="findActiveBlogWithTitleLike" resultType="Blog">
    SELECT * FROM BLOG WHERE state = ‘ACTIVE’
    <if test="title != null">
        AND title like #{title}
    </if>
</select>

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG WHERE state = ‘ACTIVE’
  <if test="title != null">
    AND title like #{title}
  </if>
  <if test="author != null and author.name != null">
    AND author_name like #{author.name}
  </if>
</select>

choose (when, otherwise)

有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。
<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG WHERE state = ‘ACTIVE’
  <choose>
    <when test="title != null">
      AND title like #{title}
    </when>
    <when test="author != null and author.name != null">
      AND author_name like #{author.name}
    </when>
    <otherwise>
      AND featured = 1
    </otherwise>
  </choose>
</select>

trim (where, set)
- where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG
  <where>
    <if test="state != null">
         state = #{state}
    </if>
    <if test="title != null">
        AND title like #{title}
    </if>
    <if test="author != null and author.name != null">
        AND author_name like #{author.name}
    </if>
  </where>
</select>

foreach
- 动态 SQL 的另一个常见使用场景是对集合进行遍历
- 当使用可迭代对象或者数组时，index 是当前迭代的序号，item 的值是本次迭代获取到的元素。当使用 Map 对象（或者 Map.Entry 对象的集合）时，index 是键，item 是值。
- collection:指定输入对象中的集合属性
  item:每次遍历生成的对象
  open:开始遍历时的拼接字符串
  close:结束时拼接的字符串
  separator:遍历对象之间需要拼接的字符串

<select id="selectPostIn" resultType="domain.blog.Post">
  SELECT *
  FROM POST P
  <where>
    <foreach item="item" index="index" collection="list"
        open="ID in (" separator="," close=")" nullable="true">
          #{item}
    </foreach>
  </where>
</select>

怡人蝶梦

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
JavaSSM-Mybatis框架使用

MyBatis 是一款优秀的持久层框架它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
复制链接

扫一扫