JavaWab(一)

Maven

Apache Maven 是一个项目管理和构建工具，它基于项目对象模型(POM)的概念，通过一小段描述信息来管理项目的构建、报告和文档。
官网 ：http://maven.apache.org/

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依旧还是主流构建工具。

  <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 坐标主要组成

  • groupId：定义当前Maven项目隶属组织名称（通常是域名反写，例如：com.itheima）
  • artifactId：定义当前Maven项目名称（通常是模块名称，例如 order-service、goods-service）
  • version：定义当前项目版本号

• 下面的代码就是用坐标表示一个项目

  <groupId>com.alibaba</groupId>  <!--隶属组织阿里巴巴-->
  <artifactId>druid</artifactId>  <!--模块名称是德鲁伊-->
  <version>1.1.12</version>       <!--版本号是1.1.12-->

IDEA 创建 Maven项目

• 创建模块，选择Maven，点击Next
• 填写模块名称，坐标信息，点击finish，创建完成
• 创建好的项目目录结构如下
  

IDEA 导入 Maven项目

• 选择右侧Maven面板，点击 + 号
• 选中对应项目的pom.xml文件，双击即可

依赖范围

通过设置坐标的依赖范围(scope)，可以设置 对应jar包的作用范围：编译环境、测试环境、运行环境。

如下图所示给 junit 依赖通过 scope 标签指定依赖的作用范围。 那么这个依赖就只能作用在测试环境，其他环境下不能使用。

<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
官网：https://mybatis.org/mybatis-3/zh/index.html

MyBatis概述

• 持久层：
  • 负责将数据到保存到数据库的那一层代码。
    以后开发我们会将操作数据库的Java代码作为持久层。而Mybatis就是对jdbc代码进行了封装。
• 框架：
  • 框架就是一个半成品软件，是一套可重用的、通用的、软件基础代码模型
  • 在框架的基础之上构建软件编写更加高效、规范、通用、可扩展

MyBatis快速入门

查询user表中的数据
1、创建user表，添加数据

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 文件中：

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>x.x.x</version>  <!--版本号记得修改-->
</dependency>

由于涉及到了数据库的相关操作，所以我们也要将数据库的jar包的坐标导入。同理，我们还可以导入一些其他需要的jar包，例如junit单元测试，写日志的logback等

<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 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 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易。

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 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 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 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 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易。

  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文件路径

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的自动补全功能，也不利于后期的维护

List<User> users = sqlSession.selectList("UserMapper.selectAll");
System.out.println(users);

如果使用 Mapper 代理方式则不存在硬编码问题。

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” 来调用映射语句了，就像上面例子中那样：

Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);

你可能会注意到，这种方式和用全限定名调用 Java 对象的方法类似。这样，该命名就可以直接映射到在命名空间中同名的映射器类，并将已映射的 select 语句匹配到对应名称、参数和返回类型的方法。因此你就可以像上面那样，不费吹灰之力地在对应的映射器接口调用方法，就像下面这样：

BlogMapper mapper = session.getMapper(BlogMapper.class);
Blog blog = mapper.selectBlog(101);

第二种方法有很多优势，首先它不依赖于字符串字面值，会更安全一点；其次，如果你的 IDE 有代码补全功能，那么代码补全可以帮你快速选择到映射好的 SQL 语句。

使用Mapper代理要求

使用Mapper代理方式，必须满足以下要求：

• 定义与SQL映射文件同名的Mapper接口，并且将Mapper接口和SQL映射文件放置在同一目录下。如下图：
  

• 设置SQL映射文件的namespace属性为Mapper接口全限定名

  XML
  <mapper namespace="com.blog.mapper.UserMapper">

• 在 Mapper 接口中定义方法，方法名就是SQL映射文件中sql语句的id，并保持参数类型和返回值类型一致

  • XML
  • Java

  对应的Java中的方法名应为selectAll，且返回值类型应为User

  <select id="selectAll" resultType="com.blog.pojo.User">

案例代码的实现

在 com.blog.mapper 包下创建 UserMapper接口，代码如下：

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 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步，代码如下

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 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（数据源）
  • databaseIdProvider（数据库厂商标识）
  • mappers（映射器）

配置各个标签的时候，必须遵守前后顺序

多环境配置

在核心配置文件的 environments 标签中其实是可以配置多个 environment ，使用 id 给每段环境起名，在 environments 中使用 default='环境id' 来指定使用哪儿段配置。我们一般就配置一个 environment 即可。

<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包下所有的类起了别名（别名就是类名），不区分大小写。内容如下：

<typeAliases>
    <!--name属性的值是实体类所在包-->
    <package name="com.blog.pojo"/> 
</typeAliases>

通过上述的配置，我们就可以简化映射配置文件中 resultType 属性值的编写

<mapper namespace="com.blog.mapper.UserMapper">
    <select id="selectAll" resultType="user">
        select * from tb_user;
    </select>
</mapper>

Mybatis练习

目标

• 能够使用映射配置文件实现CRUD操作
• 能够使用注解实现CRUD操作

一般的产品原型，里面都会包含品牌数据的 查询 、按条件查询、添加、删除、批量删除、修改 等功能，而这些功能其实就是对数据库表中的数据进行CRUD操作。接下来我们就使用Mybatis完成品牌数据的增删改查操作。以下是我们要完成功能列表：

• 查询
  • 查询所有数据
  • 查询详情
  • 条件查询
• 添加
• 修改
  • 修改全部字段
  • 修改动态字段
• 删除
  • 删除一个
  • 批量删除

环境准备

• 数据库表（tb_brand）及数据准备

  -- 删除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 实体类。

  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() 方法。

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 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 类中编写测试查询所有的方法

@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语句时给这两个字段起别名，将别名定义成和属性名一致即可。

<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 标签中

  <sql id="brand_column">
  	id, brand_name as brandName, company_name as companyName, ordered, description, status
  </sql>

  id属性值是唯一标识，引用时也是通过该值进行引用。

• 在原sql语句中进行引用
  使用 include 标签引用上述的 SQL 片段，而 refid 指定上述 SQL 片段的id值

  <select id="selectAll" resultType="brand">
      select
      <include refid="brand_column" />
      from tb_brand;
  </select>

使用resultMap解决上述问题

起别名 + sql片段的方式可以解决上述问题，但是它也存在问题。如果还有功能只需要查询部分字段，而不是查询所有字段，那么我们就需要再定义一个 SQL 片段，这就显得不是那么灵活。

那么我们也可以使用resultMap来定义字段和属性的映射关系的方式解决上述问题。

• 在映射配置文件中使用resultMap定义

字段

和

属性

的映射关系

<!--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语句正常编写

  <!--使用resultMap属性替换掉原有的resultType属性-->
  <select id="selectAll" resultMap="brandResultMap">
      select *
      from tb_brand;
  </select>

查询详情

查看详情功能实现步骤：

• 编写接口方法：Mapper接口
  • 参数：id
    查看详情就是查询某一行数据，所以需要根据id进行查询。而id以后是由页面传递过来。
  • 结果：Brand
    根据id查询出来的数据只要一条，而将一条数据封装成一个Brand对象即可
• 编写SQL语句：SQL映射文件
• 执行方法、进行测试

编写接口方法

在 BrandMapper 接口中定义根据id查询数据的方法

Brand selectById(int id);

编写SQL语句

在 BrandMapper.xml 映射配置文件中编写 statement，使用 resultMap 而不是使用 resultType

<select id="selectById" resultMap="brandResultMapper">
    select *
    from tb_brand
    where id = #{id}; <!--这个#{id}是占位符，后面会详细说-->
</select>

编写测试方法

在 test/java 下的 com.itheima.mapper 包下的 MybatisTest类中 定义测试方法

@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 来指定参数类型。只不过该属性都可以省略。

<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

<select id="selectById" resultMap="brandResultMapper">
    select *
    from tb_brand
    where id &lt; #{id};
</select>

多条件查询

在实际问题中，我们经常会遇到如上图所示的多条件查询，将多条件查询的结果展示在下方的数据列表中。而我们做这个功能需要分析最终的SQL语句应该是什么样，思考两个问题

• 条件表达式
• 如何连接

当前状态使用status字段表示，企业名称使用company_name表示，品牌名称使用brand_name表示
条件字段 企业名称 和 品牌名称 需要进行模糊查询，所以条件应该是：

select *
from tb_brand
where `status` = #{status}
    and company_name like #{companyName}
    and brand_name like #{brandName};

简单的分析后，我们来看功能实现的步骤：

• 编写接口方法
  • 参数：所有查询条件
  • 结果：List<Brand>
• 在映射配置文件中编写SQL语句
• 编写测试方法并执行

编写接口方法

在 BrandMapper 接口中定义多条件查询的方法。

而该功能有三个参数，我们就需要考虑定义接口时，参数应该如何定义。Mybatis针对多参数有多种实现

1. 使用

@Param( "SQL参数占位符名称")

标记每一个参数，在映射配置文件中就需要使用

#{参数名称}

进行占位

List<Brand> selectByCondition(@Param("status") int status, @Param("companyName") String companyName, @Param("brandName") String brandName);

1. 将多个参数封装成一个

实体对象

，将该实体对象作为接口的方法参数。该方式要求在映射配置文件的SQL中使用

#{内容}

时，里面的内容必须和实体类属性名保持一致。

List<Brand> selectByCondition(Brand brand);

1. 将多个参数封装到map集合中，将map集合作为接口的方法参数。该方式要求在映射配置文件的SQL中使用

#{内容}

时，里面的内容必须和map集合中键的名称一致。map.put(“SQL参数占位符名称”,数值);

List<Brand> selectByCondition(Map map);

编写SQL语句

在 BrandMapper.xml 映射配置文件中编写 statement，注意使用 resultMap 替换 resultType

<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集合

@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语句就会变成

where status = null and company_name = null and brand_name = "%华为%"

这样显然是不会查询成功的，下面我们来进行优化

动态SQL

上述功能实现存在很大的问题。用户在输入条件时，肯定不会所有的条件都填写，这个时候我们的SQL语句就不能那样写的

例如用户只输入 当前状态 时，SQL语句就是

select * from tb_brand where status = #{status}

而用户如果只输入企业名称时，SQL语句就是

select * from tb_brand where company_name like #{companName}

而用户如果输入了 当前状态 和 企业名称 时，SQL语句又不一样+

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 属性：逻辑表达式

    <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>

如上的这种SQL语句就会根据传递的参数值进行动态的拼接。如果此时status和companyName有值那么就会值拼接这两个条件。SQL语句将变成

select * from tb_brand where status = ? and company_name like ?

但如果我们只给companyName这一个参数，那么SQL语句会变成下面这样

select * from tb_brand where and company_name like ?

WHERE关键字后面直接跟了个AND，变成了一条错误的SQL语句，那么最笨的一个解决方案就是在where后面先接一个恒等式

select * from tb_brand where 1 = 1 and company_name like ?

但MyBatis也料想到了这种情况，所以MyBatis又提供了一个where标签

• where 标签

  • 作用：

    • 替换where关键字

    • 会动态的去掉第一个条件前的 and 或 or

    • 如果所有的参数没有值则不加where关键字

      <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 接口中定义单条件查询的方法。

List<Brand> selectByConditionSingle(Brand brand);

编写SQL语句

在 BrandMapper.xml 映射配置文件中编写 statement，使用 resultMap 替换 resultType
将where替换成<where>标签，这样当我们没有选中任何查询方式时，会自动帮我们去掉where，从而查询所有数据
或者保持where不变，在choose中添加<otherwise>标签，在其中写入一个恒等式，这样当没有选中任何查询方式时，SQL语句会变成select * from tb_brand where true，同样实现查询所有数据的效果，但还是推荐前者的方式

<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类中 定义测试方法

@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 接口中定义添加方法

void add(Brand brand);

编写SQL语句

在 BrandMapper.xml 映射配置文件中编写添加数据的 statement

<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类中 定义测试方法

@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方法

//SqlSession sqlSession = sqlSessionFactory.openSession(true); //设置自动提交事务，这种情况不需要手动提交事务了

添加-主键返回

在接收参数的时候，我们没有接收id的参数，而是利用数据库主键自增长来自动赋值，但有时候我们又需要获取这个自增长的id。

解决方案

• 在 insert 标签上添加如下属性：

  • useGeneratedKeys：是够获取自动增长的主键值。true表示获取

  • keyProperty ：指定将获取到的主键值封装到哪儿个属性里

    <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>

    添加主键返回之后，我们再来测试一下

    @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获取修改的行数

int update(Brand brand);

编写SQL语句

在 BrandMapper.xml 映射配置文件中编写修改数据的 statement。

<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类中 定义测试方法

@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语法错误

<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删除方法。

void deleteById(int id);

编写SQL语句

在 BrandMapper.xml 映射配置文件中编写删除一行数据的 statement

<delete id="deleteById">
    delete
    from tb_brand
    where id = #{id};
</delete>

编写测试方法

在 test/java 下的 com.blog.mapper 包下的 MybatisTest类中 定义测试方法

@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 接口中定义删除多行数据的方法。

// 参数是一个数组，数组中存储的是多条数据的id
void deleteByIds(int[] ids);

编写SQL语句

在 BrandMapper.xml 映射配置文件中编写删除多条数据的 statement。

编写SQL时需要遍历数组来拼接SQL语句。Mybatis 提供了 foreach 标签供我们使用
foreach 标签

用来迭代任何可迭代的对象（如数组，集合）。

• collection 属性：

  • mybatis会将数组参数，封装为一个Map集合。
    • 默认：array = 数组
    • 使用@Param注解改变map集合的默认key的名称

• item 属性：本次迭代获取到的元素。

• separator 属性：集合项迭代之间的分隔符。foreach 标签不会错误地添加多余的分隔符。也就是最后一次迭代不会加分隔符。

• open 属性：该属性值是在拼接SQL语句之前拼接的语句，只会拼接一次

• close 属性：该属性值是在拼接SQL语句拼接后拼接的语句，只会拼接一次

  <delete id="deleteByIds">
      delete from tb_brand
      where id in
      <foreach collection="ids" item="id" separator="," open="(" close=")">
          #{id}
      </foreach>
  </delete>

  假如数组中的id数据是{1,2,3}，那么拼接后的sql语句就是：

  delete from tb_brand where id in (1,2,3);

编写测试方法

在 test/java 下的 com.blog.mapper 包下的 MybatisTest类中 定义测试方法

@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的底层对于这些参数是如何处理的。

User select(@Param("username") String username,@Param("password") String password);

<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

接口中定义如下方法

User select(String username,String password);

• 在

UserMapper.xml

映射配置文件中定义SQL

<select id="select" resultType="user">
    select *
    from tb_user
    where 
    username=#{arg0}        <!--username=#{param1}-->
    and password=#{arg1}    <!--and password=#{param2}-->
</select>

运行代码结果如下

PLAINTEXT
[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)

在映射配合文件的SQL语句中使用用

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

使用注解开发会比配置文件开发更加方便。如下就是使用注解进行开发

@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



方法上添加注解

@Select("select * from tb_user where id = #{id}")
User selectById(int id);

• 测试

  @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 来映射语句。

结论：注解完成简单功能，配置文件完成复杂功能。

HTML

介绍

HTML是一门语言，所有的网页都是用HTML这门语言编写出来的，也就是HTML是用来写网页的，像京东，12306等网站有很多网页。

HTML(HyperText Markup Language)：超文本标记语言：

• 超文本：超越了文本的限制，比普通文本更强大。除了文字信息，还可以定义图片、音频、视频等内容

  如上图看到的页面，我们除了能看到一些文字，同时也有大量的图片展示；有些网页也有视频，音频等。这种展示效果超越了文本展示的限制。

• 标记语言：由标签构成的语言

  之前学习的XML就是标记语言，由一个一个的标签组成，HTML 也是由标签组成 。我们在浏览器页面右键可以查看页面的源代码。

HTML标签不像XML那样可以自定义，HTML中的标签都是预定义好的，运行在浏览器上并由浏览器解析，然后展示出对应的效果。例如我们想在浏览器上展示出图片就需要使用预定义的 img 标签；想展示可以点击的链接的效果就可以使用预定义的 a 标签等。

W3C标准：

• W3C是万维网联盟，这个组成是用来定义标准的。他们规定了一个网页是由三部分组成，分别是：
  • 结构：对应的是 HTML 语言
  • 表现：对应的是 CSS 语言
  • 行为：对应的是 JavaScript 语言

HTML定义页面的整体结构；CSS是用来美化页面，让页面看起来更加美观；JavaScript可以使网页动起来，比如轮播图也就是多张图片自动的进行切换等效果。

快速入门

在IDEA中新建一个HTML文件，会默认为我们生成几个标签

<!--HTML5的标识-->
<!DOCTYPE html>
<html lang="en">
<head>
    <!--设定字符集-->
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

</body>
</html>

html标签是根标签，下面有 head 标签和 body 标签这两个子标签。而 head 标签的 title 子标签是用来定义页面标题名称的，它定义的内容会展示在浏览器的标题位置

body 标签的内容会被展示在内容区中

使用font标签可以改变文字颜色、大小、字体

<!--HTML5的标识-->
<!DOCTYPE html>
<html lang="en">
<head>
    <!--设定字符集-->
    <meta charset="UTF-8">
    <title>我的第一个网页</title>
</head>
<body>
<font color="red" size="5" face="楷体">HELLO WORLD!!</font>
</body>
</html>

• HTML 结构标签

• HTML 标签不区分大小写

  如上案例中的 font 写成 Font 也是一样可以展示出对应的效果的。

• HTML 标签属性值 单双引皆可

  如上案例中的color属性值使用双引号也是可以的。

• HTML 语法松散

  比如 font 标签不加结束标签也是可以展示出效果的。但不建议，最好严格按照要求去写。

标签	描述
	定义HTML文档
	定义关于文档的信息