Spring常见面试题总结(超详细)

2021-10-21 15:05:48 浏览数 (1)

（原创不易，你们对阿超的赞就是阿超持续更新的动力！）

（以免丢失，建议收藏）

（------------------------------------------------------------------------）

Spring是什么

Spring是一个轻量级的IOC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。

IOC让相互协作的组件保持松散的耦合，而AOP编程允许你把遍布于应用各层的功能分离出来形成可重用的功能组件

Spring IOC

Spring IOC （1）IOC就是控制反转，指创建对象的控制权转移给Spring框架进行管理，并由Spring根据配置文件去创建实例和管理各个实例之间的依赖关系，对象与对象之间松散耦合，也利于功能的复用。DI依赖注入，和控制反转是同一个概念的不同角度的描述，即 应用程序在运行时依赖IoC容器来动态注入对象需要的外部依赖。 （2）最直观的表达就是，以前创建对象的主动权和时机都是由自己把控的，IOC让对象的创建不用去new了，可以由spring自动生产，使用java的反射机制，根据配置文件在运行时动态的去创建对象以及管理对象，并调用对象的方法的。 （3）Spring的IOC有三种注入方式 ：构造器注入、setter方法注入、根据注解注入。

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动态代理：

  1. JDK动态代理只提供接口的代理，不支持类的代理，要求被代理类实现接口。JDK动态代理的核心是InvocationHandler接口和Proxy类，在获取代理对象时，使用Proxy类来动态创建目标类的代理类（即最终真正的代理类，这个类继承自Proxy并实现了我们定义的接口），当代理对象调用真实对象的方法时， InvocationHandler 通过invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起；
  2. 如果被代理类没有实现接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成指定类的一个子类对象，并覆盖其中特定方法并添加增强代码，从而实现AOP。CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的。
  3. 静态代理与动态代理区别在于生成AOP代理对象的时机不同，相对来说AspectJ的静态代理方式具有更好的性能，但是AspectJ需要特定的编译器进行处理，而Spring AOP则无需特定的编译器处理。

Spring的核心组成

  1. Spring Context：提供框架式的Bean访问方式，以及企业级功能（JNDI、定时任务等）；
  2. Spring Core：核心类库，所有功能都依赖于该类库，提供IOC和DI服务；
  3. Spring AOP：AOP服务；
  4. Spring Web：提供了基本的面向Web的综合特性，提供对常见框架如Struts2的支持，Spring能够管理这些框架
  5. Spring的资源注入给框架，也能在这些框架的前后插入拦截器；
  6. Spring MVC：提供面向Web应用的Model-View-Controller，即MVC实现。
  7. Spring DAO：对JDBC的抽象封装，简化了数据访问异常的处理，并能统一管理JDBC事务；
  8. Spring ORM：对现有的ORM框架的支持；

Spring的优点

Spring 的优点 （1）spring属于低侵入式设计，代码的污染极低； （2）spring的DI机制将对象之间的依赖关系交由框架处理，减低组件的耦合性； （3）Spring提供了AOP技术，支持将一些通用任务，如安全、事务、日志、权限等进行集中式管理，从而提供更好的复用。 （4）spring对于主流的应用框架提供了集成支持。

Spring通知类型有哪些

  1. 前置通知（Before Advice）：在连接点（Join point）之前执行的通知。
  2. 后置通知（After Advice）：当连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
  3. 环绕通知（Around Advice）：包围一个连接点的通知，这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也可以选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。
  4. 返回后通知（AfterReturning Advice）：在连接点正常完成后执行的通知（如果连接点抛出异常，则不执行）
  5. 抛出异常后通知（AfterThrowing advice）：在方法抛出异常退出时执行的通知

Spring容器的启动流程

（1）初始化Spring容器，注册内置的BeanPostProcessor的BeanDefinition到容器中 （2）将配置类的BeanDefinition注册到容器中 （3）调用refresh()方法刷新容器

Spring常用注解

用于声明bean的注解 @Component：在类定义之前添加@Component注解，他会被spring容器识别，并转为bean @Controller：用于控制层注解 @Service：用于对业务逻辑层进行注解 @Repository：对数据访问层进行注解 @Import：要导入到容器中的组件

用于依赖注入的注解 @Autowired：由bean提供，可以作用在变量、setter方法、构造函数上，@Autowired默认是按照类型装配注入的，默认情况下它要求依赖对象必须存在（可以设置它required属性为false） @Resource：由JSR-250提供，@Resource默认是按照名称来装配注入的 @Value：为属性注入值（属性上）

Java配置类相关注解 @Configuration：声明当前类为配置类 @Bean：注解在方法上，声明当前方法的返回值为一个bean，替代xml中的方式 @ComponentScan：用于对Component进行扫描

切面（AOP）相关注解 @Aspect：声明一个切面 @After：在方法执行之后执行（方法上） @Before：在方法执行之前执行（方法上） @Around：在方法执行之前与之后执行（方法上）

Spring Bean的生命周期

实例化 Instantiation --> 属性赋值 Populate --> 初始化 Initialization --> 销毁 Destruction （1）实例化Bean：对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。 对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。 （2）设置对象属性（依赖注入）：实例化后的对象被封装在BeanWrapper对象中，紧接着，Spring根据BeanDefinition中的信息 以及 通过BeanWrapper提供的设置属性的接口完成属性设置与依赖注入。 （3）处理Aware接口：Spring会检测该对象是否实现了xxxAware接口，通过Aware类型的接口，可以让我们拿到Spring容器的一些资源： 如果这个Bean实现了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，传入Bean的名字； 如果这个Bean实现了BeanClassLoaderAware接口，调用setBeanClassLoader()方法，传入ClassLoader对象的实例。 如果这个Bean实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()方法，传递的是Spring工厂自身。 如果这个Bean实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文； （4）BeanPostProcessor前置处理：如果想对Bean进行一些自定义的前置处理，那么可以让Bean实现了BeanPostProcessor接口，那将会调用postProcessBeforeInitialization(Object obj, String s)方法。 （5）InitializingBean：如果Bean实现了InitializingBean接口，执行afeterPropertiesSet()方法。 （6）init-method：如果Bean在Spring配置文件中配置了 init-method 属性，则会自动调用其配置的初始化方法。 （7）BeanPostProcessor后置处理：如果这个Bean实现了BeanPostProcessor接口，将会调用postProcessAfterInitialization(Object obj, String s)方法；由于这个方法是在Bean初始化结束时调用的，所以可以被应用于内存或缓存技术； （8）DisposableBean：当Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean这个接口，会调用其实现的destroy()方法； （9）destroy-method：最后，如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。

Spring是线程安全的吗

Spring容器本身并没有提供Bean的线程安全策略，因此可以说Spring容器中的Bean本身不具备线程安全的特性，但是具体情况还是要结合Bean的作用域来讨论。 （1）对于prototype作用域的Bean，每次都创建一个新对象，也就是线程之间不存在Bean共享，因此不会有线程安全问题。 （2）对于singleton作用域的Bean，所有的线程都共享一个单例实例的Bean，因此是存在线程安全问题的。但是如果单例Bean是一个无状态Bean，也就是线程中的操作不会对Bean的成员执行查询以外的操作，那么这个单例Bean是线程安全的。比如Controller类、Service类和Dao等，这些Bean大多是无状态的，只关注于方法本身。

有状态Bean(Stateful Bean) ：就是有实例变量的对象，可以保存数据，是非线程安全的。 无状态Bean(Stateless Bean)：就是没有实例变量的对象，不能保存数据，是不变类，是线程安全的。 对于有状态的bean（比如Model和View），就需要自行保证线程安全，最浅显的解决办法就是将有状态的bean的作用域由“singleton”改为“prototype”。 也可以采用ThreadLocal解决线程安全问题，为每个线程提供一个独立的变量副本，不同线程只操作自己线程的副本变量。

Spring如何解决循环依赖问题

循环依赖问题在Spring中主要有三种情况： （1）通过构造方法进行依赖注入时产生的循环依赖问题。 （2）通过setter方法进行依赖注入且是在多例（原型）模式下产生的循环依赖问题。 （3）通过setter方法进行依赖注入且是在单例模式下产生的循环依赖问题。 在Spring中，只有第（3）种方式的循环依赖问题被解决了，其他两种方式在遇到循环依赖问题时都会产生异常。这是因为： 第一种构造方法注入的情况下，在new对象的时候就会堵塞住了，其实也就是”先有鸡还是先有蛋“的历史难题。 第二种setter方法（多例）的情况下，每一次getBean()时，都会产生一个新的Bean，如此反复下去就会有无穷无尽的Bean产生了，最终就会导致OOM问题的出现。 Spring在单例模式下的setter方法依赖注入引起的循环依赖问题，主要是通过二级缓存和三级缓存来解决的，其中三级缓存是主要功臣。解决的核心原理就是：在对象实例化之后，依赖注入之前，Spring提前暴露的Bean实例的引用在第三级缓存中进行存储。

Spring的自动装配

Spring的自动装配 在spring中，使用autowire来配置自动装载模式，对象无需自己查找或创建与其关联的其他对象，由容器负责把需要相互协作的对象引用赋予各个对象。 （1）在Spring框架xml配置中共有5种自动装配： 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。

Spring事务的种类

Spring支持编程式事务管理和声明式事务管理两种方式：

  1. 编程式事务管理使用TransactionTemplate。
  2. 声明式事务管理建立在AOP之上的。其本质是通过AOP功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，也就是在目标方法开始之前启动一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

声明式事务最大的优点就是不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明或通过@Transactional注解的方式，便可以将事务规则应用到业务逻辑中，减少业务代码的污染。唯一不足地方是，最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。

Spring的事务传播机制

Spring事务的传播机制说的是，当多个事务同时存在的时候，spring如何处理这些事务的行为。事务传播机制实际上是使用简单的ThreadLocal实现的，所以，如果调用的方法是在新线程调用的，事务传播实际上是会失效的

  1. PROPAGATION_REQUIRED：（默认传播行为）如果当前没有事务，就创建一个新事务；如果当前存在事务，就加入该事务。
  2. PROPAGATION_REQUIRES_NEW：无论当前存不存在事务，都创建新事务进行执行。
  3. PROPAGATION_SUPPORTS：如果当前存在事务，就加入该事务；如果当前不存在事务，就以非事务执行。
  4. PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  5. PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行；如果当前没有事务，则按REQUIRED属性执行。
  6. PROPAGATION_MANDATORY：如果当前存在事务，就加入该事务；如果当前不存在事务，就抛出异常。
  7. PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

Spring中的隔离级别

Spring中的隔离级别

  1. ISOLATION_DEFAULT：这是个 PlatfromTransactionManager 默认的隔离级别，使用数据库默认的事务隔离级别。
  2. ISOLATION_READ_UNCOMMITTED：读未提交，允许事务在执行过程中，读取其他事务未提交的数据。
  3. ISOLATION_READ_COMMITTED：读已提交，允许事务在执行过程中，读取其他事务已经提交的数据。
  4. ISOLATION_REPEATABLE_READ：可重复读，在同一个事务内，任意时刻的查询结果都是一致的。
  5. ISOLATION_SERIALIZABLE：可序化，所有事务逐个依次执行。

Spring基于xml注入bean的几种方式

Spring基于xml注入bean的几种方式：

  1. set()方法注入；
  2. 构造器注入：通过index设置参数的位置；通过type设置参数类型；
  3. 静态工厂注入；
  4. 实例工厂；

Spring 框架中都用到了哪些设计模式

Spring 框架中都用到了哪些设计模式 （1）工厂模式：Spring使用工厂模式，通过BeanFactory和ApplicationContext来创建对象 （2）单例模式：Bean默认为单例模式 （3）策略模式：例如Resource的实现类，针对不同的资源文件，实现了不同方式的资源获取策略 （4）代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术 （5）模板方法：可以将相同部分的代码放在父类中，而将不同的代码放入不同的子类中，用来解决代码重复的问题。比如RestTemplate, JmsTemplate, JpaTemplate （6）适配器模式：Spring AOP的增强或通知（Advice）使用到了适配器模式，Spring MVC中也是用到了适配器模式适配Controller （7）观察者模式：Spring事件驱动模型就是观察者模式的一个经典应用。 （8）装饰者模式：可以根据客户的需求能够动态切换不同的数据源。比如我们的项目需要连接多个数据库，客户在每次访问中根据需要会去访问不同的数据库

@Resource和@Autowired区别

@Autowired可用于：构造函数、成员变量、Setter方法

(1) @Autowired默认是按照类型装配注入的，默认情况下它要求依赖对象必须存在（可以设置它required属性为false） (2) @Resource默认是按照名称来装配注入的，只有当找不到与名称匹配的bean才会按照类型来装配注入。

@Resource和@Autowired区别 1、共同点 两者都可以写在字段和setter方法上。两者如果都写在字段上，那么就不需要再写setter方法 2、不同点 @Autowired为Spring提供的注解，需要导入包org.springframework.beans.factory.annotation.Autowired;只按照byType注入，Autowired注解是按照类型（byType）装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它的required属性为false。如果我们想使用按照名称（byName）来装配，可以结合@Qualifier注解一起使用 @Resource默认按照ByName自动注入，由J2EE提供，需要导入包javax.annotation.Resource。@Resource有两个重要的属性：name和type，而Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以，如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不制定name也不制定type属性，这时将通过反射机制使用byName自动注入策略

什么是单例模式？饿汉式和懒汉式的区别？懒汉式有哪些创建方法？

单例模式：一个类只允许创建一个实例对象，并提供访问其唯一的对象的方式。这个类就是一个单例类，这种设计模式叫作单例模式。

饿汉式与懒汉式的区别：

  • 饿汉式是类一旦加载，就把单例初始化完成，保证 getInstance() 方法被调用时的时候，单例已经初始化完成，可以直接使用。
  • 懒汉式比较懒，只有当被调用 getInstance() 方法时，才会去初始化这个单例。

懒汉创建方式：get方法加锁；双重锁；静态内部类；枚举

Spring可以做哪些事

  1. 方便解耦，简化开发 　　通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
  2. AOP编程的支持 　　通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
  3. 声明事物的支持 　　在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
  4. 方便程序的测试 　　可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。
  5. 方便集成各种优秀框架 　　Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。
  6. 降低Java EE API的使用难度 　　Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。
  7. Java 源码是经典学习范例 　　　Spring的源码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

Spring如何注入一个java集合

Spring 提供以下几种集合的配置元素： 类型用于注入一列值，允许有相同的值。 类型用于注入一组值，不允许有相同的值。 类型用于注入一组键值对，键和值都可以为任意类型。 类型用于注入一组键值对，键和值都只能为 String 类型。

Spring如何配置数据库驱动

使用”org.springframework.jdbc.datasource.DriverManagerDataSource”数据源来配置数据库驱动。示例如下：

代码语言：javascript复制
<bean id=”dataSource”>
	<property name=”driverClassName”>
         <value>org.hsqldb.jdbcDriver</value>
	</property>
	<property name=”url”>
        <value>jdbc:hsqldb:db/appfuse</value>
	</property>
	<property name=”username”><value>sa</value></property>
	<property name=”password”><value></value></property>
</bean>

Spring配置bean的实例化方式有哪些

  1. 构造方法实例化：XML配置使用bean构造器
  2. 静态工厂实例化：XML配置 factory类，使用静态工厂方法实例化
  3. 实例工厂实例化

Spring当中applicationcontext.xml能不能改成其他文件名

可以，你在web.xml 配置

代码语言：javascript复制
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener
		<context-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>/WEB-INF/xyz.xml</param-value>
		</context-param>
	</listener-class>
</listener>

Spring如何处理线程并发问题

Spring 使用 ThreadLocal 解决线程安全问题我们知道在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分 Bean 都可以声明为 singleton 作用域。就是因为 Spring 对一些Bean(RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder 等)中非线程安全状态采用 ThreadLocal 进行处理，让它们也成为线程安全的状态，因为有状态的Bean 就可以在多线程中共享了。

ThreadLocal 和线程同步机制都是为了解决多线程中相同变量访问冲突问题。同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。

ThreadLocal 则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进 ThreadLocal。 由于 ThreadLocal中可以持有任何类型的对象，低版本 JDK 所提供的 get()返回的是 Object 对象，需要强制类型转换。但 JDK5.0通过泛型很好的解决这个问题，在一定程度地简化ThreadLocal 的使用。

概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而 ThreadLocal 采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

Spring当中为什么要有事务的传播行

为了保证数据同步，事务的传播特性 PROPAGATION_REQUIRED：支持当前事务，假设当前没有事务。就新建一个事务 PROPAGATION_SUPPORTS：支持当前事务，假设当前没有事务，就以非事务方式运行 PROPAGATION_REQUIRES_NEW：新建事务，假设当前存在事务。把当前事务挂起 PROPAGATION_NOT_SUPPORTED：以非事务方式运行操作。假设当前存在事务，就把当前事务挂起 PROPAGATION_MANDATORY：支持当前事务，假设当前没有事务，就抛出异常 PROPAGATION_NEVER：以非事务方式运行，假设当前存在事务，则抛出异常 PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

IOC和DI

IOC是控制反转：创建对象实例的控制权从代码控制剥离到IOC容器控制(之前的写法，由程序代码直接操控使用new关键字)，实际就是你在xml文件控制，控制权的转移是所谓反转，侧重于原理。 Spring的IOC有三种注入方式 ：构造器注入、setter方法注入、根据注解注入。

DI是依赖注入：IOC的另一种表达方式：组件以一些预先定义好的方式(如：setter方法)接收来自容器的资源注入。相对于IOC而言，这种表述更加直接 创建对象实例时，为这个对象注入属性值或其它对象实例，侧重于实现。 注入方式 ：属性注入，构造器注入

区别

  1. 它们是spring核心思想的不同方面的描述。
  2. 依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。 依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源； 而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。

JDK动态代理和CGLIB

AOP是一种面向过程的编程思想，它的实现原理主要是Java的动态代理，而Spring对动态代理的支持有两种方式，一种是默认的JDK实现，一种是CGLIB

  1. JDK动态代理 Jdk的动态代理是Spring的默认实现，基于接口，代理类与被代理类实现相同接口
  2. CGLIB 基于继承，代理类是被代理类子类，利用回调来实现代理的。
spring aop 网络安全 容器 编程算法

0 人点赞