Spring面试题

网上有人整理了一些spring面试题目,我抽空写了个答案,可以参考

原文在 https://www.zhihu.com/question/39814046

ioc是什么,有什么用?

Ioc全称Inversion of Control意思为控制反转,是程序设计的一种思想,或者目标。spring通过DI(依赖注入)来实现IOC,把对象的实例化过程的控制权给到了容器(spring容器);

bean作用域有哪些,说一下各种使用场景?

bean的作用域比较多,可以参考spring官网文档对bean的scope的定义

https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-factory-scopes

下面给出截图

这里的生命周期常用的就是singleton和prototype,singleton指的是单例,prototype指的是原型,spring所有创建出来的bean都是单例的,比如controller和service、dao;但是有的时候我们需要bean是一个原型的,比如在类里面有全局变量。

aop是什么,有哪些实现方式?

参考spring官方文档:https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#aop

Aop叫做面向切面编程,在实际开发中我们的程序是一个自上而下的执行流程,比如一个登陆逻辑,用户发送HTTP请求,controller接受请求,封装参数,传给service、继而调用dao操作db然后返回。这整个逻辑当中会出现一些横切性的问题,比如进入controller的时候我们需要记录日志,比如调用dao的db操作时候需要进行事务操作,比如进入service的方法之前需要进行权限验证等等。。。这种和主逻辑无关不影响程序执行结果的问题称之为横切性问题,AOP的产生就是为了来解决这种横切性问题。 Aop编程不关心主业务逻辑,只关心这些横切性问题,比如他们的执行时机,执行的地方、执行顺序等等

Aop的实现方式可以从两个方面来回答

第一Aop的编程风格,spring提供两种编程风格,官网有解释一种是xml,一种是基于aspectj的注解风格来的

第二Aop的底层技术实现原理,spring里面提供jdk动态代理的技术和cglib的技术原理来实现AOP

拦截器是什么,什么场景使用?

spring当中实现拦截的接口HandlerInterceptor,拦截器主要是让请求进入controller之前进行拦截处理逻辑,主要用在和相关权限的业务上

bean的各种作用域是怎么样实现的?

工厂设计模式实现bean的作用域

工具类中如何注入bean?具体使用场景?

通过实现Aware接口注入ApplicationContext对象,继而调用getBean方法就能获取bean

使用场景分析:比如某个工具类A当中需要调用某个service B,但是A并不是bean,只是一个普通类,故而无法直接注入,需要用到上述方法

注入的bean存在多份的时候有哪些解决办法?

@Qualifier可以解决,其实spring的@autowired已经非常智能了,会先根据type找,如果找到多个,在根据名字找,但是如果名字没有找到就会报错,找到了就用这个bean。

aop里面的cglib原理是什么?

ASM字节码技术,动态产生一个子类的类(该子类继承了目标对象),然后实例该子类的对象,返回代理对象,完成代理

aop切方法的方法的时候,哪些方法是切不了的?为什么?

最显而易见的便是私有方法,因为AOP的底层是代理、不管是JDK还是cglib都是不能代理私有的。很简单jdk是基于接口的,接口是没有私有的,cglib是基于继承,就是代理对象继承了目标对象,假设你的目标对象里面有一个私有方法是无法继承的,无法继承也就无法代理

同类调用为什么无法切?怎么样解决(AOPContext)?

这个问题我看了很久无法看懂,估计面试官表达有问题,其实这个问题分场景,如果jdk动态代理是有问题的

参考JDK动态代理导致事务失效的原因(可以自行百度,当然你也看我这里对JDK原理的分析)

这里写个例子分析一下

比如我有接口 I

public interface I {
   void f1();
   void f2();
}

然后由实现类A

public class A implements I {
   @Override
   public void f1() {

   }

   @Override
   public void f2() {

   }
}

假设我现在产生一个代理对象(代理I接口),那么产生后的代理对象到底长什么样呢?假设你对jdk动态代理的原理比较清楚就知道JDK是通过动态产生字节码来产生代理对象的,那么我们直接把动态产生的字节码拿出来看看就知道代理对象长什么样子了。

public static void main(String[] args) throws IOException {
    //获得到产生I接口的代理对象的字节码
   byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
         "xx", new Class[]{I.class});
   //下面代码比较简单,就是把字节码写到本地      
   File file = new File("d:\\xx.class");
   FileOutputStream fileOutputStream =new FileOutputStream(file);
   fileOutputStream.write(proxyClassFile);
   fileOutputStream.flush();
   fileOutputStream.close();
}

现在我们已经在D盘有了一个class文件了,那么这个字节码文件我们看不懂啊,其实很简单,直接扔到idea当中(记得要扔到target下面,就是编译输出class的目录,不能放到包下面),idea反编译后的代码如下:

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import com.spring.boot.I;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class xx extends Proxy implements I {
    private static Method m1;
    private static Method m4;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public xx(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void f2() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    
    public final void f1() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m4 = Class.forName("com.spring.boot.I").getMethod("f2");
            m3 = Class.forName("com.spring.boot.I").getMethod("f1");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

比如我看f1方法去掉无用的代码里面就一行代码

super.h.invoke(this, m3, (Object[])null);

这里的super就是Proxy类,这里JDK动态代理已经默认为你继承了一个类,现在你知道为什么JDK只能用接口了吧?因为java不允许多继承。

然后在Proxy类里面有一个h属性,这个h属性就是InvocatonHandler接口,是程序员提供的一个接口。在springAop的源码中:

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

}

当然这里我先不讨论springAop;说回上面的这个InvocatonHandler接口,里面有一个invoker方法,这个方法里面的逻辑是由程序员自己提供,那么我们的代理逻辑就是写在这个方法里面,并且这个方法还负责调用目标方法的逻辑,怎么调用的呢?就是把目标对象传给这个InvocatonHandler,然后反射调用,所以你在f1里面调用f2其实是调用目标对象的f2并不是代理对象的f2。故而会导致代理失效,也是上面说的不能切本类。

spring的主要扩展点有哪些?(最重要最有用的应该就是bpp了)

BeanFactrypostprocessorBeanPostprocessorImportRegisterBeanPostProcessor(其实这个问题没有意义,你要结合一个主流框架如何扩展spring来说就更加有意义,比如可以参考我讲的spring和mybatis的视频就能看到mybatis如果扩展的spring的)

有没有用过BeanFactory?场景?

用的不多,曾经通过BeanFactory动态往spring容器当中注入一个bean,什么意思呢?假设我一个bean最开始并不要求被spring实例化,在某个时机(某个条件成了、比如你获取了一个别人传给你的对象)需要自己实例化,实例化好之后通过BeanFactory添加到spring容器当中,代码如下:

AnnotationConfigApplicationContext ac
      = new AnnotationConfigApplicationContext(Appconfig.class);
ac.getBeanFactory().registerSingleton("bname",你的对象);

说说aop和ioc关系

其实这个题目本身意义不大,IOC和AOP都是编程目标和spring没有关系,就算没有spring也能实现AOP,比如大名鼎鼎的Aspectj技术也能实现Aop。如果硬是要说关系应该说spring的IOC和springAop有什么关系。其实意义也不大,无非springAop当中的对象必须在IOC容器当中。比如Aspectj就可以脱离IOC单独使用,但是springAop就不能脱离IOC

说说DispatcherServlet做了什么

这个问题可复杂了,简单说DispatcherServlet的init方法里面load了springmvc的配置信息,然后初始化了spring容器(调用了refresh方法),把controller的信息缓存了,比如映射信息;然后DispatcherServlet会拦截所有的请求,根据用户的请求信息通过缓存的映射信息找到对应的controller的对应方法,然后反射调用(其实底层的源码就是反射调用controller的方法),然后视图裁决、解析等等工作,可以参考springMVC的工作原理去回答

原文链接

http://note.youdao.com/noteshare?id=140de418ffaae392e3d19b5c976188bd

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 对synchroized的一些认识

    synchroized关键字修饰实例方法和实例对象时,锁住的是对象,而修饰静态方法和静态方法中的代码块时,锁住的是该类的类对象。

    DH镔
  • Spring Boot源码编译

    我fork一个Spring boot到自己的github上,主要是为了把阅读源码时添加的一些注释push上去,所以这一步是可选的。

    DH镔
  • select实现socket单线程多路复用

    DH镔
  • Spring源码分析之环境搭建

    写在最前面 最近突然心血来潮,想看看源码,看看大牛都怎么码代码,膜拜下。首选肯定是spring大法,于是说干就干,从GitHub上下载spring-framew...

    YGingko
  • Spring框架结构

    spring的jar包只有20个左右,每个都有相应的功能,一个jar还可能依赖了若干其他jar,所以,搞清楚它们之间的关系,配置maven依赖就可...

    聚沙成塔
  • spring boot 配置属性大全(2)

    gemron的空间
  • spring boot 配置属性大全(1)

    gemron的空间
  • Spring系列第1篇:请问各位大佬为何要学spring?

    整个spring系列使用官方最新版本5.2.3.RELEASE,会有大量案例,都是通过maven来管理的,所以maven是必备技能,对这块不熟悉的可以去看一下:...

    路人甲Java
  • springboot系列教程导学篇

    Spring Boot 虽然凯哥从2015年年初开始就接触了spring boot。但是在之后的公司中都没有使用到,来来回回学了好几次了。正好,公司现在准备使用...

    凯哥Java
  • 梳理srping boot 的几个核心基础知识点

    spring boot之前,使用ssh或者ssm等框架开发,需要繁多的配置文件,开发效率较低,部署运维也较为麻烦,这时候为了解决这些问题spring boot ...

    海涛

扫码关注云+社区

领取腾讯云代金券