给文档的代码块加上语言

增加了mybatis的文档
增加了solr的安装文档

linux/linux防火墙.md

@@ -4,7 +4,7 @@
 
 ## 1、防火墙状态管理
 
-```
+```shell
 # 查看默认防火墙状态
 firewall-cmd --state 
 # 开启防火墙命令：
@@ -25,7 +25,7 @@ systemctl status firewalld
 
 ## 2、防火墙关闭或者开启端口
 
-```
+```shell
 # Firewall开启常见端口命令：
 firewall-cmd --zone=public --add-port=80/tcp --permanent
 firewall-cmd --zone=public --add-port=443/tcp --permanent
@@ -51,7 +51,7 @@ firewall-cmd --zone=public --remove-port=4400-4600/tcp --permanent
 
 ## 3、防火墙开放特点端口
 
-```
+```shell
 # 针对某个 IP开放端口
 firewall-cmd --permanent --add-rich-rule="rule family="ipv4" source address="192.168.142.166" port protocol="tcp" port="6379" accept"
 firewall-cmd --permanent --add-rich-rule="rule family="ipv4" source address="192.168.0.233" accept"
@@ -66,7 +66,7 @@ firewall-cmd --permanent --remove-rich-rule="rule family="ipv4" source address="
 
 ## 4、防火墙注意事项
 
-```
+```shell
 # 操作后别忘了执行重载
 firewall-cmd --reload
 

中煤/大屏反馈BUG.md

@@ -0,0 +1,8 @@
+统一登录显示的问题
+
+采煤工作面190个    20-40  大部分30左右
+
+生产统计刀术要递增
+
+
+

前端/文档/jsdoc-vue.md

@@ -0,0 +1,21 @@
+# 1、安装cnpm和jsdoc
+
+```shell
+npm install cnpm -g 
+npm install jsdoc -g
+```
+
+# 2、初始化项目
+
+```shell
+cnpm i 
+cd example 
+cnpm i
+```
+
+# 3、执行脚本生成文档
+
+````shell
+jsdoc -c .jsdoc-tui.js -r
+````
+

后端/Mybatis/Mybatis.md

@@ -0,0 +1,1755 @@
+>[TOC]
+
+
+# Mybatis
+
+***
+
+环境：
+* JDK1.8
+* Mysql5.7
+* maven3.6.1
+* IDEA
+
+# 1、简介
+
+***
+
+## 1.1、什么是mybatis
+
+* MyBatis 是一款优秀的持久层框架;
+* 它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
+* 如何获得Mybatis
+```xml
+<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
+        <dependency>
+            <groupId>org.mybatis</groupId>
+            <artifactId>mybatis</artifactId>
+            <version>3.5.6</version>
+        </dependency>
+```
+* [中文文档](https://mybatis.org/mybatis-3/zh/index.html)
+* [英文文档](https://github.com/mybatis/mybatis-3)
+
+## 1.2、持久化
+
+数据持久化
+
+* 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
+* 内存：**断电即失**
+* 数据库（JDBC）,io文件持久化
+* 生活方面的例子：冷藏，罐头
+
+为什么需要持久化
+
+* 不想丢掉一些对象
+* 内存太贵
+
+## 1.3、持久层
+
+Dao层，Service层，Controller层
+
+* 完成持久化工作的代码块
+* 层界限十分明显
+
+## 1.4、为什么需要Mybatis
+
+* 帮助程序员将数据存入到数据库中
+* 方便
+* 传统的JDBC代码太复杂，简化->框架->自动化
+* 不用Mybatis也可以。更容易上手。技术没有高低之分
+* 优点：
+	* 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件就可以了，易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
+	* 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
+	* 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
+	* 提供xml标签，支持编写动态sql。
+	* 最重要的一点，使用的人多！公司需要！
+
+# 2、第一个Mybatis程序
+
+***
+
+思路流程：搭建环境-->导入Mybatis--->编写代码--->测试
+
+## 2.1、搭建环境
+
+搭建数据库
+```sql
+CREATE DATABASE `mybatis`;
+
+USE `mybatis`;
+
+DROP TABLE IF EXISTS `user`;
+
+CREATE TABLE `user` (
+`id` int(20) NOT NULL,
+`name` varchar(30) DEFAULT NULL,
+`pwd` varchar(30) DEFAULT NULL,
+PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+insert  into `user`(`id`,`name`,`pwd`) values (1,'狂神','123456'),(2,'张三','abcdef'),(3,'李四','987654');
+```
+
+新建项目
+
+* 新建一个普通maven项目
+* 删除src目录
+* 导入maven依赖
+
+```xml
+    <!--导入依赖-->
+    <dependencies>
+        <!--mysql-->
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>8.0.22</version>
+        </dependency>
+        <!--mybatis-->
+        <dependency>
+            <groupId>org.mybatis</groupId>
+            <artifactId>mybatis</artifactId>
+            <version>3.5.6</version>
+        </dependency>
+        <!--junit-->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+        </dependency>
+    </dependencies>
+```
+
+## 2.2、创建一个模块
+
+编写MyBatis核心配置文件
+查看帮助文档
+
+```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="com.mysql.cj.jdbc.Driver"/>
+                <property name="url"
+                          value="jdbc:mysql://124.221.127.83:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
+                <property name="username" value="root"/>
+                <property name="password" value="root"/>
+            </dataSource>
+        </environment>
+    </environments>
+    <mappers>
+        <mapper resource="com/dao/UserMapper.xml"/>
+    </mappers>
+</configuration>
+```
+
+编写mybatis工具类
+
+```java
+public class MybatisUtils {
+    private static SqlSessionFactory sqlSessionFactory;
+
+    static {
+        try {
+            // 使用mybatis工具类获取sqlSessionFactory对象
+            String resource = "mybatis-config.xml";
+            InputStream inputStream = Resources.getResourceAsStream(resource);
+            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    // 既然有了SqlSessionFactory，顾名思义，我们可以从中获得SqlSession的实例。
+    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
+    public static SqlSession getSqlSession() {
+        return sqlSessionFactory.openSession();
+    }
+
+}
+```
+
+## 2.3、编写代码
+
+* 实体类
+
+```java
+public class User {
+    private int id;
+    private String name;
+    private String pwd;
+
+    public User() {
+    }
+
+    public User(int id, String name, String pwd) {
+        this.id = id;
+        this.name = name;
+        this.pwd = pwd;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getPwd() {
+        return pwd;
+    }
+
+    public void setPwd(String pwd) {
+        this.pwd = pwd;
+    }
+
+    @Override
+    public String toString() {
+        return "User{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", pwd='" + pwd + '\'' +
+                '}';
+    }
+}
+
+```
+
+* Dao接口
+
+```java
+public interface UseMapper {
+    // 获取全部用户
+    List<User> getUserList();
+
+    // 根据ID查询用户
+    User getUserById(int id);
+
+    // 添加一个用户
+    int addUser(User user);
+
+    // 修改一个用户
+    int updateUser(User user);
+
+    // 根据id删除用户
+    int deleteUser(int id);
+}
+```
+
+* mapper
+
+```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">
+<!--namespace=绑定一个对应的Dao/Mapper窗口-->
+<mapper namespace="com.dao.UseMapper">
+    <!--select查询语句-->
+    <select id="getUserList" resultType="com.entity.User">
+        select *
+        from user
+    </select>
+
+    <select id="getUserById" parameterType="int" resultType="com.entity.User">
+        select * from user where id = #{id}
+    </select>
+
+    <!--对象中的属性可以直接提取出来-->
+    <insert id="addUser" parameterType="com.entity.User">
+        insert into user (id,name,pwd) values (#{id},#{name},#{pwd})
+    </insert>
+
+    <update id="updateUser" parameterType="com.entity.User">
+        update user set name=#{name},pwd=#{pwd} where id = #{id}
+    </update>
+
+    <delete id="deleteUser" parameterType="int">
+        delete from user where id = #{id}
+    </delete>
+</mapper>
+```
+
+# 3、万能的Map
+
+***
+
+假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应当考虑使用Map！
+
+```java
+    // 万能的Map
+    int addUser2(Map<String,Object> map);
+```
+
+```xml
+    <insert id="addUser2" parameterType="map">
+        insert into user (id,pwd) values (#{userid},#{password})
+    </insert>
+```
+
+Map传递参数，直接在sql中取出key即可！
+对象传递参数，直接在sql中取对象的属性即可！
+只有一个基本类型参数的情况下，可以直接在sql中取到！
+多个参数用Map，**或者注解！**
+
+在sql语句中拼接通配符，会引起sql注入
+
+```xml
+    <select id="getUserLike" resultType="com.entity.User">
+        select * from user where name like "%"#{value}"%"
+    </select>
+```
+
+# 4、配置解析
+
+***
+
+## 4.1、核心配置文件
+
+* mybatis-config.xml
+* Mybatis的配置文件包含了会深深影响MyBatis行为的设置和属性信息。
+
+````
+configuration（配置）
+    properties（属性）
+    settings（设置）
+    typeAliases（类型别名）
+    typeHandlers（类型处理器）
+    objectFactory（对象工厂）
+    plugins（插件）
+        environments（环境配置）
+            environment（环境变量）
+            transactionManager（事务管理器）
+    dataSource（数据源）
+    databaseIdProvider（数据库厂商标识）
+    mappers（映射器）
+````
+
+## 4.2、环境变量
+
+MyBatis 可以配置成适应多种环境
+
+**不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。**
+
+Mybatis 默认的事务管理器是JDBC，连接池：POOLED
+
+## 4.3、 属性
+
+我们可以通过properties属性来引用配置文件
+
+这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。 （db.properties）
+
+编写一个配置文件
+
+````pro
+driver=com.mysql.cj.jdbc.Driver
+url=jdbc:mysql://124.221.127.83:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8
+username=root
+password=root
+````
+
+在核心配置文件中引入
+
+mybatis-config.xml (同时有的话，外面properties优先)
+
+```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>
+    <!--引入外部配置文件-->
+    <properties resource="db.properties">
+        <property name="username" value="root"/>
+        <property name="password" value="root"/>
+    </properties>
+
+    <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>
+        <mapper resource="com/dao/UserMapper.xml"/>
+    </mappers>
+</configuration>
+```
+
+
+## 4.4、类型别名 typeAliases
+
+* 类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置.
+* 意在降低冗余的全限定类名书写。
+
+```xml
+<!--可以给实体类起别名-->
+<typeAliases>
+    <typeAlias type="com.entity.User" alias="User"/>
+</typeAliases>
+```
+
+也可以指定一个包，每一个在包 `domain.blog` 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 `domain.blog.Author` 的别名为 `author`
+
+在实体类比较少的时候，使用第一种方式。
+
+如果实体类十分多，建议用第二种扫描包的方式。第一种可以DIY别名，第二种不行，如果非要改，需要在实体上增加注解。
+
+```java
+@Alias("user")
+public class User {
+    ...
+}
+```
+
+## 4.5、设置
+
+| 设置名             | 描述                                                         | 有效值                                                       | 默认   |
+| :----------------- | :----------------------------------------------------------- | :----------------------------------------------------------- | :----- |
+| cacheEnabled       | 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。     | true \| false                                                | true   |
+| lazyLoadingEnabled | 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 `fetchType` 属性来覆盖该项的开关状态。 | true \| false                                                | false  |
+| logImpl            | 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。        | SLF4J \| LOG4J \| LOG4J2 \| JDK_LOGGING \| COMMONS_LOGGING \| STDOUT_LOGGING \| NO_LOGGING | 未设置 |
+
+## 4.6、映射器
+
+MapperRegistry：注册绑定我们的Mapper文件；
+
+方式一: [推荐使用]
+
+```xml
+<mappers>
+    <mapper resource="com/dao/UserMapper.xml"/>
+</mappers>
+```
+
+方式二：
+
+```xml
+<mappers>
+    <mapper class="com.dao.UserMapper"/>
+</mappers>
+```
+
+* 接口和它的Mapper必须同名
+* 接口和他的Mapper必须在同一包下
+
+方式三：
+
+```xml
+<mappers>
+    <package name="com.dao" />
+</mappers>
+```
+
+* 接口和它的Mapper必须同名
+* 接口和他的Mapper必须在同一包下
+
+## 4.7、作用域和生命周期
+
+生命周期和作用域是至关重要的，因为错误的使用会导致非常严重的**并发问题**
+
+![image-20220228173708302](assets/image-20220228173708302.png)
+
+**SqlSessionFactoryBuilder:**
+
+- 一旦创建了SqlSessionFactory，就不再需要它了
+- 局部变量
+
+**SqlSessionFactory:**
+
+- 就是数据库连接池。
+- 一旦被创建就应该在应用的运行期间一直存在 ，**没有任何理由丢弃它或重新创建另一个实例 。** 多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。
+- 因此 SqlSessionFactory 的最佳作用域是应用作用域。
+- 最简单的就是使用单例模式或者静态单例模式。
+
+**SqlSession**：
+
+- 每个线程都应该有它自己的 SqlSession 实例。
+- 连接到连接池的请求！
+- SqlSession 的实例不是线程安全的，因此是不能被共享的 ，所以它的最佳的作用域是请求或方法作用域。
+- 用完之后赶紧关闭，否则资源被占用。
+
+![image-20220228174524811](assets/image-20220228174524811.png)
+
+**这里面的每一个Mapper就代表每一个具体业务！**
+
+# 5、解决属性名和字段名不一致的问题
+
+***
+
+数据库中的字段
+
+![image-20220301123009394](assets/image-20220301123009394.png)
+
+新建一个项目，拷贝之前，测试实体字段不一致的情况
+User
+
+```java
+public class User {
+    private int id;
+    private String name;
+    private String password;
+}
+```
+
+![image-20220301123406863](assets/image-20220301123406863.png)
+
+解决方法：
+核心配置文件
+
+* 起别名
+
+```xml
+    <select id="getUserById" parameterType="int" resultType="com.entity.User">
+        select id, name, pwd as password from user where id = #{id}
+    </select>
+```
+
+* resultMap 结果集映射
+
+```xml
+    <select id="getUserById" resultMap="UserMap" parameterType="int">
+        select * from user where id = #{id}
+    </select>
+
+    <!--结果集映射-->
+    <resultMap id="UserMap" type="User">
+        <!--column 数据库中的字段，property实体中的属性-->
+        <result column="id" property="id"></result>
+        <result column="name" property="name"></result>
+        <result column="pwd" property="password"></result>
+    </resultMap>
+```
+
+- `resultMap` 元素是 MyBatis 中最重要最强大的元素。
+- ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
+
+```xml
+    <!--结果集映射-->
+    <resultMap id="UserMap" type="User">
+        <!--column 数据库中的字段，property实体中的属性-->
+        <result column="pwd" property="password"></result>
+    </resultMap>
+```
+
+- resultMap 元素是 MyBatis 中最重要最强大的元素。
+- ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
+- ResultMap 的优秀之处——你完全可以不用显式地配置它们。
+- 如果这个世界总是这么简单就好了。
+
+# 6、日志
+
+***
+
+## 6.1、日志工厂
+
+如果一个数据库操作出现了异常，我们需要排错。日志就是最好的助手。
+曾经：sout，debug
+现在：日志工厂
+
+ ![image-20220301130041815](assets/image-20220301130041815.png)
+
+- SLF4J
+- LOG4J [掌握]
+- LOG4J2
+- JDK_LOGGING
+- COMMONS_LOGGING
+- STDOUT_LOGGING [掌握]
+- NO_LOGGING
+
+具体使用哪一个，在设置中设定
+**STDOUT_LOGGING 标志日志输出**
+mybatis-confi中
+
+```xml
+<settings>
+    <setting name="logImpl" value="STDOUT_LOGGING"/>
+</settings>
+```
+
+![image-20220301130602068](assets/image-20220301130602068.png)
+
+## 6.2、Log4j
+
+1. 先导包
+
+```xml
+        <!--log4j-->
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>1.2.17</version>
+        </dependency>
+```
+
+2. 新建log4j.properties文件
+
+```properties
+### set log levels ###
+log4j.rootLogger = DEBUG,console,file
+
+### 输出到控制台 ###
+log4j.appender.console = org.apache.log4j.ConsoleAppender
+log4j.appender.console.Target = System.out
+log4j.appender.console.Threshold = DEBUG
+log4j.appender.console.layout = org.apache.log4j.PatternLayout
+log4j.appender.console.layout.ConversionPattern = [%c]-%m%n
+
+### 输出到日志文件 ###
+log4j.appender.file=org.apache.log4j.RollingFileAppender
+log4j.appender.file.File=./log/hou.log
+log4j.appender.file.MaxFileSize=10mb 
+log4j.appender.file.Threshold=DEBUG 
+log4j.appender.file.layout=org.apache.log4j.PatternLayout
+log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n
+
+# 日志输出级别
+log4j.logger.org.mybatis=DEBUG
+log4j.logger.java.sql=DEBUG
+log4j.logger.java.sql.Statement=DEBUG
+log4j.logger.java.sql.ResultSet=DEBUG
+log4j.logger.java.sql.PreparedStatement=DEBUG
+```
+
+3. 配置实现
+
+```xml
+<settings>
+    <setting name="logImpl" value="LOG4J"/>
+</settings>
+```
+
+4. log4j的使用
+
+![image-20220301131606082](assets/image-20220301131606082.png)
+
+## 6.3、log4j简单使用
+
+1. 在要使用Log4j的类中，导入包 import org.apache.log4j.Logger;
+2. 日志对象，参数为当前类的class对象
+
+```java
+ Logger logger = Logger.getLogger(UserDaoTest.class);
+```
+
+3. 日志级别
+
+```java
+logger.info("info: 测试log4j");
+logger.debug("debug: 测试log4j");
+logger.error("error:测试log4j");
+```
+
+# 7、分页
+
+***
+
+**思考：为什么分页?**
+
+- 减少数据的处理量
+
+## 7.1、使用limit分页
+
+```sql
+SELECT * FROM user LIMIT startIndex,pageSize;
+SELECT * FROM user LIMIT end; #[0, end]
+```
+
+**使用MyBatis实现分页，核心SQL**
+
+1. 接口
+
+   ```java
+   // 分页
+   List<User> getUserByLimit(Map<String,Integer> map);
+   ```
+
+2. Mapper.xml
+
+   ```xml
+   <!--分页查询-->
+   <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
+       select * from user limit #{startIndex},#{pageSize}
+   </select>
+   ```
+
+3. 测试
+
+   ```java
+       @Test
+       public void getUserByLimit(){
+           SqlSession sqlSession = MybatisUtils.getSqlSession();
+           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
+   
+           Map<String, Integer> map = new HashMap<String, Integer>();
+           map.put("startIndex", 1);
+           map.put("pageSize", 2);
+           List<User> userList = mapper.getUserByLimit(map);
+   
+           for(User user:userList){
+               System.out.println(user);
+           }
+   
+           sqlSession.close();
+       }
+   ```
+
+## 7.2、使用RowBounds分页
+
+不再使用SQL实现分页
+
+1. 接口
+
+   ```java
+   //分页2
+   List<User> getUserByRowBounds();
+   ```
+
+2. mapper.xml
+
+   ```xml
+   <!--分页查询2-->
+   <select id="getUserByRowBounds">
+       select * from user limit #{startIndex},#{pageSize}
+   </select>
+   ```
+
+3. 测试
+
+   ```java
+   @Test
+   public void getUserByRow(){
+       SqlSession sqlSession = MybatisUtils.getSqlSession();
+       // RowBounds实现
+       RowBounds rowBounds = new RowBounds(1, 2);
+   
+       // 通过java代码层面
+       List<User> userList = sqlSession.selectList
+           ("com.dao.UserMapper.getUserByRowBounds",
+            null,rowBounds);
+   
+       for (User user : userList) {
+           System.out.println(user);
+       }
+   
+       sqlSession.close();
+   }
+   ```
+
+## 7.3、分页插件
+
+![image-20220301143250719](assets/image-20220301143250719.png)
+
+# 8、使用注解开发
+
+***
+
+## 8.1、面向接口编程
+
+**三个面向区别**
+
+- 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性和方法
+- 面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现；
+- 接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题，更多的体现就是对系统整体的架构；
+
+## 8.2、使用注解开发
+
+1. 删除 UserMapper.xml
+
+2. UserMapper
+
+   ```java
+   public interface UserMapper {
+   
+       @Select("select * from user")
+       List<User> getUsers();
+   }
+   ```
+
+3. 核心配置 mybatis-config.xml
+
+   ```xml
+    <!--绑定接口-->
+   <mappers>
+       <mapper class="com.hou.dao.UserMapper"></mapper>
+   </mappers>
+   
+   ```
+
+   本质：反射机制
+
+   底层：动态代理
+
+![image-20220301151910709](assets/image-20220301151910709.png)
+
+**Mybatis详细执行流程：**
+
+1. Resource获取全局配置文件
+2. 实例化SqlsessionFactoryBuilder
+3. 解析配置文件流XMLCondigBuilder
+4. Configration所有的配置信息
+5. SqlSessionFactory实例化
+6. trasactional事务管理
+7. 创建executor执行器
+8. 创建SqlSession
+9. 实现CRUD
+10. 查看是否执行成功
+11. 提交事务
+12. 关闭
+
+![Mybatis详细执行流程](assets/20201017070716720.png)
+
+## 8.3、注解CRUD
+
+编写接口
+
+```java
+public interface UserMapper {
+    // 获取全部用户
+    @Select("select * from user")
+    List<User> getUserList();
+
+    // 方法存在多个参数，所有的参数必须加@Param
+    @Select("select * from user where id = #{id}")
+    User getUserById(@Param("id") int id);
+
+    @Insert("insert into user (id, name, pwd) values" +
+            "(#{id},#{name},#{pwd})")
+    int addUser(User user);
+
+    @Update("update user set name=#{name}, pwd=#{pwd} " +
+            "where id=#{id}")
+    int updateUser(User user);
+
+    @Delete("delete from user where id=#{id}")
+    int deleteUser(@Param("id") int id);
+}
+```
+
+MybatisUtile
+
+```java
+public class MybatisUtils {
+    private static SqlSessionFactory sqlSessionFactory;
+
+    static {
+        try {
+            // 使用mybatis工具类获取sqlSessionFactory对象
+            String resource = "mybatis-config.xml";
+            InputStream inputStream = Resources.getResourceAsStream(resource);
+            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    // 既然有了SqlSessionFactory，顾名思义，我们可以从中获得SqlSession的实例。
+    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
+    public static SqlSession getSqlSession() {
+        return sqlSessionFactory.openSession(true);
+    }
+
+}
+```
+
+Test
+【注意：我们必须要将接口注册绑定到我们的核心配置文件中】
+
+```java
+public class UserMapperTest {
+
+    @Test
+    public void getUserById(){
+        // 获得sqlSession对象
+        SqlSession sqlSession = MybatisUtils.getSqlSession();
+        try{
+            // 1.执行 getMapper
+            UserMapper userDao = sqlSession.getMapper(UserMapper.class);
+            User user = userDao.getUserById(1);
+
+            System.out.println(user);
+
+
+        }catch(Exception e){
+            e.printStackTrace();
+        }finally{
+            // 关闭
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void addUser(){
+        // 获得sqlSession对象
+        SqlSession sqlSession = MybatisUtils.getSqlSession();
+        try{
+            // 1.执行 getMapper
+            UserMapper userDao = sqlSession.getMapper(UserMapper.class);
+            userDao.addUser(new User(6, "kun","123"));
+
+        }catch(Exception e){
+            e.printStackTrace();
+        }finally{
+            // 关闭
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void updateUser(){
+        // 获得sqlSession对象
+        SqlSession sqlSession = MybatisUtils.getSqlSession();
+        try{
+            // 1.执行 getMapper
+            UserMapper userDao = sqlSession.getMapper(UserMapper.class);
+            userDao.updateUser(new User(6, "fang","123"));
+
+        }catch(Exception e){
+            e.printStackTrace();
+        }finally{
+            //关闭
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void deleteUser(){
+        // 获得sqlSession对象
+        SqlSession sqlSession = MybatisUtils.getSqlSession();
+        try{
+            // 1.执行 getMapper
+            UserMapper userDao = sqlSession.getMapper(UserMapper.class);
+            userDao.deleteUser(6);
+
+        }catch(Exception e){
+            e.printStackTrace();
+        }finally{
+            //关闭
+            sqlSession.close();
+        }
+    }
+}
+```
+
+**关于@Param( )注解**
+
+- 基本类型的参数或者String类型，需要加上
+- 引用类型不需要加
+- 如果只有一个基本类型的话，可以忽略，但是建议大家都加上
+- 我们在SQL中引用的就是我们这里的@Param()中设定的属性名
+
+**#{} 和 ${}**
+
+* 一般使用#号，防止注入
+* 两个都可以使用
+
+# 9、Lombok
+
+***
+
+Lombok项目是一个Java库，它会自动插入编辑器和构建工具中，Lombok提供了一组有用的注释，用来消除Java类中的大量样板代码。仅五个字符(@Data)就可以替换数百行代码从而产生干净，简洁且易于维护的Java类。
+
+使用步骤：
+
+1. 在IDEA中安装Lombok插件，现在已经不需要安装，idea已经内置
+
+2. 在项目中导入Lombok的jar包
+
+   ```xml
+   <dependency>
+       <groupId>org.projectlombok</groupId>
+       <artifactId>lombok</artifactId>
+       <version>1.18.8</version>
+   </dependency>
+   ```
+
+3. 在程序上加注解
+
+   在实体类上加注解
+
+   ```java
+   @AllArgsConstructor // 有参构造
+   @NoArgsConstructor // 无参构造
+   @Data // 无参构造，get，set，toString，hashCode
+   public class User {
+       private int id;
+       private String name;
+       private String pwd;
+   }
+   ```
+
+![image-20220301155900195](assets/image-20220301155900195.png)
+
+# 10、多对一处理
+
+****
+
+![image-20220301163509735](assets/image-20220301163509735.png)
+
+多对一：
+
+- 多个学生，对应一个老师
+- 对于学生而言，**关联**–多个学生，关联一个老师【多对一】
+- 对于老师而言，**集合**–一个老师，有很多个学生【一对多】
+
+SQL语句：
+
+```sql
+CREATE TABLE `teacher` (
+	`id` INT(10) NOT NULL,
+	`name` VARCHAR(30) DEFAULT NULL,
+	PRIMARY KEY (`id`)
+)ENGINE = INNODB DEFAULT CHARSET=utf8
+
+INSERT INTO teacher(`id`,`name`) VALUES (1,'秦老师');
+
+CREATE TABLE `student` (
+	`id` INT(10) NOT NULL,
+	`name` VARCHAR(30) DEFAULT NULL,
+	`tid` INT(10) DEFAULT NULL,
+	PRIMARY KEY (`id`),
+	KEY `fktid`(`tid`),
+	CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
+)ENGINE = INNODB DEFAULT CHARSET=utf8
+
+INSERT INTO `student`(`id`,`name`,`tid`) VALUES ('1','小明','1');
+INSERT INTO `student`(`id`,`name`,`tid`) VALUES ('2','小红','1');
+INSERT INTO `student`(`id`,`name`,`tid`) VALUES ('3','小张','1');
+INSERT INTO `student`(`id`,`name`,`tid`) VALUES ('4','小李','1');
+INSERT INTO `student`(`id`,`name`,`tid`) VALUES ('5','小王','1');
+```
+
+**测试环境搭建**
+
+1. 导入lombok
+2. 新建实体类Teacher,Student
+3. 建立Mapper接口
+4. 建立Mapper.xml文件
+5. 在核心配置文件中绑定注册我们的Mapper接口或者文件 【方式很多，随心选】
+6. 测试查询是否能够成功
+
+## 10.1、按照查询嵌套处理
+
+1. 给StudentMapper接口增加方法
+
+   ```java
+   // 获取所有学生及对应老师的信息
+   public List<Student> getStudents();
+   ```
+
+2. 编写对应打的Mapper文件
+
+   ```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.kuang.dao.StudentMapper">
+   
+       <!--
+       需求：获取所有学生及对应老师的信息
+       思路：
+           1. 获取所有学生的信息
+           2. 根据获取的学生信息的老师ID->获取该老师的信息
+           3. 思考问题，这样学生的结果集中应该包含老师，该如何处理呢，数据库中我们一般使用关联查询？
+               1. 做一个结果集映射：StudentTeacher
+               2. StudentTeacher结果集的类型为 Student
+               3. 学生中老师的属性为teacher，对应数据库中为tid。
+                  多个 [1,...）学生关联一个老师=> 一对一，一对多
+               4. 查看官网找到：association – 一个复杂类型的关联；使用它来处理关联查询
+       -->
+       <select id="getStudents" resultMap="StudentTeacher">
+       select * from student
+      </select>
+       <resultMap id="StudentTeacher" type="Student">
+           <!--association关联属性 property属性名 javaType属性类型 column在多的一方的表中的列名-->
+           <association property="teacher"  column="tid" javaType="Teacher" select="getTeacher"/>
+       </resultMap>
+       <!--
+       这里传递过来的id，只有一个属性的时候，下面可以写任何值
+       association中column多参数配置：
+           column="{key=value,key=value}"
+           其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名。
+       -->
+       <select id="getTeacher" resultType="teacher">
+         select * from teacher where id = #{id}
+      </select>
+   
+   </mapper>
+   ```
+
+3. 编写完毕去Mybatis配置文件中，注册Mapper!
+
+4. 注意点说明：
+
+   ```xml
+   <resultMap id="StudentTeacher" type="Student">
+      <!--association关联属性 property属性名 javaType属性类型 column在多的一方的表中的列名-->
+      <association property="teacher"  column="{id=tid,name=tid}" javaType="Teacher" select="getTeacher"/>
+   </resultMap>
+   <!--
+   这里传递过来的id，只有一个属性的时候，下面可以写任何值
+   association中column多参数配置：
+      column="{key=value,key=value}"
+      其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名。
+   -->
+   <select id="getTeacher" resultType="teacher">
+     select * from teacher where id = #{id} and name = #{name}
+   </select>
+   ```
+
+5. 测试
+
+   ```java
+   @Test
+   public void testGetStudents(){
+      SqlSession session = MybatisUtils.getSession();
+      StudentMapper mapper = session.getMapper(StudentMapper.class);
+   
+      List<Student> students = mapper.getStudents();
+   
+      for (Student student : students){
+          System.out.println(
+                  "学生名:"+ student.getName()
+                          +"\t老师:"+student.getTeacher().getName());
+     }
+   }
+   ```
+
+## 10.2、按照结果嵌套查询
+
+除了上面这种方式，还有其他思路吗？
+
+我们还可以按照结果进行嵌套处理；
+
+1. 接口方法编写
+
+   ```java
+   public List<Student> getStudents2();
+   ```
+
+2. 编写对应的mapper文件
+
+   ```xml
+       <!--
+       按查询结果嵌套处理
+       思路：
+       1. 直接查询出结果，进行结果集的映射
+       -->
+       <select id="getStudents2" resultMap="StudentTeacher2">
+           select s.id sid, s.name sname, t.name tname, t.id tid
+           from student s,
+                teacher t
+           where s.tid = t.id
+       </select>
+   
+       <resultMap id="StudentTeacher2" type="Student">
+           <!--
+           id是作为唯一标识的，当和其他对象实例对比的时候，
+           这个id很有用，尤其是应用到缓存和内嵌的结果映射。
+           result可以有多个，分别对应数据库中的各个字段和实体类中的属性。
+           -->
+           <id property="id" column="sid"/>
+           <result property="name" column="sname"/>
+           <!--关联对象property 关联对象在Student实体类中的属性-->
+           <association property="teacher" javaType="Teacher">
+               <id property="id" column="tid"/>
+               <result property="name" column="tname"/>
+           </association>
+       </resultMap>
+   ```
+
+3. 去mybatis-config文件中注入【此处应该处理过了】
+
+   ```xml
+       <!--绑定接口-->
+       <mappers>
+           <mapper resource="com/dao/TeacherMapper.xml"/>
+           <mapper resource="com/dao/StudentMapper.xml"/>
+       </mappers>
+   ```
+
+4. 测试
+
+   ```java
+       @Test
+       public void testGetStudents2() {
+           SqlSession sqlSession = MybatisUtils.getSqlSession();
+           StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
+   
+           List<Student> students = mapper.getStudents2();
+   
+           for (Student student : students) {
+               System.out.println(student);
+           }
+           sqlSession.close();
+       }
+   ```
+
+小结
+
+- 按照查询进行嵌套处理就像SQL中的子查询
+- 按照结果进行嵌套处理就像SQL中的联表查询
+
+回顾Mysql多对一查询方式：
+
+- 子查询
+- 联表查询
+
+# 11、一对多处理
+
+***
+
+比如：一个老师拥有多个学生！
+对于老师而言，就是一对多的关系！
+
+## 11.1、环境搭建
+
+1. 环境搭建，和刚才一样
+   **实体类：**
+
+   ```java
+   @Data
+   public class Student {
+       private int id;
+       private String name;
+       private int tid;
+   
+   }
+   ```
+
+   ```java
+   @Data
+   public class Teacher {
+       private int id;
+       private String name;
+   
+       // 一个老师拥有多个学生
+       private List<Student> students;
+   }
+   ```
+
+   ..... 和之前一样，搭建测试的环境！
+
+## 11.2、按照结果嵌套查询
+
+1. TeacherMapper接口编写方法
+
+   ```java
+   // 获取指定老师，及老师下的所有学生
+   Teacher getTeacher(@Param("tid") int id);
+   ```
+
+2. 编写接口对应的Mapper配置文件
+
+   ```xml
+       <!--
+       思路:
+       1. 从学生表和老师表中查出学生id，学生姓名，老师姓名
+       2. 对查询出来的操作做结果集映射
+           1. 集合的话，使用collection！
+               JavaType和ofType都是用来指定对象类型的
+               JavaType是用来指定entity中属性的类型
+               ofType-相当于泛型-指定的是映射到list集合属性中entity的类型。
+       -->
+       <select id="getTeacher" resultMap="TeacherStudent">
+           select s.id sid, s.name sname , t.name tname, t.id tid
+           from student s,teacher t
+           where s.tid = t.id and t.id=#{tid}
+       </select>
+   
+       <resultMap id="TeacherStudent" type="Teacher">
+           <id property="id" column="tid"/>
+           <result property="name" column="tname"/>
+           <collection property="students" ofType="Student">
+               <result property="id" column="sid" />
+               <result property="name" column="sname" />
+               <result property="tid" column="tid" />
+           </collection>
+       </resultMap>
+   ```
+
+3. 将Mapper文件注册到MyBatis-config文件中
+
+   ```xml
+       <!--绑定接口-->
+       <mappers>
+           <mapper resource="com/dao/TeacherMapper.xml"/>
+           <mapper resource="com/dao/StudentMapper.xml"/>
+       </mappers>
+   ```
+
+4. 测试
+
+   ```java
+       @Test
+       public void test() {
+           SqlSession sqlSession = MybatisUtils.getSqlSession();
+           TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
+           Teacher teacher = mapper.getTeacher(1);
+           List<Student> students = teacher.getStudents();
+           for (Student student : students) {
+               System.out.println(student);
+           }
+           sqlSession.close();
+       }
+   ```
+
+## 11.3、按照查询嵌套处理
+
+1. TeacherMapper接口编写方法
+
+   ```java
+   public Teacher getTeacher2(int id);
+   ```
+
+2. 编写接口对应的Mapper配置文件
+
+   ```xml
+       <select id="getTeacher2" resultMap="TeacherStudent2">
+           select * from teacher where id = #{tid}
+       </select>
+       <resultMap id="TeacherStudent2" type="Teacher">
+           <id property="id" column="id"/>
+           <result property="name" column="name"/>
+           <!--column是一对多的外键 , 写的是一的主键的列名-->
+           <collection property="students" ofType="Student" column="id" select="getStudentByTeacherId"/>
+       </resultMap>
+       <select id="getStudentByTeacherId" resultType="Student">
+           select * from student where tid = #{id}
+       </select>
+   ```
+
+3. 将Mapper文件注册到MyBatis-config文件中
+
+4. 测试
+
+   ```java
+       @Test
+       public void test() {
+           SqlSession sqlSession = MybatisUtils.getSqlSession();
+           TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
+           Teacher teacher = mapper.getTeacher2(1);
+           System.out.println(teacher);
+           sqlSession.close();
+       }
+   ```
+
+**小结**
+
+1. 关联-association
+2. 集合-collection
+3. 所以association是用于一对一和多对一，而collection是用于一对多的关系
+4. javaType和ofType都是用来指定对象类型的
+   - JavaType是用来指定entity中属性的类型
+   - ofType指定的是映射到list集合属性中entity的类型，泛型的约束类型
+
+**注意说明：**
+
+1. 保证SQL的可读性，尽量通俗易懂
+2. 根据实际要求，尽量编写性能更高的SQL语句
+3. 注意属性名和字段不一致的问题
+4. 注意一对多和多对一 中：字段和属性对应的问题
+5. 尽量使用Log4j，通过日志来查看自己的错误
+
+**面试高频：**
+
+* Mysql引擎
+* InnoDB底层原理
+* 索引
+* 索引优化
+
+# 12、动态SQL
+
+***
+
+什么是动态SQL：动态SQL指的是根据不同的查询条件 , 生成不同的Sql语句.
+
+```java
+官网描述：
+MyBatis 的强大特性之一便是它的动态 SQL。如果你有使用 JDBC 或其它类似框架的经验，你就能体会到根据不同条件拼接 SQL 语句的痛苦。例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL 这一特性可以彻底摆脱这种痛苦。
+虽然在以前使用动态 SQL 并非一件易事，但正是 MyBatis 提供了可以被用在任意 SQL 映射语句中的强大的动态 SQL 语言得以改进这种情形。
+动态 SQL 元素和 JSTL 或基于类似 XML 的文本处理器相似。在 MyBatis 之前的版本中，有很多元素需要花时间了解。MyBatis 3 大大精简了元素种类，现在只需学习原来一半的元素便可。MyBatis 采用功能强大的基于 OGNL 的表达式来淘汰其它大部分元素。
+
+  -------------------------------
+  - if
+  - choose (when, otherwise)
+  - trim (where, set)
+  - foreach
+  -------------------------------
+```
+
+我们之前写的 SQL 语句都比较简单，如果有比较复杂的业务，我们需要写复杂的 SQL 语句，往往需要拼接，而拼接 SQL ，稍微不注意，由于引号，空格等缺失可能都会导致错误。
+
+那么怎么去解决这个问题呢？这就要使用 mybatis 动态SQL，通过 `if, choose, when, otherwise, trim, where, set, foreach`等标签，可组合成非常灵活的SQL语句，从而在提高 SQL 语句的准确性的同时，也大大提高了开发人员的效率。
+
+## 12.1、搭建环境
+
+```sql
+CREATE TABLE `blog` (
+`id` varchar(50) NOT NULL COMMENT '博客id',
+`title` varchar(100) NOT NULL COMMENT '博客标题',
+`author` varchar(30) NOT NULL COMMENT '博客作者',
+`create_time` datetime NOT NULL COMMENT '创建时间',
+`views` int(30) NOT NULL COMMENT '浏览量'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8
+```
+
+1. 创建mybatis基础工程
+2. IDUtils工具类
+3. 实体类编写
+
+```java
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class Blog {
+    private String id;
+    private String title;
+    private String author;
+    private Date createTime;
+    private int views;
+}
+```
+
+4. mapper接口和xml文件
+
+```java
+public interface BlogMapper {
+    // 插入数据
+    int addBlog(Blog blog);
+}
+
+    <insert id="addBlog" parameterType="Blog">
+        insert into blog (id, title, author, create_time, views)
+        values (#{id},#{title},#{author},#{createTime},#{views});
+    </insert>
+```
+5. mybatis核心配置文件，下环线自动转换
+
+```xml
+    <settings>
+        <setting name="mapUnderscoreToCamelCase" value="true"/>
+    </settings>
+
+    <typeAliases>
+        <typeAlias type="com.entity.Blog" alias="Blog"/>
+    </typeAliases>
+
+```
+6. 插入数据
+
+```java
+    @Test
+    public void addInitBlog(){
+        SqlSession sqlSession = MybatisUtils.getSqlSession();
+        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
+
+        Blog blog = new Blog();
+        blog.setId(IDUtils.genId());
+        blog.setTitle("Mybatis如此简单");
+        blog.setAuthor("狂神说");
+        blog.setCreateTime(new Date());
+        blog.setViews(9999);
+
+        mapper.addBlog(blog);
+
+        blog.setId(IDUtils.genId());
+        blog.setTitle("Java如此简单");
+        mapper.addBlog(blog);
+
+        blog.setId(IDUtils.genId());
+        blog.setTitle("Spring如此简单");
+        mapper.addBlog(blog);
+
+        blog.setId(IDUtils.genId());
+        blog.setTitle("微服务如此简单");
+        mapper.addBlog(blog);
+
+        sqlSession.close();
+    }
+```
+
+## 12.2、关键字
+
+### if
+
+需求：根据作者名字和博客名字来查询博客！如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询
+
+1. 编写接口类
+
+   ```java
+   // 需求1
+   List<Blog> queryBlogIf(Map map);
+   ```
+
+2. 编写SQL语句
+
+   ```xml
+   <!--需求1：
+   根据作者名字和博客名字来查询博客！
+   如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询
+   -->
+   <select id="queryBlogIf" parameterType="map" resultType="blog">
+     select * from blog where 1=1
+      <if test="title != null">
+         and title = #{title}
+      </if>
+      <if test="author != null">
+         and author = #{author}
+      </if>
+   </select>
+   ```
+
+3. 测试
+
+   ```java
+   @Test
+   public void testQueryBlogIf(){
+      SqlSession session = MybatisUtils.getSession();
+      BlogMapper mapper = session.getMapper(BlogMapper.class);
+   
+      HashMap<String, String> map = new HashMap<String, String>();
+      map.put("title","Mybatis如此简单");
+      map.put("author","狂神说");
+      List<Blog> blogs = mapper.queryBlogIf(map);
+   
+      System.out.println(blogs);
+   
+      session.close();
+   }
+   ```
+
+### where
+
+修改上面的SQL语句；
+
+```xml
+<select id="queryBlogIf" parameterType="map" resultType="blog">
+  select * from blog
+   <where>
+       <if test="title != null">
+          title = #{title}
+       </if>
+       <if test="author != null">
+          and author = #{author}
+       </if>
+   </where>
+</select>
+```
+
+这个“where”标签会知道如果它包含的标签中有返回值的话，它就插入一个‘where’。此外，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉。
+
+### choose
+
+有时候，我们不想用到所有的查询条件，只想选择其中的一个，查询条件有一个满足即可，使用 choose 标签可以解决此类问题，类似于 Java 的 switch 语句
+
+```xml
+<select id="queryBlogChoose" parameterType="map" resultType="blog">
+  select * from blog
+   <where>
+       <choose>
+           <when test="title != null">
+                title = #{title}
+           </when>
+           <when test="author != null">
+              and author = #{author}
+           </when>
+           <otherwise>
+              and views = #{views}
+           </otherwise>
+       </choose>
+   </where>
+</select>
+```
+
+MyBatis 提供了 choose 元素。if标签是与(and)的关系，而 choose 是或(or)的关系。
+
+choose标签是按顺序判断其内部when标签中的test条件出否成立，如果有一个成立，则 choose 结束。当 choose 中所有 when 的条件都不满则时，则执行 otherwise 中的sql。类似于Java 的 switch 语句，choose 为 switch，when 为 case，otherwise 则为 default。
+
+### set
+
+同理，上面的对于查询 SQL 语句包含 where 关键字，如果在进行更新操作的时候，含有 set 关键词，我们怎么处理呢？
+
+```xml
+<!--注意set是用的逗号隔开-->
+<update id="updateBlog" parameterType="map">
+  update blog
+     <set>
+         <if test="title != null">
+            title = #{title},
+         </if>
+         <if test="author != null">
+            author = #{author}
+         </if>
+     </set>
+  where id = #{id};
+</update>
+```
+
+### trim
+
+```xml
+    <insert id="addBlog" parameterType="Blog">
+        insert into blog
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="id != null">
+                id,
+            </if>
+            <if test="title != null">
+                title,
+            </if>
+            <if test="author != null">
+                author,
+            </if>
+            <if test="createTime != null">
+                create_time,
+            </if>
+            <if test="views != 0">
+                views
+            </if>
+        </trim>
+        values
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+        <if test="id != null">
+            #{id},
+        </if>
+        <if test="title != null">
+            #{title},
+        </if>
+        <if test="author != null">
+            #{author},
+        </if>
+        <if test="createTime != null">
+            #{createTime},
+        </if>
+        <if test="views != 0">
+            #{views}
+        </if>
+        </trim>;
+    </insert>
+
+```
+
+> `所谓的动态SQL，本质还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码`
+
+### SQL片段
+
+有时候可能某个 sql 语句我们用的特别多，为了增加代码的重用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用。
+
+提取SQL片段：
+
+```xml
+<sql id="if-title-author">
+   <if test="title != null">
+      title = #{title}
+   </if>
+   <if test="author != null">
+      and author = #{author}
+   </if>
+</sql>
+```
+
+引用SQL片段：
+
+```xml
+<select id="queryBlogIf" parameterType="map" resultType="blog">
+  select * from blog
+   <where>
+       <!-- 引用 sql 片段，如果refid 指定的不在本文件中，那么需要在前面加上 namespace -->
+       <include refid="if-title-author"></include>
+       <!-- 在这里还可以引用其他的 sql 片段 -->
+   </where>
+</select>
+```
+
+注意：
+
+1. 最好基于 单表来定义 sql 片段，提高片段的可重用性
+2. 在 sql 片段中不要包括 where
+
+### ForEach
+
+- 动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）。
+- foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符，看它多智能！
+- 提示你可以将任何可迭代对象（如 List、Set 等）、Map 对象或者数组对象作为集合参数传递给  foreach。当使用可迭代对象或者数组时，index 是当前迭代的序号，item 的值是本次迭代获取到的元素。当使用 Map 对象（或者  Map.Entry 对象的集合）时，index 是键，item 是值。
+
+> 将数据库中前三个数据的id修改为1,2,3；
+>
+> 需求：我们需要查询 blog 表中 id 分别为1,2,3的博客信息
+
+1. 编写接口
+
+   ```java
+   List<Blog> queryBlogForeach(Map map);
+   ```
+
+2. 编写SQL语句
+
+   ```xml
+   <select id="queryBlogForeach" parameterType="map" resultType="blog">
+     select * from blog
+      <where>
+          <!--
+          collection:指定输入对象中的集合属性
+          item:每次遍历生成的对象
+          open:开始遍历时的拼接字符串
+          close:结束时拼接的字符串
+          separator:遍历对象之间需要拼接的字符串
+          select * from blog where 1=1 and (id=1 or id=2 or id=3)
+        -->
+          <foreach collection="ids"  item="id" open="(" close=")" separator="or">
+             id=#{id}
+          </foreach>
+      </where>
+   </select>
+   ```
+
+3. 测试
+
+   ```java
+   @Test
+   public void testQueryBlogForeach(){
+       SqlSession sqlSession = MybatisUtils.getSqlSession();
+       BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
+       HashMap map = new HashMap();
+       List<Integer> ids = new ArrayList<Integer>();
+       ids.add(1);
+       ids.add(2);
+       ids.add(3);
+       map.put("ids",ids);
+       List<Blog> blogs = mapper.queryBlogForeach(map);
+       for (Blog blog : blogs) {
+           System.out.println(blog);
+       }
+   
+       sqlSession.close();
+   }
+   ```
+
+### 小结
+
+其实动态 sql 语句的编写往往就是一个拼接的问题，为了保证拼接准确，我们最好首先要写原生的 sql 语句出来，然后在通过 mybatis 动态sql 对照着改，防止出错。多在实践中使用才是熟练掌握它的技巧。
+

大数据/K8S/2.构建K8S-kubeadm方式.md

@@ -31,7 +31,7 @@ systemctl daemon-reload && systemctl restart docker
 #
 # 安装指定版本的Docker-CE:
 # Step 1: 查找Docker-CE的版本:
-# yum list docker-ce.x86_64 --showduplicates | sort -r
+yum list docker-ce.x86_64 --showduplicates | sort -r
 #   Loading mirror speeds from cached hostfile
 #   Loaded plugins: branch, fastestmirror, langpacks
 #   docker-ce.x86_64            17.03.1.ce-1.el7.centos            docker-ce-stable
@@ -39,7 +39,7 @@ systemctl daemon-reload && systemctl restart docker
 #   docker-ce.x86_64            17.03.0.ce-1.el7.centos            docker-ce-stable
 #   Available Packages
 # Step2: 安装指定版本的Docker-CE: (VERSION例如上面的17.03.0.ce.1-1.el7.centos)
-# sudo yum -y install docker-ce-[VERSION]
+sudo yum -y install docker-ce-[VERSION]
 ```
 
 # 2、配置环境，安装kubectl

大数据/docker/2.centos7安装docker.md

@@ -1,6 +1,6 @@
-# 1.下载docker镜像
+# 1、下载docker镜像
 
-```
+```shell
 $ wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo
 官方软件源默认启用了最新的软件，您可以通过编辑软件源的方式获取各个版本的软件包。例如官方并没有将测试版本的软件源置为可用，你可以通过以下方式开启。同理可以开启各种测试版本等。
 $ yum -y install docker-ce-18.06.1.ce-3.el7
@@ -9,12 +9,12 @@ $ docker --version
 Docker version 18.06.1-ce, build e68fc7a
 ```
 
-# 2.docker配置镜像加速
+# 2、docker配置镜像加速
 
 
 阿里云镜像获取地址：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors
 
-```
+```shell
 sudo mkdir -p /etc/docker
 sudo tee /etc/docker/daemon.json <<-'EOF'
 {
@@ -24,14 +24,28 @@ EOF
 systemctl daemon-reload && systemctl restart docker
 ```
 
-# 3.docker权限问题
+# 3、docker权限问题
 
 在用户权限下docker 命令需要 sudo 否则出现以下问题
 ![image-20211001121557280](../../照片/image-20211001121557280.png)
 
 通过将用户添加到docker用户组可以将sudo去掉，命令如下
-```
+```shell
 sudo groupadd docker #添加docker用户组
 sudo gpasswd -a $USER docker #将登陆用户加入到docker用户组中
 newgrp docker #更新用户组
 ```
+
+# 4、卸载docker
+
+~~~shell
+# 1.停止docker
+sudo systemctl stop docker
+# 2.查询安装过的包
+yum list installed | grep docker
+# 3.删除安装的软件包
+yum -y remove docker-engine.x86_64
+# 4.删除镜像/容器等
+rm -rf /var/lib/docker
+~~~
+

大数据/云平台安装文档/安装云平台环境.md

@@ -25,7 +25,7 @@
 
 ## 1.2安装前的准备工作
 
-```
+```shell
 # 关闭防火墙
 systemctl stop firewalld && systemctl disable firewalld
 
@@ -72,7 +72,7 @@ clock -w
 ```
 
 上述操作执行完毕后重启
-```
+```shell
 reboot
 ```
 三台服务器，开始下一步的安装
@@ -82,7 +82,7 @@ reboot
 
 ## 2.1离线安装Docker
 
-```
+```shell
 # 1.创建目录存放相应的安装包
 mkdir -p /opt/package/docker
 
@@ -107,7 +107,7 @@ docker --version
 ## 2.2离线安装Docker-compose
 
 将安装包目录下的docker-compose-linux-x86_64文件上传到服务机的```/opt/package```目录下使用命令
-```
+```shell
 // 1.将下载好的文件传入linux系统中，并重命名未docker-compose
 mv docker-compose-linux-x86_64 docker-compose
 // 2.给予docker-compose文件可执行权限
@@ -129,18 +129,18 @@ docker-compose --version
 ## 3.1安装Harbor
 
 1. 将压缩包harbor-offline-installer-v2.1.5.tgz上传到
-```
+```shell
 /opt/package/
 ```
 目录下
 2. 解压该压缩包
-```
+```shell
 tar xf harbor-offline-installer-v2.1.5.tgz
 ```
 3. 修改harbor安装的配置文件
 
 首先备份一份压缩包
-```
+```shell
 # 复制配置文件内容到harbor.yml 中（安装时只识别harbor.yml）
 cp harbor.yml.tmpl  harbor.yml         
 # 用于存放harbor的持久化数据
@@ -246,18 +246,21 @@ scp -r kube1.9.0.tar.gz root@192.168.238.22:/opt/package/k8s
 
 ```shell
 # 1.master下，进入/opt/package/k8s目录下解压，执行脚本
-tar -zxvf kube1.9.0.tar.gz
+tar -zxvf kube1.19.0.tar.gz
 cd kube/shell 
-init.sh
+chmod +x init.sh
+./init.sh
 
 # 2.等待init.sh执行完毕,之后执行
-master.sh
+chmod +x master.sh
+./master.sh
 
 # 3. node1和node2执行下面的命令
 cd /opt/package/k8s
 tar -zxvf kube1.9.0.tar.gz
 cd kube/shell 
-init.sh
+chmod +x init.sh
+./init.sh
 
 # 4. 进入master节点将/etc/kubernetes/admin.conf文件复制到node1节点和node2节点
 scp -r /etc/kubernetes/admin.conf node1:/etc/kubernetes/
@@ -381,7 +384,7 @@ kubectl get nodes
    # 进入/opt/package/nfs
    cd /opt/package/nfs
    # 安装nfs
-   rpm -ivh nfs-utils-1.3.0-0.68.el7.2.x86_64.rpm
+   rpm -ivh *.rpm  --force --nodeps # 注意如果不能安装选择  nfs.zip文件
    # 执行命令 vi /etc/exports，创建 exports 文件，文件内容如下：
    echo "/nfs/data/ *(insecure,rw,sync,no_root_squash)" > /etc/exports
    # 执行以下命令，启动 nfs 服务
@@ -401,7 +404,7 @@ kubectl get nodes
 ```shell
 # 进入node1,node2节点内/opt/package/nfs文件夹内执行以下命令
 cd /opt/package/nfs
-rpm -ivh nfs-utils-1.3.0-0.68.el7.2.x86_64.rpm
+rpm -ivh *.rpm  --force --nodeps # 注意如果不能安装选择  nfs.zip文件
 systemctl start nfs && systemctl enable nfs
 ```
 
@@ -482,7 +485,7 @@ managed-nfs-storage (default)   fuseim.pri/ifs   Delete          Immediate
 ## 5.1将离线包上传至harbor仓库（该操作只需在master节点进行）
 
 将安装包目录下的kubesphere文件夹上传至服务机master节点的
-```
+```shell
 /opt/package/
 ```
 目录下
@@ -550,7 +553,7 @@ kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=
 2. KubeSphere DevOps
 3. KubeSphere kubeedge
 
-```
+```shell
 # 1.编辑cluster-configuration.yaml
 vim cluster-configuration.yaml