spring

spring

spring 常见面试题

• 如果注入的属性为 null，你会从哪几个方向去排查？

1. 配置上的问题：注入的类不在默认包扫描路径下，并且没有另外指定包扫描路径；
2. 检查注入的位置，是否将 bean 注入到 static 成员上了，如果需要注入到 static 成员上，可以创建一个 set 方法进行注入；「https://blog.csdn.net/weixin_43631820/article/details/113604403」
3. 由于 Bean 初始化顺序导致的问题，比如：在 Filter 或 Listener 中使用了 @Autowired，因为 Filter 和 Listener加载顺序优先于 spring 容器初始化实例，所以使用 @Autowired 肯定为 null 了，可以使用 ApplicationContext 根据 bean 名称（注意名称为实现类而不是接口）去获取 bean，随便写个工具类即可；

• 单例 Bean 生命周期的执行过程如下：

1. Spring 对 bean 进行实例化，默认 bean 是单例；
2. Spring 对 bean 进行依赖注入；
3. 如果 bean 实现了 BeanNameAware 接口，Spring 将 bean 的名称传给 setBeanName()方法；
4. 如果 bean 实现了 BeanFactoryAware 接口，Spring 将调用 setBeanFactory() 方法，将 BeanFactory 实例传进来；
5. 如果 bean 实现了 ApplicationContextAware 接口，它的 setApplicationContext() 方法将被调用，将应用上下文的引用传入到 bean 中；
6. 如果 bean 实现了 BeanPostProcessor 接口，它的 postProcessBeforeInitialization() 方法将被调用；
7. 如果 bean 中有方法添加了 @PostConstruct 注解，那么该方法将被调用；
8. 如果 bean 实现了 InitializingBean 接口，spring 将调用它的 afterPropertiesSet() 接口方法，类似的如果 bean 使用了 init-method 属性声明了初始化方法，该方法也会被调用；
9. 如果在 xml 文件中通过 bean 标签的 init-method 元素指定了初始化方法，那么该方法将被调用；
10. 如果 bean 实现了 BeanPostProcessor 接口，它的 postProcessAfterInitialization() 接口方法将被调用；
11. 此时 bean 已经准备就绪，可以被应用程序使用了，他们将一直驻留在应用上下文中，直到该应用上下文被销毁；
12. 如果 bean 中有方法添加了 @PreDestroy 注解，那么该方法将被调用；
13. 若 bean 实现了 DisposableBean 接口，spring 将调用它的 distroy() 接口方法。同样的，如果bean 使用了 destroy-method 属性声明了销毁方法，则该方法被调用；

​ 这里特别说明一下 Aware 接口，Spring 的依赖注入最大亮点就是所有的 Bean 对 Spring 容器的存在是没有意识的。但是在实际项目中，我们有时不可避免的要用到 Spring 容器本身提供的资源，这时候要让 Bean 主动意识到 Spring 容器的存在，才能调用 Spring 所提供的资源，这就是 Spring 的 Aware 接口，Aware 接口是个标记接口，标记这一类接口是用来“感知”属性的，Aware 的众多子接口则是表征了具体要“感知”什么属性。

​ 例如 BeanNameAware 接口用于“感知”自己的名称，ApplicationContextAware 接口用于“感知”自己所处的上下文。其实 Spring 的 Aware 接口是 Spring 设计为框架内部使用的，在大多数情况下，我们不需要使用任何 Aware 接口，除非我们真的需要它们，实现了这些接口会使应用层代码耦合到 Spring 框架代码中。

bean 生命周期如图：

spring 中的 aop

默认采用的是 jdk 动态代理，如果被代理的类不是接口的话，那就得使用 cglib 代理。

原理区别：

1. jdk 动态代理：利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用 InvokeHandler 来处理。核心是实现 InvocationHandler 接口，使用 invoke() 方法进行面向切面的处理，调用相应的通知；「如果被代理的类没有实现接口的话，那就不能使用 jdk 动态代理」
2. cglib 代理：利用 asm 开源包，对代理对象类的 class 文件加载进来，通过修改其字节码生成子类来处理。核心是实现 MethodInterceptor 接口，使用 intercept() 方法进行面向切面的处理，调用相应的通知；「如果类没有实现接口，推荐使用 cglib，但是如果类时 final 的，那就没法代理了」

性能区别：

1. cglib 底层采用 ASM 字节码生成框架，使用字节码技术生成代理类，在 jdk6 之前比使用 Java 反射效率要高。唯一需要注意的是，cglib 不能对声明为 final 的方法进行代理，因为 cglib 原理是动态生成被代理类的子类；
2. 在 jdk6、jdk7、jdk8 逐步对 jdk 动态代理优化之后，在调用次数较少的情况下，jdk 代理效率高于 cglib 代理效率，只有当进行大量调用的时候，jdk6 和 jdk7 比 cglib 代理效率低一点，但是到 jdk8 的时候，jdk 代理效率高于 cglib 代理。

各自的局限性：

1. jdk 的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现 jdk 的动态代理；
2. cglib 是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对 final 修饰的类进行代理。

jdk 动态代理的demo

接口类

/**
 * 接口类，被代理类实现的接口
 */
public interface HelloInterface {
    /**
     * 需要增强的方法
     */
		void sayHello();
}

被代理的类，实现了对应的接口

/**
 * 被代理类，实现了接口
 */
public class HelloImpl implements HelloInterface {
  	/**
  	 * 需要被增强的方法
  	 */
    @Override
    public void sayHello() {
        System.out.println("hello");
    }
}

InvocationHandler 实现类，执行 invoke 方法

/**
 * 每次生成动态代理类对象时都需要指定一个实现了 InvocationHandler 接口的调用处理器对象
 */
public class ProxyHandler implements InvocationHandler {
		// 这个就是我们要代理的真实对象，也就是真正执行业务逻辑的类
  	private Object subject;
    public ProxyHandler(Object subject) {
      	// 通过构造方法传入这个被代理对象
        this.subject = subject;
    }
    /**
     * 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的 handler 对象的 invoke 方法来进行调用
     */
    @Override
    public Object invoke(Object obj, 
                         Method method, 
                         Object[] objs) throws Throwable {
        Object result = null;
        System.out.println("可以在调用实际方法前做一些事情。。。");
        System.out.println("当前调用的方法是" + method.getName());
      	// 需要指定被代理对象和传入参数
      	result = method.invoke(subject, objs);
        System.out.println(method.getName() + "方法的返回值是" + result);
        System.out.println("可以在调用实际方法后做一些事情。。。");
				// 返回目标方法执行后的返回值
      	return result;
    }
}

测试类

/**
 * jdk 动态代理测试方法
 */
public class Mytest {

    public static void main(String[] args) {
        //第一步：创建被代理对象
        HelloImpl hello = new HelloImpl();
        //第二步：创建 handler，传入真实对象
        ProxyHandler handler = new ProxyHandler(hello);
        //第三步：创建代理对象，传入类加载器、接口、handler
        HelloInterface helloProxy = (HelloInterface) Proxy.newProxyInstance(
                HelloInterface.class.getClassLoader(), 
                new Class[]{HelloInterface.class}, handler);
        //第四步：调用方法
        helloProxy.sayHello();
    }
}