美团 Java 最新面试题 - Spring - 朱坤乾的博客

1:什么是 Spring 框架？Spring 框架有哪些主要模块？

spring框架是一个轻量级的java开发框架，为应用开发提供平台。

spring主要框架包括7个模块spring core,spring aop,spring context,spring web,spring web mvc,spring orm,spring Dap

Spring框架是一个为Java应用程序的开发提供了综合、广泛的基础性支持的Java平台。
Spring帮助开发者解决了开发中基础性的问题，使得开发人员可以专注于应用程序的开发。
Spring框架本身亦是按照设计模式精心打造，这使得我们可以在开发环境中安心的集成Spring框架，不必担心Spring是如何在后台进行工作的。
Spring框架至今已集成了20多个模块。这些模块主要被分如下图所示的核心容器、数据访问/集成,、Web、AOP（面向切面编程）、工具、消息和测试模块。

2:使用 Spring 框架能带来哪些好处？

下面列举了一些使用 Spring 框架带来的主要好处：

1、Dependency Injection(DI依赖注入) 方法使得构造器和 JavaBean properties 文件中的依赖关系一

目了然。

2、与 EJB 容器相比较，IOC 容器更加趋向于轻量级。这样一来 IOC 容器在有限的内存和 CPU

资源的情况下进行应用程序的开发和发布就变得十分有利。

3、Spring 并没有闭门造车，Spring 利用了已有的技术比如 ORM 框架、logging 框架、J2EE、

Quartz 和 JDK Timer，以及其他视图技术。

4、Spring 框架是按照模块的形式来组织的。由包和类的编号就可以看出其所属的模块，开发者

仅仅需要选用他们需要的模块即可。

5、要测试一项用 Spring 开发的应用程序十分简单，因为测试相关的环境代码都已经囊括在框

架中了。更加简单的是，利用 JavaBean 形式的 POJO 类，可以很方便的利用依赖注入来写入测

试数据。

6、Spring 的 Web 框架亦是一个精心设计的 Web MVC 框架，为开发者们在 web 框架的选择

上提供了一个除了主流框架比如 Struts、过度设计的、不流行 web 框架的以外的有力选项。

7、Spring 提供了一个便捷的事务管理接口，适用于小型的本地事务处理（比如在单 DB 的环境

下）和复杂的共同事务处理（比如利用 JTA 的复杂 DB 环境）。

3:什么是控制反转(IOC)？什么是依赖注入？

1、控制反转是应用于软件工程领域中的，在运行时被装配器对象来绑定耦合对象的一种编程技

巧，对象之间耦合关系在编译时通常是未知的。在传统的编程方式中，业务逻辑的流程是由应用

程序中的早已被设定好关联关系的对象来决定的。在使用控制反转的情况下，业务逻辑的流程是

由对象关系图来决定的，该对象关系图由装配器负责实例化，这种实现方式还可以将对象之间的

关联关系的定义抽象化。而绑定的过程是通过“依赖注入”实现的。

2、控制反转是一种以给予应用程序中目标组件更多控制为目的设计范式，并在我们的实际工作

中起到了有效的作用。

3、依赖注入是在编译阶段尚未知所需的功能是来自哪个的类的情况下，将其他对象所依赖的功

能对象实例化的模式。这就需要一种机制用来激活相应的组件以提供特定的功能，所以依赖注入

是控制反转的基础。否则如果在组件不受框架控制的情况下，框架又怎么知道要创建哪个组件？

4、在 Java 中依然注入有以下三种实现方式：

1.构造器注入

2.Setter 方法注入

3.接口注入

ioc:控制反转和依赖倒置。所谓控制反转即把控制器反转，即把造对象的控制权反转，在没有ioc以前，自己new对象，现在把控制权交给spring容器，在初始化上下文以后，spring容器中保管了多个实例对象并维护他们的生命周期，spring会根据你的需要把对象给你。所谓依赖倒置，即依赖接口编程，依赖于抽象而不是具体实现，松散耦合。

aop:面向切面编程，与主线业务无关，存在于多个模块的通用的被调用执行的职责代码，把这些代码封装起来，减少重复代码，松散耦合。包括事务，日志。让开发者能够更清晰的针对主业务进行开发，不被事务日志等迷惑。同时更利于后续的改进和二次开发。

4:请解释下 Spring 框架中的 IoC？

Spring 中的 org.springframework.beans 包和 org.springframework.context 包构成了

Spring 框架 IOC 容器的基础。

BeanFactory 接口提供了一个先进的配置机制，使得任何类型的对象的配置成为可能。

ApplicationContex 接口对 BeanFactory（是一个子接口）进行了扩展，在 BeanFactory 的基

础上添加了其他功能，比如与 Spring 的 AOP 更容易集成，也提供了处理 message resource

的机制（用于国际化）、事件传播以及应用层的特别配置，比如针对 Web 应用的

WebApplicationContext。

5:BeanFactory 和 ApplicationContext 有什么区别？

BeanFactory 可以理解为含有 bean 集合的工厂类。BeanFactory 包含了种 bean 的定义，以

便在接收到客户端请求时将对应的 bean 实例化。

BeanFactory 还能在实例化对象的时生成协作类之间的关系。此举将 bean 自身与 bean 客户端

的配置中解放出来。BeanFactory 还包含了 bean 生命周期的控制，调用客户端的初始化方法

（initialization methods）和销毁方法（destruction methods）。

从表面上看，application context 如同 bean factory 一样具有 bean 定义、bean 关联关系的

设置，根据请求分发 bean 的功能。但 application context 在此基础上还提供了其他的功能。

1.提供了支持国际化的文本消息

2.统一的资源文件读取方式

3.已在监听器中注册的 bean 的事件

以下是三种较常见的 ApplicationContext 实现方式：

1、ClassPathXmlApplicationContext：从 classpath 的 XML 配置文件中读取上下文，并生成

上下文定义。应用程序上下文从程序环境变量中取得。

ApplicationContext context = new ClassPathXmlApplicationContext(“application.xml”);

2、FileSystemXmlApplicationContext ：由文件系统中的 XML 配置文件读取上下文。

ApplicationContext context = new FileSystemXmlApplicationContext(“application.xml”);

3、XmlWebApplicationContext：由 Web 应用的 XML 文件读取上下文。

6:Spring 提供几种配置方式来设置元数据？

将 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。

class=”org.springframework.web.servlet.view.BeanNameViewResolver”/>

class=”org.springframework.web.servlet.view.json.MappingJackson2JsonView”/>

下面这个 web.xml 仅仅配置了 DispatcherServlet，这件最简单的配置便能满足应用程序配置运行时组件的需求。

Archetype Created Web Application

spring

org.springframework.web.servlet.DispatcherServlet

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 配置文件如下：

上述配置方式的实例化方式如下：利用 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.lalala")

public class AppConfig {

}

在上面的例子中，com.lalala 包首先会被扫到，然后再容器内查找被@Component 声明

的类，找到后将这些类按照 Sring bean 定义进行注册。

如果你要在你的 web 应用开发中选用上述的配置的方式的话，需要用

AnnotationConfigWebApplicationContext 类来读取配置文件，可以用来配置 Spring 的

Servlet 监听器 ContrextLoaderListener 或者 Spring MVC 的 DispatcherServlet。

instead of the default XmlWebApplicationContext -->

contextClass

org.springframework.web.context.support.AnnotationConfigWebApplicationContext

fully-qualified @Configuration classes. Fully-qualified packages may also be

specified for component-scanning -->

contextConfigLocation

com.lalala.AppConfig

org.springframework.web.context.ContextLoaderListener

ss>

dispatcher

org.springframework.web.servlet.DispatcherServlet

instead of the default XmlWebApplicationContext -->

contextClass

org.springframework.web.context.support.AnnotationConfigWebApplicationContext

and fully-qualified @Configuration classes -->

contextConfigLocation

com.lalala.web.MVCConfig

dispatcher

/web/*

9、怎样用注解的方式配置 Spring？

spring 常用注解说明:

#####　　（1）用于对象的注解

　　　　我们将用于被扫描创建对象的注解，统称为组件注解。

　　　　组件注解包括：@Component、@Controller、@Service、@Repository

　　　@Controller：用于声明表示层的组件注解展示层Bean

　　　　@Service：用于声明服务层的组件注解业务层Bean

　　　　@Repository：用于声明持久层的组件注解存储层Bean

　　　　@Component：用于声明三层以外的组件注解　　

（2）用于依赖注入的注解

　　回顾：XML 配置文件使用  <property name=""  ref="" > 实现注入的，通过注解也可以实现。

　　　　① @Autowired 注解　　　　　　作用：用于给引用注入容器的对象。

　　　　属性：request：指定注入的对象是否允许为空，如果 required=true。表示不可以为空。

　　　　使用 @Autowired 注入的三种情况

第一种：在属性上面注入

//表示层使用@Controller
//如果组件注解不声明对象名，默认使用默认命名法，
//所谓的默认命名就是，将类的首字符小写作为类的对象名
//组件注解 
   //属性 value:作用用于指定该类对象的自定义对象名
@Controller(value="customerAction")
public class CustomerAction {

    @Autowired
    private CustomerService customerService=null;

第二种：在方法上面注入

//表示层使用@Controller
//如果组件注解不声明对象名，默认使用默认命名法，
//所谓的默认命名就是，将类的首字符小写作为类的对象名
//组件注解 
   //属性 value:作用用于指定该类对象的自定义对象名
@Controller(value="customerAction")
public class CustomerAction {

    
    private CustomerService customerService=null;

    //注意，如果将@Autowired方法方法上面，意思就是将对象注入到该的方法的参数
    //意味着：Spring会自动根据参数的CustomerService类型匹配容器中对应的对象给它
    //注意：能够使用@Autowired注解的方法是必须有参数的
    @Autowired
    public void setCustomerService(CustomerService customerService) {
        //问题：加了@Autowired的方法哎启动的时候是否执行了？
        //答：如果该方法没有执行，那么this.customerService的对象从哪里来呢？
        //加了@Autowired在启动项目的时候是必须自动执行的
        System.out.println("-setCustomerService已经被执行-");
        this.customerService = customerService;
    }

    public void save(){
        System.out.println("-保存客户-CustomerAction");
        customerService.save();
    }

第三种：在构造方法上面注入

//业务层，使用 @Service
@Service
public class CustomerServiceImpl implements CustomerService{
    
    
    //如果构造方法加入@Autowired，Spring框架会自动匹配容器中是否有对应参数类的对象，将对象赋予构造方法的参数
    //如果要使用@Autowired给构造方法注入对象，该构造方法必须要有参数
    @Autowired
    public CustomerServiceImpl(CustomerDAO customerDAO) {
        super();
        this.customerDAO = customerDAO;
    }

    private CustomerDAO customerDAO;
    
    @Override
    public void save(){
        System.out.println("-保存客户-CustomerService");
        customerDAO.save();
    }

#####　　（3）@Qualifier 注解

　　　　作用：用于指定注入的对象名，使用 @Autowired 注入对象时，@Autowired 没有指定对象名的属性，只能通过 @Qualifier 字段给容器中对象命名。

　　　　属性：value：指定注入 Spring 容器中对应对象的对象名

#####　　（4）@Resource 注解

　　　　@Resource 注解是 Spring 框架支持 Sun 官方制定的 JSR-250 标准注入对象的实现。

　　　　JSR-250 就是 Sun 公司制定，对注入的对象的标准。

　　　　@Resource 功能等同于 @Autowired + @Qualifier，等同配置文件标签

　　　　@Resource 注解：用于给引用注入容器的对象，可以通过 name 属性制定对象名

　　　　问题：在现实开发中，没有强制要求使用 @Autowired 或者 @Resource，两个都可以使用。但是因为 @Autowired 是 Spring 自带的机制。所以建议使用 @Autowired.

　　　　注意事项：@Resource 只能注入方法和属性，不能注入构造方法

#####　　（5）@Value 注解

　　　　@Value：只能设置标量类型 = 基础数据类型 + 包装类 + String

　　　　@Value 注解：注入基本数据类型以及它们的包装类和 String 类型数据的，支持 ${} 注入 Properties 文件的键值对，等同于。

　　　　属性：value：注入基本数据类型和 String 类型数据的。

示例代码 IoC 的实现

　　　通过注解的方式，实现 Spring 框架 IoC（控制反转）的配置

　　（1）导入框架需要的 jar 包

　　（2）创建配置文件 bean.xml

　　　　创建一个配置文件，加入指定扫描的包的路径

<?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd">
   <!-- 声明扫描包以及子包的类。如果发现有组件注解的类，就创建对象，并加入到容器 -->
   <context:component-scan base-package="com.mgy"></context:component-scan>
</beans>

　　（3）编写类的内容代码

　　　　通过注解的方式，实现将类注入到容器里面。从 DAO 层开始。

　　　　持久层的实现

package com.mgy.dao;

public interface CustomerDAO {
    
    public void save();

}

package com.zhukq.dao.impl;

import org.springframework.stereotype.Repository;

import com.zhukq.dao.CustomerDAO;
//持久层，使用的组件注解为@Repository
@Repository
public class CustomerDAOImpl implements CustomerDAO {
    
    @Override
    public void save(){
        System.out.println("-保存客户数据-dao");
    }

}

	业务层的实现

package com.zhukq.service;

public interface CustomerService {
    
    /**
     * 声明一个注册方法
     */
     void reigster();
}

package com.zhukq.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.zhukq.dao.CustomerDAO;
import com.zhukq.service.CustomerService;
//业务层，使用Service组件注解
@Service
public class CustomerServiceImpl implements CustomerService{
    //通过@Autowired给customerDAO引用注入Spring容器的对象
    @Autowired
    private CustomerDAO customerDAO;
    

    public void reigster(){
        System.out.println("--注册客户-service");
        customerDAO.save();
    }

}

　　　　表示层的实现

package com.zhukq.action;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;

import com.zhukq.service.CustomerService;

//表示层，使用@Controller组件注解
@Controller
public class CustomerAction {
    //使用@Resource注解将Spring容器的对象注入给customerService引用
    @Resource
    private CustomerService customerService;
    
    public void register() {
        System.out.println("-客户注册-action");
        customerService.reigster();
    }

}

　　（4）测试代码

package com.zhukq.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zhukq.action.CustomerAction;

public class CustomerServiceTest {
    
    public static void main(String[] args) {
        //CustomerService cs=new CustomerService();
         //读取bean.xml配置文件，根据bean.xml的配置创建对象，放在容器里面
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("classpath:bean.xml");
        //从容器中获得customerAction对象
        CustomerAction customerAction = context.getBean("customerAction",CustomerAction.class);
         //调用注册方法
        customerAction.register();
        //关闭容器
        context.close();
    }
}

　　（5）@Qualifier 注解的使用

　　　　在 IoC 的实现的代码的 Service 层增加一个同样继承 CustomerService 的类发现，再运行程序竟然报错了。

　　　　为什么呢？

　　　　首先我们必须先理解 Spring 创建对象到注入对象的原理。

　　　　——— Spring 对象创建流程

　　　　① 在启动 Spring 框架的时候，框架先根据去获得该包下的所有的类名。

　　　　② 通过反射技术，根据类名获得类结构的组件注解，如果有就创建对象，如果没有就忽略该类。

　　　　③ 创建对象后将对象放在 Spring 容器里面，如果不在组件注解的 value 指定对象名，使用的是默认命名法：就是取类名的首字母修改为小写为对象名，如：CustomerDaoImpl 的对象名为 customerDaoImpl

　　　　———- Spring 对象注入流程

　　　　Spring 将容器里面的对象注入给声明的引用

　　　　① 首先匹配引用的类型在容器中是否存在兼容类型的对象。就是匹配引用的类型是否是父类或者相同类型的类，如果匹配的类型的对象只有一个直接将对象注入到该引用。

　　　　② 如果匹配的类型的对象不是唯一的，将引用的属性名匹配 Spring 容器对象的对象名，如果找到对象名一样的，就注入相同对象名的对象。

　　　　根据 Spring 对象注入流程，如果出现两个类型一样的对象，必须要指定对应的对象名。指定对象名的方式有两种：

　　　　第一种：在组件注入使用 value=”对象名” 指定

package com.zhukq.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.zhukq.dao.CustomerDAO;
import com.zhukq.service.CustomerService;
//指定注入到容器里面时，对象的对象名
@Service(value="customerService")
public class CustomerServiceImpl implements CustomerService{
    
    @Autowired
    private CustomerDAO customerDAO;
    

    public void reigster(){
        System.out.println("--注册客户-service");
        customerDAO.save();
    }
}

　　　　第二种：在注入对象给引用时指定

　　　　通过 @Qualifier 指定

　　（6）@Value 注解的使用

　　　　@Value 注解：注入基本数据类型和 String 类型数据的

5、用于设置 Spring 容器对象生命周期的注解

　　Spring 是通过 @Scope 注解来指定对象的生命周期的。

　　　　scope：用于设置对象的作用范围，可选参数如下：

　　　　　　singleton：单例

　　　　　　　　对象出生：当程序加载配置文件创建容器时创建

　　　　　　　　对象存活：只要容器存在，一直存活

　　　　　　　　对象死亡：应用停止，容器销毁，对象死亡

　　　　　　prototype：多例（原型对象）

　　　　　　　　对象出生：当程序加载配置文件创建容器时创建

　　　　　　　　对象存活：只要对象被使用，一直存活

　　　　　　　　对象死亡：对象长时间不用，会被 Java 垃圾回收机制回收

　　　　　　request：web 项目中，Spring 将创建的对象放在 request 作用域中

　　　　　　session：web 项目中，Spring 将创建的对象放在 session 作用域中

（1）@Scope 注解

　　　　作用：指定 bea 的作用范围

　　　　属性：value：指定范围的值

　　　　取值：singleton、prototype、request、session

（2）示例代码 — 获得单例对象

　　　　所谓的单例对象，就是每次从 Spring 容器获得的对象就是同一个对象。默认不加 @Scope 或者声明 @Scope(value=”singleton”) 都是单例

　　　　组件类：

package com.zhukq.service;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

@Service
//默认不写，或者声明value="singleton"
//都是声明当前类的对象为一个单例对象
@Scope(value="singleton")
public class CustomerService {
    
    public void reigster(){
        System.out.println("-客户注册-");
    }
}

　　（4）和生命周期相关的注解

　　　　① @PostConstruct 注解等同于

　　　　作用：用于指定初始化方法

　　　　② @PreDestroy 注解等同于

　　　　作用：用于指定销毁方法

　　　　示例代码：

　　　　组件类

package com.zhukq.service;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

@Service
//默认不写，或者声明value="singleton"
//都是声明当前类唯一个单列对象
@Scope(value="singleton")
public class CustomerService {
    //对象初始方法
    @PostConstruct
    public void init(){
        System.out.println("初始化必须调用该方法");
    }
    

    public void reigster(){
        System.out.println("-客户注册-");
    }
    
    //对象注销前，必须调用该方法
    @PreDestroy
    public void destroy(){
        System.out.println("注销前必须调用该方法");
    }

}

有了这两个方法，可以在调用service的时候在初始化和注销的时候做一些事情

6、纯注解配置

　　用 @Configuration 注解和 @ComponentScan 注解替代 XML文件和，就可以完全不用 XML 就可以进行配置了。替换 XML 配置文件的 @Configuration 注解

　　@Configuration 配置类注解，在纯注解配置中，类加了该注解，就意味着该类是 Spring 的配置类。该类的功能就是用来替代原来的 XML 配置文件。

　　作用：用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解。获取容器时需要使用 AnnotationConfigApplicationContext(有　@Configuration 注解的类.class) @ComponentScan 注解

　　@ComponentScan 注解扫描类，作用就是配置扫描 Spring 组件类的路径。功能等同原来配置文件的

　　作用：用于指定 Spring 在初始化容器时要扫描的包。作用和在 Spring 的 XML 配置文件中的：是一样的。

　　属性：basePackage：用于指定要扫描的包，和该注解中的 value 属性作用一样 @PropertySource 注解

　　作用：用于加载 .properties 文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到 properties 配置文件中，就可以使用此注解指定 properties 配置文件的位置。等同于 XML 配置文件中的：

　　属性：value[]：用于指定 properties 文件位置。如果是在类路径下，需要写上 classpath @Bean 注解

　　作用：该注解只能写在方法上，使用此方法创建一个对象，并且放入 Spring 容器中。它就相当于我们之前在 XML 配置中介绍的

　　属性：name：给当前 @Bean 注解方法创建的对象指定一个名称（即 bean 的 id） @Import 注解

　　作用：用于导入其他配置类，在引入其他配置类时，可以不用再写 @Configuration 注解。当然，写上也没有问题。

　　属性：value[]：用于指定其他配置类的字节码

　　　　③ 编写配置类代码

　　　　　　通过该配置类的代码替换掉 Spring 配置文件

package com.zhukq.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

//1.使用@Configuration声明该类为一个Spring配置类
@Configuration
//2.使用@ComponentScan指定扫描的包路径
@ComponentScan(basePackages="com.zhukq")
public class BeanConfig {
    
}

7、Spring 整合 Junit

　　以上的代码，测试类都是通过 main 方法来测试的。当然我们最专业的单元测试工具是 Junit。你可以简单地将 main 方法换成 Junit。代码如下：

package com.zhukq.test;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.zhukq.service.CustomerService;
public class CustomerServiceTest {
    
    //简单实用Junit单元测试工具
    @Test
    public  void customerService() {

        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("classpath:bean.xml");
        CustomerService customerService = context.getBean("customerService",CustomerService.class);
        customerService.save();
        context.close();
    }
}

　　Junit 测试

package com.zhukq.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.zhukq.service.CustomerService;
//指定Junit之前测试之前，加入Spring框架启动的逻辑代码
@RunWith(SpringJUnit4ClassRunner.class)
//指定Spring启动必须的配置文件
//注意：配置文件通过locations指定
@ContextConfiguration(locations="classpath:bean.xml")
public class CustomerServiceTest {
    
    //获得Spring容器中的对象
    @Autowired
    private CustomerService customerService;
    

    //直接调用@Autowired获得容器对象
    @Test
    public void reigster() {
        customerService.reigster();

    }

}

8、总结

（1）首先要知道注解的配置与 XML 的配置功能一样

（2）理解注解的配置与 XML 的配置分别有什么作用

—— 组件注解

　　作用：用于声明类为一个注解类，Spring 会在启动的时候，根据扫描的包的范围，将这些加了组件注解的类创建对象，并且放在容器里面

　　@Component、@Controller、@Service、@Repository

　　— 依赖注入（不用 new）

　　@Autowired 作用：用于依赖注入，将容器里面的对象注入到对应的属性、构造方法的参数、方法的参数等同于

　　@Qualifier 作用：在容器中同一个类型的对象出现多个，可以通过 @Qualifier 指定对象名来获得指定的对象

　　@Resource(name=”对象名”) 等同于 @Autowired + @Qualifier

　　@Resource 的作用也是用于注入对象的，是 Java JSR250 标准的支持。注意：该注解不能将对象注入到构造方法的参数上面

　　@Value 作用：如果注入的不是对象，而是一个标量类型，可以使用 @Value

　　— 声明周期

　　@Scope 作用：用于指定创建的对象的生命周期，是单例、原型

　　　　注意：@Scope 如果放在方法上面，必须要和 @Bean 注解结合使用

　　@PostConstruct 作用：用于指定初始化方法

　　@PreDestroy 作用：用于指定容器销毁之前执行的方法

　　— 纯注解的支持（替换配置文件）

　　@Configuration 作用：用于声明类是一个配置类

　　@ComponentScan 作用：用于扫描组件类创建对象到容器

　　@PropertySource 作用：用于对 Properties 文件的支持

　　@Bean 作用：用于将非组件类的对象加入到 Spring 容器中

　　@Import(了解)作用：用于导入其他的配置类的配置

　　— 对 Junit 的整合的支持（了解）

　　@RunWith(SpringJUnit4ClassRunner.class) 作用：用于指定 Junit 测试之前，加入 Spring 框架启动的逻辑代码

　　@ContextConfiguration 作用：用于指定整合时配置文件（locations=”classpath:bean.xml”）或文件类（classes=BeanConfig.class）

10、请解释 Spring Bean 的生命周期？

Spring Bean 的生命周期简单易懂。在一个 bean 实例被初始化时，需要执行一系列的初始化操

作以达到可用的状态。同样的，当一个 bean 不在被调用时需要进行相关的析构操作，并从 bean

容器中移除。

Spring bean factory 负责管理在 spring 容器中被创建的 bean 的生命周期。Bean 的生命周期

由两组回调（call back）方法组成。

1.初始化之后调用的回调方法。

2.销毁之前调用的回调方法。

Spring 框架提供了以下四种方式来管理 bean 的生命周期事件：

1、InitializingBean 和 DisposableBean 回调接口

2、针对特殊行为的其他 Aware 接口

3、Bean 配置文件中的 Custom init()方法和 destroy()方法

4、@PostConstruct 和@PreDestroy 注解方式

使用 customInit()和 customDestroy()方法管理 bean 生命周期的代码样例如下：

init-method=”customInit” destroy-method=”customDestroy”>

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 内部使用。

public class Customer{

private Person person;

//Setters and Getters

}

public class Person{

private String name;

private String address;

private int age;

//Setters and Getters

}

13、Spring 框架中的单例 Beans 是线程安全的么？

Spring 框架并没有对单例 bean 进行任何多线程的封装处理。关于单例 bean 的线程安全和并发问题需要开发者自行去搞定。但实际上，大部分的 Spring bean 并没有可变的状态(比如 Serview类和DAO类)，所以在某种程度上说Spring的单例bean是线程安全的。如果你的bean 有多种状态的话（比如 View Model 对象），就需要自行保证线程安全。最浅显的解决办法就是将多态 bean 的作用域由“singleton”变更为“prototype”。

14、请举例说明如何在 Spring 中注入一个 Java 集合？

Spring提供了以下四种集合类的配置元素：

<list> : 该标签用来装配可重复的list值。
<set> : 该标签用来装配没有重复的set值。
<map>: 该标签可用来注入键和值可以为任何类型的键值对。
<props> : 该标签支持注入键和值都是字符串类型的键值对。

https://www.cnblogs.com/lihuibin/p/7928893.html

//普通java bean
public class NotificationBean {
    public Map hobby;
  
    public Map getHobby() {
        return hobby;
    }
 
    public void setHobby(Map hobby) {
        this.hobby = hobby;
    }
}

<!--配置文件application-spring.xml-->
<bean id="notificationBean" class="com.straw.spring.beans.NotificationBean">
    <property name="hobby">
        <map>
            <entry key="a" value="a"/>
            <entry key="b" value="b"/>
        </map>
    </property>
</bean>

//java 测试类
public class MainTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ap = new ClassPathXmlApplicationContext("application-spring.xml");
        NotificationBean notificationBean = (NotificationBean) ap.getBean("notificationBean");
        Map hobby = notificationBean.getHobby();
        Set<String> set = hobby.keySet();
        for (String s:set){
            System.out.println(s+":"+hobby.get(s));
        }
    }
}
//运行结果
a:a
b:b

其余三个同理,bean获取后通过get,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 的自动装配？

在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; }

推荐使用提示实现自动注入然后@Autowired注入

16、请解释各种自动装配模式的区别？

在 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 的自动装配方式

17、如何开启基于注解的自动装配？

要使用 @Autowired，需要注册 AutowiredAnnotationBeanPostProcessor，可以有以下两种方式来实现：

1::引入配置文件中的<bean>下引入 <context:annotation-config> ```

    2::在bean配置文件中直接引入AutowiredAnnotationBeanPostProcessor    这种比较老旧

###  18 、 自动装配有哪些局限性？

自动装配有如下局限性：

重写：你仍然需要使用 和< property>设置指明依赖，这意味着总要重写自动装配。

原生数据类型:你不能自动装配简单的属性，如原生类型、字符串和类。

模糊特性：自动装配总是没有自定义装配精确，因此，如果可能尽量使用自定义装配

###  19、请举例说明@Qualifier 注解？
@Qualifier 注解意味着可以在被标注 bean 的字段上可以自动装配。Qualifier 注解可以用来取

消 Spring 不能取消的 bean 应用。

下面的示例将会在 Customer 的 person 属性中自动装配 person 的值。

public class Customer{

@Autowired

private Person person;

}

下面我们要在配置文件中来配置 Person 类。

Spring 会知道要自动装配哪个 person bean 么？不会的，但是运行上面的示例时，会抛出下面

的异常：

Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException:

No unique bean of type [com.gupaoedu.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;

} ```

20、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);

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

Spring 框架中使用到了大量的设计模式，下面列举了比较有代表性的：

1、代理模式—在 AOP 和 remoting 中被用的比较多。

2、单例模式：在 spring 配置文件中定义的 bean 默认为单例模式。

3、模板模式：用来解决代码重复的问题。

比如. RestTemplate, JmsTemplate, JpaTemplate。

4、委派模式：Spring 提供了 DispatcherServlet 来对请求进行分发。

5、工厂模式：BeanFactory 用来创建对象的实例，贯穿于 BeanFactory / ApplicationContext 接口的核心理念。

6、代理模式：AOP 思想的底层实现技术，Spring 中采用 JDK Proxy 和 CgLib 类库。

FileSystemResource 和 ClassPathResource 有何区别？

在 FileSystemResource 中需要给出 spring-config.xml 文件在你项目中的相对路径或者绝对路径。在 ClassPathResource 中 spring 会在 ClassPath 中自动搜寻配置文件，所以要把 ClassPathResource 文件放在 ClassPath 下。

如果将 spring-config.xml 保存在了 src 文件夹下的话，只需给出配置文件的名称即可，因为 src 文件夹是默认。

简而言之，ClassPathResource 在环境变量中读取配置文件，FileSystemResource 在配置文件中读取配置文件。

Spring5 新特性

1、依赖 JDK 8+和 Java EE7+以上版本

2、首次采用反应式编程模型

3、支持使用注解进行编程

4、新增函数式编程

5、支持使用 REST 断点执行反应式编程

6、支持 HTTP 2.0

7、新增 Kotlin 和 Spring WebFlux

8、可使用 Lambda 表达式注册 Bean

9、Spring WebMVC 支持最新的 API

10、使用 JUnit5 执行条件和并发测试

11、使用 Spring WebFlux 执行集成测试

12、核心容器优化

美团 Java 最新面试题 - Spring

Spring