spring
spring 常见面试题
- 如果注入的属性为 null，你会从哪几个方向去排查？
- 配置上的问题：注入的类不在默认包扫描路径下，并且没有另外指定包扫描路径；
- 检查注入的位置，是否将 bean 注入到 static 成员上了，如果需要注入到 static 成员上，可以创建一个 set 方法进行注入；「https://blog.csdn.net/weixin_43631820/article/details/113604403」
- 由于 Bean 初始化顺序导致的问题，比如：在 Filter 或 Listener 中使用了 @Autowired，因为 Filter 和 Listener加载顺序优先于 spring 容器初始化实例，所以使用 @Autowired 肯定为 null 了，可以使用 ApplicationContext 根据 bean 名称（注意名称为实现类而不是接口）去获取 bean，随便写个工具类即可；
- 单例 Bean 生命周期的执行过程如下：
- Spring 对 bean 进行实例化，默认 bean 是单例；
- Spring 对 bean 进行依赖注入；
- 如果 bean 实现了 BeanNameAware 接口，Spring 将 bean 的名称传给 setBeanName()方法；
- 如果 bean 实现了 BeanFactoryAware 接口，Spring 将调用 setBeanFactory() 方法，将 BeanFactory 实例传进来；
- 如果 bean 实现了 ApplicationContextAware 接口，它的 setApplicationContext() 方法将被调用，将应用上下文的引用传入到 bean 中；
- 如果 bean 实现了 BeanPostProcessor 接口，它的 postProcessBeforeInitialization() 方法将被调用；
- 如果 bean 中有方法添加了 @PostConstruct 注解，那么该方法将被调用；
- 如果 bean 实现了 InitializingBean 接口，spring 将调用它的 afterPropertiesSet() 接口方法，类似的如果 bean 使用了 init-method 属性声明了初始化方法，该方法也会被调用；
- 如果在 xml 文件中通过 bean 标签的 init-method 元素指定了初始化方法，那么该方法将被调用；
- 如果 bean 实现了 BeanPostProcessor 接口，它的 postProcessAfterInitialization() 接口方法将被调用；
- 此时 bean 已经准备就绪，可以被应用程序使用了，他们将一直驻留在应用上下文中，直到该应用上下文被销毁；
- 如果 bean 中有方法添加了 @PreDestroy 注解，那么该方法将被调用；
- 若 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 代理。
原理区别：
- jdk 动态代理：利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用 InvokeHandler 来处理。核心是实现 InvocationHandler 接口，使用 invoke() 方法进行面向切面的处理，调用相应的通知；「如果被代理的类没有实现接口的话，那就不能使用 jdk 动态代理」
- cglib 代理：利用 asm 开源包，对代理对象类的 class 文件加载进来，通过修改其字节码生成子类来处理。核心是实现 MethodInterceptor 接口，使用 intercept() 方法进行面向切面的处理，调用相应的通知；「如果类没有实现接口，推荐使用 cglib，但是如果类时 final 的，那就没法代理了」
性能区别：
- cglib 底层采用 ASM 字节码生成框架，使用字节码技术生成代理类，在 jdk6 之前比使用 Java 反射效率要高。唯一需要注意的是，cglib 不能对声明为 final 的方法进行代理，因为 cglib 原理是动态生成被代理类的子类；
- 在 jdk6、jdk7、jdk8 逐步对 jdk 动态代理优化之后，在调用次数较少的情况下，jdk 代理效率高于 cglib 代理效率，只有当进行大量调用的时候，jdk6 和 jdk7 比 cglib 代理效率低一点，但是到 jdk8 的时候，jdk 代理效率高于 cglib 代理。
各自的局限性：
- jdk 的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现 jdk 的动态代理；
- 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();
}
}