面試：Spring&SpringMVC&Mybatis 面試必備面試題

Spring&SpringMVC&Mybatis常見面試題。

歷史文章：

多線程史上最全面試題&持續更新中

dubbo&zookeeper55道高頻面試題（附加答案）

SpringCloud&SpringBoot經典面試題（附加答案）

Spring篇

1、什麼是Spring框架？Spring框架有哪些主要模塊？

Spring框架是一個爲Java應用程序的開發提供了綜合、廣泛的基礎性支持的Java平臺。

Spring幫助開發者解決了開發中基礎性的問題，使得開發人員可以專注於應用程序的開發。
Spring框架本身亦是按照設計模式精心打造，這使得我們可以在開發環境中安心的集成Spring框架，不必擔心Spring是如何在後臺進行工作的。
Spring框架至今已集成了20多個模塊。這些模塊主要被分如下圖所示的核心容器、數據訪問/集成,、Web、AOP（面向切面編程）、工具、消息和測試模塊。

2、使用Spring框架能帶來哪些好處？

下面列舉了一些使用Spring框架帶來的主要好處：
• Dependency Injection(DI) 方法使得構造器和JavaBean properties文件中的依賴關係一目瞭然。
• 與EJB容器相比較，IoC容器更加趨向於輕量級。這樣一來IoC容器在有限的內存和CPU資源的情況下進行應用程序的開發和發佈就變得十分有利。
• Spring並沒有閉門造車，Spring利用了已有的技術比如ORM框架、logging框架、J2EE、Quartz和JDK Timer，以及其他視圖技術。
• Spring框架是按照模塊的形式來組織的。由包和類的編號就可以看出其所屬的模塊，開發者僅僅需要選用他們需要的模塊即可。
• 要測試一項用Spring開發的應用程序十分簡單，因爲測試相關的環境代碼都已經囊括在框架中了。更加簡單的是，利用JavaBean形式的POJO類，可以很方便的利用依賴注入來寫入測試數據。
• Spring的Web框架亦是一個精心設計的Web MVC框架，爲開發者們在web框架的選擇上提供了一個除了主流框架比如Struts、過度設計的、不流行web框架的以外的有力選項。
• Spring提供了一個便捷的事務管理接口，適用於小型的本地事物處理（比如在單DB的環境下）和複雜的共同事物處理（比如利用JTA的複雜DB環境）。

3、什麼是控制反轉(IOC)？什麼是依賴注入？

控制反轉是應用於軟件工程領域中的，在運行時被裝配器對象來綁定耦合對象的一種編程技巧，對象之間耦合關係在編譯時通常是未知的。在傳統的編程方式中，業 務邏輯的流程是由應用程序中的早已被設定好關聯關係的對象來決定的。在使用控制反轉的情況下，業務邏輯的流程是由對象關係圖來決定的，該對象關係圖由裝配 器負責實例化，這種實現方式還可以將對象之間的關聯關係的定義抽象化。而綁定的過程是通過“依賴注入”實現的。
控制反轉是一種以給予應用程序中目標組件更多控制爲目的設計範式，並在我們的實際工作中起到了有效的作用。
依賴注入是在編譯階段尚未知所需的功能是來自哪個的類的情況下，將其他對象所依賴的功能對象實例化的模式。這就需要一種機制用來激活相應的組件以提供特定的功能，所以依賴注入是控制反轉的基礎。否則如果在組件不受框架控制的情況下，框架又怎麼知道要創建哪個組件？
在Java中依然注入有以下三種實現方式：

1. 構造器注入
2. Setter方法注入
3. 接口注入

4、請解釋下Spring框架中的IoC？

Spring中的 org.springframework.beans 包和 org.springframework.context包構成了Spring框架IoC容器的基礎。
BeanFactory 接口提供了一個先進的配置機制，使得任何類型的對象的配置成爲可能。ApplicationContex接口對BeanFactory（是一個子接口）進行了擴展，在BeanFactory的基礎上添加了其他功能，比如與Spring的AOP更容易集成，也提供了處理message resource的機制（用於國際化）、事件傳播以及應用層的特別配置，比如針對Web應用的WebApplicationContext。
org.springframework.beans.factory.BeanFactory 是Spring IoC容器的具體實現，用來包裝和管理前面提到的各種bean。BeanFactory接口是Spring IoC 容器的核心接口。
IOC:把對象的創建、初始化、銷燬交給spring來管理，而不是由開發者控制，實現控制反轉。

5、BeanFactory和ApplicationContext有什麼區別？

BeanFactory 可以理解爲含有bean集合的工廠類。BeanFactory 包含了種bean的定義，以便在接收到客戶端請求時將對應的bean實例化。
BeanFactory還能在實例化對象的時生成協作類之間的關係。此舉將bean自身與bean客戶端的配置中解放出來。BeanFactory還包含 了bean生命週期的控制，調用客戶端的初始化方法（initialization methods）和銷燬方法（destruction methods）。
從表面上看，application context如同bean factory一樣具有bean定義、bean關聯關係的設置，根據請求分發bean的功能。但applicationcontext在此基礎上還提供了其他的功能。

1. 提供了支持國際化的文本消息
2. 統一的資源文件讀取方式
3. 已在監聽器中註冊的bean的事件

以下是三種較常見的 ApplicationContext 實現方式：
1、ClassPathXmlApplicationContext：從classpath的XML配置文件中讀取上下文，並生成上下文定義。應用程序上下文從程序環境變量中
ApplicationContext context = new ClassPathXmlApplicationContext(“bean.xml”);
2、FileSystemXmlApplicationContext ：由文件系統中的XML配置文件讀取上下文。
ApplicationContext context = new FileSystemXmlApplicationContext(“bean.xml”);
3、XmlWebApplicationContext：由Web應用的XML文件讀取上下文。
4.AnnotationConfigApplicationContext(基於Java配置啓動容器)

6、Spring有幾種配置方式？

1. 基於XML的配置
2. 基於註解的配置
3. 基於Java的配置

7、如何用基於XML配置的方式配置Spring？

在Spring框架中，依賴和服務需要在專門的配置文件來實現，我常用的XML格式的配置文件。這些配置文件的格式通常用開頭，然後一系列的bean定義和專門的應用配置選項組成。
SpringXML配置的主要目的時候是使所有的Spring組件都可以用xml文件的形式來進行配置。這意味着不會出現其他的Spring配置類型（比如聲明的方式或基於Java Class的配置方式）
Spring的XML配置方式是使用被Spring命名空間的所支持的一系列的XML標籤來實現的。Spring有以下主要的命名空間：context、beans、jdbc、tx、aop、mvc和aso。
如：

<beans>    
    <!-- JSON Support -->    
    <bean name="viewResolver" class="org.springframework.web.servlet.view.BeanNameViewResolver"/>    
    <bean name="jsonTemplate" class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>    
    <bean id="restTemplate" class="org.springframework.web.client.RestTemplate"/>    
</beans>   
 

下面這個web.xml僅僅配置了DispatcherServlet，這件最簡單的配置便能滿足應用程序配置運行時組件的需求。

<web-app>    
    <display-name>Archetype Created Web Application</display-name>    
    <servlet>    
        <servlet-name>spring</servlet-name>    
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>    
        <load-on-startup>1</load-on-startup>    
    </servlet>    
    <servlet-mapping>    
        <servlet-name>spring</servlet-name>    
        <url-pattern>/</url-pattern>    
    </servlet-mapping>    
</web-app>  

8、如何用基於Java配置的方式配置Spring？

Spring對Java配置的支持是由@Configuration註解和@Bean註解來實現的。由@Bean註解的方法將會實例化、配置和初始化一個 新對象，這個對象將由Spring的IoC容器來管理。@Bean聲明所起到的作用與 元素類似。被 @Configuration所註解的類則表示這個類的主要目的是作爲bean定義的資源。被@Configuration聲明的類可以通過在同一個類的 內部調用@bean方法來設置嵌入bean的依賴關係。
最簡單的@Configuration 聲明類請參考下面的代碼：

@Configuration    
public class AppConfig{    
    @Bean    
    public MyService myService() {    
        return new MyServiceImpl();    
    }    
}  

對於上面的@Beans配置文件相同的XML配置文件如下：

<beans>    
    <bean id="myService" class="com.somnus.services.MyServiceImpl"/>    
</beans> 

上述配置方式的實例化方式如下：利用AnnotationConfigApplicationContext 類進行實例化。

public static void main(String[] args) {    
    ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);    
    MyService myService = ctx.getBean(MyService.class);    
    myService.doStuff();    
} 

要使用組件組建掃描，僅需用@Configuration進行註解即可：

@Configuration    
@ComponentScan(basePackages = "com.somnus")    
public class AppConfig  {    
    ...    
}  

在上面的例子中，com.acme包首先會被掃到，然後再容器內查找被@Component 聲明的類，找到後將這些類按照Sring bean定義進行註冊。
如果你要在你的web應用開發中選用上述的配置的方式的話，需要用AnnotationConfigWebApplicationContext 類來讀 取配置文件，可以用來配置Spring的Servlet監聽器ContextLoaderListener或者Spring MVC的DispatcherServlet。

<web-app>    
    <!-- Configure ContextLoaderListener to use AnnotationConfigWebApplicationContext    
        instead of the default XmlWebApplicationContext -->    
    <context-param>    
        <param-name>contextClass</param-name>    
        <param-value>    
            org.springframework.web.context.support.AnnotationConfigWebApplicationContext    
        </param-value>    
    </context-param>    
     
    <!-- Configuration locations must consist of one or more comma- or space-delimited    
        fully-qualified @Configuration classes. Fully-qualified packages may also be    
        specified for component-scanning -->    
    <context-param>    
        <param-name>contextConfigLocation</param-name>    
        <param-value>com.howtodoinjava.AppConfig</param-value>    
    </context-param>    
     
    <!-- Bootstrap the root application context as usual using ContextLoaderListener -->    
    <listener>    
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>    
    </listener>    
     
    <!-- Declare a Spring MVC DispatcherServlet as usual -->    
    <servlet>    
        <servlet-name>dispatcher</servlet-name>    
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>    
        <!-- Configure DispatcherServlet to use AnnotationConfigWebApplicationContext    
            instead of the default XmlWebApplicationContext -->    
        <init-param>    
            <param-name>contextClass</param-name>    
            <param-value>    
                org.springframework.web.context.support.AnnotationConfigWebApplicationContext    
            </param-value>    
        </init-param>    
        <!-- Again, config locations must consist of one or more comma- or space-delimited    
            and fully-qualified @Configuration classes -->    
        <init-param>    
            <param-name>contextConfigLocation</param-name>    
            <param-value>com.howtodoinjava.web.MvcConfig</param-value>    
        </init-param>    
    </servlet>    
     
    <!-- map all requests for /app/* to the dispatcher servlet -->    
    <servlet-mapping>    
        <servlet-name>dispatcher</servlet-name>    
        <url-pattern>/app/*</url-pattern>    
    </servlet-mapping>    
</web-app>

9、怎樣用註解的方式配置Spring？

Spring在2.5版本以後開始支持用註解的方式來配置依賴注入。可以用註解的方式來替代XML方式的bean描述，可以將bean描述轉移到組件類的 內部，只需要在相關類上、方法上或者字段聲明上使用註解即可。註解注入將會被容器在XML注入之前被處理，所以後者會覆蓋掉前者對於同一個屬性的處理結 果。
註解裝配在Spring中是默認關閉的。所以需要在Spring文件中配置一下才能使用基於註解的裝配模式。如果你想要在你的應用程序中使用關於註解的方法的話，請參考如下的配置。

<beans>    
   <context:annotation-config/>    
   <!-- bean definitions go here -->    
</beans>  

在 context:annotation-config/標籤配置完成以後，就可以用註解的方式在Spring中向屬性、方法和構造方法中自動裝配變量。
下面是幾種比較重要的註解類型：

1. @Required：該註解應用於設值方法。
2. @Autowired：該註解應用於有值設值方法、非設值方法、構造方法和變量。
3. @Qualifier：該註解和@Autowired註解搭配使用，用於消除特定bean自動裝配的歧義。
4. JSR-250 Annotations：Spring支持基於JSR-250 註解的以下註解，@Resource、@PostConstruct 和 @PreDestroy。

10、請解釋Spring Bean的生命週期？

Spring Bean的生命週期簡單易懂。在一個bean實例被初始化時，需要執行一系列的初始化操作以達到可用的狀態。同樣的，當一個bean不在被調用時需要進行相關的析構操作，並從bean容器中移除。
Spring bean factory 負責管理在spring容器中被創建的bean的生命週期。Bean的生命週期由兩組回調（call back）方法組成。

1. 初始化之後調用的回調方法。
2. 銷燬之前調用的回調方法。

Spring框架提供了以下四種方式來管理bean的生命週期事件：
• InitializingBean和DisposableBean回調接口
• 針對特殊行爲的其他Aware接口
• Bean配置文件中的Custom init()方法和destroy()方法
• @PostConstruct和@PreDestroy註解方式

使用customInit()和 customDestroy()方法管理bean生命週期的代碼樣例如下：

<beans>    
    <bean id="demoBean" class="com.somnus.task.DemoBean" 
    init-method="customInit" destroy-method="customDestroy"></bean>    
</beans>   

11、Spring Bean的作用域之間有什麼區別？

Spring容器中的bean可以分爲5個範圍。所有範圍的名稱都是自說明的，但是爲了避免混淆，還是讓我們來解釋一下：

1. singleton：這種bean範圍是默認的，這種範圍確保不管接受到多少個請求，每個容器中只有一個bean的實例，單例的模式由bean factory自身來維護。
2. prototype：原形範圍與單例範圍相反，爲每一個bean請求提供一個實例。
3. request：在請求bean範圍內會每一個來自客戶端的網絡請求創建一個實例，在請求完成以後，bean會失效並被垃圾回收器回收。
4. Session：與請求範圍類似，確保每個session中有一個bean的實例，在session過期後，bean會隨之失效。
5. global- session：global-session和Portlet應用相關。當你的應用部署在Portlet容器中工作時，它包含很多portlet。如果 你想要聲明讓所有的portlet共用全局的存儲變量的話，那麼這全局變量需要存儲在global-session中。

全局作用域與Servlet中的session作用域效果相同。

12、什麼是Spring inner beans？

在Spring框架中，無論何時bean被使用時，當僅被調用了一個屬性。一個明智的做法是將這個bean聲明爲內部bean。內部bean可以用setter注入“屬性”和構造方法注入“構造參數”的方式來實現。
比如，在我們的應用程序中，一個Customer類引用了一個Person類，我們的要做的是創建一個Person的實例，然後在Customer內部使用。

13、Spring框架中的單例Beans是線程安全的麼？

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

14、請舉例說明如何在Spring中注入一個Java Collection？

Spring提供了以下四種集合類的配置元素：
• : 該標籤用來裝配可重複的list值。
• : 該標籤用來裝配沒有重複的set值。
•

<beans>    
   <!-- Definition for javaCollection -->    
   <bean id="javaCollection" class="com.howtodoinjava.JavaCollection">    
      <!-- java.util.List -->    
      <property name="customList">    
        <list>    
           <value>INDIA</value>    
           <value>Pakistan</value>    
           <value>USA</value>    
           <value>UK</value>    
        </list>    
      </property>    
     
     <!-- java.util.Set -->    
     <property name="customSet">    
        <set>    
           <value>INDIA</value>    
           <value>Pakistan</value>    
           <value>USA</value>    
           <value>UK</value>    
        </set>    
      </property>    
     
     <!-- java.util.Map -->    
     <property name="customMap">    
        <map>    
           <entry key="1" value="INDIA"/>    
           <entry key="2" value="Pakistan"/>    
           <entry key="3" value="USA"/>    
           <entry key="4" value="UK"/>    
        </map>    
      </property>    
     
    <!-- java.util.Properties -->    
    <property name="customProperies">    
        <props>    
            <prop key="admin">[email protected]</prop>    
            <prop key="support">[email protected]</prop>    
        </props>    
    </property>    
     
   </bean>    
</beans>

15、如何向Spring Bean中注入一個Java.util.Properties？

第一種方法是使用如下面代碼所示的 標籤：

<bean id="adminUser" class="com.somnus.common.Customer">    
     
    <!-- java.util.Properties -->    
    <property name="emails">    
        <props>    
            <prop key="admin">[email protected]</prop>    
            <prop key="support">[email protected]</prop>    
        </props>    
    </property>    
     
</bean>   

也可用”util:”命名空間來從properties文件中創建出一個propertiesbean，然後利用setter方法注入bean的引用。

16、請解釋Spring Bean的自動裝配？

在Spring框架中，在配置文件中設定bean的依賴關係是一個很好的機制，Spring容器還可以自動裝配合作關係bean之間的關聯關係。這意味着 Spring可以通過向Bean Factory中注入的方式自動搞定bean之間的依賴關係。自動裝配可以設置在每個bean上，也可以設定在特定的bean上。
下面的XML配置文件表明瞭如何根據名稱將一個bean設置爲自動裝配：

<bean id="employeeDAO" 
class="com.howtodoinjava.EmployeeDAOImpl" autowire="byName" />   

除了bean配置文件中提供的自動裝配模式，還可以使用@Autowired註解來自動裝配指定的bean。在使用@Autowired註解之前需要在按照如下的配置方式在Spring配置文件進行配置纔可以使用。

<context:annotation-config />  

也可以通過在配置文件中配置AutowiredAnnotationBeanPostProcessor 達到相同的效果。

<bean class ="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>    

配置好以後就可以使用@Autowired來標註了。

@Autowired    
public EmployeeDAOImpl ( EmployeeManager manager ) {    
    this.manager = manager;    
}  

17、請解釋自動裝配模式的區別？

在Spring框架中共有5種自動裝配，讓我們逐一分析。

1. no：這是Spring框架的默認設置，在該設置下自動裝配是關閉的，開發者需要自行在bean定義中用標籤明確的設置依賴關係。
2. byName：該選項可以根據bean名稱設置依賴關係。當向一個bean中自動裝配一個屬性時，容器將根據bean的名稱自動在在配置文件中查詢一個匹配的bean。如果找到的話，就裝配這個屬性，如果沒找到的話就報錯。
3. byType：該選項可以根據bean類型設置依賴關係。當向一個bean中自動裝配一個屬性時，容器將根據bean的類型自動在在配置文件中查詢一個匹配的bean。如果找到的話，就裝配這個屬性，如果沒找到的話就報錯。
4. constructor：造器的自動裝配和byType模式類似，但是僅僅適用於與有構造器相同參數的bean，如果在容器中沒有找到與構造器參數類型一致的bean，那麼將會拋出異常。
5. autodetect：該模式自動探測使用構造器自動裝配或者byType自動裝配。首先，首先會嘗試找合適的帶參數的構造器，如果找到的話就是用構造器自動裝配，如果在bean內部沒有找到相應的構造器或者是無參構造器，容器就會自動選擇byTpe的自動裝配方式。

18、如何開啓基於註解的自動裝配？

要使用 @Autowired，需要註冊 AutowiredAnnotationBeanPostProcessor，可以有以下兩種方式來實現：
1、引入配置文件中的下引入 context:annotation-config

<beans>    
    <context:annotation-config />    
</beans>  

2、在bean配置文件中直接引入AutowiredAnnotationBeanPostProcessor

<beans>    
    <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>    
</beans>

19、請舉例解釋@Required註解？

在產品級別的應用中，IoC容器可能聲明瞭數十萬了bean，bean與bean之間有着複雜的依賴關係。設值註解方法的短板之一就是驗證所有的屬性是否被註解是一項十分困難的操作。可以通過在中設置“dependency-check”來解決這個問題。
在應用程序的生命週期中，你可能不大願意花時間在驗證所有bean的屬性是否按照上下文文件正確配置。或者你寧可驗證某個bean的特定屬性是否被正確的設置。即使是用“dependency-check”屬性也不能很好的解決這個問題，在這種情況下，你需要使用@Required 註解。

需要用如下的方式使用來標明bean的設值方法。

public class EmployeeFactoryBean extends AbstractFactoryBean<Object>{    
    private String designation;    
    public String getDesignation() {    
        return designation;    
    }    
    @Required    
    public void setDesignation(String designation) {    
        this.designation = designation;    
    }    
    //more code here    
}  

RequiredAnnotationBeanPostProcessor是Spring中的後置處理用來驗證被@Required 註解的bean屬性是否被正確的設置了。在使用RequiredAnnotationBeanPostProcesso來驗證bean屬性之前，首先要在IoC容器中對其進行註冊：

<bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor" />    

但是如果沒有屬性被用 @Required 註解過的話，後置處理器會拋出一個BeanInitializationException 異常。

20、請舉例解釋@Autowired註解？

@Autowired註解對自動裝配何時何處被實現提供了更多細粒度的控制。@Autowired註解可以像@Required註解、構造器一樣被用於在bean的設值方法上自動裝配bean的屬性，一個參數或者帶有任意名稱或帶有多個參數的方法。
比如，可以在設值方法上使用@Autowired註解來替代配置文件中的 元素。當Spring容器在setter方法上找到@Autowired註解時，會嘗試用byType 自動裝配。
當然我們也可以在構造方法上使用@Autowired 註解。帶有@Autowired 註解的構造方法意味着在創建一個bean時將會被自動裝配，即便在配置文件中使用 元素。

public class TextEditor {    
   private SpellChecker spellChecker;    
   @Autowired    
   public TextEditor(SpellChecker spellChecker){    
      System.out.println("Inside TextEditor constructor." );    
      this.spellChecker = spellChecker;    
   }    
   public void spellCheck(){    
      spellChecker.checkSpelling();    
   }    
} 

下面是沒有構造參數的配置方式：

<beans>    
     
   <context:annotation-config/>    
     
   <!-- Definition for textEditor bean without constructor-arg  -->    
   <bean id="textEditor" class="com.howtodoinjava.TextEditor"/>    
     
   <!-- Definition for spellChecker bean -->    
   <bean id="spellChecker" class="com.howtodoinjava.SpellChecker"/>    
     
</beans>   

21、請舉例說明@Qualifier註解？

@Qualifier註解意味着可以在被標註bean的字段上可以自動裝配。Qualifier註解可以用來取消Spring不能取消的bean應用。
下面的示例將會在Customer的person屬性中自動裝配person的值。

public class Customer{    
    @Autowired    
    private Person person;    
}   
 

下面我們要在配置文件中來配置Person類。

<bean id="customer" class="com.somnus.common.Customer" />    
     
<bean id="personA" class="com.somnus.common.Person" >    
    <property name="name" value="lokesh" />    
</bean>    
     
<bean id="personB" class="com.somnus.common.Person" >    
    <property name="name" value="alex" />    
</bean>  

Spring會知道要自動裝配哪個person bean麼？不會的，但是運行上面的示例時，會拋出下面的異常：

Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException:    
    No unique bean of type [com.howtodoinjava.common.Person] is defined:    
        expected single matching bean but found 2: [personA, personB]    
 

要解決上面的問題，需要使用 @Quanlifier註解來告訴Spring容器要裝配哪個bean：

public class Customer{    
    @Autowired    
    @Qualifier("personA")    
    private Person person;    
}  

22、構造方法注入和設值注入有什麼區別？

請注意以下明顯的區別：

1. 在設值注入方法支持大部分的依賴注入，如果我們僅需 要注入int、string和long型的變量，我們不要用設值的方法注入。對於基本類型，如果我們沒有注入的話，可以爲基本類型設置默認值。在構造方法 注入不支持大部分的依賴注入，因爲在調用構造方法中必須傳入正確的構造參數，否則的話爲報錯。
2. 設值注入不會重寫構造方法的值。如果我們對同一個變量同時使用了構造方法注入又使用了設置方法注入的話，那麼構造方法將不能覆蓋由設值方法注入的值。很明顯，因爲構造方法盡在對象被創建時調用。
3. 在使用設值注入時有可能還不能保證某種依賴是否已經被注入，也就是說這時對象的依賴關係有可能是不完整的。而在另一種情況下，構造器注入則不允許生成依賴關係不完整的對象。
4. 在設值注入時如果對象A和對象B互相依賴，在創建對象A時Spring會拋出sObjectCurrentlyInCreationException異常，因爲在B對象被創建之前A對象是不能被創建的，反之亦然。所以Spring用設值注入的方法解決了循環依賴的問題，因對象的設值方法是在對象被創建之前被調用的。

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

Spring的ApplicationContext 提供了支持事件和代碼中監聽器的功能。我們可以創建bean用來監聽在ApplicationContext 中發佈的事件。ApplicationEvent類和在ApplicationContext接口中處理的事件，如果一個bean實現了ApplicationListener接口，當一個ApplicationEvent 被髮布以後，bean會自動被通知。

public class AllApplicationEventListener implements ApplicationListener < ApplicationEvent >{    
    @Override    
    public void onApplicationEvent(ApplicationEvent applicationEvent)    
    {    
        //process event    
    }    
}  

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

1. 上下文更新事件（ContextRefreshedEvent）：該事件會在ApplicationContext被初始化或者更新時發佈。也可以在調用ConfigurableApplicationContext 接口中的refresh()方法時被觸發。
2. 上下文開始事件（ContextStartedEvent）：當容器調用ConfigurableApplicationContext的Start()方法開始/重新開始容器時觸發該事件。
3. 上下文停止事件（ContextStoppedEvent）：當容器調用ConfigurableApplicationContext的Stop()方法停止容器時觸發該事件。
4. 上下文關閉事件（ContextClosedEvent）：當ApplicationContext被關閉時觸發該事件。容器被關閉時，其管理的所有單例Bean都被銷燬。
5. 請求處理事件（RequestHandledEvent）：在Web應用中，當一個http請求（request）結束觸發該事件。

除了上面介紹的事件以外，還可以通過擴展ApplicationEvent 類來開發自定義的事件。

public class CustomApplicationEvent extends ApplicationEvent{    
    public CustomApplicationEvent ( Object source, final String msg ){    
        super(source);    
        System.out.println("Created a Custom event");    
    }    
}   

爲了監聽這個事件，還需要創建一個監聽器：

public class CustomEventListener implements ApplicationListener < CustomApplicationEvent >{    
    @Override    
    public void onApplicationEvent(CustomApplicationEvent applicationEvent) {    
        //handle event    
    }    
}  

之後通過applicationContext接口的publishEvent()方法來發布自定義事件。

CustomApplicationEvent customEvent = new 
CustomApplicationEvent(applicationContext, "Test message");    
applicationContext.publishEvent(customEvent);    

24、FileSystemResource和ClassPathResource有何區別？

在FileSystemResource 中需要給出spring-config.xml文件在你項目中的相對路徑或者絕對路徑。在ClassPathResource中spring會在ClassPath中自動搜尋配置文件，所以要把ClassPathResource 文件放在ClassPath下。
如果將spring-config.xml保存在了src文件夾下的話，只需給出配置文件的名稱即可，因爲src文件夾是默認。
簡而言之，ClassPathResource在環境變量中讀取配置文件，FileSystemResource在配置文件中讀取配置文件。

25、Spring 框架中都用到了哪些設計模式？

Spring框架中使用到了大量的設計模式，下面列舉了比較有代表性的：
o 代理模式—在AOP和remoting中被用的比較多。
o 單例模式—在spring配置文件中定義的bean默認爲單例模式。
o 模板方法—用來解決代碼重複的問題。比如. RestTemplate, JmsTemplate, JpaTemplate。
o 前端控制器—Spring提供了DispatcherServlet來對請求進行分發。
o 視圖幫助(View Helper )—Spring提供了一系列的JSP標籤，高效宏來輔助將分散的代碼整合在視圖裏。
o 依賴注入—貫穿於BeanFactory / ApplicationContext接口的核心理念。
o 工廠模式—BeanFactory用來創建對象的實例

26.開發中主要使用 Spring 的什麼技術 ?

①. IOC 容器管理各層的組件
②. 使用 AOP 配置聲明式事務
③. 整合其他框架.

27.簡述 AOP 和 IOC 概念 AOP

Aspect Oriented Program, 面向(方面)切面的編程;Filter(過濾器) 也是一種 AOP. AOP 是一種新的方法論, 是對傳統 OOP(Object-Oriented Programming, 面向對象編程) 的補充. AOP 的主要編程對象是切面(aspect), 而切面模塊化橫切關注點.可以舉例通過事務說明.

IOC: Invert Of Control, 控制反轉. 也成爲 DI(依賴注入)其思想是反轉 資源獲取的方向. 傳統的資源查找方式要求組件向容器發起請求查找資源.作爲 迴應, 容器適時的返回資源. 而應用了 IOC 之後, 則是容器主動地將資源推送 給它所管理的組件,組件所要做的僅是選擇一種合適的方式來接受資源. 這種行 爲也被稱爲查找的被動形式

28.在 Spring 中如何配置 Bean ?

Bean 的配置方式: 通過全類名（反射）、通過工廠方法（靜態工廠方法 & 實 例工廠方法）、FactoryBean

29.IOC 容器對 Bean 的生命週期:

①. 通過構造器或工廠方法創建 Bean 實例
②. 爲 Bean 的屬性設置值和對其他 Bean 的引用
③ . 將 Bean 實 例 傳 遞 給 Bean 後 置 處 理 器 的 postProcessBeforeInitialization 方法
④. 調用 Bean 的初始化方法(init-method)
⑤ . 將 Bean 實 例 傳 遞 給 Bean 後 置 處 理 器 的 postProcessAfterInitialization 方法
⑦. Bean 可以使用了
⑧. 當容器關閉時, 調用 Bean 的銷燬方法(destroy-method)

SpringMVC篇

1、什麼是SpringMvc？

SpringMvc是spring的一個模塊，基於MVC的一個框架，無需中間整合層來整合。

2、Spring MVC的優點：

1）它是基於組件技術的.全部的應用對象,無論控制器和視圖,還是業務對象之類的都是 java組件.並且和Spring提供的其他基礎結構緊密集成.

2）不依賴於Servlet API(目標雖是如此,但是在實現的時候確實是依賴於Servlet的)

3）可以任意使用各種視圖技術,而不僅僅侷限於JSP

4）支持各種請求資源的映射策略

5）它應是易於擴展的

3、SpringMVC工作原理？

1）客戶端發送請求到DispatcherServlet

2）DispatcherServlet查詢handlerMapping找到處理請求的Controller

3）Controller調用業務邏輯後，返回ModelAndView

4）DispatcherServlet查詢ModelAndView，找到指定視圖

5）視圖將結果返回到客戶端

4、SpringMVC流程？

1）用戶發送請求至前端控制器DispatcherServlet。

2）DispatcherServlet收到請求調用HandlerMapping處理器映射器。

3）處理器映射器找到具體的處理器(可以根據xml配置、註解進行查找)，生成處理器對象及處理器攔截器(如果有則生成)一併返回給DispatcherServlet。

4）DispatcherServlet調用HandlerAdapter處理器適配器。

5）HandlerAdapter經過適配調用具體的處理器(Controller，也叫後端控制器)。

6）Controller執行完成返回ModelAndView。

7）HandlerAdapter將controller執行結果ModelAndView返回給DispatcherServlet。

8）DispatcherServlet將ModelAndView傳給ViewReslover視圖解析器。

9）ViewReslover解析後返回具體View。

10）DispatcherServlet根據View進行渲染視圖（即將模型數據填充至視圖中）。

11）DispatcherServlet響應用戶。

6、SpringMvc的控制器是不是單例模式,如果是,有什麼問題,怎麼解決？

是單例模式,所以在多線程訪問的時候有線程安全問題,不要用同步,會影響性能的,解決方案是在控制器裏面不能寫字段。

7、如果你也用過struts2.簡單介紹下springMVC和struts2的區別有哪些?

1）springmvc的入口是一個servlet即前端控制器，而struts2入口是一個filter過慮器。

2）springmvc是基於方法開發(一個url對應一個方法)，請求參數傳遞到方法的形參，可以設計爲單例或多例(建議單例)，struts2是基於類開發，傳遞參數是通過類的屬性，只能設計爲多例。

3）Struts採用值棧存儲請求和響應的數據，通過OGNL存取數據，springmvc通過參數解析器是將request請求內容解析，並給方法形參賦值，將數據和視圖封裝成ModelAndView對象，最後又將ModelAndView中的模型數據通過reques域傳輸到頁面。Jsp視圖解析器默認使用jstl。

8、SpingMvc中的控制器的註解一般用那個,有沒有別的註解可以替代？

一般用@Conntroller註解,表示是表現層,不能用用別的註解代替。

9、 @RequestMapping註解用在類上面有什麼作用？

是一個用來處理請求地址映射的註解，可用於類或方法上。用於類上，表示類中的所有響應請求的方法都是以該地址作爲父路徑。

10、怎麼樣把某個請求映射到特定的方法上面？

直接在方法上面加上註解@RequestMapping,並且在這個註解裏面寫上要攔截的路徑

11、如果在攔截請求中,我想攔截get方式提交的方法,怎麼配置？

可以在@RequestMapping註解裏面加上method=RequestMethod.GET

12、怎麼樣在方法裏面得到Request,或者Session？

直接在方法的形參中聲明request,SpringMvc就自動把request對象傳入

13、我想在攔截的方法裏面得到從前臺傳入的參數,怎麼得到？

直接在形參裏面聲明這個參數就可以,但必須名字和傳過來的參數一樣

14、如果前臺有很多個參數傳入,並且這些參數都是一個對象的,那麼怎麼樣快速得到這個對象？

直接在方法中聲明這個對象,SpringMvc就自動會把屬性賦值到這個對象裏面。

15、SpringMvc中函數的返回值是什麼？

返回值可以有很多類型,有String, ModelAndView,當一般用String比較好。

16、SpringMVC怎麼樣設定重定向和轉發的？

在返回值前面加"forward:“就可以讓結果轉發,譬如"forward:user.do?name=method4” 在返回值前面加"redirect:“就可以讓返回值重定向,譬如"redirect:http://www.bing.com”

17、SpringMvc用什麼對象從後臺向前臺傳遞數據的？

通過ModelMap對象,可以在這個對象裏面用put方法,把對象加到裏面,前臺就可以通過el表達式拿到。

18、SpringMvc中有個類把視圖和數據都合併的一起的,叫什麼？

ModelAndView。

19、怎麼樣把ModelMap裏面的數據放入Session裏面？

可以在類上面加上@SessionAttributes註解,裏面包含的字符串就是要放入session裏面的key

20、SpringMvc怎麼和AJAX相互調用的？

通過Jackson框架就可以把Java裏面的對象直接轉化成Js可以識別的Json對象。

具體步驟如下 ：

 1）加入Jackson.jar 

 2）在配置文件中配置json的映射 

 3）在接受Ajax方法裏面可以直接返回Object,List等,但方法前面要加上@ResponseBody註解

21、當一個方法向AJAX返回特殊對象,譬如Object,List等,需要做什麼處理？

要加上@ResponseBody註解

22、SpringMvc裏面攔截器是怎麼寫的

有兩種寫法,一種是實現接口,另外一種是繼承適配器類,然後在SpringMvc的配置文件中配置攔截器即可：

<!-- 配置SpringMvc的攔截器 -->
<mvc:interceptors>    
    <!-- 配置一個攔截器的Bean就可以了 默認是對所有請求都攔截 -->   
    <bean id="myInterceptor" class="com.et.action.MyHandlerInterceptor">
    </bean>    
    <!-- 只針對部分請求攔截 -->    
    <mvc:interceptor>       
        <mvc:mapping path="/modelMap.do" />       
        <bean class="com.et.action.MyHandlerInterceptorAdapter" />  
    </mvc:interceptor>
</mvc:interceptors>

23、講下SpringMvc的執行流程

系統啓動的時候根據配置文件創建spring的容器, 首先是發送http請求到核心控制器disPatherServlet，spring容器通過映射器去尋找業務控制器，使用適配器找到相應的業務類，在進業務類時進行數據封裝，在封裝前可能會涉及到類型轉換，執行完業務類後使用ModelAndView進行視圖轉發，數據放在model中，用map傳遞數據進行頁面顯示。

MyBatis篇

1、什麼是MyBatis？

MyBatis是一個可以自定義SQL、存儲過程和高級映射的持久層框架。

2、講下MyBatis的緩存

MyBatis的緩存分爲一級緩存和二級緩存,一級緩存放在session裏面,默認就有,二級緩存放在它的命名空間裏,默認是不打開的,使用二級緩存屬性類需要實現Serializable序列化接口(可用來保存對象的狀態),可在它的映射文件中配置

3、Mybatis是如何進行分頁的？分頁插件的原理是什麼？

1）Mybatis使用RowBounds對象進行分頁，也可以直接編寫sql實現分頁，也可以使用Mybatis的分頁插件。

2）分頁插件的原理：實現Mybatis提供的接口，實現自定義插件，在插件的攔截方法內攔截待執行的sql，然後重寫sql。

舉例：select * from student，攔截sql後重寫爲：select t.* from （select * from student）t limit 0，10

4、簡述Mybatis的插件運行原理，以及如何編寫一個插件？

1）Mybatis僅可以編寫針對ParameterHandler、ResultSetHandler、StatementHandler、Executor這4種接口的插件，Mybatis通過動態代理，爲需要攔截的接口生成代理對象以實現接口方法攔截功能，每當執行這4種接口對象的方法時，就會進入攔截方法，具體就是InvocationHandler的invoke()方法，當然，只會攔截那些你指定需要攔截的方法。

2）實現Mybatis的Interceptor接口並複寫intercept()方法，然後在給插件編寫註解，指定要攔截哪一個接口的哪些方法即可，記住，別忘了在配置文件中配置你編寫的插件。

5、Mybatis動態sql是做什麼的？都有哪些動態sql？能簡述一下動態sql的執行原理不？

1）Mybatis動態sql可以讓我們在Xml映射文件內，以標籤的形式編寫動態sql，完成邏輯判斷和動態拼接sql的功能。

2）Mybatis提供了9種動態sql標籤：trim|where|set|foreach|if|choose|when|otherwise|bind。

3）其執行原理爲，使用OGNL從sql參數對象中計算表達式的值，根據表達式的值動態拼接sql，以此來完成動態sql的功能。

6、#{}和${}的區別是什麼？

1）#{}是預編譯處理，${}是字符串替換。

2）Mybatis在處理#{}時，會將sql中的#{}替換爲?號，調用PreparedStatement的set方法來賦值；

3）Mybatis在處理${}時，就是把${}替換成變量的值。

4）使用#{}可以有效的防止SQL注入，提高系統安全性。

7、爲什麼說Mybatis是半自動ORM映射工具？它與全自動的區別在哪裏？
答：Hibernate屬於全自動ORM映射工具，使用Hibernate查詢關聯對象或者關聯集合對象時，可以根據對象關係模型直接獲取，所以它是全自動的。而Mybatis在查詢關聯對象或關聯集合對象時，需要手動編寫sql來完成，所以，稱之爲半自動ORM映射工具。

8、Mybatis是否支持延遲加載？如果支持，它的實現原理是什麼？

1）Mybatis僅支持association關聯對象和collection關聯集合對象的延遲加載，association指的就是一對一，collection指的就是一對多查詢。在Mybatis配置文件中，可以配置是否啓用延遲加載lazyLoadingEnabled=true|false。

2）它的原理是，使用CGLIB創建目標對象的代理對象，當調用目標方法時，進入攔截器方法，比如調用a.getB().getName()，攔截器invoke()方法發現a.getB()是null值，那麼就會單獨發送事先保存好的查詢關聯B對象的sql，把B查詢上來，然後調用a.setB(b)，於是a的對象b屬性就有值了，接着完成a.getB().getName()方法的調用。這就是延遲加載的基本原理。

9、MyBatis與Hibernate有哪些不同？

1）Mybatis和hibernate不同，它不完全是一個ORM框架，因爲MyBatis需要程序員自己編寫Sql語句，不過mybatis可以通過XML或註解方式靈活配置要運行的sql語句，並將java對象和sql語句映射生成最終執行的sql，最後將sql執行的結果再映射生成java對象。

2）Mybatis學習門檻低，簡單易學，程序員直接編寫原生態sql，可嚴格控制sql執行性能，靈活度高，非常適合對關係數據模型要求不高的軟件開發，例如互聯網軟件、企業運營類軟件等，因爲這類軟件需求變化頻繁，一但需求變化要求成果輸出迅速。但是靈活的前提是mybatis無法做到數據庫無關性，如果需要實現支持多種數據庫的軟件則需要自定義多套sql映射文件，工作量大。

3）Hibernate對象/關係映射能力強，數據庫無關性好，對於關係模型要求高的軟件（例如需求固定的定製化軟件）如果用hibernate開發可以節省很多代碼，提高效率。但是Hibernate的缺點是學習門檻高，要精通門檻更高，而且怎麼設計O/R映射，在性能和對象模型之間如何權衡，以及怎樣用好Hibernate需要具有很強的經驗和能力纔行。

總之，按照用戶的需求在有限的資源環境下只要能做出維護性、擴展性良好的軟件架構都是好架構，所以框架只有適合纔是最好。

10、MyBatis的好處是什麼？

1）MyBatis把sql語句從Java源程序中獨立出來，放在單獨的XML文件中編寫，給程序的維護帶來了很大便利。

2）MyBatis封裝了底層JDBC API的調用細節，並能自動將結果集轉換成Java Bean對象，大大簡化了Java數據庫編程的重複工作。

3）因爲MyBatis需要程序員自己去編寫sql語句，程序員可以結合數據庫自身的特點靈活控制sql語句，因此能夠實現比Hibernate等全自動orm框架更高的查詢效率，能夠完成複雜查詢。

11、簡述Mybatis的Xml映射文件和Mybatis內部數據結構之間的映射關係？

Mybatis將所有Xml配置信息都封裝到All-In-One重量級對象Configuration內部。在Xml映射文件中，標籤會被解析爲ParameterMap對象，其每個子元素會被解析爲ParameterMapping對象。標籤會被解析爲ResultMap對象，其每個子元素會被解析爲ResultMapping對象。每一個<select>、<insert>、<update>、<delete>標籤均會被解析爲MappedStatement對象，標籤內的sql會被解析爲BoundSql對象。

12、什麼是MyBatis的接口綁定,有什麼好處？

接口映射就是在MyBatis中任意定義接口,然後把接口裏面的方法和SQL語句綁定,我們直接調用接口方法就可以,這樣比起原來了SqlSession提供的方法我們可以有更加靈活的選擇和設置.

13、接口綁定有幾種實現方式,分別是怎麼實現的?

接口綁定有兩種實現方式,一種是通過註解綁定,就是在接口的方法上面加上@Select@Update等註解裏面包含Sql語句來綁定,另外一種就是通過xml裏面寫SQL來綁定,在這種情況下,要指定xml映射文件裏面的namespace必須爲接口的全路徑名.

14、什麼情況下用註解綁定,什麼情況下用xml綁定？

當Sql語句比較簡單時候,用註解綁定；當SQL語句比較複雜時候,用xml綁定,一般用xml綁定的比較多

15、MyBatis實現一對一有幾種方式?具體怎麼操作的？

有聯合查詢和嵌套查詢,聯合查詢是幾個表聯合查詢,只查詢一次,通過在resultMap裏面配置association節點配置一對一的類就可以完成;嵌套查詢是先查一個表,根據這個表裏面的結果的外鍵id,去再另外一個表裏面查詢數據,也是通過association配置,但另外一個表的查詢通過select屬性配置。

16、Mybatis能執行一對一、一對多的關聯查詢嗎？都有哪些實現方式，以及它們之間的區別？

能，Mybatis不僅可以執行一對一、一對多的關聯查詢，還可以執行多對一，多對多的關聯查詢，多對一查詢，其實就是一對一查詢，只需要把selectOne()修改爲selectList()即可；多對多查詢，其實就是一對多查詢，只需要把selectOne()修改爲selectList()即可。

關聯對象查詢，有兩種實現方式，一種是單獨發送一個sql去查詢關聯對象，賦給主對象，然後返回主對象。另一種是使用嵌套查詢，嵌套查詢的含義爲使用join查詢，一部分列是A對象的屬性值，另外一部分列是關聯對象B的屬性值，好處是隻發一個sql查詢，就可以把主對象和其關聯對象查出來。

17、MyBatis裏面的動態Sql是怎麼設定的?用什麼語法?

MyBatis裏面的動態Sql一般是通過if節點來實現,通過OGNL語法來實現,但是如果要寫的完整,必須配合where,trim節點,where節點是判斷包含節點有內容就插入where,否則不插入,trim節點是用來判斷如果動態語句是以and 或or開始,那麼會自動把這個and或者or取掉。

18、Mybatis是如何將sql執行結果封裝爲目標對象並返回的？都有哪些映射形式？

第一種是使用標籤，逐一定義列名和對象屬性名之間的映射關係。

第二種是使用sql列的別名功能，將列別名書寫爲對象屬性名，比如T_NAME AS NAME，對象屬性名一般是name，小寫，但是列名不區分大小寫，Mybatis會忽略列名大小寫，智能找到與之對應對象屬性名，你甚至可以寫成T_NAME AS NaMe，Mybatis一樣可以正常工作。

有了列名與屬性名的映射關係後，Mybatis通過反射創建對象，同時使用反射給對象的屬性逐一賦值並返回，那些找不到映射關係的屬性，是無法完成賦值的。

19、Xml映射文件中，除了常見的select|insert|updae|delete標籤之外，還有哪些標籤？

還有很多其他的標籤，<resultMap>、<parameterMap>、<sql>、<include>、<selectKey>，加上動態sql的9個標籤，trim|where|set|foreach|if|choose|when|otherwise|bind等，其中爲sql片段標籤，通過標籤引入sql片段，爲不支持自增的主鍵生成策略標籤。

20、當實體類中的屬性名和表中的字段名不一樣，如果將查詢的結果封裝到指定pojo？

1）通過在查詢的sql語句中定義字段名的別名。

2）通過來映射字段名和實體類屬性名的一一對應的關係。

21、模糊查詢like語句該怎麼寫

1）在java中拼接通配符，通過#{}賦值

2）在Sql語句中拼接通配符 （不安全 會引起Sql注入）(後面mybatis更新了這個漏洞)

22、通常一個Xml映射文件，都會寫一個Dao接口與之對應, Dao的工作原理，是否可以重載？

不能重載，因爲通過Dao尋找Xml對應的sql的時候全限名+方法名的保存和尋找策略。接口工作原理爲jdk動態代理原理，運行時會爲dao生成proxy，代理對象會攔截接口方法，去執行對應的sql返回數據。

23、Mybatis映射文件中，如果A標籤通過include引用了B標籤的內容，請問，B標籤能否定義在A標籤的後面，還是說必須定義在A標籤的前面？

雖然Mybatis解析Xml映射文件是按照順序解析的，但是，被引用的B標籤依然可以定義在任何地方，Mybatis都可以正確識別。原理是，Mybatis解析A標籤，發現A標籤引用了B標籤，但是B標籤尚未解析到，尚不存在，此時，Mybatis會將A標籤標記爲未解析狀態，然後繼續解析餘下的標籤，包含B標籤，待所有標籤解析完畢，Mybatis會重新解析那些被標記爲未解析的標籤，此時再解析A標籤時，B標籤已經存在，A標籤也就可以正常解析完成了。

24、Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重複？

不同的Xml映射文件，如果配置了namespace，那麼id可以重複；如果沒有配置namespace，那麼id不能重複；畢竟namespace不是必須的，只是最佳實踐而已。原因就是namespace+id是作爲Map<String, MappedStatement>的key使用的，如果沒有namespace，就剩下id，那麼，id重複會導致數據互相覆蓋。有了namespace，自然id就可以重複，namespace不同，namespace+id自然也就不同。

25、Mybatis中如何執行批處理？

使用BatchExecutor完成批處理。

26、Mybatis都有哪些Executor執行器？它們之間的區別是什麼？

Mybatis有三種基本的Executor執行器，SimpleExecutor、ReuseExecutor、BatchExecutor。1）SimpleExecutor：每執行一次update或select，就開啓一個Statement對象，用完立刻關閉Statement對象。
2）ReuseExecutor：執行update或select，以sql作爲key查找Statement對象，存在就使用，不存在就創建，用完後，不關閉Statement對象，而是放置於Map3）BatchExecutor：完成批處理。

27、Mybatis中如何指定使用哪一種Executor執行器？

在Mybatis配置文件中，可以指定默認的ExecutorType執行器類型，也可以手動給DefaultSqlSessionFactory的創建SqlSession的方法傳遞ExecutorType類型參數。

28、Mybatis執行批量插入，能返回數據庫主鍵列表嗎？

能，JDBC都能，Mybatis當然也能。

29、Mybatis是否可以映射Enum枚舉類？

Mybatis可以映射枚舉類，不單可以映射枚舉類，Mybatis可以映射任何對象到表的一列上。映射方式爲自定義一個TypeHandler，實現TypeHandler的setParameter()和getResult()接口方法。TypeHandler有兩個作用，一是完成從javaType至jdbcType的轉換，二是完成jdbcType至javaType的轉換，體現爲setParameter()和getResult()兩個方法，分別代表設置sql問號佔位符參數和獲取列查詢結果。

30、如何獲取自動生成的(主)鍵值？

配置文件設置usegeneratedkeys 爲true

31、在mapper中如何傳遞多個參數？

1）直接在方法中傳遞參數，xml文件用#{0} #{1}來獲取

2）使用 @param 註解:這樣可以直接在xml文件中通過#{name}來獲取

32、resultType resultMap的區別？

1）類的名字和數據庫相同時，可以直接設置resultType參數爲Pojo類

2）若不同，需要設置resultMap 將結果名字和Pojo名字進行轉換

33、使用MyBatis的mapper接口調用時有哪些要求？

1）Mapper接口方法名和mapper.xml中定義的每個sql的id相同

2）Mapper接口方法的輸入參數類型和mapper.xml中定義的每個sql 的parameterType的類型相同

3）Mapper接口方法的輸出參數類型和mapper.xml中定義的每個sql的resultType的類型相同

4）Mapper.xml文件中的namespace即是mapper接口的類路徑。

34、Mybatis比IBatis比較大的幾個改進是什麼？

1）有接口綁定,包括註解綁定sql和xml綁定Sql

2）動態sql由原來的節點配置變成OGNL表達式3） 在一對一,一對多的時候引進了association,在一對多的時候引入了collection節點,不過都是在resultMap裏面配置

35、IBatis和MyBatis在覈心處理類分別叫什麼？

IBatis裏面的核心處理類交SqlMapClient,MyBatis裏面的核心處理類叫做SqlSession。

36、IBatis和MyBatis在細節上的不同有哪些？

1）在sql裏面變量命名有原來的#變量# 變成了#{變量}

2）原來的$變量$變成了${變量}

3）原來在sql節點裏面的class都換名字交type

4）原來的queryForObject queryForList 變成了selectOne selectList5）原來的別名設置在映射文件裏面放在了核心配置文件裏