2024届java面试准备--spring篇
什么是spring？
Spring可以做很多事情，它为企业级开发提供给了丰富的功能，但是这些功能的底层都依赖于它的两个核心特性，也就是控制反转（Inversion of Control，IOC）和面向切面编程（aspect-oriented programming，AOP）。
为了降低Java开发的复杂性，Spring采取了以下4种关键策略
- 基于POJO的轻量级和最小侵入性编程；
- 通过依赖注入和面向接口实现松耦合；
- 基于切面和惯例进行声明式编程；
- 通过切面和模板减少样板式代码。
Bean作用域
| 名称 | 作用域 |
|---|---|
| singleton | 单例对象，默认值的作用域 |
| prototype | 每次获取都会创建⼀个新的 bean 实例 |
| request | 每⼀次HTTP请求都会产⽣⼀个新的bean，该bean仅在当前HTTP request内有效。 |
| session | 在一次 HTTP session 中，容器将返回同一个实例 |
| global-session | 将对象存入到web项目集群的session域中,若不存在集群,则global session相当于session |
默认作用域是singleton，多个线程访问同一个bean时会存在线程不安全问题
反射原理以及使用场景
Java反射：
是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法；并且都能够调用它的任意一个方法；
反射原理：
反射首先是能够获取到Java中的反射类的字节码，然后将字节码中的方法，变量，构造函数等映射成 相应的 Method、Filed、Constructor 等类
如何得到Class的实例:
1.类名.class(就是一份字节码)
2.Class.forName(String className);根据一个类的全限定名来构建Class对象
3.每一个对象多有getClass()方法:obj.getClass();返回对象的真实类型
使用场景：
-
开发通用框架 - 反射最重要的用途就是开发各种通用框架。很多框架（比如 Spring）都是配置化的（比如通过 XML 文件配置 JavaBean、Filter 等），为了保证框架的通用性，需要根据配置文件运行时动态加载不同的对象或类，调用不同的方法。
-
动态代理 - 在切面编程（AOP）中，需要拦截特定的方法，通常，会选择动态代理方式。这时，就需要反射技术来实现了。
JDK：spring默认动态代理，需要实现接口
CGLIB：通过asm框架序列化字节流，可配置，性能差
-
自定义注解 - 注解本身仅仅是起到标记作用，它需要利用反射机制，根据注解标记去调用注解解释器，执行行为。
Spring框架的设计目标，设计理念，和核心是什么？
Spring设计目标：Spring为开发者提供一个一站式轻量级应用开发平台；
Spring设计理念：在JavaEE开发中，支持POJO和JavaBean开发方式，使应用面向接口开发，充分支持OO（面向对象）设计方法；Spring通过IoC容器实现对象耦合关系的管理， 并实现依赖反转，将对象之间的依赖关系交给IoC容器，实现解耦；
Spring框架的核心：IoC容器和AOP模块。通过IoC容器管理POJO对象以及他们之间的耦合关系；通过AOP以动态非侵入的方式增强服务。
IoC让相互协作的组件保持松散的耦合，而AOP编程允许你把遍布于应用各层的功能分离出来形成可重用的功能组件。
Spring的优缺点是什么？
优点
①. 方便解耦，简化开发
Spring就是一个大工厂，可以将所有对象的创建和依赖关系的维护，交给Spring管理。
②. AOP编程的支持
Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。
③. 声明式事务的支持
只需要通过配置就可以完成对事务的管理，而无需手动编程。
④. 方便程序的测试
Spring对Junit4支持，可以通过注解方便的测试Spring程序。
⑤. 方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的直接支持（如：Struts、Hibernate、MyBatis等）。
⑥. 降低JavaEE API的使用难度
Spring对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低。
缺点
Spring明明一个很轻量级的框架，却给人感觉大而全
Spring依赖反射，反射影响性能
使用门槛升高，入门Spring需要较长时间
Spring 框架中都用到了哪些设计模式？
工厂模式：BeanFactory就是简单工厂模式的体现，用来创建对象的实例；
单例模式：Bean默认为单例模式。
代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术；
模板方法：用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。
观察者模式：定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被自动更新，如Spring中listener的实现–ApplicationListener。
什么是Spring IOC 容器？
IoC（Inverse of Control:控制反转）是⼀种设计思想，就是将原本在程序中⼿动创建对象的控制权，交由Spring框架来管理。 IoC 在其他语⾔中也有应⽤，并⾮ Spring 特有。
IoC 容器是 Spring⽤来实现 IoC 的载体，将对象之间的相互依赖关系交给 IoC 容器来管理，并由 IoC 容器完成对象的注⼊。这样可以很⼤程度上简化应⽤的开发，把应⽤从复杂的依赖关系中解放出来。 IoC 容器就像是⼀个⼯⼚⼀样，当我们需要创建⼀个对象的时候，只需要配置好配置⽂件/注解即可，完全不⽤考虑对象是如何被创建出来的。
DI 依赖注入
DI:（Dependancy Injection：依赖注入)站在容器的角度，将对象创建依赖的其他对象注入到对象中。
依赖注入三种方式（Ioc的三种实现方式）
- 构造方法注入
- setter注入
- 基于注解的注入
实例化bean的三种方式
-
无参构造方法实例化（Spring默认，常用，需要bean类中存在无参构造方法）；
-
静态工厂实例化
- 实例化工厂实例化
IOC容器初始化加载Bean流程：
@Override
public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) {
// 第一步:刷新前的预处理
prepareRefresh();
//第二步: 获取BeanFactory并注册到 BeanDefitionRegistry
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 第三步:加载BeanFactory的预准备工作(BeanFactory进行一些设置，比如context的类加载器等)
prepareBeanFactory(beanFactory);
try {
// 第四步:完成BeanFactory准备工作后的前置处理工作
postProcessBeanFactory(beanFactory);
// 第五步:实例化BeanFactoryPostProcessor接口的Bean
invokeBeanFactoryPostProcessors(beanFactory);
// 第六步:注册BeanPostProcessor后置处理器，在创建bean的后执行
registerBeanPostProcessors(beanFactory);
// 第七步:初始化MessageSource组件(做国际化功能;消息绑定，消息解析);
initMessageSource();
// 第八步:注册初始化事件派发器
initApplicationEventMulticaster();
// 第九步:子类重写这个方法，在容器刷新的时候可以自定义逻辑
onRefresh();
// 第十步:注册应用的监听器。就是注册实现了ApplicationListener接口的监听器
registerListeners();
//第十一步:初始化所有剩下的非懒加载的单例bean 初始化创建非懒加载方式的单例Bean实例(未设置属性)
finishBeanFactoryInitialization(beanFactory);
//第十二步: 完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，完成创建
finishRefresh();
}
……
}
总结：
四个阶段
- 实例化 Instantiation
- 属性赋值 Populate
- 初始化 Initialization
- 销毁 Destruction
多个扩展点
- 影响多个Bean
- BeanPostProcessor
- InstantiationAwareBeanPostProcessor
- 影响单个Bean
- Aware
完整流程
- 实例化一个Bean－－也就是我们常说的new；
- 按照Spring上下文对实例化的Bean进行配置－－也就是IOC注入；
- 如果这个Bean已经实现了BeanNameAware接口，会调用它实现的setBeanName(String)方法，也就是根据就是Spring配置文件中Bean的id和name进行传递
- 如果这个Bean已经实现了BeanFactoryAware接口，会调用它实现setBeanFactory(BeanFactory)也就是Spring配置文件配置的Spring工厂自身进行传递；
- 如果这个Bean已经实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，和4传递的信息一样但是因为ApplicationContext是BeanFactory的子接口，所以更加灵活
- 如果这个Bean关联了BeanPostProcessor接口，将会调用postProcessBeforeInitialization()方法，BeanPostProcessor经常被用作是Bean内容的更改，由于这个是在Bean初始化结束时调用那个的方法，也可以被应用于内存或缓存技术
- 如果Bean在Spring配置文件中配置了init-method属性会自动调用其配置的初始化方法。
- 如果这个Bean关联了BeanPostProcessor接口，将会调用postProcessAfterInitialization()，打印日志或者三级缓存技术里面的bean升级
- 以上工作完成以后就可以应用这个Bean了，那这个Bean是一个Singleton的，所以一般情况下我们调用同一个id的Bean会是在内容地址相同的实例，当然在Spring配置文件中也可以配置非Singleton，这里我们不做赘述。
- 当Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean这个接口，或者根据spring配置的destroy-method属性，调用实现的destroy()方法
Spring 的 IoC支持哪些功能
Spring 的 IoC 设计支持以下功能：
-
依赖注入
-
依赖检查
-
自动装配
-
支持集合
-
指定初始化方法和销毁方法
-
支持回调某些方法（但是需要实现 Spring 接口，略有侵入）
其中，最重要的就是依赖注入，从 XML 的配置上说，即 ref 标签。对应 Spring RuntimeBeanReference 对象。
对于 IoC 来说，最重要的就是容器。容器管理着 Bean 的生命周期，控制着 Bean 的依赖注入。
面向切面编程（AOP）
无侵入式编程
AOP (Aspect Oriented Programing) 称为：面向切面编程，它是一种编程思想。
AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码的编写方式（例如性能监视、事务管理、安全检查、缓存、日志记录等）。
Spring AOP就是基于动态代理的，如果要代理的对象，实现了某个接⼝，那么Spring AOP会使⽤JDKProxy，去创建代理对象，⽽对于没有实现接⼝的对象，就⽆法使⽤ JDK Proxy 去进⾏代理了，这时候Spring AOP会使⽤基于asm框架字节流的Cglib动态代理 ，这时候Spring AOP会使⽤ Cglib ⽣成⼀个被代理对象的⼦类来作为代理。
AOP 思想： 基于代理思想，对原来目标对象，创建代理对象，在不修改原对象代码情况下，通过代理对象，调用增强功能的代码，从而对原有业务方法进行增强 ！
切面：需要代理一些方法和增强代码 。
AOP的应用场景
场景一： 记录日志
场景二： 监控方法运行时间 （监控性能）
场景三： 权限控制（通过Around，可以在执行方法前进行权限验证）
场景四： 缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ）
场景五： 事务管理 （调用方法前开启事务， 调用方法后提交或者回滚、关闭事务 ）
AOP通知类型
-
前置通知 Before advice：在连接点前面执行，前置通知不会影响连接点的执行，除非此处抛出异常
-
后置通知 After returning advice：在连接点正常执行完成后执行，如果连接点抛出异常，则不会执行
-
异常通知 After throwing advice：在连接点抛出异常后执行
-
最终通知 After (finally) advice：在连接点执行完成后执行，不管是正常执行完成，还是抛出异常，都会执行返回通知中的内容
-
环绕通知 Around advice：环绕通知围绕在连接点前后，能在方法调用前后自定义一些操作，还需要负责决定是继续处理 join point (调用 ProceedingJoinPoint 的 proceed 方法)还是中断执行
Spring AOP编程两种方式
- Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类植入增强代码。
- AsPectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持。
使用注解@Aspect流程
1.切面类 @Aspect： 定义切面类，加上@Aspect、@Component注解
2.切点 @Pointcut
3.Advice通知，在切入点上执行的增强处理，主要有五个注解
4.JoinPoint ：方法中的参数JoinPoint为连接点对象，它可以获取当前切入的方法的参数、代理类等信息，因此可以记录一些信息，验证一些信息等；
@Aspect
@Component
//设置注解执行的顺序
@Order(1)
public class AspectTest {
/**
* 定义切点,切点为对应controller
*/
@Pointcut("execution(public * com.example.zcs.Aop.controller.*.*(..))")
public void aopPointCut(){
}
@Before("aopPointCut()")
public void testbefor(JoinPoint joinPoint) {
illegalParam(joinPoint);
System.out.println("执行方法之前执行。。。。。");
}
@After("aopPointCut()")
public void testAfter(JoinPoint joinPoint) {
//illegalParam(joinPoint);
System.out.println("执行方法之后执行。。。。。");
}
/**
*获取请求参数
* @param joinPoint
* @return
*/
private static void illegalParam(JoinPoint joinPoint) {
if(joinPoint == null){
return;
}
boolean flag = false;
try{
// 参数值
Object[] args = joinPoint.getArgs();
if (args != null) {
for (Object o : args) {
System.out.println(o);
}
}
}catch(Exception e){
}
}
}
AOP的相关术语
Aspect(切面): 是通知和切入点的结合,通知和切入点共同定义了关于切面的全部内容—它的功能、在何时和何地完成其功能
joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.
Pointcut(切入点):所谓切入点是指我们要对哪些joinpoint进行拦截的定义.
通知定义了切面的”什么”和”何时”，切入点就定义了”何地”.
Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Target(目标对象):代理的目标对象
weaving(织入):是指把切面应用到目标对象来创建新的代理对象的过程.切面在指定的连接点织入到目标对象
Introduction(引介):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
AOP编程底层实现机制
AOP 就是要对目标进行代理对象的创建， Spring AOP是基于动态代理的，基于两种动态代理机制： JDK动态代理和CGLIB动态代理
JDK动态代理
JDK动态代理，针对目标对象的接口进行代理 ，动态生成接口的实现类 ！（必须有接口）
JDK动态代理的缺点： 只能面向接口代理，不能直接对目标类进行代理 ，如果没有接口，则不能使用JDK代理。
Cglib动态代理
Cglib动态代理基于父类，Cglib的引入为了解决类的直接代理问题(生成代理子类)，不需要接口也可以代理 ！
什么是cglib ？
CGLIB(Code Generation Library)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。
代理知识小结
区别：
- Jdk代理：基于接口的代理，一定是基于接口，会生成目标对象的接口类型的子对象。
- Cglib代理：基于类的代理，不需要基于接口，会生成目标对象类型的子对象。
- Spring AOP 优先对接口进行代理 （使用Jdk动态代理）
- 如果目标对象没有实现任何接口，才会对类进行代理 （使用cglib动态代理）
BeanFactory 和 FactoryBean 的区别
-
BeanFactory： 是 IOC 容器，并且提供方法支持外部程序对这些 bean 的访问，在程序启动时 根据传入的参数产生各种类型的 bean，并添加到 IOC容器（实现 BeanFactory接口的类) 的 singletonObject 属性中。
-
FactoryBean： 首先是个 bean，也存放在 BeanFactory 中。它具有工厂方法的功能，在程序运行中 产生指定(一种)类型的 bean，并添加到了 IOC容器中的 factoryBeanObjectCache 属性中。
首先 FactoryBean 是一个 bean，但它又不仅仅是个 bean。它是一个可以 创建 或 修饰 其他对象的”工厂 bean“，这跟设计模式中的工厂模式或者装饰器模式很相似，它可以创建除自身以外的其他对象。
@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格式的数据
Servlet的生命周期
加载类—>实例化(为对象分配空间)—>初始化(为对象的属性赋值)—>请求响应(服务阶段)—>销毁
Jsp和Servlet的区别
Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。
而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。
JSP侧重于视图，Servlet主要用于控制逻辑
Servlet更多的是类似于一个Controller，用来做控制。
SpringMvc执行流程
- 客户端（浏览器）发送请求，直接请求到 DispatcherServlet（前端控制器） 。
- DispatcherServlet 根据请求信息调⽤ HandlerMapping ，解析请求对应的 Handler 。
- 解析到对应的 Handler （也就是 Controller 控制器）后，开始由HandlerAdapter 适配器处理。
- HandlerAdapter 会根据 Handler 来调⽤真正的处理器来处理请求，并处理相应的业务逻辑。
- 处理器处理完业务后，会返回⼀个 ModelAndView 对象， Model 是返回的数据对象
- ViewResolver 会根据逻辑 View 查找实际的 View 。
- DispaterServlet 把返回的 Model 传给 View （视图渲染）。
- 把 View 返回给请求者（浏览器）
@RequestMapping是怎么使用
在Controller类的方法下使用这个注解，作用就是映射URL路径，将http的请求地址映射到控制器。返回值交给视图解析器解析，如果配合@ResponseBody则返回JSON或者XML数据
面试问题：
1.如果一个接口有多个实现类，在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指定的名字
2.拦截器的配置
- 实现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";
}
}
3.分页功能实现
@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;
}
}