9、MyBatis的动态SQL

最新推荐文章于 2022-03-23 16:31:49 发布
最新推荐文章于 2022-03-23 16:31:49 发布
阅读量170 收藏
点赞数
分类专栏： SSM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ShawnYue_08/article/details/108560698
版权

文章目录

动态SQL

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。

使用动态 SQL 并非一件易事，但借助可用于任何 SQL 映射语句中的强大的动态 SQL 语言，MyBatis 显著地提升了这一特性的易用性。

如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。

  • if
  • choose (when, otherwise)
  • trim (where, set)
  • foreach

数据库环境准备

-- 动态SQL
USE mybatis;

CREATE TABLE IF NOT EXISTS `user` (
	uid INT NOT NULL AUTO_INCREMENT,
	uname VARCHAR(50) NOT NULL,
	upassword VARCHAR(50) NOT NULL,
	u_nickname VARCHAR(50) NOT NULL,
	PRIMARY KEY (uid)
);

INSERT INTO `user` VALUES (NULL, '赵云', '123456', '常山赵子龙'), (NULL, '张飞', 'asdfff', '燕人张飞'), (NULL, '关羽', 'ghhjkl', '关云长');

sql标签

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private static final long serialVersionUID = -5970028623059313270L;
    private Integer uid;
    private String uname;
    private String upassword;
    private String unickname;
}

public interface UserMapper {
    User selectByPrimaryKey(Integer uid);
}

<?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="org.westos.mapper.UserMapper">
    <sql id="baseColumn">
        uid, uname, upassword, u_nickname
    </sql>
    
    <select id="selectByPrimaryKey" resultType="User">
        select
            <include refid="baseColumn"/>
        from
             user
        where
            uid = #{uid}
    </select>
</mapper>

@Test
public void test() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.selectByPrimaryKey(1);
        System.out.println(JSON.toJSONString(user, true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: select uid, uname, upassword, u_nickname from user where uid = ? 
==> Parameters: 1(Integer)
<==    Columns: uid, uname, upassword, u_nickname
<==        Row: 1, 赵云, 123456, 常山赵子龙
<==      Total: 1
{
    "uid":1,
    "uname":"赵云",
    "unickname":"常山赵子龙",
    "upassword":"123456"
}

if标签

//根据条件查询
//使用if标签
List<User> selectAll(User user);

<select id="selectAll" resultType="User">
    select
    <include refid="baseColumn"/>
    from
    user
    where  1 = 1
    <if test="uid != null">
        and uid = #{uid}
    </if>
    <if test="uname != null and uname != ''">
        and uname = #{uname}
    </if>
    <if test="upassword != null and upassword != ''">
        and upassword = #{upassword}
    </if>
</select>

如果传递的User对象属性都为null，那么就是查询全部User。

@Test
public void test() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setUid(2);
        user.setUname("张飞");
        List<User> users = mapper.selectAll(user);
        System.out.println(JSON.toJSONString(users, true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

User对象的uid和uname是有值的。

==>  Preparing: select uid, uname, upassword, u_nickname from user where 1 = 1 and uid = ? and uname = ? 
==> Parameters: 2(Integer), 张飞(String)
<==    Columns: uid, uname, upassword, u_nickname
<==        Row: 2, 张飞, asdfff, 燕人张飞
<==      Total: 1
[
    {
        "uid":2,
        "uname":"张飞",
        "unickname":"燕人张飞",
        "upassword":"asdfff"
    }
]

where标签

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

//根据条件查询
//使用where标签
List<User> selectAll2(User user);

<!--where标签 标签的特点是只有满足if判断条件，才输出where，而且可以去除 第一个 and / or-->
<select id="selectAll2" resultType="User">
    select
    <include refid="baseColumn"/>
    from
    user
    <where>
        <if test="uid != null">
            and uid = #{uid}
        </if>
        <if test="uname != null and uname != ''">
            and uname = #{uname}
        </if>
        <if test="upassword != null and upassword != ''">
            and upassword = #{upassword}
        </if>
    </where>
</select>

@Test
public void test() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setUid(2);
        user.setUname("张飞");
        List<User> users = mapper.selectAll2(user);
        System.out.println(JSON.toJSONString(users, true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: select uid, uname, upassword, u_nickname from user WHERE uid = ? and uname = ? 
==> Parameters: 2(Integer), 张飞(String)
<==    Columns: uid, uname, upassword, u_nickname
<==        Row: 2, 张飞, asdfff, 燕人张飞
<==      Total: 1
[
    {
        "uid":2,
        "uname":"张飞",
        "unickname":"燕人张飞",
        "upassword":"asdfff"
    }
]

@Test
public void test() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setUname("");
        List<User> users = mapper.selectAll2(user);
        System.out.println(JSON.toJSONString(users, true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: select uid, uname, upassword, u_nickname from user 
==> Parameters: 
<==    Columns: uid, uname, upassword, u_nickname
<==        Row: 1, 赵云, 123456, 常山赵子龙
<==        Row: 2, 张飞, asdfff, 燕人张飞
<==        Row: 3, 关羽, ghhjkl, 关云长
<==      Total: 3
[
	{
		"uid":1,
		"uname":"赵云",
		"unickname":"常山赵子龙",
		"upassword":"123456"
	},
	{
		"uid":2,
		"uname":"张飞",
		"unickname":"燕人张飞",
		"upassword":"asdfff"
	},
	{
		"uid":3,
		"uname":"关羽",
		"unickname":"关云长",
		"upassword":"ghhjkl"
	}
]

set标签

void updateUser(User user);

<!--set标签-->
<update id="updateUser">
    update
    user
    <set>
        <if test="uname != null and uname != ''">
            uname = #{uname},
        </if>
        <if test="upassword != null and upassword != ''">
            upassword = #{upassword},
        </if>
        <if test="unickname != null and unickname != ''">
            u_nickname = #{unickname},
        </if>
    </set>
    where uid = #{uid}
</update>

@Test
public void test() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setUid(3);
        user.setUname("黄忠");
        user.setUpassword("huang");
        user.setUnickname("汉升");
        mapper.updateUser(user);
        sqlSession.commit();
        System.out.println(JSON.toJSONString(mapper.selectByPrimaryKey(3), true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: update user SET uname = ?, upassword = ?, u_nickname = ? where uid = ? 
==> Parameters: 黄忠(String), huang(String), 汉升(String), 3(Integer)
<==    Updates: 1
Committing JDBC Connection [com.mysql.jdbc.JDBC4Connection@10a035a0]
==>  Preparing: select uid, uname, upassword, u_nickname from user where uid = ? 
==> Parameters: 3(Integer)
<==    Columns: uid, uname, upassword, u_nickname
<==        Row: 3, 黄忠, huang, 汉升
<==      Total: 1
{
	"uid":3,
	"uname":"黄忠",
	"unickname":"汉升",
	"upassword":"huang"
}

trim标签

<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>

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

如果 where 元素与你期望的不太一样，你也可以通过自定义 trim 元素来定制 where 元素的功能。比如，和 where 元素等价的自定义 trim 元素为：

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

查询

//使用trim标签
List<User> selectAll3(User user);

<!--trim标签的属性，prefix增加一个前缀，prefixOverrides去除一个前缀-->
<!--suffix增加一个后缀，suffixOverrides去除一个后缀-->
<!--主要是在插入、更新时使用-->
<select id="selectAll3" resultType="User">
    select
    <include refid="baseColumn"/>
    from
    user
    <trim prefix="where" prefixOverrides="and |or ">
        <if test="uid != null">
            and uid = #{uid}
        </if>
        <if test="uname != null and uname.trim != ''">
            and uname = #{uname}
        </if>
    </trim>
</select>

prefix：增加一个前缀

prefixOverrides：去除一个前缀。

@Test
public void test() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setUid(3);
        user.setUname("黄忠");
        System.out.println(JSON.toJSONString(mapper.selectAll3(user), true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: select uid, uname, upassword, u_nickname from user where uid = ? and uname = ? 
==> Parameters: 3(Integer), 黄忠(String)
<==    Columns: uid, uname, upassword, u_nickname
<==        Row: 3, 黄忠, huang, 汉升
<==      Total: 1
[
	{
		"uid":3,
		"uname":"黄忠",
		"unickname":"汉升",
		"upassword":"huang"
	}
]

更新

//使用trim标签
void updateUser2(User user);

<!--prefix增加一个前缀，suffixOverrides去除一个后缀-->
<update id="updateUser2">
    update
    user
    <trim prefix="set" suffixOverrides=",">
        <if test="uname != null and uname.trim != ''">
            uname = #{uname},
        </if>
        <if test="upassword != null and upassword.trim != ''">
            upassword = #{upassword},
        </if>
        <if test="unickname != null and unickname.trim != ''">
            u_nickname = #{unickname},
        </if>
    </trim>
    where uid = #{uid}
</update>

@Test
public void test() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setUid(3);
        user.setUname("马超");
        user.setUpassword("ma");
        user.setUnickname("马儿");
        mapper.updateUser2(user);
        sqlSession.commit();
        System.out.println(JSON.toJSONString(mapper.selectAll3(user), true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: update user set uname = ?, upassword = ?, u_nickname = ? where uid = ? 
==> Parameters: 马超(String), ma(String), 马儿(String), 3(Integer)
<==    Updates: 1
Committing JDBC Connection [com.mysql.jdbc.JDBC4Connection@481a15ff]
==>  Preparing: select uid, uname, upassword, u_nickname from user where uid = ? and uname = ? 
==> Parameters: 3(Integer), 马超(String)
<==    Columns: uid, uname, upassword, u_nickname
<==        Row: 3, 马超, ma, 马儿
<==      Total: 1
[
	{
		"uid":3,
		"uname":"马超",
		"unickname":"马儿",
		"upassword":"ma"
	}
]

插入

//使用trim标签
void insertUser(User user);

<insert id="insertUser">
    insert into user
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="uname != null">
            uname,
        </if>
        <if test="upassword != null">
            upassword,
        </if>
        <if test="unickname != null">
            u_nickname,
        </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides=",">
        <if test="uname != null">
            #{uname},
        </if>
        <if test="upassword != null">
            #{upassword},
        </if>
        <if test="unickname != null">
            #{unickname},
        </if>
    </trim>
</insert>

@Test
public void test() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setUname("黄忠");
        user.setUpassword("huang");
        user.setUnickname("汉升");
        mapper.insertUser(user);
        sqlSession.commit();
        System.out.println(JSON.toJSONString(mapper.selectAll(null), true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: insert into user ( uname, upassword, u_nickname ) values ( ?, ?, ? ) 
==> Parameters: 黄忠(String), huang(String), 汉升(String)
<==    Updates: 1
Committing JDBC Connection [com.mysql.jdbc.JDBC4Connection@706a04ae]
==>  Preparing: select uid, uname, upassword, u_nickname from user where 1 = 1 
==> Parameters: 
<==    Columns: uid, uname, upassword, u_nickname
<==        Row: 1, 赵云, 123456, 常山赵子龙
<==        Row: 2, 张飞, asdfff, 燕人张飞
<==        Row: 3, 马超, ma, 马儿
<==        Row: 4, 黄忠, huang, 汉升
<==      Total: 4
[
	{
		"uid":1,
		"uname":"赵云",
		"unickname":"常山赵子龙",
		"upassword":"123456"
	},
	{
		"uid":2,
		"uname":"张飞",
		"unickname":"燕人张飞",
		"upassword":"asdfff"
	},
	{
		"uid":3,
		"uname":"马超",
		"unickname":"马儿",
		"upassword":"ma"
	},
	{
		"uid":4,
		"uname":"黄忠",
		"unickname":"汉升",
		"upassword":"huang"
	}
]

foreach

动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）。比如：

//使用foreach标签
List<User> select(List<Integer> list);

<select id="select" resultType="User">
    select
    <include refid="baseColumn"/>
    from
    user
    <trim prefix="where">
        uid in 
        <foreach collection="list" open="(" close=")" separator="," index="index" item="item">
            #{item}
        </foreach>
    </trim>
</select>


@Test
public void test() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
        List<User> users = mapper.select(arrayList);
        System.out.println(JSON.toJSONString(users, true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: select uid, uname, upassword, u_nickname from user where uid in ( ? , ? , ? , ? ) 
==> Parameters: 1(Integer), 2(Integer), 3(Integer), 4(Integer)
<==    Columns: uid, uname, upassword, u_nickname
<==        Row: 1, 赵云, 123456, 常山赵子龙
<==        Row: 2, 张飞, asdfff, 燕人张飞
<==        Row: 3, 马超, ma, 马儿
<==        Row: 4, 黄忠, huang, 汉升
<==      Total: 4
[
	{
		"uid":1,
		"uname":"赵云",
		"unickname":"常山赵子龙",
		"upassword":"123456"
	},
	{
		"uid":2,
		"uname":"张飞",
		"unickname":"燕人张飞",
		"upassword":"asdfff"
	},
	{
		"uid":3,
		"uname":"马超",
		"unickname":"马儿",
		"upassword":"ma"
	},
	{
		"uid":4,
		"uname":"黄忠",
		"unickname":"汉升",
		"upassword":"huang"
	}
]

choose…when…otherwise

//使用choose...when...otherwise标签
User select2(User user);

<select id="select2" resultType="User">
    select
    <include refid="baseColumn"/>
    from
    user
    where
    <choose>
        <when test="uid != null">
            uid = #{uid}
        </when>
        <when test="uname != null">
            uname = #{uname}
        </when>
        <otherwise>
            upassword = #{upassword}
        </otherwise>
    </choose>
</select>

@Test
public void test() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setUid(1);
        User user1 = mapper.select2(user);
        System.out.println(JSON.toJSONString(user1, true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: select uid, uname, upassword, u_nickname from user where uid = ? 
==> Parameters: 1(Integer)
<==    Columns: uid, uname, upassword, u_nickname
<==        Row: 1, 赵云, 123456, 常山赵子龙
<==      Total: 1
{
	"uid":1,
	"uname":"赵云",
	"unickname":"常山赵子龙",
	"upassword":"123456"
}
ShawnYue_08
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mysql mybatis原数据相加_MyBatisPlus-入门使用笔记
weixin_35874254的博客
01-27 5907
MyBatisPlusMyBatisPlus快速入门官网文档地址：https://baomidou.gitee.io/mybatis-plus-doc/#/install使用第三方组件步骤：1、导入相应的依赖2、研究依赖如何配置3、代码如何编写4、提高扩展技术能力步骤1、创建数据库 User 表idnameageemail1Jone18test1@baomidou.com2Jack20test2@...
mybatis update 不为空的_MyBatis Plus更新对象无法设空值解决方案
weixin_39653361的博客
01-12 3634
原因因为 MyBatis-Plus 自带的更新方法，都有对对象空值进行判空。只有不为空的字段才会进行数据更新。解决方式在实体类对应的字段上加注解@TableField(strategy=FieldStrategy.IGNORED)，忽略null值的判断，例如：@TableField(updateStrategy = FieldStrategy.IGNORED)private String addr...
javascript 快速入门之第六章 表单验证
qq_61313896的博客
03-23 1418
一：表单验证的基本概念 为了保证用户提交的信息都是正确的，保证系统的安全性，验证是必不可少的，同时也为降低服务器的压力，减少资源损耗，在数据被送往服务器前对 HTML 表单中的这些输入数据进行验证。 二：表单验证的实现方式 内置对象String 正则表达式 内置对象String基本概念 String 对象用于处理文本，也就是字符串。一个字符串用于存储一系列的字符，通常 JS 字符 串是原始值，可以使用变量声明，也可以使用 new 关键...
Mysql中TIMESTAMP时间进位问题
calm_encode的博客
08-04 759
一 SQL Preparing: INSERT INTO user (start_time,create_time) VALUES ( ?, ? ) Parameters: 2021-07-23T11:25:49.737(LocalDateTime),2021-07-23T11:25:49.737(LocalDateTime) 分析：可以看到日志中的start_time，create_time都是带有毫秒的。 但是进入数据库之后时间就发生了进位，毫秒值没有了且秒...
trim()方法
02-08 490
Trim() 功能：删除字符串中多余的空格，但会在英文字符串中保留一个作为词与词之间分隔的空格。 语法：Trim ( string ) 参数string：string类型，指定要删除首部和尾部空格的字符串返回值String。函数执行成功时返回删除了string字符串首部和尾部空格的字符串，发生错误时返回空字符串（""）。 如果参数值为null时，会抛出空指针异常。 百度百科
mybatis动态sql.zip
04-28
mybatis动态sql，动态sql解析引擎，类似mybatis动态sql的功能。 mybatis动态sql，动态sql解析引擎，类似mybatis动态sql的功能。mybatis动态sql，动态sql解析引擎，类似mybatis动态sql的功能。mybatis动态sql，...
mybatis动态sqlmybatis动态sqlmybatis动态sql
04-28
mybatis动态sql MyBatis是一种开源的持久层框架，它为Java程序员提供了一种简化数据库访问的方式。其中，动态SQL是MyBatis的一个重要特性，它允许用户根据不同的条件拼接SQL语句，从而实现更加灵活和可扩展的数据库...
MyBatis 动态 SQL 示例
最新发布
04-28
附件是MyBatis 动态 SQL 示例，MyBatis 是一个持久层框架，它允许用户在 XML 文件中编写动态 SQL 语句。MyBatis 的动态 SQL 功能非常强大，它允许开发者根据运行时的条件动态地生成 SQL 语句。这使得 MyBatis 能够...
MyBatis 动态SQL示例
04-28
附件是MyBatis 动态SQL示例，MyBatis 是一个持久层框架，它允许用户在 XML 文件中编写动态 SQL 语句。MyBatis 的动态 SQL 功能非常强大，它允许开发者根据运行时的条件动态地生成 SQL 语句。这使得 MyBatis 能够灵活...
mybatisPlus实现创建时间、更新时间自动添加
热门推荐
weixin_44774355的博客
04-30 1万+
对于添加数据和修改记录时都要对添加时间和修改时间也要同时做更新，在我们使用mybatis时，需要手动记录当前时间为创建时间，当我们使用mybatisPlus时，就不想mybatis那样麻烦的手动去记录时间，只需要添加一个注解就可以实现自动添加功能。 （1）在表中的字段与类中的属性字段要对应： private Date createTime; private Date updateTime; （2）在属性加上相关注解 @TableField(fill = FieldFill.INS
sql基本操作2
伟大的程序员
11-16 204
sql语句基本操作2 1.插入记录 insert into user(uid,uname,upassword)values(null,'zhangsan','123'); insert into user values(null,'lisi','321'); 2.修改表记录 update user set upassword='666'; update user set upasswo
5、MyBatis中的输入参数映射（@Param、Map、@MapKey）、输出参数映射resultMap标签、mapUnderscoreToCamelCase（单表下的演示）
ShawnYue_08的博客
09-07 1844
文章目录再解输入和输出映射输入参数映射多个输入参数VO输入参数小结输出参数映射Map返回值映射@MapKeyResultMapmapUnderscoreToCamelCase Mapper代理开发模式，编程者只需要编写三项内容： model 实体类，通常一个程序只编写一次，可以编写工具一键生成。 mapper接口，Java mapper映射，xml mapper.xml，这个就是MyBatis编程核心关注的文件，尤其是mapper映射中的查询。 在mapper.xml映射文件中，需要 查找sql，参数映射，
8、sqlSesson.getMapper(接口.class）、mapper.selectAll()的源码跟踪
ShawnYue_08的博客
09-12 985
文章目录跟踪sqlSession.getMapper(接口.class)跟踪mapper.selectAll() 跟踪sqlSession.getMapper(接口.class) mybatis—getMapper() UserMapper mapper = sqlSession.getMapper(UserMapper.class); System.out.println(mapper); //org.apache.ibatis.binding.MapperProxy@67b92f0a Java中的代理
10、MyBatis的自动生成代码、PageHelper分页插件
ShawnYue_08的博客
09-22 824
文章目录代码生成方式一：官方jar方式二：IDEA插件及其应用（PageHelper） 代码生成 方式一：官方jar 为了简化MyBatis的编写，官方推出了一个工具"mybatis-generator"，Java编写的，通过这个工具可以生成数据库表对应的实体类、Mapper接口以及Mapper映射文件。 官网： http://mybatis.org/generator/ 快速入门指南： http://mybatis.org/generator/quickstart.html 我们这里就是使用从命令
3、JavaWeb中Service层的作用、MyBatis的重要组件、mybatis-config.xml中的别名映射、properties配置、#{}和${}的区别、获取插入数据的主键值
ShawnYue_08的博客
09-04 784
文章目录1、Service层的作用2、MyBatis重要组件ResourcesSqlSessionFactoryBuilderSqlSessionFactorySqlSession针对上面的点，对上次的代码进行改进3、MyBatis优化开发（mybatis-config.xml）配置properties别名typeAlias映射文件mapper4、#{} 和 ${}#{}${}5、插入数据并返回数据库中的主键值 1、Service层的作用 MVC = Jsp + Servlet + JavaBean 其中j
6、数据库表的关系、Java对象的关系、关联查询（一对多）、延迟加载访问
ShawnYue_08的博客
09-07 605
文章目录关联查询、多表数据库表关系Java对象之间的关系前提条件一对多单向关联延迟加载双向关联延迟加载延迟加载中传递多个参数 关联查询、多表 数据库表关系 表—>约束（主键约束、唯一性、非空、默认值、check约束）保证数据的准确性和完整性； 多张表，表与表之间存在外键约束。 外键约束，是关系型数据库典型的一个特点，是指一张表中的列参考/来源于另一张表的某个列的值。 比如，学生信息表，电脑表，一台电脑属于一个学生。 学生信息表，主表，父表。 电脑表，子表，外键表。 学生编号 学生编号
15、Spring MVC 数据绑定（基本数据类型、包装类、数组、List、Map、JSON）
ShawnYue_08的博客
12-19 518
Spring MVC 数据绑定 数据绑定：在后端的业务方法中直接获取客户端 HTTP 请求中的参数，将请求参数映射到业务方法的形参中， Spring MVC 中数据绑定的工作是由 HandlerAdapter 来完成的。 基本数据类型 package org.westos.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.Request
2、Maven + Junit测试单个@Test方法
ShawnYue_08的博客
09-03 434
Junit在包含多个@Test的测试方法中执行一个测试方法。 1、Maven设置跳过测试 2、点击方法左侧的按钮 这样就不会执行上面的insert测试方法。
4、MyBatis + Log4j日志查看Sql参数、结果集元数据、Mapper代理开发、JDK的动态代理与CGLib代理
ShawnYue_08的博客
09-05 412
文章目录MyBatis优化开发日志ResultSet如何转换为Java对象数据库元数据结果集元数据Fastjson基于MyBatis的DAO开发（传统）推荐mapper代理开发JDK动态代理CGLib代理 MyBatis优化开发 日志 MyBatis在执行过程中的信息显示，尤其是SQL参数。 1、增加依赖 <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId
Mybatis动态sql
04-14
Mybatis动态SQL是Mybatis框架中的一个重要特性，它允许我们在SQL语句中根据不同的条件动态地生成SQL语句。 Mybatis动态SQL的主要特点包括： 1. 条件判断：可以使用if、choose、when、otherwise等标签来实现条件判断...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值