2024年java面试（四）--spring篇

---

1.BeanFactory 和 FactoryBean 的区别

①BeanFactory： 是 IOC 容器，并且提供方法支持外部程序对这些 bean 的访问，在程序启动时 根据传入的参数产生各种类型的 bean，并添加到 IOC容器（实现 BeanFactory接口的类) 的 singletonObject 属性中。

②FactoryBean： 首先是个 bean，也存放在 BeanFactory 中。它具有工厂方法的功能，在程序运行中 产生指定(一种)类型的 bean，并添加到了 IOC容器中的 factoryBeanObjectCache 属性中。

首先 FactoryBean 是一个 bean，但它又不仅仅是个 bean。它是一个可以 创建 或 修饰 其他对象的”工厂 bean“，这跟设计模式中的工厂模式或者装饰器模式很相似，它可以创建除自身以外的其他对象。

---

2.BeanFactory和ApplicationContext有什么区别?

ApplicationContext是BeanFactory的子接口

ApplicationContext提供了更完整的功能:
①继承MessageSource，因此支持国际化。
②统一的资源文件访问方式。
③提供在监听器中注册bean的事件。
④同时加载多个配置文件。
⑤载入多个(有继承关系)上下文，使得每一个上下文都专注于一个特定的层次，比如应用的web层。

• BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化。这样，我们就不能发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入，BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常。
• ApplicationContext，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误，这样有利于检查所依赖属性是否注入。ApplicationContext启动后预载入所有的单实例Bean，通过预载入单实例bean
  ,确保当你需要的时候，你就不用等待，因为它们已经创建好了。
• 相对于基本的BeanFactory，ApplicationContext
  唯一的不足是占用内存空间。当应用程序配置Bean较多时，程序启动较慢。
  BeanFactory通常以编程的方式被创建，ApplicationContext还能以声明的方式创建，如使用ContextLoader。

---

3.@RequestBody、@RequestParam、@ResponseBody

RequestBody注解的主要作用就是用于接收前端的参数，当我们使用post请求的时候，我们会将参数放在request body中，此时我们就需要在Controller的方法的参数前面加上@RequestBody用来接受到前端传过来的request body中的值 （将请求体中的JSON数据自动解析成Java对象）

RequestParam接收的参数主要是来自request Header中，即请求头中。通常用于get请求中，我们都知道get请求的参数都是写在url中的，例如：http://localhost:8080/my/api/testMethod?name=雷神&age=3 该url我们可以看到有name和age两种属性，那么当我们将此请求发送到后台服务以后，现在解释一下@RequestParam的括号中的三个参数的意思，value值得就是请求的url中必须要有的参数名，相当于key值；required表示的是是否为必须，也就是说参数在url中是否为必须，默认的是true；defaultValue指的则是参数的默认值； （将请求参数的值映射到控制器方法的参数上，从而方便地获取和使用这些参数）

Responsebody 注解表示该方法的返回的结果直接写入 HTTP 响应正文（ResponseBody）中，一般在异步获取数据时使用；通常是在使用 @RequestMapping 后，返回值通常解析为跳转路径，加上 @Responsebody 后返回结果不会被解析为跳转路径，而是直接写入HTTP 响应正文中。ResponseBody的作用是将后端以return返回的javabean类型数据转为json类型数据。将java对象转为json格式的数据

---

4.cookie和session的区别

cookie不是很安全，它的数据是存放在客户的浏览器上，单个cookie保存的数据不能超过4K。

session比较安全，它会在一定时间内保存在服务器上，但是当访问增多，会比较占用服务器的性能，所以考虑到减轻服务器性能方面，应当使用cookie。

---

5.Servlet的生命周期

加载类—>实例化(为对象分配空间)—>初始化(为对象的属性赋值)—>请求响应(服务阶段)—>销毁

---

6.Jsp和Servlet的区别

Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。

而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。

JSP侧重于视图，Servlet主要用于控制逻辑

Servlet更多的是类似于一个Controller，用来做控制。

---

7.SpringMvc执行流程

①客户端（浏览器）发送请求，直接请求到 DispatcherServlet（前端控制器） 。
②DispatcherServlet 根据请求信息调⽤ HandlerMapping ，解析请求对应的 Handler 。
③解析到对应的 Handler （也就是 Controller 控制器）后，开始由HandlerAdapter 适配器处理。
④HandlerAdapter 会根据 Handler 来调⽤真正的处理器来处理请求，并处理相应的业务逻辑。
⑤处理器处理完业务后，会返回⼀个 ModelAndView 对象， Model 是返回的数据对象
⑥ViewResolver 会根据逻辑 View 查找实际的 View 。
⑦DispaterServlet 把返回的 Model 传给 View （视图渲染）。
⑧把 View 返回给请求者（浏览器）

---

8.@RequestMapping是怎么使用

在Controller类的方法下使用这个注解，作用就是映射URL路径，将http的请求地址映射到控制器。返回值交给视图解析器解析，如果配合@ResponseBody则返回JSON或者XML数据

---

9.如果一个接口有多个实现类，在springboot中如何调用不同实现类中的方法

public interface Animal {
    //动物的叫声
   public void call();
    //动物吃的东西
   public void eat();
}
​
实现类1
@Service("dogImpl")
public class Dog implements Animal {
  
    @Override
    public void call() {
        System.out.println("汪汪汪......");
    }
​
    @Override
    public void eat() {
        System.out.println("骨头");
    }
}
​
实现类2
@Service("catImpl")
public class Cat implements Animal {
  
    @Override
    public void call() {
        System.out.println("喵喵喵......");
    }
​
    @Override
    public void eat() {
        System.out.println("鱼");
    }
}

方法1 指明实现类的优先级

在写实现类的时候事先指明实现类的优先级，注入的时候就会使用优先级高的实现类。在调用的类中注入接口，默认使用的是Primary 标注的实现类的方法

@Service("dog")
@Primary
public class Dog implements Animal {
    .......
}

方法2 通过@Autowride和@Qualifier两个注解配合使用

在调用处使用这两个注解

@Autowired
@Qualifier("dog")
private Animal animal;    //正常启动

注：注解@Qualifier内的值是实现类的默认名

方法3 使用@Resource注解，默认类名区分

在调用处使用此注解

@Resource(name = "dog")
private Animal animal;     //正常启动

注：注解@Qualifier内的值是实现类中@Service指定的名字

---

10.拦截器的配置

第一步，实现HandlerInterceptor接口的拦截器

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {
        // 在请求处理之前进行拦截处理
        return true; // 返回true表示继续执行请求处理，返回false表示中断请求处理
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception {
        // 在请求处理之后进行拦截处理
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,Exception ex) throws Exception {
        // 在请求处理完成之后进行拦截处理
    }
}

@Configuration
public class SpringMvcSupport extends webMvcConfigurationSupport {
    @Autowired
    private MyInterceptor myInterceptor;
    
    @verride
    protected void addInterceptors( InterceptorRegistry registry){          
        registry.addInterceptor(projectInterceptor).addPathPatterns("/路径");
    }
}

第二步，使用注解的拦截器

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
}
​
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {
        // 判断请求方法是否有MyAnnotation注解
        if (handler instanceof HandlerMethod) {
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        if (method.isAnnotationPresent(MyAnnotation.class)) {
        // 在请求处理之前进行拦截处理
        return true; // 返回true表示继续执行请求处理，返回false表示中断请求处理
    }
}
    return true;
}
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception {
        // 在请求处理之后进行拦截处理
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,Exception ex) throws Exception {
        // 在请求处理完成之后进行拦截处理
    }
}
​
@Controller
public class MyController {
    @RequestMapping("/test")
    @MyAnnotation
    public String test() {
        // 处理请求
        return "test";
    }
}

---

11.分页功能实现

@Test
void testGetPage(){
    IPage page = new Page( "current": 1，"size": 5);
    bookDao.selectPage(page, "queryWrapper": null);
    page.getCurrent();//获取当前页
    page.getSize();//获取每页数量
    page.getTotal();//获取总共数据条数
    page.getPages();//获取一共多少页
    page.getRecords();//获取的数据
}
​
//配置拦截器实现分页
@Configuration
public class MPConfig{
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor( ));
        return interceptor;
    }
}

---

12.如何定义一个全局异常处理类？

想要定义一个全局异常处理类的话，我们需要在这个类上添加@ContaollerAdvice注解，然后定义一些用于捕捉不同异常类型的方法，在这些方法上添加@ExceptionHandler(value = 异常类型.class)和@ResponseBody注解，方法参数是HttpServletRequest和异常类型，然后将异常消息进行处理。

如果我们需要自定义异常的话，就写一个自定义异常类，该类需要继承一个异常接口，类属性包括final类型的连续id、错误码、错误信息，再根据需求写构造方法；

---

13.说出Spring或者SpringMVC中常用的5个注解

@Component 基本注解，标识一个受Spring管理的组件

@Controller 标识为一个表现层的组件

@Service 标识为一个业务层的组件

@Repository 标识为一个持久层的组件

@Autowired 自动装配

@Qualifier(“”) 具体指定要装配的组件的id值

@RequestMapping() 完成请求映射

@PathVariable 映射请求URL中占位符到请求处理方法的形参

---

14.简述SpringMVC中如何返回JSON数据

Step1：在项目中加入json转换的依赖，例如jackson，fastjson，gson等

Step2：在请求处理方法中将返回值改为具体返回的数据的类型， 例如数据的集合类List等

Step3：在请求处理方法上使用@ResponseBody注解

---

15.什么是循环依赖?

循环依赖就是在创建 A 实例的时候里面包含着 B 属性实例，所以这个时候就需要去创建 B 实例，而创 建 B 实例过程中也包含着 A 实例。 这样 A 实例还在创建的过程当中，所以就导致 A 和 B 实例都创建不出来。

spring通过三级缓存来解决循环依赖：

一级缓存：缓存经过完整的生命周期的Bean

二级缓存 ：缓存未经过完整的生命周期的Bean

三级缓存：缓存的是ObjectFactory，其中存储了一个生成代理类的拉姆达表达式

我们在创建 A 的过程中，先将 A 放入三级缓存 ，这时要创建B，B要创建A就直接去三级缓存中查找，并且判断需不需要进行 AOP 处理，如果需要就执行拉姆达表达式得到代理对象，不需要就取出原始对象。然后将取出的对象放入二级缓存中，因为这个时候 A 还未经 过完整的生命周期所以不能放入一级缓存。这个时候其他需要依赖 A 对象的直接从二级缓存中去获取即可。当B创建完成，A 继续执行生命周期，当A完成了属性的注入后，就可以放入一级缓存了

---

16.为什么构造器注入属性无法解决循环依赖问题?

由于spring中的bean的创建过程为先实例化 再初始化(在进行对象实例化的过程中不必赋值)将实例化好的对象暴露出去,供其他对象调用,然而使用构造器注入,必须要使用构造器完成对象的初始化的操作,就会陷入死循环的状态

---

17.一级缓存能不能解决循环依赖问题? 不能

在三个级别的缓存中存储的对象是有区别的 一级缓存为完全实例化且初始化的对象 二级缓存实例化但未初始化对象 如果只有一级缓存,如果是并发操作下,就有可能取到实例化但未初始化的对象,就会出现问题

---

18.二级缓存能不能解决循环依赖问题?

理论上二级缓存可以解决循环依赖问题,但是需要注意,为什么需要在三级缓存中存储匿名内部类(ObjectFactory),原因在于 需要创建代理对象 eg:现有A类,需要生成代理对象 A是否需要进行实例化(需要) 在三级缓存中存放的是生成具体对象的一个匿名内部类,该类可能是代理类也可能是普通的对象,而使用三级缓存可以保证无论是否需要是代理对象,都可以保证使用的是同一个对象,而不会出现,一会儿使用普通bean 一会儿使用代理类