Maven
Apache Maven 是一个项目管理和构建工具,它基于项目对象模型(POM)的概念,通过一小段描述信息来管理项目的构建、报告和文档。
官网 :Maven – Welcome to Apache Maven
Maven简介
- 什么是Maven?这里先引用知乎的一个回答
我先不说maven,也不说java开发,先说做菜,你可能像做个红烧小排(HongshaoxiaopaiApp),你需要的材料是:
1、小排(xiaopai.jar),要小猪的(version=little pig)。
2、酱油(jiangyou.jar),要82年的酱油(version=1982)
3、盐(yan.jar)
4、糖(tang.jar),糖要广东产的(version=guangdong)
5、生姜(shengjiang.jar)
6、茴香(huixiang.jar)
于是,你要去菜场买小排,去门口杂货店买酱油,买盐……可能你家门口的杂货店还没有1982年的酱油,你要去3公里外的农贸市场买……你买原材料的过程估计会很痛苦,可能买到的材料不是1982年的,会影响口感。
在你正式开始做小排前,你会为食材的事情,忙得半死。
现在有个超市出了个盒装版的半成品红烧小排,把生的小排,1982年的酱油,盐,广东产的糖等材料打包成一个盒子里,你回家只要按照说明,就能把红烧小排做出来,不用考虑材料的来源问题。
Maven就是那个超市,红烧小排就是你要开发的软件,酱油、盐什么的就是你开发软件要用到的jar包——我们知道,开发java系统,下载一堆jar包依赖是很正常的事情。有了maven,你不用去各个网站下载各种版本的jar包,也不用考虑这些jar包的依赖关系。Maven会给你搞定,就是超市的配菜师傅会帮你把红烧小排的配料配齐一样。
现在你应该明白Maven是做什么的了吧。
-
Maven是专门用于管理和构建Java项目的工具,它的主要功能有:
- 提供了一套标准化的项目结构
- 提供了一套标准化的构建流程(编译,测试,打包,发布……)
- 提供了一套依赖管理机制
-
标准化的项目结构:
项目结构我们都知道,每一个开发工具(IDE)都有自己不同的项目结构,它们互相之间不通用。我再eclipse中创建的目录,无法在idea中进行使用,这就造成了很大的不方便
而Maven提供了一套标准化的项目结构,所有的IDE使用Maven构建的项目完全一样,所以IDE创建的Maven项目可以通用。如下图右边就是Maven构建的项目结构。 -
标准化的构建流程:
例如我们开发了一套系统,代码需要进行编译、测试、打包、发布,这些操作如果需要反复进行就显得特别麻烦,而Maven提供了一套简单的命令来完成项目构建。 -
依赖管理:
依赖管理其实就是管理你项目所依赖的第三方资源(jar包、插件)。如之前我们项目中需要使用JDBC和Druid的话,就需要去网上下载对应的依赖包,复制到项目中,创建一个lib文件夹存放各种jar包,还要将jar包加入工作环境这一系列的操作。
而Maven使用标准的坐标
配置来管理各种依赖,只需要简单的配置就可以完成依赖管理。
下面的代码就是mysql驱动包的坐标,在项目中只需要写这段配置,其他都不需要我们担心,Maven都帮我们进行操作了。
市面上有很多构建工具,而Maven依旧还是主流构建工具。XML
1 2 3 4 5
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.34</version> </dependency>
IDEA中使用Maven
以后开发中我们肯定会在高级开发工具中使用Maven管理项目,而我们常用的高级开发工具是IDEA,所以接下来我们会讲解Maven在IDEA中的使用。
IDEA配置Maven环境
- 选择 IDEA中 File —> Settings
- 在Setting页面搜索maven
- 设置 IDEA 使用本地安装的 Maven,并修改配置文件路径(默认的jar包下载路径在C盘,我们最好把它改到D盘)
Maven坐标详解
-
什么是坐标?
- Maven 中的坐标是
资源的唯一标识
- 使用坐标来定义项目或引入项目中需要的依赖
- Maven 中的坐标是
-
Maven 坐标主要组成
- groupId:定义当前Maven项目隶属组织名称(通常是域名反写,例如:com.itheima)
- artifactId:定义当前Maven项目名称(通常是模块名称,例如 order-service、goods-service)
- version:定义当前项目版本号
-
下面的代码就是用坐标表示一个项目
XML
1 2 3
<groupId>com.alibaba</groupId> <!--隶属组织阿里巴巴--> <artifactId>druid</artifactId> <!--模块名称是德鲁伊--> <version>1.1.12</version> <!--版本号是1.1.12-->
IDEA 创建 Maven项目
IDEA 导入 Maven项目
- 选择右侧Maven面板,点击 + 号
- 选中对应项目的pom.xml文件,双击即可
依赖范围
通过设置坐标的依赖范围(scope),可以设置 对应jar包的作用范围:编译环境、测试环境、运行环境。
如下图所示给 junit
依赖通过 scope
标签指定依赖的作用范围。 那么这个依赖就只能作用在测试环境,其他环境下不能使用。
XML
1 2 3 4 | <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13</version> <scope>test</scope> |
那么 scope
都可以有哪些取值呢?
依赖范围 | 编译classpath | 测试classpath | 运行classpath | 例子 |
---|---|---|---|---|
compile | Y | Y | Y | logback |
test | - | Y | - | Junit |
provided | Y | Y | - | servlet-api |
runtime | - | Y | Y | jdbc驱动 |
system | Y | Y | - | 存储在本地的jar包 |
- compile :作用于编译环境、测试环境、运行环境。
- test : 作用于测试环境。典型的就是Junit坐标,以后使用Junit时,都会将scope指定为该值
- provided :作用于编译环境、测试环境。我们后面会学习
servlet-api
,在使用它时,必须将scope
设置为该值,不然运行时就会报错 - runtime : 作用于测试环境、运行环境。jdbc驱动一般将
scope
设置为该值,当然不设置也没有任何问题
如果引入坐标不指定 scope
标签时,默认就是 compile 值。以后大部分jar包都是使用默认值。
MyBatis
MyBatis 是一款优秀的持久层框架
,用于简化 JDBC 开发
MyBatis 本是 Apache 的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis 。2013年11月迁移到Github
官网:mybatis – MyBatis 3 | 简介
MyBatis概述
-
持久层:
- 负责将数据到保存到数据库的那一层代码。
以后开发我们会将操作数据库的Java代码作为持久层。而Mybatis就是对jdbc代码进行了封装。
- 负责将数据到保存到数据库的那一层代码。
-
框架:
- 框架就是一个半成品软件,是一套可重用的、通用的、软件基础代码模型
- 在框架的基础之上构建软件编写更加高效、规范、通用、可扩展
MyBatis快速入门
查询user表中的数据
1、创建user表,添加数据
SQL
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | CREATE DATABASE mybatis; USE mybatis; DROP TABLE IF EXISTS tb_user; CREATE TABLE tb_user( id INT PRIMARY KEY AUTO_INCREMENT, username VARCHAR(20), PASSWORD VARCHAR(20), gender CHAR(1), addr VARCHAR(30) ); INSERT INTO tb_user VALUES (1, 'zhangsan', '123', '男', '北京'); INSERT INTO tb_user VALUES (2, '李四', '234', '女', '天津'); INSERT INTO tb_user VALUES (3, '王五', '11', '男', '西安'); |
2、创建模块,导入坐标
下面是官方文档的叙述
要使用 MyBatis, 只需将 mybatis-x.x.x.jar 文件置于类路径(classpath)中即可。
如果使用 Maven 来构建项目,则需将下面的依赖代码置于 pom.xml 文件中:
XML
1 2 3 4 5 | <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>x.x.x</version> <!--版本号记得修改--> </dependency> |
由于涉及到了数据库的相关操作,所以我们也要将数据库的jar包的坐标导入。同理,我们还可以导入一些其他需要的jar包,例如junit单元测试,写日志的logback等
XML
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 39 40 41 42 43 | <dependencies> <!--mybatis 依赖--> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.5</version> </dependency> <!--mysql 驱动--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.46</version> </dependency> <!--junit 单元测试--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13</version> <scope>test</scope> </dependency> <!-- 添加slf4j日志api --> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.20</version> </dependency> <!-- 添加logback-classic依赖 --> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>1.2.3</version> </dependency> <!-- 添加logback-core依赖 --> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-core</artifactId> <version>1.2.3</version> </dependency> </dependencies> |
随后将logback需要的XML配置文件存放在src/main/resource
目录下
XML
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 | <?xml version="1.0" encoding="UTF-8"?> <configuration> <!-- CONSOLE :表示当前的日志信息是可以输出到控制台的。 --> <appender name="Console" class="ch.qos.logback.core.ConsoleAppender"> <encoder> <pattern>[%level] %cyan([%thread]) %boldGreen(%logger{15}) - %msg %n</pattern> </encoder> </appender> <logger name="com.itheima" level="DEBUG" additivity="false"> <appender-ref ref="Console"/> </logger> <!-- level:用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF , 默认debug <root>可以包含零个或多个<appender-ref>元素,标识这个输出位置将会被本日志级别控制。 --> <root level="DEBUG"> <appender-ref ref="Console"/> </root> </configuration> |
3、编写MyBatis核心配置文件 —> 替换连接信息 解决硬编码问题
这里继续看看官网怎么说的
每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。
从 XML 文件中构建 SqlSessionFactory 的实例非常简单,建议使用类路径下的资源文件进行配置。 但也可以使用任意的输入流(InputStream)实例,比如用文件路径字符串或 file:// URL 构造的输入流。MyBatis 包含一个名叫 Resources 的工具类,它包含一些实用方法,使得从类路径或其它位置加载资源文件更加容易。
JAVA
1 2 3 | String resource = "org/mybatis/example/mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); |
XML 配置文件中包含了对 MyBatis 系统的核心设置,包括获取数据库连接实例的数据源(DataSource)以及决定事务作用域和控制方式的事务管理器(TransactionManager)。后面会再探讨 XML 配置文件的详细内容,这里先给出一个简单的示例:
XML
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | <?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> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <!--数据库的连接信息--> <property name="driver" value="${driver}"/> <property name="url" value="${url}"/> <property name="username" value="${username}"/> <property name="password" value="${password}"/> </dataSource> </environment> </environments> <mappers> <!--加载SQL映射文件--> <mapper resource="org/mybatis/example/BlogMapper.xml"/> </mappers> </configuration> |
我们继续在src/main/resource
目录下创建一个mybatis-config.xml,将示例给出的XML代码复制到我们创建好的XML文件中,将数据库的连接信息改成我们自己的数据库链接信息。那现在还差一个SQL映射文件
4、编写SQL映射文件 —> 统一管理SQL语句,解决硬编码问题
继续看看官网怎么说的
探究已映射的 SQL 语句
现在你可能很想知道 SqlSession 和 Mapper 到底具体执行了些什么操作,但 SQL 语句映射是个相当广泛的话题,可能会占去文档的大部分篇幅。 但为了让你能够了解个大概,这里先给出几个例子。
在上面提到的例子中,一个语句既可以通过 XML 定义,也可以通过注解定义。我们先看看 XML 定义语句的方式,事实上 MyBatis 提供的所有特性都可以利用基于 XML 的映射语言来实现,这使得 MyBatis 在过去的数年间得以流行。如果你用过旧版本的 MyBatis,你应该对这个概念比较熟悉。 但相比于之前的版本,新版本改进了许多 XML 的配置,后面我们会提到这些改进。这里给出一个基于 XML 映射语句的示例,它应该可以满足上个示例中 SqlSession 的调用。
XML
1 2 3 4 5 6 7 8 9 10 | <?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="org.mybatis.example.BlogMapper"> <!--id是整个sql语句的唯一标识,resultType是结果的类型--> <select id="selectBlog" resultType="Blog"> select * from Blog where id = #{id} </select> </mapper> |
继续在src/main/resource
目录下UserMapper文件(命名规则:操作对象User+Mapper,根据不同的操作对象,将User换成不同的名称),将示例代码粘贴进去,随后将resultType
改成User类的路径,那么查询结果就会自动返回一个User类型,同时在src/main/java
目录下,新建com.blog.pojo.User类
,属性与数据库中的User表相对应。
- XML映射文件
- User类
查询语句改为了查询user表中的所有数据,同时将id改为selectAll用来标识此sql语句,resultType改为我们刚刚创建的User类的路径,namespace我们后面再说
然后将第3步的映射文件路径改为我们新创建的UserMapper路径 <mapper resource="UserMapper.xml"/>
XML
1 2 3 4 5 6 7 8 9 | <?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="UserMapper"> <select id="selectAll" resultType="com.blog.pojo.User"> select * from tb_user; </select> </mapper> |
5、编码 —> 定义POJO类,加载核心配置文件 —> 获取SqlSessionFactory对象 —> 获取SqlSession对象,执行SQL语句 —> 释放资源
- 看看官网怎么说
从 XML 文件中构建 SqlSessionFactory 的实例非常简单,建议使用类路径下的资源文件进行配置。 但也可以使用任意的输入流(InputStream)实例,比如用文件路径字符串或 file:// URL 构造的输入流。MyBatis 包含一个名叫 Resources 的工具类,它包含一些实用方法,使得从类路径或其它位置加载资源文件更加容易。
JAVA
1 2 3
String resource = "org/mybatis/example/mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
我们在java目录下新建com.blog.MyBatisDemo
类,将示例代码粘贴进去,将resource的路径改为我们的mybatis-config.xml
文件路径
JAVA
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 | import com.blog.pojo.User; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import java.io.IOException; import java.io.InputStream; import java.util.List; public class MyBatisDemo { public static void main(String[] args) throws IOException { //1. 加载MyBatis核心配置文件,获取SqlSessionFactory对象 String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //2. 调用SqlSessionFactory的openSession(),获取SqlSession对象 SqlSession sqlSession = sqlSessionFactory.openSession(); //3. 执行sql语句,String类型的参数写我们的UserMapper.xml中的 namespace.id List<User> users = sqlSession.selectList("UserMapper.selectAll"); System.out.println(users); //4. 资源关闭 sqlSession.close(); } } |
Mapper代理开发
Mapper代理开发概述
之前我们写的代码是基本使用方式,它也存在硬编码的问题,这里调用 selectList()
方法传递的参数是映射配置文件中的 namespace.id值。如果参数写错了,程序就无法执行,而参数的内容也没有IDE的自动补全功能,也不利于后期的维护
JAVA
1 2 | List<User> users = sqlSession.selectList("UserMapper.selectAll"); System.out.println(users); |
如果使用 Mapper 代理方式则不存在硬编码问题。
JAVA
1 2 | UserMapper userMapper = sqlSession.getMapper(UserMapper.class); List<User> users = userMapper.selectAll(); |
通过上面的描述可以看出 Mapper 代理方式的目的:
- 解决原生方式中的硬编码
- 简化后期执行SQL
Mybatis 官网也是推荐使用 Mapper 代理的方式。
为了这个简单的例子,我们似乎写了不少配置,但其实并不多。在一个 XML 映射文件中,可以定义无数个映射语句,这样一来,XML 头部和文档类型声明部分就显得微不足道了。文档的其它部分很直白,容易理解。 它在命名空间 “org.mybatis.example.BlogMapper” 中定义了一个名为 “selectBlog” 的映射语句,这样你就可以用全限定名 “org.mybatis.example.BlogMapper.selectBlog” 来调用映射语句了,就像上面例子中那样:
JAVA
1 | Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101); |
你可能会注意到,这种方式和用全限定名调用 Java 对象的方法类似。这样,该命名就可以直接映射到在命名空间中同名的映射器类,并将已映射的 select 语句匹配到对应名称、参数和返回类型的方法。因此你就可以像上面那样,不费吹灰之力地在对应的映射器接口调用方法,就像下面这样:
JAVA
1 2 | BlogMapper mapper = session.getMapper(BlogMapper.class); Blog blog = mapper.selectBlog(101); |
第二种方法有很多优势,首先它不依赖于字符串字面值,会更安全一点;其次,如果你的 IDE 有代码补全功能,那么代码补全可以帮你快速选择到映射好的 SQL 语句。
使用Mapper代理要求
使用Mapper代理方式,必须满足以下要求:
- 定义与SQL映射文件同名的Mapper接口,并且将Mapper接口和SQL映射文件放置在同一目录下。如下图:
-
设置SQL映射文件的namespace属性为Mapper接口全限定名
XML
1
<mapper namespace="com.blog.mapper.UserMapper">
-
在 Mapper 接口中定义方法,方法名就是SQL映射文件中sql语句的id,并保持参数类型和返回值类型一致
- XML
- Java
对应的Java中的方法名应为selectAll,且返回值类型应为User
XML
1
<select id="selectAll" resultType="com.blog.pojo.User">
案例代码的实现
在 com.blog.mapper
包下创建 UserMapper接口,代码如下:
JAVA
1 2 3 4 5 6 | import com.blog.pojo.User; import java.util.List; public interface UserMapper { List<User> selectAll(); } |
在 resources
下创建 com/blog/mapper
目录,并将原来 UserMapper.xml 映射配置文件粘贴进去,此时应该将MyBatis核心配置文件的SQL映射文件的路径更新
- UserMapper.xml
- mybatis-config.xml
XML
1 2 3 4 5 6 7 8 9 | <?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.blog.mapper.UserMapper"> <select id="selectAll" resultType="com.blog.pojo.User"> select * from tb_user; </select> </mapper> |
修改我们的MybatisDemo
测试类的第3步,代码如下
JAVA
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 | import com.blog.mapper.UserMapper; import com.blog.pojo.User; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import java.io.IOException; import java.io.InputStream; import java.util.List; public class MyBatisDemo { public static void main(String[] args) throws IOException { //1. 加载MyBatis核心配置文件,获取SqlSessionFactory对象 String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //2. 调用SqlSessionFactory的openSession(),获取SqlSession对象 SqlSession sqlSession = sqlSessionFactory.openSession(); //3. 获取UserMapper的代理对象 //3.1 通过SqlSession的getMapper方法获取Mapper接口的代理对象 UserMapper userMapper = sqlSession.getMapper(UserMapper.class); //3.2 调用对应方法完成sql的执行 List<User> users = userMapper.selectAll(); System.out.println(users); //4. 资源关闭 sqlSession.close(); } } |
细节:如果Mapper接口名称和SQL映射文件名称相同,并在同一目录下,则可以使用包扫描的方式简化SQL映射文件的加载
如果遵循Mapper代理的方式 —> Mapper接口名与SQL映射文件名就相同 —> 可以使用包扫描。
XML
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | <?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> <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:13306/mybatis?useSSL=false"/> <property name="username" value="root"/> <property name="password" value="PASSWORD."/> </dataSource> </environment> </environments> <mappers> <!--如果要在这里写好多映射文件,一个一个手写,也太麻烦了,如果你遵循了Mapper代理方式,就可以用包扫描的方式来简化操作--> <!--<mapper resource="com/blog/mapper/UserMapper.xml"/>--> <package name="com.blog.mapper"/> </mappers> </configuration> |
核心配置文件
核心配置文件中还可以配置很多内容。我们可以通过查询官网看可以配置的内容
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下:
- configuration(配置)
- properties(属性)
- settings(设置)
- typeAliases(类型别名)
- typeHandlers(类型处理器)
- objectFactory(对象工厂)
- plugins(插件)
- environments(环境配置)
- environment(环境变量)
- transactionManager(事务管理器)
- dataSource(数据源)
- environment(环境变量)
- databaseIdProvider(数据库厂商标识)
- mappers(映射器)
配置各个标签的时候,必须遵守前后顺序
多环境配置
在核心配置文件的 environments
标签中其实是可以配置多个 environment
,使用 id
给每段环境起名,在 environments
中使用 default='环境id'
来指定使用哪儿段配置。我们一般就配置一个 environment
即可。
XML
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | <environments default="development"> <!--切换不同的id可以使用不同的环境--> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <!--数据库连接信息--> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/> <property name="username" value="root"/> <property name="password" value="1234"/> </dataSource> </environment> <environment id="test"> <!--例如开发和测试使用的不是同一个数据库,或者想测试不同版本的数据库,可以新建一个环境--> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <!--数据库连接信息--> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/> <property name="username" value="root"/> <property name="password" value="1234"/> </dataSource> </environment> </environments> |
类型别名
在映射配置文件中的 resultType
属性需要配置数据封装的类型(类的全限定名)。而每次这样写是特别麻烦的,Mybatis 提供了 类型别名
(typeAliases) 可以简化这部分的书写。
首先需要现在核心配置文件中配置类型别名,也就意味着给pojo包下所有的类起了别名(别名就是类名),不区分大小写。内容如下:
XML
1 2 3 4 | <typeAliases> <!--name属性的值是实体类所在包--> <package name="com.blog.pojo"/> </typeAliases> |
通过上述的配置,我们就可以简化映射配置文件中 resultType
属性值的编写
XML
1 2 3 4 5 | <mapper namespace="com.blog.mapper.UserMapper"> <select id="selectAll" resultType="user"> select * from tb_user; </select> </mapper> |
Mybatis练习
目标
- 能够使用映射配置文件实现CRUD操作
- 能够使用注解实现CRUD操作
一般的产品原型,里面都会包含品牌数据的 查询
、按条件查询
、添加
、删除
、批量删除
、修改
等功能,而这些功能其实就是对数据库表中的数据进行CRUD操作。接下来我们就使用Mybatis完成品牌数据的增删改查操作。以下是我们要完成功能列表:
- 查询
- 查询所有数据
- 查询详情
- 条件查询
- 添加
- 修改
- 修改全部字段
- 修改动态字段
- 删除
- 删除一个
- 批量删除
环境准备
-
数据库表(tb_brand)及数据准备
SQL
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
-- 删除tb_brand表 DROP TABLE IF EXISTS tb_brand; -- 创建tb_brand表 CREATE TABLE tb_brand ( -- id 主键 id INT PRIMARY KEY AUTO_INCREMENT, -- 品牌名称 brand_name VARCHAR(20), -- 企业名称 company_name VARCHAR(20), -- 排序字段 ordered INT, -- 描述信息 description VARCHAR(100), -- 状态:0:禁用 1:启用 STATUS INT ); -- 添加数据 INSERT INTO tb_brand (brand_name, company_name, ordered, description, STATUS) VALUES ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0), ('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织,构建万物互联的智能世界', 1), ('小米', '小米科技有限公司', 50, 'are you ok', 1);
-
实体类 Brand,在
com.itheima.pojo
包下创建 Brand 实体类。JAVA
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 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
public class Brand { // id 主键 private Integer id; // 品牌名称 private String brandName; // 企业名称 private String companyName; // 排序字段 private Integer ordered; // 描述信息 private String description; // 状态:0:禁用 1:启用 private Integer status; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getBrandName() { return brandName; } public void setBrandName(String brandName) { this.brandName = brandName; } public String getCompanyName() { return companyName; } public void setCompanyName(String companyName) { this.companyName = companyName; } public Integer getOrdered() { return ordered; } public void setOrdered(Integer ordered) { this.ordered = ordered; } public String getDescription() { return description; } public void setDescription(String description) { this.description = description; } public Integer getStatus() { return status; } public void setStatus(Integer status) { this.status = status; } @Override public String toString() { return "Brand{" + "id=" + id + ", brandName='" + brandName + '\'' + ", companyName='" + companyName + '\'' + ", ordered=" + ordered + ", description='" + description + '\'' + ", status=" + status + '}'; } }
-
编写测试用例,测试代码需要在
test/java
目录下创建包及测试用例。 -
安装 MyBatisX 插件
- MybatisX 是一款基于 IDEA 的快速开发插件,为效率而生。
- 主要功能
- XML映射配置文件 和 接口方法 间相互跳转
- 根据接口方法生成 statement
查询所有数据
实现该功能我们分以下步骤进行实现:
- 编写接口方法:Mapper接口
- 参数:无
查询所有数据功能是不需要根据任何条件进行查询的,所以此方法不需要参数。 - 结果:
List<Brand>
我们会将查询出来的每一条数据封装成一个Brand
对象,而多条数据封装多个Brand
对象,需要将这些对象封装到List集合中返回。 - 执行方法、测试
- 参数:无
编写接口方法
在 com.blog.mapper
包写创建名为 BrandMapper
的接口。并在该接口中定义 List<Brand> selectAll()
方法。
JAVA
1 2 3 4 5 6 7 8 9 | package com.blog.mapper; import com.blog.pojo.Brand; import java.util.List; public interface BrandMapper { List<Brand> selectAll(); } |
编写SQL语句
在 reources
下创建 com/itheima/mapper
目录结构,并在该目录下创建名为 BrandMapper.xml
的映射配置文件
XML
1 2 3 4 5 6 7 8 9 10 | <?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.blog.mapper.BrandMapper"> <select id="selectAll" resultMap="brandResultMapper"> select * from tb_brand; </select> </mapper> |
编写测试方法
在 MybatisTest
类中编写测试查询所有的方法
JAVA
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | @Test public void testSelectAll() throws IOException{ //1. 加载MyBatis核心配置文件,获取SqlSessionFactory对象 String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //2. 获取SqlSession对象 SqlSession sqlSession = sqlSessionFactory.openSession(); //3. 获取Mapper接口的代理对象 BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class); //4. 执行方法 List<Brand> brands = brandMapper.selectAll(); System.out.println(brands); //5. 资源关闭 sqlSession.close(); } |
执行测试方法部分结果如下Brand{id=1, brandName='null', companyName='null', ordered=5, description='好吃不上火', status=0
其中brandName和companyName的值为NULL,究其原因是我们Brand类中的属性名和MySQL中的列名不一致。
这个问题我在上篇JDBC文章中给出了一个比较初级的解决方案,那就是给列取别名,令别名与我们Java中的命名方式相同,这样我们就可以通过获取列的别名,来进行反射赋值。
另一种解决方式是使用resultMap定义字段和属性的映射关系(推荐)
起别名解决上述问题
我们可以在写sql语句时给这两个字段起别名,将别名定义成和属性名一致即可。
XML
1 2 3 4 5 | <select id="selectAll" resultType="brand"> select id, brand_name as brandName, company_name as companyName, ordered, description, status from tb_brand; </select> |
而上面的SQL语句中的字段列表书写麻烦,如果表中还有更多的字段,同时其他的功能也需要查询这些字段时就显得我们的代码不够精炼。Mybatis提供了sql
片段可以提高sql的复用性。
SQL片段:
-
将需要复用的SQL片段抽取到
sql
标签中XML
1 2 3
<sql id="brand_column"> id, brand_name as brandName, company_name as companyName, ordered, description, status </sql>
id属性值是唯一标识,引用时也是通过该值进行引用。
-
在原sql语句中进行引用
使用include
标签引用上述的 SQL 片段,而refid
指定上述 SQL 片段的id值XML
1 2 3 4 5
<select id="selectAll" resultType="brand"> select <include refid="brand_column" /> from tb_brand; </select>
使用resultMap解决上述问题
起别名 + sql片段的方式可以解决上述问题,但是它也存在问题。如果还有功能只需要查询部分字段,而不是查询所有字段,那么我们就需要再定义一个 SQL 片段,这就显得不是那么灵活。
那么我们也可以使用resultMap来定义字段和属性的映射关系的方式解决上述问题。
- 在映射配置文件中使用resultMap定义
字段
和属性
的映射关系XML
1 2 3 4 5 6 7 8 9 10 11 12 13
<!--id用来标识唯一的resultMap,type表示映射类型--> <resultMap id="brandResultMap" type="brand"> <!-- id:完成主键字段的映射 column:表的列名 property:实体类的属性名 result:完成一般字段的映射 column:表的列名 property:实体类的属性名 --> <result column="brand_name" property="brandName"/> <result column="company_name" property="companyName"/> </resultMap>
注意:在上面只需要定义 字段名 和 属性名 不一样的映射,而一样的则不需要专门定义出来。
- SQL语句正常编写
XML
1 2 3 4 5
<!--使用resultMap属性替换掉原有的resultType属性--> <select id="selectAll" resultMap="brandResultMap"> select * from tb_brand; </select>
查询详情
查看详情功能实现步骤:
- 编写接口方法:Mapper接口
- 参数:id
查看详情就是查询某一行数据,所以需要根据id进行查询。而id以后是由页面传递过来。 - 结果:Brand
根据id查询出来的数据只要一条,而将一条数据封装成一个Brand对象即可
- 参数:id
- 编写SQL语句:SQL映射文件
- 执行方法、进行测试
编写接口方法
在 BrandMapper
接口中定义根据id查询数据的方法
JAVA
1 | Brand selectById(int id); |
编写SQL语句
在 BrandMapper.xml
映射配置文件中编写 statement
,使用 resultMap
而不是使用 resultType
XML
1 2 3 4 5 | <select id="selectById" resultMap="brandResultMapper"> select * from tb_brand where id = #{id}; <!--这个#{id}是占位符,后面会详细说--> </select> |
编写测试方法
在 test/java
下的 com.itheima.mapper
包下的 MybatisTest类中
定义测试方法
JAVA
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | @Test public void testSelectById() throws IOException { //接收参数,该id以后需要传递过来 int id = 1; //1. 加载MyBatis核心配置文件,获取SqlSessionFactory对象 String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //2. 获取SqlSession对象 SqlSession sqlSession = sqlSessionFactory.openSession(); //3. 获取Mapper接口的代理对象 BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class); //4. 执行方法 Brand brand = brandMapper.selectById(id); System.out.println(brand); //5. 资源关闭 sqlSession.close(); } |
参数占位符
mybatis提供了两种参数占位符:
#{}
:执行SQL时,会将 #{} 占位符替换为?,将来自动设置参数值。#{}
底层使用的是PreparedStatement
${}
:拼接SQL。底层使用的是Statement
,会存在SQL注入问题。关于SQL注入的问题我在上篇JDBC文章中做过详细的说明。
以后开发我们使用 #{} 参数占位符。
parameterType使用
对于有参数的mapper接口方法,我们在映射配置文件中应该配置 ParameterType
来指定参数类型。只不过该属性都可以省略。
XML
1 2 3 4 | <select id="selectById" parameterType="int" resultMap="brandResultMap"> select * from tb_brand where id = #{id}; </select> |
SQL语句中特殊字段处理
在xml中,”<”、”>”、”&”等字符是不能直接存入的,否则xml语法检查时会报错,如果想在xml中使用这些符号,必须将其转义为实体,如<
、>
、&
,这样才能保存进xml文档。或者使用<![CDATA[]]>
,被这个标记所包含的内容将表示为纯文本
但是严格来说,在XML中只有”<”和”&”是非法的,其它三个都是可以合法存在的,但是,把它们都进行转义是一个好的习惯。
不管怎么样,转义前的字符也好,转义后的字符也好,都会被xml解析器解析,为了方便起见,使用<![CDATA[]]>
来包含不被xml解析器解析的内容。但要注意的是:
- 此部分不能再包含
]]>
; - 不允许嵌套使用;
]]>
这部分不能包含空格或者换行。
最后,说说<![CDATA[]]>
和xml转移字符的关系,它们两个看起来是不是感觉功能重复了?
- 是的,它们的功能就是一样的,只是应用场景和需求有些不同:
<![CDATA[]]>
不能适用所有情况,转义字符可以;- 对于短字符串
<![CDATA[]]>
写起来啰嗦,对于长字符串转义字符写起来可读性差; <![CDATA[]]>
表示xml解析器忽略解析,所以更快。
- 转义字符
- CDATA
XML
1 2 3 4 5 | <select id="selectById" resultMap="brandResultMapper"> select * from tb_brand where id < #{id}; </select> |
多条件查询
在实际问题中,我们经常会遇到如上图所示的多条件查询,将多条件查询的结果展示在下方的数据列表中。而我们做这个功能需要分析最终的SQL语句应该是什么样,思考两个问题
- 条件表达式
- 如何连接
当前状态使用status
字段表示,企业名称使用company_name
表示,品牌名称使用brand_name
表示
条件字段 企业名称
和 品牌名称
需要进行模糊查询,所以条件应该是:
SQL
1 2 3 4 5 | select * from tb_brand where `status` = #{status} and company_name like #{companyName} and brand_name like #{brandName}; |
简单的分析后,我们来看功能实现的步骤:
- 编写接口方法
- 参数:所有查询条件
- 结果:
List<Brand>
-
在映射配置文件中编写SQL语句
-
编写测试方法并执行
编写接口方法
在 BrandMapper
接口中定义多条件查询的方法。
而该功能有三个参数,我们就需要考虑定义接口时,参数应该如何定义。Mybatis针对多参数有多种实现
- 使用
@Param( "SQL参数占位符名称")
标记每一个参数,在映射配置文件中就需要使用#{参数名称}
进行占位JAVA
1
List<Brand> selectByCondition(@Param("status") int status, @Param("companyName") String companyName, @Param("brandName") String brandName);
- 将多个参数封装成一个
实体对象
,将该实体对象作为接口的方法参数。该方式要求在映射配置文件的SQL中使用#{内容}
时,里面的内容必须和实体类属性名保持一致。JAVA
1
List<Brand> selectByCondition(Brand brand);
- 将多个参数封装到map集合中,将map集合作为接口的方法参数。该方式要求在映射配置文件的SQL中使用
#{内容}
时,里面的内容必须和map集合中键的名称一致。map.put(“SQL参数占位符名称”,数值);JAVA
1
List<Brand> selectByCondition(Map map);
编写SQL语句
在 BrandMapper.xml
映射配置文件中编写 statement
,注意使用 resultMap
替换 resultType
XML
1 2 3 4 5 6 7 | <select id="selectByCondition" resultMap="brandResultMap"> select * from tb_brand where status = #{status} and company_name like #{companyName} and brand_name like #{brandName} </select> |
编写测试方法
在 test/java
下的 com.blog.mapper
包下的 MybatisTest类中
定义测试方法
- Param注解
- 封装成对象
- 封装到map集合
JAVA
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | @Test public void testSelectByCondition() throws IOException { // 接收参数 int status = 1; String companyName = "华为"; String brandName = "华为"; // 处理参数 companyName = "%" + companyName + "%"; brandName = "%" + brandName + "%"; //1. 加载MyBatis核心配置文件,获取SqlSessionFactory对象 String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //2. 获取SqlSession对象 SqlSession sqlSession = sqlSessionFactory.openSession(); //3. 获取Mapper接口的代理对象 BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class); //4. 执行方法 List<Brand> brands = brandMapper.selectByCondition(status, companyName, brandName); System.out.println(brands); //5. 资源关闭 sqlSession.close(); } |
现在的这种查询方式,只有当用户把三个参数都填上的时候才能查询出来,如果另外两个参数没有填,那么SQL语句就会变成
SQL
1 | where status = null and company_name = null and brand_name = "%华为%" |
这样显然是不会查询成功的,下面我们来进行优化
动态SQL
上述功能实现存在很大的问题。用户在输入条件时,肯定不会所有的条件都填写,这个时候我们的SQL语句就不能那样写的
例如用户只输入 当前状态 时,SQL语句就是
SQL
1 | select * from tb_brand where status = #{status} |
而用户如果只输入企业名称时,SQL语句就是
SQL
1 | select * from tb_brand where company_name like #{companName} |
而用户如果输入了 当前状态
和 企业名称
时,SQL语句又不一样
SQL
1 | select * from tb_brand where status = #{status} and company_name like #{companName} |
针对上述的需要,Mybatis对动态SQL有很强大的支撑:
- if
- choose (when, otherwise)
- trim (where, set)
- foreach
我们先学习 if 标签:
- if 标签:条件判断
- test 属性:逻辑表达式
XML
1 2 3 4 5 6 7 8 9 10 11 12 13 14
<select id="selectByCondition" resultMap="brandResultMapper"> select * from tb_brand where <if test="status != null"> `status` = #{status} </if> <if test="companyName != null and companyName != ''"> and company_name like #{companyName} </if> <if test="brandName != null and brandName != ''"> and brand_name like #{brandName}; </if> </select>
- test 属性:逻辑表达式
如上的这种SQL语句就会根据传递的参数值进行动态的拼接。如果此时status和companyName有值那么就会值拼接这两个条件。SQL语句将变成
SQL
1 | select * from tb_brand where status = ? and company_name like ? |
但如果我们只给companyName这一个参数,那么SQL语句会变成下面这样
SQL
1 | select * from tb_brand where and company_name like ? |
WHERE关键字后面直接跟了个AND,变成了一条错误的SQL语句,那么最笨的一个解决方案就是在where后面先接一个恒等式
SQL
1 | select * from tb_brand where 1 = 1 and company_name like ? |
但MyBatis也料想到了这种情况,所以MyBatis又提供了一个where标签
- where 标签
- 作用:
- 替换where关键字
- 会动态的去掉第一个条件前的 and 或 or
- 如果所有的参数没有值则不加where关键字
XML
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
<select id="selectByCondition" resultMap="brandResultMapper"> select * from tb_brand <where> <if test="status != null"> `status` = #{status} </if> <if test="companyName != null and companyName != ''"> and company_name like #{companyName} </if> <if test="brandName != null and brandName != ''"> and brand_name like #{brandName}; </if> </where> </select>
- 作用:
单个条件(动态SQL)
如上图所示,在查询时只能选择 品牌名称
、当前状态
、企业名称
这三个条件中的一个,但是用户到底选择哪儿一个,我们并不能确定。这种就属于单个条件的动态SQL语句。
这种需求需要使用到 choose(when,otherwise)标签
实现,分别对应Java中的swtich
,case
,default
编写接口方法
在 BrandMapper
接口中定义单条件查询的方法。
JAVA
1 | List<Brand> selectByConditionSingle(Brand brand); |
编写SQL语句
在 BrandMapper.xml
映射配置文件中编写 statement
,使用 resultMap
替换 resultType
将where替换成<where>
标签,这样当我们没有选中任何查询方式时,会自动帮我们去掉where,从而查询所有数据
或者保持where不变,在choose中添加<otherwise>
标签,在其中写入一个恒等式,这样当没有选中任何查询方式时,SQL语句会变成select * from tb_brand where true
,同样实现查询所有数据的效果,但还是推荐前者的方式
XML
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | <select id="selectByConditionSingle" resultType="com.blog.pojo.Brand"> select * from tb_brand <where> <choose> <when test="status != null"> `status` = #{status} </when> <when test="companyName != null and companyName != ''"> companyName = #{companyName} </when> <when test="brandName != null and brandName != ''"> brandName = #{brandName} </when> </choose> </where> </select> |
编写测试方法
在 test/java
下的 com.blog.mapper
包下的 MybatisTest类中
定义测试方法
JAVA
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 | @Test public void testSelectByConditionSingle() throws IOException { //接收参数 int status = 1; String companyName = "华为"; String brandName = "华为"; // 处理参数 companyName = "%" + companyName + "%"; brandName = "%" + brandName + "%"; //封装对象 Brand brand = new Brand(); //brand.setStatus(status); brand.setCompanyName(companyName); //brand.setBrandName(brandName); //1. 获取SqlSessionFactory String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //2. 获取SqlSession对象 SqlSession sqlSession = sqlSessionFactory.openSession(); //3. 获取Mapper接口的代理对象 BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class); //4. 执行方法 List<Brand> brands = brandMapper.selectByConditionSingle(brand); System.out.println(brands); //5. 释放资源 sqlSession.close(); } |
其实我在测试的时候,一直出现Preparing: select * from tb_brand WHERE status = ?
,也就是这个status有值啊,哪儿来的值呢?
想了半天发现可能是构造器的status默认值为0吧,因为我那会儿吧status设为的int类型,所以默认值为0,随后恍然大悟,把status的类型改为Integer就行了,以前还真没注意过这个
添加数据
实际开发中,添加数据时会有一个图形化界面,而我们在该页面输入想要的数据后添加 提交
按钮,就会将这些数据添加到数据库中。接下来我们就来实现添加数据的操作。
- 编写接口方法
- 参数:除了id之外的所有的数据。id对应的是表中主键值,而主键我们是 自动增长 生成的。
- 编写SQL语句
- 编写测试方法并执行
编写接口方法
在 BrandMapper
接口中定义添加方法
JAVA
1 | void add(Brand brand); |
编写SQL语句
在 BrandMapper.xml
映射配置文件中编写添加数据的 statement
XML
1 2 3 4 | <insert id="add" > insert into tb_brand(brand_name, company_name, ordered, description, status) VALUES (#{brandName},#{companyName},#{ordered},#{description},#{status}) </insert> |
编写测试方法
在 test/java
下的 com.blog.mapper
包下的 MybatisTest类中
定义测试方法
JAVA
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 | @Test public void testAdd() throws IOException { //接收参数 String brandName = "波导"; String companyName = "波导手机"; Integer ordered = 100; String description = "手机中的战斗机"; int status = 1; //封装对象 Brand brand = new Brand(); brand.setBrandName(brandName); brand.setCompanyName(companyName); brand.setOrdered(ordered); brand.setDescription(description); brand.setStatus(status); //1. 获取SqlSessionFactory String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //2. 获取SqlSession对象 SqlSession sqlSession = sqlSessionFactory.openSession(); //3. 获取Mapper接口的代理对象 BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class); //4. 执行方法 brandMapper.add(brand); //提交事务 sqlSession.commit(); //5. 释放资源 sqlSession.close(); } |
在第2步获取SqlSession对象时,默认是不会自动提交事务的,我们可以在openSession方法中加上true,这样就能自动提交事务了,不用手动调用commit方法
JAVA
1 | //SqlSession sqlSession = sqlSessionFactory.openSession(true); //设置自动提交事务,这种情况不需要手动提交事务了 |
添加-主键返回
在接收参数的时候,我们没有接收id的参数,而是利用数据库主键自增长来自动赋值,但有时候我们又需要获取这个自增长的id。
解决方案
- 在 insert 标签上添加如下属性:
- useGeneratedKeys:是够获取自动增长的主键值。true表示获取
- keyProperty :指定将获取到的主键值封装到哪儿个属性里
XML
添加主键返回之后,我们再来测试一下1 2 3 4
<insert id="add" useGeneratedKeys="true" keyProperty="id"> insert into tb_brand(brand_name, company_name, ordered, description, status) VALUES (#{brandName},#{companyName},#{ordered},#{description},#{status}) </insert>
JAVA
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
@Test public void testAdd() throws IOException { //接收参数 String brandName = "波导"; String companyName = "波导手机"; Integer ordered = 100; String description = "手机中的战斗机"; int status = 1; //封装对象 Brand brand = new Brand(); brand.setBrandName(brandName); brand.setCompanyName(companyName); brand.setOrdered(ordered); brand.setDescription(description); brand.setStatus(status); //1. 获取SqlSessionFactory String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //2. 获取SqlSession对象 SqlSession sqlSession = sqlSessionFactory.openSession(); //3. 获取Mapper接口的代理对象 BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class); //4. 执行方法 brandMapper.add(brand); System.out.println(brand.getId()); //在这里输出一下id,看看有没有值输出,我这里是有的 //提交事务 sqlSession.commit(); //5. 释放资源 sqlSession.close(); }
修改
编写接口方法
在 BrandMapper
接口中定义修改方法。int获取修改的行数
JAVA
1 | int update(Brand brand); |
编写SQL语句
在 BrandMapper.xml
映射配置文件中编写修改数据的 statement
。
XML
1 2 3 4 5 6 7 8 9 | <update id="update"> update tb_brand set brand_name = #{brandName}, company_name = #{companyName}, ordered = #{ordered}, `description` = #{description}, `status` = #{status} where id = #{id} </update> |
编写测试方法
在 test/java
下的 com.blog.mapper
包下的 MybatisTest类中
定义测试方法
JAVA
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 | @Test public void testUpdate() throws IOException { //接收参数 int id = 5; String brandName = "波导"; String companyName = "波导手机"; Integer ordered = 200; String description = "波导手机,手机中的战斗机"; int status = 5; //封装对象 Brand brand = new Brand(); brand.setBrandName(brandName); brand.setCompanyName(companyName); brand.setOrdered(ordered); brand.setDescription(description); brand.setStatus(status); brand.setId(id); //1. 获取SqlSessionFactory String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //2. 获取SqlSession对象,并设置自动提交事务 SqlSession sqlSession = sqlSessionFactory.openSession(true); //3. 获取Mapper接口的代理对象 BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class); //4. 执行方法 int updateCount = brandMapper.update(brand); System.out.println(updateCount); //5. 释放资源 sqlSession.close(); } |
此种修改方式要改只能全部改,如果没有给某一个字段赋值,那么修改之后的值就是null,十分的不方便,所以我们要将其优化成动态的修改字段
修改动态字段
解决方案跟上面的类似,也是用if标签来判断用户的输入,然后用set标签来删除额外的逗号(上面是用where标签去除and或or),防止出现SQL语法错误
XML
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | <update id="update"> update tb_brand <set> <if test="brandName != null and brandName != ''"> brand_name = #{brandName}, </if> <if test="companyName != null and companyName != ''"> company_name = #{companyName}, </if> <if test="ordered != null"> ordered = #{ordered}, </if> <if test="description != null and description != ''"> `description` = #{description}, </if> <if test="status != null"> `status` = #{status} </if> </set> where id = #{id} </update> |
删除一行数据
我们在App网购的时候,购物车里都会有删除
按钮,,当用户点击了该按钮,就会将改行数据删除掉。那我们就需要思考,这种删除是根据什么进行删除呢?是通过主键id删除,因为id是表中数据的唯一标识。
接下来就来实现该功能。
编写接口方法
在 BrandMapper
接口中定义根据id删除方法。
JAVA
1 | void deleteById(int id); |
编写SQL语句
在 BrandMapper.xml
映射配置文件中编写删除一行数据的 statement
XML
1 2 3 4 5 | <delete id="deleteById"> delete from tb_brand where id = #{id}; </delete> |
编写测试方法
在 test/java
下的 com.blog.mapper
包下的 MybatisTest类中
定义测试方法
JAVA
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | @Test public void testDeleteById() throws IOException { //接收参数 int id = 6; //1. 获取SqlSessionFactory String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //2. 获取SqlSession对象 SqlSession sqlSession = sqlSessionFactory.openSession(true); //3. 获取Mapper接口的代理对象 BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class); //4. 执行方法 brandMapper.deleteById(id); //5. 释放资源 sqlSession.close(); } |
批量删除
我们在删除购物车订单的时候,都会有个多选按钮,可以选中多条记录进行删除,下面我们来实现这个功能
编写接口方法
在 BrandMapper
接口中定义删除多行数据的方法。
JAVA
1 2 | // 参数是一个数组,数组中存储的是多条数据的id void deleteByIds(int[] ids); |
编写SQL语句
在 BrandMapper.xml
映射配置文件中编写删除多条数据的 statement
。
编写SQL时需要遍历数组来拼接SQL语句。Mybatis 提供了 foreach
标签供我们使用
foreach 标签
用来迭代任何可迭代的对象(如数组,集合)。
- collection 属性:
- mybatis会将数组参数,封装为一个Map集合。
- 默认:array = 数组
- 使用@Param注解改变map集合的默认key的名称
- mybatis会将数组参数,封装为一个Map集合。
- item 属性:本次迭代获取到的元素。
- separator 属性:集合项迭代之间的分隔符。
foreach
标签不会错误地添加多余的分隔符。也就是最后一次迭代不会加分隔符。 - open 属性:该属性值是在拼接SQL语句之前拼接的语句,只会拼接一次
- close 属性:该属性值是在拼接SQL语句拼接后拼接的语句,只会拼接一次
XML
假如数组中的id数据是{1,2,3},那么拼接后的sql语句就是:1 2 3 4 5 6 7
<delete id="deleteByIds"> delete from tb_brand where id in <foreach collection="ids" item="id" separator="," open="(" close=")"> #{id} </foreach> </delete>
delete from tb_brand where id in (1,2,3);
编写测试方法
在 test/java
下的 com.blog.mapper
包下的 MybatisTest类中
定义测试方法
JAVA
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | @Test public void testDeleteByIds() throws IOException { //接收参数 int[] ids = {1,2,3}; //1. 获取SqlSessionFactory String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //2. 获取SqlSession对象 SqlSession sqlSession = sqlSessionFactory.openSession(true); //3. 获取Mapper接口的代理对象 BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class); //4. 执行方法 brandMapper.deleteByIds(ids); //5. 释放资源 sqlSession.close(); } |
MyBatis参数传递
Mybatis 接口方法中可以接收各种各样的参数,如下:
- 多个参数
- 单个参数:单个参数又可以是如下类型
- POJO 类型
- Map 集合类型
- Collection 集合类型
- List 集合类型
- Array 类型
- 其他类型
多个参数
如下面的代码,就是接收两个参数,而接收多个参数需要使用 @Param
注解,那么为什么要加该注解呢?这个问题要弄明白就必须来研究Mybatis的底层对于这些参数是如何处理的。
JAVA
1 | User select(@Param("username") String username,@Param("password") String password); |
XML
1 2 3 4 5 6 7 | <select id="select" resultType="user"> select * from tb_user where username=#{username} and password=#{password} </select> |
我们在接口方法中定义多个参数,Mybatis 会将这些参数封装成 Map 集合对象,值就是参数值,而键在没有使用 @Param
注解时有以下命名规则:
- 以 arg 开头 :第一个参数就叫 arg0,第二个参数就叫 arg1,以此类推。如:
- map.put(“arg0”,参数值1);
- map.put(“arg1”,参数值2);
- 以 param 开头 : 第一个参数就叫 param1,第二个参数就叫 param2,依次类推。如:
- map.put(“param1”,参数值1);
- map.put(“param2”,参数值2);
下面我们来验证一下
- 在
UserMapper
接口中定义如下方法JAVA
1
User select(String username,String password);
- 在
UserMapper.xml
映射配置文件中定义SQLXML
运行代码结果如下1 2 3 4 5 6 7
<select id="select" resultType="user"> select * from tb_user where username=#{arg0} <!--username=#{param1}--> and password=#{arg1} <!--and password=#{param2}--> </select>
PLAINTEXT
在映射配合文件的SQL语句中使用用1 2
[DEBU6][main] c.i.m.0.select- ==> Preparing: SELECT * FROM tb_user WHERE username = ? AND PASSWORD = ? [DEBU6] [main] c.i.m.U.select- ==> Parameters: zhangsan(STRING),123(STRING)
arg
开头的和param
书写,代码的可读性会变的特别差,此时可以使用@Param
注解。
在接口方法参数上使用 @Param
注解,Mybatis 会将 arg
开头的键名替换为对应注解的属性值。
以后接口参数是多个时,在每个参数上都使用 @Param
注解。这样代码的可读性更高。
单个参数
-
POJO 类型
直接使用。要求
属性名
和参数占位符名称
一致 -
Map 集合类型
直接使用。要求
map集合的键名
和参数占位符名称
一致 -
Collection 集合类型
Mybatis 会将集合封装到 map 集合中,如下:
map.put(“arg0”,collection集合);
map.put(“collection”,collection集合;
==可以使用
@Param
注解替换map集合中默认的 arg 键名。== -
List 集合类型
Mybatis 会将集合封装到 map 集合中,如下:
map.put(“arg0”,list集合);
map.put(“collection”,list集合);
map.put(“list”,list集合);
==可以使用
@Param
注解替换map集合中默认的 arg 键名。== -
Array 类型
Mybatis 会将集合封装到 map 集合中,如下:
map.put(“arg0”,数组);
map.put(“array”,数组);
==可以使用
@Param
注解替换map集合中默认的 arg 键名。== -
其他类型
比如int类型,
参数占位符名称
叫什么都可以。尽量做到见名知意
注解实现CURD
使用注解开发会比配置文件开发更加方便。如下就是使用注解进行开发
JAVA
1 2 | @Select(value = "select * from tb_user where id = #{id}") public User select(int id); |
注解是用来替换映射配置文件方式配置的,所以使用了注解,就不需要再映射配置文件中书写对应的 statement
Mybatis 针对 CURD 操作都提供了对应的注解,已经做到见名知意。如下:
- 查询 :@Select
- 添加 :@Insert
- 修改 :@Update
- 删除 :@Delete
接下来我们做一个案例来使用 Mybatis 的注解开发
- 代码实现:
- 将之前案例中
UserMapper.xml
中的 根据id查询数据 的statement
删掉 - 在
UserMapper
接口的selectById
方法上添加注解JAVA
1 2
@Select("select * from tb_user where id = #{id}") User selectById(int id);
- 测试
JAVA
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
@Test public void testSelect() throws IOException { //接收参数 int id = 2; //1. 获取SqlSessionFactory String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //2. 获取SqlSession对象 SqlSession sqlSession = sqlSessionFactory.openSession(true); //3. 获取Mapper接口的代理对象 UserMapper userMapper = sqlSession.getMapper(UserMapper.class); //4. 执行方法 User user = userMapper.selectById(id); System.out.println(user); //5. 释放资源 sqlSession.close(); }
- 将之前案例中
注意在官方文档中 入门
中有这样的一段话:
使用注解来映射简单语句会使代码显得更加简洁,但对于稍微复杂一点的语句,Java 注解不仅力不从心,还会让本就复杂的 SQL 语句更加混乱不堪。 因此,如果你需要做一些很复杂的操作,最好用 XML 来映射语句。
结论:注解完成简单功能,配置文件完成复杂功能。