Spring相关面试题

Spring框架介绍

https://blog.csdn.net/qq_30764991/article/details/79815989

Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将
面向接口的编程思想贯穿整个系统应用。Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod 	  
Johnson创建。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。

个人自己的理解：spring框架是可以解决对象之间的依赖关系的一种轻量级框架，可以与其他框架一起使用。
如企业常用的spring与struts2,hibernate,mybatis,springboot等

Spring的单例和多例

http://www.cnblogs.com/pilihaotian/p/5810887.html

在Spring中，bean可以被定义为两种模式：prototype（多例）和singleton（单例）

singleton（单例）：只有一个共享的实例存在，所有对这个bean的请求都会返回这个唯一的实例。

prototype（多例）：对这个bean的每次请求都会创建一个新的bean实例，类似于new。

Spring bean 默认是单例模式。

实战演示：

代码详见上一篇文章中的代码。

在配置文件中，修改这句代码为：

<bean id="hi" class="com.test.Hi" init-method="init" scope="singleton">

定义类的作用域?
当定义一个 在Spring里，我们还能给这个bean声明一个作用域。它可以通过bean 定义中的scope属性来定义。如，当Spring要在需要的时候每次生产一个新的bean实例，bean的scope属性被指定为prototype。另一方面，一个bean每次使用的时候必须返回同一个实例，这个bean的scope 属性 必须设为 singleton。

Spring框架支持以下五种bean的作用域：

singleton : bean在每个Spring ioc 容器中只有一个实例。
prototype：一个bean的定义可以有多个实例。
request：每次http请求都会创建一个bean，该作用域仅在基于web的Spring ApplicationContext情形下有效。
session：在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
global-session：在一个全局的HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
缺省的Spring bean 的作用域是Singleton.

底层如何实现的？

http://www.cnblogs.com/nickup/p/9800120.html

Spring对单例的底层实现，到底是饿汉式单例还是懒汉式单例呢？Spring框架对单例的支持是采用单例注册表的方式进行实现的—即用一个hashmap存储bean的名字及对应bean

public abstract class AbstractBeanFactory implements ConfigurableBeanFactory{  
       /** 
        * 充当了Bean实例的缓存，实现方式和单例注册表相同 
        */  
       private final Map singletonCache=new HashMap();  
       public Object getBean(String name)throws BeansException{  
           return getBean(name,null,null);  
       }  
    ...  
       public Object getBean(String name,Class requiredType,Object[] args)throws BeansException{  
          //对传入的Bean name稍做处理，防止传入的Bean name名有非法字符(或则做转码)  
          String beanName=transformedBeanName(name);  
          Object bean=null;  
          //手工检测单例注册表  
          Object sharedInstance=null;  
          //使用了代码锁定同步块，原理和同步方法相似，但是这种写法效率更高  
          synchronized(this.singletonCache){  
             sharedInstance=this.singletonCache.get(beanName);  
           }  
          if(sharedInstance!=null){  
             ...  
             //返回合适的缓存Bean实例  
             bean=getObjectForSharedInstance(name,sharedInstance);  
          }else{  
            ...  
            //取得Bean的定义  
            RootBeanDefinition mergedBeanDefinition=getMergedBeanDefinition(beanName,false);  
             ...  
            //根据Bean定义判断，此判断依据通常来自于组件配置文件的单例属性开关  
            //<bean id="date" class="java.util.Date" scope="singleton"/>  
            //如果是单例，做如下处理  
            if(mergedBeanDefinition.isSingleton()){  
               synchronized(this.singletonCache){  
                //再次检测单例注册表  
                 sharedInstance=this.singletonCache.get(beanName);  
                 if(sharedInstance==null){  
                    ...  
                   try {  
                      //真正创建Bean实例  
                      sharedInstance=createBean(beanName,mergedBeanDefinition,args);  
                      //向单例注册表注册Bean实例  
                       addSingleton(beanName,sharedInstance);  
                   }catch (Exception ex) {  
                      ...  
                   }finally{  
                      ...  
                  }  
                 }  
               }  
              bean=getObjectForSharedInstance(name,sharedInstance);  
            }  
           //如果是非单例，即prototpye，每次都要新创建一个Bean实例  
           //<bean id="date" class="java.util.Date" scope="prototype"/>  
           else{  
              bean=createBean(beanName,mergedBeanDefinition,args);  
           }  
    }  
    ...  
       return bean;  
    }  
    }

Spring AOP和IOC的底层实现

https://www.cnblogs.com/cyhzzu/p/6644981.html

IoC（Inversion of Control）  

  (1). IoC（Inversion of Control）是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。 对于Spring而言，就是由Spring来控制对象的生命周期和对象之间的关系；IoC还有另外一个名字——“依赖注入（Dependency Injection）”。从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，即由容器动态地将某种依赖关系注入到组件之中。  

(2). 在Spring的工作方式中，所有的类都会在spring容器中登记，告诉spring这是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

(3). 在系统运行中，动态的向某个对象提供它所需要的其他对象。  

(4). 依赖注入的思想是通过反射机制实现的，在实例化一个类时，它通过反射调用类中set方法将事先保存在HashMap中的类属性注入到类中。 总而言之，在传统的对象创建方式中，通常由调用者来创建被调用者的实例，而在Spring中创建被调用者的工作由Spring来完成，然后注入调用者，即所谓的依赖注入or控制反转。 注入方式有两种：依赖注入和设置注入； IoC的优点：降低了组件之间的耦合，降低了业务对象之间替换的复杂性，使之能够灵活的管理对象。

AOP（Aspect Oriented Programming）

(1). AOP面向方面编程基于IoC，是对OOP的有益补充；

(2). AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了 多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的 逻辑或责任封装起来，比如日志记录，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。

(3). AOP代表的是一个横向的关 系，将“对象”比作一个空心的圆柱体，其中封装的是对象的属性和行为；则面向方面编程的方法，就是将这个圆柱体以切面形式剖开，选择性的提供业务逻辑。而 剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹，但完成了效果。

(4). 实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

(5). Spring实现AOP：JDK动态代理和CGLIB代理 JDK动态代理：其代理对象必须是某个接口的实现，它是通过在运行期间创建一个接口的实现类来完成对目标对象的代理；其核心的两个类是InvocationHandler和Proxy。 CGLIB代理：实现原理类似于JDK动态代理，只是它在运行期间生成的代理对象是针对目标类扩展的子类。CGLIB是高效的代码生成包，底层是依靠ASM（开源的java字节码编辑类库）操作字节码实现的，性能比JDK强；需要引入包asm.jar和cglib.jar。     使用AspectJ注入式切面和@AspectJ注解驱动的切面实际上底层也是通过动态代理实现的。

Spring Boot和Spring Cloud区别？

https://blog.csdn.net/qq_39335514/article/details/80352843

有些童鞋刚接触这块 ，理解不是很深刻会经常问道这样类似的问题，下面我就简单讲解一下Spring boot与Spring cloud 之间的关系！

浅析Spring boot与Spring cloud 之间的关系

Spring boot 是 Spring 的一套快速配置脚手架，可以*~~基于spring boot 快速开发单个微服务~~ *，Spring Boot，看名字就知道是Spring的引导，就是用于启动Spring的，使得Spring的学习和使用变得快速无痛。不仅适合替换原有的工程结构，更适合微服务开发。

**~~Spring Cloud基于Spring Boot，为微服务体系开发中的架构问题，提供了一整套的解决方案——服务注册与发现，服务消费，服务保护与熔断，网关，分布式调用追踪，分布式配置管理等。~~ **

Spring Cloud是一个基于Spring Boot实现的云应用开发工具；Spring boot专注于快速、方便集成的单个个体，Spring Cloud是关注全局的服务治理框架；spring boot使用了默认大于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置，Spring Cloud很大的一部分是基于Spring boot来实现。

学过Spring的都知道，Spring开发有非常头疼的三点:

以启动一个带Hibernate的Spring MVC为例。
1. 依赖太多了，而且要注意版本兼容。这个应用，要添加10-20个依赖，Spring相关的包10多个，然后是Hibernate包，Spring与Hibernate整合包，日志包，json包一堆，而且要注意版本兼容性。

2. 配置太多了，要配置注解驱动，要配置数据库连接池，要配置Hibernate，要配置事务管理器，要配置Spring MVC的资源映射，要在web.xml中配置启动Spring和Spring MVC等

3.部署和运行麻烦。要部署到tomcat里面。不能直接用java命令运行。

太多重复和大家都一样的配置了。

Spring Boot的哲学就是***约定大于配置***。既然很多东西都是一样的，为什么还要去配置。

1. 通过starter和依赖管理解决依赖问题。
2. 通过自动配置，解决配置复杂问题。
3. 通过内嵌web容器，由应用启动tomcat，而不是tomcat启动应用，来解决部署运行问题。

Spring Cloud体系就比较复杂了。基本可以理解为通过Spring Boot的三大魔法，将各种组件整合在一起，非常简单易用。

你可以把spring boot的官方的包分为两类，一种是为了搭建一个服务用的，比如hibernate jpa，比如 message。另外一种含有cloud关键字的，是为了各个spring boot之前管理和使用的包。

因为当把集群、CI等方法集中进来一起考虑的时候，这件事情就复杂了。

多个小有服务整合成的大服务，要有一个消息总线来用于互相通知和调用，要有一个服务发现程序来管理某个小服务上线可用，同时在服务离线时也要能处理，各个小服务要尽量各自独立，还要考虑服务的依赖性，集群的负载均衡，配置文件的分离。

再把CI和Docker拿进来一起考虑的话，更乱。

但我认为这样完成的一个服务是更具有可插拔性，更容易维护的。而且遵循了上面的cloud方案的话，在服务的健壮性上面也很强。

写到这里对于新接触的我认为可以先从单独的spring boot程序开始入门，当要添加一个新功能时，考虑拆分成另外服务。两个程序间可以通过 jmx或是 其它消息中间件或是rest通讯。最后实现了一个各自独立的功能集群。

总结一句：**Spring boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring boot，属于依赖的关系。**

Spring和Spring MVC区别

springmvc是spring的一个模块，提供web层解决方案（基于mvc设计架构）
Spring MVC就是一个MVC框架，需要有spring的架包作为支撑才能跑起来

Spring的特点是什么

https://www.cnblogs.com/hoje/p/8127718.html

一、非侵入式编程

   Spring框架的API不会再业务逻辑上出现，即业务逻辑是POJO（Plain Ordinary Java Object）。
   由于业务逻辑中没有Spring的API，所以业务逻辑可以从Spring框架快速的移植到其他框架。

二、容器

  Spring作为一个容器，可以管理对象的生命周期、对象与对象之间的依赖关系。可以通过配置文件
  来定义对象，以及设置其他对象的依赖关系。

三、IoC

   控制反转（Inversion of Control），即创建被调用的实例不是由调用者完成，而是由Spring容器
   完成，并注入调用者。

  当应用IoC，一个对象依赖的其他对象会通过被动的方式传递进来，而不是这个对象自己创建或
  查找依赖对象，即，不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动
  将依赖传递给它。

四、AOP

    面向切面编程，是一种编程思想，是面向对象编程OOP的补充。Spring提供面向对象编程的支持
    ，允许通过分离应用的业务逻辑与系统级服务（日志和事务管理）进行开发。应用对象只实现他
    们应该做的（完成业务逻辑），并不负责其它的系统级关注点（日志或者事务的支持）。

  可以把日志、安全、事务管理等服务理解成一个“切面”，把很多被业务逻辑反复使用的服务完全剥
  离出来，以达到复用。然后将“切面”动态的“织入”到业务逻辑中，让其享受此“切面”的服务。

你对IOC的理解

Spring Boot优点

https://baijiahao.baidu.com/s?id=1610033543038346392&wfr=spider&for=pc

其实就是简单、快速、方便！平时如果我们需要搭建一个spring web项目的时候需要怎么做呢？

1）配置web.xml，加载spring和spring mvc

2）配置数据库连接、配置spring事务

3）配置加载配置文件的读取，开启注解

4）配置日志文件

...

配置完成之后部署tomcat 调试

...

现在非常流行微服务，如果我这个项目仅仅只是需要发送一个邮件，如果我的项目仅仅是生产一个积分；我都需要这样折腾一遍!


但是如果使用spring boot呢？

很简单，我仅仅只需要非常少的几个配置就可以迅速方便的搭建起来一套web项目或者是构建一个微服务！

Spring 拦截器

https://blog.csdn.net/H12KJGJ/article/details/78231658

    导言：struts2中的拦截器是一个有用的功能，使用它我们可以在一系列业务操作之前或之后做一些特定的操作，比如常见的权限控制。

原理：它采用了java动态代理和反射的机制来实现。

示例：自定义拦截器类，业务接口和实现类，动态代理类，执行，效果

1.//Brightmart自定义的拦截器类，它有两个普通方法：before和after.
public class BrightmartInterceptor {
 public void before() {
  System.out.println("Brightmart的拦截器类，的before()方法");
 }

 public void after() {
  System.out.println("Brightmart的拦截器类，的after()方法");
 }
}

2.//一个OA办公系统的服务接口，提供在线办公方法（onlineOffice）
public interface IOAService {
 public void onclineOffice();
}

3.//OA办公服务接口的实现类
public class OAService implements IOAService {

 @Override
 public void onclineOffice() {
    String str=null;
    System.out.println("我们使用OA在线办公系统onclineOffice，工作中（onlineOffice）。。。");}
 }

4.//a Brightmart的动态代理类，用于代理某个类。
 //b 本示例中我们用来代理【OA办公系统】服务类，目标是将特定的任务绑定到【OA办公系统】服务类之前或之后来执行
//c 我们可以认为在绑定了绑定被代理类和代理处理器（bind()），并显示调用被代理类的方法时候，invoke便被执行。
public class BrightmartDynamicProxy implements InvocationHandler {
   private Object object;//被代理的对象

  //Brightmart自定义的拦截器（它是一个普通的类） 
   private BrightmartInterceptor interceptor=new BrightmartInterceptor();   

  // 动态生成一个代理类对象,并绑定被代理类(object)和代理处理器(this).
  //或者说：bind方法返回一个特定的，具有代理功能的对象，这个对象根据传入的被代理对象的接口而定。
   public Object bind(Object object){
     this.object=object;
     return Proxy.newProxyInstance(object.getClass().getClassLoader(),

      object.getClass().getInterfaces(), this);
  }   
    //method:被调用的方；args:方法的参数；标记为1,2的方法可以根据你业务需要而改动，或只在调用前或调用后执行某种操作
 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
  Object result=null;
  interceptor.before();//1 调用before方法
  method.invoke(object, args);
  interceptor.after();//2 调用after方法
  return result;
 }

}

5.//执行自定义的拦截器类

public class TestBrightmartInterceptor {
 public static void main(String[] args) {
  //Brightmart自己实现的拦截器,调用bind方法获取一个代理类，这个代理类调用原有的业务逻辑类（被代理类）的方法。
  BrightmartDynamicProxy handler=new BrightmartDynamicProxy();
  IOAService oaService=new OAService();
  IOAService oaServiceProxy=(IOAService)handler.bind(oaService);//关键代码
  oaServiceProxy.onclineOffice();
 }
}