sql映射文件

最新推荐文章于 2022-08-20 10:34:08 发布

这次又写信给哪位

最新推荐文章于 2022-08-20 10:34:08 发布

阅读量213

点赞数

分类专栏： mybatis 文章标签： mybatis

本文链接：https://blog.csdn.net/weixin_44134725/article/details/112987879

版权

mybatis 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1、所有可用标签

2、增删改标签

（1）使用useGeneratedKeys和keyProperty可以配合实现获取到插入后的自增id；

（2）使用selectKey获取非自增主键的值

（2）联合查询-级联属性的方式封装查出的数据

（3）使用association定义联合查询对象封装规则

（4）collection标签定义集合类型属性的封装规则

（5）使用select属性指定分布查询

（6）按需加载和延迟加载

1、所有可用标签

cache：缓存有关
cache-ref：和缓存有关
delete、insert、update、select：增删改查
parameterMap：参数Map，已经废弃，原本是做复杂参数映射的
resultMap：结果映射，自定义结果集的封装规则；
sql：抽取可重用的sql

2、增删改标签

可用的标签：

id：唯一标识符，要实现接口的方法名
parameterType : 指定参数类型，一般不用写，因为Mybatis可以通过TypeHandler推断出具体传入语句的参数类型，默认值为unset。
flushCache : 将其设置为true，都会导致本地缓存和二级缓存都会被清空，默认值为true（对应更新、插入和删除语句）
timeout ：超时属性有关，这个设置是在抛出异常前，等待数据库返回请求结果的秒数，默认值为unset（依赖驱动）
statementType ：可设置为statement（执行sql用的原生JDBC的statement对象执行）、prepared（执行sql用原生JDBC的prepared对象）、callable（用来调用mysql数据库的存储过程），默认是prepared，比较安全，一般不调整。
useGeneratedKeys：仅对insert和update有用，会令Mybatis使用JDBC的getGeneratedKeys方法来取出数据库内部生成的主键（比如MYSQL这样的关系型数据库管理系统的自增字段），默认为false。
keyProperty ：仅对insert和update有用，唯一标记一个属性，Mybatis会根据getGeneratedKeys的返回值或者通过insert语句的selectKey子元素设置它的键值。默认unset。
keyColumn：（仅适用于 insert 和 update）设置生成键值在表中的列名，在某些数据库（像 PostgreSQL）中，当主键列不是表中的第一列的时候，是必须设置的。如果生成列不止一个，可以用逗号分隔多个属性名称。一般不用。
databaseId：指定curd属于哪个数据库，如果带和不带的语句都有，则不带的会被忽略。

（1）使用useGeneratedKeys和keyProperty可以配合实现获取到插入后的自增id；

    <!--插入
    keyProperty:将刚才自增的id赋值给哪个属性
    -->
    <insert id="insertBook" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO book(ISBN,bookName,author,price) VALUES(#{ISBN},#{bookName},#{author},#{price})
    </insert>

    /*
    * 使用useGeneratedKeys和keyProperty可以配合实现获取到插入后的自增id*/
    @Test
    public void test3(){
        try(final SqlSession sqlSession = sqlSessionFactory.openSession();) {
            final BookMapper mapper = sqlSession.getMapper(BookMapper.class);
            final Book book = new Book(1006, "自增id测试", "自增id测试的作者", new BigDecimal("20.01"));
            final int i = mapper.insertBook(book);
            System.out.printf("插入影响了%d行\n",i);
            System.out.println("插入前的id是:"+book.getId());
            sqlSession.commit();
        }
    }

（2）使用selectKey获取非自增主键的值

    <!--全字段保存-->
    <insert id="insertBook2">
        /*order="BEFORE":可以在核心sql语句运行之前先运行一个sql，把查到的price赋值给javaBean的属性*/
        <selectKey order="BEFORE" keyProperty="id" resultType="integer">
            select max(id)+1 from book
        </selectKey>
        INSERT INTO book(id,ISBN,bookName,author,price) VALUES(#{id},#{ISBN},#{bookName},#{author},#{price})
    </insert>

     * 使用selectKey获取非自增主键的值*/
    @Test
    public void test4(){
        try(final SqlSession sqlSession = sqlSessionFactory.openSession();) {
            final BookMapper mapper = sqlSession.getMapper(BookMapper.class);
            final Book book = new Book(1007, "非自增主键测试", "非自增主键测试的作者", new BigDecimal("0.01"));
            final int i = mapper.insertBook2(book);
            System.out.printf("插入影响了%d行\n",i);
            System.out.println("插入的id是:"+book.getId());
            sqlSession.commit();
        }
    }

在默写不支持自增的数据库可以采用这种方法，但是我个人而言感觉会有问题。同一个事务中的，多个插入，即使最后没有提交，数据库也会把这几个没提交的id给占用。其他事务再添加时，不会使用这几个占用了的id。如果这样来生成主键，会不会存在不同事务同时insert时，造成id冲突呢。个人猜想，没有验证，但感觉还是尽量不用为好。

3、查询标签 - select

（1）传参数：

（1）单个参数（基本类型）

取值：#{ 随便写 }

（2）多个参数

这个时候使用 #{ 参数名 }是无效的！！！

取值： 0,1（参数索引）或者param1，param2........paramN

原因：只要传入了多个参数，mybatis会自动的将这些参数封装在一个map中，而封装时使用的key就是参数的索引和参数的第几个标识。

#{key}就是直接从这个map中取值；所以要用map中的key，我们可以告诉mybatis封装参数map时，使用我们制定的key。

使用@Param指定封装id时的key 这种称为命名参数，推荐使用!!

//根据id和图书名查
    Book getBookByIDAndName(@Param("id") Integer id, @Param("name") String bookName);

    <select id="getBookByIDAndName" resultType="com.bookStore.bean.Book">
        select *
        from book
        where id = #{id}
          and bookName = #{name}
    </select>

（3）传入了map，将多个要使用的参数封装起来。

    //使用map作为参数
    Book getBookByIdAndName2(Map<String,Object> map);

    /*
     * map封装传参
     * */
    @Test
    public void test6(){
        try(final SqlSession sqlSession = sqlSessionFactory.openSession();) {
            final BookMapper mapper = sqlSession.getMapper(BookMapper.class);
            final Map<String, Object> map = new HashMap<>();
            map.put("id",1);
            map.put("name","世界上最爱我的人");
            final Book book = mapper.getBookByIdAndName2(map);
            System.out.println("book = " + book);
            sqlSession.commit();
        }
    }

取值：#{ key }

（4）传入了POJO

取值：#{ pojo的属性名 }

无论传入什么参数，都要正确取出值。

（2）#{}和${}取值的区别

#{ 属性名 }：是参数预编译的方式，参数的位置都是用？代替，参数后来都是预编译设置进去的

${ 属性名 }：不是参数取值，而是直接和sql语句进行sql拼串，会有sql注入问题，不安全。

sql语句只有参数位置是预编译的，其他的（比如表名）不支持预编译。我们可以用${}来传入表名（分表时可能用到）；

一般都是使用#{ }，安全，在不支持预编译的位置要进行取值就使用${ }

（3）查询返回list集合

    //查询出所有图书信息
    List<Book> getAllBooks();

    <!--getAllBooks:方法返回值为一个list集合:
    如果返回的是集合，resultType写的是集合里元素的类型
    -->
    <select id="getAllBooks" resultType="com.bookStore.bean.Book">
        select * from book
    </select>

如果返回的是集合，resultType写的是集合里元素的类型。

（4）查询返回多个封装map

单条记录

    //查询单个记录返回map
    Map<String,Object> getBookByIdForMap(Integer id);

    <!--
    查询单个数据返回map：列名作为key，值作为value
    -->
    <select id="getBookByIdForMap" resultType="map">
        select *
        from book
        where id = #{id}
    </select>

    /*
     * 查询单个记录返回map
     * */
    @Test
    public void test8(){
        try(final SqlSession sqlSession = sqlSessionFactory.openSession();) {
            final BookMapper mapper = sqlSession.getMapper(BookMapper.class);
            final Map<String, Object> map = mapper.getBookByIdForMap(1);
            System.out.println("map = " + map);
            sqlSession.commit();
        }
    }

查询多条记录封装为map

使用@Mapkey指定封装的map的key

    //查询多条记录封装map
    //key就是这个记录的主键，value就是这条记录封装好的对象
    //@MapKey:把查询的记录的id作为key封装这个map
    @MapKey("id")
    Map<Integer,Book> getAllBookForMap();

这里使用map作为resultType，后边发现，实际上封装的value还是单条记录的map，

    <!--
    查询多个记录返回一个map
    -->
    <select id="getAllBookForMap" resultType="map">
        select *
        from book
    </select>

    /*
     * 查询多个记录返回一个map
     * */
    @Test
    public void test9(){
        try(final SqlSession sqlSession = sqlSessionFactory.openSession();) {
            final BookMapper mapper = sqlSession.getMapper(BookMapper.class);
            final Map<Integer, Book> map = mapper.getAllBookForMap();
            System.out.println("map = " + map);
            //虽然map的value看起来是一个对象,但仔细观察，Book对象的toString方法不是这么打印的
            final Book book = map.get(1);
            //所以resultType要写javaBean，而不是和单条记录一样的map
            System.out.println(book.getClass());
            sqlSession.commit();
        }
    }

所以resultType还是应该使用javaBean

    <!--
    查询多个记录返回一个map
    -->
    <select id="getAllBookForMap" resultType="com.bookStore.bean.Book">
        select *
        from book
    </select>

这下正常运行。

4、resultMap标签

（1）自定义封装规则

    <!--
    自定义结果集:
    id:唯一标识，让别人在后边引用的；
    type:指定为哪个javaBean自定义封装规则
    -->
    <resultMap id="myBook" type="com.bookStore.bean.Book">
        <!--
        id:指定主键列的对应规则;
        column:指定哪一列是主键列
        property:指定book的哪个的属性封装id这一列的数据，这样id属性和id列就对应起来了   
        -->
        <id column="id" property="id"/>
        <!--普通列-->
        <result column="bookName" property="name"/>
        ........
    </resultMap>
    
    <!--使用自定义的结果集-->
    <select id="getAllBookForMap" resultMap="myBook">
        select *
        from book
    </select>

（2）联合查询-级联属性的方式封装查出的数据

    <!--查询-->
    <select id="getPersonById" resultMap="myPerson">
        SELECT p1.id     id,
               p1.name   name,
               p1.father fatherId,
               p2.NAME   fatherName,
               p2.father fatherMore
        FROM person p1
                 LEFT JOIN person p2 ON p1.father = p2.id
        WHERE p1.id = #{id}
    </select>

    <!--自定义封装规则-->
    <resultMap id="myPerson" type="com.bookStore.bean.Person">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="fatherId" property="father.id"/>
        <result column="fatherName" property="father.name"/>
    </resultMap>

    /*
     * 联合查询-级联属性的方式封装查出的数据
     * */
    @Test
    public void test10(){
        try(final SqlSession sqlSession = sqlSessionFactory.openSession();) {
            final PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);
            final Person person = mapper.getPersonById(5);
            System.out.println("person = " + person);
            sqlSession.commit();
        }
    }

（3）使用association定义联合查询对象封装规则

    <!--自定义封装规则-->
    <resultMap id="myPerson" type="com.bookStore.bean.Person">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <!--接下来的属性是一个对象，自定义这个对象的封装规则，使用association表示联合了一个对象-->
        <!--javaType:指定这个属性的类型-->
        <association property="father" javaType="com.bookStore.bean.Person">
            <!--定义father属性对应的对象的封装规则-->
            <id property="id" column="fatherId"/>
            <result property="name" column="fatherName"/>
        </association>
    </resultMap>

效果和（2）一样

（4）collection标签定义集合类型属性的封装规则

一对多：外键放在多的表中

多对多：使用中间表存储对应关系

例子：查询一个人时查询出他的所有儿子

    <select id="getPersonById2" resultMap="myPerson2">
        SELECT p2.id   id,
               p2.name name,
               p1.id   sonId,
               p1.name sonName
        FROM person p1
                 LEFT JOIN person p2 ON p1.father = p2.id
        WHERE p2.id =#{id}
    </select>

    <resultMap id="myPerson2" type="com.bookStore.bean.Person">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <!--定义集合元素的属性
            property:指定哪个属性是集合属性;
            ofType:指定集合里边元素的类型; -->
        <collection property="sons" ofType="com.bookStore.bean.Person">
            <id property="id" column="sonId"/>
            <result property="name" column="sonName"/>
        </collection>
    </resultMap>

    /*
     * 联合查询-collection标签定义集合类型属性的封装规则
     * */
    @Test
    public void test11(){
        try(final SqlSession sqlSession = sqlSessionFactory.openSession();) {
            final PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);
            final Person father = mapper.getPersonById2(7);
            System.out.println("father = " + father);
            sqlSession.commit();
        }
    }

（5）使用select属性指定分布查询

    <!--select属性指定分布查询-->
    <select id="getPersonByIdForSelect" resultMap="myPerson3">
        select *
        from person
        where id = #{id}
    </select>

    <select id="getPersonByFather" resultType="com.bookStore.bean.Person">
        select *
        from person
        where id = #{id}
    </select>

    <resultMap id="myPerson3" type="com.bookStore.bean.Person">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <!--select:Mybatis自动调用指定的sql将查出来的结果封装-->
        <!--column:指定将哪一列的值封装上去-->
        <association property="father" javaType="com.bookStore.bean.Person"
                     select="com.bookStore.dao.PersonMapper.getPersonByFather" column="father"/>
    </resultMap>

    /*
     * 使用select属性指定分布查询
     * */
    @Test
    public void test12(){
        try(final SqlSession sqlSession = sqlSessionFactory.openSession();) {
            final PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);

            final Person person = mapper.getPersonByIdForSelect(5);
            System.out.println("person = " + person);
            sqlSession.commit();
        }
    }

这样，如果我只使用了id，name，没有用到father属性，但它还是每一次都会调用两个sql，把father封装出来。就造成了性能浪费所以，接下来......

（6）按需加载和延迟加载

在mybatis配置文件中设置

lazyLoadingEnabled 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 true | false false

aggressiveLazyLoading 开启时，任一方法的调用都会加载该对象的所有延迟加载属性。否则，每个延迟加载属性会按需加载（参考 lazyLoadTriggerMethods)。 true | false false （在 3.4.1 及之前的版本中默认为 true）

全局开启按需加载策略

    <settings>
        <!--开启延迟加载开关-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--开启属性按需加载-->
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

同时，我们还可以局部设置，覆盖全局配置

延迟加载也可以在collection中使用

这次又写信给哪位

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
sql映射文件

1、所有可用标签cache：缓存有关 cache-ref：和缓存有关 delete、insert、update、select：增删改查 parameterMap：参数Map，已经废弃，原本是做复杂参数映射的 resultMap：结果映射，自定义结果集的封装规则； sql：抽取可重用的sql2、增删改标签可用的标签：id：要实现接口的方法名 databaseId：指定curd属于哪个数据库 parameterType:...
复制链接

扫一扫

专栏目录