Spring面試題：

1、簡單介紹一下Spring?

Spring 是個java企業(yè)級應用的開源開發(fā)框架。Spring主要用來開發(fā)Java應用，但是有些擴展是針對構(gòu)建J2EE平臺的web應用。Spring 框架目標是簡化Java企業(yè)級應用開發(fā)，并通過POJO為基礎(chǔ)的編程模型促進良好的編程習慣。

Spring是一個輕量級的IoC和AOP容器框架。是為Java應用程序提供基礎(chǔ)性服務(wù)的一套框架，目的是用于簡化企業(yè)應用程序的開發(fā)，它使得開發(fā)者只需要關(guān)心業(yè)務(wù)需求。常見的配置方式有三種：基于XML的配置、基于注解的配置、基于Java的配置。

主要由以下幾個模塊組成：

Spring Core：核心類庫，提供IOC服務(wù)；

Spring Context：提供框架式的Bean訪問方式，以及企業(yè)級功能（JNDI、定時任務(wù)等）；

Spring AOP：AOP服務(wù)；

Spring DAO：對JDBC的抽象，簡化了數(shù)據(jù)訪問異常的處理；

Spring ORM：對現(xiàn)有的ORM框架的支持；

Spring Web：提供了基本的面向Web的綜合特性，例如多方文件上傳；

Spring MVC：提供面向Web應用的Model-View-Controller實現(xiàn)。

2、Spring有哪些優(yōu)點？

（1）spring屬于低侵入式設(shè)計，代碼的污染極低；

（2）spring的DI機制將對象之間的依賴關(guān)系交由框架處理，減低組件的耦合性；

（3）Spring提供了AOP技術(shù)，支持將一些通用任務(wù)，如安全、事務(wù)、日志、權(quán)限等進行集中式管理，從而提供更好的復用。

（4）spring對于主流的應用框架提供了集成支持。

（1）輕量：Spring 是輕量的，基本的版本大約2MB。

（2）控制反轉(zhuǎn)：Spring通過控制反轉(zhuǎn)實現(xiàn)了松散耦合。

（3）面向切面的編程(AOP)：Spring支持面向切面的編程，并且把應用業(yè)務(wù)邏輯和系統(tǒng)服務(wù)分開。

（4）容器：Spring 包含并管理應用中對象的生命周期和配置。

（5）MVC框架：Spring的WEB框架是個精心設(shè)計的框架，是Web框架的一個很好的替代品。

（6）事務(wù)管理：Spring 提供一個持續(xù)的事務(wù)管理接口，可以擴展到上至本地事務(wù)，下至全局事務(wù)（JTA）。

（7）異常處理：Spring 提供方便的API把具體技術(shù)相關(guān)的異常（比如由JDBC，Hibernate or JDO拋出的）轉(zhuǎn)化為一致的unchecked 異常。

3、講一講對Spring中的AOP技術(shù)的理解

OOP面向?qū)ο笃渲幸粋€優(yōu)勢就是繼承，父類的代碼可以被子類所復用，但平級關(guān)系類中使用相同的功能代碼時會出現(xiàn)大量代碼的重復，不利于各個模塊的復用，這種情況可以使用AOP技術(shù)來解決。

AOP稱為面向切面編程，作為面向?qū)ο蟮囊环N補充，用于將那些與業(yè)務(wù)無關(guān)，但卻對多個對象產(chǎn)生影響的那些公共行為和邏輯進行抽取并封裝為一個可重用的模塊，這個模塊被命名為“切面（Aspect）”。切面可以減少系統(tǒng)中的重復代碼，降低模塊間的耦合度，同時提高系統(tǒng)的可維護性?？捎糜跈?quán)限認證、日志、事務(wù)處理。

AOP（Aspect Oriented Programming），即面向切面編程，可以說是OOP（Object Oriented Programming，面向?qū)ο缶幊蹋┑难a充和完善。OOP引入封裝、繼承、多態(tài)等概念來建立一種對象層次結(jié)構(gòu)，用于模擬公共行為的一個集合。不過OOP允許開發(fā)者定義縱向的關(guān)系，但并不適合定義橫向的關(guān)系，例如日志功能。日志代碼往往橫向地散布在所有對象層次中，而與它對應的對象的核心功能毫無關(guān)系對于其他類型的代碼，如安全性、異常處理和透明的持續(xù)性也都是如此，這種散布在各處的無關(guān)的代碼被稱為橫切（cross cutting），在OOP設(shè)計中，它導致了大量代碼的重復，而不利于各個模塊的重用。

AOP技術(shù)恰恰相反，它利用一種稱為"橫切"的技術(shù)，剖解開封裝的對象內(nèi)部，并將那些影響了多個類的公共行為封裝到一個可重用模塊，并將其命名為"Aspect"，即切面。所謂"切面"，簡單說就是那些與業(yè)務(wù)無關(guān)，卻為業(yè)務(wù)模塊所共同調(diào)用的邏輯或責任封裝起來，便于減少系統(tǒng)的重復代碼，降低模塊之間的耦合度，并有利于未來的可操作性和可維護性。

使用"橫切"技術(shù)，AOP把軟件系統(tǒng)分為兩個部分：

核心關(guān)注點和橫切關(guān)注點。業(yè)務(wù)處理的主要流程是核心關(guān)注點，與之關(guān)系不大的部分是橫切關(guān)注點。橫切關(guān)注點的一個特點是，他們經(jīng)常發(fā)生在核心關(guān)注點的多處，而各處基本相似，比如權(quán)限認證、日志、事物。AOP的作用在于分離系統(tǒng)中的各種關(guān)注點，將核心關(guān)注點和橫切關(guān)注點分離開來。

4、介紹一下使用JDK Proxy類如何實現(xiàn)動態(tài)代理？

有業(yè)務(wù)接口，有實現(xiàn)業(yè)務(wù)接口的業(yè)務(wù)類，還需要創(chuàng)建實現(xiàn)了InvocationHandler接口的MyInvocationHandler類。

InvocationHandler 的 invoke(Object proxy,Method method,Object[] args)：proxy是最終生成的代理實例; method 是被代理目標實例的某個具體方法; args 是被代理目標實例某個方法的具體入?yún)? 在方法反射調(diào)用時使用。

使用如下代碼創(chuàng)建代理類：

Proxy.newProxyInstance(Test1.class.getClassLoader(),

dangdangBook.getClass().getInterfaces(), handler);

5、介紹一下靜態(tài)和動態(tài)代理以及區(qū)別？

AOP技術(shù)的原理是“代理模式”，AOP代理主要分為靜態(tài)代理和動態(tài)代理。

（A）普通的類和接口實現(xiàn)靜態(tài)代理，代理類綁死了接口。

另外也可以使用AspectJ是靜態(tài)代理的增強，所謂靜態(tài)代理，就是AOP框架會在編譯階段生成AOP代理類，因此也稱為編譯時增強，他會在編譯階段將AspectJ(切面)織入到Java字節(jié)碼中，運行的時候就是增強之后的AOP對象。

參考網(wǎng)址：

Java 靜態(tài)代理 AspectJ 使用

http://www.itdecent.cn/p/aa293edba2e4

Spring AOP,AspectJ, CGLIB 有點暈

http://www.itdecent.cn/p/fe8d1e8bd63e

（B）Spring AOP使用的動態(tài)代理，所謂的動態(tài)代理就是說AOP框架不會去修改字節(jié)碼，而是每次運行時在內(nèi)存中臨時為方法生成一個AOP對象，這個AOP對象包含了目標對象的全部方法，并且在特定的切點做了增強處理，并回調(diào)原對象的方法。動態(tài)代理可以使用JDK Proxy和CGLIB來實現(xiàn)。

回答思路可以先介紹靜態(tài)代理的缺點，再介紹動態(tài)代理的優(yōu)點。

（C）靜態(tài)代理與動態(tài)代理區(qū)別在于生成AOP代理對象的時機不同。靜態(tài)代理在編譯時創(chuàng)建了代理類，而動態(tài)代理是在運行時創(chuàng)建了代理類。

6、當業(yè)務(wù)類實現(xiàn)或未實現(xiàn)接口時，在創(chuàng)建代理類時的區(qū)別是什么？

① 實現(xiàn)接口：JDK動態(tài)代理只支持對接口進行代理，不支持對類進行代理。核心內(nèi)容是InvocationHandler接口和Proxy類，InvocationHandler 通過在invoke()方法中使用反射技術(shù)調(diào)用目標類中的代碼，動態(tài)地將橫切邏輯和業(yè)務(wù)編織在一起；接著，Proxy利用 InvocationHandler動態(tài)創(chuàng)建一個符合某一接口的的實例, 生成目標類的代理對象。

② 未實現(xiàn)接口：如果業(yè)務(wù)類沒有實現(xiàn)接口，那么Spring AOP會選擇使用CGLIB實現(xiàn)動態(tài)代理，代理類繼承自業(yè)務(wù)類。CGLIB（Code Generation Library），是一個代碼生成的類庫，可以在運行時動態(tài)的生成指定類的一個子類對象，并覆蓋其中特定方法并添加增強代碼，從而實現(xiàn)AOP。CGLIB是通過繼承的方式做的動態(tài)代理，因此如果某個類被標記為final，那么它是無法使用CGLIB做動態(tài)代理的。

7、介紹一下對Spring IoC的理解：

（1）IOC是控制反轉(zhuǎn)，是指創(chuàng)建對象的控制權(quán)的轉(zhuǎn)移，以前創(chuàng)建對象的主動權(quán)和時機是由自己把控的，而現(xiàn)在這種權(quán)力轉(zhuǎn)移到Spring容器中，并由容器根據(jù)配置文件去創(chuàng)建實例和管理各個實例之間的依賴關(guān)系，對象與對象之間松散耦合，也利于功能的復用。DI依賴注入和IOC控制反轉(zhuǎn)是同一個概念的不同角度的描述，即：應用程序在運行時依賴IoC容器來動態(tài)注入對象需要的外部資源。

（2）最直觀的表達就是，IOC讓對象的創(chuàng)建不用去new了，可以由spring自動生產(chǎn)，使用java的反射機制，根據(jù)配置文件在運行時動態(tài)的去創(chuàng)建對象以及管理對象，并調(diào)用對象的方法的。

（3）Spring的IOC有三種注入方式 ：構(gòu)造器注入、setter方法注入、根據(jù)注解注入。

IoC讓相互協(xié)作的組件保持松散的耦合，而AOP編程允許你把遍布于應用各層的功能分離出來形成可重用的功能組件。

IoC不是什么技術(shù)，而是一種設(shè)計思想。在java的開發(fā)過程中。ioc意味著將你設(shè)計好的對象交給容器控制，而不是傳統(tǒng)的在對象內(nèi)部直接控制。理解“誰控制誰，控制什么，為何是反轉(zhuǎn)（有反轉(zhuǎn)是不是有正轉(zhuǎn)），反轉(zhuǎn)了哪些”

1

? 誰控制誰，控制什么：傳統(tǒng)java se程序設(shè)計，我們直接在對象內(nèi)部通過new進行創(chuàng)建對象；而IOC有專門的容器創(chuàng)建對象，由容器來控制對象；誰控制誰？IOC容器控制對象；控制了什么？主要控制了外部資源獲取（不只是對象，包括文件）

? 為何是反轉(zhuǎn)，哪些反轉(zhuǎn)了：有反轉(zhuǎn)就有正轉(zhuǎn)，傳統(tǒng)的應用程序是由我們在對象中主動控制去直接獲取依賴對象，也就是正轉(zhuǎn)；反轉(zhuǎn)就是由容器幫我們創(chuàng)建以及注入依賴對象；為何是反轉(zhuǎn)，因為是由容器幫我們查找及注入對象，對象只是被動的接受；

哪些反轉(zhuǎn)了：依賴對象的獲取方式被反轉(zhuǎn)了

IOC是一種設(shè)計思想（思想的轉(zhuǎn)變），之前所有創(chuàng)建對象的操作是由程序員自己new，現(xiàn)在交給了spring，由spring幫我們創(chuàng)建對象，注入之類的?？刂品崔D(zhuǎn)，控制是指 ioc提供的容器控制類的對象，反轉(zhuǎn)是指轉(zhuǎn)交給spring來負責。最大的作用就是解耦（降低耦合性）

IOC是一種叫做“控制反轉(zhuǎn)”的設(shè)計思想。

1、較淺的層次——從名字上解析

“控制”就是指對 對象的創(chuàng)建、維護、銷毀等生命周期的控制，這個過程一般是由我們的程序去主動控制的，如使用new關(guān)鍵字去創(chuàng)建一個對象（創(chuàng)建），在使用過程中保持引用（維護），在失去全部引用后由GC去回收對象（銷毀）。

“反轉(zhuǎn)”就是指對 對象的創(chuàng)建、維護、銷毀等生命周期的控制由程序控制改為由IOC容器控制，需要某個對象時就直接通過名字去IOC容器中獲取。

2、更深的層次——提到DI，依賴注入，是IOC的一種重要實現(xiàn)

一個對象的創(chuàng)建往往會涉及到其他對象的創(chuàng)建，比如一個對象A的成員變量持有著另一個對象B的引用，這就是依賴，A依賴于B。IOC機制既然負責了對象的創(chuàng)建，那么這個依賴關(guān)系也就必須由IOC容器負責起來。負責的方式就是DI——依賴注入，通過將依賴關(guān)系寫入配置文件，然后在創(chuàng)建有依賴關(guān)系的對象時，由IOC容器注入依賴的對象，如在創(chuàng)建A時，檢查到有依賴關(guān)系，IOC容器就把A依賴的對象B創(chuàng)建后注入到A中（組裝，通過反射機制實現(xiàn)），然后把A返回給對象請求者，完成工作。

3、IOC的意義何在？

IOC并沒有實現(xiàn)更多的功能，但它的存在使我們不需要很多代碼、不需要考慮對象間復雜的耦合關(guān)系就能從IOC容器中獲取合適的對象，而且提供了對 對象的可靠的管理，極大地降低了開發(fā)的復雜性。

8、BeanFactory和ApplicationContext有什么區(qū)別？

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

1

（1）兩者具有繼承關(guān)系

BeanFactory：是Spring里面最底層的接口，包含了各種Bean的定義，讀取bean配置文檔，管理bean的加載、實例化，控制bean的生命周期，維護bean之間的依賴關(guān)系。ApplicationContext接口作為BeanFactory的子接口，除了提供BeanFactory所具有的功能外，還提供了更完整的框架功能：

A.繼承MessageSource，因此支持國際化。

B.統(tǒng)一的資源文件訪問方式。

C.提供在監(jiān)聽器中注冊bean的事件。

D.同時加載多個配置文件。

E.載入多個（有繼承關(guān)系）上下文 ，使得每一個上下文都專注于一個特定的層次，比如應用的web層。

（2）兩者實例化類的時機不同

A.BeanFactroy采用的是延遲加載形式來注入Bean的，即只有在使用到某個Bean時(調(diào)用getBean())，才對該Bean進行加載實例化。這樣，我們就不能發(fā)現(xiàn)一些存在的Spring的配置問題。如果Bean的某一個屬性沒有注入，BeanFacotry加載后，直至第一次使用調(diào)用getBean方法才會拋出異常。

B.ApplicationContext，它是在容器啟動時，一次性創(chuàng)建了所有的Bean。這樣，在容器啟動時，我們就可以發(fā)現(xiàn)Spring中存在的配置錯誤，這樣有利于檢查所依賴屬性是否注入。 ApplicationContext啟動后預載入所有的單實例Bean，通過預載入單實例bean ,確保當你需要的時候，你就不用等待，因為它們已經(jīng)創(chuàng)建好了。

C.相對于基本的BeanFactory，ApplicationContext 唯一的不足是占用內(nèi)存空間。當應用程序配置Bean較多時，程序啟動較慢。

（3）BeanFactory通常以手寫代碼的方式被創(chuàng)建。

ApplicationContext還能以聲明的方式創(chuàng)建，如使用ContextLoader，在web.xml中進行配置，代碼如下：

org.springframework.web.context.ContextLoaderListener

繼承關(guān)系：

public class ContextLoaderListener extends ContextLoader implements ServletContextListener {

（4）BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但兩者之間的區(qū)別是：

BeanFactory需要手動注冊，代碼如下：

DefaultListableBeanFactory c;

c.addBeanPostProcessor(beanPostProcessor);

方法為public：

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor)

ApplicationContext則是自動注冊。

public abstract class AbstractApplicationContext extends DefaultResourceLoader

implements ConfigurableApplicationContext {

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {

PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);

}

1

2

3

BeanFactory：

是spring里面最底層的接口，提供了最簡單的容器的功能，只提供實例化對象和獲取對象

applicationContext：

應用上下文，繼承了BeanFactory接口（上一個的子接口），提供了更多的功能

1.ClassPathXmlApplicationContext 從 classpath 加載 spring 的配置文件

2.FileSystemApplicationContext 從系統(tǒng)文件加載 spring 的配置文件

3.AnnotationConfigApplicationContext 獲取基于注解的 spring 容器對象

4.XmlWebApplicationContext 在web環(huán)境中獲取 spring 容器對象

9、請解釋Spring Bean的生命周期？

首先說一下Servlet的生命周期：實例化，初始init，接收請求service，銷毀destroy；

Spring上下文中的Bean生命周期也類似，如下：

（1）實例化Bean：

對于BeanFactory容器，當客戶向容器請求一個尚未初始化的bean時，或初始化bean的時候需要注入另一個尚未初始化的依賴時，容器就會調(diào)用createBean進行實例化。對于ApplicationContext容器，當容器啟動結(jié)束后，通過獲取BeanDefinition對象中的信息，實例化所有的bean。

（2）設(shè)置對象屬性（依賴注入）：

實例化后的對象被封裝在BeanWrapper對象中，緊接著，Spring根據(jù)BeanDefinition中的信息 以及 通過BeanWrapper提供的設(shè)置屬性的接口完成依賴注入。

（3）處理Aware接口：

接著，Spring會檢測該對象是否實現(xiàn)了xxxAware接口，并將相關(guān)的xxxAware實例注入給Bean：

①如果這個Bean已經(jīng)實現(xiàn)了BeanNameAware接口，會調(diào)用它實現(xiàn)的setBeanName(String beanId)方法，此處傳遞的就是Spring配置文件中Bean的id值；

②如果這個Bean已經(jīng)實現(xiàn)了BeanFactoryAware接口，會調(diào)用它實現(xiàn)的setBeanFactory()方法，傳遞的是Spring工廠自身。

③如果這個Bean已經(jīng)實現(xiàn)了ApplicationContextAware接口，會調(diào)用setApplicationContext(ApplicationContext)方法，傳入Spring上下文；

（4）BeanPostProcessor：

如果想對Bean進行一些自定義的處理，那么可以讓Bean實現(xiàn)了BeanPostProcessor接口，那將會調(diào)用postProcessBeforeInitialization(Object obj, String s)方法。

（5）InitializingBean 與 init-method：

如果Bean在Spring配置文件中配置了 init-method 屬性，則會自動調(diào)用其配置的初始化方法。

（6）如果這個Bean實現(xiàn)了BeanPostProcessor接口，將會調(diào)用postProcessAfterInitialization(Object obj, String s)方法；由于這個方法是在Bean初始化結(jié)束時調(diào)用的，所以可以被應用于內(nèi)存或緩存技術(shù)；

以上幾個步驟完成后，Bean就已經(jīng)被正確創(chuàng)建了，之后就可以使用這個Bean了。

（7）DisposableBean：

當Bean不再需要時，會經(jīng)過清理階段，如果Bean實現(xiàn)了DisposableBean這個接口，會調(diào)用其實現(xiàn)的destroy()方法；

（8）destroy-method：

最后，如果這個Bean的Spring配置中配置了destroy-method屬性，會自動調(diào)用其配置的銷毀方法。

還可以參考網(wǎng)址：https://www.cnblogs.com/kenshinobiy/p/4652008.html

10、解釋Spring支持的幾種bean的作用域。

Spring容器中的bean可以分為5個范圍：

（1）singleton：默認，每個容器中只有一個bean的實例，單例的模式由BeanFactory自身來維護。

（2）prototype：為每一個獲得bean的請求創(chuàng)建一個新的實例。

（3）request：為每一個網(wǎng)絡(luò)請求創(chuàng)建一個實例，在請求完成以后，bean會失效并被垃圾回收器回收。

（4）session：與request范圍類似，確保每個session中有一個bean的實例，在session過期后，bean會隨之失效。

（5）global-session：全局作用域，global-session和Portlet應用相關(guān)。當你的應用部署在Portlet容器中工作時，它包含很多portlet。如果你想要聲明讓所有的portlet共用全局的存儲變量的話，那么這全局變量需要存儲在global-session中。全局作用域與Servlet中的session作用域效果相同。

其中比較常用的是singleton和prototype兩種作用域。對于singleton作用域的Bean，每次請求該Bean都將獲得相同的實例。容器負責跟蹤Bean實例的狀態(tài)，負責維護Bean實例的生命周期行為；如果一個Bean被設(shè)置成prototype作用域，程序每次請求該id的Bean，Spring都會新建一個Bean實例，然后返回給程序。在這種情況下，Spring容器僅僅使用new 關(guān)鍵字創(chuàng)建Bean實例，一旦創(chuàng)建成功，容器不在跟蹤實例，也不會維護Bean實例的狀態(tài)。

　　如果不指定Bean的作用域，Spring默認使用singleton作用域。Java在創(chuàng)建Java實例時，需要進行內(nèi)存申請；銷毀實例時，需要完成垃圾回收，這些工作都會導致系統(tǒng)開銷的增加。因此，prototype作用域Bean的創(chuàng)建、銷毀代價比較大。而singleton作用域的Bean實例一旦創(chuàng)建成功，可以重復使用。因此，除非必要，否則盡量避免將Bean被設(shè)置成prototype作用域。

當定義一個 在Spring里，可以給這個bean聲明一個作用域。通過bean 定義的scope屬性來定義。例如當Spring要在需要的時候每次生產(chǎn)一個新的bean實例，bean的scope屬性被指定為prototype。另一方面，一個bean每次使用的時候必須返回同一個實例，這個bean的scope 屬性必須設(shè)為 singleton。默認是singleton。

11、Spring框架中的單例Beans是線程安全的么？

不一定，因為安全與不安全取決于Bean的寫法。

Spring框架并沒有對單例bean進行任何多線程的封裝處理。關(guān)于單例bean的線程安全和并發(fā)問題需要開發(fā)者自行去搞定。但實際上，大部分的Spring bean并沒有可變的狀態(tài)(比如Service類和DAO類)，所以在某種程度上說Spring的單例bean是線程安全的。如果你的bean有多種狀態(tài)的話（比如 View Model 對象），就需要自行保證線程安全。最淺顯的解決辦法就是將多態(tài)bean的作用域由“singleton”變更為“prototype”。

12、Spring如何處理線程并發(fā)問題？

在一般情況下，只有無狀態(tài)的Bean才可以在多線程環(huán)境下共享，在Spring中，絕大部分Bean都可以聲明為singleton作用域，因為Spring對一些Bean中非線程安全狀態(tài)采用ThreadLocal進行處理，解決線程安全問題。

ThreadLocal和線程同步機制都是為了解決多線程中相同變量的訪問沖突問題。同步機制采用了“時間換空間”的方式，僅提供一份變量，不同的線程在訪問前需要獲取鎖，沒獲得鎖的線程則需要排隊。而ThreadLocal采用了“空間換時間”的方式。

ThreadLocal會為每一個線程提供一個獨立的變量副本，從而隔離了多個線程對數(shù)據(jù)的訪問沖突。因為每一個線程都擁有自己的變量副本，從而也就沒有必要對該變量進行同步了。

ThreadLocal提供了線程安全的共享對象，在編寫多線程代碼時，可以把不安全的變量封裝進ThreadLocal。

13、Spring基于xml注入bean的幾種方式：

（1）Set方法注入；

（2）構(gòu)造器注入：①通過index設(shè)置參數(shù)的位置；②通過type設(shè)置參數(shù)類型；

（3）靜態(tài)工廠注入；

（4）實例工廠；

詳細內(nèi)容可以閱讀：https://blog.csdn.net/a745233700/article/details/89307518

14、Spring的自動裝配有哪些：

在spring中，對象無需自己查找或創(chuàng)建與其關(guān)聯(lián)的其他對象，由容器負責把需要相互協(xié)作的對象引用賦予各個對象，使用autowire來配置自動裝載模式。

在Spring框架xml配置中共有5種裝配方式：

（1）no：默認的方式是不進行自動裝配的，需要通過手工設(shè)置ref屬性來進行裝配bean。

（2）byName：通過bean的名稱進行自動裝配，如果一個bean的 property 與另一bean 的name 相同，就進行自動裝配。

（3）byType：通過參數(shù)的數(shù)據(jù)類型進行自動裝配。使用@autowire。

（4）constructor：利用構(gòu)造函數(shù)進行裝配，并且構(gòu)造函數(shù)的參數(shù)通過byType進行裝配。

（5）autodetect：自動探測，如果有構(gòu)造方法，通過 construct的方式自動裝配，否則使用 byType的方式自動裝配。參考：https://www.yiibai.com/spring/spring-autowiring-by-autodetect.html

在Spring框架中使用注解的裝配方式：

使用@Autowired注解來自動裝配指定的bean。在使用@Autowired注解之前需要在Spring配置文件進行配置：

<context:annotation-config />。

在啟動spring IoC時，容器自動裝載了一個AutowiredAnnotationBeanPostProcessor后置處理器，當容器掃描到@Autowied、@Resource或@Inject時，就會在IoC容器自動查找需要的bean，并裝配給該對象的屬性。

在使用@Autowired時，首先在容器中查詢對應類型的bean：

（1）如果查詢結(jié)果剛好為一個，就將該bean裝配給@Autowired指定的數(shù)據(jù)；

（2）如果查詢的結(jié)果不止一個，那么@Autowired會根據(jù)名稱來查找；

（3）如果上述查找的結(jié)果為空，那么會拋出異常。解決方法時，使用required=false。

@Autowired可用于：構(gòu)造函數(shù)、成員變量、Setter方法

注：@Autowired和@Resource之間的區(qū)別

(1) @Autowired默認是按照類型裝配注入的，默認情況下它要求依賴對象必須存在（可以設(shè)置它required屬性為false）。

(2) @Resource默認是按照名稱來裝配注入的，只有當找不到與名稱匹配的bean才會按照類型來裝配注入。

自動裝配類型：

（1）autowire byName (按名稱自動裝配)

①將查找其類中所有的set方法名，例如setCat，獲得將set去掉并且首字母小寫的字符串，即cat。

②去spring容器中尋找是否有此字符串名稱id的對象。

如果有，就取出注入；如果沒有，就報空指針異常。

（2）autowire byType (按類型自動裝配)

使用autowire byType首先需要保證：同一類型的對象，在spring容器中唯一。如果不唯一，會報不唯一的異常。

（3）自動裝配autowire

首先嘗試使用constructor進行自動裝配，如果失敗，再嘗試使用byType進行自動裝配

（4）constructor

把與Bean的構(gòu)造器入?yún)⒕哂邢嗤愋偷钠渌鸅ean自動裝配到Bean構(gòu)造器的對應入?yún)⒅小?/p>

15、Spring 框架中都用到了哪些設(shè)計模式？

（1）工廠模式：BeanFactory就是簡單工廠模式的體現(xiàn)，用來創(chuàng)建對象的實例；

（2）單例模式：Bean默認為單例模式。

（3）代理模式：Spring的AOP功能用到了JDK的動態(tài)代理和CGLIB字節(jié)碼生成技術(shù)；

（4）模板方法：用來解決代碼重復的問題。比如. RestTemplate, JmsTemplate, JpaTemplate。

（5）觀察者模式：定義對象鍵一種一對多的依賴關(guān)系，當一個對象的狀態(tài)發(fā)生改變時，所有依賴于它的對象都會得到通知被制動更新，如Spring中l(wèi)istener的實現(xiàn)–ApplicationListener。

16、Spring事務(wù)處理有哪兩種方式：

Spring事務(wù)的本質(zhì)其實就是數(shù)據(jù)庫對事務(wù)的支持，只不過Spring框架進行了封裝，如果沒有底層數(shù)據(jù)庫對事務(wù)的支持，spring是無法提供事務(wù)功能的。

Spring支持編程式事務(wù)管理和聲明式事務(wù)管理兩種方式：

（1）編程式事務(wù)管理使用TransactionTemplate類，使用較少。

（2）聲明式事務(wù)管理建立在AOP之上的，使用較多。該方式本質(zhì)是通過AOP功能對方法前后進行攔截，將事務(wù)處理的功能編織到攔截的方法中，也就是在目標方法開始之前加入一個事務(wù)，在執(zhí)行完目標方法之后根據(jù)執(zhí)行情況提交或者回滾事務(wù)。

聲明式事務(wù)最大的優(yōu)點就是不需要在業(yè)務(wù)邏輯代碼中摻雜事務(wù)管理的相關(guān)代碼，只需在配置文件中做相關(guān)的事務(wù)規(guī)則聲明或通過@Transactional注解的方式，便可以將事務(wù)規(guī)則應用到業(yè)務(wù)邏輯中。

聲明式事務(wù)管理要優(yōu)于編程式事務(wù)管理，這正是spring倡導的非侵入式的開發(fā)方式，使業(yè)務(wù)代碼不受污染，只要加上注解就可以獲得完全的事務(wù)支持。唯一不足地方是，最細粒度只能作用到方法級別，無法做到像編程式事務(wù)那樣可以作用到代碼塊級別。

透徹的掌握 Spring 中@transactional 的使用

https://www.ibm.com/developerworks/cn/java/j-master-spring-transactional-use/index.html

17、spring的事務(wù)傳播行為：

spring事務(wù)的傳播行為說的是，當多個事務(wù)同時存在的時候，spring如何處理這些事務(wù)的行為。

（1）PROPAGATION_REQUIRED：如果當前沒有事務(wù)，就創(chuàng)建一個新事務(wù)，如果當前存在事務(wù)，就加入該事務(wù)，該設(shè)置是最常用的設(shè)置。

（2）PROPAGATION_SUPPORTS：支持當前事務(wù)，如果當前存在事務(wù)，就加入該事務(wù)，如果當前不存在事務(wù)，就以非事務(wù)執(zhí)行。‘

（3） PROPAGATION_MANDATORY：支持當前事務(wù)，如果當前存在事務(wù)，就加入該事務(wù)，如果當前不存在事務(wù)，就拋出異常。

（4） PROPAGATION_REQUIRES_NEW：創(chuàng)建新事務(wù)，無論當前存不存在事務(wù)，都創(chuàng)建新事務(wù)。

（5） PROPAGATION_NOT_SUPPORTED：以非事務(wù)方式執(zhí)行操作，如果當前存在事務(wù)，就把當前事務(wù)掛起。

（6） PROPAGATION_NEVER：以非事務(wù)方式執(zhí)行，如果當前存在事務(wù)，則拋出異常。

（7） PROPAGATION_NESTED：如果當前存在事務(wù)，則在嵌套事務(wù)內(nèi)執(zhí)行。如果當前沒有事務(wù)，則按REQUIRED屬性執(zhí)行。

我的總結(jié)：

（1）REQUIRED代表如果已經(jīng)存在一個事務(wù)，就加入到這個事務(wù)中。如果當前沒有事務(wù)，就新建一個事務(wù)，這是默認的事務(wù)傳播設(shè)置。

白話解釋：如果馬路上有車就搭車，如果馬路上沒有車就造一個車。

（2）SUPPORTS代表如果已經(jīng)存在一個事務(wù)，就加入到這個事務(wù)中。如果當前沒有事務(wù)，就以非事務(wù)方式執(zhí)行。

白話解釋：如果馬路上有車就搭車，如果馬路上沒有車就自己走綠色環(huán)保。

（3）MANDATORY代表如果已經(jīng)存在一個事務(wù)，就加入到這個事務(wù)中。如果當前沒有事務(wù)，就拋出異常。

白話解釋：如果馬路上有車就搭車，如果馬路上沒有車就憤怒的爆炸。

（4）REQUIRES_NEW代表新建事務(wù)，如果已經(jīng)存在一個事務(wù)，就把這個事務(wù)掛起并創(chuàng)建新的事務(wù)。

白話解釋：如果馬路上有車也不搭車，還要自己造車。

（5）NOT_SUPPORTED代表如果已經(jīng)存在一個事務(wù)，就把這個事務(wù)掛起。并以非事務(wù)方式執(zhí)行操作。

白話解釋：如果馬路上有車也不搭車，自己走綠色環(huán)保。

（6）NEVER代表如果已經(jīng)存在一個事務(wù)，則拋出異常。如果當前沒有事務(wù)，以非事務(wù)方式執(zhí)行。

白話解釋：馬路上有車就憤怒的爆炸，一臺車都沒有時則自己走綠色環(huán)保。

（7）NESTED代表創(chuàng)建當前事務(wù)的子事務(wù)。

白話解釋：水和魚的關(guān)系，魚（子事務(wù)）沒有了但不影響水（父事務(wù)），但水（父事務(wù)）沒有了則影響魚（子事務(wù)）。

18、Spring中的隔離級別：

（1） ISOLATION_DEFAULT：這是個 PlatfromTransactionManager 默認的隔離級別，使用數(shù)據(jù)庫默認的事務(wù)隔離級別。

（2） ISOLATION_READ_UNCOMMITTED：讀未提交，允許另外一個事務(wù)可以看到這個事務(wù)未提交的數(shù)據(jù)。

（3） ISOLATION_READ_COMMITTED：讀已提交，保證一個事務(wù)修改的數(shù)據(jù)提交后才能被另一事務(wù)讀取，而且能看到該事務(wù)對已有記錄的更新。

（4） ISOLATION_REPEATABLE_READ：可重復讀，保證一個事務(wù)修改的數(shù)據(jù)提交后才能被另一事務(wù)讀取，但是不能看到該事務(wù)對已有記錄的更新。

（5） ISOLATION_SERIALIZABLE：一個事務(wù)在執(zhí)行的過程中完全看不到其他事務(wù)對數(shù)據(jù)庫所做的更新。

19、Spring框架中有哪些不同類型的事件？

Spring 提供了以下5種標準的事件：

（1）上下文更新事件（ContextRefreshedEvent）：在調(diào)用ConfigurableApplicationContext 接口中的refresh()方法時被觸發(fā)。

（2）上下文開始事件（ContextStartedEvent）：當容器調(diào)用ConfigurableApplicationContext的Start()方法開始/重新開始容器時觸發(fā)該事件。

（3）上下文停止事件（ContextStoppedEvent）：當容器調(diào)用ConfigurableApplicationContext的Stop()方法停止容器時觸發(fā)該事件。

（4）上下文關(guān)閉事件（ContextClosedEvent）：當ApplicationContext被關(guān)閉時觸發(fā)該事件。容器被關(guān)閉時，其管理的所有單例Bean都被銷毀。

（5）請求處理事件（RequestHandledEvent）：在Web應用中，當一個http請求（request）結(jié)束觸發(fā)該事件。

如果一個bean實現(xiàn)了ApplicationListener接口，當一個ApplicationEvent 被發(fā)布以后，bean會自動被通知。

20、解釋一下Spring AOP里面的幾個名詞：

（1）切面（Aspect）：被抽取的公共模塊，可能會橫切多個對象。 在Spring AOP中，切面可以使用通用類（基于模式的風格） 或者在普通類中以 @AspectJ 注解來實現(xiàn)。

（2）連接點（Join point）：指方法，在Spring AOP中，一個連接點 總是 代表一個方法的執(zhí)行。

（3）通知（Advice）：在切面的某個特定的連接點（Join point）上執(zhí)行的動作。通知有各種類型，其中包括“around”、“before”和“after”等通知。許多AOP框架，包括Spring，都是以攔截器做通知模型， 并維護一個以連接點為中心的攔截器鏈。

（4）切入點（Pointcut）：切入點是指 我們要對哪些Join point進行攔截的定義。通過切入點表達式，指定攔截的方法，比如指定攔截add*、search*。

（5）引入（Introduction）：（也被稱為內(nèi)部類型聲明（inter-type declaration））。聲明額外的方法或者某個類型的字段。Spring允許引入新的接口（以及一個對應的實現(xiàn)）到任何被代理的對象。例如，你可以使用一個引入來使bean實現(xiàn) IsModified 接口，以便簡化緩存機制。

參考URL：https://blog.csdn.net/Danny_idea/article/details/78232298

（6）目標對象（Target Object）： 被一個或者多個切面（aspect）所通知（advise）的對象。也有人把它叫做 被通知（adviced） 對象。 既然Spring AOP是通過運行時代理實現(xiàn)的，這個對象永遠是一個 被代理（proxied） 對象。

（7）織入（Weaving）：指把增強應用到目標對象來創(chuàng)建新的代理對象的過程。Spring是在運行時完成織入。

切入點（pointcut）和連接點（join point）匹配的概念是AOP的關(guān)鍵，這使得AOP不同于其它僅僅提供攔截功能的舊技術(shù)。 切入點使得定位通知（advice）可獨立于OO層次。 例如，一個提供聲明式事務(wù)管理的around通知可以被應用到一組橫跨多個對象中的方法上（例如服務(wù)層的所有業(yè)務(wù)操作）。

21、Spring通知有哪些類型？

參考：https://blog.csdn.net/qq_32331073/article/details/80596084

（1）前置通知（Before advice）：在某連接點（join point）之前執(zhí)行的通知，但這個通知不能阻止連接點前的執(zhí)行（除非它拋出一個異常）。

（2）返回后通知（After returning advice）：在某連接點（join point）正常完成后執(zhí)行的通知：例如，一個方法沒有拋出任何異常，正常返回。

（3）拋出異常后通知（After throwing advice）：在方法拋出異常退出時執(zhí)行的通知。

（4）最終通知（After (finally) advice）：當某連接點退出的時候執(zhí)行的通知（不論是正常返回的還是異常退出的）。

（5）環(huán)繞通知（Around Advice）：包圍一個連接點（join point）的通知，如方法調(diào)用。這是最強大的一種通知類型。 環(huán)繞通知可以在方法調(diào)用前后完成自定義的行為。它也會選擇是否繼續(xù)執(zhí)行連接點或直接返回它們自己的返回值或拋出異常來結(jié)束執(zhí)行。 環(huán)繞通知是最常用的一種通知類型。大部分基于攔截的AOP框架，例如Nanning和JBoss4，都只提供環(huán)繞通知。

使用注解法實現(xiàn)通知時，使用同一個aspect，但使用不同的advice的執(zhí)行順序：

（1）沒有異常情況下的執(zhí)行順序：

around before advice

before advice

target method 執(zhí)行

around after advice

after advice

afterReturning

（2）有異常情況下的執(zhí)行順序：

around before advice

before advice

target method 執(zhí)行

around after advice

after advice

afterThrowing:異常發(fā)生

java.lang.RuntimeException: 異常發(fā)生

22、介紹一下Spring有哪些模塊及其作用？

1、Spring core 是spring框架的核心，提供了IOC和依賴注入特性。

2、Spring Context 提供了一種框架風格的方式來訪問對象，繼承了beans包的功能，同時增加了國際化、事件傳播、資源裝載、以及透明創(chuàng)建上下文。

3、Spring AOP 通過配置管理，直接將面向切面編程技術(shù)集成到了框架之中。

4、Spring DAO 提供了JDBC的抽象層?？梢韵唛L的JDBC編碼和數(shù)據(jù)庫廠商特有的錯誤代碼。

5、Spring ORM Spring框架插入了若干個ORM框架，從而提供了ORM對象關(guān)系工具，其中包括JDO、Hibernate、Ibatis、Mybatis等，所有這些都遵從Spring的事務(wù)和DAO異常層次結(jié)構(gòu)。

6、Spring Web 此模塊建立在應用程序上下文模塊程序之上，為web應用程序提供了上下文，所以他支持與Struts1或Struts2或SpringMVC的集成。

7、SpringMVC是一個全功能的構(gòu)建web應用程序的mvc實現(xiàn)。

8、Spring ORM是對象與表關(guān)系映射，通過對象直接操作表。

23、自動掃描包

在一個稍大的項目中，通常會有上百個組件，如果這些組件采用XML的bean定義來配置，顯然會增加配置文件的體積，查找及維護起來也不太方便。

Spring2.5為我們引入了組件自動掃描機制，使用注解 后可以在類路徑底下尋找標注了@Component、@Service、@Controller、@Repository注解的類，并把這些類納入進Spring容器中管理，它的作用和在XML文件中使用bean節(jié)點配置組件是一樣的。

24、常見Spring注解的解釋

@Controller：只能用控制器類上

@Service：只能用在業(yè)務(wù)類上

@Repository：只能用在dao類上

@Component：工具類的組件使用此注解

@Bean：在方法上面使用@Bean注解代表聲明一個創(chuàng)建bean的工廠方法，并且交給Spring容器管理；當使用此Bean時直接使用@Autowire進行注入即可。

@Aspect：表明整個類是一個切面。

@Component：標記該類是一個組件，spring掃描注解配置時，會標記這些類要生成bean

@Pointcut：注解聲明對應的方法為切入點。

@Inject：和@Autowired注解一樣，@Inject可以用來自動裝配屬性、方法和構(gòu)造器；與@Autowired不同的是，@Inject沒有required屬性。因此@Inject注解所標注的依賴關(guān)系必須存在，如果不存在，則會拋出異常。

@Named：相對于@Autowired對應的Qualifier，@Inject所對應的是@Named注解。

25、注解的分類

注解分為兩類：

1、一類是使用Bean，即是把已經(jīng)在xml文件中配置好的Bean拿來用，完成屬性、方法的組裝；比如@Autowired , @Resource，可以通過byTYPE（@Autowired）、byNAME（@Resource）的方式獲取Bean；

2、一類是注冊Bean,@Component , @Repository , @ Controller , @Service , @Configration這些注解都是把你要實例化的對象轉(zhuǎn)化成一個Bean，放在IoC容器中，等你要用的時候，它會和上面的@Autowired , @Resource配合到一起，把對象、屬性、方法完美組裝。

26、談?wù)勀銓pring的理解

從spring的工作原理、核心技術(shù)、優(yōu)缺點

spring的工作原理：

spring是按照設(shè)計模式精細打造的，它實現(xiàn)了工廠模式的工廠類，這個類名為BeanFactory（接口），常常使用它的子接口ApplicationContext

spring的核心是IOC（控制反轉(zhuǎn)），IOC是一種設(shè)計思想，用于實現(xiàn)模塊之間的解耦，在Spring中它的作用是對對象的創(chuàng)建，維護和銷毀生命周期的控制。IOC:把對象的創(chuàng)建、初始化、銷毀、交給Spring來管理，而不是由開發(fā)者，實現(xiàn)了控制反轉(zhuǎn)

spring是一個大的工廠類，spring的特點就是基于配置，在其配置文件中通過來創(chuàng)建實例對象

根據(jù)業(yè)務(wù)邏輯來看，對象經(jīng)常不是獨立的，一個對象的創(chuàng)建往往涉及到另一個對象的

創(chuàng)建，當然這個對象也要由IOC容器負責，負責的方式就是依賴注入DI,通過反射機制實現(xiàn)。有三種注入方式：（1）接口注入、（2）構(gòu)造器注入、（3）setter方法注入。

另外一個工作原理AOP請參考前面的答案。

Spring的核心技術(shù)

Spring的核心技術(shù)：IOC、AOP

Java的高級特性：反射機制，代理

AOP：面向切面編程，系統(tǒng)中有很多各不相干的類的方法，在這眾多方法中加入某種系統(tǒng)功能的代碼，如加入日志、權(quán)限、判斷等，AOP可以實現(xiàn)橫切關(guān)注點（如日志，安全，緩存和事務(wù)管理）與他們所影響的對象之間的解耦。

實現(xiàn)AOP功能采用的是代理技術(shù)，調(diào)用代理類，代理類與目標類具有相同的方法聲明。

AOP在spring中主要表現(xiàn)在兩個方面：提供聲明式的事務(wù)管理、spring支持用戶自定義切面

AOP主要包括通知（advice）切點（point cut）連接點（join point）

Spring的優(yōu)缺點

Spring的核心概念是IOC和AOP，這兩個核心服務(wù)的對象是bean，定位是一個輕量級的框架。

優(yōu)點：

Spring中避免了關(guān)鍵字new造成的耦合問題

Spring本身就是一個工廠，不需要再編寫工廠類

Spring不需要進行明確的引用關(guān)系的傳遞，直接通過配置完成

所有框架幾乎都可以在spring中整合使用

Spring編程=factory設(shè)計模式+proxy設(shè)計模式

缺點：

應用代碼與Spring的API發(fā)生了緊耦合。Spring模塊眾多，學習成本高。Spring的內(nèi)容太龐大，隨便打斷點查﹁看的時候會出現(xiàn)十幾二十層代碼，代碼非常復雜，閱覽性不強，在實際開發(fā)的過程中spring的角色更像是膠水一樣，將不同的框架粘合整合起來，充當整合粘合各種技術(shù)的角色，同時作為bean的容器。

27、延遲和立即加載的優(yōu)點

延遲實例化的優(yōu)點（BeanFactory）

應用啟動的時候占用資源很少；對資源要求較高的應有，比較有優(yōu)勢

立即實例化的優(yōu)點（ApplicationContext）

1.所有的Bean在啟動的時候都加載，系統(tǒng)運行的速度快

2.在啟動的時候所有Bean都加載，就能在系統(tǒng)啟動的時候盡早的發(fā)現(xiàn)系統(tǒng)中的配置問題

3.建議web應用中，在啟動的時候就把所有的Bean都加載了（把費時操作放到系統(tǒng)啟動中完成）

28、Spring框架中，工廠模式，單例模式，代理模式在哪里有應用

（1）工廠模式：BeanFactory用來創(chuàng)建對象的實例。

通常由應用程序直接使用new創(chuàng)建新的對象，為了將對象的創(chuàng)建和使用相分離，采用工廠模式,即應用程序?qū)ο蟮膭?chuàng)建及初始化職責交給工廠對象。一般情況下,應用程序有自己的工廠對象來創(chuàng)建bean.如果將應用程序自己的工廠對象交給Spring管理,那么Spring管理的就不是普通的bean,而是工廠Bean。

（2）單例模式：在spring配置文件中定義的bean默認為單例模式。

1.餓漢模式

將構(gòu)造方法設(shè)為私有，并設(shè)置成員變量并初始化對象（立即加載）。通過靜態(tài)方法返回初始化對象

2.懶漢模式

將構(gòu)造方法設(shè)為私有，設(shè)置成員變量并不初始化（延遲加載），通過靜態(tài)方法返回new出的對象，首先判斷成員變量是否為空，然后為new出對象的代碼加上鎖，最后再判斷一次成員變量是否為空，最后new出對象

3.靜態(tài)內(nèi)部類實現(xiàn)

靜態(tài)內(nèi)部類雖然保證了單例在多線程并發(fā)下的線程安全，但是在遇到序列化對象時，默認的方式運行得到的結(jié)果就是多例的

4.static靜態(tài)代碼塊實現(xiàn)

5.內(nèi)部枚舉類實現(xiàn)

（3）代理模式：在AOP和remoting中被用的比較多。

靜態(tài)代理和動態(tài)代理本質(zhì)區(qū)別：是否需要修改源代碼（不包含測試類），就可以控制代理內(nèi)容的變化。

A. 靜態(tài)代理：程序?qū)懞弥?，想修改代理過程，就必須修改源代碼。

優(yōu)點：可以做到在符合開閉原則的情況下對目標對象進行功能擴展。

缺點：需要為每一個服務(wù)都得創(chuàng)建代理類，工作量太大，不易管理。同時接口一旦發(fā)生改變，代理類也得相應修改。

B. 動態(tài)代理：程序?qū)懞煤?，更改代理過程。只需要修改代理對象（分身）

JDK動態(tài)代理：代理類實現(xiàn)invocationHandler

優(yōu)點：相對于靜態(tài)代理，動態(tài)代理大大減少了我們的開發(fā)任務(wù)，同時減少了對業(yè)務(wù)接口的依賴，降低了耦合度。

缺點：需要被代理類實現(xiàn)接口。

CGLIB動態(tài)代理：CGLib采用了非常底層的字節(jié)碼技術(shù)，其原理是通過字節(jié)碼技術(shù)為一個類創(chuàng)建子類，并在子類中采用方法攔截的技術(shù)攔截所有父類方法的調(diào)用，順勢織入橫切邏輯。但因為采用的是繼承，所以不能對final修飾的類進行代理。

優(yōu)點：CGLIB創(chuàng)建的動態(tài)代理對象比JDK創(chuàng)建的動態(tài)代理對象的性能更高，對于單例的對象，因為無需頻繁創(chuàng)建對象，用CGLIB合適。

缺點：CGLIB創(chuàng)建代理對象時所花費的時間卻比JDK多得多。

JDK動態(tài)代理是需要根據(jù)接口創(chuàng)建出新的實現(xiàn)類，新的實現(xiàn)類是目標類的代理類。而CGLIB是根據(jù)父類創(chuàng)建出新的子類，新的子類就是父類的代理類，

29、Spring通知有哪五種常見類型？

1.前置通知：

<aop:before method=“before” pointcut-ref=“pc01”/>

在目標方法執(zhí)行之前執(zhí)行通知

前置通知方法，可以沒有參數(shù)，也可以額外接收一個JoinPoint，Spring會自動將該對象傳入，代表當前的連接點，通過該對象可以獲取目標對象和目標方法相關(guān)的信息。

注意，如果接收JoinPoint，必須保證其為方法的第一個參數(shù)，否則報錯。

2.環(huán)繞通知：

<aop:around method=“around” pointcut-ref=“pc1”/>

在目標方法執(zhí)行之前和之后都可以執(zhí)行額外代碼的通知

在環(huán)繞通知中必須顯式的調(diào)用目標方法，目標方法才會執(zhí)行，這個顯式調(diào)用時通過ProceedingJoinPoint來實現(xiàn)的，可以在環(huán)繞通知中接收一個此類型的形參，spring容器會自動將該對象傳入，注意這個參數(shù)必須處在環(huán)繞通知的第一個形參位置。

注意：只有環(huán)繞通知可以接收ProceedingJoinPoint，而其他通知只能接收JoinPoint。

環(huán)繞通知需要返回返回值，否則真正調(diào)用者將拿不到返回值，只能得到一個null。

環(huán)繞通知有控制目標方法是否執(zhí)行、有控制是否返回值、有改變返回值的能力。環(huán)繞通知雖然有這樣的能力，但一定要慎用，不是技術(shù)上不可行，而是要小心不要破壞了軟件分層的“高內(nèi)聚 低耦合”的目標。

3.后置通知

<aop:after-returning method=“afterReturn” pointcut-ref=“pc1”/>

在目標方法執(zhí)行之后執(zhí)行的通知。在后置通知中也可以選擇性的接收一個JoinPoint來獲取連接點的額外信息，但是這個參數(shù)必須處在參數(shù)列表的第一個。

在后置通知中，還可以通過returning屬性配置：

<aop:after-returning method=“method3AfterReturning” pointcut-ref=“pointCut3” returning=“returnParam”/>

獲取返回值，一定要保證JoinPoint處在參數(shù)列表的第一位，否則拋異常

4.異常通知

<aop:after-throwing method=“afterThrow” pointcut-ref=“pc1” throwing=“e”/>

在目標方法拋出異常時執(zhí)行的通知，可以配置傳入JoinPoint獲取目標對象和目標方法相關(guān)信息，但必須處在參數(shù)列表第一位。另外，還可以配置throwing="e"參數(shù)，讓異常通知可以接收到目標方法拋出的異常對象

5.最終通知

<aop:after method=“after” pointcut-ref=“pc1” />

是在目標方法之后執(zhí)行的通知。和后置通知不同之處在于，后置通知是在方法正常返回后執(zhí)行的通知，如果方法沒有正常返-例如拋出異常，則后置通知不會執(zhí)行。而最終通知無論如何都會在目標方法調(diào)用過后執(zhí)行，即使目標方法沒有正常的執(zhí)行完成，類似于finally代碼塊的效果。另外，后置通知可以通過配置得到返回值，而最終通知無法得到。最終通知也可以額外接收一個JoinPoint參數(shù)，來獲取目標對象和目標方法相關(guān)信息，但一定要保證必須是第一個參數(shù)。

30、ApplicationContext接口常見的3個實現(xiàn)類分別是什么？

（1）FileSystemXmlApplicationContext ：此容器從一個XML文件中加載beans的定義，XML Bean 配置文件的全路徑名必須提供給它的構(gòu)造函數(shù)。用在直接從硬盤上某一個位置加載XML配置文件。

（2）ClassPathXmlApplicationContext：此容器也從一個XML文件中加載beans的定義，這里，你需要正確設(shè)置classpath因為這個容器將在classpath里找bean配置。用在在類路徑中加載XML配置文件，適用于Java類型的項目。

（3）WebXmlApplicationContext：此容器加載一個XML文件，此文件定義了一個WEB應用的所有bean。用在在WEB環(huán)境中加載XML配置文件，適用于web類型的項目。

31、介紹一下三種實現(xiàn)IOC的方式？

? （1）構(gòu)造器依賴注入：構(gòu)造器依賴注入通過容器執(zhí)行一個類的構(gòu)造器來實現(xiàn)的，該類有一系列參數(shù)，每個參數(shù)代表一個對其他類的依賴。

? （2）Setter方法注入：Setter方法注入是容器通過調(diào)用無參構(gòu)造器或無參static工廠 方法實例化bean之后，調(diào)用該bean的setter方法，即實現(xiàn)了基于setter的依賴注入。

（3）注解注入：使用@autowire注解進行注入

32、IOC容器中的Bean可以來自于哪些方式？

（1）XML配置文件。

（2）基于注解。

（3）基于javaconfig。

33、談一下@autowired 和@resource區(qū)別是什么？

1、共同點

兩者都可以寫在字段和setter方法上。兩者如果都寫在字段上，那么就不需要再寫setter方法。

2、不同點

（1）@Autowired

@Autowired為Spring提供的注解，需要導入包org.springframework.beans.factory.annotation.Autowired;只按照byType注入。

@Autowired注解是按照類型（byType）裝配依賴對象，默認情況下它要求依賴對象必須存在，如果允許null值，可以設(shè)置它的required屬性為false。如果我們想使用按照名稱（byName）來裝配，可以結(jié)合@Qualifier注解一起使用。

（2）@Resource

@Resource默認按照ByName自動注入，由J2EE提供，需要導入包javax.annotation.Resource。@Resource有兩個重要的屬性：name和type，而Spring將@Resource注解的name屬性解析為bean的名字，而type屬性則解析為bean的類型。所以，如果使用name屬性，則使用byName的自動注入策略，而使用type屬性時則使用byType自動注入策略。如果既不制定name也不制定type屬性，這時將通過反射機制使用byName自動注入策略。

34、介紹Spring中常見注解及解釋？

@Component：是一個標識類是IOC容器的一個組件確保被掃描器識別,注入進來

@Repossitory：聲明dao層

@Lazy(value=true) ：延遲加載

@Configuration：起到配置定義的作用,細節(jié)就是@Bean創(chuàng)建了JavaBean的細節(jié)信息

@ComponentScan(basePackages="")：掃包,也可以進行類掃描

@Scope(scopeName=“singleton”)：單例

@Scope(scopeName=“prototype”)：多例

@Service：聲明業(yè)務(wù)類

@Autowrite：反射注入，如果找不到符合的JavaBean對象時,控制臺會出現(xiàn)NoSuchBeanDefinitionException

@Primary：當Spring不知道具體注入那個實現(xiàn)類對象,使用這個設(shè)置優(yōu)先級

@Qualifier：給service主鍵設(shè)置一個別名,注入指定別名的主鍵，適用于1個接口多個實現(xiàn)類

@Resource官方：可以使用byName或byType形式進行注入

@ImportResource(value=“ac.xml”)：在Java類中導入xml文件中的配置

35、Spring怎么配置事務(wù)（具體說出一些關(guān)鍵的xml 元素）

配置事務(wù)的方法有兩種：

1）、基于XML的事務(wù)配置。

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"> <!-- 數(shù)據(jù)元信息 -->

<bean id="dataSource"

class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

<property name="driverClassName"

value="oracle.jdbc.driver.OracleDriver" />

<property name="url"

value="jdbc:oracle:thin:@rj-t42:1521:elvis" />

<property name="username" value="root" />

<property name="password" value="root" />

</bean>

<!-- 管理事務(wù)的類,指定我們用誰來管理我們的事務(wù) -->

<bean id="txManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<property name="dataSource" ref="dataSource" />

</bean>

<!-- 首先我們要把服務(wù)對象聲明成一個bean 例如HelloService -->

<bean id="helloService" class="com.yintong.service.HelloService" />

<!-- 然后是聲明一個事物建議tx:advice,spring為我們提供了事物的封裝，這個就是封裝在了<tx:advice/>中 --> <!-- <tx:advice/>有一個transaction-manager屬性，我們可以用它來指定我們的事物由誰來管理。 默認：事務(wù)傳播設(shè)置是

REQUIRED，隔離級別是DEFAULT -->

<tx:advice id="txAdvice" transaction-manager="txManager"> <!-- 配置這個事務(wù)建議的屬性 -->

<tx:attributes>

<!-- 指定所有g(shù)et開頭的方法執(zhí)行在只讀事務(wù)上下文中 -->

<tx:method name="get*" read-only="true" /> <!-- 其余方法執(zhí)行在默認的讀寫上下文中 -->

<tx:method name="*" />

</tx:attributes>

</tx:advice>

<!-- 我們定義一個切面，它匹配FooService接口定義的所有操作 -->

<aop:config>

<!-- <aop:pointcut/>元素定義AspectJ的切面表示法，這里是表示com.yintong.service.helloService包下的任意方法。 -->

<aop:pointcut id="helloServiceOperation"

expression="execution(* com.yintong.service.helloService.*(..))" />

<!-- 然后我們用一個通知器：<aop:advisor/>把這個切面和tx:advice綁定在一起，表示當這個切面：fooServiceOperation執(zhí)行時tx:advice定義的通知邏輯將被執(zhí)行 -->

<aop:advisor advice-ref="txAdvice"

pointcut-ref="helloServiceOperation" />

</aop:config>

</beans>

2）、基于注解方式的事務(wù)配置。

@Transactional：直接在Java源代碼中聲明事務(wù)的做法讓事務(wù)聲明和將受其影響的代碼距離更近了，而且一般來說不會有不恰當?shù)鸟詈系娘L險，因為，使用事務(wù)性的代碼幾乎總是被部署在事務(wù)環(huán)境中。

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<bean id="helloService" class="com.yintong.service.HelloService" />

<bean id="txManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<property name="dataSource" ref="dataSource" />

</bean>

<!-- 配置注解事務(wù) -->

<tx:annotation-driven

transaction-manager="txManager" />

</beans>

36、在Spring中可以通過哪幾種方式實現(xiàn)注入

可以在Spring中使用4種方式實現(xiàn)注入：

（1）get/set方法注入

（2）構(gòu)造器注入

（3）靜態(tài)工廠方法注入

（4）實例工廠方法注入

37、如何在Spring中解決循環(huán)依賴的問題？

http://www.itdecent.cn/p/b65c57f4d45d

http://www.itdecent.cn/p/4463b9b81249

http://www.itdecent.cn/p/8bb67ca11831

https://www.cnblogs.com/chenpt/p/9896618.html

總結(jié)：不要使用有叁構(gòu)造注入，使用set方法解決循環(huán)依賴。

38、配置文件ApplicationContext.xml可以改成其它名字嗎？

缺省情況下，它會在WEB-INF/applicationContext.xml文件找Spring的配置?？梢酝ㄟ^定義一個元素名字為”contextConfigLocation”來改變Spring配置文件的位置。示例如下：

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/xyz.xml</param-value>

</context-param>

39、自動裝配有哪些局限性 ?

　　（1）重寫： 仍需用 和 配置來定義依賴，意味著總要重寫自動裝配。

　　（2）基本數(shù)據(jù)類型：不能自動裝配簡單的屬性，如基本數(shù)據(jù)類型，String字符串，和類。

　?。?）模糊特性：自動裝配不如顯式裝配精確，如果有可能，建議使用顯式裝配。