Java开发面试问答-Spring 基础

最新推荐文章于 2024-06-10 21:57:08 发布
最新推荐文章于 2024-06-10 21:57:08 发布
阅读量64 收藏 1
点赞数
分类专栏： 面试 文章标签： java spring 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suli77/article/details/129249929
版权

Spring [Top]

Spring IOC & AOP[Top]

Spring IOC[Top]

IOC(Inversion of Control) 理解

  1. 控制反转：原来在程序中手动创建对象，现在需要什么对象由IOC提供，一个好处就是对象统一管理。
  2. 依赖注入：将对象之间的相互依赖关系交给 IoC 容器来管理，并由 IoC 容器完成对象的注入。简化开发及对象的创建。

AOP[Top]

AOP(Aspect-Oriented Programming,面向切面编程)：能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

Spring AOP就是基于动态代理的，如果要代理的对象，实现了某个接口，那么Spring AOP会使用JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候Spring AOP会使用Cglib 。

应用场景[Top]
  1. Authentication 权限
  2. Caching 缓存
  3. Context passing 内容传递
  4. Error handling 错误处理
  5. Lazy loading 懒加载
  6. Debugging 调试
  7. logging, tracing, profiling and monitoring 记录跟踪 优化 校准
  8. Performance optimization 性能优化
  9. Persistence 持久化
  10. Resource pooling 资源池
  11. Synchronization 同步
  12. Transactions 事务
aop 相关概念[Top]
  1. 切面（aspect）:类是对物体特征的抽象，切面就是对横切关注点的抽象
  2. 横切关注点： 对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点。
  3. 连接点（joinPoint）:被拦截到的点，因为 Spring 只支持方法类型的连接点，所以在 Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器。
  4. 切入点（pointcut）:对连接点进行拦截的定义
  5. 通知（advice）:所谓通知指的就是指拦截到连接点之后要执行的代码， 通知分为前置、后置、异常、最终、环绕通知五类。
  6. 目标对象： 代理的目标对象
  7. 织入（weave）:将切面应用到目标对象并导致代理对象创建的过程
  8. 引入（introduction）:在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段
aop切面的相关方法 [Top]
@Aspect
public class TransactionDemo {
    @Pointcut(value="execution(* com.yangxin.core.service.*.*.*(..))")
    public void point(){
    }
    @Before(value="point()")
    public void before(){
        System.out.println("transaction begin");
    }
    @AfterReturning(value = "point()")
    public void after(){
        System.out.println("transaction commit");
    }
    @Around("point()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("transaction begin");
        joinPoint.proceed();
        System.out.println("transaction commit");
    }
}

Spring AOP切点表达式用法总结

面试问题[Top]

Spring AOP 和 AspectJ AOP 有什么区别？
Spring AOP 属于运行时增强，而 AspectJ 是编译时增强。 Spring AOP 基于代理(Proxying)，而 AspectJ 基于字节码操作(Bytecode Manipulation)。

  • 如果我们的切面比较少，那么两者性能差异不大。但是，当切面太多的话，最好选择 AspectJ ，基于字节码的修改实现代理，它比Spring AOP 快很多。
  • @EnableAspectJAutoProxy + @Configuration 用于加载@AspectJ的类。但是在Spring Boot项目中，我们不必显式使用@EnableAspectJAutoProxy。 如果Aspect或Advice位于类路径中，则有一个专用的AopAutoConfiguration启用Spring的AOP支持。

代理方法可以为private吗？

  • Jdk动态代理代理类必须要实现接口，并且只能代理接口中的方法，接口默认的封装级别都是public
  • Cglib动态代理本质是基于继承代理类，重写子类方法实现代理，重写子类方法不能为private的。

Jdk动态代理和Cglib动态代理区别?
Jdk动态代理和Cglib动态代理对比：

  • Jdk动态代理本质是基于反射，Cglib动态代理本质是基于继承代理类，重写子类方法实现代理。
  • Jdk动态代理代理类必须要实现接口，并且只能代理接口中的方法，Cglib动态代理，代理类本身不需要实现任何方法即可实现代理，但是由于实现原理是基于继承代理类实现，所以，代理类以及代理的方法不能用final修饰。
  • Jdk动态代理基于反射实现，在运行期间完成代理工作，Cglib动态代理是通过字节码增强技术，在编译器完成代理，所以，Cglib动态代理的效率要稍高于Jdk动态代理。

Spring 中的 bean 的作用域有哪些?[Top]

  • singleton : 唯一 bean 实例，Spring 中的 bean 默认都是单例的。
  • prototype : 每次请求都会创建一个新的 bean 实例。如跟请求状态有关的对象，就不能使用单例，需要使用多例保证线程安全。

    之所以用多例，是为了防止并发问题；即一个请求改变了对象的状态，此时对象又处理另一个请求，而之前请求对对象状态的改变导致了对象对另一个请求做了错误的处理；
    使用@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE,proxyMode = ScopedProxyMode.TARGET_CLASS)。ScopedProxyMode.TARGET_CLASS是字节码级别多例,设置多例的代理模式使用一次就会产生一个运行时字节新对象

  • request : 每一次HTTP请求都会产生一个新的bean，该bean仅在当前HTTP request内有效。
  • session : 每一次HTTP请求都会产生一个新的 bean，该bean仅在当前 HTTP session 内有效。

global-session： 全局session作用域，仅仅在基于portlet的web应用中才有意义，Spring5已经没有了。Portlet是能够生成语义代码(例如：HTML)片段的小型Java Web插件。它们基于portlet容器，可以像servlet一样处理HTTP请求。但是，与 servlet 不同，每个 portlet 都有不同的会话

Spring 中的 bean 生命周期[Top]

  • 见声明周期详解

Spring 循环依赖[Top]

对于普通的循环依赖如A 依赖B， B依赖A。在初始化A的时候，会实例化B，实例化B发现需要A的引用，这时候通过缓存返回A的引用。虽然A还未初始化完毕，但是由于是对象的引用，所以最终初始化完成的时候，两个对象均是初始化完整的。
avatar

getSingleton(beanName, true)这个方法实际上就是到缓存中尝试去获取Bean，整个缓存分为三级

  • singletonObjects，一级缓存，存储的是所有创建好了的单例Bean
  • earlySingletonObjects，完成实例化，但是还未进行属性注入及初始化的对象
  • singletonFactories，提前暴露的一个单例工厂（一个获取对象的函数表达式），二级缓存中存储的就是从这个工厂中获取到的对象。

循环依赖装载流程：

  • 条件1.出现循环依赖的Bean必须要是单例
  • 条件2.依赖注入的方式不能全是构造器注入的方式
  1. 实例化A对象，添加提前暴露的对象的方法到singletonFactory
  2. 填充对象，无循环引用，直接调用postProcessAfterInitialization方法。有循环引用，doGetBean循环引用的对象。
  3. 循环引用对象B实例化，在填充对象的时候，发现循环依赖A，从三级缓存中获取，并添加A到二级缓存。
  4. 若A为AOP代理，此时二级缓存中的对象为代理对象A。
  5. B初始化完成后，继续A的对象填充及初始化，填充完成后。从二级缓存中获取对象，若存在对象，说明发生了循环引用，返回二级缓存的对象。

相关问题(加深理解)[Top]

可以使用两层缓存吗？

  1. 如果单单使用二级缓存，为解决循环引用问题，那么二级缓存存储的就是为进行属性注入的对象。这与Spring生命周期的设计相悖。\
  2. Spring结合AOP跟Bean的生命周期本身就是通过AnnotationAwareAspectJAutoProxyCreator这个后置处理器来完成的，在这个后置处理的postProcessAfterInitialization方法中对初始化后的Bean完成AOP代理。
    如果出现了循环依赖，那没有办法，只有给Bean先创建代理。但是如果没有出现循环依赖的情况下，设计之初就是让Bean在生命周期的最后一步完成代理而不是在实例化后就立马完成代理。

三级缓存为什么要使用工厂而不是直接使用引用？换而言之，为什么需要这个三级缓存，直接通过二级缓存暴露一个引用不行吗？

这个工厂的目的在于延迟对实例化阶段生成对象的代理，只有真正发生循环依赖的时候，才去提前生成代理对象，否则只会创建一个工厂并将其放入到三级缓存中，但是不会去通过这个工厂去真正创建对象。

三级缓存引入对于对象延迟实例化的体现。
avatar

不同注入方式对于循环引用的影响
avatar

相关文章[Top]

讲一讲Spring中的循环依赖

Spring Transaction[Top]

基础知识[Top]

Spring 框架中，事务管理相关最重要的 3 个接口如下：

  • TransactionDefinition： 事务定义信息(事务隔离级别、传播行为、超时、只读、回滚规则)。
  • PlatformTransactionManager： （平台）事务管理器，Spring 事务策略的核心，约束了事务常用的方法。

通过这个接口，Spring 为各个平台如 JDBC(DataSourceTransactionManager)、Hibernate(HibernateTransactionManager)、JPA(JpaTransactionManager)等都提供了对应的事务管理器，但是具体的实现就是各个平台自己的事情了。

public interface PlatformTransactionManager {
    //获得事务
    TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;
    //提交事务
    void commit(TransactionStatus var1) throws TransactionException;
    //回滚事务
    void rollback(TransactionStatus var1) throws TransactionException;
}
  • TransactionStatus： 事务运行状态。
public interface TransactionStatus{
   boolean isNewTransaction(); // 是否是新的事务
   boolean hasSavepoint(); // 是否有恢复点
   void setRollbackOnly();  // 设置为只回滚
   boolean isRollbackOnly(); // 是否为只回滚
   boolean isCompleted; // 是否已完成
}
  1. 注解@EnableTransactionManagement 实现事务相关的Bean加载（现在自动配置使用AutoConfiguration实现）
  2. TransactionInterceptor 主要的实现类，继承TransactionAspectSupport（定义了事务实现的方式）
  3. 实现原理为使用AOP+ThreadLocal实现。

事务能否生效数据库引擎是否支持事务是关键。比如常用的 MySQL 数据库默认使用支持事务的innodb引擎。但是，如果把数据库引擎变为 myisam，那么程序也就不再支持事务了！

详细可见spring 源码部分

编程式事务[Top]

  1. 使用 TransactionManager 进行编程式事务管理
  2. 使用TransactionTemplate 进行编程式事务管理
public class TestTransactionController {
    private PlatformTransactionManager transactionManager;

    private TransactionTemplate transactionTemplate;

    private JdbcTemplate jdbcTemplate;
  /**
     * 使用transaction manager实现编程性事务
     */
    @GetMapping("/manager")
    public void testManager() {
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
        try {
            String sql = "INSERT INTO `demo` (`demo_id`, `demo_code`, `demo_name`, `status`, `status_desc`, `demo_qty`, `demo_rate`, `start_date`, `end_date`, `create_time`, `create_by`, `create_by_name`, `update_time`, `update_by`, `update_by_name`, `version`) VALUES (?, 11, ?, '1', '123', '12', '12.000', '2020-11-19 19:36:07', '2020-11-07 19:36:11', '2020-11-07 19:36:18', '123', '123', NULL, NULL, NULL, '0') ";
            Object[] objects = new Object[]{String.valueOf(random.nextInt(1000000)), "test"};
            jdbcTemplate.update(sql, objects);
            transactionManager.commit(status);
        } catch (Exception e) {
            transactionManager.rollback(status);
        }
    }

    /**
     * 使用transaction Template 实现编程性事务
     */
    @GetMapping("/template")
    public void testTemplate() {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
                try {
                    String sql = "INSERT INTO `demo` (`demo_id`, `demo_code`, `demo_name`, `status`, `status_desc`, `demo_qty`, `demo_rate`, `start_date`, `end_date`, `create_time`, `create_by`, `create_by_name`, `update_time`, `update_by`, `update_by_name`, `version`) VALUES (?, 11, ?, '1', '123', '12', '12.000', '2020-11-19 19:36:07', '2020-11-07 19:36:11', '2020-11-07 19:36:18', '123', '123', NULL, NULL, NULL, '0') ";
                    Object[] objects = new Object[]{String.valueOf(random.nextInt(1000000)), "test"};
                    jdbcTemplate.update(sql, objects);
                    // ....  业务代码
                } catch (Exception e){
                    //回滚
                    transactionStatus.setRollbackOnly();
                }

            }
        });
    }
}

@Transactional 声明式事务管理[Top]

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, rollbackFor = RuntimeException.class, readOnly = false, timeout = -1)
@GetMapping("/update")
public String update() {
... 
}

声明式事务相关属性[Top]

属性名说明
propagation事务的传播行为，默认值为 REQUIRED，可选的值在上面介绍过
isolation事务的隔离级别，默认值采用 DEFAULT，可选的值在上面介绍过
timeout事务的超时时间，默认值为-1（不会超时）。如果超过该时间限制但事务还没有完成，则自动回滚事务。
readOnly指定事务是否为只读事务，默认值为 false。
rollbackFor用于指定能够触发事务回滚的异常类型，并且可以指定多个异常类型。

事务传播行为[Top]

事务传播行为是为了解决业务层方法之间互相调用的事务问题。

汇总：

  • Propagation.REQUIRED：如果当前存在事务，则加入该事务，如果当前不存在事务，则创建一个新的事务。

  • Propagation.SUPPORTS：如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务的方式继续运行。

  • Propagation.MANDATORY：如果当前存在事务，则加入该事务；如果当前不存在事务，则抛出异常IllegalTransactionStateException。

  • Propagation.REQUIRES_NEW：重新创建一个新的事务，如果当前存在事务，延缓当前的事务。

  • Propagation.NESTED：如果没有，就新建一个事务；如果有，就在当前事务中嵌套其他事务。

  • Propagation.NOT_SUPPORTED：以非事务的方式运行，如果当前存在事务，暂停当前的事务。

  • Propagation.NEVER：以非事务的方式运行，如果当前存在事务，则抛出异常。

spring transaction的隔离级别[Top]

  • TransactionDefinition.ISOLATION_DEFAULT :使用后端数据库默认的隔离级别，MySQL 默认采用的 REPEATABLE_READ 隔离级别 Oracle 默认采用的 READ_COMMITTED 隔离级别.
  • TransactionDefinition.ISOLATION_READ_UNCOMMITTED :最低的隔离级别，使用这个隔离级别很少，因为它允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读
  • TransactionDefinition.ISOLATION_READ_COMMITTED : 允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生
  • TransactionDefinition.ISOLATION_REPEATABLE_READ : 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生。
  • TransactionDefinition.ISOLATION_SERIALIZABLE : 最高的隔离级别，完全服从 ACID 的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

事务失效场景[Top]

  1. 注解导致的事务失效：
    1. @Transactional 注解属性 propagation 设置错误，设置了以非事务的状态运行
    2. @Transactional 注解属性 rollbackFor 设置错误，实际抛出的错误跟设置不一致
  2. 方法修饰符导致的事务失效
    1. @Transactional 应用在非 public 修饰的方法上，在事务方法拦截执行中，非public方法不执行。
    2. 在动态代理层面，若为也需要代理的方法为public才能正常代理。如JDK动态代理，通过接口代理，接口方法默认都是public。而Cglib基于类的代理中会默认判断是否为public方法。
  3. 同一个类中方法调用，导致@Transactional失效，在当前的bean中非事务方法调用事务方法为什么不生效？
    • 当进行方法拦截的时候，方法拦截器首先获取当前动态代理的对象所代理的原始对象。如果判断当前的方法比如save方法没有Advice(增强)，则直接调用原对象的方法，即这个时候调用的是FirstApp.save方法。
  4. 异常被 catch 导致@Transactional失效
  5. 数据库引擎不支持事务
同一个方法调用无事务的解决方案[Top]

当这个方法被同一个类调用的时候，spring无法将这个方法加到事务管理中。只有在代理对象之间进行调用时，可以触发切面逻辑。

  1. 使用 ApplicationContext 上下文对象获取该对象;
  2. 使用 AopContext.currentProxy() 获取代理对象,但是需要配置exposeProxy=true

Spring boot 自动配置的加载流程[Top]

在上下文初始化中invoke**PostProcessor是有执行等级之分的。
自动配置加载主要在上下文初始化的invokeBeanFactoryPostProcessors(beanFactory);

  1. Spring boot的配置自动加载主要通过@SpringBootApplication 中的 @EnableAutoConfiguration注解实现
  2. 注解中@Import(AutoConfigurationImportSelector.class) 的类。借助@Import的支持，收集和注册特定场景相关的bean定义。
  3. 该AutoConfigurationImportSelector类的getAutoConfigurationEntry方法会扫描所有包下spring-autoconfigure-metadata.properties的属性
  4. 通过@ConditionOn的系列注解并对比过滤符合当前配置的配置项，重新进行config的注解扫描添加需要的bean配置到BenDefinition中
  5. 再执行初始化方法。

Spring mvc 工作原理[Top]

流程说明（重要）：

一个http请求发送过来先经过Servlet的filter进行过滤，之后进入MVC流程

  1. 客户端（浏览器）发送请求，直接请求到 DispatcherServlet。
  2. DispatcherServlet 根据请求信息调用 HandlerMapping，解析请求对应的 Handler。
  3. 解析到对应的 Handler（也就是我们平常说的 Controller 控制器）后，开始由 HandlerAdapter 适配器处理。
  4. HandlerAdapter 会根据 Handler 来调用真正的处理器来处理请求，并处理相应的业务逻辑。调用handler的时候，如果有继承HandlerInterceptor接口，就对应拦截处理。
  5. 处理器处理完业务后，会返回一个 ModelAndView 对象，Model 是返回的数据对象，View 是个逻辑上的 View。
  6. ViewResolver 会根据逻辑 View 查找实际的 View。
  7. DispatcherServlet 把返回的 Model 传给 View Resolver（视图渲染）。
  8. 把 View 返回给请求者（浏览器）

BeanFactory和ApplicationContext的区别[Top]

BeanFactory：负责配置、创建、管理bean，IOC功能的实现主要就依赖于该接口子类实现。

  • 针对bean对象数据加载都是懒加载模式，只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化。

ApplicationContext 是 Spring 应用程序中的中央接口，用于向应用程序提供配置信息。它继承了 BeanFactory 接口，所以 ApplicationContext 包含 BeanFactory 的所有功能以及更多功能
其主要实现的接口与功能如下：

  • MessageSource，主要用于国际化数据资源的加载，如存在中文的配置文件。
  • ApplicationEventPublisher，提供了事件发布功能，事件驱动模型。
  • EnvironmentCapable，可以获取容器当前运行的环境
  • ResourceLoader，主要用于加载资源文件，提供底层资源的访问的能力
  • BeanFactory接口
  • 非延迟加载：ApplicationContext是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误。
  • 后置处理器注册方式：两者都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，而ApplicationContext则是自动注册
  • 提供Web及Aop的支持

BeanFactory是Spring框架的基础设施，面向Spring本身；而ApplicationContext面向使用Spring的开发者，相比BeanFactory提供了更多面向实际应用的功能，几乎所有场合都可以直接使用ApplicationContext而不是底层的BeanFactory

ApplicationContext 还区分不同类型的上下文：

  1. ClassPathXmlApplicationContext：从类路径加载配置文件的上下文。
  2. AnnotationApplicationContext：基于注解加载配置的上下文。
  3. ServletWebServerApplicationContext：提供web应用的服务的上下文。

spring容器启动过程、spring boot启动过程[Top]

spring boot启动过程

  1. 新建SpringApplication对象，实例化ApplicationContextInitializer和ApplicationListener
  2. 实例化EventPublishRunLister，用于事件驱动模型的广播。
  3. prepareEnvironment准备环境，并广播事件。

    • 环境准备的时候，BootStrapApplicationListener会启动父类上下文，并加载对应的父类配置(spring cloud的应用)。添加CloseContextOnFailureApplicationListener，用于关闭父类上下文的监听器

  4. 区分类型创建上下文。分为server、reactive和默认基于注解的三种
  5. prepareContext准备上下文，调用初始化器的初始化方法

    • BeanDefinition的加载是通过BeanDefinitionHolder填充BeanDefinition的属性，再注册到Context的BeanFactory中

  6. refresh 刷新上下文，区分上下文类型创建bean工厂。
    1. 对象锁 + AtomicBoolean 锁定刷新过程。
    2. 区分类型创建 BeanFactory
    3. 进入postProcessor的调用。其中invokeBeanFactoryPostProcessors触发自动配置的加载流程
    4. 对于web 类型的上下文，新建对应的嵌入式Server
    5. 对于所有非懒加载的Bean对象，触发bean 的实例化
    6. 完成初始化后，启动server容器

@RestController vs @Controller[Top]

@RestController

@Controller
@ResponseBody
public @interface RestController { ... }

单独使用 @Controller 不加 @ResponseBody的话返回一个视图，这种情况属于比较传统的Spring MVC 的应用

@ResponseBody[Top]

@ResponseBody 注解的作用是将 Controller 的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到HTTP 响应(Response)对象的 body 中，通常用来返回 JSON 或者 XML 数据，返回 JSON 数据的情况比较多。

  • 自定义MessageConvert？
    TODO

spring中的设计模式[Top]

  • 工厂设计模式 : Spring使用工厂模式通过 BeanFactory、ApplicationContext 创建 bean 对象。
  • 代理设计模式 : Spring AOP 功能的实现。
  • 单例设计模式 : Spring 中的 Bean 默认都是单例的。
  • 模板方法模式 : Spring 中 jdbcTemplate、hibernateTemplate 等以 Template 结尾的对数据库操作的类，它们就使用到了模板模式。
  • 包装器设计模式 : 我们的项目需要连接多个数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库。这种模式让我们可以根据客户的需求能够动态切换不同的数据源。
  • 观察者模式: Spring 事件驱动模型就是观察者模式很经典的一个应用。
  • 适配器模式 :Spring AOP 的增强或通知(Advice)使用到了适配器模式、spring MVC 中也是用到了适配器模式适配Controller。

@Import 注解[Top]

  1. 直接填class数组方式

    @Import({ 类名.class , 类名.class… })

  2. ImportSelector方式

    实现ImportSelector接口，返回一个String数组，将全类名返回。

    public class Myclass implements ImportSelector {
   @Override
   public String[] selectImports(AnnotationMetadata annotationMetadata) {
       return new String[]{"com.yc.Test.TestDemo3"};
   }
}
  3. ImportBeanDefinitionRegistrar方式 (手动注册bean到容器)

spring注解之@Import注解的三种使用方式

零散的一些面试题[Top]

@Autowired和@Resource的区别是什么？[Top]

  1. @Autowired注解是按类型装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它required属性为false。可以结合@Qualifier注解一起使用。
  2. @Resource注解和@Autowired一样，也可以标注在字段或属性的setter方法上，但它默认按名称装配。默认按byName自动注入，也提供按照byType 注入；
  3. @Resources按名字，是JDK的，@Autowired按类型，是Spring的。
  4. 处理这2个注解的BeanPostProcessor不一样CommonAnnotationBeanPostProcessor是处理@Resource注解的，AutoWiredAnnotationBeanPostProcessor是处理@AutoWired注解的

@PostConstruct和@PreDestroy[Top]

@PostConstruct和@PreDestroy 是两个作用于 Servlet 生命周期的注解，被这两个注解修饰的方法可以保证在整个 Servlet 生命周期只被执行一次，即使 Web 容器在其内部中多次实例化该方法所在的 bean。

  • @PostConstruct : 用来修饰方法，标记在项目启动的时候执行这个方法,一般用来执行某些初始化操作比如全局配置。PostConstruct 注解的方法会在构造函数之后执行,Servlet 的init()方法之前执行。
  • @PreDestroy : 当 bean 被 Web 容器的时候被调用，一般用来释放 bean 所持有的资源。。@PreDestroy 注解的方法会在Servlet 的destroy()方法之前执行。
  • 实现Spring 提供的 InitializingBean和 DisposableBean接口的效果和使用@PostConstruct和@PreDestroy 注解的效果一样

    建议您不要使用 InitializingBean回调接口，因为它不必要地将代码耦合到 Spring

@Configuration
public class MyConfiguration {
    public MyConfiguration() {
      System.out.println("构造方法被调用");
    }
    
    @PostConstruct
    private void init() {
      System.out.println("PostConstruct注解方法被调用");
    }
    
    @PreDestroy
    private void shutdown() {
      System.out.println("PreDestroy注解方法被调用");
    }
}

Spring 的异常处理[Top]

使用 @ControllerAdvice 和 @ExceptionHandler处理全局异常

@RestControllerAdvice(basePackages = {"com.design.apidesign.controller"}) 
public class ExceptionControllerAdvice { 

      @ExceptionHandler(MethodArgumentNotValidException.class)
      public String MethodArgumentNotValidExceptionHandler(MethodArgumentNotValidException e) { }
}

@ResponseStatusException：通过 ResponseStatus注解简单处理异常的方法（将异常映射为状态码）。

@ResponseStatus(code = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException2 extends RuntimeException {

   public ResourceNotFoundException2() {
   }

   // status ： http status 
   // reason ：response 的消息内容
   // cause ： 抛出的异常
   public ResponseStatusException(HttpStatus status, @Nullable String reason, @Nullable Throwable cause) {
        super(null, cause);
        Assert.notNull(status, "HttpStatus is required");
        this.status = status;
        this.reason = reason;
   }

   public ResourseNotFoundException2(String message) {
       super(message);
   }
}

json 数据处理[Top]

  • @JsonIgnoreProperties 作用在类上用于过滤掉特定字段不返回或者不解析
  • @JsonIgnore一般用于类的属性上，作用和上面的@JsonIgnoreProperties 一样。
  • @JsonFormat一般用来格式化 json 数据。
  • @JsonUnwrapped扁平化对象
  //before
  {
      "location": {
          "provinceName":"湖北",
          "countyName":"武汉"
      },
      "personInfo": {
          "userName": "coder1234",
          "fullName": "shaungkou"
      }
  }
  
  
  @Getter
  @Setter
  @ToString
  public class Account {
      @JsonUnwrapped
      private Location location;
      @JsonUnwrapped
      private PersonInfo personInfo;
      ......
  }
  
  
  //after 
  {
    "provinceName":"湖北",
    "countyName":"武汉",
    "userName": "coder1234",
    "fullName": "shaungkou"
  }

@Component 和 @Bean 的区别是什么？[Top]

作用对象不同: @Component 注解作用于类，而@Bean注解作用于方法。

  • @Component通常是通过类路径扫描来自动侦测以及自动装配到Spring容器中（我们可以使用 @ComponentScan 注解定义要扫描的路径从中找出标识了需要装配的类自动装配到 Spring 的 bean 容器中）。@Bean 注解通常是我们在标有该注解的方法中定义产生这个 bean,@Bean告诉了Spring这是某个类的示例，当我需要用它的时候还给我。
  • @Bean 注解比 Component 注解的自定义性更强，而且很多地方我们只能通过 @Bean 注解来注册bean。比如当我们引用第三方库中的类需要装配到 Spring容器时，则只能通过 @Bean来实现。
suli77
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【面试大全-Java】Spring核心问答
起而行动，方能平定心中的惶恐
04-10 1万+
Spring 是Java企业级应用的开源开发框架，Spring主要用于开发Java应用，简化Java企业级应用开发。通知实在方法执行前或者执行后要做的动作，实际就是程序需要通过AOP触发的代码段。Spring切面有5中类型的通知before：前置通知，在方法前被执行after：在方法执行之后调用的通知，无论方法是否执行成功：方法执行成功执行通知：在方法抛出异常退出时执行的通知around：在方法执行前和执行后的通知。
经典Java-SpringCloud面试题_javaspringcloud面试题
2401_84023482的博客
05-04 991
服务雪崩、降级与熔断Java面试核心知识点一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！Java面试核心知识点[外链图片转存中…(img-EwxovhKu-1714782469858)]Java面试核心知识点一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！[外链图片转存中…(img-DrC97okx-1714782469859)]Java面试核心知识点本文已被。
Java面试题--spring mvc
青春季风暴
04-02 9670
什么是Spring MVC ？简单介绍下你对springMVC的理解? Spring MVC是一个基于MVC架构的用来简化web应用程序开发的应用开发框架，它是Spring的一个模块,无需中间整合层来整合 ，它和Struts2一样都属于表现层的框架。在web模型中，MVC是一种很流行的框架，通过把Model，View，Controller分离，把较为复杂的web应用分成逻辑清晰的几部分，简化开发...
Java后端真实面试题大全(有详细答案)--高频/真题
IT利刃出鞘的博客
11-24 12万+
本文分享Java后端真实高频面试题，有详细答案，保你稳过面试。题目包括：Java基础、多线程、JVM、数据库、Redis、Shiro、Spring、SpringBoot、MyBatis、MQ、ELK、SpringCloud、设计模式等。 本博客包含从简单到困难、从高频到低频的题目，适合所有Java求职者，包括：刚入门的、三年以内经验、三到五年经验、五到十年经验等。
面试汇总-Spring-IOC和AOP
weixin_37672801的博客
08-18 9951
Resource对象与对应ApplicationContext类型如下。
Spring常见面试题总结（超详细回答）
热门推荐
张维鹏的博客
07-08 89万+
1、Spring是什么? Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。常见的配置方式有三种：基于XML的配置、基于注解的配置、基于Java的配置。 主要由以下几个模块组成： Spring Core：核心类库，提供IOC服务； Spring Context：提...
Java面试题--真实、高频、有答案，全网最强
IT利刃出鞘的博客
08-05 1505
Java面试题--真实、高频、有答案，全网最强
Java岗大厂面试百日冲刺 - 日积月累，每日三题【Day15】—— Spring框架1
陈哈哈的菜园子
06-28 2万+
百日闭关修炼，每日三道高频面试题。一起冲进大厂！看什么看？快上车！
Java笔试面试-Spring 核心
HenryLei的博客
09-23 10万+
  Spring Framework 简称 Spring，是 Java 开发中最常用的框架，地位仅次于 Java API，就连近几年比较流行的微服务框架 SpringBoot，也是基于 Spring 实现的，SpringBoot 的诞生是为了让开发者更方便地使用 Spring，因此 Spring 在 Java 体系中的地位可谓首屈一指。 Spring 介绍   Spring 是一个开源框架，为了解...
Java面试--SpringBoot启动流程
小刺猬喜歡獨角獸
12-20 1499
springboot启动流程
java面试问题-spring框架相关.docx
02-11
java面试问题-spring框架相关.docx
Java开发面试-Redis专区
10-28
当准备面试Java开发Redis部分时，对于工作一年左右经验的开发者来说，了解和掌握Redis的使用和应用是非常重要的。下面将为你详细介绍一些可能涉及的面试题，帮助你更好地准备。首先，Redis是一个开源的内存数据存储...
Java开发面试-nacos专区.md
10-28
Java开发Nacos部分是面试中常见的技术领域之一，尤其对于工作一年左右的开发者来说，掌握Nacos的使用和应用能够提升自己的竞争力和职业发展。下面将详细介绍一些可能涉及的面试题，帮助你更好地准备。首先，Nacos是...
【Java面试资料】-原创_27道大厂高频Spring面试
08-16
7. Spring 框架的优点：包括帮助开发者解决开发中基础性的问题、使开发人员可以专注于应用程序的开发、提供了一个便捷的事务管理接口等多种优势。 8. Spring 框架的设计理念：包括按照设计模式精心打造的设计理念、...
2023最新JAVA面试题集
03-28
最新JAVA面试题总结之基础/框架/数据库/JavaWeb/Redis BIO,NIO,AIO,Netty面试题 35道 BTA 常问的 Java基础39道常见面试题及详细答案 Dubbo面试题 47道 ElasticSearch面试题 30道 Git常用命令面试题 60道 Java并发...
简单的项目部署脚本（转载）
u010230019的博客
06-09 703
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1612
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 548
修改菜品——后端Java
【Java02】Java中数组的定义与初始化
最新发布
饮冰室
06-10 563
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
Java spring面试题
08-19
这些问题旨在考察面试者对于Java开发和Spring框架的综合应用能力。 综上所述，Java Spring面试题的内容主要涵盖了与Spring框架相关的知识点，包括基本概念、核心特性、常用注解、依赖注入、AOP等。此外，还可能扩展...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

suli77

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值