Spring学习系列笔记之Spring心得

Posted 2020-10-17 jxtx92

1 解释一下Dependency injection(DI依赖注入)和IOC(Inversion of control,控制反转)?

答：1.1:Dependency injection(DI依赖注入)：

　　就是说将一个目标与目标对象之间的依赖通过Spring容器来实现注入，这样使得与传统的通过自己写代码来创建对象的方式完全颠倒过来了，这就是控制反转的由来吧。

我觉得用口头举例子来说明DI更方便，更清晰。通过DI机制，降低了替换业务对象的复杂性。

依赖注入主要有两种方式来实现：

  a:设值注入.           泛化 实现 依赖 关联 聚合 组合

  b:构造注入. (使用构造器注入通过配置构造器参数实现，构造器参数就是依赖)

1.2:  IOC(Inversion of control,控制反转)

a:用简洁的话总结:就是把传统的通过程序代码来创建对象的权力交给Spring容器来创建。也就是说对象的创建由主动创建变成被动获取。

2 spring中的BeanFactory与ApplicationContext的作用有哪些?

答：BeanFacotry是IOC的核心容器,它的作用,功能主要有两个:

  1:创建对象.

  2:管理依赖.

它们的结构图是这样的:

　            　BeanFacotry

　　 　         /                \                      MessageSource

　　        　/实现            \继承               /继承

　　         /                           \                      /

XmlBeanFacotry                       ApplicationContext

                /                                    \

             /实现                          \实现

          / 　                               \

FileSystemXmlApplicationContext      ClassPathXmlApplicationContext

ApplicationContext可以说是BeanFactory的增强版，就像是struts2中的Action接口和ActionSupport类，Action功能是提供五个小统一的常量，ActionSupport类也是Action接口的增强版，它不但提供了五个统一的常量，更是加入了国际化，校验功能。

3 如何在spring中实现国际化:

答：(1).可以通过元数据支持的xml里进行配置Spring支持国际化的类，ResourceBundleMessageSource。

(2).通过ApplicationContext的子类FileSystemXmlApplicationContext或ClassPathXmlApplicationContext容器创建MessageSource对象，这样就使得通过MessageSource里的getMessage(String string ,Object[] objects,Locale.UA/China)方法来实现国际化。

4 spring中的核心类有那些，各有什么作用?

答：如上。

5 spring的组成部分

答：Spring主要由七个部分组成:

(1).对web的支持

(2).Spring MVC

(3).核心控制：它主要是分为依赖注入，控制反转.

(4).context.

(5).Spring DAO.

最常用的有以下几个类:

  2.0版本的有：JdbcDaoSupport,JdbcTemplate．

  2.5版本的有：simpleJdbcTemplate.

(6).Spring ORM.

(7).Spring AOP:面向切面编程.

  学习Spring AOP主要是围绕Spring AOP的整体思路，

  它解决什么问题，并怎么解决，解决的方案的，以及用哪些技术可以解决来进行学习。

6 spring 中bean的作用域(注意版本差别)

答：在spring 2.0前，作用域只有singleton和prototype，

在spring 2.0后新增了request，session，global session

五种作用域(版本):

   (1).singleton(默认):

      一个bean的作用域为singleton, 那么Spring IoC容器中只会存在一个共享的bean实例，

      并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。

   (2).prototype:

      Prototype作用域的bean会导致在每次对该bean请求(将其注入到另一个bean中，或者以程序的 方式调用容器的getBean()方法)时都会创建一个新的bean实例，一般对所有有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个prototype bean的整个生命周期负责：容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。

什么是有状态bean和无状态bean：

   有状态会话bean （@Stateful）：每个用户有自己特有的一个实例，在用户的生存期内，bean保持了用户的信息，即“有状态”； 一旦用户灭亡（调用结束或实例结束），bean的生命期也告结束。即每个用户最初都会得到一个初始的bean。

  无状态会话bean （@Stateless）：bean一旦实例化就被加进会话池中，各个用户都可以共用。即使用户已经消亡，bean 的生命期也不一定结束，它可能依然存在于会话池中，供其他用户调用。由于没有特定的用户，那么也就不能保持某一用户的状态，所以叫无状态bean。

下面是Spring 2.5的使用bean的作用域：

request、session、global session使用的时候，首先要在初始化web的web.xml中做如下配置：

<listener>
　　<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
</listener>

 (3).request:

     request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效

 (4).session:

     session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效，

 (5).global session(portlet)：

      global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个 portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。如果你在web中使用 global session作用域来标识bean，那么，web会自动当成session类型来使用。

7 spring的四大特点

答：它主要有四大特征，他们分别是：

(1).低侵入式设计，对源代码染污极低。

  主要的体现就是加入处理，日志,以及通过Spring容器创建对象时，对源代理的无关性。

(2).跨平台性，Spring 真正做到了一次编写到处运行。到现在为止，这个特征我还没有感觉到。

(3).DI机制，降低了替换业务对象的复杂性。

　 在项目中的体现：就是说当一个接口它的实现,最开始是用工厂来控制创建了类实例的，如果要增加要增加新的实现类，一定在在源代码里进行创建，但现在通过DI<依赖注入>的方式来实现，只要在xml里通过bean配置新的实现类，然后再通过Spring 容器注入依赖将bean定义的id注入即可。这样替换业务对象的复杂性的特征就体现出来了。

(4).高度开放性，使得你可以不完全用Spring提供的，横穿表现层，业务层，持久层。

  在项目中的体现：

  比如说持久层：Spring DAO也支持对持久层的操作,它有JdbcDaoSupport，JdbcTemplate 但它对jdbc,dbutil,IBaits,Hibernate是完全支持的。

  业务层：Service层，比如说我们以前是用工厂来创建对象的，现在改为用Spring 容器来实现创建对象。

  这个也是不需在改变源代码的。

8 什么是IOC容器?

  答：IOC的核心容器是：BeanFacotry，它的作用主要是用两个:

(1).创建对象.

(2).管理依赖.

详细如上.

9 spring注入的2种方式

  答:它可以说是分为三种,但最常用的两种是:

(1)设值注入<set>

(2).构造注入</constructor-arg>

(3).lookup-method，这个一般不常用。

10  spring创建实例的方式(如默认的, 静态工厂 工厂方法)

答：Spring的核心就是:核心控制及Spring AOP，核心控制包括:DI<依赖注入>,IOC<控制反转>.

Spring 容器它就是创建对象和管理依赖的,通过Spring容器创建bean的实例有三种方式:

1:xml配置使用bean的类构造器：<bean id="" class="" />

2:xml配置+factory类,使用静态工厂方法实例化,bean里的class是factory类：<bean id="" class="" factory-method=""/>    static

  加入factory-method属性,这个方法指定的就是创建实例的方法,但此方法是用static修饰的。

3:xml配置+factory类,使用非静态工厂方法实例化<实例工厂方法实例化> ：<bean id="XXFactory" class="XXFactory" />   <bean id="" factory-bean="" factory-method="" />

  这个里面的配置和静态工厂配置最大的区别就是创建产实例的方法不是静态的。

11  spring初始化回调方法以及销毁( 析构回调)方法配置

答：初始化回调方法配置:在bean声明的时候加入init-method属性；销毁方法配置:在bean声明的时候加入destroy-method属性.。

12  连接点,切入点,切面,方面,处理,代理,目标对象

答：连接点：就是一个方法的调用

切入点：就是连接点的集合.

方面：就是说你加入什么功能就是什么方面,它主要是指四个方面， 1:日志2:事务3:安全4:权限

切面：由点组成面,横切多个对象.

处理：通过处理解决了Spring AOP解决的问题：

将系统中通用的功能隔离出来,形成一个新的功能，并切入到程序当中.

在一个方法调用前,后加入我们的功能,在不影响源代码的情况下,通过处理就得到了解决.

它分为了五种处理<通知>: a：前置处理<before advice> b：后置处理<after advice> c：前后处理<around advice> d：异常处理<exception advice> e：引入处理<introduce advice>

代理：Spring AOP提供了两种代理：<横切多个对象>

  1:个人代理,它传入的是接口,代理类是:proxyFactoryBean.

  2:自动代理,它传入的是实现类,代理类是BeanNameAutoProxyCreator.

目标对象：就是被一个或者多个切面所通知的对象，也被称做被通知（advised）对象。

13  spring中代理的两种方式

答：Spring AOP提供了两种代理，实现横切多个对象:

  1:个人代理,它传入的是接口,代理类是:proxyFactoryBean.

  2:自动代理,它传入的是实现类,代理类是BeanNameAutoProxyCreator.

14  事务的类型：事务它主要是控制数据的安全访问，要么全部成功，要么全部失败.

答：事务有两种划分方式,一种是按类型划分，一种是按实现划分.

按类型划分，它分为:

  全局事务：JTA<JNDI java命名目录规范>,应用服务器管理,使用的是JTA.

 局部事务：和资源相关的，主要应用于jdbc这一块.

JTA事务和jdbc事务的区别:

   jdbc事务：事务控制的局限性在一个数据库连接内,但它的使用相对来说简单.

   JTA事 务：它的功能强大，事务可以跨多个数据库或DAO，但使用复杂.

容器事务：主要是指EJB。

按实现划分，它分为:

编程型事务：

A:  jdbc事务主要用Connection 对象控制的。

该对象提供了两种事务模式：自动提交和手动提交。

它提供了以下控制事务的方法：

public void setAutoCommit(boolean)这个方法是用来设置事务提交的方式

public boolean getAutoCommit()这个方法是用来得到当前事务的提交方式

public void commit()事务手动提交

public void rollback()事务回滚

B：Spring aop也对局部事务是支持的,它主要是提供了以下三个类来实现编程型事务:

PlatformTransationManager:平台管理事务,它是事务的高层接口.

TransationTemplate：模版事务.

TransationStatus  : 状态事务.

声明型事务：

说到声明型事务,就得先说一下bean的继承也就是说模版技术:

模版技术主要是:一般是指指先定义一个抽象的bean，使得子bean可以利用父bean里定义的属性或参数，在子bean里用加入present属性等于父bean的id即可。

声明型事务主要是通过代理机制来实现,它有五种实现方式:

1:一个代理一个bean,它的代理模版类是DataSourceTransactionManager.

2:所有bean共享一个代理基类：它的代理模版类是DataSourceTransactionManager.

3:使用拦截器 Spring使用拦截器声明型事务有两个类:

  BeanNameAutoProxyCreator,DefaultAdvisoAutoProxyCreator,它们的基类是BeanPostProcessor

4:使用Tx标签配置拦截器.

5:全注解配置.

编程型事务,声明型事务的区别：

编程式事务则要操作逻辑代码。存在重复的代码比较多，相对繁琐，而且不利于系统的扩展.

声明式事务是非侵入式的事务。声明式事务只需在配置文件中配置，而不需要去操作逻辑代码.

我们什么时候编程事务，什么时候用声明事务呢？这个要看具体问题，具本分析，如果是使用事务比较少就使用编程型事务，如果事务被不断的反复使用，就使用声明型事务。

既然Spring AOP主要是通过以下两种方式来实现的

  1:动态代理<面向接口编程>,默认的是这个.

  2:CGlib<面向具体类编程>

Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。

15 jdbc是如何支持事务

答：jdbc主要是通过connection来控制事务,该对象提供了两个事务模式:自动提交，手动提交.

得到Connection对象有多种方式,而在Spring AOP当中,如果是用Spring AOP连接数据库的话, 用DataSource类里的getConnection方法来取得Connection对象, 将jdbc设为自动提交和手动提交的方法是:

public void setAutoCommit(boolean)这个方法是用来设置事务提交的方式

事务手动提交的方法是:public  void commit();

事务回滚的方法：public void rollback();

16 spring事务的组成部分

事务分为两部分:全局事务，局部事务.

答：按类型划分，它分为:

全局事务：JTA<JNDI java命名目录规范>,应用服务器管理,使用的是JTA.

局部事务：和资源相关的，主要应用于jdbc这一块.

JTA事务和jdbc事务的区别:

jdbc事务：事务控制的局限性在一个数据库连接内,但它的使用相对来说简单.

JTA事 务：它的功能强大，事务可以跨多个数据库或DAO，但使用复杂.

容器事务：主要是指EJB。

按实现划分：同上.

17 说说一下spring事务支持的几个类

答：1：PlatformTransationManager 平台管理事务,它是事务的高层接口

2：TransationTamplate  模版事务

3：TransationStatus    状态事务

18 spring定义事务的几种方式

答：编程式的和声明式的。

(1).一个bean一个代理.

(2).所有bean共用一个基类.

(3).通过拦截器定义.

(4).可以通过注解配置来定义.

19 spring中事务代理的几个类

答： BeanNameAutoProxyCreator:自动代理,根据你加入的bean 名进行切面.

DefaultAdvisoAutoProxyCreator：切所有的bean名,但它是切入点是所有在拦截器里配置的方法进行切。它们的基类是BeanPostProcessor.

20  -exception与+exception

答：-exception就是说：一碰到指定的异常就回滚,

+exception就是说：表示发生异常时不回滚.

前面加上 "-" 时，表示发生指定异常时撤消操作， 如果前面加上 "+"，表示发生异常时立即提交。

21 log4j日志的几种级别

答:off-->fatal-->error-->warn-->info-->debug;

22 说说一下在项目中用aop加入日志的流程

答:加入日志的流程:

1:首先肯定是在加入log4j包.

2:写一个log4j.properties文件.

3:在客户端得到Logger对象

好处:使用日志通过修改log4j的属性文件,可以定义每一条日志信息的级别,从而控制是否输出. 使用日志通过修改log4j的属性文件,可以决定log信息的目的地.如:控制台,文件里. 在项目中是怎么用的:因我们项目是基于MVC实现,并且是通过SPring容器来管理依赖和创建对象的, 所以加入日志就相对于简单.

23 spring模板技术 ,他有什么好处

答:模版技术就是说bean的继承,它主要是定义一个模版.

   使得子bean可以利用父bean的属性及参数.

24 说说一下spring支持的通知有几种

答:通知:通过处理解决了Spring AOP解决的问题:

将系统中通用的功能隔离出来,形成一个新的功能，并切入到程序当中.。在一个方法调用前,后加入我们的功能,在不影响源代码的情况下,通过处理就得到了解决。

它分为了五种处理<通知>:

   a：前置通知.<before advice>

   b：后置通知.<after advice>

   c：前后通知.<around advice>

   d：异常通知.<exception advice>

   e：引入通知.<introduce advice>

25 spring事务的原理(从架构图回答)

答:它是可以通过DataSource,TransationManager,以及事务代理机制来实现.

1:DataSource就不用多说了,主要用来数据库连接，得到Connection对象。

2:TransationManager:主要用在处理事务机制，对事务进行管理因为它是一个顶层接口,下面主要有:

  2.1: PlatformTransationManager 平台事务管理

  2.2: TransationTemplete 模版事务

3:事务代理机制可以通过三种方式来实现:

  3.1: 一个代理一个bean,它的代理模版类是DataSourceTransactionManager.

  3.2: 所有bean共享一个代理基类：它的代理模版类是DataSourceTransactionManager.

  3.3: 使用拦截器

Spring使用拦截器声明型事务有两个类: BeanNameAutoProxyCreator,DefaultAdvisoAutoProxyCreator,它们的基类是BeanPostProcessor

3.4:使用Tx标签配置拦截器.

3.5:全注解配置.

26 spring的后处理技术是干什么的

答:通过Spring的后处理技术,使得Spring就支持了注解配置, 它主要是通过BeanPostProcessor来实现. 其实使用拦截器代理事务,也是因为BeanPostProccessor(后处理)在起着作用.

@Autowired:也是提供三种注入方式来完成依赖注入

1:通过成员变量来进行注入依赖.

2:通过setter方法注入依赖.

3:通过构造方法注入依赖.

@Autowired,的后处理类是:AutowiredAnnotationBeanPostProcessor

Spring不但支持自己定义的注解注入依赖,还支持JSR-250提供的注解注入依赖:@Resource,

@Resource:也支持:通过成员变量来进行注入依赖,通过setter方法注入依赖.

不过按道理来说,它应该也是支持构造注入,但不清楚在应用中怎么不行.

@@Resource的后处理类是:CommonAnnotationBeanPostProcessor

@Autowired及@Resource的区别:

@Autowired:它默认的是根据byType来进行自动装配的,它是Spring提供的.

@Resource:它是根据根据byName来进行自动装配的,它是jdk提供的.

27 spring事务的传播属性(7个,最好能说出3个)

答: PROPAGATION_REQUIRED:要求在事务环境中执行该方法，如果当前执行线程已处于事务中，则直接调用， 如果当前执行线程不已处于事务中，则启动新的事务后执行该方法

28 spting默认的事务隔离级别是什么?

答:事务的隔离级别主要有三个:

它默认的是:READ COMMITTED:大多数主流数据库的默认事务等级， 保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。 该级别适用于大多数系统。

1、Serializable：最严格的级别，事务串行执行，资源消耗最大；

2、REPEATABLE READ：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。

避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。