Spring 框架的总结与介绍

容器框架：封装对象
IOC
- IOC ：开发思想，Inversion Of Control 控制反转（反转资源获取的方向）
- 资源：对象
- 以前如何new来创建对象，创建对象的工作交于Spring来做，告知Spring我要什么对象，Spring对象推送给我们。
DI
- Dependency Inject ：依赖注入
一站式框架： Spring的生态，基于Spring各种各样的不同领域解决方案。
- Spring-data
- Spring-cloud
- Spring-boot
sun公司赋予了java生命，Spring是对于java一种生命延续。

第二章初识Spring

1、不是所有的对象都适合有Spring管理

核心的bean对象
实体类对象、vo对象不适合spring管理

2、Spring框架的搭建流程

导入jar包

配置文件

<bean id="bean的名称" class="类型"></bean>

从Spring获取对象

通过xml来创建一个全新的Spring容器对象

ClassPathXmlApplicationContext ac = new
 ClassPathXmlApplicationContext("spring-config.xml");

在从容器当中获取你要对象： getBean()
真实作用
- 项目当中，如果某一个对象创建过程非常复杂，而且对象在项目当中经常使用，将这个对象放置到Spring容器当中，需要这个对象，通过getBean告知Spring要什么对象，Spring就会将对象推送过来
- Spring提供了获取对象的另外一种方式。

第三章基于XML文件配置

1、xml文件的注意事项

id不能重复
id可以省略，省略id，Spring会自动给bean对象设置一个id值
- 默认的值全类名（全限定类名）
当Spring接管多个同类型对象，省略了id
- 默认的id值为: 全类名#0 全类名#1

2、依赖注入（DI）

依赖（Dependency）

public class Person{
    private String name;
    private Car car;
  
}

public class Car{
    
}

public class UserServiceImpl{
    private UserMapper userMapper;
}
public interface UserMapper{
    
}

成员变量：类型当中编写属性(全局性的变量)
依赖：是一种特殊的成员变量，当一个类当中很多的方法都需要使用的成员变量就叫做依赖

注入（Inject）
- 赋值 int a = 1;

依赖注入：如何给依赖赋值，可以通过一种特定xml配置来依赖的注入

通过set方法进行依赖的注入

<bean id="" class="">
    <property name="属性名" value="值"></property>
</bean>

通过构造器进行依赖的注入

<bean id="" class="">
    <constructor-arg index="下标" value="值"></constructor-arg>
</bean>

3、字面值（字面量）

一个具体的值
```
String a = "tom";
int b = 12;
```

表达式（expression） : 一个运算过程最终得到的结果

String b = 12 * 3 + 2 * 5 + 1333;

double a = Math.random();

布尔表达式
boolean c = 2 > 1;

依赖注入的时候：

set方法

<bean id="" class="">
    <property name="" value=""></property>
</bean>

<bean id="" class="">
    <property name="">
        <value>张三</value>
    </property>
</bean>

构造器

<bean id="" class="">
    <constructor-arg index="下标" value="值"></constructor-arg>
</bean>
<bean id="" class="">
    <constructor-arg index="下标">
        <value>值</value>
    </constructor-arg>
</bean>

value属性还是value标记
- 内部只能放字面值

4、Spring EL表达式

el ： expression language
xml文件当中可以通过 #{} 成员依赖（value="#{}"）

5、bean的应用

一个项目当中某个功能往往需要很多bean协同合作才能完成

service{
    private FIlmTMapper filmTMapper;
    private FilmInfoTMapper filmInfoTMapper;
    
    public FilmInfoVO findInfo(int uuid){

    }
}

当某一个类和另外一个类产生依赖关系，Spring管理，类的对象全部放置到Spring容器

bean的注入：当多个对象spring管理，对象和对象之间产生依赖关系，给bean注入值

class A{
    private B b;
    private C c;
}
class B{
    
}
class C{
    
}

<bean id="a" class="A">
    <property name="b" value="#{b}"></peroperty>
    <property name="c" value="#{c}"></peroperty>
</bean>
<bean id="b" class="B"></bean>
<bean id="c" class="C"></bean>
spring的el表达式来完成bean的引入

property和constructor-arg提供属性ref=""

第四章基于注解进行配置

1、四个通用注解

@Component
@Controller
@Service
@Repository
功能是一模一样
区别：
- 普通类： @Component （组件）
- 业务类： @Service
- 持久层类： @Repository
- 控制器类 : @Controller 讲解Spring MVC框架

2、注解作用

四个注解，修饰类
当一个类由上面四个注解当中的任意一个修饰，Spring就会接管当前类对象，单例

3、spring的注意事项

Spring默认不开启注解

xml文件当中

<context:component-scan base-package="com.group32.bean"></context:component-scan>

4、自动装配

当Spring容器当中某一个bean对象，依赖于另外一个bean的时候
- xml配置
  - ref
  - value="#{}"
- 注解
  - @Value("#{}")
  - 自动装配
    - @Autowired
自动装配
- 按照类型装配
  - 依赖的上面@Autowired，默认按照类型，容器当中同一类型的bean只能有一个！
- 按照名称装配
  - @Qualifier("c1")，必须配合@Autowired
  - @Resource("c1")

5、总结

xml
注解

配置类

Spring提供一种可以通过一个类来代替xml文件

@Configuration
public class MyConfig{
    @Bean
    public Student create(){
        Student s = new Student();
        s.setName('张三');
        Car c = new Car();
        s.setCar(c);
        return s;
    }
}

伏笔：
- AOP ：面向切面编程
- xml文件的详细配置

第五章 IOC和DI

1、IOC

Inversion Of Control ：控制反转，反转传统获取资源的方向。

2、DI

Dependency Injection ：依赖注入

3、DI和IOC

DI是对于IOC思想的良好补充
DI和IOC描述的最终目的是一致
进行DI（注入的时候）可以通过IOC的思想来完成。

第六章 Maven

1、maven简介

构建项目的工具
maven项目
- jar包的管理
- 自动化测试（全局项目进行测试）
- 打包
- ......

2、使用

IDEA自带maven（不推荐使用）

3、安装流程

解压压缩包（不要解压到一个中文目录）
配置java环境变量
- 鼠标右键点击我的电脑
- 选择属性
- 高级系统设置
- 环境变量
- 系统变量内部当中是否包含 JAVA_HOME
  - 如果由，跳过本步骤
  - 如果没有，点击新建，创建一个变量，变量名必须JAVA_HOME,值 jdk安装的路径
- 系统变量当中path，新建一个%JAVA_HOME%\bin
配置maven环境
- 鼠标右键点击我的电脑
- 选择属性
- 高级系统设置
- 环境变量
- 系统变量内部当中是否包含 MAVEN_HOME
  - 如果由，跳过本步骤
  - 如果没有，点击新建，创建一个变量，变量名必须MAVEN_HOME,值
- 系统变量当中path，新建一个%MAVEN_HOME%\bin
打开命令行工具（cmd） mvn -v命令测试

4、中央仓库和本地仓库

中央仓库（central repository）：美国一台计算机包含了所有开源框架jar包
本地仓库（local repostiroy） : 从中央库当中下载的jar包
maven有一项比较重要的功能：下载jar包
maven的配置
- maven安装目录： conf ----> settings.xml
- 修改中央仓库地址 : 我已经给大家改好了，不需要处理！
- 设置本地仓库地址
```
 <localRepository>f:/maven/repository</localRepository>
```

5、创建maven

src
- main ：核心代码
  - java ：所有的java代码
  - resources ：所有非java代码（xml、html）
- test ：测试代码
  - java ：所有的java的测试代码
pom.xml : 全局配置（改变maven的一些默认行为）

6、pom.xml

pom.xml整个maven项目的全局信息
project object model : 项目对象模型
信息
- group-id : 名称（域名的倒写方式） com.pay.alibaba
- artifect-id : 项目名称
- version : 版本
任何maven工程都具备group-id、artifect-id、version
maven工程的坐标（gav）： maven中央库当中所有的开源jar包都是通过maven，gav
依赖：
- 类当中包含了另外一个类对象 : 依赖
- maven的依赖：当项目当中需要导入另外一个jar包，mybatis叫做当前项目的依赖

7、maven案例

创建一个maven工程
导入依赖（jar包）
建立一个mapper访问 StudentMapper ，通过学生编号查找学生信息
配置maven：通过maven下载依赖，jar并没有存放到配置本地库当中。
2020版本配置
- 下方 Configuration -> settings
2021版本
- 左侧： costumize --> all settins

8、maven的常用配置（pom.xml）

gav
依赖
资源配置

第七章 maven的生命周期

1、打包（package）

项目打成jar包

2、安装（install）

项目打成jar包
jar按照maven工程的坐标安装到本地库（某一个私服）

3、编译（compile）

java代码 ---> 编译器 ---> .class字节码文件 --> jvm
编译查看，当前代码是否存在语法错误（idea编译）

4、测试

junit测试
允许任何类的任何方法都可以作为测试类
@Test注解，导入依赖

第八章 lombok工具框架

1、作用

可以帮助我们对类进行一些常用的操作
set和get
toString
构造器
....

2、使用

@Setter
@Getter
@ToString
@EqualsAndHashCode

@Data

第九章 Spring Boot框架

1、Spring和Spring Boot

Spring是管理核心bean对象的容器框架，IOC和DI思想。
Spring Boot基于Spring的一个框架
- 用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置

2、Spring Boot作用

简化xml，特定的配置方式简化项目开发（properties、yml）
Spring Boot将其他框架常用的对象全部由Spring来管理
自动化配置

Spring Boot默认自带容器

问题

ClassPathXmlApplicationContext ac = new ........;
ac.getBean()

获取对象
@Component
public class A{
	@Autowired
    private B b;
}

结论
- 从容器获取对象，自动装配来获取即可

3、Spring Boot

Spring Boot工程是通过maven构建
@SpringBootTest
- 和Spring四大注解一致（@Component、@Service、@Controller、@Repository）
- 当前测试类
Spring Boot对于组件扫描的自动配置

4、Spring Boot集成mybatis

传统java工程如何使用mybatis
- 导入jar包 maven
- 全局文件（数据源、mapper的注册、全局的设置） Spring Boot简化配置
- 编写接口 mybatis-plus简化
- 编写接口对应的sql映射文件注解
- 注册 Spring boot简化
- 测试使用 Spring Boot

Spring Boot集成mybatis

导入依赖

 <dependency>
     <groupId>org.mybatis.spring.boot</groupId>
     <artifactId>mybatis-spring-boot-starter</artifactId>
     <version>2.2.2</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

问题
- 下载失败，红色波浪线
- maven配置有问题，idea没有集成maven，idea默认使用自带的maven
- 刷新

特定配置进行数据源

# application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/maoyan_32?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false&allowPublicKeyRetrieval=true
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=123456

mybatis.configuration.map-underscore-to-camel-case=true
mybatis.mapper-locations=classpath:com/abc/mapper/xml/*.xml

问题
- 连接数据库失败，数据库的信息错误
- =两边不能加入空格
- BindingException :

接口
- @Repository
- @Mapper
映射文件
- mybatis的知识点（mybatis学的不扎实）

注册sql映射文件

mybatis.mapper-locations=classpath:com/abc/mapper/xml/*.xml

spring boot基于maven，默认要求放到resources

 <resources>
     <resource>
         <directory>src/main/java</directory>
         <includes>
         	<include>**/*.xml</include>
         </includes>
     </resource>
 </resources>

spring boot解决测试
- @Autowired ：容器当中没有指定，基础包

5、全局配置

类型

properties

配置名=值
spring.datasource.url=值
spring.datasource.driver-class-name=值
spring.datasource.username=值
spring.datasource.password=值

yml （yaml）

相对xml （可拓展标记语言）

缩进描述从属关系

spring:
	datasource:
		url: 值
		driver-class-name: 值
		username: 值
		password: 值

application.properties或者application.yml
约定大于配置

6、读取自定义配置

项目当中全局的数据放置到application.yml或者application.properties
意义
- 狭义的概念：当某一些数据，在项目当中频繁使用，便于维护，值放到配置文件当中，开发人员可以通过@Value("${key}")修饰成员变量，读取自定义配置所属类的对象必须由Spring来管理
- 广义的概念：当前项目运行过程当中，需要一些数据，配置文件的方式来告知开发人员，xjc.book.num=8，便于维护

7、读取自定义配置的方式

@Value("${}") : 只能修饰容器当中bean的成员变量
配置封装类一次性读取所有的配置
- 当某一些配置是以同样的前缀作为开始
- 一次性的将所有指定前缀的数据读取到一个对象当中
- 写一个类
  - 放到容器当中@Component
  - @ConfigurationProperties(prefix="指定前缀")
  - 提供get和set方法
  - 类的成员变量必须和配置名一致

8、多环境配置

环境：当前项目在不同的生命周期当中所处计算机环境
开发环境（dev）、测试环境（test）、生产环境（pro）
实现方式
- 多配置多环境选择
  - application-环境名称.yml
  - appplication.yml文件中加入
```
spring:
	profiles:
		active: 环境名称
```
- 单配置多环境选择（不推荐使用）
多环境配置有什么意义？
- 应付不同的环境使用
- 业务方法的不同实现
  - 同样一个业务在不同的环境当中实现方式不同

9、事务处理

事务（Transactional）：一个业务方法在需要多条SQL语句执行之后才能完成当前业务（包含多个SQL语句执行的方法，事务）
事务的四大特性 ACID
- 原子性（atomicity）：当一个物体在研究的领域范畴当中，不可拆分的；事务，不可拆分。要么全部提交，要么全部回滚
- 一致性（consistency) ：事务提交之前和之后的数据要保证前后一致性。
- 隔离性（isolation）：当一个事务在执行的过程当中，不允许其他客户端再次访问事务（乐观锁、悲观锁）
- 持久性（durability）：当事务没有提交之前，让数据状态回滚到最初的样子，但是一旦事务提交之后，无法通过回滚让数据还原到最初的状态。
持久层对于事务处理
- jdbc ：没有默认的事务处理，手动代码来提交或者回滚来完成事务
```
public class Service{
    void buy(){
        // 代码对于数据库进行操作
        try{
            
            提交
        }catch(Exception e){
            回滚
        }
    }
}
```
- mybatis ：默认是任何对于数据的独立操作，都是一个事务
- Spring Boot（Spring）：
  - @Transactional 方法，自动完成事务处理，当方法内部出现了运行时异常，会对当前方法进行回滚操作，如果没有出现任何运行时异常，自动提交
- 事务的属性
  - 定义事务的时候给事务定义一些信息，信息可以英雄事务的行为

第十章 Spring MVC

1、专业术语

web ：所有和互联网相关技术
服务器（server）
- 一台计算机安装了专业服务器软件，其他计算机就可以通过网络来访问这台计算机当中服务器内部提供的资源
- mysql ：提供了数据存储的服务器软件
- tomcat ：（Spring Boot内嵌了tomcat），Spring Boot内部所有的资源都允许客户进行访问
客户端（client）：访问服务器的计算机
端口（port）：
- 一台安装tomcat，配置端口号 8080
- 安装了mysql ,3306
- 安装ftp服务器
- http://ip地址:8080
- 天安门：地址 IP地址
url ：统一资源定位符
- 互联网当中所有的资源都有一个属于自己的地址
- 网址
网络资源
- 客户端访问服务器的内容
- 网页、图片、音频、视频、java当中的方法也可以作为网络资源
方法
- 类的对象必须由Spring来管理
- @Controller
- 方法可以加入一个注解 @RequestMapping("地址")
- @ResponseBody
- 控制器类的对象，用来让客户端可以轻松访问目标服务器中方法的一种方式。
案例
- 登录
- 注册

2、请求和响应模式

请求（request）
- 当客户端访问服务器端资源，过程叫做发送请求
- tomcat服务器，会为每一次的请求都产生一个请求对象（HttpServletRequest）
- 请求对象
  - 请求行：请求协议、协议版本
  - 请求头：客户端相关信息
  - 请求体：核心的数据
- Controller ：方法当中使用请求对象，仅仅将形参位置加入HttpServletRequest
响应（response）
- 当客户端访问服务器端资源，数据返回给客户端的过程，叫做响应
- 创建全新的对象 HttpServletResponse对象包含所有返回给客户端的额信息
请求和响应的无状态性
- 当客户端发送请求，最终得到响应之后，客户端不在于服务器产生网络连接。

3、常用注解

@Controller
@RequestMapping
- 方法的上面（url地址）
- 类的上面（url地址）
@ResponseBody
- 方法的的上面：可以将方法的返回值直接返回给前端
- 类的上面：可以将类里面所有的方法返回值返回给前端

4、问题

没有前端页面的支持（服务器渲染数据、前后端分离）
请求参数（前端向控制器发送请求的时候传递数据）

5、前端传递请求参数

url?请求参数名=值&请求参数名=值
- 当传递多个数据
form表单配合提交按钮，可以将form表单当中所有的控件提交给action所对应的资源，name属性作为请求参数名、作为请求参数值

占位符参数

url/值

@RequestMapping("/test1/{catId}")
@ResponseBody
public int test1(@PathVariable("catId") int catId){
    return catId;
}

/test1/12

传递主键的时候

javascript、jquery、vue
- ajax
- axios

6、后端控制器如何接受请求参数

多个形参对应多个请求参数
- 形参名字和请求参数名字必须一致
- 形参的名字可以和请求参数名不一致
  - @RequestParam(value="请求参数名") 类型形参
  - 当控制器需要请求参数，用户并没有传递的情况。指定默认值
对象来接受多个请求参数
- 对象的成员变量必须和请求参数一致

7、请求转发和重定向

请求和响应
- 客户端通过网络访问服务器端资源过程，发送请求
- 服务器接受到请求之后做出反馈结果，响应
模型数据的作用域
- 有效期就在一次请求和响应
- 一次请求和响应过程产生一个模型数据（Map）
请求转发
- 相邻web资源之间访问
- A --> B --> C
- 张三 ---> 李四 --> 王五
- 控制器方法：return "forward:转发的资源"
- 总结：
  - 请求地址不会发生变化
  - 发生请求转发的资源之间共享同一个request请求，模型数据是一个
重定向
- 相邻web资源之间访问
- 控制器方法 : return "redirect:地址"
- 总结
  - 请求地址会发生变化
  - 发送多个请求，多个模型数据，发生重定向的相邻web资源之间无法共享map数据

第十一章 MVC设计模式

1、web开发模式（最重要的内）

mvc
- view : 视图，配合着模板引擎技术将控制器返回的结果渲染到页面当中
  - JSP（Java Server Page）
  - ThymeLeaf（重点讲，Spring Boot官方推荐的一款模板引擎技术）
  - FreeMarker
  - Volecity
  - 服务器端渲染数据
- controller：控制器
  - 接受请求，做出响应
- model : 模型数据
前后端分离：最重要
mvc开发模式和前后端分离开发模式区别
- 数据渲染：服务器端thymeleaf技术；前后端分离采用专业前端技术来解决
- 控制器的要求：
  - mvc返回值必须String，return 页面的名字，配置文件当中加入mvc的视图的前缀和后缀
  - 前后端分离：返回模型数据（vo），@ResponseBody
- 前后端分离：保证后端唯一性，前端多样性

2、MVC实现流程

导入依赖： spring-boot-starter-web
控制器的方法不再随意返回结果，必须是String，取消@ResponseBody
application.yml或者application.properties文件当中对mvc进行配置
```
spring:
  mvc:
    view:
      prefix: /
      suffix: .html
```
将模型数据传递给目标页面（形参位置加入Map集合）

页面当中模型数据展现出来

导入thymeleaf依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

html页面的上面

<html lang="en" xmlns:th="http://www.thymeleaf.org">

th:each 、th:text、th:if

3、thymeleaf

视图数据渲染的一种框架，基于服务器端的数据渲染的框架（模板引擎）
将模型数据展示到页面当中，提供大量的html属性，可以对页面当中元素进行数据渲染
问题
- 访问templates当中的html页面，绝对不允许直接访问；要求这个页面必须经由控制器进入。
- 如果发送请求，服务器做出响应，页面一定会刷新。

4、模型数据处理

方法形参位置加入Map<String,Object> map
方法形参位置加入Model model
方法形参位置加入ModelMap modelMap
方法返回值不再是String， ModelAndView类型数据

5、全局异常处理

HttpStatus对象：错误编码、原因
404 ：资源未找到
500 ：服务器内部出错（代码当中出现的异常）
templates模板引擎加入 : 404.html或者500.html
异常：
- NullPointerException
- BinddingException
- BadSqlGrammerException
- SQLException
编写一个控制器，对于异常进行定制化处理

第十二章 session会话对象

1、session

请求对象、响应对象：
session对象
- 当一个客户端访问服务器，服务器底层会去识别客户端是否传递了jSessionId数据
  - 没有传递：服务器会为当前这个客户端在服务器端分配一个内存空间，分配id值就是jSessionId，jSessionId回传给客户端
  - 客户端再次访问的服务器，自动携带第一次分配的jSession访问服务器，根据传递jSessionId来找到属于当前客户单的内存空间

控制器如何获取当前客户端的额session对象呢

方法形参 HttpSession对象即可

方法

setAttribute(String,Object)
getAttribute(String)
getId() : 返回jSessionId
session.setMaxInactiveInterval(int); 
 设置session的有效时长，规定session销毁时长，从你最后一次操作页面开始计算

session到底是什么？
- 服务器端对于每一个客户端访问的服务器，服务器对每一个客户端分配一个内存空间
- 对象：大量的数据，方法来完成操作
应用场景：与客户端相关的临时数据session当中
- 用户的登录信息
- 购物车信息

第十三章拦截器

1、拦截器（interceptor）

客户端发送请求给服务器端的控制器，进行拦截程序的处理
拦截器
- 拦截哪些控制器方法
- 放行

接口 : HandlerInterceptor

public boolean preHandle(HttpServletRequest request,HttpServletResponse response,Object Handler);

public void postHandle(HttpServletRequest request,HttpServletResponse response,Object Handler,ModelAndView mv);

public void afterCompletion(......);

3、mvc的配置

Spring Boot全面接管MVC的配置
配置类配置mvc的默认行为

Spring MVC配置类

public class xxx implements WebMvcConfigure{
    //大量的方法完成配置
    public void addInterceptors(InterceptorRegistry registry){
        registry.addInterceptor(new 拦截器对象).addPath().excludePathPattern(路径)
    }
}

4、多个拦截器可以同时拦截相同的资源

优先级如何配置
- 配置类当中调用.order(数字)，数字越小优先级越高
- 拦截器类实现Order接口， int value(){}
- 注解
执行顺序
- 按照从前向后的顺序执行preHandle方法
- 进入目标控制器之后，由从后向前执行posstHandle
- 请求响应结束之后，从后向前执行afterCompletion

第十三章 MVC总结

1、web的开发模式

MVC模式： Model、View、Controller
前后端分离：
- 后端：控制器，不在参与到页面的跳转以及模型数据处理，结果return出去
- 前端服务器来做： javascript、es、jquery、vue.js、angular.js
MVVM是什么东西？
DDD ：领域驱动模型

2、案例

登录功能、登录校验，点击立即购买
分析业务、实现立即购买功能。
- 库存不足显示错误消息
- 余额不足显示错误消息
- 购买成功显示购买成功

3、异常

对象：成员变量+方法
异常类结构
- Throwable
```
public class Throwable{
    private String message;
    private ..............;
    public Throwable(String message){
        this.message = message;
    }
    public void printStackTrance(){
        System.out.println();
    }
}
```
```
当我们系统出现任何异常的情况下，系统就会调用printStackTrance方法
```
- Error、Exception
- Exception ：异常
  - 编译时异常（受检查异常）： IOException、ClassNotFoundException、FileNotFoundException
    - 编写代码的过程当中，编译器就会提醒你有可能出现的异常
    - throws、try/catch
  - 运行时异常（RuntimeException）：程序已经运行起来了，才可以发现的异常
    - 空指针异常、BindingException
    - 不需要try/cath,系统自动处理，报错

4、MVC的问题

代码耦合度极高（控制器当中，return 不同界面）控制器、模型数据、跳转视图
模型数据处理（4种方法）非常的复杂
thymeleaf ： html基础基础上加入thymeleaf
控制器之间设计到数据传递（请求转发）

5、前后端分离

控制器不再参与页面跳转，控制器需要的数据返回给返回给前端 @ResponseBody
数据渲染，前端来实现

6、postman ：

测试后台
登录功能

7、泛型

当一个方法在执行的过程当中，有一些数据是不固定
当我们使用一个类，类里面有一些数据类型是未知？

第十四章 mybatis-plus

1、mybatis-plus简介

mp是一款基于mybatis的增强版工具，简化开发。
特征
- 润物无声：对mybatis没有做任何改变，引入mp不会对现有mybatis工程代码有任何的影响
- 效率至上：简单的配置，就可以完成对于"单表"的CRUD操作，对于多表查询没有过多的处理。只能用原生mybatis的写法实现
- 强大功能：分页处理，逻辑删除、代码生成。

2、特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

3、使用流程

导入依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.1.1</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.22</version>
</dependency>

进行配置

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/permission_27?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false&allowPublicKeyRetrieval=true
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath:com/abc/mapper/xml/*.xml

启动类上面加入注解

@MapperScan("mapper接口对应包名")  ，可以省略所有mapper接口上面@Mapper注解

使用
- mapper层，mybatis-plus提供了大量的增删改查方法，BaseMapper<实体类>

4、mapper层封装常用api

查询方法的封装
- 查询方法（select）
  - selectById(Serializable) : T
  - selectList(Wrapper) : List<T> 查询多行
  - selectObjs(Wrapper) : List<Object> 查询多行（非实体类对象）
  - selectOne(Wrapper) : User 结果只能有0或1行，如果多行出现TooManyResultException
  - selectBatchIds(Collection<? extends Serializable>) : List<T>
  - selectByMap(Map<String,Object>) : List<T> 根据map集合当中key和value描述列和值相等关系的条件，构建sql语句，最终返回list集合实体类
  - selectCount(Wrapper) : Integer
  - selectMaps(Wrapper) : List<Map<String,Object>> ：将通过条件查询到的多条记录，记录封装成map集合，map集合当中列名做为key、列值作为value
删除方法
- delete(Wrapper) : int 根据条件进行删除
- deleteById(Serializable) : int 根据主键删除
- deleteBatchIds(Collection) : int 根据多个主键进行删除
修改方法
- updateById(T) : int 参数传递对象必须包含主键
- update(T,Wrapper) ： int 根据条件，将满足条件数据库当中内容改造为实体类对象内部的数据
插入方法
- insert

5、Serializable序列化接口

接口：当一个类实现了Serializable接口，证明类的对象可以实现序列化。
空接口，只要有一个类实现Serializable接口，证明这个类的对象可以进行序列化，当我们将一个对象放置到一段内存空间当中，jdk底层回去判断这个类实现序列化接口。标识接口

6、条件构造器

查询方法的参数（Wrapper<T>）
Wrapper是一个抽象类
- QueryWrapper<T>
- UpdateWrapper<T>
条件构造Wrapper类型当中常用的方法
- eq
- noteq
- lt
- gt
- le
- ge
- in
- notin
- between
- notbetween
- like
- notlike
- likeLeft
- likeRight
- notLikeLeft
- notLikeRight
- last
- ........

7、Service的封装（业务）

查询的方法
- list(Wrapper) : List<T> 根据条件查询多行
- list() : List<T> 查询所有
- listById(Collection) : Collection<T>
- getById(Serializable) ： T
- getOne(Wrapper) : T
- getBaseMapper()
删除的方法
- remove(Wrapper) : boolean
- removeById(Serializable) : boolean
- removeByIds(Collection) : boolean
保存的方法
- save(T) :boolean
- saveOrUpdate(T) : boolean 做修改、做插入
- saveBatch(Collection) : boolean
- saveOrUpdateBatch(Collection) : boolean
修改
- updateById(T) : int 参数传递对象必须包含主键
- update(T,Wrapper) ： int 根据条件，将满足条件数据库当中内容改造为实体类对象内部的数据

8、关于Service层方法的链式调用

query() : 构造一个QueryChainWrapper对象
- 调用内部的条件构造方法（lt、gt、le.....）构造条件
- list() : 查询多个
- one() : 查询一个
update() : 构造一个UpdateChainWrapper对象
- 调用内部的条件构造方法（lt、gt、le.....）构造条件
- update() : 设置某个值 set方法
- remove()

9、代码生成器

导入依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.4.0</version>
</dependency>
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.0</version>
</dependency>

代码生成器源码

 // 代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath + "/src/main/java");
        gc.setAuthor("邢景春");
        gc.setOpen(false);
        // gc.setSwagger2(true); 实体属性 Swagger2 注解
        mpg.setGlobalConfig(gc);

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/shop?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false&allowPublicKeyRetrieval=true");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("123456");
        mpg.setDataSource(dsc);

        // 包配置
        PackageConfig pc = new PackageConfig();

        pc.setParent("com.future.auto");
        mpg.setPackageInfo(pc);


        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);
        strategy.setRestControllerStyle(true);
        // 公共父类

        // 写于父类中的公共字段

        strategy.setControllerMappingHyphenStyle(true);
        strategy.setTablePrefix(pc.getModuleName() + "_");
        mpg.setStrategy(strategy);
        mpg.execute();

10、分页查询的处理方式

mapper层
- selectPage(Page,Wrapper) : Page
service层
- page(Page)
- page(Page,Wrapper)

Page对象内部的内容：

    protected List<T> records = Collections.emptyList();

    /**
     * 总数
     */
    protected long total = 0;
    /**
     * 每页显示条数，默认 10
     */
    protected long size = 10;

    /**
     * 当前页
     */
    protected long current = 1;

11、常用注解

@TableName(value="") : 修饰类
@TableId(value="",type=IdType.AUTO)
- IdType不仅仅有Auto
@TableField(value=""，exsit=boolean) : 非主键列映射关系
当我们某一个实体类当中，加入一个成员变量，成员变量不对应数据库当中某一列

第十五章权限管理案例

1、登录业务

后台得到用户名和密码，Result （data是CmsUser对象）

2、ftp服务器

window自带一款服务器（帮助我们存储文件）
上传了一个图片，图片放到window自带服务器当中，生成服务图片地址存储到数据库当中
搭建window的ftp服务器（自行查资料）
前端如何设置一个上传图片的组件
后端接受到图片，如何将图片放置到ftp服务器当中

第十六章 java高级

1、lambda表达式

匿名内部类的一种简化写法（语法糖）

封装

1、存储整数
int a = 1;
2、封装整数
int[] array = {1,2,3,4,5,6};
List<Integer> array = new ArrayList<>();
3、封装多个不同类型的数据
Object[] p = {"张三",1.75,22};
List<Object> p = new ArrayList<>();
4、定义类（创建对象）
Person p = new Person("",1.75,22);

方法

修饰符 返回值 方法名(形参)

1、整数
修饰符 返回值 方法名(int a)

2、小数
修饰符 返回值 方法名(double a)

3、若干整数
修饰符 返回值 方法名(int[] a)
修饰符 返回值 方法名(int... a)
修饰符 返回值 方法名(List<Integer> a)

4、一个整数、小数、字符串
修饰符 返回值 方法名(Person person)

5、需要一段代码段
修饰符 返回值 方法名(Person person){
    person.方法();
}
public class Person{
    public void travle(Tool tool){
        // 买票
        // 如何取旅游！
        tool.dirve();
	}
	
	public static void main(String[] args){
        Person p = new Person();
        p.travle(new Tool(){
            public void drive(){
                // 火车代码
            }
        });
	}
}
// 在实现一个接口，不需要创建类，直接将接口的实现类对象创建出来，匿名内部类

public interface Tool{
    void drive();
}

2、匿名内部类作用

当我们在调用一个方法，参数需要一段代码段的，方法声明到一个接口当中

创建接口实现类对象的形式来传递代码段

public interface A{
    void a();
}

public class Person{
    public void test(A a){
        a.a();
    }
}

public static void main(String[] args){
    Person p = new Person();
    A a = new A(){
        public void a(){
            // .......
        }
    }
    p.test(a);
}

3、函数式编程

面向对象编程，哪一个对象调用哪一个方法
函数式编程，关注于对于数据的操作，而不在乎对象

java体现在lambda表达式： jdk8之后提供的一个全新的语法糖（简化传统开发一种全新语法规则），简化匿名内部类

public interface A{
    void a(int m,int n);
}

public class Person{
    public void test(A a){
        a.a();
    }
}

public static void main(String[] args){
    Person p = new Person();
    
    p.test(new A(){
        public void a(int m,int n){
            // .......
        }
    });
    
    p.test((int m,int n) -> {
        // 方法实现即可
    })
}

4、应用场景

当一个方法参数是一个接口的情况下，可以使用匿名内部类
接口只能有一个抽象方法，才可以使用lambda表达式
```
public void t1(Tool tool){
    
}

t1((形参) -> {方法体})
```
lambda只适用于函数式接口：只有一个抽象方法的接口，叫函数式接口。@FunctainalInterface

5、lambda简化语法

省略形参的数据类型

 p.test((m,n) -> {
        // 方法实现即可
})

如果接口当中抽象方法的形参是一个，既可以省略数据类型，也可省略()
如果接口当中抽象方法的方法体只有一行的时候，{}也可以省略
如果接口当中抽象方法的方法体只要一行，而且只有一个return，省略returen同时需要省略;

6、Stream流

IO流：数据读取和写入过程，开启IO流

java当中提供的可以对于数组、集合进行操作一个对象，Stream对象（流对象）

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,3,4);
int m = 0;
for(int i = 0 ; i <= list.size - 1 ; i ++){
    if(list.get(i) > m){
        m = list.get(i);
    }
}

获取Stream流对象

// 1、单列集合
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,3,4);
Stream s = list.stream()

// 2、数组
Integer[] array = {1,2,3,4,5,6};
Stream s = Arrays.stream(array);
Stream s = Stream.of(array);


// 3、双列
Map<String,Object> map = new HashMap<>();
Stream s = map.entrySet().stream();

stream流的魅力
- 定义集合，大量的整数
- 将集合当中偶数过滤出来

方法

中间操作：对流数据进行数据处理，得到全新的流

filter(Predicate)

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8);

List<Integer> n = list.stream()
    				  .filter(a -> a > 3)
    				  .collect(Collectors.toList());

map(参数) ：可以对流当中每一个对象转换为另外一个对象，并且形成自己新的一个流

// 获取所有作者当中，名字包含三，的年龄
 List<Author> list = getAuthor();
List<Integer> n = list.stream()
    .filter(author -> author.getName().contains("三"))
    .map(author -> author.getAge()).collect(Collectors.toList());
System.out.println(n);

limit(long) : 可以对流数据进行限制

List<Author> authors = getAuthors();
List<Author> collect = 	authors.stream()
    							.limit(2)
    							.collect(Collectors.toList());
System.out.println(collect);

skip()

List<Author> list = getAuthor();
List<Author> collect = list.stream()
    .skip(2).collect(Collectors.toList());
System.out.println(collect);

sorted()

List<String> collect = list.stream().sorted((a, b) -> b.getAge() - a.getAge())
                .map(author -> author.getName())
                .limit(2)
                .collect(Collectors.toList());
        System.out.println(collect);

flatMap（）

map() : 将一个对象转换为另外一个对象

flatMap() : 将一个流当中一个对象转换为多个对象

List<String> collect = list.stream()
                    .flatMap(author -> author.getBooks().stream())
                    .map(book -> book.getName())
                    .collect(Collectors.toList());

peek() : 中间操作，可以对流的操作做数据监控
distinct() : 去重

终结操作：对流数据进行数据处理完毕之后，流数据在进行最终处理
- collect() : 得到一个最终结果类型
```
collect(Collectors.toList())
collect(Collectors.toSet())
```
- max() ：求最大值
- min()

7、Compartor接口的简化

public interface Compartor{
    int compare(T t1,T t2);
}

// 想将所有产品获取出来，并且按照产品名称的长度进行升序排列
products.stream()
        .sorted((a,b) -> a.getName().length() - b.getName().length)
        .collect(Collectors.toList())
        
        max(Comparator.comparing(Book::get属性))
        min(Comparator)

8、Optional数据类型

对于数据的一种包装类型，对于数据一层封装

public class Optional<T>{
    private T value;
    // 提供大量的方法帮助我们对数据进行处理
}

常用包装类
- Integer、Double、Float、Byte、Short、Long、Character、Boolean
```
int a = 1;

Integer a = 1; // 包装类当中的方法  new 

小罗伯特唐尼
```

如何创建Optional对象

Optional.ofNullable(数据) ： Optional

如何避免空指针异常

optional.ifPresent(a -> {执行})
如何获取值

optional.get() : 避免不了空指针
optional.orElse(对象)
optional.orElseThrow(() -> 异常对象)

10、方法引用

Lambda简化写法
语法糖简化Lambda表达式
当Lambda表达式的方法体当中只有一条语句，而且这条语句是对于某个方法的调用，尝试使用方法引用简化
方法引用的语法规则
- 类名或者对象名::方法名
- 类的静态方法引用
  - 使用前提：当某一个lambda表达式的方法体只有一条语句，这条语句是对于某一个类的静态方法的调用，并且Lambda表达式的形参按照顺序传递给目标静态方法参数。
```
方法(a -> String.valueOf(a))
方法(String::valueOf)

int a = 1;
String s = String.valueOf(a);
```
- 对象的实例方法
  - 使用前提：当某一个lambda表达式的方法体只有一条语句，这条语句对于某一个对象的实例方法的调用，并且Lambda表达式的形参按照顺序传递给目标实例方法形参
```
方法((a,b,c,d) -> 对象.test(a,b,c,d))
方法(对象::test)
```
- 类的实例方法
  - 使用前提：当某一个lambda表达式的方法体只有一条语句，这条语句对lambda的第一个形参方法的调用，第二个开始lambda表达式的形参按照顺序传递给目标第一个形参方法的参数里面
```
方法((a,b,c,d) -> a.test(b,c,d))
方法(A::test)
```
- 类的构造方法引用
  - 使用前提：当某一个lambda表达式的方法体只有一条语句，创建一个对象，lambda表达式的形参按照顺序传递给目标构造方法，进而创建对象
```
方法((a,b) -> new Person(a,b))
方法(Person::new)
```
11、Mybatis-plus
- LambdaQueryWrapper

第十七章 Redis

1、非关系型数据库：

no-sql数据库（not - only sql）
不是用表来存储，存储的数据之间没有任何关系
并不是用来取代关系型数据库，有一些数据是适合存储关系型数据库当中，有一些数据适合非关系型数据当中。
Redis是单线程，底层采用IO多路复用的设计，速度非常快。 10WQPS , 集群，基于内存。
mysql叫做关系型数据库，存储的数据之间是有一定关联
- 单表内部的数据：字段（设定数据类型、长度、约束（主键、非空、唯一性约束））
- 多表数据：数据都是通过维护表和表之间的关系
- 通过表来存储数据的DB叫做关系型数据库
安装Redis
- 下载windows版本的redis
- 下载一个redis的客户端软件（管理redis）

2、安装Redis

没有官方的windows版本
- 解压缩（放置到指定的物理路径当中）
- 启动服务
  - window提供命令，将redis注册到服务列表
  - redis-server.exe redis.windows.conf 直接运行即可
官方Linux操作系统Redis

3、Redis常用客户端

命令行客户端：命令进入到redis当中，redis进行操作
图形化界面客户端：下载一个客户端软件，进入到redis当中
java的客户端：
- Jedis ：基于java的一个访问redis数据库的一套API
- spring-data-redis : 简单的就可以对redis进行操作

4、命令行客户端

打开redis服务
redis-cli -p 6379

5、存储数据

no-sql数据库的分类
基于键值对来存储数据
- Redis基于键值对
- 键是String类型
基于文档存储数据
- MongoDB
基于图片存储数据
- 社交类的网站
基于列存储数据
- 大数据，HBase

6、数据类型

所说的数据类型值value的数据类型，而key必须是String

String（普通字符串、数字）

命令

set key value
get key
mset key value key value key value 
mget key key key 
incr key
decr key
incrby key 数字
decrby key 数字
setnx ： 分布式锁的实现方案， 查找是否存在指定key，如果存在设置失败，如果不存在设置成功
	     set not exsit
	    
set key value ex 秒 px 毫秒 nx或者xx

可以存储简单的数据、存储JSON字符串

hash（散列）：（对象）

命令

hset key fieldkey filedvalue
hget key fieldkey
hmset key fieldkey filedvalue fieldkey filedvalue fieldkey filedvalue
hmget key fieldkey fieldkey fieldkey
hincrby key fileldkey 10
hsetnx key fieldkey fieldValue ex ...
hdel key fieldkey : 删除某一个hash散列成员

存储一个对象
String和Hash的区别
- String可以存储对象，一般适用于查询业务较多的数据，修改内部数据
- Hash可以存储对象，数据进行增删改的时候，Hash存储对象

list（列表）：有序可重复的集合，双向链表结构

有序：插入顺序、自然顺序

LinkedList ：底层不是链表结构

lpush key vlaue value value      ：   left push
rpush key value value value
lrange key 起始下标 终止下标

lpop key ： 左边弹出一个元素，获取出来，并且从集合当中删除
rpop key : 右边弹出一个元素，获取出来，并且从集合当中删除

set（集合）：无序不可重复的结合

sadd key value value value value
没有顺序（插入顺序，没有下标）

smembers key : 直接获取内部所有元素
sisMember key 值 ： 值是否在set当中

spop key ： 随机弹出某一个数据

zset(sorted set) : 有序不能重复元素的集合（排行榜）
- 存储数据，每个数据设定一个评分分数（）
```
zadd key 分数 值 分数 值 分数 值
zrange key 起始下标 终止下标    ： -1
zscore key 值 ： 分数
```

7、通用命令

keys *
del key
flushdb

8、失效时长（超时剔除 TTL）

redis当中key都可以设置一个失效的时间
expire key 时间（秒）
ttl key

第十八章 Java客户端

1、jedis客户端

java提供的可以访问redis的客户端程序
几个常用的类，创建当前类的对象，对象当中方法，对redis进行操作
jedis的集成方式
- 导入依赖
```
<dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
</dependency>
```
- 创建Jedis对象
  - spring boot 工程当中将 Jedis对象放置到Spring容器当中
  - 创建一个配置类
- 使用：原生命令API

2、框架

Spring Data Redis框架
Reddison框架：功能更加丰富

3、应用场景

1、内存数据库（登录信息、购物车信息、用户浏览记录等） -- 为了减轻数据库的压力，提升性能，我们把某一些数据直接存储到内存数据库。最终存储，登录后的session信息，
2、缓存服务器（商品数据、广告数据等等）使用最多。数据实际上是存储在数据库中的。为了提升性能才在数据库的上面加入了缓存服务器。
3、解决分布式集群框架中的session分离问题（session共享）。互联网项目分布式集群，必然会出现session分离。redis是解决的一种方式。
4、任务队列（秒杀、抢购、12306等） RabbitMQ、RocketMQ
5、分布式锁的实现（setnx）面试常见问题，共享数据的安全性问题，不是分布式可以用关键字。分布式锁是一种思想，实现有多重方案，redis是一种zookeeper是一种
6、支持发布订阅的消息模式
7、应用排行榜
8、网站访问统计:
9、数据过期处理（可以精确到毫秒）冷热数据。分离。可以通过过数据过期时间来区分。 100个春季流行女装

4、专业名词

entity ：类描述数据表
vo : view object 一些数据发送给前端，封装vo对象
mapper ：操作数据库
service ：做业务
controller : 请求
dao : data access object 数据访问对象 UserDAO
pojo :
bean : 项目当中核心对象
model : 需要传递目标页面的对象

dto : data transfer object

public void test(int a,int b,int c,double d,String n){
    
}
public void test(XjcDTO dto){
    
}
@Data
class XjcDTO{
    private int a;
    private int b;
    private int c;
    private double d;
    private String n;
}