mybatis总结


阅读数: 次   

mybatis

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

1. j2ee三层架构

在这里插入图片描述

  1. 表现层（spring-mvc）
    主要是JSP和HTML页面，用于接收du用户的zhi请求，以及返dao回操作数据，是应用专程序访问的入属口。
  2. 业务逻辑层service（spring）
    主要是对数据层进行操作，对数据逻辑层进行处理，如果数据层是积木，那么逻辑层就是堆积木的搭建。
  3. 数据访问层dao（mybatis）
    主要是对原始数据的操作层，具体为业务逻辑层或表现层提供数据服务。

    2. mybatis使用步骤

    2.1. 加入maven依赖

    在pom文件中加入mybatis的依赖
1
2
3
4
5
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.5</version>
</dependency>

因为要mybatis是在dao层用来访问数据库的，所以也要加入mysql的依赖

1
2
3
4
5
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>8.0.21</version>
</dependency>

2.2. 创建dao接口

创建一个dao包，在dao包中创建一个dao接口，例如在这里我创建了一个StudentDao接口，其中有两个方法，查询所有学生和插入学生

1
2
3
4
5
public interface StudentDao {
    public List<Student> selectStudents();

    public int insertStudent(Student student);
}

2.3. 创建查询结果类

查询结果学生类的属性应该和表中的列一一对应，类名推荐使用和表名一样的名称，每个对象相当于mysql表中的一行数据

1
2
3
4
5
6
7
8
public class Student {
    //属性名和列名一致，类型也一致
    private Integer id;
    private String name;
    private String email;
    private Integer age;
    ...
}

mysql中的student表
在这里插入图片描述

2.4. 创建mapper文件

格式参考mybatis官网，mapper文件的名字要和dao接口的名字对应，一个接口对应一个mapper，将sql语句都定义在mapper文件当中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?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">
<!--dtd为约束文件，检查标签是否符合mybatis要求-->
<mapper namespace="com.hjznb.dao.StudentDao">
    <!--mapper为根标签
        namespace为命名空间，唯一值。要求使用dao接口的全限定名称
        -->
    <!--select标签表示查询操作。
        id：为你要执行的sql语法的唯一表示，mybatis会根据id来查找语句
            要求使用接口中的方法名称
        resultType：表示结果类型，是sql语句执行后得到的java对象,为类型的全限定名称
            -->
    <select id="selectStudents" resultType="com.hjznb.domain.Student">
        select id,name,email,age from student order by id
    </select>
    <!--#{id}表示从对象中寻找属性值id-->
    <insert id="insertStudent">
        insert into student values(#{id},#{name},#{email},#{age})
    </insert>
</mapper>
<!--sql映射文件（sql mapper ）-->

其中命名空间namespace的属性为其所对应的dao接口的全限定名称，select这些标签的id要与dao接口中的方法名一致。

2.5. 创建mybatis的主配置文件

在resource目录下创建一个xml文件，在该文件中连接数据库和指定mapper文件的位置，格式如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<?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>
    <!--环境配置：数据库的连接信息
        default:必须和某个environment的id值一样
        告诉mybatis使用哪个数据库的连接信息-->
    <environments default="development">
        <!--environment：一个数据库信息的配置、环境
            id：唯一值，自定义，表示环境的名称
            -->
        <environment id="development">
            <!--transactionManager：mybatis的事务类型
                type：JDBC（表示使用jdbc中的Connection对象的commit和rollback做事物处理）-->
            <transactionManager type="JDBC"/>
            <!--dataSource：表示数据源，连接数据库的
                type：表示数据源的类型，pooled表示使用自带的连接池-->
            <dataSource type="POOLED">
                <!--driver、user、username、password是固定的，不能自定义-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="hjznb"/>
            </dataSource>
        </environment>
    </environments>

    <!--sql映射文件的位置-->
    <mappers>
        <!--一个mapper标签指定一个文件的位置
            从类路径开始classes
            -->
        <mapper resource="com/hjznb/dao/StudentDao.xml"/>
    </mappers>
</configuration>
<!--mybatis的主配置文件
    configuration为根标签-->

其中mappers标签中可以直接指定mapper文件的位置，也可以指定包名，加载配置文件时会扫描包中的所有xml文件.使用package标签，name为 包名

1
2
3
<mappers>
    <package name="com.hjznb.dao"/>
</mappers>

注意：

  • mysql的jar包版本不同，所对应的driver格式也不同，因为我使用的是最新版本的驱动，此处为com.mysql.cj.jdbc.Driver
  • 如果运行时出现了如下错误：java.sql.SQLException: The server time zone value '�й���׼ʱ��' is unrecognized or represents more than one time zone. You must configure either the server or JDBC driver (via the 'serverTimezone' configuration property) to use a more specifc time zone value if you want to utilize time zone support.此时需要在url属性后添加如下字符串：?serverTimezone=UTC

2.6. 使用mybatis的对象SqlSession的方法

方法一，通过SqlSessionFactory对象来创建SqlSession对象，调用SqlSession对象的方法，指定要执行的语句的标识，格式为：sql映射文件(mapper)中的namespace+”.”+标签的id值
具体步骤如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class MyApp {
    public static void main(String[] args) throws IOException {
        //主配置文件的位置
        String config = "mybatis.xml";
        //读取这个config表示的文件
        InputStream in = Resources.getResourceAsStream(config);
        //创建了SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //创建了SqlSessionFactory对象
        SqlSessionFactory factory = builder.build(in);
        //【重要】从SqlSessionFactory获取SqlSession对象
        SqlSession sqlSession = factory.openSession();
        //【重要】指定要执行的sql语句的标识。sql映射文件中的namespace+"."+标签的id值
        String sqlId = "com.hjznb.dao.StudentDao.selectStudents";
        //执行sql语句，通过sqlId找到语句
        List<Object> studentList = sqlSession.selectList(sqlId);
        studentList.forEach(stu-> System.out.println(stu));
        //关闭资源
        sqlSession.close();
    }
}

可以看见，方法一太过繁琐，而且dao接口似乎没用。因此大部分时间都是使用动态代理来访问数据库

2.7. 使用mybatis的动态代理

方法二是使用mybatis的动态代理，具体要求如下
在这里插入图片描述
通过一个例子来了解mybatis动态代理的使用，使用SqlSession对象的getMapper(dao.class)来获取dao接口的动态代理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class AppTest 
{
    @Test
    public void shouldAnswerWithTrue()
    {
    	//得到SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession(false);
        //调用getMapper得到Dao接口的实现类
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        //调用方法进行增删查改
        List<Student> students = dao.selectStudents();
        students.forEach(student -> System.out.println(student));
        sqlSession.close();
    }
}

MybatisUtils为我包装的工具类，因为前面大多数操作都相同，主要为获取SqlSession对象。下面为工具类的代码，通过一个静态块加载mybatis主配置文件。调用getSqlSession方法得到SqlSession对象，因此减少了重复的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
 * 工具类
 */
public class MybatisUtils {
    private static SqlSessionFactory build = null;

    static {
        System.out.println("静态块执行了");
        String config = "mybatis.xml";
        try {
            InputStream in = Resources.getResourceAsStream(config);
            build = new SqlSessionFactoryBuilder().build(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
	
	 /**
     * 得到SqlSession对象
     * @param commit true为自动提交事务，false为不自动提交
     * @return 返回的SqlSession对象
     */
    public static SqlSession getSqlSession(boolean commit){
        SqlSession sqlSession = null;
        if(build != null){
            sqlSession = build.openSession(commit);
        }
        return sqlSession;
    }
}

mybatis的动态代理会生成到接口的代理类，其实现了dao接口的所有方法，通过使用得到的代理类来操作数据库。

注意：mybatis默认为不自动提交事务，因此在更新操作后需要调用sqlSession.commit()提交事务。如果需要mybatis自动提交事务，需要在创建SqlSession时将openSession()中的参数设为true

3. 两种占位符的使用

mybatis中有两种占位符，一个是’#’，一个是’$’。占位符可以用来表示参数或者对象的属性，在mybatis运行时会将其替代。

3.1. ‘#’占位符

1.当dao接口方法的参数为一个简单类型的参数时，#{任意字符}表示参数
dao接口

1
2
3
4
5
6
7
8
9
public interface StudentDao {
    /**
     * 一个简单类型的参数
     * 在Mapper文件获取简单类型的一个参数的值，使用#{任意字符}
     * '#'占位符使用的是jdbc的preparedStatement，运行时会用'?'代替#{},更加安全
     */
    public Student selectStudentById(Integer id);
	...
}

mapper文件，#{id}表示方法参数

1
2
3
<select id="selectStudentById" resultType="com.hjznb.domain.Student" parameterType="int">
    select id,name,email,age from student where id = #{id}
</select>

2.当方法参数为多个时，使用@Param(“参数的命名”)在方法参数前面指定参数的名称，在mapper文件中使用#{参数的命名}来获取指定参数。

1
2
3
4
5
6
/*
* 多个参数
* 使用@Param命名，在Mapper文件中使用#{参数的命名}来指定参数，推荐使用
* */
public List<Student> selectMultiParam(@Param("myName") String name,
@Param("myAge") Integer age);

mapper文件

1
2
3
4
<!--多个参数要使用@Param("名")来命名，mapper中用#{名}来指定参数-->
<select id="selectMultiParam" resultType="com.hjznb.domain.Student">
    select id,name,email,age from student where name = #{myName} or age = #{myAge}
</select>

3.参数为java对象时，在mapper文件中用 #{对象属性名} 来指定对象的属性

1
2
3
4
/**
 *使用java对象作为参数，mapper文件中#{参数名}要与对象中的参数名一致
 */
public List<Student> selectMultiStudent(QueryParam queryParam);

mapper

1
2
3
4
5
6
7
8
9
10
11
12
<!--多个参数，使用java对象属性值作为参数实际值
    使用对象语法：#{属性名,javaType=类型名称,jdbcType=数据类型}，这位完整版
                javaType为属性名对应的java中的数据类型
                jdbcType为属性名对应的数据库中的数据类型
                例如：#{paramName,javaType=java.lang.String,jdbcType=VARCHAR}

    平常使用的简化版：#{属性名}，其余可以通过反射获取
    属性名为java对象中的属性名
    -->
<select id="selectMultiStudent" resultType="student">
    select id,name,email,age from student where name = #{myName} or age = #{myAge}
</select>

QueryParam类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
 * 自定义查询类
 */
public class QueryParam {
    private Integer myAge;
    private String myName;

    public QueryParam(Integer myAge, String myName) {
        this.myAge = myAge;
        this.myName = myName;
    }

    public Integer getMyAge() {
        return myAge;
    }

    public void setMyAge(Integer myAge) {
        this.myAge = myAge;
    }

    public String getMyName() {
        return myName;
    }

    public void setMyName(String myName) {
        this.myName = myName;
    }
}

4.多个简单类型使用位置传参，从arg0开始

1
2
3
4
5
/**
 *多个参数，简单类型的，使用位置传参
 * #{arg0},#{arg1}
 */
public List<Student> selectMultiPosition(String name,Integer age);

mapper

1
2
3
4
<!--多个简单类型位置传参，从arg0开始-->
<select id="selectMultiPosition" resultType="student">
    select id,name,email,age from student where name = #{arg0} or age = #{arg1}
</select>

3.2. $ 占位符

$占位符使用的是字符串的拼接

1.和#{}类似，${}也可以用来指代方法中的参数

1
2
3
4
/**
  *使用'$'占位符，该占位符使用的是字符串的拼接，使用的是Statement
  */
 public List<Student> selectUse$(@Param("myName") String name,@Param("myAge") Integer age);
1
2
3
<select id="selectUse$" resultType="student">
    select id,name,email,age from student where name = ${myName} or age = ${myAge}
</select>

需要注意：由于$使用的是字符串的拼接，因此要注意调用方法时传进去的字符串的格式，字符串需要写成”‘字符串’”的格式

1
2
3
4
5
6
7
8
9
10
11
@Test
public void test5(){
    //$和#
    SqlSession sqlSession = MybatisUtils.getSqlSession(false);
    StudentDao mapper = sqlSession.getMapper(StudentDao.class);
    //因为'$'是进行字符串的拼接，所以需要写成"''"形式，
    //否则会变成where name = 哈吉，错误
    List<Student> students = mapper.selectUse$("'哈吉'",20);
    students.forEach(student -> System.out.println(student));
    sqlSession.close();
}

2.$可以替换列名，因此可以用来替换诸如order by或者group by后面的语句，不会插入””

1
2
3
4
/**
 *'$'可以替换列名
 */
public List<Student> selectOrderByParam(@Param("mycol") String col);
1
2
3
4
<!--返回值是一个对象，同名的列赋给同名的属性,使用resultMap-->
<select id="selectOrderByParam" resultMap="resultMap">
    select * from student order by ${mycol}
</select>

如果此处使用#{}会报错

3.3. #和$的总结

在这里插入图片描述

4. 返回值的类型resultType

当sql语句的返回值为一行数据时，可以使用对应的java对象来代替返回结果

如Student类的一个对象代指为表中的一行数据，java对象的属性名要和表中的列名相对应，在mapper文件中sql标签中的resultType指定java对象的全限定名称，mybatis即可将查询出的数据变为java对象

1
2
3
4
<!--此处返回值即为java对象-->
    <select id="selectStudentById" resultType="com.hjznb.domain.Student" parameterType="int">
        select id,name,email,age from student where id = #{id}
    </select>

当返回值为简单类型时，resultType属性值是什么呢？
mybatis给出了对应简单类型的别名，如int

1
2
3
4
<!--返回值为简单类型int，int为Integer的别名-->
<select id="count" resultType="int">
    select count(*) from student
</select>

具体参考mybatis官网，大多都有对应的别名，也可以使用全限定名称，如Integer的全限定名称。

如果返回类型为List<>，则resultType为List菱形括号内的属性类型

5. resultMap

resultMap,可以指定将查询结果赋值给哪个属性，并且可以复用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!--
    resultMap,可以指定将查询结果赋值给哪个属性，并且可以复用
    id：自定义名称，用来标识你定义的这个resultMap
    type：java类型的全限定名称
-->
<resultMap id="resultMap" type="com.hjznb.domain.Student">
    <!--主键用id标签，其余的用result标签
        column为表的列名，property为type中对象的属性名
        当对象的属性名和表的列名不一致时，可以使用resultMap进行绑定
    -->
    <id column="id" property="id"></id>
    <result column="name" property="name"></result>
    <result column="email" property="email"></result>
    <result column="age" property="age"></result>
</resultMap>

然后就可以在sql标签中使用resultMap了，其中#{}中为resultMap中绑定的属性

当列名和属性名不一致时，可以使用resultMap，select标签中的resultMap的属性值是想要使用的resultMap所对应的id值

1
2
3
<select id="selectMyStudents" resultMap="resultMap1">
      select * from student
</select>

或者可以通过将列名取别名来解决，将列名改为对应的属性名

1
2
3
4
<select id="selectMyStudents" resultType="com.hjznb.domain.MyStudent">
    select id as myId, name as myName, email as myEmail, age as myAge
    from student
</select>

6. useGeneratedKeys和keyProperty属性

在Mybatis Mapper文件中添加属性“useGeneratedKeys”和“keyProperty”，其中keyProperty是Java对象的属性名

1
对于支持自动生成记录主键的数据库，如：MySQL，SQL Server，此时设置useGeneratedKeys参数值为true，在执行添加记录之后可以获取到数据库自动生成的主键ID。
1
2
3
<insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
    insert into payment(serial) values (#{serial});
</insert>

Mybatis执行完插入语句后，自动将自增长值赋值给对象Payment的属性id。

7. LIKE模糊查询

在mybatis中使用like模糊查询，最好先将糊查询的语句提前写好，传进方法中

1
2
3
4
5
6
7
8
9
10
11
@Test
public void test10(){
    //like模糊查询
    SqlSession sqlSession = MybatisUtils.getSqlSession(false);
    StudentDao mapper = sqlSession.getMapper(StudentDao.class);
    //提前写好模糊查询语句
    String name = "张%";
    List<Student> students = mapper.selectLike(name);
    students.forEach(myStudent -> System.out.println(myStudent));
    sqlSession.close();
}

mapper文件

1
2
3
4
5
<select id="selectLike" resultType="student">
    select *
    from student
    where name like #{name}
</select>

8. 动态sql

常用的动态sql标签有< where > 、< if >、< foreach>
下面为测试的StudentDao

1
2
3
4
5
6
7
8
9
public interface StudentDao {
    List<Student> selectWhere(Student stu);

    List<Student> selectForeachOne(List<Integer> idList);

    List<Student> selectForeachTwo(List<Student> idList);

    List<Student> selectAll();
}

8.1. where标签和if标签

where标签经常和if标签搭配着使用

1
2
3
4
5
6
7
8
9
10
11
12
<!--动态sql-->
<select id="selectWhere" resultType="com.hjznb.domain.Student">
    select * from student
    <where>
        <if test="name!=null and name!=''">
            name = #{name}
        </if>
        <if test="age>18">
            or age>#{age}
        </if>
    </where>
</select>

< if test = “” >< /if >该标签可以动态的插入sql语句，如果test中的表达式为真，就会插入标签中的语句
当test中使用java对象的属性值作为判断条件时，格式：属性=xxx值

if标签可能会出现一些语法错误，需要和where标签搭配着使用。
where标签可以检出where语句的最前面是否含有AND和一个空格 或者 or和一个空格 ,如果有的话删除。

在此处，如果第一个if标签的表达式为假，第二个表达式为真。此时如果没有使用where标签，而是使用where语句，那么就会变成如下sql

1
2
select * from student where or age>#{age} 
<!--系统会报错，where后面有语法错误-->

如果使用了where标签，会对其进行优化，去掉where后的or

1
select * from student where age>#{age}

8.2. foreach标签

该标签可以用来遍历集合，会在sql语句中插入集合中元素指定的属性，下面的foreach标签将遍历结果的格式指定为以括号开头和结尾，集合中的元素用逗号分隔

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<!--
collection：要循环的集合

index：循环索引；

item：集合中的一个元素（item和collection，按foreach循环理解）；

open：以什么开始；

close：以什么结束；

separator：循环内容之间以什么分隔

mybatis接受的参数分为：（1）基本类型；（2）对象；（3）List；（4）数组；（5）Map

-->
<select id="selectForeachOne" resultType="com.hjznb.domain.Student">
    select * from student where id in
    <foreach collection="list" item="idList" open="(" close=")" separator=",">
        #{idList}
    </foreach>
</select>

mybatis会将上面的语句翻译为如下sql语句，会将遍历出的元素插入到？中

1
select * from student where id in ( ? , ? , ? )

例如下面这个例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Test
public void testForeachOne(){
    SqlSession sqlSession = MybatisUtils.getSqlSession(false);
    StudentDao dao = sqlSession.getMapper(StudentDao.class);
    
    List<Integer> list = new ArrayList<>();
    list.add(1001);
    list.add(1002);
    list.add(1003);
    
    List<Student> students = dao.selectForeachOne(list);
    students.forEach(student -> System.out.println(student));
    /*
    *   ==>  Preparing: select * from student where id in ( ? , ? , ? )
    *   ==> Parameters: 1001(Integer), 1002(Integer), 1003(Integer)
    * */
}

mybatis将1001,1002,1003替换掉语句中的‘？’，于是查询语句变为了

1
select * from student where id in ( 1001 , 1002 , 1003 )

在foreach中也能访问java对象的属性，格式：item.属性名
foreach标签中的属性也可以不用指定，自己拼接

1
2
3
4
5
6
7
8
<select id="selectForeachTwo" resultType="com.hjznb.domain.Student">
    /*使用sql片段，会被替换成sql语句*/
    <include refid="sql1"/> id in (
        <foreach collection="list" separator="," item="stu">
            #{stu.id}
        </foreach>
        )
</select>

在这里没有指定查询结果以什么开始和结束，只是指定了元素之间用逗号分隔，括号由自己拼接。

其中的include标签为自己定义的sql片段sql1

1
2
3
4
<!--定义sql片段，以后可以复用-->
<sql id="sql1">
    select * from student where
</sql>

refid属性值为sql片段的id值，mybatis会用sql片段替换掉include标签，那么上面的语句会变成如下形式

1
2
3
4
5
select * from student where id in (
    <foreach collection="list" separator="," item="stu">
        #{stu.id}
    </foreach>
    )

9. springboot整合mybatis步骤

9.1. 注解版

  1. 导入pom依赖
    1
    2
    3
    4
    5
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.1</version>
    </dependency>
  2. 建表，创建实体类对象
  3. 创建dao接口，在类上面标@Mapper注解，表明这是一个mapper
    1
    2
    3
    4
    5
    6
    @Mapper
    public interface CityMapper {

      City findByState(@Param("state") String state);

    }
  4. 在接口中使用@Select注解（或其他），给其value属性赋值sql语句
    1
    2
    3
    4

    @Select("SELECT * FROM CITY WHERE state = #{state}")
    City findByState(@Param("state") String state);

  5. 在配置文件application.yml中配置信息
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    mybatis:
        type-aliases-package: com.example.domain.model #使用别名
        configuration:
            map-underscore-to-camel-case: true #开启驼峰命名法
    spring:
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource #数据源
        driver-class-name: org.gjt.mm.mysql.Driver #驱动
        url: jdbc:mysql://localhost:3306/cloud2020?useUnicode=true&characterEncoding=utf-8&useSSL=false
        username: root
        password: 123456
  6. 在主配置类中使用MapperScan批量扫描所有的Mapper接口
    1
    2
    3
    4
    5
    6
    7
    8
    @MapperScan(value = "com.example.mapper")
    @SpringBootApplication
    public class SpringBoot06DataMybatisApplication {

    	public static void main(String[] args) {
    		SpringApplication.run(SpringBoot06DataMybatisApplication.class, args);
    	}
    }

*注意：如果想在mapper中使用其他属性，可使用@Options注解 *

1
2
3
@Options(useGeneratedKeys = true,keyProperty = "id")
@Insert("insert into department(departmentName) values(#{departmentName})")
public int insertDept(Department department);

9.2. 配置文件版

也可使用配置文件来配置mybatis

1
2
3
mybatis:
  config-location: classpath:mybatis/mybatis-config.xml 指定全局配置文件的位置
  mapper-locations: classpath:mybatis/mapper/*.xml  指定sql映射文件的位置

9.3. 混合开发

可使用配置文件和注解来开发：

  • 在application.yml文件中配置全局配置，而不使用xml
  • 在dao接口上加@Mapper注解
  • 在xml文件中写sql映射文件，而不是java

    10. 总结

    mybatis是一个优秀的持久层框架，一般还是和spring整合着使用，单独用的少。
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一名在校的大学生<br><br>梦想是成为一名优秀的程序员(划掉)，icer！