增加了spring的学习文档

后端/spring/spring.md

@@ -39,7 +39,7 @@ GitHub：https://github.com/spring-projects/spring-framework
         </dependency>
 ```
 
-## 1.2 优点
+## 1.2、 优点
 
 - Spring是一个开源的免费的框架（容器）！
 - Spring是一个轻量级的、非入侵式的框架！
@@ -52,7 +52,7 @@ GitHub：https://github.com/spring-projects/spring-framework
 
 ![image-20220319142033626](assets/image-20220319142033626.png)
 
-## 1.4 拓展
+## 1.4 、拓展
 
 现代化的Java开发！说白了就是基于Spring的开发！
 
@@ -291,14 +291,14 @@ IOC是一种编程思想，由主动的编程变成被动的接收。
 
 ***
 
-## 5.1 别名
+## 5.1 、别名
 
 ```xml
     <!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
     <alias name="user" alias="userNew"/>
 ```
 
-## 5.2 Bean配置
+## 5.2 、Bean配置
 
 ```xml
     <!--
@@ -312,7 +312,7 @@ IOC是一种编程思想，由主动的编程变成被动的接收。
     </bean>
 ```
 
-## 5.3 import
+## 5.3、 import
 
 这个import。一般用于团队开发使用，它可以将多个配置文件，导入合并为一个。
 假设，现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！
@@ -919,3 +919,1101 @@ public class MyTest {
 
 这种纯Java的配置方式，在SpringBoot中随处可见！
 
+# 10、代理模式 
+
+***
+
+为什么要学习代理模式？因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】
+
+代理模式的分类：
+
+- 静态代理
+- 动态代理
+
+![image-20220320202519970](assets/image-20220320202519970.png)
+
+## 10.1、静态代理
+
+角色分析：
+
+- 抽象角色：一般会使用接口或者抽象类来解决
+- 真实角色：被代理的角色
+- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
+- 客户：访问代理对象的人！
+
+代码步骤：
+
+1. 接口
+
+```java
+//租房
+public interface Rent {
+    public void rent();
+}
+```
+
+2. 真实角色
+
+```java
+//房东
+public class Host implements Rent{
+    public void rent() {
+        System.out.println("房东出租房子！");
+    }
+}
+```
+
+3. 代理角色
+
+```java
+public class Proxy implements Rent{
+    private Host host;
+
+    public Proxy() {
+    }
+
+    public Proxy(Host host) {
+        this.host = host;
+    }
+
+    public void rent() {
+        host.rent();
+        seeHouse();
+        sign();
+        fee();
+    }
+
+    //看房
+    public void seeHouse(){
+        System.out.println("中介带着看房子！");
+    }
+
+    //签合同
+    public void sign(){
+        System.out.println("和中介签署租赁合同！");
+    }
+
+    //收费用
+    public void fee(){
+        System.out.println("中介收取费用！");
+    }
+}
+```
+
+4. 客户端访问代理角色
+
+```java
+public class Client {
+    public static void main(String[] args) {
+        //房东要出租房子
+        Host host = new Host();
+//        host.rent();
+
+        //代理，中介帮房东出租房子，并且代理角色一般会有一些附属操作！
+        Proxy proxy = new Proxy(host);
+
+        //不用面对房东，直接找中介租房即可！
+        proxy.rent();
+    }
+}
+```
+
+代理模式的好处：
+
+- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
+- 公共角色就交给代理角色！实现了业务的分工！
+- 公共业务发生扩展的时候，方便集中管理！
+
+缺点：
+
+- 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低~
+
+## 10.2、加深代理的理解
+
+代码步骤：
+
+1. 接口
+
+   ```java
+   public interface UserService {
+       public void add();
+       public void delete();
+       public void update();
+       public void query();
+   }
+   ```
+
+2. 真实角色
+
+   ```java
+   //真实角色
+   public class UserServiceImpl implements UserService{
+       public void add() {
+           System.out.println("增加了一个用户！");
+       }
+   
+       public void delete() {
+           System.out.println("删除了一个用户！");
+       }
+   
+       public void update() {
+           System.out.println("修改了一个用户！");
+       }
+   
+       public void query() {
+           System.out.println("查询了一个用户！");
+       }
+   }
+   ```
+
+3. 代理角色
+
+   ```java
+   public class UserServiceProxy implements UserService{
+       private UserServiceImpl userService;
+   
+       public void setUserService(UserServiceImpl userService) {
+           this.userService = userService;
+       }
+   
+       public void add() {
+           log("add");
+           userService.add();
+       }
+   
+       public void delete() {
+           log("delete");
+           userService.delete();
+       }
+   
+       public void update() {
+           log("update");
+           userService.update();
+       }
+   
+       public void query() {
+           log("query");
+           userService.query();
+       }
+   
+       public void log(String msg){
+           System.out.println("[Debug] 使用了一个"+msg+"方法");
+       }
+   }
+   ```
+
+4. 客户端访问代理角色
+
+   ```java
+   public class Client {
+       public static void main(String[] args) {
+           UserServiceImpl userService = new UserServiceImpl();
+   
+           UserServiceProxy proxy = new UserServiceProxy();
+           proxy.setUserService(userService);
+   
+           proxy.delete();
+       }
+   }
+   ```
+
+聊聊AOP
+
+![image-20220320205008091](assets/image-20220320205008091.png)
+
+## 10.3、动态代理
+
+- 动态代理和静态代理角色一样
+- 动态代理的代理类是动态生成的，不是我们直接写好的！
+- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
+  - 基于接口 — JDK动态代理【我们在这里使用】
+  - 基于类：cglib
+  - java字节码实现：javassist
+
+需要了解两个类：Proxy：代理；InvocationHandler：调用处理程序。
+
+代码步骤：
+
+1. 接口
+
+   ```java
+   public interface Rent {
+       public void rent();
+   }
+   ```
+
+2. 真实角色
+
+   ```java
+   public class Host implements Rent{
+       public void rent() {
+           System.out.println("房东要出租房子！");
+       }
+   }
+   ```
+
+3. ProxyInvocationHandler类
+
+   ```java
+   //我们会用这个类，自动生成代理类！
+   public class ProxyInvocationHandler implements InvocationHandler {
+       //被代理的接口
+       private Rent rent;
+   
+       public void setRent(Rent rent) {
+           this.rent = rent;
+       }
+   
+       //生成得到代理类
+       public Object getProxy(){
+           return Proxy.newProxyInstance(this.getClass().getClassLoader(),
+                   rent.getClass().getInterfaces(),this);
+       }
+   
+       //处理代理实例，并返回结果
+       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+           //动态代理的本质，就是使用反射机制实现！
+           Object result = method.invoke(rent, args);
+           seeHose();
+           fee();
+           return result;
+       }
+   
+       public void seeHose(){
+           System.out.println("中介带着看房子！");
+       }
+   
+       public void fee(){
+           System.out.println("中介收取费用！");
+       }
+   }
+   ```
+
+4. 测试
+
+   ```java
+   public class Client {
+       public static void main(String[] args) {
+           //真实角色
+           Host host = new Host();
+   
+           //代理角色：现在没有
+           ProxyInvocationHandler pih = new ProxyInvocationHandler();
+   
+           //通过调用程序处理角色来处理我们要调用的接口对象！
+           pih.setRent(host);
+           Rent proxy = (Rent) pih.getProxy(); //这里的proxy就是动态生成的，我们并没有写
+           proxy.rent();
+   
+       }
+   }
+   ```
+
+在此，我们可以提炼出ProxyInvocationHandler作为工具类
+
+```java
+//用这个类自动生成代理类！
+public class ProxyInvocationHandler implements InvocationHandler {
+
+    //被代理的接口
+    private Object target;
+
+    public void setTarget(Object target) {
+        this.target = target;
+    }
+
+    //生成得到代理类
+    public Object getProxy(){
+        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
+                target.getClass().getInterfaces(),this);
+    }
+
+    //处理代理实例，并返回结果
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        log(method.getName());
+        Object result = method.invoke(target, args);
+        return result;
+    }
+
+    public void log(String msg){
+        System.out.println("[Debug] 使用了一个"+msg+"方法");
+    }
+}
+```
+
+动态代理的好处：
+
+- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
+- 公共角色就交给代理角色！实现了业务的分工！
+- 公共业务发生扩展的时候，方便集中管理！
+- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
+- 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！
+
+# 11、AOP
+
+***
+
+## 11.1、什么是AOP
+
+AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
+
+![image-20220326151637541](assets/image-20220326151637541.png)
+
+## 11.2、AOP在spring中的作用
+
+提供声明式事务；允许用户自定义切面
+
+- 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
+- 切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
+- 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
+- 目标（Target）：被通知对象。
+- 代理（Proxy）：向目标对象应用通知之后创建的对象。
+- 切入点（PointCut）：切面通知执行的“地点”的定义。
+- 连接点（JointPoint）：与切入点匹配的执行点。
+
+ ![image-20220326153800124](assets/image-20220326153800124.png)
+
+SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：
+
+![image-20220326153843054](assets/image-20220326153843054.png)
+
+## 11.3、使用spring实现AOP
+
+【重点】使用AOP织入，需要导入一个依赖包！
+
+```xml
+<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
+<dependency>
+    <groupId>org.aspectj</groupId>
+    <artifactId>aspectjweaver</artifactId>
+    <version>1.9.4</version>
+</dependency>
+```
+
+**方式一：** 使用Spring的API接口【主要是SpringAPI接口实现】
+
+1. 在service包下，定义UserService业务接口和UserServiceImpl实现类
+
+```java
+public interface UserService {
+    public void add();
+    public void delete();
+    public void update();
+    public void select();
+}
+public class UserServiceImpl implements UserService {
+    public void add() {
+        System.out.println("增加了一个用户！");
+    }
+
+    public void delete() {
+        System.out.println("删除了一个用户！");
+    }
+
+    public void update() {
+        System.out.println("更新了一个用户！");
+    }
+
+    public void select() {
+        System.out.println("查询了一个用户！");
+    }
+}
+```
+
+2. 在log包下，定义我们的增强类，一个Log前置增强和一个AfterLog后置增强类
+
+```java
+public class Log implements MethodBeforeAdvice {
+
+    //method: 要执行的目标对象的方法
+    //args：参数
+    //target：目标对象
+    public void before(Method method, Object[] agrs, Object target) throws Throwable {
+        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
+    }
+}
+public class AfterLog implements AfterReturningAdvice {
+
+    //returnValue： 返回值
+    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
+        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
+    }
+}
+```
+
+3. 最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束，配置applicationContext.xml文件
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:aop="http://www.springframework.org/schema/aop"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans
+        https://www.springframework.org/schema/beans/spring-beans.xsd
+        http://www.springframework.org/schema/aop
+        https://www.springframework.org/schema/aop/spring-aop.xsd">
+
+    <!--注册bean-->
+    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
+    <bean id="log" class="com.kuang.log.Log"/>
+    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
+
+    <!--方式一：使用原生Spring API接口-->
+    <!--配置aop:需要导入aop的约束-->
+    <aop:config>
+        <!--切入点：expression：表达式，execution(要执行的位置！* * * * *)-->
+        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
+
+        <!--执行环绕增加！-->
+        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
+        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
+    </aop:config>
+
+</beans>
+```
+
+4. 测试
+
+```java
+public class MyTest {
+    public static void main(String[] args) {
+        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
+
+        //动态代理代理的是接口：注意点
+        UserService userService = (UserService) context.getBean("userService");
+
+        userService.add();
+//        userService.select();
+    }
+}
+```
+
+**方式二：** 自定义类来实现AOP【主要是切面定义】
+
+1. 在diy包下定义自己的DiyPointCut切入类
+
+```java
+public class DiyPointCut {
+    public void before(){
+        System.out.println("======方法执行前======");
+    }
+
+    public void after(){
+        System.out.println("======方法执行后======");
+    }
+}
+```
+
+2. 去spring中配置文件
+
+```xml
+    <!--方式二：自定义类-->
+    <bean id="diy" class="com.kuang.diy.DiyPointCut"/>
+
+    <aop:config>
+        <!--自定义切面，ref 要引用的类-->
+        <aop:aspect ref="diy">
+            <!--切入点-->
+            <aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
+            <!--通知-->
+            <aop:before method="before" pointcut-ref="point"/>
+            <aop:after method="after" pointcut-ref="point"/>
+        </aop:aspect>
+    </aop:config>
+```
+
+3. 测试
+
+**方式三：** 使用注解实现！
+
+1. 在diy包下定义注解实现的AnnotationPointCut增强类
+
+```java
+//声明式事务！
+@Aspect //标注这个类是一个切面
+public class AnnotationPointCut {
+
+    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
+    public void before(){
+        System.out.println("====方法执行前====");
+    }
+
+    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
+    public void after(){
+        System.out.println("====方法执行后====");
+    }
+
+    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点；
+    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
+    public void around(ProceedingJoinPoint jp) throws Throwable{
+        System.out.println("环绕前");
+
+        Signature signature = jp.getSignature();// 获得签名
+        System.out.println("signature:"+signature);
+
+        Object proceed = jp.proceed(); //执行方法
+
+        System.out.println("环绕后");
+
+        System.out.println(proceed);
+    }
+
+}
+```
+
+2. 在Spring配置文件中，注册bean，并增加支持注解的配置。
+
+```xml
+    <!--方式三：使用注解-->
+    <bean id="annotationPointCut" class="com.kuang.diy.AnnotationPointCut"/>
+    <!--开启注解支持！ JDK(默认是 proxy-target-class="false")  cglib（proxy-target-class="true"）-->
+    <aop:aspectj-autoproxy/>
+```
+
+3. 测试
+
+# 12、整合Mybatis
+
+***
+
+步骤：
+
+1. 导入相关jar包
+   - junit
+   - mybatis
+   - mysql数据库
+   - spring相关
+   - aop织入器
+   - mybatis-spring整合包【重点】在此还导入了lombok包。
+   - 配置Maven静态资源过滤问题！
+
+```xml
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+        </dependency>
+        <dependency>
+            <groupId>org.mybatis</groupId>
+            <artifactId>mybatis</artifactId>
+            <version>3.5.6</version>
+        </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>5.1.47</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webmvc</artifactId>
+            <version>5.2.0.RELEASE</version>
+        </dependency>
+        <!--Spring操作数据库的话，还需要一个spring-jdbc
+               -->
+        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-jdbc</artifactId>
+            <version>5.2.0.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjweaver</artifactId>
+            <version>1.8.13</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
+        <dependency>
+            <groupId>org.mybatis</groupId>
+            <artifactId>mybatis-spring</artifactId>
+            <version>2.0.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.10</version>
+        </dependency>
+    </dependencies>
+
+     <build>
+        <resources>
+            <resource>
+                <directory>src/main/java</directory>
+                <includes>
+                    <include>**/*.properties</include>
+                    <include>**/*.xml</include>
+                </includes>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+    </build>
+```
+
+2. 编写配置文件
+
+3. 测试
+
+## 12.1、回忆Mybatis
+
+1. 编写pojo实体类
+
+   ```java
+   @Data
+   public class User {
+       private int id;
+       private String name;
+       private String pwd;
+   }
+   ```
+
+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>
+   
+      <typeAliases>
+          <package name="com.kuang.pojo"/>
+      </typeAliases>
+   
+      <environments default="development">
+          <environment id="development">
+              <transactionManager type="JDBC"/>
+              <dataSource type="POOLED">
+                  <property name="driver" value="com.mysql.jdbc.Driver"/>
+                  <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8"/>
+                  <property name="username" value="root"/>
+                  <property name="password" value="123456"/>
+              </dataSource>
+          </environment>
+      </environments>
+   
+      <mappers>
+          <package name="com.kuang.dao"/>
+      </mappers>
+   </configuration>
+   ```
+
+3. 编写UserMapper接口
+
+   ```java
+   public interface UserMapper {
+       public List<User> selectUser();
+   }
+   ```
+
+4. 编写UserMapper.xml文件
+
+   ```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.mapper.UserMapper">
+   
+       <!--sql-->
+       <select id="selectUser" resultType="user">
+           select * from mybatis.user
+       </select>
+   </mapper>
+   ```
+
+5. 测试
+
+   ```java
+   @Test
+   public void selectUser() throws IOException {
+   
+      String resource = "mybatis-config.xml";
+      InputStream inputStream = Resources.getResourceAsStream(resource);
+      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
+      SqlSession sqlSession = sqlSessionFactory.openSession();
+   
+      UserMapper mapper = sqlSession.getMapper(UserMapper.class);
+   
+      List<User> userList = mapper.selectUser();
+      for (User user: userList){
+          System.out.println(user);
+     }
+   
+      sqlSession.close();
+   }
+   ```
+
+## 12.2、Mybatis-Spring
+
+什么是MyBatis-Spring？
+
+MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。
+
+文档链接：http://mybatis.org/spring/zh/index.html
+
+如果使用 Maven 作为构建工具，仅需要在 pom.xml 中加入以下代码即可：
+
+```xml
+        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
+        <dependency>
+            <groupId>org.mybatis</groupId>
+            <artifactId>mybatis-spring</artifactId>
+            <version>2.0.2</version>
+        </dependency>
+```
+
+**整合实现一：**
+
+1. 引入Spring配置文件spring-dao.xml
+
+```xml
+<?xml version="1.0" encoding="GBK"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans
+        https://www.springframework.org/schema/beans/spring-beans.xsd">
+
+    
+
+ </beans>
+```
+
+2. 配置数据源替换mybaits的数据源
+
+```xml
+    <!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid
+    我们这里使用Spring提供的JDBC：-->
+    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
+        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
+        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
+        <property name="username" value="root"/>
+        <property name="password" value="123456"/>
+    </bean>
+```
+
+3. 配置SqlSessionFactory，关联MyBatis
+
+```xml
+    <!--sqlSessionFactory-->
+    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
+        <property name="dataSource" ref="dataSource" />
+        <!--关联mybatis配置文件-->
+        <property name="configLocation" value="classpath:mybatis-config.xml"/>
+        <property name="mapperLocations" value="classpath:com/kuang/mapper/*.xml"/>
+    </bean>
+```
+
+4. 注册sqlSessionTemplate，关联sqlSessionFactory
+
+```xml
+    <!--SqlSessionTemplate:就是我们使用的sqlSession-->
+    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
+        <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
+        <constructor-arg index="0" ref="sqlSessionFactory" />
+    </bean>
+```
+
+5. 需要UserMapper接口的UserMapperImpl 实现类，私有化sqlSessionTemplate
+
+```java
+public class UserMapperImpl implements UserMapper {
+
+    //我们的所有操作，都使用sqlSession来执行，在原来，现在都使用SqlsessionTemplate
+    private SqlSessionTemplate sqlSession;
+
+    public void setSqlSession(SqlSessionTemplate sqlSession) {
+        this.sqlSession = sqlSession;
+    }
+
+    public List<User> selectUser() {
+        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
+        return mapper.selectUser();
+    }
+}
+```
+
+6. 将自己写的实现类，注入到Spring配置文件中。
+
+```xml
+    <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
+        <property name="sqlSession" ref="sqlSession"/>
+    </bean>
+```
+
+7. 测试使用即可！
+
+```java
+    @Test
+    public void test () throws IOException {
+
+        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
+        
+        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
+        for (User user : userMapper.selectUser()) {
+            System.out.println(user);
+        }
+    }
+```
+
+结果成功输出！现在我们的Mybatis配置文件的状态！发现都可以被Spring整合！
+
+```xml
+结果成功输出！现在我们的Mybatis配置文件的状态！发现都可以被Spring整合！
+
+<?xml version="1.0" encoding="GBK" ?>
+<!DOCTYPE configuration
+        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-config.dtd">
+<!--configuration core file-->
+<configuration>
+    
+    <typeAliases>
+        <package name="com.kuang.pojo"/>
+    </typeAliases>
+
+</configuration>
+```
+
+**整合实现二：**
+
+mybatis-spring1.2.3版以上的才有这个，官方文档截图：
+
+dao继承Support类 , 直接利用 getSqlSession() 获得 , 然后直接注入SqlSessionFactory . 比起整合方式一 , 不需要管理SqlSessionTemplate , 而且对事务的支持更加友好 . 可跟踪源码查看。
+
+![在这里插入图片描述](assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpNjQzOTM3NTc5,size_16,color_FFFFFF,t_70#pic_center.png)
+
+测试：
+
+1. 将我们上面写的UserMapperImpl修改一下
+
+```java
+public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
+
+    public List<User> selectUser() {
+        
+        return getSqlSession().getMapper(UserMapper.class).selectUser();
+    }
+}
+```
+
+2. 注入到Spring配置文件中。
+
+```xml
+    <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
+        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
+    </bean>
+```
+
+3. 测试
+
+```java
+    @Test
+    public void test () throws IOException {
+
+        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
+        
+        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
+        for (User user : userMapper.selectUser()) {
+            System.out.println(user);
+        }
+    }
+```
+
+# 13、声明式事务
+
+***
+
+## 13.1、回顾事务
+
+- 把一组业务当成一个业务来做；要么都成功，要么都失败！
+- 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
+- 确保完整性和一致性。
+
+**事务ACID原则：**
+
+- 原子性（atomicity）
+  - 事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用。
+- 一致性（consistency）
+  - 一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中。
+- 隔离性（isolation）
+  - 可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
+- 持久性（durability）
+  - 事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中。
+
+**测试：**
+
+将上面的代码拷贝到一个新项目中
+在之前的案例中，我们给userMapper接口新增两个方法，删除和增加用户；
+
+```java
+//添加一个用户
+int addUser(User user);
+
+//根据id删除用户
+int deleteUser(int id);
+```
+
+UserMapper文件，我们故意把 deletes 写错，测试！
+
+```xml
+<insert id="addUser" parameterType="com.kuang.pojo.User">
+insert into user (id,name,pwd) values (#{id},#{name},#{pwd})
+</insert>
+
+<delete id="deleteUser" parameterType="int">
+deletes from user where id = #{id}
+</delete>
+```
+
+编写接口的UserMapperImpl实现类，在实现类中，我们去操作一波
+
+```java
+public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
+
+
+    //增加一些操作
+    public List<User> selectUser() {
+        User user = new User(5, "小王", "185161");
+        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
+        mapper.addUser(user);
+        mapper.deleteUser(5);
+
+        return mapper.selectUser();
+    }
+    
+    //新增
+    public int addUser(User user) {
+        return getSqlSession().getMapper(UserMapper.class).addUser(user);
+    }
+
+    //删除
+    public int deleteUser(int id) {
+        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
+    }
+}
+```
+
+测试
+
+```java
+    @Test
+    public void test(){
+        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
+
+        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
+
+        for (User user : userMapper.selectUser()) {
+            System.out.println(user);
+        }
+    }
+```
+
+报错：sql异常，delete写错了
+
+结果 ：数据库结果显示插入成功！
+
+没有进行事务的管理；我们想让他们都成功才成功，有一个失败，就都失败，我们就应该需要事务！
+
+以前我们都需要自己手动管理事务，十分麻烦！
+
+但是Spring给我们提供了事务管理，我们只需要配置即可；
+
+## 13.2、Spring中的事务管理
+
+Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。
+
+**编程式事务管理**
+
+- 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
+- 缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码
+
+**声明式事务管理**
+
+- 一般情况下比编程式事务好用。
+- 将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
+- 将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。
+
+**1. 使用Spring管理事务，注意头文件的约束导入 : tx**
+
+```xml
+xmlns:tx="http://www.springframework.org/schema/tx"
+
+http://www.springframework.org/schema/tx
+http://www.springframework.org/schema/tx/spring-tx.xsd">
+```
+
+**2. JDBC事务**
+
+```xml
+    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
+        <property name="dataSource" ref="dataSource"/>
+    </bean>
+```
+
+**3. 配置好事务管理器后我们需要去配置事务的通知**
+
+```xml
+    <!--结合AOP实现事务的织入-->
+    <!--配置事务通知-->
+    <tx:advice id="txAdvice" transaction-manager="transactionManager">
+        <!--给那些方法配置事务-->
+        <!--配置事务的传播特性： new -->
+        <tx:attributes>
+            <tx:method name="add" propagation="REQUIRED"/>
+            <tx:method name="delete" propagation="REQUIRED"/>
+            <tx:method name="update" propagation="REQUIRED"/>
+            <tx:method name="query" read-only="true"/>
+            <tx:method name="*" propagation="REQUIRED"/>
+        </tx:attributes>
+    </tx:advice>
+```
+
+**spring事务传播特性：**
+事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：
+
+- propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
+- propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
+- propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
+- propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
+- propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
+- propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
+- propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作。
+
+Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。
+
+就好比，我们刚才的几个方法存在调用，所以会被放在一组事务当中！
+
+**4. 配置AOP，导入aop的头文件**
+
+```xml
+    <!--配置事务切入-->
+    <aop:config>
+        <aop:pointcut id="txPointCut" expression="execution(* com.kuang.mapper.*.*(..))"/>
+        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
+    </aop:config>
+```
+
+**5. 删掉刚才插入的数据，再次测试！**
+
+```java
+    @Test
+    public void test(){
+        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
+
+        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
+
+        for (User user : userMapper.selectUser()) {
+            System.out.println(user);
+        }
+    }
+```
+
+**思考：**
+
+为什么需要事务？
+
+- 如果不配置事务，可能存在数据提交不一致的情况；
+- 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务！
+- 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！
+

部署文档/大数据平台/大数据平台环境搭建.md

@@ -312,7 +312,7 @@ hadoop集群规划：
    tar -zxf kafka_2.11-2.1.1.tgz
    ```
 
-2. 进入/opt/modules/kafka_2.11-2.1.1/config/目录，修改server.properties、producer.properties、consumer.properties文件
+2. 进入/opt/modules/kafka_2.11-2.1.1/config/目录，修改server.properties、producer.properties、consumer.properties、kafka-run-class.sh、kafka-server-start.sh文件
 
    ```shell
    vi server.properties
@@ -346,6 +346,35 @@ hadoop集群规划：
    bootstrap.servers=lab1:9092,lab2:9092,lab3:9092
    ```
 
+   ```shell
+   vi kafka-run-class.sh
+   
+   # 修改如下配置
+   KAFKA_JMX_OPTS="
+   -Dcom.sun.management.jmxremote=true 
+   -Dcom.sun.management.jmxremote.authenticate=false  
+   -Dcom.sun.management.jmxremote.ssl=false 
+   -Djava.rmi.server.hostname=服务器的IP地址或者域名
+   -Dsun.rmi.transport.tcp.responseTimeout=60000   #超时时间
+   -Dcom.sun.management.jmxremote.rmi.port=9999    #端口
+   -Dcom.sun.management.jmxremote.port=9999        #端口
+   -Dcom.sun.management.jmxremote.local.only=false"
+   
+   ```
+
+   ```shell
+   vi kafka-server-start.sh
+   
+   # 增加export JMX_PORT="9999"
+   
+   if [ "x$KAFKA_HEAP_OPTS" = "x" ]; then
+       export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G"
+       export JMX_PORT="9999"
+   fi
+   ```
+
+   
+
 3. 上传kafka安装包至lab2、lab3的/opt/modules/目录并解压
 
    ```shell
@@ -366,6 +395,7 @@ hadoop集群规划：
    broker.id=1（当前broker的编号）
    
    listeners=PLAINTEXT://lab2:9092（当前broker的ip）
+   advertised.listeners=PLAINTEXT://当前服务器的wip:9092
    
    zookeeper.connect=lab1:2181,lab2:2181,lab3:2181
    
@@ -395,7 +425,7 @@ hadoop集群规划：
 6. 在三台机器的/opt/modules/kafka_2.11-2.1.1/bin目录下启动kafka
 
    ```shell
-   ./kafka-server-start.sh -daemon config/server.properties
+   kafka-server-start.sh -daemon ../config/server.properties
    ```
 
 7. 使用jps查看相关进程

部署文档/大数据平台/大数据监控安装文档.md

@@ -2,7 +2,7 @@
 
 # 监控安装文档
 
-# 1. `prometheus`
+# 1、 `prometheus`
 
 1. 上传`prometheus`安装包至`lab3`服务器`/opt/modules/`目录下并解压
 
@@ -56,7 +56,7 @@
    lsof -i:9090
    ```
 
-# 2. `node_exporter`
+# 2、`node_exporter`
 
 1. 上传`node_exporter`安装包至`lab3`服务器`/opt/modules/`目录下并解压
 
@@ -78,7 +78,7 @@
 
 4. 在`lab1`和`lab2`上重复上述步骤
 
-# 3. `kafka_exporter`
+# 3、 `kafka_exporter`
 
 1. 上传`kafka_exporter`安装包至`lab3`服务器`/opt/modules/`目录下并解压
 
@@ -98,7 +98,7 @@
    lsof -i:9308
    ```
 
-# 4. `grafana`
+# 4、`grafana`
 
 1. 上传`grafana`至`lab3`服务器`/opt/modules/`目录