03-框架篇 面试题-mk

1.Spring框架中的单例bean是线程安全的吗？

Spring框架中的bean是单例的吗？

是的，可以通过给类设置 @Scope(“singleton”) 注解来确定是否为单例，不设置注解默认是单例的

@Service
@Scope("singleton")
public class UserServiceImpl implements UserService {
    }

• singleton：bean在每个Spring IOC容器中只有一个实例。
• prototype：一个bean的定义可以有多个实例。
  Spring框架中的单例bean是线程安全的吗？

不是线程安全的

既然不是线程安全的，实际开发中有没有问题呢？

并发请求getById方法，都会修改成员变量 count值，count会有线程安全问题。形参id 作为局部变量，一般情况下没有线程安全问题。

userService 也是成员变量有没有线程安全问题？

它没有线程安全问题，它是一个无状态的类

Spring bean并没有可变的状态(比如Service类和DAO类)，所以在某种程度上说Spring的单例bean是线程安全的。

什么是无状态？

简单来说就是判断当前成员变量能不能被修改

@Controller
@RequestMapping("/user")
public class UserController {
   
    private int count;
    
    @Autowired   
    private UserService userService;
 
    @GetMapping("/getById/{id}")    
    public User getById(@PathVariable("id") Integer id){
           
        count++;        
        System.out.println(count);        
        return userService.getById(id);    
    }
}

尽量避免定义可修改的成员变量

Spring框架中的单例bean是线程安全的吗？

不是线程安全的
Spring框架中有一个@Scope注解，默认的值就是singleton，单例的。
因为一般在spring的bean的中都是注入无状态的对象（比如Service类和DAO类），没有线程安全问题，如果在bean中定义了可修改的成员变量，是要考虑线程安全问题的，可以使用多例（prototype）或者加锁来解决

2.什么是AOP，你们项目中有没有使用到AOP

AOP 的底层原理

• 对AOP的理解
• 有没有真的用过aop

AOP称为面向切面编程，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。

常见的AOP使用场景：

• 记录操作日志
• 缓存处理
• Spring中内置的事务处理（用的是AOP，底层用的动态代理）

记录操作日志思路

获取请求的用户名、请求方式、访问地址、模块名称、登录ip、操作时间，记录到数据库的日志表中


Spring中的事务是如何实现的?

Spring支持编程式事务管理和声明式事务管理两种方式。

• 编程式事务管理：需使用TransactionTemplate来进行实现，对业务代码有侵入性，项目中很少使用（需要在代码中开启事务、提交事务、回滚事务）
• 声明式事务管理：声明式事务管理建立在AOP之上的。其本质是通过AOP功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，也就是在目标方法开始之前加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

什么是AOP

面向切面编程，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取公共模块复用，降低耦合

你们项目中有没有使用到AOP

记录操作日志，缓存，spring实现的事务
核心是：使用aop中的环绕通知+切点表达式（找到要记录日志的方法），通过环绕通知的参数获取请求方法的参数（类、方法、注解、请求方式等），获取到这些参数以后，保存到数据库

Spring中的事务是如何实现的

其本质是通过AOP功能，对方法前后进行拦截，在执行方法之前开启事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

面试参考回答：

面试官：什么是AOP

候选人：aop是面向切面编程，在spring中用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取公共模块复用，降低耦合，一般比如可以做为公共日志保存，事务处理等

面试官：你们项目中有没有使用到AOP

候选人：我们当时在后台管理系统中，就是使用aop来记录了系统的操作日志

主要思路是这样的，使用aop中的环绕通知+切点表达式，这个表达式就是要找到要记录日志的方法，然后通过环绕通知的参数获取请求方法的参数，比如类信息、方法信息、注解、请求方式等，获取到这些参数以后，保存到数据库

面试官：Spring中的事务是如何实现的

候选人：spring实现的事务本质就是aop完成，对方法前后进行拦截，在执行方法之前开启事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

3.Spring 事务传播行为

Spring 事务传播行为

3.Spring中事务失效的场景有哪些

对spring框架的深入理解、复杂业务的编码经验

• 异常捕获处理
• 抛出检查异常
• 非public方法

@Transactional
public void update(Integer from, Integer to, Double money) {
   
    try {
   
        //转账的用户不能为空       
        Account fromAccount = accountDao.selectById(from);
        //判断用户的钱是否够转账       
        if (fromAccount.getMoney() - money >= 0) {
   
            fromAccount.setMoney(fromAccount.getMoney() - money);
            accountDao.updateById(fromAccount);
            //异常      
            int a = 1 / 0;
            //被转账的用户       
            Account toAccount = accountDao.selectById(to);
            toAccount.setMoney(toAccount.getMoney() + money);
            accountDao.updateById(toAccount);
        }
    } catch (Exception e) {
   
        e.printStackTrace();
    }
}

原因：事务通知只有捉到了目标抛出的异常，才能进行后续的回滚处理，如果目标自己处理掉异常，事务通知无法知悉

解决方案：在catch块添加throw new RuntimeException(e)抛出

情况二：抛出检查异常

@Transactional
public void update(Integer from, Integer to, Double money) throws FileNotFoundException {
   
    //转账的用户不能为空    
    Account fromAccount = accountDao.selectById(from);
    //判断用户的钱是否够转账    
    if (fromAccount.getMoney() - money >= 0) {
   
        fromAccount.setMoney(fromAccount.getMoney() - money);
        accountDao.updateById(fromAccount);
        //读取文件    
        new FileInputStream("dddd");
        //被转账的用户     
        Account toAccount = accountDao.selectById(to);
        toAccount.setMoney(toAccount.getMoney() + money);
        accountDao.updateById(toAccount);
    }
}

原因：Spring 默认只会回滚非检查异常

解决方案：配置rollbackFor属性，@Transactional(rollbackFor=Exception.class)

情况三：非public方法导致的事务失效

@Transactional
void update(Integer from, Integer to, Double money) throws FileNotFoundException {
   
    //转账的用户不能为空    
    Account fromAccount = accountDao.selectById(from);
    //判断用户的钱是否够转账    
    if (fromAccount.getMoney() - money >= 0) {
   
        fromAccount.setMoney(fromAccount.getMoney() - money);
        accountDao.updateById(fromAccount);
        //读取文件    
        new FileInputStream("dddd");
        //被转账的用户     
        Account toAccount = accountDao.selectById(to);
        toAccount.setMoney(toAccount.getMoney() + money);
        accountDao.updateById(toAccount);
    }
}

原因：Spring 为方法创建代理、添加事务通知、前提条件都是该方法是 public 的

解决方案：改为 public 方法

Spring中事务失效的场景有哪些？

• 异常捕获处理，自己处理了异常，没有抛出，解决：手动抛出
• 抛出检查异常，配置rollbackFor属性为Exception
• 非public方法导致的事务失效，改为public

面试参考回答：

面试官：Spring中事务失效的场景有哪些

候选人：嗯！这个在项目中之前遇到过，我想想啊

第一个，如果方法上异常捕获处理，自己处理了异常，没有抛出，就会导致事务失效，所以一般处理了异常以后，别忘了抛出去就行了

第二个，如果方法抛出检查异常，如果报错也会导致事务失效，最后在spring事务的注解上，就是@Transactional上配置rollbackFor属性为Exception，这样别管是什么异常，都会回滚事务

第三，我之前还遇到过一个，如果方法上不是public修饰的，也会导致事务失效

嗯，就能想起来那么多

4.Spring的bean的生命周期

了解Spring的bean 的生命周期有哪些好处？

• 知道Spring容器是如何管理和创建bean实例（spring的循环依赖问题）
• 方便调试和解决问题，同时也可以编写更健壮、灵活、易维护的应用程序

BeanDefinition

Spring容器在进行实例化时，会将xml配置的的信息封装成一个BeanDefinition对象（注解也是类似的），Spring根据BeanDefinition来创建Bean对象，里面有很多的属性用来描述Bean

<bean id="userDao" class="com.aaron.dao.impl.UserDaoImpl" lazy-init="true"/>
<bean id="userService" class="com.aaron.service.UserServiceImpl" scope="singleton">            
    <property name="userDao" ref="userDao"></property>
</bean>

• beanClassName：bean 的类名（获取类名后，可以通过反射创建bean对象）
• initMethodName：初始化方法名称（bean的生命周期的时候，会调用该方法）
• propertyValues：bean 的属性值
• scope：作用域
• lazyInit：延迟初始化
  
  bean 的生命周期
  
  Spring的bean的生命周期

1. 通过BeanDefinition获取bean的定义信息
2. 调用构造函数实例化bean
3. bean的依赖注入
4. 处理Aware接口(BeanNameAware、BeanFactoryAware、ApplicationContextAware)
5. Bean的后置处理器BeanPostProcessor-前置
6. 初始化方法(InitializingBean、init-method)
7. Bean的后置处理器BeanPostProcessor-后置
8. 销毁bean

5.Spring中的循环引用

在创建A对象的同时需要使用的B对象，在创建B对象的同时需要使用到A对象，循环引用还有别的情况：

• A依赖B，B依赖C，C依赖A
• A依赖自己
  
  循环引用会出现死循环问题
  
  Spring解决循环依赖是通过三级缓存，对应的三级缓存如下所示：

//单实例对象注册器
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
   
        private static final int SUPPRESSED_EXCEPTIONS_LIMIT = 100;
        private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);// 一级缓存
        private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);// 二级缓存
        private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap(16);//三级缓存
    }

一级缓存作用：限制bean在beanFactory中只存一份，即实现singleton scope，解决不了循环依赖

如果要想打破循环依赖, 就需要一个中间人的参与, 这个中间人就是二级缓存。


构造方法出现了循环依赖怎么解决？
报错信息：

解决：

Spring中的循环引用

• 循环依赖：循环依赖其实就是循环引用,也就是两个或两个以上的bean互相持有对方,最终形成闭环。比如A依赖于B,B依赖于A
• 循环依赖在spring中是允许存在，spring框架依据三级缓存已经解决了大部分的循环依赖
  • 一级缓存：单例池，缓存已经经历了完整的生命周期，已经初始化完成的bean对象
  • 二级缓存：缓存早期的bean对象（生命周期还没走完）
  • 三级缓存：缓存的是ObjectFactory，表示对象工厂，用来创建某个对象的