从零开始 Spring Boot 25：MyBatis II

最新推荐文章于 2024-02-22 14:53:57 发布
最新推荐文章于 2024-02-22 14:53:57 发布
阅读量521 收藏
点赞数
分类专栏： JAVA 文章标签： mybatis spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hy6533/article/details/127557431
版权

从零开始 Spring Boot 25：MyBatis II

spring boot

图源：简书 (jianshu.com)

在从零开始 Spring Boot 23：MyBatis - 红茶的个人站点 (icexmoon.cn)中我介绍了MyBatis的一些基本功能和用法，下文介绍遗漏的部分。

本文的示例代码都基于从零开始 Spring Boot 24：处理时间 - 红茶的个人站点 (icexmoon.cn)的最终示例修改而来，可以通过learn_spring_boot/ch24 (github.com)获取相应的代码。

TypeHandler

在之前的文章中，已经介绍过类型处理器（type handler）的基本用法，可以通过在resultMap中对特定字段映射添加typeHandler的方式来实现读取特定字段的特殊处理：

<?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="cn.icexmoon.books2.book.mapper.CouponMapper">
    <select id="getCouponById" resultMap="couponResult">
        SELECT * FROM
            coupon
        WHERE id=#{id} AND del_flag=0
    </select>
    <resultMap id="couponResult" type="cn.icexmoon.books2.book.entity.Coupon">
        <result property="type" column="type" typeHandler="cn.icexmoon.books2.book.entity.typehandler.CouponTypeHandler"></result>
        <discriminator javaType="int" column="type">
            <case value="1" resultType="cn.icexmoon.books2.book.bo.FreeCoupon">
            </case>
            <case value="2" resultType="cn.icexmoon.books2.book.bo.EnoughCoupon">
            </case>
        </discriminator>
    </resultMap>
    <insert id="addCoupon" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO coupon(add_user_id,add_time,amount,expire_time,enough_amount,`type`,del_flag)
        VALUES (#{coupon.addUserId},#{coupon.addTime},#{coupon.amount,javaType=double,jdbcType=NUMERIC,numericScale=2},#{coupon.expireTime},#{coupon.enoughAmount},#{coupon.type,typeHandler=cn.icexmoon.books2.book.entity.typehandler.CouponTypeHandler},0)
    </insert>
</mapper>

当然，写入的时候也一样，上边的示例同样说明了这一点。

之所以这里需要这么做，是因为对于枚举类型，MyBatis默认会使用EnumOrdinalTypeHandler或EnumTypeHandler处理器来进行处理，前者会让枚举转化为枚举在enum中的定义顺序，后者会将枚举转换为枚举的字面量。

可以从mybatis – MyBatis 3 | 配置页面查看MyBatis所有默认的类型处理器列表。

更常见的是，我们会采用以下方式定义的枚举：

package cn.icexmoon.books2.book.entity.enums;
// ...
public enum CouponType implements IDesc<Integer> {
    FREE_COUPON(1, "无门槛券"), ENOUGH_COUPON(2, "满减券");
    @JsonValue
    private Integer value;
    private String desc;

    public Integer getValue() {
        return value;
    }

    public String getDesc() {
        return desc;
    }

    CouponType(Integer value, String desc) {
        this.value = value;
        this.desc = desc;
    }

    public static CouponType match(Integer value) {
        for (CouponType ct : CouponType.values()) {
            if (ct.getValue().equals(value)) {
                return ct;
            }
        }
        return null;
    }
}

这里的IDesc是一个为了方便获取自定义枚举值和中文名称而定义的接口：

package cn.icexmoon.books2.system;
// ...
public interface IDesc<T> {
    T getValue();

    String getDesc();
}

所以这里我们希望MyBatis能默认将实现了IDesc接口的枚举转换为IDesc.getValue返回的值存储，或者以相反的方式读取。

就像之前一样，我们可以创建一个类型处理器来完成这件事：

package cn.icexmoon.books2.system.typehandler;
// ...
@MappedTypes(IDesc.class)
public class IDescEnumTypeHandler<E extends Enum<E> & IDesc<Integer>> extends BaseTypeHandler<E> {
    private Class<E> type;

    public IDescEnumTypeHandler(Class<E> type) {
        this.type = type;
    }


    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, E parameter, JdbcType jdbcType) throws SQLException {
        if (jdbcType == null) {
            ps.setInt(i, parameter.getValue());
        } else {
            ps.setObject(i, parameter.getValue(), jdbcType.TYPE_CODE);
        }

    }

    @Override
    public E getNullableResult(ResultSet rs, String columnName) throws SQLException {
        int i = rs.getInt(columnName);
        return MyEnumUtil.getIEnumInstance(type, i);
    }

    @Override
    public E getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        int i = rs.getInt(columnIndex);
        return MyEnumUtil.getIEnumInstance(type, i);
    }

    @Override
    public E getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        int i = cs.getInt(columnIndex);
        return MyEnumUtil.getIEnumInstance(type, i);
    }
}

不同的是，这里使用了泛型，表明这是一个能够处理实现了IDesc接口的枚举类型的类型处理器：

IDescEnumTypeHandler<E extends Enum<E> & IDesc<Integer>> extends BaseTypeHandler<E>

实际上应当使用IDesc<?>而非IDesc<Integer>，但前者需要在具体实现中处理类型转换的问题，暂时没想到如何处理，所以只能特异化采用后者。

为了让MyBatis能够在需要的时候自动使用这个处理器，而不是手动指定，需要通过@MappedTypes注解添加该处理器能够处理的类型。

此外，还需要通过配置文件将处理器所在包加入MyBatis相关配置，以添加到MyBatis的默认处理器中：

mybatis.type-handlers-package=cn.icexmoon.books2.system.typehandler

现在重启项目后MyBatis就可以自动处理实现了IDesc接口的自定义枚举类型，而不需要在XML中手动指定typeHandler属性了。

MyBatisPlus实现了上述功能，如果集成了MyBatisPlus，可以通过实现IEnum接口来实现自定义枚举，不需要自己实现类型处理器。

动态SQL

这里所谓的动态SQL实际上就是MyBatis拼接SQL时的流程控制语句，其用途和写法和编程语言中的控制语句相似。

if

if标签常用于在SQL中拼接查询条件：

<select id="pageBooks" resultMap="bookResult3">
        SELECT b.*,u.id AS u_id,u.name AS u_name,u.password AS u_password,u.open_id AS u_open_id,u.real_name AS u_real_name,u.icon AS u_icon,u.dept_id AS u_dept_id,u.del_flag AS u_del_flag
        FROM book AS b
                 LEFT JOIN `user` AS u
                           ON b.user_id=u.id
        WHERE b.del_flag=0
          AND u.del_flag=0
          <if test="dto.userName != null and dto.userName != ''">
            AND u.name LIKE CONCAT('%',#{dto.userName},'%')
          </if>
          <if test="dto.bookName != null and dto.bookName != ''">
            AND b.name LIKE CONCAT('%',#{dto.bookName},'%')
          </if>
          <if test="dto.desc != null and dto.desc != ''">
            AND b.desc LIKE CONCAT('%',#{dto.desc},'%')
          </if>
          <if test="dto.type != null">
              AND b.type = #{dto.type.value}
          </if>
            LIMIT #{start},#{limit};
    </select>

这里dto对应以下类型：

package cn.icexmoon.books2.book.entity.dto;
// ...
@Data
@NoArgsConstructor
public class BookQueryDTO {
    private String userName;
    private String bookName;
    private String desc;
    private CouponType type;
}

BookQueryDTO表示一个查询书籍的条件，包含书籍名称、录入书籍人员姓名等，显然这些条件是可选的，在查询时可能有一个或没有，也可能都存在。所以在XML中使用if来判断条件是否存在，进而完成查询语句的拼接。

需要注意的是，在if的test属性中，如果存在多个条件，使用and或or进行逻辑运算，而不是Java常见的&&和||，这是因为&是XML的保留字符，需要进行转义，所以最好不要使用。

choose

choose标签的用途类似于编程语言中的switch语句，可以从众多执行块中匹配一个条件符合的执行：

<select id="pageBooks" resultMap="bookResult3">
        SELECT b.*,u.id AS u_id,u.name AS u_name,u.password AS u_password,u.open_id AS u_open_id,u.real_name AS u_real_name,u.icon AS u_icon,u.dept_id AS u_dept_id,u.del_flag AS u_del_flag
        FROM book AS b
                 LEFT JOIN `user` AS u
                           ON b.user_id=u.id
        WHERE b.del_flag=0
          AND u.del_flag=0
          <choose>
              <when test="dto.bookId != null and dto.bookId > 0">
                  AND b.id = #{dto.bookId}
              </when>
              <otherwise>
                  <if test="dto.bookName != null and dto.bookName != ''">
                    AND b.name LIKE CONCAT('%',#{dto.bookName},'%')
                  </if>
                  <if test="dto.userName != null and dto.userName != ''">
                    AND u.name LIKE CONCAT('%',#{dto.userName},'%')
                  </if>
                  <if test="dto.desc != null and dto.desc != ''">
                    AND b.desc LIKE CONCAT('%',#{dto.desc},'%')
                  </if>
                  <if test="dto.type != null">
                      AND b.type = #{dto.type.value}
                  </if>
              </otherwise>
          </choose>
            LIMIT #{start},#{limit};
    </select>

在这个修改后的示例中，添加了一个新的查询条件bookId，并且通过引入choose标签，实现了如果查询条件中有有效的bookId，则无视其他查询条件，按照id查询图书信息并返回。

这里when标签的作用类似于case，用于匹配一个条件。otherwise标签的用途类似于default。

当然，就像switch...case那样，你可以添加多个when标签，这里仅有一个when和otherwise的情况其实起到了if...else的用途。

where

如果你已经很熟悉在代码中拼接SQL的写法，那肯定对在WHERE语句开头保留至少一个固定条件的必要性有深刻认识，比如上边示例中的：

        WHERE b.del_flag=0
          AND u.del_flag=0

如果所有条件都是动态生成的，比如：

        WHERE 
          <choose>
              <when test="dto.bookId != null and dto.bookId > 0">
                  AND b.id = #{dto.bookId}
              </when>
              <otherwise>
                  <if test="dto.bookName != null and dto.bookName != ''">
                    AND b.name LIKE CONCAT('%',#{dto.bookName},'%')
                  </if>
                  <if test="dto.userName != null and dto.userName != ''">
                    AND u.name LIKE CONCAT('%',#{dto.userName},'%')
                  </if>
                  <if test="dto.desc != null and dto.desc != ''">
                    AND b.desc LIKE CONCAT('%',#{dto.desc},'%')
                  </if>
                  <if test="dto.type != null">
                      AND b.type = #{dto.type.value}
                  </if>
              </otherwise>
          </choose>

当所有条件为空时，就会产生一个类似SELECT * FROM book WHERE这样的语句，显然是不符合SQL语法的，会无法执行。或者因为第一个条件为空，而产生SELECT * FROM book WHERE AND xxx这样的语句，同样无法执行。

如果你的表设计中有逻辑删除字段，可以放在WHERE后避免这一点，就像之前的示例中那样。如果没有，也可以添加一个1=1：

        WHERE 1 = 1
          <choose>
              <when test="dto.bookId != null and dto.bookId > 0">
                  AND b.id = #{dto.bookId}
              </when>
              <otherwise>
                  <if test="dto.bookName != null and dto.bookName != ''">
                    AND b.name LIKE CONCAT('%',#{dto.bookName},'%')
                  </if>
                  <if test="dto.userName != null and dto.userName != ''">
                    AND u.name LIKE CONCAT('%',#{dto.userName},'%')
                  </if>
                  <if test="dto.desc != null and dto.desc != ''">
                    AND b.desc LIKE CONCAT('%',#{dto.desc},'%')
                  </if>
                  <if test="dto.type != null">
                      AND b.type = #{dto.type.value}
                  </if>
              </otherwise>
          </choose>

新手可能会对这种写法很困惑，但其实是一种很实际的写法。

如果你不愿意这么做，MyBatis提供一个额外的选择——where标签：

<select id="pageBooks" resultMap="bookResult3">
        SELECT b.*,u.id AS u_id,u.name AS u_name,u.password AS u_password,u.open_id AS u_open_id,u.real_name AS u_real_name,u.icon AS u_icon,u.dept_id AS u_dept_id,u.del_flag AS u_del_flag
        FROM book AS b
                 LEFT JOIN `user` AS u
                           ON b.user_id=u.id
        <where>
          <choose>
              <when test="dto.bookId != null and dto.bookId > 0">
                  AND b.id = #{dto.bookId}
              </when>
              <otherwise>
                  <if test="dto.bookName != null and dto.bookName != ''">
                    AND b.name LIKE CONCAT('%',#{dto.bookName},'%')
                  </if>
                  <if test="dto.userName != null and dto.userName != ''">
                    AND u.name LIKE CONCAT('%',#{dto.userName},'%')
                  </if>
                  <if test="dto.desc != null and dto.desc != ''">
                    AND b.desc LIKE CONCAT('%',#{dto.desc},'%')
                  </if>
                  <if test="dto.type != null">
                      AND b.type = #{dto.type.value}
                  </if>
              </otherwise>
          </choose>
          AND b.del_flag=0
          AND u.del_flag=0
        </where>
        LIMIT #{start},#{limit};
    </select>

where标签可以在所有条件为空和第一个条件为空这两种情况下都拼接出正常的SQL。

trim

where标签可以看做是特异化的trim标签，其等效于：

<trim prefix="WHERE" prefixOverrides="AND |OR ">
  ...
</trim>

trim标签的用途是将包裹内容中以prefixOverrides值开头的内容用prefix中的值代替，当然如果包裹的内容为空，就不处理。

所以上边的示例也可以用trim标签替代：

<select id="pageBooks" resultMap="bookResult3">
        SELECT b.*,u.id AS u_id,u.name AS u_name,u.password AS u_password,u.open_id AS u_open_id,u.real_name AS u_real_name,u.icon AS u_icon,u.dept_id AS u_dept_id,u.del_flag AS u_del_flag
        FROM book AS b
                 LEFT JOIN `user` AS u
                           ON b.user_id=u.id
        <trim prefix="WHERE" prefixOverrides="AND |OR ">
          <choose>
              <when test="dto.bookId != null and dto.bookId > 0">
                  AND b.id = #{dto.bookId}
              </when>
              <otherwise>
                  <if test="dto.bookName != null and dto.bookName != ''">
                    AND b.name LIKE CONCAT('%',#{dto.bookName},'%')
                  </if>
                  <if test="dto.userName != null and dto.userName != ''">
                    AND u.name LIKE CONCAT('%',#{dto.userName},'%')
                  </if>
                  <if test="dto.desc != null and dto.desc != ''">
                    AND b.desc LIKE CONCAT('%',#{dto.desc},'%')
                  </if>
                  <if test="dto.type != null">
                      AND b.type = #{dto.type.value}
                  </if>
              </otherwise>
          </choose>
        </trim>
        LIMIT #{start},#{limit};
    </select>

set

在UPDATE语句中，同样存在上边类似的问题：

    <update id="updateBookById" parameterType="cn.icexmoon.books2.book.entity.Book">
        UPDATE book
        SET
        <if test="name != null">name=#{name},</if>
        <if test="description != null">description=#{description},</if>
        <if test="userId != null">user_id=#{userId},</if>
        <if test="type != null">type=#{type.value},</if>
        <if test="extra != null">extra=#{extra},</if>
        <if test="delFlag != null">del_flag=#{delFlag}</if>
        WHERE id=#{id} AND del_flag=0
    </update>

只要映射器入参的delFlag属性为空，就会出现类似UPDATE xxx SET xxx=xxx, WHERE这样的语句出现，会报错。这个问题比之前更棘手，不能简单添加1=1之类的去规避，好在MyBatisPlus提供一个set标签：

 <update id="updateBookById" parameterType="cn.icexmoon.books2.book.entity.Book">
        UPDATE book
        <set>
            <if test="name != null">name=#{name},</if>
            <if test="description != null">description=#{description},</if>
            <if test="userId != null">user_id=#{userId},</if>
            <if test="type != null">type=#{type.value},</if>
            <if test="extra != null">extra=#{extra},</if>
            <if test="delFlag != null">del_flag=#{delFlag}</if>
        </set>
        WHERE id=#{id} AND del_flag=0
    </update>

同样的，set标签可以看做是特异化的trim标签，和下边的trim标签等效：

<trim prefix="SET" suffixOverrides=",">
  ...
</trim>

需要注意，因为是要特殊处理最后一个,，所以这里是suffixOverrides属性而非prefixOverrides。

foreach

foreach标签类似于Java中的for语句，常用于生成SQL中的IN语句。

假设我们的查询条件要求能够一次性查询出多种类型的书籍：

package cn.icexmoon.books2.book.entity.dto;
// ...
@Data
@NoArgsConstructor
public class BookQueryDTO {
    private Integer bookId;
    private String userName;
    private String bookName;
    private String desc;
    private List<BookType> types;
}

对应的XML：

<select id="pageBooks" resultMap="bookResult3">
        SELECT b.*,u.id AS u_id,u.name AS u_name,u.password AS u_password,u.open_id AS u_open_id,u.real_name AS u_real_name,u.icon AS u_icon,u.dept_id AS u_dept_id,u.del_flag AS u_del_flag
        FROM book AS b
                 LEFT JOIN `user` AS u
                           ON b.user_id=u.id
        <trim prefix="WHERE" prefixOverrides="AND |OR ">
          <choose>
              <when test="dto.bookId != null and dto.bookId > 0">
                  AND b.id = #{dto.bookId}
              </when>
              <otherwise>
                  <if test="dto.bookName != null and dto.bookName != ''">
                    AND b.name LIKE CONCAT('%',#{dto.bookName},'%')
                  </if>
                  <if test="dto.userName != null and dto.userName != ''">
                    AND u.name LIKE CONCAT('%',#{dto.userName},'%')
                  </if>
                  <if test="dto.desc != null and dto.desc != ''">
                    AND b.desc LIKE CONCAT('%',#{dto.desc},'%')
                  </if>
                  <foreach collection="dto.types" item="type" nullable="true"
                           open=" AND type IN (" separator="," close=")">
                    #{type.value}
                  </foreach>
              </otherwise>
          </choose>
        </trim>
        LIMIT #{start},#{limit};
    </select>

只要指定相关拼接字符，foreach就可以自动生成合适的IN语句。

需要注意的是，常见的下边的写法是有问题的：

                  AND type IN
                  <foreach collection="dto.types" item="type" nullable="true"
                           open="(" separator="," close=")">
                    #{type.value}
                  </foreach>

如果dto.types不为空，可以正常执行。但如果为空列表，就会导致生成WHERE XXX=xxx AND type IN LIMIT ?,?这样的SQL。

bind

bind标签可以创建一个变量，并将其绑定到当前的上下文：

              <otherwise>
                  <if test="dto.bookName != null and dto.bookName != ''">
                    <bind name="bookNameLike" value="'%'+dto.bookName+'%'"/>
                    AND b.name LIKE #{bookNameLike}
                  </if>
                  <!-- ... -->
              </otherwise>

前边说过，${}实际上是调用JDBC的SQL参数预处理进行参数替换，所以我们不能直接写LIKE %#{dto.bookName}%这样的语句，必须使用MySQL的字符串连接函数CONCAT。除此之外，还可以像上面那样使用bind标签，这里相当于用Java生成了一个bookNameLike变量，该变量的值是'%'+dto.bookName+'%'语句执行后的结果。然后可以将该变量用于参数替换LIKE #{bookNameLike}。

当然这个示例并不比直接使用CONCAT函数方便和直观，但可以看到bind标签的强大，我们甚至可以在value属性中调用其它函数获取一个值来绑定。

谢谢阅读。

本文最终的完整示例代码可以从learn_spring_boot/ch25 (github.com)获取。

参考资料

魔芋红茶
关注
专栏目录
从零开始学Spring Boot
06-09
《从零开始学Spring Boot》是一套全面且深入的学习教程，专为想要掌握Spring Boot技术的初学者设计。Spring Boot是Java开发中的一个热门框架，它简化了Spring应用的初始搭建以及开发过程，使得开发者可以更快地构建...
从零搭建一个 Spring Boot 开发环境！Spring Boot+Mybatis+Swagger2 环境搭建.docx
11-19
在本文中，我们将详细介绍如何从零开始搭建一个基于Spring Boot的开发环境，其中包括Spring Boot、Mybatis和Swagger2的集成。首先，让我们了解为何选择Spring Boot。 **为什么使用Spring Boot** Spring Boot是...
从零搭建Spring Boot脚手架，集成mybatis.docx
07-03
本文将详细介绍如何从零开始搭建一个Spring Boot项目，并集成MyBatis框架。Spring Boot是一个基于Java的轻量级框架，简化了新Spring应用程序的初始设置和配置。而MyBatis是一个优秀的持久层框架，它支持自定义SQL、...
从零搭建Spring Boot脚手架，整合 Mybatis Plus.docx
07-03
本篇着重介绍了如何从零开始搭建Spring Boot项目，并整合Mybatis Plus，旨在帮助开发者高效地进行数据库交互。 #### 2. Mybatis Plus 的优势 Mybatis Plus 是一款优秀的开源项目，其核心优势在于： - **单表通用 ...
从零开始 Spring Boot 18：微信登录
梦幻天空
08-15 5292
在之前的文章中我介绍了如何给Spring Boot开发的Web应用添加Shiro身份验证模块，这样我们就可以通过用户/密码的方式让用户进行登录。当然了，这种方式就必须要求用户先进行注册，或者管理员为用户预先添加帐号才行，所以如果我们需要降低用户使用系统干的门槛，让用户更容易登录系统，就可以接入第三方登录。而天朝最流行的第三方登录就是微信，这点应该是没有争议的。下面就介绍如何在现有用户/密码登录体系外额外接入微信登录。...
从零开始 Spring Boot 16：枚举
梦幻天空
08-05 2715
在开发Web应用时，无法避免的是会定义一些“离散值”，比如书籍类型，包含艺术、小说、工程书籍等。在数据库中，我们一般会使用整数来表示这些值，比如1代表小说，2代表艺术，3代表工程相关书籍等。但在代码中使用整数来表示类型可读性就很差了，以前一般使用类常量来表示这些值，但更好的做法是使用枚举。关于Java中枚举的基本知识，可以阅读。下面通过在我们的图书应用中引入枚举类型来说明如何在Spring Boot项目中使用枚举，以及相关的注意事项。下面的示例代码都将由中的最终代码修改而来，相关完整代码见。表的。...
从零开始 Spring Boot 51：JPA 中的默认列值
梦幻天空
06-29 2488
JPA 是一个 ORM 框架，因此，通常我们需要在实体类中定义表结构，这其中就包含可能的字段默认值。本文介绍如何在 Hibernate（JPA）中设置默认列值（Default Column Value）。
IDEA生成spring boot项目jar包
梦幻天空
04-26 2026
IDEA生成spring boot项目jar包 刚上手IDEA做sping boot项目，学习过程中遇到一些坑，具体我也不清楚为什么IDEA的默认项生成jar包会产生这些问题，但经过以下折腾后的确可以解决问题，所以先记录。 用IDEA打开一个spring boot项目： File>project structure： project settings > Artifacts选项卡中点加号： 依次选择JAR > From modules… 然后是重点： 这里必须像上图这样设置：
从零开始 Spring Boot 37：初始化 ApplicationContext
梦幻天空
06-12 1706
从前文可以知道，作为 Ioc 容器的 ApplicationContext，需要进行一系列步骤来初始化以最终就绪（对于 Web 应用来说就是可以提供Http服务）。
从零开始 Spring Boot 28：资源
梦幻天空
05-14 1646
Resource。
Redis 学习笔记 3：黑马点评
最新发布
梦幻天空
02-22 1589
启动后端代码和 Nginx。
从零开始 Spring Boot 11：返回数据
梦幻天空
07-02 1573
图源：简书 (jianshu.com)在之前文章中，已经展示了如何在前后端分离的Web应用中封装并返回统一格式的返回值，但之前展示的返回值封装的相当简单，只能用于简单示例，今天对返回值进行进一步封装和重构。本篇文章会在从零开始 Spring Boot 9：Shiro - 魔芋红茶’s blog (icexmoon.cn)中最终代码的基础上进行修改。你可以从下面的链接获取对应的示例代码：为了说明之前设计的一些缺陷，这里为这个示例代码添加上Swagger文档支持，具体方法见从零开始 Spring Boot 8：
从零开始 Spring Boot 63：Hibernate 继承映射
梦幻天空
07-07 1554
关系型数据库设计中是不存在继承概念的，但实体类可以用继承来组织代码结构，所以需要用一种方式将实体类的继承结构映射到表结构。本文将介绍几种在 JPA（Hibernate）中映射实体类继承层次的方式。
Java编程笔记31：Record
梦幻天空
06-07 1548
总的来说，Record 的用途相对简单和直接，就是充当一个“透明的数据载体”，而 Lombok 除了直接使用@Value注解外，还可以结合其它注解更灵活地定制一个类型。
Java编程笔记11：字符串
梦幻天空
01-28 1412
Java编程笔记11：字符串 图源：PHP中文网 字符串连接 字符串连接是程序中最常使用的对字符串的操作，看一个最简单的例子： package ch11.conn; public class Main { public static void main(String[] args) { String a = "hellow"; String b = "world"; String c = "!"; String result = a
从零开始 Spring Boot 38：Lombok 与依赖注入
梦幻天空
06-13 1402
在中，我详细介绍了 Lombok 的用法，考虑到在 Spring 中使用依赖注入（DI）是如此的频繁，因此有必要讨论使用 Lombok 时可能对依赖注入造成的影响。**无论我们有没有使用构造器注入，用@Autowired标记的属性都会在 bean 实例创建后被 Spring 通过反射来完成注入。**因此实际上这里 Lombok 的注解生成的构造器并不会对属性的注入产生影响。
从零开始 Spring Boot 60：一个实体映射到多个表
梦幻天空
07-05 1298
在之前的文章中我们讨论了，实际上存在一种特殊的一对一关系，即将一个实体映射到多张表，本文会讨论这种关系。我之前提过，有时候会因为性能上的考量将一张表拆分成多张表，虽然拆分后也可以用一对一关系来表示和实现，但这样并不是特别合适，因为一对一关系中一边的关系是可以为null的，比如说一个学生对应一个电子邮件地址，也可能有的学生没有电子邮件地址，此时email表可能就没有一条对应的数据。但如果是从同一张表上拆分出的两张表，必然存在一对一的关系，即使另一张表中的数据都是null字段。
从零开始 Spring Boot 47：缓存
梦幻天空
06-23 1265
Spring 提供一个简单但使用的缓存（Cache）机制，我们可以利用它来优化代码执行效率。
从零开始 Spring Boot 31：Spring 表达式语言
梦幻天空
05-19 1258
}这里通过三种方式从配置文件获取配置项：其中是很常见的直接获取配置项，则是通过注入的对象来获取配置项，而则是通过SpEL表达式获取这个bean，然后调用对应的方法获取。SpEL表达式可以直接获取Spring中预设的bean，比如enviroment。类似的，用XML方式定义bean的时候，同样可以使用SpEL。除了可以利用SpEL定义bean的属性之外，还可以在用于创建bean的构造器（默认构造器或者@Autowired} // ... }这里通过@Value。
Spring Boot 2.2.2整合MyBatis教程：从零开始
- 数据库设置：文档首先强调了数据库环境的重要性，这意味着在开始Spring Boot与MyBatis的整合之前，你需要确保有一个可用的数据库（如MySQL、Oracle等），并且数据库连接信息是正确的。可能需要创建相应的数据库表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值