1.spring是什么 ？使用Spring框架的好处是什么？
轻量：Spring 是轻量的，基本的版本大约2MB。
控制反转：Spring通过控制反转实现了松耦合，把对象创建和对象之间的调用交给spring容器管理
面向切面的编程(AOP)：通过动态代理把应用业务逻辑和系统服务分开。如安全、事务、日志、权限等进行集中式管理，从而提供更好的复用。
容器：Spring 包含并管理应用中对象的生命周期和配置。
MVC框架：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。
事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。
异常处理：Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO抛出的）转化为一致的unchecked 异常。
1.1ioc和di关系
ioc是一种设计模式，相当于一个容器，di就好比是实现ioc的一种方式
1.2.aop动态代理
面向切面编程，主要靠动态代理，
1.有接口情况，使用jdk动态代理（要求被代理类实现接口）
创建接口实现类的代理对象，增强类的方法
2.无接口情况，使用cglib动态代理（被代理类没有实现接口）
创建当前类子类的代理对象，增强类的方法
2.bean生命周期和作用域（scope）
生命周期：实例化 --> 属性赋值 --> 初始化 -->使用 --> 销毁
1.通过构造器创建bean实例（执行无参数构造创建bean实例）
2.为bean的属性赋值和对其它bean引用（调用set方法设置属性值）
（把bean实例传递bean后置处理器方法（postprocessbeforeinitilation）beanpostprocess）
3.调用bean的初始化方法（执行初始化方法）
（把bean实例传递bean后置处理器方法（postprocessafterinitilation））
4.bean可以使用了
5.当容器关闭是，调用bean的销毁方法
张鹏第九题
作用域：srgps
（1）singleton：默认作用域，单例bean，每个容器中只有一个bean的实例。
（俩者区别上面加载时创建）
（2）prototype：为每一个bean请求创建一个实例。
（3）request：为每一个request请求创建一个实例，在请求完成以后，bean会失效并被垃圾回收器回收。
（4）session：与request范围类似，同一个session会话共享一个实例，不同会话使用不同的实例。
（5）global-session：全局作用域，所有会话共享一个实例。如果想要声明让所有会话共享的存储变量的话，那么这全局变量需要存储在global-session中。
原文链接：https://blog.csdn.net/a745233700/article/details/80959716
3.不同的自动装配（xml和注解2种）
（1）在Spring框架xml配置中共有5种自动装配：（autowire）
no：默认的方式是不进行自动装配的，通过手工设置ref属性来进行装配bean。
byName：通过bean的名称进行自动装配，如果一个bean的 property 与另一bean 的name 相同，就进行自动装配。
byType：通过参数的数据类型进行自动装配。
constructor：利用构造函数进行装配，并且构造函数的参数通过byType进行装配。
autodetect：自动探测，如果有构造方法，通过 construct的方式自动装配，否则使用 byType的方式自动装配。
（2）基于注解的自动装配方式：
使用@Autowired、@Resource注解来自动装配指定的bean。在使用@Autowired注解之前需要在Spring配置文件进行配置，。在启动spring IoC时，容器自动装载了一个AutowiredAnnotationBeanPostProcessor后置处理器，当容器扫描到@Autowied、@Resource或@Inject时，就会在IoC容器自动查找需要的bean，并装配给该对象的属性。在使用@Autowired时，首先在容器中查询对应类型的bean：
如果查询结果刚好为一个，就将该bean装配给@Autowired指定的数据；
如果查询的结果不止一个，那么@Autowired会根据名称来查找；
如果上述查找的结果为空，那么会抛出异常。解决方法时，使用required=false。
@Autowired可用于：构造函数、成员变量、Setter方法
注：@Autowired和@Resource之间的区别：
(1) @Autowired默认是按照类型装配注入的，默认情况下它要求依赖对象必须存在（可以设置它required属性为false）。
如果我们想使用按名称装配，可以结合@Qualifier注解一起使用。如下：
@Autowired @Qualifier("personDaoBean")
(2) @Resource默认是按照名称来装配注入的，只有当找不到与名称匹配的bean才会按照类型来装配注入。
5.不同的依赖注入
set()方法注入；
(无参)构造器注入：①通过index设置参数的位置；②通过type设置参数类型；
Spring的IOC有三种注入方式 ：构造器注入、setter方法注入
5.spring中的单例bean线程安全吗
作用域是singleton,
1.单例bean存在线程问题，主要是因为当多个线程操作同一个对象的时候，对这个对象的非静态成员变量的写操作会存在线程安全问题
2.对于单例Bean,所有线程都共享一个单例实例Bean,因此是存在资源的竞争。
3.对于有状态的bean，Spring官方提供的bean，一般提供了通过ThreadLocal去解决线程安全的方法
4.有状态会话bean ：每个用户有自己特有的一个实例，在用户的生存期内，bean保持了用户的信息，即“有状态”；一旦用户灭亡（调用结束或实例结束），bean的生命期也告结束。即每个用户最初都会得到一个初始的bean。简单来说，有状态就是有数据存储功能。有实例变量，有状态对象(Stateful Bean)，就是有实例变量的对象 ，可以保存数据，是非线程安全的。
无状态会话bean ：bean一旦实例化就被加进会话池中，各个用户都可以共用。即使用户已经消亡，bean 的生命期也不一定结束，它可能依然存在于会话池中，供其他用户调用。由于没有特定的用户，那么也就不能保持某一用户的状态，所以叫无状态bean。但无状态会话bean 并非没有状态，如果它有自己的属性（变量），那么这些变量就会受到所有调用它的用户的影响，这是在实际应用中必须注意的。简单来说，无状态就是一次操作，无实例变量，不能保存数据。无状态对象(Stateless Bean)，就是没有实例变量的对象 .不能保存数据，是不变类，是线程安全的。
使用ThreadLocal的好处
使得多线程场景下，多个线程对这个单例Bean的成员变量并不存在资源的竞争，因为ThreadLocal为每个线程保存线程私有的数据。这是一种以空间换时间的方式。
当然也可以通过加锁的方法来解决线程安全，这种以时间换空间的场景在高并发场景下显然是不实际的。
线程安全是针对不同用户之间对成员变量的操作互相影响导致的，换句话说如果你的类中没有非静态成员变量 ，即使有多个线程同时访问单例对象的成员方法也不会出问题
是单例模式，在多线程访问的时候有线程安全问题，解决方案是在控制器里面不能写可变状态量，如果需要使用这些可变状态，可以使用ThreadLocal机制解决，为每个线程单独生成一份变量副本，独立操作，互不影响。
6.@compoment和@bean的区别是什么？
7.spring事务有哪几种传播行为（多事务之间关系propagation7）
支持当前事务
REQUIRED ：如果当前存在事务，则加入该事务。如果当前没有事务，则创建一个新的事务
SUPPORTS：如果当前存在事务，则加入该事务 。如果当前没有事务， 则以非事务的方式继续运行
MANDATORY ：如果当前存在事务，则加入该事务 。如果当前没有事务，则抛出异常
不支持当前事务
REQUIRES_NEW ：创建一个新事务，如果当前存在事务，则把当前事务挂起
NOT_SUPPORTED ：以非事务方式运行，如果当前存在事务，则把当前事务挂起
NEVER ：以非事务方式运行，如果当前存在事务，则抛出异常
其他情况
NESTED ：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来执行 。如果当前没有事务，则该取值等价于REQUIRED
以NESTED启动的事务内嵌于外部事务中 （如果存在外部事务的话），此时内嵌事务并不是一个独立的事务，它依赖于外部事务。只有通过外部事务的提交，才能引起内部事务的提交，嵌套的子事务不能单独提交
8.spring事务隔离级别有几种(ioslation)
脏读：一个未提交事务读取到另一个未提交的事务
不可重复读：一个未提交事务读取到另一个提交的事务
幻读：一个未提交事务读取到另一个提交事务添加数据
脏读 不可重复读 幻读
读未提交 有 有 有 （read_uncommit）
读已提交 无 有 有 （read_commit）
可重复读 无 无 有 （repeatable read）
串行化 无 无 无 （serializable）
9.其他事务参数
timeout
readonly
rollbackfor回滚
norollbackfor不回滚
10.BeanFactory和ApplicationContext有什么区别？
张鹏第八题 ioc容器实现的俩种方式
是spring的俩大核心接口，都可以作为springioc容器
benafactory是spring内部使用的容器，不提供开发人员使用，懒加载（）
apllacationContext:是beanfactory的子接口，提供更多的功能供开发人员使用，加载配置文件时就创建里面对象
15. ApplicationContext通常的实现是什么?
FileSystemXmlApplicationContext ：此容器从一个XML文件中加载beans的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。
ClassPathXmlApplicationContext：此容器也从一个XML文件中加载beans的定义，这里，你需要正确设置classpath因为这个容器将在classpath里找bean配置。
-------------------------------------------------------------------------------------------------------------------------
9.Spring 的优点？
（1）spring属于低侵入式设计，代码的污染极低；
（2）spring的DI机制将对象之间的依赖关系交由框架处理，减低组件的耦合性；
（3）Spring提供了AOP技术，支持将一些通用任务，如安全、事务、日志、权限等进行集中式管理，从而提供更好的复用。
（4）spring对于主流的应用框架提供了集成支持。
原文链接：https://blog.csdn.net/a745233700/article/details/80959716
.spring模块
jdbc web core test aop
10.BeanFactory和ApplicationContext有什么区别？
张鹏第八题 ioc容器实现的俩种方式
是spring的俩大核心接口，都可以作为springioc容器
benafactory是spring内部使用的容器，不提供开发人员使用，懒加载（）
apllacationContext:是beanfactory的子接口，提供更多的功能供开发人员使用，加载配置文件时就创建里面对象
15. ApplicationContext通常的实现是什么?
FileSystemXmlApplicationContext ：此容器从一个XML文件中加载beans的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。
ClassPathXmlApplicationContext：此容器也从一个XML文件中加载beans的定义，这里，你需要正确设置classpath因为这个容器将在classpath里找bean配置。
11.Spring的AOP理解：
OOP面向对象，允许开发者定义纵向的关系，但并不适用于定义横向的关系，会导致大量代码的重复，而不利于各个模块的重用。
AOP，一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，提高系统的可维护性。可用于权限认证、日志、事务处理。
AOP实现的关键在于 代理模式，AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ；动态代理则以Spring AOP为代表。
（1）AspectJ是静态代理，也称为编译时增强，AOP框架会在编译阶段生成AOP代理类，并将AspectJ(切面)织入到Java字节码中，运行的时候就是增强之后的AOP对象。
（2）Spring AOP使用的动态代理，所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。
Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理：
① JDK动态代理只提供接口的代理，不支持类的代理，要求被代理类实现接口。JDK动态代理的核心是InvocationHandler接口和Proxy类，在获取代理对象时，使用Proxy类来动态创建目标类的代理类（即最终真正的代理类，这个类继承自Proxy并实现了我们定义的接口），当代理对象调用真实对象的方法时， InvocationHandler 通过invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起；
InvocationHandler 的 invoke(Object proxy,Method method,Object[] args)：proxy是最终生成的代理对象; method 是被代理目标实例的某个具体方法; args 是被代理目标实例某个方法的具体入参, 在方法反射调用时使用。
② 如果被代理类没有实现接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成指定类的一个子类对象，并覆盖其中特定方法并添加增强代码，从而实现AOP。CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的。
（3）静态代理与动态代理区别在于生成AOP代理对象的时机不同，相对来说AspectJ的静态代理方式具有更好的性能，但是AspectJ需要特定的编译器进行处理，而Spring AOP则无需特定的编译器处理。
IoC让相互协作的组件保持松散的耦合，而AOP编程允许你把遍布于应用各层的功能分离出来形成可重用的功能组件。
5、Spring AOP里面的几个名词的概念：
（1）连接点（Join point）：指程序运行过程中所执行的方法。在Spring AOP中，一个连接点总代表一个方法的执行。
（2）切面（Aspect）：被抽取出来的公共模块，可以用来会横切多个对象。Aspect切面可以看成 Pointcut切点 和 Advice通知 的结合，一个切面可以由多个切点和通知组成。
在Spring AOP中，切面可以在类上使用 @AspectJ 注解来实现。
（3）切点（Pointcut）：切点用于定义 要对哪些Join point进行拦截。
切点分为execution方式和annotation方式。execution方式可以用路径表达式指定对哪些方法拦截，比如指定拦截add*、search*。annotation方式可以指定被哪些注解修饰的代码进行拦截。
（4）通知（Advice）：指要在连接点（Join Point）上执行的动作，即增强的逻辑，比如权限校验和、日志记录等。通知有各种类型，包括Around、Before、After、After returning、After throwing。
（5）目标对象（Target）：包含连接点的对象，也称作被通知（Advice）的对象。 由于Spring AOP是通过动态代理实现的，所以这个对象永远是一个代理对象。
（6）织入（Weaving）：通过动态代理，在目标对象（Target）的方法（即连接点Join point）中执行增强逻辑（Advice）的过程。
（7）引入（Introduction）：添加额外的方法或者字段到被通知的类。Spring允许引入新的接口（以及对应的实现）到任何被代理的对象。例如，你可以使用一个引入来使bean实现 IsModified 接口，以便简化缓存机制。
几个概念的关系图可以参考下图：
网上有张非常形象的图，描述了各个概念所处的场景和作用，贴在这里供大家理解：
6、Spring通知（Advice）有哪些类型？
（1）前置通知（Before Advice）：在连接点（Join point）之前执行的通知。
（2）后置通知（After Advice）：当连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
（3）环绕通知（Around Advice）：包围一个连接点的通知，这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也可以选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。
（4）返回后通知（AfterReturning Advice）：在连接点正常完成后执行的通知（如果连接点抛出异常，则不执行）
（5）抛出异常后通知（AfterThrowing advice）：在方法抛出异常退出时执行的通知
同一个Aspect，不同advice的执行顺序：
（1）没有异常情况下的执行顺序：
around before advice
before advice
target method 执行
around after advice
after advice
afterReturning
（2）有异常情况下的执行顺序：
around before advice
before advice
target method 执行
around after advice
after advice
afterThrowing
java.lang.RuntimeException: 异常发生
7、Spring容器的启动流程：
————————————————
版权声明：本文为CSDN博主「张维鹏」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/a745233700/article/details/80959716
11.aop动态代理
面向切面编程，主要靠动态代理，
1.有接口情况，使用jdk动态代理
创建接口实现类的代理对象，增强类的方法
2.无接口情况，使用cglib动态代理
创建当前类子类的代理对象，增强类的方法
