一小时迅速入门Mybatis之实体类别名与多参数 动态SQL

目录
  • 一、说明
  • 二、开搞
    • 数据库表
    • 2.1 实体类别名
      • 2.1.1 第一种方式
      • 2.1.2 第二种方式
      • 2.1.3 mybatis默认别名
    • 2.2 插入数据返回自增主键
      • 2.2.1方式一
      • 2.2.2 方式二
    • 2.3 多参数
      • 2.3.1 一个参数
      • 2.3.2 多个参数 之实体类
      • 2.3.3 多个参数之@Param注解
      • 2.3.4 多个参数之Map
      • 2.3.5 多个参数之默认
      • 2.3.6 数组参数之基础值&实体类
      • 2.3.7 集合参数之基础值&实体类
    • 2.4 四大标签的说明
    • 2.5 唠唠

一、说明

前边两篇腿已经迈进门了,这篇开始讲实体类别名、多参数、动态SQL等

二、开搞

数据库表

DROP TABLE IF EXISTS `test`;
CREATE TABLE `test`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `salary` decimal(10, 2) NOT NULL,
  `age` int(11) NULL DEFAULT NULL,
  `city` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `job` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 43 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of test
-- ----------------------------
INSERT INTO `test` VALUES (1, '小明', 40000.00, 18, '北京', '程序猿');
INSERT INTO `test` VALUES (2, '小强', 50000.00, 19, '南京', '程序汪');
INSERT INTO `test` VALUES (3, '小月月', 50000.00, 20, '天津', '程序狗');
INSERT INTO `test` VALUES (4, '小月鸟', 40000.00, 21, '广州', '程序屌丝');

2.1 实体类别名

2.1.1 第一种方式

1.创建实体类
package entity;

import java.math.BigDecimal;

/**
 * 一个生活在互联网底层,做着增删改查的码农,不谙世事的造作
 * @create 2021-08-25 22:05
 */

public class TestEntity {
    private  Long id;
    private String name;
    private BigDecimal salary;
    private Integer age;
    private String city;
    private String job;
	// get set方法省略  IntelliJ IDEA  生成快捷键是Alt+Inert 选择Getter and Setter
    // toString 方法省略   IntelliJ IDEA  生成快捷键是Alt+Inert 选择 toString
}
2.创建XML

mybatis-config.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>
    <!--这里一定注意顺序 -->
    <typeAliases>
        <typeAlias type="entity.TestEntity" alias="testEntity"/>
    </typeAliases>
    <!--省略environments 看前2篇 -->
	 <!--省略扫描 看前2篇-->
</configuration>

配置文件顺序要这样配置:

<properties>...</properties>
<settings>...</settings>
<typeAliases>...</typeAliases>
<typeHandlers>...</typeHandlers>
<objectFactory>...</objectFactory>
<objectWrapperFactory>...</objectWrapperFactory>
<plugins>...</plugins>
<environments>...</environments>
<databaseIdProvider>...</databaseIdProvider>
<mappers>...</mappers>

3.使用别名
<!--根据主键查询-->
<select id="get" resultType="testEntity">
    select * from test where id = #{id}
</select>
public class TestMain {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper
            TestMapper mapper = session.getMapper(TestMapper.class);
            System.out.println(mapper);
            // 查询数据
            TestEntity testEntity = mapper.get(1L);
            System.out.println(testEntity);
        }
    }
}

2.1.2 第二种方式

扫描包路径 mybatis-config.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>
  <!--扫描包路径-->
    <typeAliases>
        <package name="entity"/>
    </typeAliases>
    <!--省略environments 看前2篇 -->
	 <!--省略扫描 看前2篇-->
</configuration>

用扫描包路径的方式,实体类别名默认就是java类首字母小写

例如:TestEntity --> testEntity

还可以注解指定:

@Alias("testEntityxxoo")
public class TestEntity {
    // 其他省略
}

如果写了注解@Alias 别名就不是”testEntity”了 ,就变成”testEntityxxoo“

2.1.3 mybatis默认别名

映射类型
_byte byte
_long long
_short short
_int int
_integer int
_double double
_float float
_boolean boolean
string String
byte Byte
long Long
short Short
int Integer
integer Integer
double Double
float Float
boolean Boolean
date Date
decimal BigDecimal
bigdecimal BigDecimal
object Object
map Map
hashmap HashMap
list List
arraylist ArrayList
collection Collection
iterator Iterator

2.2 插入数据返回自增主键

2.2.1方式一

<!--增加-->
<insert id="save" useGeneratedKeys="true" keyProperty="id">
    INSERT INTO `test`( `name`, `salary`) VALUE (#{name}, #{salary});
</insert>
public class TestMain {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper
            TestMapper mapper = session.getMapper(TestMapper.class);
            // 测试id是否到了实体类里边
            TestEntity testEntity = new TestEntity();
            testEntity.setName("小鸭子");
            testEntity.setSalary(new BigDecimal(100000));
            mapper.save(testEntity);
            System.out.println("主键:"+testEntity.getId());
        }
    }
}

输出结果:

主键不是直接返回的,而是把主键值设置到插入的对象里的

2.2.2 方式二

<!--增加-->
<insert id="save">
    <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Long">
        SELECT LAST_INSERT_ID()
    </selectKey>
    INSERT INTO `test`(`id`, `name`, `salary`) VALUE (#{id},#{name}, #{salary})
</insert>

2.3 多参数

2.3.1 一个参数

// 根据主键查询
TestEntity get(Long id);
<!--根据主键查询-->
<select id="get" resultType="testEntity">
    select * from test where id = #{id}
</select>
<select id="get" resultType="testEntity">
    select * from test where id = #{xx}
</select>
<select id="get" resultType="testEntity">
    select * from test where id = #{oo}
</select>
<select id="get" resultType="testEntity">
    select * from test where id = #{aaabbb}
</select>

如果只有一个参数,并且参数类型是Java基础类型或String类型,那么使用这个参数的时候

#{xxoo} xxoo可以是任意字符 与方法输入参数名称无关

上边例子中:id、xx、oo、aaabbb 都可以使用 ,但是哈,我们一般见名知意,传递的什么参数(id),我们xml就用#{传递的参数} 这不是必须但可以遵循这个规范

2.3.2 多个参数 之实体类

// 新增
void save(TestEntity testEntity);
<!--增加-->
<insert id="save">
    INSERT INTO `test`(`name`, `salary`) VALUE (#{name}, #{salary})
</insert>

这个很容易明白,实体类参数叫什么 这里#{}里边就用什么

2.3.3 多个参数之@Param注解

// 根据名称模糊查询
List<TestEntity> listByNameAndAge(@Param("name") String name,@Param("age") Integer age);
<!--根据名称和年龄查寻-->
<select id="listByNameAndAge" resultType="testentity">
    select * from test
    where 1=1
    <if test="name != null">
        and name like CONCAT('%',#{name},'%')
    </if>
    <if test="age != null">
        and age = #{age}
    </if>
</select>
public class TestMain {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper
            TestMapper mapper = session.getMapper(TestMapper.class);
            List<TestEntity> list = mapper.listByNameAndAge("小强", 19);
            System.out.println(list);
        }
    }
}

2.3.4 多个参数之Map

用Map跟用实体类差不多 就key值当做是实体类的字段名称就可以

// 多参数Map 方式传递
List<TestEntity> listByNameAndAgeMap(Map<String, Object> param);
<!--param多参数map使用-->
<select id="listByNameAndAgeMap" resultType="testentity">
    select * from test
    where 1=1
    <if test="name != null">
        and name like CONCAT('%',#{name},'%')
    </if>
    <if test="age != null">
        and age = #{age}
    </if>
</select>
public class TestMain {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper
            TestMapper mapper = session.getMapper(TestMapper.class);
            Map<String,Object> param = new HashMap<>();
            param.put("name", "小强");
            param.put("age", 19);
            List<TestEntity> list = mapper.listByNameAndAgeMap(param);
            System.out.println(list);
        }
    }
}

2.3.5 多个参数之默认

默认有两套参数:

arg0、arg1、arg2、argxxx ; arg从0开始按照方法参数顺序

param1、param2、param3、paramxxx ; param从1开始按照方法参数顺序

// 什么都不用
List<TestEntity> listByNameAndAgeNone(String name, int age);
<!--用默认顺序-->
<select id="listByNameAndAgeNone" resultType="testentity">
    select * from test
    where 1=1
    <if test="arg0 != null">
        and name like CONCAT('%',#{arg0},'%')
    </if>
    <if test="arg1 != null">
        and age = #{arg1}
    </if>
</select>
<!--用默认顺序-->
<select id="listByNameAndAgeNone" resultType="testentity">
    select * from test
    where 1=1
    <if test="param1 != null">
        and name like CONCAT('%',#{param1},'%')
    </if>
    <if test="param2 != null">
        and age = #{param2}
    </if>
</select>
public class TestMain {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper
            TestMapper mapper = session.getMapper(TestMapper.class);
            List<TestEntity> list = mapper.listByNameAndAgeNone("小月", 20);
            System.out.println(list);
        }
    }
}

2.3.6 数组参数之基础值&实体类

注意传递数组的话,默认参数名称为arry

1. 根据多个年龄查询数据:
// 根据年龄集合查询
List<TestEntity> listByAges(int[] ages);
<select id="listByAges" resultType="testentity">
    select * from test
    where 1=1
    <if test="array != null and array.length >0">
        and age in
        <foreach collection="array" item="age" open="(" separator="," close=")">
        #{age}
</foreach>
    </if>
        </select>
public class TestMain {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper
            TestMapper mapper = session.getMapper(TestMapper.class);
            int[] ages = new int[]{19,20};
            List<TestEntity> list = mapper.listByAges(ages);
            System.out.println(list);
        }
    }
}
2. 根据名称和年龄多条件查询

例如:名称是小强并且年龄是19 或者名称是小月月年龄是20 的数据

// 根据多组参数查询
List<TestEntity> listByNameAndAges(TestEntity[] params);
<select id="listByNameAndAges" resultType="testentity">
    select * from test
    where 1=1
    <if test="array != null and array.length >0">
        and (
        <foreach collection="array" item="item"  separator="or" >
        (name = #{item.name} and age = #{item.age})
        </foreach>
    )
        </if>
</select>
public class TestMain {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper
            TestMapper mapper = session.getMapper(TestMapper.class);
            TestEntity[] params = new TestEntity[2];
            TestEntity testEntity01 = new TestEntity();
            testEntity01.setName("小强");
            testEntity01.setAge(19);
            TestEntity testEntity02 = new TestEntity();
            testEntity02.setName("小月月");
            testEntity02.setAge(20);
            params[0] =  testEntity01;
            params[1] =  testEntity02;
            List<TestEntity> list = mapper.listByNameAndAges(params);
            System.out.println(list);
        }
    }
}

最后输出的sql格式是这样的:

select* from test where 1=1 and (
(name = '小强' and age = 19) or
(name = '小月月' and age = 20)
)

2.3.7 集合参数之基础值&实体类

集合与数组差不多,但还是有点儿差别

不同点1: 集合如果不指定参数名称的话默认使用:collection或者list 不是array

不同点2:集合判断大小是这样的 用的size() 不是length

 <if test="list != null and list.size() >0"></if>

2.4 四大标签的说明

select是Mybatis使用最多的标签之一,他与insert update delete不同,他不对数据库值做改变,只是查

insert、 update、 delete 会对数据库的值做变更,这三个标签可以混用,也就是说他们功能一样,出三个的意义就是为了业务上可以区分一下是新增、修改还是删除。一般我们也遵循这个使用。

2.5 唠唠

没写动态Sql相关的东西 后边几篇写吧

下期预告:

# {}${} 这哥俩的区别与使用

到此这篇关于一小时迅速入门Mybatis之实体类别名与多参数 动态SQL的文章就介绍到这了,更多相关Mybatis 动态SQL 多参数 实体类别名内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 一小时迅速入门Mybatis之Prepared Statement与符号的使用

    目录 一.用一用 PreparedStatement 二.用一用 Statement 三.Mybatis #{} ${} 的使用 四.ResultMap ResultType的区别 引入Mysql的Jar包以及表结构前几篇已经有了这里就不赘述了 一.用一用 PreparedStatement import java.math.BigDecimal; import java.sql.*; /** * @author 发现更多精彩 关注公众号:木子的昼夜编程 * 一个生活在互联网底层,做着增删改查的

  • 一小时迅速入门Mybatis之增删查改篇

    目录 一.说明 二.开搞 2.1 数据库表 2.1 创建实体类 2.2 创建接口 2.3 创建XML 2.5 测试类 2.6 唠唠 一.说明 这二篇涉及到映射Java实体类.面向接口编写Mybatis.增删查改示例 怎么引入jar包,怎么配置数据库看上一篇哦~ 二.开搞 2.1 数据库表 上一篇好像丢了数据库创建语句 -- 主键自增 DROP TABLE IF EXISTS `test`; CREATE TABLE `test` ( `id` bigint(20) NOT NULL AUTO_I

  • 一小时迅速入门Mybatis之初识篇

    目录 一.Mybatis简介 二.mybatis入门 2.1 创建Maven项目 2.2 修改pom文件(引入jar包) 2.3 编写xml 2.4 编写Java代码 2.5 唠唠 一.Mybatis简介 Mybatis是一款超级无敌的持久层框架,它支持自定义SQL.存储过程以及高级映射.Mybatis可以通过简单的XML或者注解来配置和映射原始类型.接口和Java POJO为数据库中的记录. Mybatis相比于Hibernate在处理复杂业务的时候灵活度更高.复杂的SQL编写更容易. 二.m

  • 一小时迅速入门Mybatis之实体类别名与多参数 动态SQL

    目录 一.说明 二.开搞 数据库表 2.1 实体类别名 2.1.1 第一种方式 2.1.2 第二种方式 2.1.3 mybatis默认别名 2.2 插入数据返回自增主键 2.2.1方式一 2.2.2 方式二 2.3 多参数 2.3.1 一个参数 2.3.2 多个参数 之实体类 2.3.3 多个参数之@Param注解 2.3.4 多个参数之Map 2.3.5 多个参数之默认 2.3.6 数组参数之基础值&实体类 2.3.7 集合参数之基础值&实体类 2.4 四大标签的说明 2.5 唠唠 一.

  • 一小时迅速入门Mybatis之bind与多数据源支持 Java API

    目录 一.bind 二. 多数据库支持 2.1 pom.xml 2.2 mybatis-config.xml 2.3 接口 PersonMapper 2.4 xml PersonMapper.xml 2.5 测试 这次说一下bind.多数据源支持.Java API 一.bind // 测试bind List<Person> testBind(@Param("name") String name); <!--测试bind--> <!--相当于SQL sele

  • Java的MyBatis框架中对数据库进行动态SQL查询的教程

    其实MyBatis具有的一个强大的特性之一通常是它的动态 SQL 能力. 如果你有使用 JDBC 或其他 相似框架的经验,你就明白要动态的串联 SQL 字符串在一起是十分纠结的,确保不能忘了空格或在列表的最后省略逗号.Mybatis中的动态 SQL 可以彻底处理这种痛苦.对于动态SQL,最通俗简单的方法就是我们自己在硬编码的时候赋予各种动态行为的判断,而在Mybatis中,用一种强大的动态 SQL 语 言来改进这种情形,这种语言可以被用在任意映射的 SQL 语句中.动态 SQL 元素和使用 JS

  • MyBatis中动态sql的实现方法示例

    1. 动态sql 动态sql是mybatis中的一个核心,什么是动态sql? 动态sql即对sql语句进行灵活操作,通过表达式进行判断,对sql进行灵活拼接.组装. MyBatis的强大特性之一便是它的动态 SQL.如果你有使用 JDBC 或其他类似框架的经验,你就能体会到根据不同条件拼接 SQL 语句有多么痛苦.拼接的时候要确保不能忘了必要的空格,还要注意省掉列名列表最后的逗号.有些时候,SQL语句where条件中,需要一些安全判断,例如按某一条件查询时如果传入的参数是空,此时查询出的结果很可

  • Mybatis动态SQL的实现示例

    场景 在实际应用开发过程中,我们往往需要写复杂的 SQL 语句,需要拼接,而拼接SQL语句又稍微不注意,由于引号,空格等缺失可能都会导致错误. Mybatis提供了动态SQL,也就是可以根据用户提供的参数,动态决定查询语句依赖的查询条件或SQL语句的内容. 动态SQL标签 if 和 where 标签 <!--动态Sql : where / if--> <select id="dynamicSql" resultType="com.lks.domain.Use

  • 史上最简单的MyBatis动态SQL入门示例代码

    假如有如下的关于书籍基本信息的表: DROP DATABASE IF EXISTS `books`; CREATE DATABASE `books`; USE books; DROP TABLE IF EXISTS `book`; CREATE TABLE `book` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(128) DEFAULT NULL, `author` varchar(64) DEFAULT NULL, `pres

  • Mybatis入门教程(四)之mybatis动态sql

    推荐阅读: MyBatis入门学习教程(一)-MyBatis快速入门  什么是动态SQL? 动态SQL有什么作用? 传统的使用JDBC的方法,相信大家在组合复杂的的SQL语句的时候,需要去拼接,稍不注意哪怕少了个空格,都会导致错误.Mybatis的动态SQL功能正是为了解决这种问题, 其通过 if, choose, when, otherwise, trim, where, set, foreach标签,可组合成非常灵活的SQL语句,从而提高开发人员的效率. 下面就去感受Mybatis动态SQL

随机推荐