Spring框架知识点

今天是圣诞节圣诞老人给我送了个系统bug，24号加班到晚上12点多在便利店买了杯暖柚发现有便利店真好，我还可以喝到暖暖的饮料，最近加班太多，原本今天请假休息、没想到圣诞老人给我送了礼物O(∩_∩)O哈哈~

昨天系统迁移改造，修改的地方没有测试全面，导致生产功能报错，中午还没缓过来呢，就找vpn连接看问题，发邮件打版本，脑袋很沉、思考缓慢感觉我要挂了O(∩_∩)O哈哈~、最近思考了一下，有些东西记不住了感觉就在嘴边就是说不出来、忘了需要整理一下。给自己立个flag。我知道自己哪里不知道的我都要知道。也就是不明白的要去研究，研究不明白的就去问，所有的欲望和无知都是我前进的动力。 使我痛苦者使我进步。

首先理解和复习一下框架在需要的时候可以进行查阅进行整理1、Spring框架、2、Java中的锁机制 、3、分布式事务框架机制、4、Jvm、5、Collection接口是 (java.util.Collection)、6、redis 底层结构是怎么实现的、7、CurrentHashmap 是怎么扩容的  jdk1.7、1.8区别 （红黑树实现）9、mysql的索引、10、联合索引查询是否有效、数据库事务隔离级别、11、线程的生命周期、线程池的7个参数理解、12、mongdb数据库的重要知识点、13、kafka知识点  14、rocketMq知识点 15、jdk1.8新特性实战 16、SpringBoot、17、SpringCloud。

1、Spring框架知识点：(官网地址：Spring | Home)

 1.1、首先介绍：是一个开源框架，是Rod Johnson发起。Spring是为了简化企业开发的框架，使用Spring开发可以将Bean对象交给Spring对象来管理，这样使得很多复杂的代码在Spring中开发会变得非常的优雅和简洁降低代码的耦合度的框架，》是基于pojo的轻量级和最小的侵入式编程；》通过依赖注入和面向接口实现松耦合；》基于切面的编程；基于切面和惯例进行声明式编程；(切面是什么呢？可以理解为一个方面 ）；》通过切面和模板式编程减少代码的侵入性。

查看官网Spring里有很多项目框架，我这里说的是-spring-framework5.x

Spring框架采用是分层结构：根据不同的功能划分的这些模块可根据作用分为DataAccess/Integration、 web、Aop、aspests、Messageing、instrumentation、core、 Container、test

DataAccess/Integration

数据访问 / 集成层包括 JDBC 、 ORM 、 OXM 、 JMS 和 Transactions 模块，具体介绍如下。 提供了一个 JDBC 的抽象层，大幅度减少了在开发过程中对数据库操 作的编码。 ORM 模块：对流行的对象关系映射 API ，包括 JPA 、 JDO 、 Hibernate 和 MyBatis 提

供了的集成。 OXM 模块：提供了一个支持对象 /XML 映射的抽象层实现。 JMS 模块：指 Java 消息服务，包含的消息生产和消费的处理。 Transactions 事务模块：支持编程和声明式事务处理。

 WEB   

spring-web、spring-webmvc、spring-websocket 和 spring-webflux 组成

1、Spring-web 模块：提供了基本的 Web 开发集成特性，例如多文件上传功能、使用

的 Servlet 监听器的 IoC 容器初始化以及 Web 应用上下文

2、Spring-webmvc 模块：也称为 Web-Servlet 模块，包含用于 web 应用程序的 Spring MVC

和 REST Web Services 实现。 Spring MVC 框架提供了领域模型代码和 Web 表单之间

的清晰分离，并和  Spring Framework 的所有其他功能集成。

3、Spring-websocket 模块： Spring4.0 以后新增的模块，它提供了 WebSocket 和 SocketJS

的实现。

4、Spring-webflux 模块：是一个新的非堵塞函数式 Reactive Web 框架， 可以用来建

立异步的， 非阻塞，事件驱动的服务， 并且扩展性非常好

*Core Container

Core Containe是Spring 的核心容器是其他模块建立的基础，由 Beans 模块、Core 核心模块、Context 和 Expression Language 表达式语言模块组成的。

Beans 模块：提供了 BeanFactory ，是工厂模式的经典实现， Spring 将管理对象称 为 Bean 。 Core 核心模块：提供了 Spring 框架的基本组成部分，包括 IoC 和 DI 功能。 Context 上下文模块：建立在核心和 Beans 模块的基础之上，它是访问定义和配 置任何对象的媒介。ApplicationContext 接口是上下文模块的焦点。 Expression Language 模块：是运行时查询和操作对象图的强大的表达式语言。是对 JSP2.1 规范中规定的统一表达式语言（ Unified EL ）的扩展。

1.2、SpringIOC容器介绍

 1.2.1、  ioc(inversion of control)思想，是指在程序开发中对象实例的创建不在由调用者管理，而是由Spring容器创建，Spring容器会负责控制程序之间的关系，而不是由程序代码直接进行控制，控制权由之前的代码控制放到了Spring的容器中，控制发生了反转，这个就是Spring的IOC的思想，ioc容器是一个依赖注入容器，ioc容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖，应用程序，无需直接在代码中new相关的对象，应用程序由IOC容器进行组装，就像Spring中的BeanFactory对象。Spring中管理的对象叫做Bean对象，一个Spring的Bean对象可以是任何形式的pojo.

SpringIOC提供了两种容器类型：Beanfactory、 ApplicationContext

    BeanFactory：基础的容器类型，它由 org.springframework.beans.facytory.BeanFactory 接口定义，并提供了完整的 IoC 服务支持。BeanFactory 就是一个管理 Bean 的工厂，它主要负责初始化各种 Bean，并调用它们的生命周期方法。

   ApplicationContext:是BeanFactory的子接口，叫做应用上下文，该接口的全路径 为 org.springframework.context.ApplicationContext，它不仅提供了BeanFactory的所有功能，还添加了对国际化、资源访问，事件传播、等方面的良好支持。比较常用的有两个实现类1.ClasspathXmlApplicationContext,该类从类路径Classpath 寻找制定的xml文件位置，并装载完成ApplicationContext的实例化工作，ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocationPath);（像springboot集成框架里注解初始化等也是。）configLocationPath为了指定加载配置文件的位置。2.SystemXmlApplicationContext  该类从指定的文件系统路径中寻找指定的xml配置文件，找到并装载完成applicationContext的实例化工作，ApplicationContext applicationContext = new FileSystemXmlAplicationcontext不从类路径中读取配置文件。而是通过参数指定配置文件的位置。他可以获取类路径之外的资源。如d:/webroot/applicationContext.xml ,

ioc容器获取对象的方法，通过构造方法获取，get方法获取，对于 Spring IOC 容器而言我们更多的是使用它的依赖注入。 Spring 创建对象的过程叫 做 IOC,创建对象时给对象属性赋值叫做 DI可以理解为是同一个事情。为了分清这个事情介绍一下

DI（依赖注入）：是指在SpringIoc容器的创建对象的过程中，将依赖的对象通过配置进行注入，我们可以通过依赖注入的方式来降低对象的耦合度，在软件过程中对象之间的耦合度就是对象之间的依赖性，耦合越高维护的成本就越高，因此对象的设计应该是耦合度越低越好。依赖关系：是一种使用的关系, 即一个类的实现需要另一个类的协助, 所以要尽量 不使用双向的互相依赖类的关系。聚合关系：是整体与部分的关系.如车和轮胎是整体和部分的关系. 聚合关系是关联关系的一种，是强的关联关系；关联和聚合在语法上无法区分，必须考察具体的逻辑关系。在使用依赖注入时，如果注入的是 Bean 对象，那么要求注入的 Bean 对象与被注入的 Bean 对象都需要 Spring IOC 容器来实例化。使用的方式是，使用构造方法或set方法进行注入

1.3、代理模式和Aop编程：

代理模式就是类似于我们通过中介去买卖房子，客户端不直接调用对象，通过代理类去调用对象。买房子就是客户类，卖房子就是委托类。

1.3为什么使用代理模式呢？

1、隔离作用：在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类 对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。

     开闭原则：代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额 外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合 代码设计的开闭原则。

2、代理模式的优点：

#代理模式能将代理对象与真实对象被调用的目标对象分离。

#一定程度上降低了系统的耦合度，扩展性好。

#保护目标对象。

#增强目标对象。

3、代理模式的缺点：

#  代理模式会造成系统设计中类的数目的增加。

# 在客户端和目标对象增加一个代理对象，会造成请求处理速度变慢

#  增加了系统的复杂度。

代理模式可以分为两种：静态代理、动态代理。

  静态代理模式分为三个部分：

 1、公共的接口，2、被代理的对象、3、代理对象

public interface Intermediary  {

void saleHouse ();

}

  创建被代理角色

public class AlenSellers implements Intermediary {

@Override

public void saleHouse () {

System. out .println( " AlenSellers  正在卖房 " );

}

}

  创建代理角色

public class StaticProxyIntermediary implements Intermediary {

private Intermediary itd ;

public StaticProxyIntermediary (Intermediary  itd ){

this . itd = itd ;

}

@Override

public void saleHouse () {

System. out .println( " 向房客卖房子、完成卖房！ " );

this . itd . saleHouse ();

System. out .println( " 完成卖房售后服务 " );

}

}

  创建测试类

public class StaticProxyTest {

public static void main(String[] args) {

Intermediary itd = new AlenSellers ();

StaticProxyIntermediary staticProxyIntermediary = new StaticProxyIntermediary (itd);

staticProxyIntermediary . saleHouse ();

}

}

   动态代理：

  1、Jdk的proxy类实现动态代理   

   

动态代理的实现

在动态代理中分为两种实现方式：

使用 JDK 的 Proxy 类实现动态代理

使用 CGLIB 实现动态代理

使用 JDK 的 Proxy 类实现动态代理

  创建业务接口

public interface JdkProxyIntermediary {

void saleHouse ();

}

  创建接口实现类

public class JdkProxy AlenSellers implements JdkProxyIntermediary {

@Override

public void saleHouse () {

System. out .println( " Alen 正在卖房子 " );

}

}

  创建生成代理对象的工厂

public class JdkProxyFactory {

/**

* 动态生成代理对象

*/

public static Object getProxyBean(Object target){

Class clazz = target.getClass();

MyAspect myAspect = new MyAspect();

// 在 JDK 中动态生成代理对象的方法

return Proxy. newProxyInstance (clazz.getClassLoader(),

clazz.getInterfaces(), new InvocationHandler() {

/**

* 动态生成代理对象中的方法。

* @param proxy 动态生成的代理对象

* @param method 目标方法的方法对象

* @param args 传递到目标方法中的参数列表

* @return

* @throws Throwable

*/

@Override

public Object invoke(Object proxy, Method method, Object[]

args) throws Throwable {

myAspect .before();

Object obj = method.invoke( target ,args);

myAspect .after();

return obj;

}

});

}

  创建切面对象

public class MyAspect {

public void before(){

System. out .println( " 带领房客看房。。。卖房完成签署卖房协议 " );

}

public void after(){

System. out .println( " 售后服务哈哈。 " );

}

}

创建测试类

public class JdkProxyTest {

public static void main(String[] args) {

JdkProxyIntermediary jdkProxyIntermediary = new JdkProxy AlenSellers ();

JdkProxyIntermediary  jd1  = (JdkProxyIntermediary ) JdkProxyFactory.getProxyBean(jdkProxyIntermediary );

jd1. saleHouse ();

}

}

2、使用CGLIB实现动态代理

CGLIB （ Code Generation Library ）是一个高性能开源的代码生成包，它被许多框架所使 用，其底层是通过使用一个小而快的字节码处理框架 ASM （ Java 字节码操控框架）转换字节码并生成新的类。因此 CGLIB 要依赖于 ASM 的包。 JDK 的动态代理机制只能代理实现了接口的类，而对于没有实现接口的类就不能使用 JDK 的 Proxy 类生成代理对象， cglib 是针对类来实现代理的，他的原理是对指定的目标类生 成一个子类并通过回调的方式来实现增强，但因为采用的是继承，所以不能对 final 修饰的 类进行代理。（jar包：cglib.jar、asm.jar ）

public interface CglibProxyIntermediary {

void saleHouse ();

}

  创建接口实现类

public class CglibProxyAlenSellers   implements CglibProxyIntermediary {

@Override

public void saleHouse () {

System. out .println( "  ALEN在卖房子 " );

}

}

  创建生成代理对象的工厂

public class CglibProxyBeanFactory {

public static Object getProxyBean(CglibProxyIntermediary  idt ){

CglibMyAspect myAspect = new CglibMyAspect();

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(idt .getClass());

enhancer.setCallback( new MethodInterceptor() {

/**

*

* @param o 代理对象的引用

* @param method 目标对象的方法对象

* @param objects 目标方法的参数列表

* @param methodProxy 目标方法的方法对象的代理对象

* @return

* @throws Throwable

*/

@Override

public Object intercept(Object o, Method method, Object[]

objects, MethodProxy methodProxy) throws Throwable {

myAspect .before();

Object obj = method.invoke(idt ,objects);

myAspect .after();

return obj;

}

});

return enhancer.create();

}

}

创建切面

public class CglibMyAspect {

public void before(){

System. out .println( " 带领客户看房了，客户卖房子签署售房协议！ " );

}

public void after(){

System. out .println( " 售后服务 " );

}

}

  创建测试类

public class Test {

public static void main(String[] args) {

CglibProxyIntermediary idt = new CglibProxyIntermediary ();

CglibProxyIntermediary idt1 = (CglibProxyIntermediary ) CglibProxyBeanFactory.getProxyBean(idt);

idt1. saleHouse ();

}

}

AOP编程：

1.1 什么是 AOP

AOP 的全称是 Aspect Oriented Programming ，即面向切面编程，它将业务逻辑的各个部 分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。

AOP 采取横向抽取机制，取代了传统纵向继承体系的重复性代码，其应用主要体现在 事务处理、日志管理、权限控制、异常处理等方面。 目前最流行的 AOP 技术有两个，

分别为 Spring 框架的 AOP 和 AspectJ 框架。

1.2 什么是面向切面编程

把一个个的横切关注点放到某个模块中去，称之为切面。每个切面影响业务的一种功能， 切面的目的就是为了功能增强，将需要增强的方法做成切面，实现对业务的增强，就是面向切面编程。

面向切面编程的目的：将与业务本身无关，却被业务模块所共同调用的功能代码封装成 切面，以减少系统的重复代码，降低耦合，提高可扩展性。

面向切面编程的优势：把多个方法前或 后的共同代码抽出来，使用动态代理机制来控 制，先执行抽离出来的代码，再执行每一个真实方法。

为了更好地理解 AOP ，需要了解这些专业术语、主要包含：

AOP：Joinpoint、Pointcut、Advice、Target、Weaving、Proxy 、 Aspect

Joinpoint（连接点）：指那些被拦截到的点，是指应用在执行过程中能够插入切面的一个点

Pointcut（切入点）：指要对哪些Joinpoint进行拦截，即被拦截的连接点。

Advice（通知）：指拦截到Joinpoint要做的事情要对其切入点进行增强的内容。

   1、 org.springframework.aop.MethodBeforeAdvice（前置通知）   在调用目标方法之前自动执行的通知称为前置通 知，可以应用于权限管理等功能

   2、org.springframework.aop.AfterReturningAdvice（后置通知）   在调用目标方法之后自动执行的通知称为后置通 知，可以应用于关闭流、上传文件、删除临时文件等功能。

   3、org.aopalliance.intercept.MethodInterceptor     （环绕通知）    在调用目标方法前后自动执行的通知称为环绕通知，可以应用于日志、事务管理等功能。

   4、org.springframework.aop.ThrowsAdvice            （异常通知）    在方法抛出异常时自动执行的通知称为异常通知， 可以应用于处理异常记录日志等功能。

Target（目标）：指代理的目标对象。

Weaving （织入）：指把增强代码应用到目标上，生成代理对象的过程，

proxy（代理）：指生成的代理对象。

Aspect（切面）：切入点和通知的结合体。

*AspectJ 框架*

AspectJ 框架简介

AspectJ 是一个基于 Java 语言的 AOP 框架。在 Spring 2.0 以后，新增了对 AspectJ 框 架的支持。在 Spring 框架中建议使用 AspectJ 框架开发 AOP 。

1、前置通知 (before) ：在调用目标方法之前自动执行

2、后置通知 (afterReturning) ：在调用目标方法之后自动执行

3、环绕通知 (around) ：在调用目标方法之前与之后自动执行

4、异常通知 (afterThrowing) ：在方法抛出异常时自动执行

5、最终通知 (after) ：无论程序发生任何事情，都将执行

Execution 是 AspectJ 框架中的一种表达式，用于配置切点。

基本语法格式为： execution(<修饰符模式 >?< 返回类型模式 >< 方法名模式 >(< 参数模式 >)< 异常模式 >?)

其中 < 修饰符模式 > 与 < 异常模式 > 为可选。 execution(public * com.alan.service..*.*(..)

execution() ：表达式的主体

public ：方法的修饰符

第一个“*”符号 ：表示返回值的类型任意

com.alan.service ：AOP 所拦截的目标对象的包名，即，需要进行横切的业务类

包名后面的 “..” ：表示当前包及子包

第二个 “*” ：表示类名，* 即所有类

第三个 “*” ：表示任何方法名

(..) ：括号表示参数，两个点表示任何参数类型

使用注解或者配置文件的方式进行切片配置。

2、Java中的锁机制

      sy

3、分布式事务框架机制

事务
事务提供一种“要么什么都不做，要么做全套（All or Nothing）”的机制，她有ACID四大特性
原子性（Atomicity）：事务作为一个整体被执行，包含在其中的对数据库的操作要么全部被执行，要么都不执行。
一致性（Consistency）：事务应确保数据库的状态从一个一致状态转变为另一个一致状态。一致状态是指数据库中的数据应满足完整性约束。除此之外，一致性还有另外一层语义，就是事务的中间状态不能被观察到（这层语义也有说应该属于原子性）。
隔离性（Isolation）：多个事务并发执行时，一个事务的执行不应影响其他事务的执行，如同只有这一个操作在被数据库所执行一样。
持久性（Durability）：已被提交的事务对数据库的修改应该永久保存在数据库中。在事务结束时，此操作将不可逆转。

4、Jvm、

5、Collection接口是 (java.util.Collection)

6、redis 底层结构是怎么实现的。

7、CurrentHashmap 是怎么扩容的  jdk1.7、1.8区别 （红黑树实现）

9、mysql的索引（mysql的日志类型、mysql的存储引擎）、

10、联合索引查询是否有效、数据库事务隔离级别、

11、线程池的7个参数理解、

12、mongdb数据库的重要知识点、

13、kafka知识点 

14、rocketMq知识点

15、jdk1.8新特性实战：