Spring 全家桶
2022-07-30 21:01:42 0 举报AI智能生成
spring 技术总结
作者其他创作
大纲/内容
ServletConfig获取配置信息、ServletContext的应用
Spring 应用启动的关键
1.在Servlet容器启动的时候， 会创建一个ServletContext（整个应用上下文）
2. ContextLoaderListener实现了ServletContextListener接口，所以会有两个方法contextInitialized和contextDestroyed。web容器初始化时会调用方法contextInitialized，web容器销毁时会调用方法contextDestroyed。
3.通过 contextInitialized 方法，通过该方法创建一个IOC容器，并将创建的IOC容器存到servletContext中（将WebApplicationContext放入ServletContext）
Spring web启动过程
ContextLoaderListener 监听器
@Service在业务逻辑层(service层)
@Repository在数据访问层(dao层)
@Controller在展现层(MVC→SpringMVC)
声明Bean的注解
@Autowired:Spring提供的注解
@Inject:JSR-330提供的注解
@Resource:JSR-250提供的注解
注入Bean的注解
依赖注入
@Configuration声明当前类是一个配置类
Java配置
@Aspect 声明是一个切面
拦截规则@After @Before @Around
PointCut
JoinPoint
AOP
Spring基础配置
Singleton
Prototype
Request
Session
GlobalSession
Bean的Scope
注入普通字符
注入操作系统属性
注入表达式云算结果
注入其他Bean的属性
注入文件内容
注入网址内容
注入属性文件
SpringEL和资源调用
Java配置方式
注解方式
Bean的初始化和销毁
@Profile
通过设定jvm的spring.profiles.active参数
web项目设置在Servlet的context parameter中
Profile
使用容器发布事件
事件Application Event
Spring常用配置
子主题
Spring-Core
Spring-Beans
Spring-Context
Spring-Context-Support
Spring-Expression
核心容器CoreContainer
Spring-AOP
Spring-Aspects
Spring-Messaging
Messaging
Spring-Web
Spring-Webmvc
Spring-WebSocket
Spring-Webmvc-Portlet
WEB
Spring-JDBC
Spring-TX
Spring-ORM
Spring-OXM
Spring-JMS
数据访问/集成(DataAccess/Intefration)
Spring的模块
spring模块
bean工厂（由`org.springframework. beans.factory.eanFactory`接口定义）是最简单的容器，提供基本的DI支持。
一般情况下，Spring通过反射机制利用<bean>的class属性指定实现类实例化Bean，在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在<bean>中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。FactoryBean接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个FactoryBean的实现。它们隐藏了实例化一些复杂Bean的细节，给上层应用带来了便利。从Spring3.0开始，FactoryBean开始支持泛型，即接口声明改为FactoryBean<T>的形式以Bean结尾，表示它是一个Bean，不同于普通Bean的是：它是实现了FactoryBean<T>接口的Bean，根据该Bean的ID从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象，而不是FactoryBean本身，如果要获取FactoryBean对象，请在id前面加一个&符号来获取。
https://www.cnblogs.com/tiancai/p/9604040.html
FactoryBean
DefaultListableBeanFactory
BeanFactory
AnnotationConfigBootstrap 启动类
XmlConfigBootstrap 启动类。
手动启动容器
AnnotationConfigApplicationContext：从一个或多个基于Java的配置类中加载Spring应用上下文
`AnnotationConfigWebApplicationContext`：从一个或多个基于Java的配置类中加载Spring Web应用上下文。
`ClassPathXmlApplicationContext`：从类路径下的一个或多个XML配置文件中加载上下文定义，把应用上下文的定义文件作为类资源。
`FileSystemXmlapplicationcontext`：从文件系统下的一个或多个XML配置文件中加载上下文定义。
`XmlWebApplicationContext`：从Web应用下的一个或多个XML配置文件中加载上下文定义。
应用上下文
图示
Spring 事件发布的核心类 AbstractApplicationContext事件最终还是由组播（ApplicationEventMulticaster）发布。
事件监听
方法参数
接口方法
https://www.jianshu.com/p/a354d3f849ec
国际化消息接口MessageSource
ApplicationContext
https://yemengying.com/2016/07/14/spring-bean-life-cycle/
BeanNameAware
BeanFactoryAware
ApplicationContextAware
MessageSourceAware
ApplicationEventPublisherAware
ResourceLoaderAware
Spring Aware
bean的生命周期
1. singleton——唯一 bean 实例
2. prototype——每次请求都会创建一个新的 bean 实例
3. request——每一次HTTP请求都会产生一个新的bean，该bean仅在当前HTTP request内有效
4. session——每一次HTTP请求都会产生一个新的 bean，该bean仅在当前 HTTP session 内有效
5. globalSession
bean 的作用域
创建Bean的整个过程
通过HierarchicalBeanFactory 接口，Spring 的IOC容器可以建立父子关系的容器，子容器可以访问父容器的Bean 但是父容器不能访问子容器的Bean。
在容器内，Bean的id必须 是唯一的，但是子容器可以拥有一个父容器相同的Bean。
而典型的父子容器就是spring和springmvc同时使用的时候。分别ContextLoaderListener 创建的容器是父容器，DispatcherServlet 创建的容器是子容器。
SpringMVC中体现
父子容器
IOC容器一系列缓存组件组成
容器
构造注入
属性注入
接口注入
基于xml
基于注解
基于javaConfig
如何装配对象
依赖注入（手段）
好莱坞法则：“不要给我们打电话，我们会给你打电话”
ioc容器控制bean的生命周期
控制反转（目的）
IOC
前置通知：在目标方法执行之前执行，不改变方法的执行流程及执行结果，前置通知的实现类要实现`MethodBeforeAdvice`这个接口。
环绕通知：也叫方法拦截器，可以改变方法的执行流程及执行结果，环绕通知的实现类要实现`MethodInterceptor`这个接口。 (最强大)
后置通知：在目标方法执行之后执行，不改变方法的执行流程及执行结果，后置通知的实现类要实现`AfterReturningAdvice`这个接口。
顾问（advisor） 核心接口：`PointcutAdvisor `接口，通知增强版
切入点 ` Pointcut` : 切点的定义会匹配通知所要织入的一个或多个连接点.我们通常使用明确的类和方法名称，或是利用正则表达式定义所匹配的类和方法名称来指定这些切点。有些AOP框架允许我们创建动态的切点，可以根据运行时的决策（比如方法的参数值）来决定是否应用通知。
连接点：我们的应用可能也有数以千计的时机应用通知。这些时机被称为连接点。连接点是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时、抛出异常时、甚至修改一个字段时。切面代码可以利用这些点插入到应用的正常流程之中，并添加新的行为。
织入：织入是把切面应用到目标对象并创建新的代理对象的过程。切面在指定的连接点被织入到目标对象中。
切面： 切面是通知和切点的结合。通知和切点共同定义了切面的全部内容——它是什么，在何时和何处完成其功能。
Spring 原生APO 支持
@EnableAspectJAutoProxy；
@Pointcut语法详解
AspectJ 支持
如果把传统核心逻辑编程理解为纵向执行，所有逻辑竖线走向，那么AOP则是以一种横切的方式织入到纵向逻辑中
我们可以把切面想象为覆盖在很多组件之上的一个外壳。借助AOP，可以使用各种功能层去包裹核心业务层。
AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理。
理解核心思想
Spring对AOP的支持
AOP编程其实是很简单的事情，纵观AOP编程，程序员只需要参与三个部分：
结果
反编译输出到文件
JDK 动态代理
CGLIB 动态代理
Spring AOP 实现原理
使用模板消除样板式代码
各种 Template 使用
@Entity(name=\"USER\
@Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = \"ID\")
@Column(name=\"USER_NAME\")
@OneToMany注解的使用
JPA支持
@EnableJpaRepositories
开启
什么是Spring Data JPA
query queryForObject queryForList updateexecute
定义数据访问层
常规查询
限制结果数量
根据属性名查询
使用JPA的NamedQuery
使用参数索引
使用命名参数
更新查询
Specification
定义
使用排序
使用分页
排序与分页
使用@Query查询
find…By… / read…By… / query…By… / get…By…
count…By…
…OrderBy…[Asc / Desc]
And / Or / IgnoreCase
Top / First / Distinct
定义查询方法
Pageable / Sort
Slice<T> / Page<T>
分页查询
定义自定义Repository接口
定义接口实现
自定义ReposityFactoryBean
开启自定义支持使用@EnableJpaRepositories的repositoryFactoryBeanClass来指定FactoryBean即可
自定义Repository的实现
SpringDataJPA
JDBC
配置
opsForValue()
opsForList()
opsForSet()
opsForZSet()
opsForHash()
使用
定义Serializer
Spring的支持
Spring Boot的支持
非Docker安装
Docker安装
安装Redis
Redis
关键类
基本组成
通过便签的形式，减少了拼接SQL的难度
常用标签 if foreach where等
动态SQL
association
collection
ResultMap
输入和输出映射
结果映射
数据类型转换
分页插件
扩展四个接口中的方法
核心类和接口：InterceptorChain执行链Interceptor 执行InvocationPlugin 生成代理的类。
核心原理
插件机制
配置mybatis支持延迟加载
小结
延迟加载
一级缓存 session级别默认开启。
二级缓存默认是关闭的，Mapper接口级别，也是xml的NameSpace级别，不建议使用 ，用redis第三方等代替。
缓存
MyBatis：#和$的区别
mapper代理的方式
sqlMapConfig.xml
SaveOrUpdate
扩展
mybatis.mapper-locations = classpath*:mapper/**/*.xml
mybatis.type-aliases-package = 类型别名的包名
mybatis.type-handlers-package = TypeHandler扫描包名
mybatis.configuration.map-underscore-to-camel-case = true
@MapperScan 配置扫描位置
@Mapper 定义接⼝
映射的定义—— XML 与注解
Mapper 的定义与扫描
springboot中配置
PageHelper
Mybatis（ORM框架）
事务隔离级别
七大事务传播特性
DataSourceTransactionManager
JpaTransactionManger
JPA
HibernateTransactionManger
Hibernate
JdoTransactionManger
JDO
JtaTransactionManager
分布式事务
事务机制
使用TransactionTemplate或者使用PlatformTransactionManager 等 API完成
TransactionTemplate
PlatformTransactionManager
编程式事务
通过xml配置
通过注解@Transaction
开启事务注解的⽅方式
声明式事务
org.springframework.jdbc.datasource.DataSourceTransactionManager 用于管理jdbc 和mybatis 数据源
org.springframework.orm.hibernate3.HibernateTransactionManager 用于管理hibernate 数据源
核心接口 PlatformTransactionManager
事务管理器
@Transactional(rollbackFor = Exception.class)注解了解吗？
只会回滚 RuntimeException 异常
异常回滚
事务处理
TransactionDefinition
核心接口
事务抽象
Spring是怎么认识那些错误码的
JDBC 异常抽象
持久层
Authentication（认证）
Authorization（授权） 发生在 Authentication（认证）之后。
什么是Spring Security
DelegatingFilterProxy
内存中的用户
JDBC中的用户
通用的用户
请求授权
定制登录行为
用户认证
Spring Security的配置
SpringSecurity快速入门
自动配置了一个内存中的用户
忽略/css/** /js/** /images/** /**/favicon.ico等静态文件的拦截
自动配置的securityFilterChainRegistration的Bean
SpringBoot的支持
Spring Security
xml 配置 task:scheduler
注解 @Scheduled
https://www.cnblogs.com/yanghj010/p/10875151.html
cron
fixDelay
fixRate
计划任务
Spring task定时任务
多线程
异步任务
https://docs.spring.io/spring/docs/5.2.6.RELEASE/spring-framework-reference/integration.html#cache
为 Java ⽅方法增加缓存，缓存执⾏行行结果
支持ConcurrentMap、EhCache、Caffeine、JCache（JSR-107）
org.springframework.cache.Cache
org.springframework.cache.CacheManager
接口
Spring 的缓存抽象
基于注解的缓存
缓存支持 Spring Cache
“在计算机中，响应式编程或反应式编程（英语：ReactiveProgramming）是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很⽅便地表达静态或动态的数据流，⽽而相关的计算模型会自动将变化的值通过数据流进行传播。”
Backpressure 指的是在 Buffer 有上限的系统中，Buffer 溢出的现象；它的应对措施只有一个：丢弃新事件。
https://www.jianshu.com/p/4e02c35152a9
Backpressure
概念
响应式编程 webFlux
Spring5 新特性
字符串操作
StringUitls
处理web的工具
WebUtils
ObjectUtils
属性复制等
BeanUtils
简化反射操作
ReflectionUtils
FileCopyUtils（文件复制），ResourceUtils（读取文件）等
序列化工具类
SerializationUtils
可参看 org.springframework.util包下
Spring中的工具类
Spring中有逻辑的代码doXXX，getXX，pa r se XXX
Spring：过滤器filter、拦截器interceptor、和AOP的区别与联系
Java 必须掌握的 20+ 种 Spring 常用注解
防止XSS跨站脚本攻击：Java过滤器
Spring：动态刷新JavaWeb应用ApplicationContext配置
Spring @Value：读取Properties配置文件
分布式Session：基于Spring-Session 和 Redis实现
Spring：代理Filter：DelegatingFilterProxy原理和作用
分析spring
什么是三级缓存
Spring如何解决循环依赖问题
Spring的后置处理器
扩展-面试
Spring
一个请求的大致处理流程
核心流程
web版
mvc 异步请求
核心图示
Model1：在 Model1 模式下，整个 Web 应用几乎全部用 JSP 页面组成，只用少量的 JavaBean 来处理数据库连接、访问等操作。
@Controller
path / method 指定映射路径与请求方法
params / headers 限定映射范围
consumes / produces 限定请求与响应格式
@GetMapping / @PostMapping / @PutMapping / @DeleteMapping / @PatchMapping
@RequestMapping
@ResponseBody
@RequestBody
@PathVariable
@RestController
@ResponseStatus
Spring MVC的常用注解
静态资源映射
拦截器配置
@ExceptionHandler
@InitBinder
@ModelAttribute
@ControllerAdivce
ViewController
路径匹配参数配置
WebMvcConfigurerAdapter
WebMvcConfigurer
其他配置
Spring MVC的基本配置
文件上传配置
MappingJackson2HttpMessageConverter
StringHttpMessageConverter
自定义HttpMessageConverter
SSE
Servlet3.0+异步方法处理
服务器端推送技术
Spring MVC的高级配置
MockMVC
MockHttpServlerRequest
MockHttpServletResponse
MockHttpSession
Spring MVC的测试
SpringMVC基础
前端控制器DispatcherServlet
处理器映射器HandlerMapping
处理器适配器HandlerAdapter
处理器Handler
ViewResolver 与 View 接口
DispatcherServlet 中的视图解析逻辑
视图解析器View resolver
支持的视图
视图View
基础模块
RequestMappingHandlerAdapter
HandlerMethodArgumentResolverComposite类定义了26个默认的解析器;
ServletModelAttributeMethodProcessor 两种情况1. 使用@ModelAttribute注解的类型参数2. 自定义的POJO，通过特定的DataBinder将请求参数绑定到实体的属性上
其他参数的处理如：Map，ServletRequest，ServletResponse，Model 使用内置的转化器
HandlerMethodArgumentResolver接口
https://docs.spring.io/spring/docs/5.1.5.RELEASE/spring-framework-reference/web.html#mvc-ann-arguments
请求参数解析和封装
自定义类型转换器，实现convert方法
ConversionService接口
https://www.iteye.com/blog/elim-1860732
Spring Boot 在 WebMvcAutoConfiguration 中实现了了一个
添加⾃定义的 Converter
添加⾃定义的 Formatter
自己实现 WebMvcConfigurer
类型转换
通过 Validator 对绑定结果进行校验
@Valid 注解
BindingResult
定义校验
HandlerMethodReturnValueHandler接口
https://docs.spring.io/spring/docs/5.1.5.RELEASE/spring-framework-reference/web.html#mvc-ann-return-types
方法返回值处理
HandlerInteceptor
ResponseBodyAdvice
针对 @ResponseBody 和 ResponseEntity 的情况
AsyncHandlerInterceptor
针对异步请求的接口
Spring MVC 的拦截器
WebMvcConfigurer.addInterceptors()
常规方法
创建一个带 @Configuration 的 WebMvcConfigurer 配置类
不能带 @EnableWebMvc（想彻底⾃己控制 MVC 配置除外）
Spring Boot 中的配置
拦截器器的配置⽅式
拦截器
配置CommonsMultipartResolver 文件上传解析器
通过参数MultipartFile 接收
⽀持类型 multipart/form-data
配置 MultipartResolverSpring Boot ⾃自动配置 MultipartAutoConfiguration
文件上传
SimpleMappingExceptionResolver
DefaultHandlerExceptionResolver
ResponseStatusExceptionResolver
ExceptionHandlerExceptionResolver
实现类
实现HandlerExceptionResolver接口
@ExceptionHandler：用于捕获所有控制器里面的异常，并进行处理。（和@ControllerAdveice两者配合使用处理全局异常，该注解在单个Controller中使用只会处理单个Controler的异常）@InitBinder：用来设置 WebDataBinder，WebDataBinder 用来自动绑定前台请求参数到 Model 中。@ModelAttribute：@ModelAttribute 本来的作用是绑定键值对到 Model 里，此处是让全局的@RequestMapping 都能获得在此处设置的键值对。
@ControllerAdvice 注解
添加位置
异常处理方法
全局异常处理
JacksonAutoConfiguration
JacksonHttpMessageConvertersConfiguration
Spring Boot 对 Jackson 的支持
WebMvcConfigurer.addResourceHandlers()
核心逻辑
spring.mvc.static-path-pattern=/**
常用配置
Spring Boot 中的静态资源配置
ResourceProperties.Cache
spring.resources.cache.cachecontrol.max-age=时间
spring.resources.cache.cachecontrol.no-cache=true/false
spring.resources.cache.cachecontrol.s-max-age=时间
常用配置（默认时间单位都是秒）
Spring Boot 中的缓存配置
静态资源与缓存
@WebServlet
@WebFilter
@WebListener
https://www.jianshu.com/p/3a3edbcd8f24
SPI机制实现
https://blog.csdn.net/huxiutao/article/details/86615325
Spring 在servlet容器实现（servlet3.0）WebApplicationInitializer
web容器三大组件（servlet 3.0）
Spring MVC
application.properties和application.yml的配置会覆盖默认配置
为项目添加默认配置
导入某个配置类
@Import
@SpringBootApplication 入口类上的注解，复合注解，自动化配置，包扫描
从 CLASSPATH下的每个Jar包中搜寻所有 META-INF/spring.factories配置文件
自动扫描
@EnableWebMvc
@EnableTransactionManagement
@EnableAspectJAutoProxy
@EnableAsync
...
enable模式
@ConditionalOnBean\t配置了某个特定bean
@ConditionalOnClass\tClasspath里有指定的类
@ConditionalOnWebApplication\t这是一个Web应用程序
@ConditionalOnMissingClass\tClasspath里没有指定的类
@ConditionalOnBean
@ConditionalOnClass
@ConditionalOnExpression
@ConditionalOnJava
@ConditionalOnJndi
ConditionalOnMissingBean
ConditionalOnMissingClass
ConditionalOnNotWebApplication
ConditionalOnProperty
ConditionalOnResource
ConditionalOnSingleCandidate
ConditionalOnWebApplication
核心注解
condition模式
声明一个bean导入@Configuration注解的配置类导入ImportSelector的实现类导入ImportBeanDefinitionRegistrar的实现类
@Import用来导入@Configuration注解的配置类、声明@Bean注解的bean方法、导入ImportSelector的实现类或导入ImportBeanDefinitionRegistrar的实现类。
Import模式
注解模式
@EnableAutoConfiguration注解上导入AutoConfigurationImportSelector该类
https://blog.csdn.net/huang__2/article/details/104897957
自动装配原理
@EnableConfigurationProperties(MultipartProperties.class)
MultipartAutoConfiguration
自动配置（AutoConfigurer）
Spring 注解驱动示例
注解编程模型
写法
Spring Boot 引导示例
SpringApplication
事件发布
事件基础
步骤
Spring Boot 事件监听示例
Spring Boot 事件监听器
框架底层的事件是单线程么？业务实现是否可以使用事件去实现？如果使用事件实现会不会是不是会有性能问题？
面试
SpringBoot 事件
自动配置、起步依赖、Actuator、命令行界面(CLI) 是Spring Boot最重要的4大核心特性，能够快速构建spring 应用，内嵌web容器，starter 简化maven配置
独立运行的Spring项目
内嵌Servlet容器
提供Starter简化Maven配置
自动配置Spring
准生产的应用监控
无代码声称和xml配置
SpringBoot核心功能
使用约定的配置，不需要大量编写配置文件
“约定大于配置“的思想
@Configuration
@EnableAutoConfiguration
@ComponentScan
入口类和@SpringBootApplication
关闭特定的自动配置
修改Banner
main里修改
fluentAPI
关闭Banner
定制Banner
application.properties
application.yml
src/main/resources
SpringBoot的配置文件
spring-boot-starter
spring-boot-starter-actuator
spring-boot-starter-remote-shell
spring-boot-starter-amqp
spring-boot-starter-aop
spring-boot-starter-batch
spring-boot-starter-cache
spring-boot-starter-cloud-connectors
spring-boot-starter-data-elasticsearch
spring-boot-starter-data-gemfire
spring-boot-starter-data-jpa
spring-boot-starter-data-mongodb
spring-boot-starter-data-rest
spring-boot-starter-data-solr
spring-boot-starter-freemarker
spring-boot-starter-groovy-templates
spring-boot-starter-hateoas
spring-boot-starter-hornetq
spring-boot-starter-integration
spring-boot-starter-jdbc
spring-boot-starter-jerscy
spring-boot-starter-jta-atomikos
spring-boot-starter-jta-bitronix
spring-boot-starter-mail
spring-boot-starter-mobile
spring-boot-starter-mustache
spring-boot-starter-redis
spring-boot-starter-security
spring-boot-starter-social-facebook
spring-boot-starter-social-linkedin
spring-boot-starter-social-twitter
spring-boot-starter-test
spring-boot-starter-thymeleaf
spring-boot-starter-velocity
spring-boot-starter-web
spring-boot-starter-Tomcat
spring-boot-starter-Jetty
spring-boot-starter-undertow
spring-boot-starter-logging
spring-boot-starter-log4j
spring-boot-starter-websocket
spring-boot-starter-ws
官方starter pom
Handlebars
Vaadin
Apache Camel
WRO4J
Spring Batch
HDIV
Jade Templates(jade4J)
Actitivi
第三方starter pom
starter pom
@ImportResource
使用XML配置
基本配置
命令行参数配置
常规属性配置
类型安全的配置(基于properties)
外部配置
日志配置
Profile配置
SpringBoot基础
@Bean
JavaConfig与常见Annotation
与@PropertySource（该注解指定配置文件的位置）配合使用，读取指定的配置属性
可以直接读取 application.properties文件
缺点， 单个属性的读取，仅支持简单数据类型，String，Beanlean 数值等
spring原有的@Value注解
可以指定配置属性前缀，自动绑定属性值
1.支持实体属性的自动封装，2.支持复杂类型的解析，数组，list等
使用@ConfigurationProperties注解标注在类或者方法上
apringboot 可以自动注入Environment 类读取 application.properties文件
基于properties配置文件的读取
基于注解的配置
actuator
autoconfig
beans
dump
configprops
health
info
metrics
mappings
shutdown
trace
测试端点
修改端点id
开启端点
关闭端点
只开启所需端点
定制端点访问路径
定制端点访问端口
关闭http端点
定制端点
状态服务
自定义端点
注册端点并定义演示控制器
http
应用监控
Actuator 监控
https://mp.weixin.qq.com/s/LIE0MorIkcyH5YPDs3pMcQ
知识清单
Thymeleaf
FreeMarker
Groovy
Velocity
模板热部署
SpringLoaded
JRebel
spring-boot-devtools
开发的热部署
打包
运行
注册为Linux的服务
jar形式
打包方式为war时
打包方式为jar时
war形式
常规部署
FROM指令
MAINTAINER指令
RUN指令
CMD指令
EXPOSE指令
ENV指令
ADD指令
ENTRYPOINT指令
Dockerfile
安装Docker
项目目录及文件
编译镜像
云部署--基于Docker的部署
新建SpringBoot项目
业务代码
测试用例
执行测试
SpringBoot的测试
开发部署与测试
getForObject() / getForEntity()
GET 请求
postForObject() / postForEntity()
POST 请求
put()
PUT 请求
delete()
DELETE 请求
常⽤方法
UriComponentsBuilder
构造 URI
ServletUriComponentsBuilder
构造相对于当前请求的 URI
MvcUriComponentsBuilder
构造指向 Controller 的 URI
RestTemplate.exchange()
RequestEntity<T> / ResponseEntity<T>
传递 HTTP Header
JsonSerializer / JsonDeserializer
@JsonComponent
ParameterizedTypeReference<T>
解析泛型对象
高阶用法
PoolingHttpClientConnectionManager
KeepAlive 策略
连接管理
connectTimeout / readTimeout
超时设置
证书检查策略
SSL校验
优化底层请求策略
简单定制 RestTemplate
Spring Boot 中的 RestTemplate
Springboot
架构设计图示
调用过程
SpringCloud电商基本架构图示
第三方注册由一个独立的服务Registrar负责注册与注销。当服务启动后以某种方式通知Registrar，然后 Registrar 负责向注册中心发起注册工作。同时注册中心要维护与服务之间的心跳，当服务不可用时，向注册中心注销服务。这种方式的缺点是 Registrar 必须是一个高可用的系统，否则注册工作没法进展。
第三方注册 （ 独立的服务 Registrar ）
客户端发现是指客户端负责查询可用服务地址，以及负载均衡的工作。这种方式最方便直接，而且也方便做负载均衡。再者一旦发现某个服务不可用立即换另外一个，非常直接。缺点也在于多语言时的重复工作，每个语言实现相同的逻辑。
客户端发现
服务端发现需要额外的 Router 服务，请求先打到 Router，然后 Router 负责查询服务与负载均衡。这种方式虽然没有客户端发现的缺点，但是它的缺点是保证 Router 的高可用。
服务端发现
使用注册中心前，要明白其作用和概念
拉取镜像：docker pull consul
启动镜像：docker run --restart=always -d -p 8500:8500/tcp -p 8500:8500/udp -p 8600 --name=consul -e CONSUL_BIND_INTERFACE=eth0 consul
访问：http://ip:8500
使用docker搭建Consul
使用开发模式启动
使用和zk 类似
使用和基础知识
主要功能有服务发现、健康检查、KV存储、安全服务沟通和多数据中心
Server 节点保存数据;Server 节点有一个 Leader 节点和多个 Follower 节点，Leader 节点会将数据同步到 Follower 节点，在 Leader 节点挂掉的时候会启动选举机制产生一个新的 Leader
SERVER表示consul的server模式，表明这个consul是个server，这种模式下，功能和CLIENT都一样，唯一不同的是，它会把所有的信息持久化的本地，这样遇到故障，信息是可以被保留的。
service模式
Client 节点负责健康检查及转发数据请求到 Server；Client 节点很轻量且无状态，它以 RPC (RPC（Remote Procedure Call）—远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议)的方式向 Server 节点做读写请求的转发，此外也可以直接向 Server 节点发送读写请求
CLIENT表示consul的client模式，就是客户端模式。是consul节点的一种模式，这种模式下，所有注册到当前节点的服务会被转发到SERVER，本身是不持久化这些信息
client模式
S-A启动时通过服务注册和服务发现工具获取到所有的健康实例S-B，并且将这些信息放入自己的内存中，S-A 可以通过监听（Watch）注册工具来更新存入内存中的 S-B 的服务信息。比如 S-B-1 挂了，健康检查机制就会将其标为不可用，这样的信息变动就被 S-A 监听到了，S-A 就更新自己内存中 S-B-1 的服务信息
Watch模式
Conslu 核心
注册中心：Consul
什么是服务治理
什么是服务注册
Eureka两组件
actuator微服务信息完善
服务发现Discovery
概述
导致原因
关闭后效果
怎么禁止自我保护
eureka自我保护
https://github.com/Netflix/eureka/wiki
基础知识
peer（同伴）
Eureka注册中心的原理
单机故障
集群架构
Eureka：常见问题总结
Eureka：缓存细节以及生产环境的最佳配置
Spring Cloud : 如何优雅下线微服务？
源码
Eureka注册中心
服务节点是临时节点还是持久节点----临时节点
基本使用
基础知识和使用
客户端注册
zookeeper注册中心
AP(eureka)
CP(Zookeeper/Consul)
三个注册中心异同点
微服务：注册中心ZooKeeper、Eureka、Consul 、Nacos对比
注册中心比较
阐述一下你们的服务注册中心部署架构，生产环境下怎么保证高可用？
你们系统遇到过服务发现过慢的问题吗？怎么优化和解决的？
如果需要部署上万服务实例，现有的服务注册中心能否抗住？如何优化？
提供了了 ServiceRegistry 抽象
服务注册抽象
提供了了 DiscoveryClient 抽象
提供了了 LoadBalancerClient 抽象
客户发现抽象
Spring Cloud Commons 提供的抽象
服务注册发现
OpenFeign是什么
能干嘛
Feign和OpenFeign两者区别
总结
yml
OpenFeign超时控制
日志级别
OpenFeign日志打印功能
OpenFeign服务接口调用
例子
在使用微服务时，避免不了的就是各个微服务间的调用，各个微服务都是以HTTP接口的形式暴露自身服务的，因此在调用远程服务时就必须使用HTTP客户端。我们可以使用JDK原生的URLConnection、Apache的Http Client、Netty的异步HTTP Client，Spring的RestTemplate。但是，用起来最方便的还是要属Feign了。
简介
使用@FeignClient用于通知Feign组件对该接口进行代理(不需要编写接口实现)，使用者可直接通过@Autowired注入
Spring Cloud应用在启动时，Feign会扫描标有@FeignClient注解的接口，生成代理，并注册到Spring容器中。生成代理时Feign会为每个接口方法创建一个RequetTemplate对象，该对象封装了HTTP请求需要的全部信息，请求参数名、请求方法等信息都是在这个过程中确定的，Feign的模板化就体现在这里。
关键类参数介绍
深入理解Feign之源码解析
feign.hystrix.enabled=true
fallback / fallbackFactory
@FeignClient
Feign 支持Hystrix
服务间调用：Spring Cloud Feign
Spring cloud Ribbon是一个基于HTTP和TCP的客户端负载均衡工具，它是基于Netflix的Riboon实现的。Ribbon是客户端负载均衡器，这有别语例如Nginx服务端负载均衡器。Ribbon本身提供了不同负载均衡策略使用不同的应用场景。
客户端负载均衡和服务端负载均衡的区别
BaseLoadBalancer类是Ribbon服务均衡器的基础实现类，在该类中定义了很多关于负载均衡器的基础内容。
BaseLoadBalancer
getForObject方法/getForEntity方法
RestTemplate的使用
负载均衡+RestTemplate调用
集中式LB
进程内LB
LB(负载均衡)
com.netflix.loadbalancer.RoundRobinRule
com.netflix.loadbalancer.RandomRule
com.netflix.loadbalancer.RetryRule
WeightedResponseTimeRule
BestAvailableRule
AvailabilityFilteringRule
ZoneAvoidanceRule
替换使用
Ribbon核心组件IRule
轮询算法
RoundRobinRule
RandomRule
源码阅读
Ribbon负载均衡算法
客户端负载均衡：Spring Cloud Ribbon
zkui为用户提供可视化界面，方便导入导出配置；使用docker安装zkui比较方便（1）docker pull maauso/zkui（2）docker run -t -i -e ZKLIST='10.2.11.202:2181' -p 9090:9090 maauso/zkui
ZKUI
与GitHub整合配置
读取配置规则
Config服务端配置
Config客户端配置
Config客户端之动态刷新
spring cloud config
统一配置中心：zookeeper/spring cloud config
服务降级
服务熔断
服务限流
隔离
重要概念
解释
效果
注意:新版本Hystrix需要在主启动MainAppHystrix8001中指定监控路径
监控失败
访问
七色
一圈
一线
整图说明1
整图说明2
搞懂一个才能看懂复杂的
监控窗口如何看?
服务监控hystrixDashboard
缺陷原因
每个方法配置一个???膨胀
和业务逻辑混在一起???混乱
服务降级缺陷
服务降级使用
熔断是什么
熔断器的核心API如下图
熔断开关图示
熔断类型
熔断过程
断路器在什么情况下开始起作用
断路器打开之后
ALL配置
Hystrixl流程图（深入 Hystrix 执行时内部原理）
一个HystrixCommand的执行逻辑
hystrix案例
基础核心知识
Hystrix 更加细节的设计原则
Hystrix 的设计原则
请求熔断
依赖隔离
比如一个请求过来请求我userId=1的数据，你后面的请求也过来请求同样的数据，这时我不会继续走原来的那条请求链路了，而是把第一次请求缓存过了，把第一次的请求结果返回给后面的请求。
请求缓存
我依赖于某一个服务，我要调用N次，比如说查数据库的时候，我发了N条请求发了N条SQL然后拿到一堆结果，这时候我们可以把多个请求合并成一个请求，发送一个查询多条数据的SQL的请求，这样我们只需查询一次数据库，提升了效率。
请求合并
Hystrix特性
demo
小型电商网站的商品详情页系统架构
大型电商网站的商品详情页系统架构
基于Hystrip电商网站的商品详情页系统架构
利用 HystrixCommand 获取单条数据
利用 HystrixObservableCommand 批量获取数据
我们回过头来，看看 Hystrix 线程池技术是如何实现资源隔离的。
基于 Hystrix 线程池技术实现资源隔离
信号量机制
信号量简单 Demo
基于 Hystrix 信号量机制实现资源隔离
线程池与信号量区别
execution.isolation.strategy
command key & command group
command thread pool
command key & command group & command thread pool
其他
Hystrix 隔离策略细粒度控制
图示（上面特性--流程图）
步骤一：创建 command
步骤二：调用 command 执行方法
步骤三：检查是否开启缓存
步骤四：检查是否开启了断路器
步骤五：检查线程池/队列/信号量是否已满
步骤六：执行 command
步骤七：断路健康检查
步骤八：调用 fallback 降级机制
相关配置
实例 Demo
深入 Hystrix 断路器执行原理的配置
深入 Hystrix 执行时内部原理
线程池隔离技术的设计
Hystrix 应用线程池机制的场景
优缺点
接口限流 Demo
深入 Hystrix 线程池隔离与接口限流
实现 Hystrix 请求上下文过滤器并注册
command 重写 getCacheKey() 方法
controller 调用 command 查询商品信息
发起请求
删除缓存
基于 request cache 请求缓存技术优化批量商品数据查询接口
步骤一：本地缓存获取数据
步骤二：实现 GetBrandNameCommand
步骤三：CacheController 调用接口
基于本地缓存的 fallback 降级机制
基于 timeout 机制为服务接口调用超时提供安全保护
原理分析和使用(基于上面的系统)
如何做技术选型？Sentinel 还是 Hystrix？
Hystrix使用笔记
https://www.cnblogs.com/kingszelda/p/10312242.html
Hystrix源码分析
服务容错模式：舱壁模式、熔断器的异同点
Hystrix：普通Javaweb结合AOP使用
服务容错保护：Spring Cloud Hystrix
请求转发服务转发主要是对客户端的请求安装微服务的负载转发到不同的服务上
响应合并把业务上需要调用多个服务接口才能完成的工作合并成一次调用对外统一提供服务。
协议转换重点是支持 SOAP，JMS，Rest 间的协议转换。
数据转换重点是支持 XML 和 Json 之间的报文格式转换能力（可选）
安全认证1. 基于 Token 的客户端访问控制和安全策略2. 传输数据和报文加密，到服务端解密，需要在客户端有独立的 SDK 代理包3. 基于 Https 的传输加密，客户端和服务端数字证书支持4. 基于 OAuth2.0 的服务安全认证(授权码，客户端，密码模式等）
API 网关
Zuul1.x
Zuul
Route 是网关的基础元素，由 ID、目标 URI、断言、过滤器组成。当请求到达网关时，由 Gateway Handler Mapping 通过断言进行路由匹配（Mapping），当断言为真时，匹配到路由。
Route
Predicate 是 Java 8 中提供的一个函数。输入类型是 Spring Framework ServerWebExchange。它允许开发人员匹配来自 HTTP 的请求，例如请求头或者请求参数。简单来说它就是匹配条件。
Predicate
Filter
工作流程（原理）
核心
代码中注入RouteLocator的Bean
通过服务名实现动态
配置使用
Route Predicate Factories这个是什么东东
1.After Route Predicate
2.Before Route Predicate
3.Between Route Predicate
4.Cookie Route Predicate
5.Header Route Predicate
6.Host Route Predicate
7.Method Route Predicate
8.Path Route Predicate
9.Query Route Predicate
10.RemoteAddr Route Predicate
11.Weight Route Predicate
小总结
常用的Route Predicate
Spring Cloud Gateway的filter
AddRequestParameter
常用的GatewayFilter
案例
自定义全局GlobalFilter
自定义过滤器
Filter的使用
网关的作用:在使用微服务的过程中，随着服务数量的增加，会发现大量的ip和端口难以管理，此时网关结合注册中心就很好的解决了这个问题，对外只暴露网关的ip地址和端口，大大的提高了服务的安全性，当业务向某个应用发送请求时，只需请求网关，网关通过你携带的服务名进行请求转发，在转发前可以对请求的安全性进行校验，满足系统安全要求的请求才会被转发，否则拦截。当然不仅仅是安全性，还有其他一些操作，可以根据需求添加
作用
计数器算法
在算法实现方面，可以准备一个队列，用来保存请求，另外通过一个线程池（ScheduledExecutorService）来定期从队列中获取请求并执行，可以一次性获取多个并发执行。这种算法，在使用过后也存在弊端：无法应对短时间的突发流量。
漏桶算法
实现思路：可以准备一个队列，用来保存令牌，另外通过一个线程池定期生成令牌放到队列中，每来一个请求，就从队列中获取一个令牌，并继续执行。
RateLimiter：结合Spring Aop应用，以及SmoothBursty原理分析
令牌桶算法
令牌桶和漏桶对比
常见的限流算法
限流总并发/连接/请求数
限流总资源数
限流某个接口的总并发/请求数
限流某个接口的时间窗请求数
平滑限流某个接口的请求数
应用级限流
https://crossoverjie.top/JCSprout/#/distributed/Distributed-Limit
分布式限流
在Spring Cloud Gateway中，有Filter过滤器，因此可以在“pre”类型的Filter中自行实现上述三种过滤器。但是限流作为网关最基本的功能，Spring Cloud Gateway官方就提供了RequestRateLimiterGatewayFilterFactory这个类，适用Redis和lua脚本实现了令牌桶的方式。具体实现逻辑在RequestRateLimiterGatewayFilterFactory类中，lua脚本在request_rate_limiter.lua文件
限流篇
Spring Cloud Gateway
灰度发布
架构图示
第一个是高并发
第二个是如何优化
如果网关需要抗每秒10万的高并发访问，你应该怎么对网关进行生产优化？
说说生产环境下，你们是怎么实现网关对服务的动态路由的？
你们是如何基于网关实现灰度发布的？说说你们的灰度发布方案？
说说你们一个服务从开发到上线，服务注册、网关路由、服务调用的流程？
网关
是什么
为什么被称为总线
1.利用消息总线触发一个客户端/bus/refresh，从而刷新所有客户端配置
2.利用消息总线触发一个服务端ConfigServer的/bus/refresh端点，从而刷新所有客户端配置
对比
设计思想
SpringCloud Bus动态刷新全局广播
SpringCloud Bus动态刷新定点通知
总体架构
Git 配置更新 Bus 架构
SpringCloud Bus消息总线
为什么使用Cloud Stream
stream凭什么可以统一底层差异
INPUT对应于消费者
OUTPUT对应于生产者
Binder
Stream中的消息通信方式遵循了发布-订阅模式
Spring Cloud Stream标准流程套路
编码API和常用注解
标准MQ
分组消费与持久化
Spring Cloud Stream 以及 Binder 架构
深入对比
SpringCloud Stream消息驱动
为什么出现
https://dl.bintray.com/openzipkin/maven/io/zipkin/java/zipkin-server/
java -jar zipkin-server-2.12.9-exec.jar
http://localhost:9411/zipkin/
控制台
简化
术语
1.zipkin
SpringCloud Sleuth分布式链路跟踪
dubbo 和Spring Cloud
画一下你们系统的整体架构图，说说各个服务在生产环境怎么部署的？
你们系统每天有多大访问量？每个服务高峰QPS多少？压测过服务最大QPS吗？
如果系统访问量比现在增加10倍，你们考虑过系统的扩容方案吗？
你们生产环境的服务是怎么配置超时和重试参数的？为什么要这样配置？
如果出现服务请求重试，会不会出现类似重复下单的问题？
对于核心接口的防重幂等性，你们是怎么设计的？怎么防止重复下单问题？
画一下你们电商系统的核心交易链路图，说说分布式架构下存在什么问题？
针对电商核心交易链路，你们是怎么设计分布式事务技术方案的？
对于TCC事务、最终一致性事务的技术选型，你们是怎么做的？如何调研的？
具体实现
如果公司没有RocketMQ中间件，那你们如何实现最终一致性事务？
你了解RocketMQ对分布式事务支持的底层实现原理吗？
你们是用哪个开源框架实现的Redis分布式锁？能说说其核心原理么？
如果Redis是集群部署的，那么集群故障时分布式锁还有效么？
你们生产系统中有哪个业务场景是需要用分布式锁的？为什么呢？
对于ZooKeeper的羊群效应，分布式锁实现应该如何优化？
如果遇到ZooKeeper脑裂问题，分布式锁应该如何保证健壮性？
如果要实现ZooKeeper分布式锁，一般用哪个开源框架？核心原理是什么？
你们的分布式锁做过高并发优化吗？能抗下每秒上万并发吗？
淘宝和京东的库存是怎么实现的？能不能不用分布式锁实现高并发库存更新？
版本技术选型
1.版本选择
服务注册中心
服务调用
服务网关
服务配置
服务主线
https://cloud.spring.io/spring-cloud-static/Hoxton.SR1/reference/htmlsingle/
https://www.bookstack.cn/read/spring-cloud-docs/docs-index.md
Spring Cloud中文文档
Spring Cloud
https://docs.spring.io/spring-boot/docs/2.2.2.RELEASE/reference/htmlsingle/
Spring Boot
参考资料见官网
2.关于Cloud各种组件的停更/升级/替换
3.微服务架构编码构建
服务注册
Namespace+group+data ID三者关系？为什么这么设计？
配置中心
官网版本简化
架构图
注意
Nacos持久化配置解释
集群配置
Nacos集群和持久化配置(重要)
SpringCloud Alibaba Nacos服务注册和配置中心
和hystrix对比
特性
控制台使用
接入客户端注意
划分
sentinel
直接(默认)
关联
链路
流控模式
直接->快速失败
场景
预热
qps / 1 秒 = 每隔多少时间通过一个请求
排队等待
流控效果
流控规则
基本使用的概念
复习Hystrix
Sentinel的断路器是没有半开状态的
RT
异常比例
异常数
降级策略
降级规则
实现
异常
热点key限流
各项配置说明
系统规则
入门
按资源名称限流
按照Url地址限流
自定义限流
@SentinelResource
核心API
怎么玩
配置 4 个数据源：
数据源
添加Nacos业务规则配置
验证
规则持久化
SpringCloud Alibaba Sentinel实现熔断与限流
分布式事务问题
seata的分布式交易解决方案
Seata简介
Transaction ID(XID)
三组件概念
分布式事务处理过程-ID+三组件模型
处理过程
一个典型的分布式事务过程
再看TC/TM/RM三个组件
一阶段加载
二阶段提交
三阶段回滚
AT模式如何做到对业务的无侵入
过程
补充内容
红色的自己取名字
service模块
store模块
file.conf
3.seata-server-0.9.0.zip解压到指定目录并修改conf目录下的file.conf配置文件
4.mysql5.7数据库新建库seata
5.在seata库里新建表
6.修改seata-server-0.9.0\\seata\\conf目录下的registry.conf目录下的registry.conf配置文件
7.先启动Nacos端口号8848
8.再启动seata-server
Seata-Server安装
使用注意
SpringCloud Alibaba Seata处理分布式事务
Springcloud（微服务）
单体系统，所有功能模块 耦合在一个系统打包部署 独立单元 jar war只有一个进程
单体架构
架构风格 1：N=系统：多个服务每个服务独立部署每个服务高内聚 服务之间低耦合
其他架构风格：客户端 服务端组件架构 EJB分层架构 MVC面向服务架构 SOA
微服务架构
区别
通过服务进行组件化
围绕业务能力进行组织
智能端点和哑管
去中心化的治理
分散数据管理
基建自动化
设计时为故障做好准备
演化设计
微服务架构的特征
微服务技术栈
微服务和分布式数据管理问题
1.订单服务创建一个带有 NEW 状态的 Order （订单），发布了一个 “Order Created Event（创建订单）” 的事件。
2.客户服务消费 Order Created Event 事件，为此订单预留信用，发布 “Credit Reserved Event（信用预留）” 事件。
3.订单服务消费 Credit Reserved Event ，改变订单的状态为 OPEN。
事件驱动架构
使用本地交易发布事件
挖掘数据库交易日志
使用事件源
原子操作 Achieving Atomicity
问题
微服务：通信协议
微服务：幂等机制和解决方案
深入浅出Event Sourcing和CQRS
微服务：设计模式
从分布式一致性谈到CAP理论、BASE理论
微服务：如何做好服务拆分？
为什么大型互联网都需要网关服务？
系统架构演变：SOA、微服务架构的区别和联系
微服务：全链路压测和容量规划
微服务：监控体系，容器监控
微服务
控制反转
控制：对对象的创建和管理
反转：对对象的控制由程序员转变为框架
让spring来管理对象
核心目的
单例
降低耦合(类与类之间的依赖关系)
优点
单例对象适用AplicationContext在构建核心容器时，创建对象采用的是立即加载的方式，即配置文件一读取完，立马创建对象
多例对象适用BeanFactory在构建核心容器时，创建对象采用的是延迟加载方式，即什么时候通过Id获取对象，什么时候创建
顶层接口BeanFactory和ApplicationContext的区别
读取类路径下的配置文件
ClassPathXmlApplicationContext
读取电脑任意位置的配置文件
FileSystemXmlApplicationContext
用于使用新注解+配置类的方式代替xml配置文件时
AnnotationConfigApplicationContext
ApplicationContext常用实现类
IoC核心容器
在spring配置文件中用bean标签配置
创建的对象名
id
需要被管理的类的全路径
class
bean标签的属性
无参构造器
条件：需要工厂类，该工厂类中需要有静态方法
<bean id=\"factory\" class=\"com.wxs.factory.BeanFactory\" factory-method=\"静态方法名\" />
配置文件语法
当用spring容器调用getBean方法时会创建工厂类对象，并执行工厂类中的方法返回需要的对象并放入spring容器中
静态工厂
条件：需要工厂类，这个工厂类中需要有普通方法
<bean id=\"factory\" class=\"com.wxs.factory.BeanFactory\" />
<bean id=\"car\" factory-bean=\"factory\" factory-method=\"普通方法名\">
需要先创建工厂对象再调用工厂中的普通方法
实例工厂
IOC创建对象方式
条件：属性必须有setter方法
name：属性名
value：属性值，针对基本类型和String类型
ref：针对对象类型，指向的是bean标签的id属性的值
bean标签下<property>标签
setter注入
list类型语法
数组类型与list类型类似只是没有ref标签
<bean id=\"empService\" class=\"com.wxs.service.EmpService\"> <property name=\"list\"> <map> <entry key=\"\" value=\"\"></entry> </map> </property></bean>
map类型
<bean id=\"empService\" class=\"com.wxs.service.EmpService\"> <property name=\"p\"> <props> <prop key=\"\" value=\"\"></prop> </props> </property></bean>
properties类型
复杂注入(map、list、[]...)
<bean id=\"empService\" class=\"com.wxs.service.EmpService\"> <property name=\"list\"> <list> <value>基本类型和String类型</value> <ref bean=\"对象类型\"></ref> </list> </property></bean>
条件：必须要有构造器
name属性：属性名
value：值，针对基本类型和Stirng
ref：针对对象类型
bean标签下<constructor-arg>标签
有参构造器注入
条件：需要在配置文件中导入p的命名空间(spring提供的)，底层还是set方式，所以属性也必须有setter方法
p名称空间注入
DI(依赖注入)的方式
id属性：用来给对象命名
只要配置文件被加载，就会创建对象，创建的对象放在spring容器中，这个容器底层为map集合，key为bean标签的id值，value为这个对象
当调用容器的getBean方法的时候，总是获取到唯一的实例
service/dao需要单例模式
singleton
多例
当配置文件加载的时候不创建对象，当调用容器的getBean方法时，创建对象并返回，调用一次getBean则创建一次
action适合多例
proyotype
作用于web应用的请求范围
request
作用于web应用的会话范围
session
作用于集群环境的会话范围(全局范围)
globle-session
scope属性
当spring容器关闭的时候对象销毁
长时间不用则被GC回收
对象销毁时机
bean标签：在配置文件中用bean标签配置一个类
name属性：类的属性名
value：定义普通成员变量的值
ref：如果一个类中引用到其他类的对象，需要用此属性注入
***注意：在配置文件中给属性设置初始值需要提供该属性的setter方法
若需要给一个类中的成员变量赋初始值则需要在bean标签中定义property子标签
专门用于给list集合类型的成员变量赋初始值
<bean id=\"empService\" class=\"com.wxs.service.EmpService\"> <property name=\"list\"> <list> <value>11</value> </list> </property></bean>
格式
property子标签<list>
手动配置方式
半自动配置方式主要是将类与类之间的依赖关系用注解的方式实现
类的对象还是需要手动配置，但类的依赖关系用注解@Autowired自动实现，例如A类中引用了B类，在配置文件中用bean标签配置A，在A中用注解标记引用的B
***注意：Spring框架为了效率，默认在扫描类的时候不会扫描注解，所以默认情况下只加Autowired注解是无法自动注入的，需要在配置文件用<context:annotation-config/>进行配置
半自动配置方式
基本不用配置文件
在类上用@Component注解标记，类中的依赖关系用@Autowired注解标记
在配置文件中用<context:component-scan base-package=\"com.wxs\" />配置需要扫描的包
在全自动配置方式中，对于私有的成员变量，也无须提供setter方法，反射会自动打开访问权限强制访问
***注意：如果通过一个类型匹配到了多个实现类，则会报错，解决方式为在引用类型上添加@Qualifier(\"\")注解指明需要的类
Component：无法划分类的时候
Repository：一般用于标注dao层或者说标注数据库操作层
Service：业务层
Controller：控制层/表现层(springmvc替代servlet)
**以上四个注解没有区别，只是用于不同场景
Scope：定义类的单例多例
指定销毁方法
PreDestory
指定初始化方法
PostConstruct
四个创建对象的注解
针对基本数据类型和String类型
Value
该注解由Spring框架提供
按类型去找，如果找不到就是没有，如果找到多个就报错，解决方式是搭配Qualifier注解指明适用哪个注解
Autowired
该注解由JDK提供
先按名字去找，第一种是name属性配置名字@Resource(name = \"名字\")，如果没有指定名字则把变量名当作要寻找的属性名，如果再找不到，最后按类型去找
Resource
三个依赖注入的注解
全自动配置方式
IOC三种开发方式
写一个类，用新注解标注，可以让该类的作用和application.xml的作用一样
表名该被标注的类是一个配置类，但本质作用并不是标注它是一个配置类，而是加上这个注解之后，该类中的所有方法会被CGLib代理，方法会跟原来的方法完全不一样，这样就保证了对象的生命周期和作用域。如果不加该注解，在该类中用Bean注解照样好用，用AnnotationApplicationContext去容器取对象也好用，只不过如果该类中的一个创建对象的方法调用了另一个创建对象的方法，那么另一个对象将被创建多次，不能保证对象的单例，即作用域scope不能被保证
通过该注解告诉spring在创建容器时需要扫描的包
属性value，和xml配置文件中的<context:component-scan>标签中的basePackage属性作用一样
用于标注配置类中的方法，将方法的返回值对象存入spring容器中
name属性用于定义bean的id，当不写时，存入容器集合时key默认为方法名，值为对象
细节：当我们使用注解配置方法时，如果方法有参数，spring会自动去容器中找有没有可用的bean，查找的方式与@Autowired注解的方式一致
此时不再使用ClassPathXmlApplicationContext，而是要用AnnotationConfigApplication，并将该配置类的class对象传入
spring新注解
通过IO读取配置文件
利用反射创建对象：class.forName(配置文件中的全路径名)
如果是全自动模式，则通过IO读取配置文件读到的是包，然后再通过IO去扫描这个包下所有的类(包括子包)扫描的类如果由Component注解标记，则创建该类对象，如果没有，则忽略
重点是反射+IO
如何创建对象
扫描所有成员变量，如果成员变量带有自动注入注解，则从自己容器中寻找要注入的对象，利用反射对其进行注入，如果找到相应对象，暴力破解直接赋值，如果没找到，则报错
如何管理依赖关系
原理
面向切面编程思想：对共同内容进行抽取，在需要用到的地方用动态代理的方式进行插入，在不修改源代码的基础上，还能对源码进行加强
底层为动态代理：对目标类进行功能增强
缺点：需要直到要增强的方法的类才能继承
继承
缺点：需要有接口，这个接口下除了要增强的方法外别的方法也要实现
装饰者模式
需要接口但可以指定增强方法，不需要实现全部方法
参数列表：和目标对象相同的类加载器；目标类所有的接口；增强类(可以自定义增强类并实现InvlcationHandler接口并重写其内部方法，也可以在此处直接定义匿名内部类)
proxyPerson.run(); // 执行这个方法 invoke都会执行一遍 执行的内容就是针对该方法的增强
返回值 return 谁调用返回给谁 返回的内容就是最终值而不是需要增强的方法的返回值
通过if-else判断方法名来增强指定方法
细节
JDK
不需要接口，可以指定增强方法，但代码量比较大
该代理模式是用拦截器和过滤器的方式进行继承，对目标类的方法进行增强
CGLIB原理
CGLIB
动态代理模式
对目标类方法进行加强的方式
确定目标类(要被切的类，即需要被加强的类)，需要定义切入点，此处切入点为需要增强的方法
确定切面类，即用来切类的刀，需要定义增强后的方法
织入配置，把增强方法指定在切入点之前、之后、环绕、异常、最终 执行
配置文件
用<aop:before>标签配置
前置增强
用<aop:after>标签配置
在原方法执行结束后介入增强后的方法
后置增强
用<aop:around>标签配置，需要在增强后的方法中传参：ProceedingJoinPoint类型的对象，这个对象中包含着目标类需要增强的方法，需要在增强后的方法中调用pjp.proceed()方法，相当于调用原方法，在该方法前后需要写自己的业务逻辑实现环绕介入
环绕增强
用<aop:after-throwing>标签配置
在原方法发生异常时会介入，一般用于对数据库事务的处理
异常增强
用<aop:after-returning>标签配置
在需要增强的方法正确地返回之后执行
最终增强
织入时机
自由式
定义切面类，让其实现特定接口(五类织入时机)
确定目标类(被介入的类)，确定其切点
确定切面类(做介入角色的类)
<aop:config> <!-- 定义切点 即需要被增强的方法 --> <aop:pointcut id=\"empCut\" expression=\"execution(..........)\"></aop:pointcut> <!-- 定义切面 指向bean标签中的切面类 包含切点(指向上方的切点) --> <aop:advisor advice-ref=\"bean标签对应的切面类\" pointcut-ref=\"empCut\"></aop:advisor></aop:config>
定义的切面类需要实现MethodBeforeAdvice接口并实现befor方法
该方式底层会调用目标类中需要增强的方法，在该切面类中的before方法中只需要写自己的业务逻辑即可
定义的切面类需要实现AfterReturnAdvice接口并实现afterReturn方法
原方法返回值
Object returnValue
目标方法
Method method
目标方法执行需要的参数数组
Object[] args
目标对象，即被代理的类的对象
Object target
参数
切面类需要实现MethodInterceptor接口并实现invoke(MethodInvocation invocation)方法
切面类实现ThrowsAdvice接口，该接口是一个空接口，需要在该切面类中自定义名为afterThrowing(Exception e)方法
接口规范式
注解介入
AOP的三种方式
springmvc实际上是springframwork的一个模块，这个模块主要是对web的支持
springmvc是基于IoC和aop的
什么是springmvc
获取参数比较繁琐，如果类型不是字符串类型则需要进行类型转换，还需要判断是否为空
如果每个servlet对应一个请求，则会产生大量的servlet，如果一个servlet对应多个请求，则违反可单一原则
servlet缺点
springmvc提供了一个servlet，我们把所有的请求都发送给这个servlet，这个servlet我们称之为核心控制器
核心控制器在tomcat启动时就会创建，在其init方法中会读取配置文件并扫描指定的包，会为由@Controller注解标记的类创建对象，并把所有的由@RequestMapping注解标记的映射关系放到HandlerMapping中，键放注解的地址，值放方法
当在地址栏输入地址，核心控制器会根据资源路径从HandlerMapping中寻找要执行的方法，找到后并调用
在控制类的方法中处理请求和响应，用return实现请求转发(携带的参数放到ModelMap中)和重定向(在返回的字符串前加redirect)
作用：帮我们找到对应的controller
依赖BeanNameUrlHandlerMapping类
传统开发方式，即配置文件方式
AnnotationMethodHandlerAdapter（过时的注解开发方式）
注解开发方式，已过时类
RequestMappingHandlerAdapter（最新版本的注解开发方式）
注解开发方式，最新类
在springmvc内部配置文件中，注解开发方式配置的还是过时的注解驱动类，需要在springmvc配置文件中用<mvc:annotation-driven/>标签配置新版注解驱动类
HandlerMapping
处理器映射器
作用：帮我们找到响应的方法
方法返回ModelAndView
处理器适配器
将结果渲染成页面
视图解析器
三大核心组件
标记控制类，该类拥有处理请求的能力
标注方法，定义请求路径
窄化映射，可以定义到controller类上，隔离各个控制类中的方法
标注这个方法处理请求的地址，支持传数组，可以响应多个请求
value和path属性
设置接收的请求的请求方式
method
@RequesMapping
设置跨域访问
传统方式需要设置响应头setHeader(\"Access-Control-Allow-Origin\
同源指的是同一个服务器
如果a服务器向b服务器发送ajax请求，b服务器接收并响应数据，在默认情况下，a服务器的ajax拒绝接收b服务器的响应，所以需要在b服务器端设置跨域访问，解决跨域错误问题
浏览器的同源策略
@CrossOrigin
用于绑定url的占位符，例如：在请求的url中，/emplist/{empId}，{empId}就是一个占位符，在参数列表中想要对应占位符的参数前用该注解标注，该注解中的值应当与占位符的值一致。url支持占位符是在spring3.0以后引入的
用于实现restful风格
如果想要实现restful风格，则需要将web.xml文件中核心控制器的请求路径设置为/，但此时将会把所有的静态文件例如js、css等也作为请求发送到核心控制器并去找相应的方法执行，此时就会访问不到静态资源，所以释放静态资源
在springmvc配置文件中配置静态资源，用<mvc:resources location=\"请求地址例如：/js/(以js开头的请求)\" mapping=\"映射位置例如 ：/js/**(项目下js文件夹下所有的文件的子文件)\" />
用占位符的方式接收参数，占位符的参数名叫啥，前端name应该叫啥
RequestMapping(\"/delete\")localhost：8080/delete?id=10
传统风格
RequestMapping(\"/delete/{id}\")restful风格：localhost：8080/delete/10
restful风格
@PathVaribale
被该注解标注的方法会先执行
适用场景：当前端提交表单，带着表单数据向控制类中的某个方法发送请求，但表单数据并不是一个完整的JavaBean对象的数据，此时可以定义一个新的方法，用该注解标注，那么在执行对应请求方法时会先执行该方法，该方法也可以从请求中获取请求参数，可以在该方法中通过请求参数从数据库查询完整数据，并将最后JavaBean对象返回，这样数据就会完整，另一种方式是无返回值方法，可以参参数列表定义一个map集合，将最后的JavaBean放入map集合中，在对应的请求方法的参数列表中也用ModelAttribute注解标注参数，并在注解中给出放入map集合的key
在spring4.2.x版本及以后出现了复合注解
@GetMapping(\"/\")
直接指明请求方式
@PostMapping
@Controller和@ResponseBody的符合注解
注解语法糖
控制类中的注解
response
ModelMap
默认参数绑定
在对应方法的参数列表中定义请求参数
类型写你需要的，底层会帮你转，要求参数列表中的参数名与请求参数名一致
mvc会反射你的方法参数列表，根据参数名去找请求参数对应的值，会尝试将数据转成你想要的类型，如果不能转成你想要的，抛异常
基本数据类型
可以使用对象接收，在参数列表定义对象类型，mvc可以直接自动封装成对象，前提是对象的属性名跟请求参数名一致
bean方式
绑定包装的bean
一般用于批量删除，在前端定义复选框，复选框的名称相同且和控制类对应方法的数组名一致，springmvc可自动帮你获取参数
数组绑定
应用场景不多，一般用于批量修改，前端修改n条数据，提交多个对象到后台，但只能支持向对象中接收集合，即控制类对应方法中需要定义一个集合，接收参数时会接收到该对象的集合中，而且要求前端name属性为集合名[下标].对象属性名在jsp页面的c:foreach标签中的status属性可以获取遍历的集合的每次索引值
集合绑定
@RequestParam注解，标记参数列表
指明要获取的参数名，用于跟请求参数名匹配
value/name
默认为true，要求请求参数必须有，如果没有，则出现400，设为false则可以没有
required
用于定义参数列表的默认值，如果请求参数没有传来，则默认值生效
defaultValue
注解属性
当前端参数出现springmvc无法自动转换的参数时，例如时间，可以使用自定义转换器
实现convert(T t)方法并返回想要的
在注册新版处理器映射器，处理器适配器驱动时，将自定义转换器配置<mvc:annotation-driven conversion-service=\"自定义转换器id\"/>
配置自定义转换器<bean id=\"\" class=\"org.springframework.format.support.FormattingConversionServiceFactoryBean\"> <property name=\"convers\"> <set><bean class=\"自己定义的转换器类的全限定名\"/></set> </property></bean>
将自定义转换器配置到springmvc容器中
将spring不支持的绑定类型参数上用@DateTimeFormat(pattern = \"yyyy-MM-dd HH:mm:ss\")
注解方式解决mvc不支持的参数绑定
自定义转换器
参数绑定
在方法中直接return页面地址默认就是请求转发
在返回的页面地址字符串前加redirect:则为重定向
例如
请求转发携带的参数需要放到ModelMap中
@RequestMapping(\"/listEmp\")public String ListEmp(ModelMap modelMap) { List list = empMapper.listEmpDept(); modelMap.put(\"empList\
返回String类型的地址
在spring配置文件中配置前缀和后缀
配置语法
将配置文件的前缀和后缀与控制类中方法return的字符串拼接即可得到想要的路径
配置视图解析器
<bean class=\"org.springframework.web.servlet.view.InternalResourceViewResolver\"> <!-- 配置前缀 --> <property name=\"prefix\" value=\"/WEB-INF/pages/\"/> <!-- 配置后缀 --> <property name=\"suffix\" value=\".jsp\"/></bean>
springmvc如何响应
框架提供的有跟过滤器功能类似但更强大的拦截器
在controller类中方法执行前被拦截
在controller类的方法执行之后但在视图解析前被拦截
方法执行完且视图解析之后拦截
拦截器会拦截Controller类中方法的调用
1. 定义一个类实现HandlerInterceptor接口
该接口中的方法为默认方法，每个方法都有不同的拦截时机
在controller的方法被调用之前执行该方法
在方法被调用视图解析之前调用
在方法执行完视图解析之后调用
2. 实现该接口中的方法，所有的方法返回值为boolean，真放行，假拦截
<mvc:interceptors> <mvc:interceptor> <!-- 配置哪个方法需要拦截 --> <mvc:mapping path=\"/**\"> <!-- 配置哪个方法不需要拦截 --> <mvc:exclued-mapping path=\"\"> <!-- 设置拦截器类路径 --> <bean class=\"拦截器类全限定名\"> </mvc:interceptor></mvc:interceptors>
3. 在配置文件中配置拦截器，可以配置多个拦截器，哪个在上边，最先执行哪个拦截器
快速入门
两个兰拦截器，1拦截器配置在前，2拦截器配置在后
执行顺序
浏览器通过input标签将需要上传的文件自动读入到内存，当提交表单的时候，会将该文件发送到后台核心控制器，在请求中会携带这个文件，此时会调用到文件解析器，文件解析器会解析请求对象，将请求对象的文件解析出来返回给核心控制器
核心控制器再调用处理器映射器，找到相应的控制类的方法，通过参数绑定的形式，绑定给该方法，该方法的参数类型必须是MultipartFile类型，参数名必须要和input标签中的name属性保持一致，最后调用该MultipartFile对象的方法进行上传
springmvc文件上传原理
文件解析器配置
1. 表单提交方式一定是post
2. 表单的enctype的值一定是multipart/form-data
3. input的type一定是file
传统表单方式
1. type：post
2. data：FormData
3. processData: false
ajax方式
页面要求
1. 需要两个jar包commons-io.jar和commons-fileupload.jar
2. 在ppringmvc配置文件中配置文件解析器
3. 绑定参数类型一定为MultipartFile，参数名字要和input的name属性的值保持一致
springmvc要求
前后端要求
都基于mvc设计模式
底层都是对ServletAPI的封装
处理请求的机制都是一个核心控制器
相同点
springmvc的入口是Servlet，struts2的入口是Filter
springmvc的最小单元是方法，是基于方法设计的，struts2的最小单元是基于类，每次执行都会创建一个动作类，所以mvc更快
springmvc使用更简洁，发送ajax更方便
s2的OGNL表达式使页面开发效率更高，但执行效率没有并没有比JSTL有所提升
springmvc和struts2优劣
springmvc
我们使用DataSourceTransactionManager这一实现类 主要针对dbutils和jdbcTemplate 对jdbc的封装这个实现类就是一个切面类
PlatformTransactionManager 平台事务管理器 是一个接口 定义了开启事务、提交事务、回滚的方法
事务的隔离级别
事务的超时时间
事务的是否只读
事务的传播行为
TransactionDefinition：定义事务参数的接口
查看当前事务是否完成
查看是否为新事务
查看是否回滚
TransactionStatus：事务运行状态接口
API方式/硬编码
事务包spring-tx.jar
AOP联盟
aspectj.jar
spring-aspects.jar
事务依赖包
jar包
<bean id=\"事务管理器名\" class=\"事务类全路径\"> <property name=\"\" ref=\"bean标签中的数据源\"></bean>
细节：需要为事务配置一些事务参数：是否只读、超时时间、传播行为(标签)用<tx:advice transaction-manager=\"bean标签中配置的平台事务管理器\
确定切面类即配置事务管理器
<tx:advice id=\"事务名\" transaction-manager=\"需要的事务管理器名\"> <tx:attributes> <!-- 需要进行事务管理的方法 --> <tx:method name=\"方法名\"/> </tx:attributes></tx:advice>
配置声明事务即切面
用事务作为切点
配置织入
声明式/配置文件式
注解
spring事务管理
程序的入口为main
junit内部集成了一个main方法
当执行时，会利用反射判断该测试类有没有被@Test标注的方法
如果有，.invoke执行该方法
junit单元测试中没有main方法也能执行
在执行测试方法的时候，junit根本不知道我们是否使用了框架，所以在执行的时候根本不会为我们通过配置文件或者配置类来创建spring容器
junit不会管我们是否用框架
所以，在用junit测试的时候根本没有ioc容器，就算使用Autowired方法也不会有效果
在spring下junit的问题
导入spring整合junit的jar包--->spring-test.jar
使用junit提供的一个注解，把原有的main方法替换了，替换成spring自己的main@RunWith(SpringJUnit4ClassRunner.class)
告知spring运行器，spring和ioc创建是基于xml还是注解，并说明位置用@ContextConfiguration--->locations属性：指定xml文件位置，加上classpath关键字，表示该文件在类路径下 classes属性：指定配置类所在位置
整合思路
当我们用spring5.x版本的时候，要求junit版本在4.12及以上版本
spring整合junit
开发效率较高
每次请求都是整个页面刷新，当页面数据量大，用户设备老旧或者网速较差，会出现页面卡顿问题以至于交互效果较差
执行效率与交互效果低
如果有多个前端页面例如手机版、电脑版、iPad版，那得写多套控制层，较难
不灵活，解决多端变化问题较难
jsp开发模式
后台一律响应数据(json格式)而不响应页面，前端利用前端语言和后台的网络接口进行接收数据和显示
只需要写一套后台，不同前端用不同方式与后台交互
灵活，易于解决多端变化问题
开发效率较低
缺点
前后端分离开发模式开发前需要先设计文档，规定后台与前端所需要接口和参数的标准格式，以便于前后端同时开发且不容易出现前端调用后台接口出问题的情况
协议相同、ip相同、端口号相同
同源
做一个假网站，里面用 iframe 嵌套一个银行网站 http://mybank.com。
把 iframe 宽高啥的调整到页面全部，这样用户进来除了域名，别的部分和银行的网站没有任何差别。
这时如果用户输入账号密码，我们的主网站可以跨域访问到 http://mybank.com 的 dom 节点，就可以拿到用户的账户密码了。
DOM 同源策略：禁止对不同源页面 DOM 进行操作。这里主要场景是 iframe 跨域的情况，不同域名的 iframe 是限制互相访问的。
XMLHttpRequest 同源策略：禁止使用 XHR 对象向不同源的服务器地址发起 HTTP 请求。
同源策略
response.setHeader(\"Access-Control-Allow-Origin\
request.getHeader(\"Origin\")
该服务器路径可以通过请求对象动态获取
在后端设置响应头
在每个Controller类上加@CrossOrigin注解，该注解允许请求服务器默认为*
但是当前端设置为允许跨域携带参数后不允许将跨域访问路径设为*，虽然该注解可以设置路径，但需要在每个注解中设置跨域请求服务器路径，所以该方式不太方便
或者通过注解设置
在mvc.xml配置文件中配置拦截器
将该拦截器设置在所有拦截器的最上方，所有请求来之后都先被该拦截器拦截
在拦截器类中为response设置响应头response.setHeader(\"Access-Control-Allow-Origin\
通过拦截器设置
1. 设置后台允许接受跨域请求
在ajax请求中设置属性
在前端页面设置xhr对象的属性
XHR原生对象的withCredentials是用于跨域请求的，默认为false如果想要跨域请求并携带数据则需要将其打开
***在这种可携带数据的跨域模式下不可以设置为*
2. 设置前端允许跨域请求携带数据
在拦截器类中设置响应头
response.setHeader(\"Access-Control-Allow-Credentials\
3. 后台允许跨域请求携带数据
解决方案
跨域问题跨域带数据
前后端分离
开发模式
核心控制器路径，此处的url-pattern如果是/则指的是除jsp文件以外的所有请求都包含，/*则包含jsp
核心控制器创建时机
核心控制器需要的配置文件
配置核心控制器
当服务器启动时，该监听器会创建spring容器对象
配置监听器
该参数指向spring配置文件(该配置文件用于整合spring、mybatis)，监听器会加载该配置文件，将配置文件中的数据源、对象以及mapper扫描器创建
配置全局参数
在web.xml中配置
mybatis.xml(可有可无)，一般在该文件下配置settings和typeAliases，不过在配置sqlFactoryFactoryBean时也可以配置别名
数据源(druid)
<property name=\"typeAliasesPackage\" value=\"com.wxs.entity\">
别名
在配置sqlSession工厂时，通过property标签，让name值为mapperLocationsvalue值为classpath:com/wxs/mapper，这里需要使用斜线
用这种方式可以扫描项目下任意路径，可以解决mapper映射器文件和接口不在同意路径下的问题
配置mapper扫描器
sqlSessionFactory
<bean class=\"org.mybatis.spring.mapper.MapperScannerConfigurer\">
在该bean标签下配置sqlSessionFactoryBean，因为mapper接口的底层还是需要由sqlSession得到的
配置需要扫描的包
mapper扫描器
applicationContext-dao.xml
持久层(dao)
事务
包扫描器(主要针对@Service注解)
applicationContext-service.xml
业务层
配置处理器适配器、处理器映射器最新驱动
<mvc:annotation-driven/>
注解驱动版本
包扫描器，主要针对@Controller注解
以setter方式注入前缀和后缀
异常处理器，文件解析器，拦截器
springmvc.xml
web层(有mvc支持)
spring容器(配置文件)与springmvc容器(配置文件)是父子容器关系在这两个容器中都只能出现一个<context:property-placeholder location=\"\">标签加载文件，且子容器可以访问父容器加载到的配置文件，而父容器不能访问子容器加载的文件
***父子容器关系
ssm整合
Spring详细配置版
Spring 全家桶
0 条评论
回复 删除
下一页
