MyBatis（一）-映射

最新推荐文章于 2024-06-01 20:31:56 发布
原创 最新推荐文章于 2024-06-01 20:31:56 发布 · 519 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了MyBatis框架的使用方法，包括如何通过XML和注解进行CRUD操作，以及如何处理一对一、一对多和多对多的关联映射。详细介绍了SqlSessionFactory和SqlSession的使用，以及事务控制和缓存清理的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

MyBatis是支持普通SQL查询，存储过程和高级映射的优秀持久层框架，其使用简单的xml或注解用于配置和原始映射，将接口和Java的POJO映射成数据库中的记录；

所用的jar以及xml:

链接：https://pan.baidu.com/s/11eoHPbvS8mNzkAgolFYqoQ
提取码：ze4i

命令行自动生成映射文件：java -jar mybatis1.jar -configfile generator.xml -overwrite


MyBatis持久化步骤：

  • 持久化类PO和编写持久化操作的Mapper.xml（对应的Mapper接口），在其中定义要执行的SQL语句；
  • 获取SqlSessionFactory;
  • 获取SqlSession;
  • 用面向对象的方式操作数据库；
  • 关闭事务，关闭SqlSession;

SqlSessionFactory是单个数据库映射关系经过编译后的内存镜像，且线程安全；

sqlSessionFactory=new SqlSessionFactoryBuilder().build(PersonImpl.class.getClassLoader().getResourceAsStream("mybatis.cfg.xml"));

SqlSession是执行持久化的操作的对象，类似于JDBC的Connection,是应用程序与持久存储层之间执行交互操作的一个单线程对象，其方法有：

语句执行方法：

这些方法被用来执行定义在 SQL 映射的 XML 文件中的 SELECT,INSERT,UPDA E T 和 DELETE 语句。它们都会自行解释,每一句都使用语句的 ID 属性和参数对象,参数可以 是原生类型(自动装箱或包装类) ,JavaBean,POJO 或 Map。

namespace + id : 即：namespace 定位到唯一的mapper映射文件，id 定位到这个mapper映射文件的指定的sql语句：

<T> T selectOne(String statement, Object parameter)

<E> List<E> selectList(String statement, Object parameter)

<K,V> Map<K,V> selectMap(String statement, Object parameter, String mapKey)

int insert(String statement, Object parameter)

int update(String statement, Object parameter)

int delete(String statement, Object parameter)

<T> T selectOne(String statement)

selectOne 和 selectList 的不同仅仅是 selectOne 必须返回一个对象。 如果多余一个, 或者 没有返回 (或返回了 null) 那么就会抛出异常。 , 如果你不知道需要多少对象, 使用 selectList。

如果你想检查一个对象是否存在,那么最好返回统计数(0 或 1) 。因为并不是所有语句都需 要参数,这些方法都是有不同重载版本的,它们可以不需要参数对象。

<E> List<E> selectList(String statement)

<K,V> Map<K,V> selectMap(String statement, String mapKey)

int insert(String statement)

int update(String statement)

int delete(String statement)

<E> List<E> selectList (String statement, Object parameter, RowBounds rowBounds)

它们允许你限制返回行数的范围,或者提供自定 义结果控制逻辑,这通常用于大量的数据集合。

<K,V> Map<K,V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowbounds)

void select (String statement, Object parameter, ResultHandler handler)

void select (String statement, Object parameter, RowBounds rowBounds, ResultHandler handler)

事务控制方法：

控制事务范围有四个方法。如果是自动提交或正在使用外部事务管理器,则不需要这四个方法。若使用 JDBC 事务管理员,由 Connection 实例来控制,则需要这四个方法；

默认情况下 MyBatis 不会自动提交事务, 除非它侦测到有插入, 更新或删除操作改变了 数据库。如果你已经做出了一些改变而没有使用这些方法,那么你可以传递 true 到 commit 和 rollback 方法来保证它会被提交(注意,你不能在自动提交模式下强制 session,或者使用 了外部事务管理器时) 。很多时候你不用调用 rollback(),因为如果你没有调用 commit 时 MyBatis 会替你完成。然而,如果你需要更多对多提交和回滚都可能的 session 的细粒度控 制,你可以使用回滚选择来使它成为可能。

void commit()

void commit(boolean force)

void rollback()

void rollback(boolean force)

void clearCache()

清理 Session 级的缓存
void close()确保 SqlSession 被关闭
<T> T getMapper(Class<T> type)使用映射器，返回Mapper接口的代理对象

Connection getConnection()

获得JDBC的数据库连接对象

MyBatis初始化基本过程：

sqlSessionFactory=new SqlSessionFactoryBuilder().build(PersonImpl.class.getClassLoader().getResourceAsStream("mybatis.cfg.xml"));

SqlSessionFactoryBuilder根据传入的数据流生成Configuration对象，然后根据Configuration对象创建默认的SqlSessionFactory实例；

简单的xml-CRUD：

UserMapper.xml

<?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="com.answer.mapper.UserMapper">
    <select id="selectUserById" parameterType="int" resultType="com.answer.model.User" resultMap="userResultMap">
        select * from tb_user where id= #{id}
    </select>
    <insert id="insert" parameterType="com.answer.model.User">
        insert into tb_user() values (#{id},#{username},#{loginname},
        #{pword},#{phone},#{address})
    </insert>
    <delete id="delete" parameterType="int">
        delete from tb_user where id=#{id}
    </delete>
    <update id="update" parameterType="com.answer.model.User">
        update tb_user
        set username =#{username},loginname=#{loginname},
        pword=#{pword},phone=#{phone},address=#{address}
        where id=#{id}
    </update>
</mapper>

UserMapper接口：

public interface UserMapper {
    User selectUserById(int id);
    List<Order> selectOrderByUserId(int id);
    int insert(User user);
    int delete(int id);
    int update(User user);
    User selectUserByIdDy(int id);
}

测试：

private SqlSessionFactory sqlSessionFactory;
    public UserImpl(){
        sqlSessionFactory=new SqlSessionFactoryBuilder().build(PersonImpl.class.getClassLoader().getResourceAsStream("mybatis.cfg.xml"));

    }
    @Test
    public void query(){
        SqlSession sqlSession=sqlSessionFactory.openSession();
        try{
            User user=sqlSession.selectOne("selectUserById",1);
            System.out.println(user.getOrders());
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }
    @Test
    public void insert(){
        SqlSession sqlSession=sqlSessionFactory.openSession();
        try{
            User user=new User();
            user.setId(2);
            user.setUsername("刘");
            user.setLoginname("liu");
            user.setPword("123123");
            user.setPhone("98474929");
            user.setAddress("兰州");
            sqlSession.selectOne("insert",user);
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }
    @Test
    public void del(){
        SqlSession sqlSession=sqlSessionFactory.openSession();
        try{
            sqlSession.selectOne("delete",2);
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }
    @Test
    public void update(){
        SqlSession sqlSession=sqlSessionFactory.openSession();
        try{

            User user=new User();
            user.setId(2);
            user.setUsername("刘");
            user.setLoginname("liuyf");
            user.setPword("123123000");
            user.setPhone("9847492999");
            user.setAddress("兰州安宁");
            sqlSession.selectOne("update",user);
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }

xml关联映射：

一对一：Card和Person

<?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="com.answer.mapper.CardMapper">
    <select id="selectCardById" parameterType="int" resultType="com.answer.model.Card">
        select * from tb_card where id= #{id}
    </select>
</mapper>
<mapper namespace="com.answer.mapper.PersonMapper">
    <select id="selectPersonById" parameterType="int" resultMap="personMapper">
        select * from tb_person where id= #{id}
    </select>
    <resultMap id="personMapper" type="com.answer.model.Person">
        <id property="id" column="id"/>
        <result property="name" column="name"></result>
        <result property="sex" column="sex"></result>
        <result property="age" column="age"></result>
        <!-- 一对一关联映射-->
        <association property="card" column="card_id"
                     select="com.answer.mapper.CardMapper.selectCardById"
                     javaType="com.answer.model.Card">
        </association>
    </resultMap>
</mapper>

测试：

private SqlSessionFactory sqlSessionFactory;
    public PersonImpl(){
        sqlSessionFactory=new SqlSessionFactoryBuilder().build(PersonImpl.class.getClassLoader().getResourceAsStream("mybatis.cfg.xml"));

    }
    @Test
    public void query(){
        SqlSession sqlSession=sqlSessionFactory.openSession();
        try{
            /*Card card=sqlSession.selectOne("selectCardById",1);
            System.out.println(card.getCard());*/
            Person person=sqlSession.selectOne("selectPersonById",1);
            System.out.println(person.getName()+":"+person.getCard().getCard());
            /*PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            Person person=personMapper.selectPersonById(1);*/
            //System.out.println(person.getName()+":"+person.getCard().getCard());
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }

一对多：Class和Student

<mapper namespace="com.answer.mapper.ClassMapper">
    <select id="selectClassById"  parameterType="int" resultMap="classResultMapper">
        select * from tb_class where id= #{id}
    </select>
    <resultMap id="classResultMapper" type="com.answer.model.Class">
        <id property="id" column="id"/>
        <result property="code" column="code"/>
        <result property="name" column="name"/>
        <!-- 一对多关联映射-->
        <collection property="student" javaType="ArrayList"
                    column="id" ofType="com.answer.model.Student"
                    select="com.answer.mapper.StudentMapper.selectStudentByClassId"
                    fetchType="lazy">
            <id property="id" column="id"/>
            <result property="name" column="name"/>
            <result property="sex" column="sex"/>
            <result property="age" column="age"/>
        </collection>
    </resultMap>
</mapper>
<mapper namespace="com.answer.mapper.StudentMapper">
    <select id="selectStudentById" parameterType="int" resultMap="studentResultMapper">
  	SELECT * FROM tb_clazz c,tb_student s
  	WHERE c.id = s.clazz_id
  	 AND s.id = #{id}
  </select>
    <select id="selectStudentByClassId"  parameterType="int" resultMap="studentResultMapper">
        select * from tb_student where class_id= #{id}
    </select>
    <resultMap id="studentResultMapper" type="com.answer.model.Student">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="sex" column="sex"/>
        <result property="age" column="age"/>
        <!-- 多对一关联映射-->
        <association property="aClass" column="class_id"
                     select="com.answer.mapper.ClassMapper.selectClassById"
                     javaType="com.answer.model.Class">
            <id property="id" column="id"/>
            <result property="code" column="code"/>
            <result property="name" column="name"/>
        </association>
    </resultMap>
</mapper>

测试：

private SqlSessionFactory sqlSessionFactory;
    public ClassImpl(){
        sqlSessionFactory=new SqlSessionFactoryBuilder().build(PersonImpl.class.getClassLoader().getResourceAsStream("mybatis.cfg.xml"));

    }
    @Test
    public void query(){
        SqlSession sqlSession=sqlSessionFactory.openSession();
        try{
            Class c=sqlSession.selectOne("selectClassById",1);
            System.out.println(c.getName());
            List<Student> list=c.getStudent();
            list.forEach(student -> System.out.println(student.getName()+":"+student.getaClass().getName()));
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }

多对多：Order和Article(需建立中间表item)

<mapper namespace="com.answer.mapper.OrderMapper">

    <resultMap id="orderResultMap" type="com.answer.model.Order">
        <id property="id" column="oid"/>
        <result property="code" column="code"/>
        <result property="total" column="total"/>
        <association property="user" column="user_id"
                     select="com.answer.mapper.UserMapper.selectUserById"
                     javaType="com.answer.model.User">
            <id property="id" column="id"/>
            <result property="username" column="username"/>
            <result property="loginname" column="loginname"/>
            <result property="pword" column="pword"/>
            <result property="phone" column="phone"/>
            <result property="address" column="address"/>
        </association>
        <collection property="articles" javaType="ArrayList"
                    column="id" ofType="com.answer.model.Article"
                    select="com.answer.mapper.ArticleMapper.selectArticleByOrderId"
                    fetchType="lazy">
            <id property="id" column="id"/>
            <result property="name" column="name"/>
            <result property="price" column="price"/>
            <result property="remark" column="remark"/>
        </collection>
    </resultMap>
    <!-- 注意，如果查询出来的列同名，例如tb_user表的id和tb_order表的id都是id，同名，需要使用别名区分 -->
    <select id="selectOrderById" parameterType="int" resultMap="orderResultMap">
  	SELECT u.*,o.id AS oid,CODE,total,user_id
  	 FROM tb_user u,tb_order o
  	WHERE u.id = o.user_id
  	 AND o.id = #{id}
  </select>

    <!-- 根据userid查询订单 -->
    <select id="selectOrderByUserId" parameterType="int" resultType="com.answer.model.Order">
  	SELECT * FROM tb_order WHERE user_id = #{id}
  </select>

</mapper>
<mapper namespace="com.answer.mapper.ArticleMapper">

    <select id="selectArticleByOrderId" parameterType="int" resultMap="articleResultMapper">
  	SELECT * FROM tb_article WHERE id IN (
		SELECT article_id FROM tb_item WHERE order_id = #{id}
	)
  </select>
	<select id="selectArticleById"  parameterType="int" resultMap="articleResultMapper">
        select * from tb_article where id= #{id}
    </select>
	<resultMap id="articleResultMapper" type="com.answer.model.Article">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<result property="price" column="price"/>
		<result property="remark" column="remark"/>
	</resultMap>
</mapper>

测试:

private SqlSessionFactory sqlSessionFactory;
    public OrderImpl(){
        sqlSessionFactory=new SqlSessionFactoryBuilder().build(PersonImpl.class.getClassLoader().getResourceAsStream("mybatis.cfg.xml"));

    }
    @Test
    public void query(){
        SqlSession sqlSession=sqlSessionFactory.openSession();
        try{
            /*List<Order> orders=sqlSession.selectList("selectOrderByUserId",1);
            orders.forEach(order -> System.out.println(order.getArticles()));
            for(Order order:orders){
                System.out.println(order.getArticles());
            }*/
            Order order=sqlSession.selectOne("selectOrderById",1);
            System.out.println(order.getUser().getUsername());
            List<Article> articles=order.getArticles();
            articles.forEach(article -> System.out.println(article.getName()));
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }

简单的注解-CRUD：

UserMapper接口：

@Select("select * from tb_user where id=#{id}")
    @Results({
         @Result(id = true,property = "id",column = "id"),
            @Result(property ="username",column = "username"),
            @Result(property ="loginname",column = "loginname"),
            @Result(property ="pword",column = "pword"),
            @Result(property ="phone",column = "phone"),
            @Result(property ="address",column = "address"),
    })
    User selectUserById(int id);

@Insert("insert into tb_user() values(#{id},#{username},#{loginname},#{pword},#{phone},#{address})")
    int insert(User user);

    @Delete("delete from tb_user where id=#{id}")
    int delete(int id);

    @Update("update tb_user set username =#{username},loginname=#{loginname}," +
            "        pword=#{pword},phone=#{phone},address=#{address}" +
            "        where id=#{id}")
    int update(User user);

测试同xml;

一对一：Card和Person

CardMapper接口:

@Select("select * from tb_card where id=#{id}")
    @Results({
            @Result(id = true,property = "id",column = "id"),
            @Result(property = "card",column = "card"),

    })
    Card selectCardById(int id);

PersonMapper接口：

@Select("select * from tb_person where id=#{id} ")
    @Results({
            @Result(id=true,property = "id",column = "id"),
            @Result(property = "name",column = "name"),
            @Result(property = "sex",column = "sex"),
            @Result(property = "age",column = "age"),
            @Result(property = "card",column = "card_id",
            one = @One(select = "com.answer.mapper.CardMapper.selectCardById"))
    })
    Person selectPersonById(int id);

一对多：Class和Student

public interface ClassMapper {
    @Select("select * from tb_class where id=#{id}")
    @Results({
            @Result(id = true,property = "id",column = "id"),
            @Result(property ="code",column = "code"),
            @Result(property ="name",column = "name"),
            @Result(property = "student",column = "id",
            many = @Many(select = "com.answer.mapper.StudentMapper.selectStudentByClassId"))
    })
    Class selectClassById(int id);
}
public interface StudentMapper {
    @Select("select * from tb_student where id=#{id}")
    @Results({
            @Result(id = true,property = "id",column = "id"),
            @Result(property ="name",column = "name"),
            @Result(property ="sex",column = "sex"),
            @Result(property ="age",column = "age"),
            @Result(property = "aClass",column = "class_id",
                    one = @One(select = "com.answer.mapper.ClassMapper.selectClassById"))
    })
    Student selectStudentById(int id);

    @Select("select * from tb_student where class_id=#{id}")
    @Results({
            @Result(id = true,property = "id",column = "id"),
            @Result(property ="name",column = "name"),
            @Result(property ="sex",column = "sex"),
            @Result(property ="age",column = "age")
    })
    List<Student> selectStudentByClassId(int id);
}

多对多：Order和Article(需建立中间表item)

public interface OrderMapper {
    @Select("select * from tb_order where id=#{id}")
    @Results({
            @Result(id=true,property = "id",column = "id"),
            @Result(property = "code",column = "code"),
            @Result(property = "total",column = "total"),
            @Result(property = "articles",column = "id",
            many = @Many(select = "com.answer.mapper.ArticleMapper.selectArticleByOrderId"))
    })
    Order selectOrderById(int id);

}
public interface ArticleMapper {
    @Select("select * from tb_article where id in (select article_id from tb_item where order_id=#{id})")
    @Results({
            @Result(id = true,property = "id",column = "id"),
            @Result(property = "name",column = "name"),
            @Result(property = "price",column = "price"),
            @Result(property = "remark",column = "remark")
    })
    List<Article> selectArticleByOrderId(int id);

    
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

mybatis映射
zhang_asd的博客
11-30 719
1 映射文件XXMapper.xml语法： <mapper namespace="cn.smbms.dao.user.UserMapper"> <select id="getUserList" … …… </select> </mapper> 1.1 namespace：命名空间 namespace的命名必须跟某个接口同名 1.2 id: 命名空间中唯一的标识符 接口中的方法与映射文件中的SQL语句id一一对应 1.3 parameterTy
Mybatis——mybatis的mapper映射配置文件、个别场景记录
YR_112233的博客
11-30 7207
mybatis的mapper映射配置文件详解 一、常用属性标签 1、namespace的作用 在MyBatis中，Mapper中的namespace用于绑定Dao接口的，即面向接口编程。namespace属性的值要和对应的Mapper接口的全限定名保持一致 它的好处在于当使用了namespace之后就可以不用写接口实现类，业务逻辑会直接通过这个绑定寻找到相对应的SQL语句进行对应的数据处理 2、常用标签介绍 insert,update,delete,select,sql,resultMap sql:可被其它
Mybatis映射详解
热门推荐
asxyxxx的博客
11-20 1万+
在最近的工作中，碰到一个比较复杂的返回结果，发现简单映射已经解决不了这个问题了，只好去求助百度，学习mybatis复杂映射应该怎么写，将学习笔记结合工作碰到的问题写下本文，供自身查漏补缺，同时已被不时之需。
Mybatis映射
zmzmii的博客
12-09 549
     当mybatis的查询结果具有一对多和多对一还有一对一的映射关系，为一对多的关系时，例如球队和队员的关系，我们可以理解为一个球队拥有多个球员。此时这里的一为球队，多为球员。多对一、一对一就是这样类似，可以举一反三。   多对一映射   表示一个球员时，既要表示他本身的球员信息，又要表示球员的球队信息，那么我们该怎么做呢？   首先，先将实体类写出来 图1   getter和setter省略了，下方补上关系图吧 图2   多方的球员对应着一方的球队。比如同一个球队的人，库里、汤普森、威金斯，所在
MyBatis 映射
S_numb的博客
02-22 517
文章目录1. resultType2. resultMap MyBatis 在查询进行 select 映射的时候，返回类型可以用 resultType 和 resultMap，resultType 是直接表示返回类型的，resultMap是对外部的resultMap 的引用，在 select 标签中， resultType 和 resultMap是不能同时存在的。 在 MyBatis 进行查询映射...
mybatis-3-config.dtd mybatis-3-mapper.dtd
10-13
`mybatis-3-mapper.dtd` 文件则是MyBatis映射器文件的DTD文档，用于定义映射文件的结构。映射文件通常包含SQL查询、结果映射、参数映射等，它们定义了如何将Java对象与数据库中的表进行对应。例如： 1. `<select>`：...
MybatisX-1.7.3.zip
最新发布
04-24
6. 高级映射支持：MybatisX增强了Mybatis原有的映射功能，支持多对一、一对多等复杂关系映射，减少了开发者的编码负担，让数据关系的处理变得更加简单。 7. 代码重构：MybatisX支持数据库结构变更时的代码重构，如...
idea插件MybatisX-1.6.1
02-23
MybatisX是一款针对IntelliJ IDEA的高效MyBatis开发插件，版本为1.6.1。这个插件旨在简化MyBatis框架在IDEA中的使用，提高开发效率，帮助开发者快速完成与MyBatis相关的各种任务。下面将详细介绍这款插件的主要功能...
mybatis 中映射
小加的博客
06-04 295
1. 一个实体里面包含另一个实体如：对应的mapper 配置文件2. 一个实体包含 一个   List&lt;Entity&gt; 如：对应的mapper.xml
MyBatis 映射器
java那些事儿
09-29 525
映射器是MyBatis最复杂最重要的组件。它是由一个接口加上XML文件（或注解）组成。 在映射器中可以配置参数、各类的SQL语句、存储过程、缓存、级联等复杂的内容，并且通过简易的映射规则映射到POJO或者其他对象 上，映射器也能有效消除JDBC底层的代码。 MyBatis的映射器也可以使用注解来完成，但是这里不提倡使用，原因有三： （1）面对复杂性，SQL会显得无力，尤其是长的SQL。 （
MyBatis的关联映射
06-21
1、已知数据库MyBatisRelation中存在以下几个表： a. 学生(Student)：id(int, primary key, auto increment)，Name(姓名，varchar)，Birthday(出生日期，date)，性别(Sex，varchar) b. 学生证(StudentIDCard)：id(int, primary key, auto increment)，StuNo(学号，long) c. 班级(Class)：id(int, primary key, auto increment)，Specialty(专业，varchar)，Grade(年级，int)，Class(班，int) d. 课程(Course)：id(int, primary key, auto increment)，Name(课程名，varchar) 现建立以下的关联关系：学生与学生证、学生与班级、学生与课程的选课。分别说出这三种关系属于MyBatis关联关系的哪种类型，通过在相应表中添加合适的外键或创建中间表的方式实现这些关联关系，并创建相应的类，实现以下的查询： (1)通过Student表的id查找该学生的信息，并同时获取其学号； (2)通过Class表的id查找某个班级的信息，并同时查找该班级的所有学生信息； (3)通过Student表的id查找该学生的信息，并同时获取其选课信息。 以上每种查询都使用嵌套查询和嵌套结果查询实现。
MyBatis关系映射
TestXzing的博客
09-04 1682
在关系映射中，MyBatis提供了一些注解和XML配置来实现对象和数据库表之间的映射关系。例如，@Table注解可以用于指定Java对象对应的数据库表，@Column注解可以用于指定Java对象属性对应的数据库字段。
Mybatis(二）--映射
m0_51945098的博客
12-01 495
1 映射文件XXMapper.xml语法： <mapper namespace="cn.kgc.mspper.UserMapper"> <select id=" findCount " … …… </select> </mapper> 1.1 namespace：命名空间 namespace的命名必须跟某个接口同名 1.2 id: 命名空间中唯一的标识符** 接口中的方法与映射文件中的SQL语句id一一对应 1.3 parameterType: 参数类型
MyBatis映射文件
zhangyuanshuai的博客
01-15 587
Mapper映射文件 MyBatis Mapper映射文件主要包含以下标签： select、insert、updae、delete、resultMap、parameterMap、sql、include、selectKey。 select 查询标签，对应一条查询语句。示例： <select id="selectUserById" paramterType="Integer" resultType="User"> select * from user where id = #{id} &lt
MyBatis 关联映射
m0_52861684的博客
11-17 3396
MyBatis 关联映射，实现数据的一对一、一对多、多对多查询，同时对嵌套查询和嵌套结果集两种配置方法分别进行了演示。
Mybatis-映射
一蓑烟雨任平生
08-15 784
#{}和${}的区别 #{}是占位符，预编译处理；${}是拼接符，字符串替换，没有预编译处理。 Mybatis在处理#{}时，#{}传入参数是以字符串传入，会将SQL中的#{}替换为?号，调用PreparedStatement的set方法来赋值。 Mybatis在处理时，是原值传入，就是把{}时，是原值传入，就是把时，是原值传入，就是把{}替换成变量的值，相当于JDBC中的Statement编译 变量替换后，#{} 对应的变量自动加上单引号 ‘’；变量替换后，${} 对应
带你学习Mybatis之Mybatis映射文件
Lxn2zh的博客
06-01 1501
补全预编译语句，调用PreparedStatement的set方法来赋值，有效的防止Sql语句注入，这种取值是编译好SQL语句再取值。很多情况下使用map作为返回是可以支持的，但是map不是一个很好的领域模型，在获取到数据库结果之后，还需要再去人工的从map中取值给业务需要的字段去赋值，是一件痛苦而繁琐的事情。使用PO进行接收结果集时，考虑到数据库中的列名可能与po中的字段名不一致，需要为每个字段起别名，sql写起来就变长了很多。{}直接替换成变量的值，不做任何转换，这种是取值以后再去编译SQL语句。
MyBatis映射器
m0_46604319的博客
02-22 865
Mybatis配置概述 MyBatis的核心配置文件配置了很多影响MyBatis行为的信息，这些信息通常只会配置在一个文件中，并且不会轻易改动。另外，与Spring框架整合后，MyBatis的核心配置文件信息将配置到Spring的配置文件中。因此，在实际开发中需要编写或修改MyBatis的核心配置文件的情况不多。 映射器 在SQL映射文件中元素用于映射SQL的select语句，其示例代码如下： <!-- 根据uid查询一个用户信息 --> <selectid="selectUserByI
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Dream答案

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值