面试: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配置启动容器)

spring

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">admin@nospam.com</prop>    
            <prop key="support">support@nospam.com</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">admin@nospam.com</prop>    
            <prop key="support">support@nospam.com</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)原来的别名设置在映射文件里面放在了核心配置文件里

发布了21 篇原创文章 · 获赞 78 · 访问量 1万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 书香水墨 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览