MyBatis学习笔记

最新推荐文章于 2024-07-21 13:35:10 发布
最新推荐文章于 2024-07-21 13:35:10 发布
阅读量1.2k 收藏 4
点赞数 1
分类专栏： mybatis
本站已迁移至：https://jacksonary.github.io
本文链接：https://blog.csdn.net/jacksonary/article/details/80074941
版权

 先做个科普吧，MyBatis是其3.0以后的叫法，之前的版本都叫iBatis，这个名字肯定听过吧，也是大名鼎鼎的Apache旗下的产品，后来易主谷歌，正式改名为MyBatis，代码迁到github上。它是一种持久化框架，和Hibernate一样都是ORM(Object Relation Mapping，对象关系映射)框架，他们需要完成的任务都是将JavaBean映射成数据库中的一条记录。

 不管是什么框架，Java和数据库交互，内部肯定少不了jdbc的支持(所有的框架都是对原生JDBC方式的封装)，但是之前接触的都是jdbc的小工具，而不是框架。jdbc本身sql语句都是写在java代码中的，逻辑很混乱，耦合度也很高，所以不好，这里先回顾一下jdbc操作数据的流程：

这里写图片描述

 Hibernate是我学习的第一个ORM框架，觉得挺好用，后来接触到了MyBatis，由于追星的原因，我从来原来的SSH转成了SSM架构开发，网上很多大牛都说Hibernate不如MyBtais好用，不够灵活，我也不懂为什么这么说，但是那么多比我厉害的人都说它好用，那就用呗，反正我是不知道哪里好，今天终于好像有点懂了_。首先看一下Hibernate，它是一个全自动的ORM框架，它的工作流程如下：

这里写图片描述

Hibernate把jdbc的工作都做完了，连编写SQL这活儿都包了，其实挺好的，我就只要面向对象去撸代码就好了，而且Hibernate框架是全映射的ORM(啥意思，就是如果JavaBean有多少属性，它查询时候就直接将对应表中的属性字段全部查询出来，这里我想问一下懒加载这一块有没有反驳的理由)，但是这样就带来一个问题，它的SQL的控制权没有留给开发人员带来方便(针对小项目)的同时也带来了麻烦。因为在写大的工程时，不可能不涉及SQL的优化问题，我们需要去自己写SQL，但是Hibernate的本质目的就是为了消除SQL语句，让不懂SQL的人员也可以实现增删改查，那怎么办，当然在Hibernate中也提供了HQL语言，通过HQL我们可以定制SQL语句，但是这个过程还是比较麻烦的，所以说Hibernate不灵活。

 基于上述Hibernate的全封装弊端，我们希望SQL由我们自己写，所以MyBatis出现了，它和Hibernate最大的不同就是将SQL的控制权交给了我们自己(单独放到配置文件中)，因为作为一个框架要是要有点逼格的，不能啥都不做吧(所以说MyBatis是一个半自动化框架)，它的工作流程如下：

这里写图片描述

1. Hello,MyBatis!

 同理，首先给出MyBatis官网教程，这个是最好的老师，同时，在MyBatis的压缩包中有一个pdf文件也是文档教程。好了，开始搞第一个Demo吧，本文中所有Mybatis的栗子默认都是基于当前最新版本MyBatis-3.4.6。

  • 导入mybatis-3.4.6.jar、mysql-connector-java-5.1.7-bin.jar和log4j-1.2.17.jar，创建一个JavaBean为Employee:
public class Employee {
   
    private int id;
    private String lastName;
    private String gender;
    private String email;
    //getter and setter as well as toString
}

对应的MySQL的表结构如下
这里写图片描述

  • 创建MyBatis的核心配置文件(全局配置文件)：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>
    <!--
        MyBatis的配置文件中子标签必须按照一定的顺序去写
        不按顺序有的配置将不生效或者直接报错；
        正确的子标签顺序应该依次为：
        properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,
        reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?
    -->
    <!--配置MyBatis在控制台打印sql语句，需要配置log4j使用-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/db_mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="921228jack"/>
            </dataSource>
        </environment>
    </environments>

    <!--sql映射文件是在写完mapper文件后再加入这里面的-->
    <mappers>
        <mapper resource="conf/EmployeeMapper.xml"/>
    </mappers>

</configuration>

因为配置了log4j日志，所以这里需要额外写一个log4j的配置文件log4j.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/xml/doc-files/log4j.dtd">

<log4j:configuration debug="true">

<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8"/>
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m  (%F:%L) \n"/>
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug"/>
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info"/>
    </logger>
    <root>
        <level value="debug"/>
        <appender-ref ref="STDOUT"/>
    </root>
</log4j:configuration>
  • 配置sql映射文件EmployeeMapper.xml，里面封装了每一条SQL语句，并将其配置到全局配置文件中：
<?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">
<!--namespace：名称空间，写全类名-->
<mapper namespace="com.hhu.entity.Employee">
    <!--id：唯一标识，就是方法名
         resultType：返回值类型，即执行sql后的返回值想要怎么处理，封装成什么对象
         #{
   id}：从方法传入的参数“id”获取传入sql语句的参数
     -->
    <select id="selectEmp" resultType="com.hhu.entity.Employee">
        <!--这里是查不到lastName属性的，MyBatis默认根据JavaBean中的属性名的方式去查找
              数据库，如果属性和字段名对不上，那么就查不到；
              解决方法：在mapper文件属性名和字段名不一样地方，用JavaBean中的属性名做该字段的别名，
              不用通配符*，即可
        -->
        select id, last_name lastName, gender,email from tbl_employee where id = #{
   id}
    </select>
</mapper>
  • 测试MyBatis的操作流程：
/**
    * 1. 根据xml配置文件创建一个SqlSessionFactory，再由此创建sqlSession，通过它可以实现MyBatis对数据库的增删改查，每一次用完后一定要将其关闭；
    * 2. sql映射文件(即mapper文件)，配置每一条sql语句和其封装规则
    * 3. 将sql映射文件配置到全局配置文件mybatis-config.xml
    */
@Test
public void testSqlSession() throws IOException {
   
    //读取配配置文件（这是一MyBatis的核心配置文件，也是一个全局配置文件）
    String resource = "conf/mybatis-config.xml";
    //注意这里的Resources是apach包下面的类
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    //获取sqlSession，它可以执行已经映射的SQL语句（即mapper中的文件）
    SqlSession sqlSession = sqlSessionFactory.openSession();

    //注意这里使用try-finally，不管如何，最后一定要将sqlSession关闭
    try{
   
        //第一个参数是唯一标识，第二个参数是执行SQL传入的参数
        Employee employee = sqlSession.selectOne("selectEmp", 2);
        System.out.println(employee);
    } finally {
   
        //关闭Session
        sqlSession.close();
    }

}

2. 面向接口编程的MyBatis(推荐)

 在前一小节，使用MyBatis的方式有些古老，正常情况我们都是通过在Dao层的接口直接去关联的mapper的sql映射文件，而不是通过想selectOne类似指定唯一标识符的方式去执行sql，而且这个接口我们不需要有实现类，下面看下MyBatis更为常见的接口使用方式。

  • 创建接口EmployeeDao:
public interface EmployeeDao {
   
    public Employee getEmployeeById(int id);
}
  • 将接口与sql映射文件动态绑定：
<?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">
<!--namespace：名称空间，写绑定接口的全类名-->
<mapper namespace="com.hhu.dao.EmployeeDao">
    <!--id：唯一标识，就不是随意写了，需要写成绑定接口中对应的方法名
         resultType：返回值类型，即执行sql后的返回值想要怎么处理，封装成什么对象
         #{
   id}：从方法传入的参数“id”获取传入sql语句的参数
     -->
    <select id="getEmployeeById" resultType="com.hhu.entity.Employee">
        <!--这里是查不到lastName属性的，MyBatis默认根据JavaBean中的属性名的方式去查找
              数据库，如果属性和字段名对不上，那么就查不到；
              解决方法：在mapper文件属性名和字段名不一样地方，用JavaBean中的属性名做该字段的别名，
              不用通配符*，即可
        -->
        select id, last_name lastName, gender,email from tbl_employee where id = #{
   id}
    </select>
</mapper>
  • 调用：
@Test
public void testInterface() throws IOException {
   
    //从配置文件的输入流读取配置创建SessionFactory
        InputStream is = Resources.getResourceAsStream("conf/mybatis-config.xml");
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);

        //打开一个会话
        SqlSession sqlSession = sessionFactory.openSession();

        try {
   
            //这里虽然是获取的是接口类型的类，但是一旦将接口和sql映射文件动态绑定后
            //MyBatis会自动为接口创建代理对象
            EmployeeDao employeeDao = sqlSession.getMapper(EmployeeDao.class);
            //查看获取对象的类型，可以发现是一个代理对象，可以通过这个代理对象实现增删改查
            System.out.println(employeeDao.getClass());
            Employee e = employeeDao.getEmployeeById(1);
            System.out.println(e);
        } finally {
   
        sqlSession.close();
        }
    }

经过上述的工作就完成了，在学习过Hibernate和MyBatis之后发现两者都有SqlSession，并且都是通过它来操作数据库，也就是说通过这个对象可以获取Connection对象。

【注意】SqlSession和Connection一样都是非线程安全的，在多线程环境下不能将它们作为成员变量放在外面!比如：

public class TestSqlSessionFactory {
   

private SqlSession sqlSession = null;

    @Test
    public void test1() {
   ...}

    @Test
    public void test1() {
   ...}

    @Test
    public void test1() {
   ...}
}

上面的写法就是有问题的，如果多线程都获取了这个SqlSession，A线程操作完直接关闭了，那其他线程怎么办，对吧，所以每次都要去获取显得实例。

3. MyBatis的全局配置文件(mybatis-config.xml)

 mybatis-config.xml是MyBatis的全局配置文件，也是其核心配置文件，上面是以xml的形式来搞的，当然我们也可以不去搞这个文件，而是通过其他的方式，具体参见官方文档。关于MyBatis的全局配置文件需要写的东西基本都涵盖在了<configuration>和</configuration>标签中，下面着重对这个标签中的各个子标签做说明。

 这里重要的地方再说一遍，被坑过啊，MyBatis的配置文件中标签必须按照指定的顺序去写，不按顺序写将直接报错！！
正确的标签顺序应该依次为：properties，settings，typeAliases，typeHandlers，objectFactory，objectWrapperFactory，reflectorFactory，plugins，environments，databaseIdProvider，mappers，下面看一下关于其中一些常用标签的用法

3.1 properties标签

 这个标签见名知意，很明显是用于配置文件的，在MyBatis这个标签是用来引入外部资源文件的，通常会将数据库的连接配置单独拎出来写一个db.properties文件，下面的是一个小栗子：

<properties resource="db.properties"></properties>

在properties除了resource标签外，还有一个url标签，两者作用：

  • resource：用来引入类路径下的资源
  • url：用来引入网络路径或者磁盘路径下的资源

这里在写的时候还要注意，我是将所有的配置文件单独放在了src一个文件下，在IDEA需要将这个文件夹标记成Resources才能这么写，否则前面要加上路径

3.2 settings标签

 这个标签很重要，它可以直接影响MyBatis运行时的行为，里面也有很子标签，具体参见文档，下面是一个关于下划线驼峰命名的设置栗子：

 <settings>
        <!--下划线驼峰命名规则，默认关闭;
        若数据库中的字段为A_COUNT，而JavaBean中的属性名为aCount，即满足下划线后的
        第一个字母大写，其他小写MyBatis即可自动映射成功，如果不满足这个规则将不能做映射，
        像之前的Demo中lastName就是这个原因无法获取，只能通过别名获取，这里配置一下就可以了
        -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

3.3 typeAliases标签

 这个标签是用来给JavaBean起别名(在mapper文件中的别名)，在mapper映射文件中，对于返回实体类的SQL语句，之前是写JavaBean的全类名，现在就可以直接写在此标签的中别名，用法如下：

<typeAliases>
    <!--
    type为JavaBean的全类名，alias为该实体类的别名，其中alias属性可以缺省
    (默认为首字母小写的类名)
    -->
    <typeAlias type="com.hhu.entitieses.Employee" alias="employee"/>
</typeAliases>

上述是对单个JavaBean起别名，如果数量比较多的话，这样的方式倒也是很麻烦，对某个包中以及子包中的JavaBean起别名可以使用package标签进行配置，如下：

<typeAliases>
    <!--
    name是包名，它会为该包下的所有类和子包的类起默认别名
    (默认为首字母小写的类名)
    -->
    <package name="com.hhu.entities" />
</typeAliases>

在使用package批量起别名的时候可能遇见这样的情况，父类包和子类包中含有同名的JavaBean，这就比较尴尬了，MyBatis中提供使用注解的方式来解决这个这个问题，只要在有冲突的JavaBean的类上使用@Alias("别名")注解为该JavaBean重新起一个没有冲突的别名即可。

3.4 typeHandlers标签

 它是类型处理器标签，是架起Java类型和数据库数据类型的桥梁，比如将java中String类型如何保存到数据库兼容的varchar或者char，又比如将数据库中查出的int类型转成java的Integer或者int类型。

3.5 objectFactory标签

 这个标签我们一般不动，使用MyBatis默认的就挺好。

3.6 plugins标签

 插件标签也是其中比较重要的标签，MyBatis可以通过插件对SQL语句进行拦截。

3.7 environments标签

 用于配置MyBatis的运行环境(我理解下来就是数据连接的配置)，通过default属性指定使用的环境(值为环境的唯一标识符id)，总体结构如下：

<environments default="dev_mysql">
    <!--环境1-->
    <environment id="dev_mysql">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <!--引用外部配置文件的属性进行赋值-->
            <property name="driver" value="${jdbc.driver}"/>
            .
            .
            .
        </dataSource>
    </environment>

    <!--环境2、环境3等等-->
</environments>

在environments标签中的environment标签可以配置多种MyBatis的运行环境，每个environment标签中必须配置事务管理器transactionManager和数据源dataSource才算完整：

  • transactionManager：事务管理器，通过type属性指定事务管理器(正常为JDBC)，在MyBatis中主要有三种：JDBC和MANAGED以及自定义事务管理器
    • JDBC:就是使用JdbcTransactionFactory作为事务管理器
    • MANAGED:就是使用ManagedTransactionFactory作为事务管理器
    • 自定义事务管理器：可以通过实现org.apache.ibatis.transaction.TransactionFactory接口即可，type指定为自定义事务管理器的全类名
  • dataSource：数据源同样，可以通过其中的type指定数据源的类型，MyBatis默认支持UNPOOLED和POOLED以及JNDI，也可以自定义。
    • UNPOOLED：即不使用连接池，每次对数据库的操作都会创建新的连接去操作
    • POOLED：就是使用连接池技术，这个比较好
    • 自定义数据源：实现org.apache.ibatis.datasource.DataSourceFactory接口即可。

3.8 databaseIdProvider标签

 MyBatis可以根据不同的底层数据库的类型执行不同的SQL语句，其实就是MyBatis对于移植性的考虑，Hibernate在这一块做的特别好，因为SQL语句不需要我们自己写，都是由Hibernate自动帮我们发送SQL语句的，但是MyBatis可以根据这个标签指定我们在SQL映射文件使用的SQL语句是基于哪种数据库去写的，从而达到MaBatis根据不同的数据库动态的发送SQL。通过这个标签可以配置不同数据库底层的标识符，MyBatis根据这个标识符执行不同的SQL语句，主要体现MyBatis和数据库底层的解耦，一般的配置如下：

<!--这里面的type属性就是DB_VENDOR，不要写其他的-->
<databaseIdProvider type="DB_VENDOR">
    <!--为不同的数据库厂商起别名，前面name属性是死的，value可以自己指定
        下面的配置就是想让MyBatis同时支持MySQL和MySQL和SQL Server三种数据库，
        在实际开发中主要看的想搞几种数据库类型

        然后在mapper.xml文件中进行SQL语句查询时可以在select标签中用databaseId="别名"的方式
        告诉MyBatis这个SQL语句是发送到哪种数据库的
    -->
    <property name="MySQL" value="mysql"/>
    <property name="Oracle" value="oracle"/>
    <property name="SQL Server" value="sql server"/>
</databaseIdProvider>

由于是不同的数据库，所以很容易就能想到需要配置其他的数据的环境吧，也就是说这个标签需要和前面的environments标签结合使用，另外mapper文件中在写SQL语句的时候需要使用databaseId属性指定使用的是哪种数据库厂商(它的值就是这里配置的各个数据库厂商和别名，比如MySQL我们自定义的别名为mysql)，同时SQL映射文件中也要为不同的数据库的查询方式写不同的SQL语句的实现，下面以MySQL和Microsoft SQL Server两种数据库为例，看一下这个标签的用法：

  • 导入额外的MMSQL的jar包：mssql-jdbc-6.4.0.jre8.jar
  • 在MSSQL中创建一张employees表，也有Employee对象的属性，然后在db.properties配置文件中加入MSSQL的连接配置：
# MySQL Configuration--db_mybatis
jdbc.userName=root
jdbc.password=9j
jdbc.url=jdbc:mysql://localhost:3306/db_mybatis
jdbc.driver=com.mysql.jdbc.Driver

# MicroSoft SQL Server--SchoolServer
mssqlserver.userName=sa
mssqlserver.password=9
mssqlserver.url=jdbc:sqlserver://localhost:1433;DatabaseName=SchoolServer
mssqlserver.driver=com.microsoft.sqlserver.jdbc.SQLServerDriver
  • 在mybatis-config.xml配置文件中配置environments和databaseIdProvider标签：
<environments default="dev_mysql">

    <!---配置MySQL的环境-->
    <environment id="dev_mysql">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <!--使用外部配置文件中的属性-->
            <property name="driver" value="${jdbc.driver}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.userName}"/>
            <property name="password" value="${jdbc.password}"/>
        </dataSource>
    </environment>

        <!--配置SQLServer的运行环境-->
    <environment id="dev_mssql">
        <transactionManager type="JDBC"></transactionManager>
        <dataSource type="POOLED">
            <property name="driver" value="${mssqlserver.driver}"/>
            <property name="url" value="${mssqlserver.url}"/>
            <property name="username" value="${mssqlserver.userName}"/>
            <property name="password" value="${mssqlserver.password}"/>
        </dataSource>
    </environment>

</environments>


<databaseIdProvider type="DB_VENDOR">
    <property name="MySQL" value="mysql"/>
    <property name="SQL Server" value="sql server"/>
</databaseIdProvider>
  • SQL映射文件增加MSSQL的SQL语句，并用databaseId指定数据库厂商的别名：
    <!--MySQL的查询语句-->
    <select id="getEmployeeById" resultType="employee" databaseId="mysql">
        select * from tbl_employee where id = #{id}
    </select>

    <!--同一SQL在不同数据库查询，这里指定去SQL Server中查询-->
    <select id="getEmployeeById" resultType="employee" databaseId="sql server">
        select * from employees where id = #{id}
    </select>

然后运行面向接口的测试代码，通过控制台发现MyBatis发送的是mysql的SQL语句，然后通过更改environments标签的default属性值为default="dev_mssql"，再次运行，控制台打印的是MSSQL的语句。
【注意】这里除了在select标签中使用databaseId属性来指定SQL映射的哪种版本的数据库以外，还可以使用MyBatis内置参数_databaseId和结合if标签完成上面的工作，因为上述的方式必须要写两个select标签，并不符合程序员偷懒的好习惯，改造一下如下：

<!--注意去掉原来标签中的databaseId属性-->
<select id="getEmployeeById" resultType="employee">
    <!--注意在数据库上厂商别名上加单引号，否则MyBatis不能识别-->
    <if test="_databaseId=='mysql'">
        select * from tbl_employee where id = #{id}
    </if>
    <if test="_databaseId=='sql server'">
        select * from employees where id = #{id}
    </if>
</select>

<!--在MyBatis中必须配置数据库厂商的别名-->
<databaseIdProvider type="DB_VENDOR">
    <property name="MySQL" value="mysql"/>
    <property name="SQL Server" value="sql server"/>
</databaseIdProvider>

3.9 mappers标签

 通过该标签可以将SQL映射文件注册到全局配置文件中，用法如下：

<mappers>
    <mapper resource="EmployeeMapper.xml"/>
</mappers>

当然在其子标签mapper是注册各个SQL映射文件的，这个子标签下主要有3个属性：

  • resource：引用类路径下的SQL映射文件；
  • url：引用网络路径或者磁盘路径下的SQL映射文件；
  • class：直接引用接口。

前两种不作太多说明，主要关于第三种class属性做说明，如果直接引用接口，需要将接口和接口绑定的SQL映射文件必须在同一路径下并且两者的同名；但是更常规的做法是利用注解直接将SQL写在接口中的方法身上而不写mapper文件了，然后引用接口的类，比如：

@Select("select * from tbl_employee where id=#{id}")
Employee    getEmployeeById(int id);

但是又不太推荐这么去写，因为MyBatis好不容易将java代码和SQL语句分离开来，现在又给他搞进去，确实不太好，而且不利于复杂SQL语句后期的优化，但是又因为用注解的方式实在太方便了，所以可以将简单的、不太重要的SQL直接用注解去搞，复杂的SQL写在xml中。

 上面是单个SQL映射文件的注入，同时MyBatis也提供了批量映射文件的注册，只用如下的方式：

<mappers>
    <!--会注册该包下所有类-->
    <package name="包名"/>
</mappers>

但是这种适用于注解的方式，如果在xml的形式，就需要将SQL的映射文件和绑定的接口类放到同一包路径下并且同名。

4. SQL映射文件xxmapper.xml

 SQL映射文件是MyBatis的核心文件之一，主要用于SQL语句的存放和接口的绑定。在一开始的Demo中就涉及到了关于mapper文件的一些写法，该文件中的主体是<mapper>标签，里面还有其他的一些常用的标签：

  • cache：配置接口的缓存
  • cache-ref：引用其他接口的缓存
  • resultMap：描述从数据库中加载出来的结果集
  • parameterMap：已废弃
  • sql：一个可重用的SQL语句，可以被其他语句引用；
  • insert：插入操作的SQL映射；
  • update：更新操作的SQL映射；
  • delete：删除操作的SQL映射；
  • select：查询操作的SQL映射；

下面先对其中用的最多的增删改查标签搞一个小栗子：

<?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">
<!--namespace：名称空间，写绑定接口的全类名-->
<mapper namespace="com.hhu.dao.EmployeeDao">
    <!--id：唯一标识，就写成绑定接口中对应的方法名
         resultType：返回值类型，即执行sql后的返回值想要怎么处理，封装成什么对象
         #{id}：从方法传入的参数“id”获取传入sql语句的参数
     -->
    <select id="getEmployeeById" resultType="com.hhu.entities.Employee">
        <!--这里是查不到lastName属性的，MyBatis默认根据JavaBean中的属性名的方式去查找
              数据库，如果属性和字段名对不上，那么就查不到；
              解决方法：在mapper文件属性名和字段名不一样地方，用JavaBean中的属性名做该字段的别名，
              不用通配符*，即可
        -->
        select id, last_namemm lastName, gender,email from tbl_employee where id = #{id}
    </select>

    <!--这里更新的时候，使用parameterType指明传入参数类型是Employee对象，
    但是在SQL语句中我们需要的是这个对象中一些属性的时候，可以直接写
    这个对象中的属性名即可，#{id}就是表示employee.id的意思-->
    <update id="upDateById"  parameterType="employee">
        UPDATE tbl_employee SET  last_NameMM=#{lastName}, gender=#{gender},email=#{email}
        WHERE  id = #{id}
    </update>

    <delete id="deleteById">
        DELETE  FROM  tbl_employee WHERE id = #{id}
    </delete>

    <!--
        有时候用户在做数据的写操作的时候，希望得到一个结果的反馈，
        写入成功返回true，写入失败返回false;

        MyBatis在涉及到写操作的删、除、改三种操作是允许返回true或者false的,
        直接在接口中将这些方法的返回值定义为boolean即可，但是在mapper文件
        中标签中不需要指定返回值类型。原理是根据SQL语句影响的行数来
        封装返回值的，如果影响的行数为0则返回false，如果影响的行数大于0则返回true
    -->
    <insert id="saveEmp" parameterType
最低0.47元/天 解锁文章
jacksonary
关注
专栏目录
Mybatis 学习笔记
Captain Leo的专栏
03-03 601
Mybatis基本概念、应用、开发、注解、缓存、插件、架构原理、设计模式
Mybatis学习笔记
07-22
本学习笔记是作者在大学期间深入学习Mybatis后的整理，旨在帮助初学者快速入门并掌握其核心概念与功能。 笔记共分为11个章节，涵盖Mybatis的基础到高级应用，以下是主要知识点的详细讲解： 1. **Mybatis简介**：...
MyBatis 笔记
weixin_33845477的博客
10-17 121
Mybatis 基础用法 sql数据,建表,注意主外键 关系, 以及建立db.properties CREATE TABLE user( id int AUTO_INCREMENT, userName VARCHAR(255) not NULL, userAge VARCHAR(255) ...
【Mybatis整合Oracle】在 xml 文件中 WITH 子句的简单使用
最新发布
ALiangSev的博客
07-21 799
作用范围：WITH 子句定义的 CTE 仅在 WITH 子句后面的查询中有效。性能：CTE 通常被视为临时的视图，Oracle在执行查询时可能会优化 CTE 的使用方式，因此性能影响通常较小，但在某些复杂查询中，CTE 可能会影响性能。通过合理使用 WITH子句，你可以简化复杂查询，提升 SQL 代码的可读性。在 MyBatis XML 文件中使用 WITH 子句是一种很好的方式来组织和简化复杂的 SQL 查询。通过合理使用 CTE，你可以使 SQL 查询更加清晰和易于维护。
Mybatis入门例子
weixin_30274627的博客
02-06 203
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 一、理解什么是MyBatis？ MyBatis 是支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。 MyBatis 消除了几乎所有的 JDB...
mybatis笔记
weixin_45408048的博客
07-18 133
mybatis
Mybatis笔记
longtengzzZ的博客
07-21 337
Mybatis 1.1 基本概念 l、什么是框架？ 它是我们软件开发中的一套解决方案，不同的框架解决的是不同的问题。 使用框架的好处： 框架封装了很多的细节，使开发者可以使用极简的方式实现功能。大大提高开发效率。 2、三层架构 表现层: 是用于展示数据的 业务层: 是处理业务需求 持久层: 是和数据库交互的 3、持久层技术解决方案 JDBC技术: Connection PreparedStatement ResultSet Spring的JdbcTemplate: Spring中对jdbc的简单封装 以上这
Mybatis学习笔记(一)
MineCodelife的博客
07-18 456
MyBatis 是一个可以自定义 SQL、存储过程和高级映射的持久层框架。 MyBatis 摒除了大部分的 JDBC 代码、手工设置参数和结果集重获。 MyBatis 只使用简单的 XML 和注解来配置和映射基本数据类型、Map 接口和 POJO 到数据库记录。 SqlSessionFactoryBuilder SqlSessionFactoryBuilder 用于创建 SqlSessionFa...
MyBatis笔记
万神小栈
12-30 969
MyBatis 笔记 MyBatis 是基于 Java 语言的开源的持久层框架，利用实体类和数据表之间产生了关联，通过映射文件中的 sql 语句对数据库进行操作</p> <p>使用 maven 创建工程需要导入 <code>mybatis</code> 的依赖：</p> <pre><code>&lt;dependency&gt; ...
MyBatis学习笔记（全）
m0_45364328的博客
06-04 271
MyBatis最初是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下， iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到Github。iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。 iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）。1） M
MyBatis学习笔记（一）
weixin_44580146的博客
02-02 904
MyBatis学习笔记 （一） 本系列笔记学习的是黑马程序员推出的ssm系列课程，感谢老师的精彩讲解，在此立贴以示感激。 一、MyBatis概述 ​ MyBatis是一款优秀的Java持久层框架，它封装了JDBC，使开发者只需要关注Sql语句本身，二不需要花费精力去处理加载驱动，创建连接、创建Statement等繁杂的过程 ​ MyBatis通过xml或注解的方式将要执行的各种stateme...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值