什么是spring?spring组成模块、spring优缺点、应用场景、bean的生命周期、线程并发问题

什么是spring

在不同的语境中，Spring 所代表的含义是不同的。下面我们就分别从“广义”和“狭义”两个角度，对 Spring 进行介绍。

广义的 Spring：Spring 技术栈

广义上的 Spring 泛指以 Spring Framework 为核心的 Spring 技术栈。

经过十多年的发展，Spring 已经不再是一个单纯的应用框架，而是逐渐发展成为一个由多个不同子项目（模块）组成的成熟技术，例如 Spring Framework、Spring MVC、SpringBoot、Spring Cloud、Spring Data、Spring Security 等，其中 Spring Framework 是其他子项目的基础。

Spring 是一种基于 Bean 的编程技术，它深刻地改变着 Java 开发世界。Spring 使用简单、基本的 Java Bean 来完成以前只有 EJB 才能完成的工作，使得很多复杂的代码变得优雅和简洁，避免了 EJB 臃肿、低效的开发模式，极大的方便项目的后期维护、升级和扩展。

在实际开发中，服务器端应用程序通常采用三层体系架构，分别为表现层（web）、业务逻辑层（service）、持久层（dao）。

Spring 致力于 Java EE 应用各层的解决方案，对每一层都提供了技术支持。

在表现层提供了对 Spring MVC、Struts2 等框架的整合；
在业务逻辑层提供了管理事务和记录日志的功能；
在持久层还可以整合 MyBatis、Hibernate 和 JdbcTemplate 等技术，对数据库进行访问。

这充分地体现了 Spring 是一个全面的解决方案，对于那些已经有较好解决方案的领域，Spring 绝不做重复的事情。

从设计上看，Spring 框架给予了 Java 程序员更高的自由度，对业界的常见问题也提供了良好的解决方案，因此在开源社区受到了广泛的欢迎，并且被大部分公司作为 Java 项目开发的首选框架。

狭义的 Spring：Spring Framework

狭义的 Spring 特指 Spring Framework，通常我们将它称为 Spring 框架。

Spring 框架是一个分层的、面向切面的 Java 应用程序的一站式轻量级解决方案，它是 Spring 技术栈的核心和基础，是为了解决企业级应用开发的复杂性而创建的。

Spring 有两个核心部分： IoC 和 AOP。

Spring Framework 的特点

方便解耦，简化开发

Spring 就是一个大工厂，可以将所有对象的创建和依赖关系的维护交给 Spring 管理。

方便集成各种优秀框架

Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如 Struts2、Hibernate、MyBatis 等）的直接支持。

降低 Java EE API 的使用难度

Spring 对 Java EE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等）都提供了封装，使这些 API 应用的难度大大降低。

方便程序的测试

Spring 支持 JUnit4，可以通过注解方便地测试 Spring 程序。

AOP 编程的支持

Spring 提供面向切面编程，可以方便地实现对程序进行权限拦截和运行监控等功能。

声明式事务的支持

只需要通过配置就可以完成对事务的管理，而无须手动编程。

为什么要用spring

1.方便解耦,简化开发(高内聚低耦合) Spring就是一个大工厂(容器),用于创建对象(bean)和维护对象间的依赖关系. 2.AOP编程的支持 Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能. 声明式事务的支持,只需要通过配置就可以完成对事务的管理,而且无需手动编程. 3.方便程序的测试 Spring对Junit4支持,可以通过注解方便的测试Spring程序. 4.方便集成各种的优秀框架 5.降低JavaEE API的使用难度 Spring 对JavaEE开发中非常难用的一些API,都提供了封装,使用这些API应用难度大大降低.

Spring框架的设计目标，设计理念，和核心是什么？

Spring设计目标：Spring为开发者提供一个一站式轻量级应用开发平台；

Spring设计理念：在JavaEE开发中，支持POJO和JavaBean开发方式，使应用面向接口开发，充分支持OO（面向对象）设计方法；Spring通过IoC容器实现对象耦合关系的管理，并实现依赖反转，将对象之间的依赖关系交给IoC容器，实现解耦；

Spring框架的核心：IoC容器和AOP模块。通过IoC容器管理POJO对象以及他们之间的耦合关系；通过AOP以动态非侵入的方式增强服务。

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

Spring的优缺点是什么？

Spring的优点

1.降低了组件之间的耦合性,实现了软件各层之间的解耦. 2.可以使用容器提供的众多服务,如事务管理,消息服务等. 3.容器提供单利模式支持. 4.容器提供了AOP技术,利用它可以很容易实现的一些拦截,如权限拦截,运行期监控等. 5.容器提供了AOP技术,利用它可以很容易实现运行拦截,如权限拦截,运行期监控等. 6.spring对于主流的应用框架提供了很好的支持,例如mybatis等. 7.spring属于低入侵设计 8.独立各种应用服务器 9.spring的DI机制减低了业务对象替换的复杂性. 10.spring的高开放性,并不强制应用于完全依赖于它,开发者可以自由选择spring的部分或者全部.

Spring缺点

使用了大量的反射机制，反射机制非常占用内存。

Spring有哪些应用场景？

应用场景：JavaEE企业应用开发，包括SSH、SSM等

Spring有哪些模块组成？

1、核心容器(Spring Core)

核心容器提供Spring框架的基础功能。Spring以bean的方式进行java应用的各大组件及关系的组织和管理。Spring使用BeanFactory来产生和管理bean,是工厂模式的实现。BeanFactory使用控制反转（IOC）模式来将应用的配置和依赖性规范与实际的应用程序代码分开。

2、应用上下文（Spring Context）

实现了ApplicationContext接口，Spring的上下文，拓展了核心容器，提供事件处理、国际化等功能。它还提供了一些企业级服务的功能，提供了JNDI、EJB、RMI的支持。

3、Spring面向切面编程（Spring AOP）

提供切面支持，是个轻量级的容器。Spring管理的任何对象都支持AOP，SpringAOP模块基于Spring的应用程序中的对象提供了事务管理服务，通过使用SpringAOP，就可以将声明性事务管理集成在应用程序中。

4、JDBC和DAO模块（Spring DAO）

提供对JDBC的支持，还提供了DAO的支持，提供事务支持。

JDBC、DAO的抽象层，提供了有意义的异常层次结构实现，可用该结构来管理异常处理，和不同数据库提供商抛出的错误信息，异常层次结构简化了错误处理，并且极大的降低了需要编写的代码数量，比如打开和关闭链接。

5、对象实体映射（Spring ORM）

ORM：Object Relational Mapping，指对象实体映射。Spring插入了若干个ORM框架，提供了ORM对象的关系工具，其中包括Hibernate，JDO和IBatisSQL Map等，所有这些都遵从Spring的通用事务和DAO异常层次结构。

6、Web模块（Spring Web）

拓展了Spring上下文，提供Web应用上下文，对Web开发提供功能上的支持，如请求、表单、异常等。

7、MVC模块（SpringWebMVC）

MVC框架是一个全功能的构建Web应用程序的MVC实现，通过策略接口，MVC框架编程高度可配置的，MVC容纳了大量视图技术，其中包括JSP，POI等，模型由JavaBean来构成，存放于m当中，而视图是一个接口，负责实现模型，控制器表示逻辑代码，由c的事情

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

代理模式—在 AOP 和 remoting 中被用的比较多。单例模式—在 spring 配置文件中定义的 bean 默认为单例模式。模板方法—用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTempl ate。前端控制器—Spring 提供了 DispatcherServlet 来对请求进行分发。视图帮助(View Helper )—Spring 提供了一系列的 JSP 标签，高效宏来辅助将分散的代码整合在视图里。依赖注入—贯穿于 BeanFactory / ApplicationContext 接口的核心理念。工厂模式—BeanFactory 用来创建对象的实例

什么是IOC&DI？

IoC 即控制反转，DI即依赖注入

控制反转，是Inversion of Control的缩写，DI（Dependency Injection）叫依赖注入，是对IoC更简单的诠释。控制反转是把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。所谓的”控制反转”就是对组件对象控制权的转移，从程序代码本身转移到了外部容器，由容器来创建对象并管理对象之间的依赖关系。

依赖注入可以通过setter方法注入（设值注入）、构造器注入和接口注入三种方式来实现，Spring支持setter注入和构造器注入，通常使用构造器注入来注入必须的依赖关系，对于可选的依赖关系，则setter注入是更好的选择，setter注入需要类提供无参构造器或者无参的静态工厂方法来创建对象。

BeanFactory 和 ApplicationContext有什么区别？

BeanFactory和ApplicationContext是Spring的两大核心接口，都可以当做Spring的容器。其中ApplicationContext是BeanFactory的子接口。

BeanFactory:

BeanFactory是Spring里面最底层的接口,是Ioc的核心,定义了Ioc的基本功能,包含了各种Bean的定义、加载、实例化,依赖注入和生命周期管理;

ApplicationContext:

ApplicationContext接口作为BeanFactory的子类,除了提供BeanFactory所具有的功能外,还提供了更完整的框架功能: ①继承MessageSource,因此支持国际化 ②资源文件访问，如URL和文件（ResourceLoader） ③载入多个（有继承关系）上下文（及同时加载多个配置文件），使得每一个上下文都专注于一个特定的层次 ④提供在监听器中注册bean的事件；

二者区别

1.BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化，这样，我们就不能发现一些存在的Spring的配置问题。而ApplicationContext则相反，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误。相对于基本的BeanFactory，ApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时，程序启动较慢。

BeanFacotry延迟加载,如果Bean的某一个属性没有注入，BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常；而ApplicationContext则在初始化自身是检验，这样有利于检查所依赖属性是否注入；所以通常情况下我们选择使用 ApplicationContext。应用上下文则会在上下文启动后预载入所有的单实例Bean。通过预载入单实例bean ,确保当你需要的时候，你就不用等待，因为它们已经创建好了。

2.BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，而ApplicationContext则是自动注册。（Applicationcontext比 beanFactory 加入了一些更好使用的功能。而且 beanFactory 的许多功能需要通过编程实现而 Applicationcontext 可以通过配置实现。比如后处理 bean ， Applicationcontext 直接配置在配置文件即可而 beanFactory 这要在代码中显示的写出来才可以被容器识别。）

3.beanFactory主要是面对与 spring 框架的基础设施，面对 spring 自己。而 Applicationcontex 主要面对与 spring 使用的开发者。基本都会使用 Applicationcontex 并非 beanFactory 。

总结

因此，在实际开发中，通常都选择使用 ApplicationContext，而只有在系统资源较少时，才考虑使用 BeanFactory。

Spring框架中的单例bean是线程安全的吗？怎么解决？

不是

Spring默认的bean是单例的，也没有进行封装处理，所以不是线程安全的。

但是，共享不一定会有线程安全问题。如果某个bean我们定义了共享数据，且可以对共享数据进行修改，这样才会造成线程安全问题。比如我们在线程中定义一个count++，那么这个数就是不安全的，每次线程到来都会被执行一次，count值加一。 controller、service、dao本身不是安全的，但是，我们只在这些方法中相互调用，那么不会产生线程安全问题。 Dao层会操作数据库，但是每一个和数据库连接的connection，都会被数据库的事务机制管理，如果开启了Spring事务机制，那么也会被其管理。这都不会造成线程安全问题。

如果，我们必须要在bean中定义有状态的实例或变量，那么我们可以有以下几种办法，保证安全。

使用ThreadLocal，把变量变成线程私有的 synchronized、lock、CAS，保证互斥访问临界区把bean从单例（singleton）设置成原型（protopyte）

ThreadLocal使用不当造成内存溢出 ThreadLocal，底层使用map，当前线程的对象作为key，value则是你想让变成私有属性的变量，或实例对象。那么当该线程要使用这个变量或实例时候，就可以从map中get出来。每一个线程到来后，都会去创建map，如果是线程池中的核心线程，这个线程不死亡，它每次执行到这里都会往map中存对象，可能导致内存溢出。如何解决呢？线程每次get（key）使用过后，就把map中的数据删除掉，remove（key）。

Spring如何处理线程并发问题？

1、可以将成员变量声明在方法内。

2、将成员变量放在ThreadLocal之中。

（ThreadLocal userName = new ThreadLocal<>();）

成员变量放在ThreadLocal之中，传进来的参数是跟随线程的，所以也是线程安全的。

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

3、将bean设置为多例模式。（@Scope（“prototype”））

多例模式，bean线程之间不共享就不会发生线程安全问题。

4、使用同步锁（会影响系统的吞吐量） synchronized 修饰方法。

Spring框架中bean的生命周期？

bean的生命周期

bean的定义在spring中通常是通过配置文档的方式来定义Bean的，在一个配置文件中可以定义多个Bean

bean的初始化默认在IOC容器加载的时候实例化对象（ApplicationContext是，Beanfactory只有在调用getBean的时候才进行实例化）：生命周期（初始化、销毁方法、BeanPostProcessor后处理Bean） - 怀梦想，致远方 - 博客园

bean的使用通过ApplicationContext对象或Beanfactory对象获取bean

销毁

Bean 容器找到配置文件中 Spring Bean 的定义（配置文件或注解的方式定义）

Bean 容器利用Java Reflection API创建一个Bean的实例（ApplicationContext或Beanfactory）

如果涉及到一些属性值，利用set()方法设置一些属性值。

如果Bean实现了BeanNameAware接口，调用setBeanName()方法，传入Bean的ID

如果 Bean 实现了`BeanClassLoaderAware接口，调用setBeanClassLoader()方法，传入 ClassLoader对象的实例。

类似的，如果实现了其他 *.Aware接口，就调用相应的方法。

如果有和加载这个Bean的Spring容器相关的BeanPostProcessor对象，执行postProcessBeforeInitialization() 方法

如果Bean实现了InitializingBean接口，执行afterPropertiesSet()方法。

如果 Bean 在配置文件中的定义包含 init-method 属性，执行指定的方法。

如果有和加载这个 Bean的 Spring 容器相关的 BeanPostProcessor 对象，执行postProcessAfterInitialization()方法

当要销毁 Bean 的时候，如果 Bean 实现了 DisposableBean 接口，执行 destroy() 方法。

当要销毁 Bean 的时候，如果 Bean 在配置文件中的定义包含 destroy-method 属性，执行指定的方法。