quarkus依赖注入之十三:其他重要知识点大串讲(终篇)

欢迎访问我的GitHub

这里分类和汇总了欣宸的全部原创(含配套源码):https://github.com/zq2599/blog_demos

本篇概览

  • 本篇是《quarkus依赖注入》系列的终篇,前面十二篇已覆盖quarkus依赖注入的大部分核心内容,但依然漏掉了一些知识点,今天就将剩下的内容汇总,来个一锅端,轻松愉快的结束这个系列
  • 总的来说,本篇由以下内容构成,每个段落都是个独立的知识点
  1. 几处可以简化编码的地方,如bean注入、构造方法等
  2. WithCaching:特定场景下,减少bean实例化次数
  3. 静态方法是否可以被拦截器拦截?
  4. All注解,让多个bean的注入更加直观
  5. 统一处理异步事件的异常
  • 咱们从最简单的看起:表达方式的简化,一共有三个位置可以简化:bean的注入、bean构造方法、bean生产方法

简化之一:bean注入

  • quarkus在CDI规范的基础上做了简化,可以让我们少写几行代码

  • 将配置文件中名为greeting.message的配置项注入到bean的成员变量greetingMsg中,按照CDI规范的写法如下

  @Inject
  @ConfigProperty(name = "greeting.message")
  String greetingMsg;
  • 在quarkus框架下可以略去@Inject,写成下面这样的效果和上面的代码一模一样
@ConfigProperty(name = "greeting.message")
String greetingMsg;

简化之二:bean构造方法

  • 关于bean的构造方法,CDI有两个规定:首先,必须要有无参构造方法,其次,有参数的构造方法需要@Inject注解修饰,实例代码如下所示
@ApplicationScoped
public class MyCoolService {

  private SimpleProcessor processor;

  MyCoolService() { // dummy constructor needed
  }

  @Inject // constructor injection
  MyCoolService(SimpleProcessor processor) {
    this.processor = processor;
  }
}
  • 但是,在quarkus框架下,无参构造方法可不写,有参数的构造方法也可以略去@Inject,写成下面这样的效果和上面的代码一模一样
@ApplicationScoped
public class MyCoolService {

  private SimpleProcessor processor;

  MyCoolService(SimpleProcessor processor) {
    this.processor = processor;
  }
}

简化之三:bean生产方法

  • 在CDI规范中,通过方法生产bean的语法如下,可见要同时使用ProducesApplicationScoped注解修饰返回bean的方法
class Producers {
  
  @Produces
  @ApplicationScoped
  MyService produceServ
    ice() {
    return new MyService(coolProperty);
  }
}
  • 在quarkus框架下可以略去@Produces,写成下面这样的效果和上面的代码一模一样
class Producers {

  @ApplicationScoped
  MyService produceService() {
    return new MyService(coolProperty);
  }
}
  • 好了,热身结束,接下来看几个略有深度的技能

WithCaching注解:避免不必要的多次实例化

  • 在介绍WithCaching注解之前,先来看一个普通场景
  • 下面是一段单元测试代码,HelloDependent类型的bean通过Instance的方式被注入,再用Instance#get来获取此bean
@QuarkusTest
public class WithCachingTest {

    @Inject
    Instance<HelloDependent> instance;

    @Test
    public void test() {
        // 第一次调用Instance#get方法
        HelloDependent helloDependent = instance.get();
        helloDependent.hello();

        // 第二次调用Instance#get方法
        helloDependent = instance.get();
        helloDependent.hello();
    }
}
  • 上述代码是种常见的bean注入和使用方式,我们的本意是在WithCachingTest实例中多次使用HelloDependent类型的bean,可能是在test方法中使用,也可能在WithCachingTest的其他方法中使用

  • 如果HelloDependent的作用域是ApplicationScoped,上述代码一切正常,但是,如果作用域是Dependent呢?代码中执行了两次Instance#get,得到的HelloDependent实例是同一个吗?Dependent的特性是每次注入都实例化一次,这里的Instance#get又算几次注入呢?

  • 最简单的方法就是运行上述代码看实际效果,这里先回顾HelloDependent.java的源码,如下所示,构造方法中会打印日志,这下好办了,只要看日志出现几次,就知道实例化几次了

@Dependent
public class HelloDependent {

    public HelloDependent(InjectionPoint injectionPoint) {
        Log.info("injecting from bean "+ injectionPoint.getMember().getDeclaringClass());
    }

    public String hello() {
        return this.getClass().getSimpleName();
    }
}
  • 运行单元测试类WithCachingTest,如下图红框所示,构造方法中的日志打印了两次,所以:每次Instance#get都相当于一次注入,如果bean的作用域是Dependent,就会创建一个新的实例并返回
  • 现在问题来了:如果bean的作用域必须是Dependent,又希望多次Instance#get返回的是同一个bean实例,这样的要求可以做到吗?
  • 答案是可以,用WithCaching注解修饰Instance即可,改动如下图红框1,改好后再次运行,红框2显示HelloDependent只实例化了一次

拦截静态方法

  • 先回顾一下拦截器的基本知识,定义一个拦截器并用来拦截bean中的方法,总共需要完成以下三步
  • 实现拦截器的具体功能时,还要用注解指明拦截器类型,一共有四种类型
  1. AroundInvoke:拦截bean方法
  2. PostConstruct:生命周期拦截器,bean创建后执行
  3. PreDestroy:生命周期拦截器,bean销毁前执行
  4. AroundConstruct:生命周期拦截器,拦截bean构造方法
  • 现在问题来了:拦截器能拦截静态方法吗?
  • 答案是可以,但是有限制,具体的限制如下
  1. 仅支持方法级别的拦截(即拦截器修饰的是方法)
  2. private型的静态方法不会被拦截
  3. 下图是拦截器实现的常见代码,通过入参InvocationContext的getTarget方法,可以得到被拦截的对象,然而,在拦截静态方法时,getTarget方法的返回值是null,这一点尤其要注意,例如下图红框中的代码,在拦截静态方法是就会抛出空指针异常

All更加直观的注入

  • 假设有个名为SayHello的接口,源码如下
public interface SayHello {
    void hello();
}
  • 现在有三个bean都实现了SayHello接口,如果想要调用这三个bean的hello方法,应该怎么做呢?

  • 按照CDI的规范,应该用Instance注入,然后使用Instance中的迭代器即可获取所有bean,代码如下

public class InjectAllTest {
    /**
     * 用Instance接收注入,得到所有SayHello类型的bean
     */
    @Inject
    Instance<SayHello> instance;

    @Test
    public void testInstance() {
        // instance中有迭代器,可以用遍历的方式得到所有bean
        for (SayHello sayHello : instance) {
            sayHello.hello();
        }
    }
}
  • quarkus提供了另一种方式,借助注解io.quarkus.arc.All,可以将所有SayHello类型的bean注入到List中,如下所示
@QuarkusTest
public class InjectAllTest {
    /**
     * 用All注解可以将SayHello类型的bean全部注入到list中,
     * 这样更加直观
     */
    @All
    List<SayHello> list;

    @Test
    public void testAll() {
        for (SayHello sayHello : list) {
            sayHello.hello();
        }
    }
}
  • 和CDI规范相比,使用All注解可以让代码显得更为直观,另外还有以下三个特点
  1. 此list是immutable的(内容不可变)

  2. list中的bean是按照priority排序的

  3. 如果您需要的不仅仅是注入bean,还需要bean的元数据信息(例如bean的scope),可以将List中的类型从SayHello改为InstanceHandle<SayHello>,这样即可以得到注入bean,也能得到注入bean的元数据(在InjectableBean中),参考代码如下

@QuarkusTest
public class InjectAllTest {
    
    @All
    List<InstanceHandle<SayHello>> list;

    @Test
    public void testQuarkusAllAnnonation() {
        for (InstanceHandle<SayHello> instanceHandle : list) {
            // InstanceHandle#get可以得到注入bean
            SayHello sayHello = instanceHandle.get();

            // InjectableBean封装了注入bean的元数据信息
            InjectableBean<SayHello> injectableBean = instanceHandle.getBean();

            // 例如bean的作用域就能从InjectableBean中取得
            Class clazz = injectableBean.getScope();

            // 打印出来验证
            Log.infov("bean [{0}], scope [{1}]", sayHello.getClass().getSimpleName(), clazz.getSimpleName() );
        }
    }
}
  • 代码的执行结果如下图红框所示,可见注入bean及其作用域都能成功取得(要注意的是注入bean是代理bean)

统一处理异步事件的异常

  • 需要提前说一下,本段落涉及的知识点和AsyncObserverExceptionHandler类有关,而《quarkus依赖注入》系列所用的quarkus-2.7.3.Final版本中并没有AsyncObserverExceptionHandler类,后来将quarkus版本更新为2.8.2.Final,就可以正常使用AsyncObserverExceptionHandler类了

  • 本段落的知识点和异步事件有关:如果消费异步事件的过程中发生异常,而开发者有没有专门写代码处理异步消费结果,那么此异常就默默无闻的被忽略了,我们也可能因此错失了及时发现和处理问题的时机

  • 来写一段代码复现上述问题,首先是事件定义TestEvent.java,就是个普通类,啥都没有

public class TestEvent {
}
  • 然后是事件的生产者TestEventProducer.java,注意其调用fireAsync方法发送了一个异步事件
@ApplicationScoped
public class TestEventProducer {

    @Inject
    Event<TestEvent> event;

    /**
     * 发送异步事件
     */
    public void asyncProduce() {
        event.fireAsync(new TestEvent());
    }
}
  • 事件的消费者TestEventConsumer.java,这里在消费TestEvent事件的时候,故意抛出了异常
@ApplicationScoped
public class TestEventConsumer {

    /**
     * 消费异步事件,这里故意抛出异常
     */
    public void aSyncConsume(@ObservesAsync TestEvent testEvent) throws Exception {
       throw new Exception("exception from aSyncConsume");
    }
}
  • 最后是单元测试类将事件的生产和消费运行起来
@QuarkusTest
public class EventExceptionHandlerTest {

    @Inject
    TestEventProducer testEventProducer;

    @Test
    public void testAsync() throws InterruptedException {
       testEventProducer.asyncProduce();
    }
}
  • 运行EventExceptionHandlerTest,结果如下图,DefaultAsyncObserverExceptionHandler处理了这个异常,这是quarkus框架的默认处理逻辑

  • DefaultAsyncObserverExceptionHandler只是输出了日志,这样的处理对于真实业务是不够的(可能需要记录到特定地方,调用其他告警服务等),所以,我们需要自定义默认的异步事件异常处理器
  • 自定义的全局异步事件异常处理器如下
package com.bolingcavalry.service.impl;

import io.quarkus.arc.AsyncObserverExceptionHandler;
import io.quarkus.logging.Log;

import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.spi.EventContext;
import javax.enterprise.inject.spi.ObserverMethod;

@ApplicationScoped
public class NoopAsyncObserverExceptionHandler implements AsyncObserverExceptionHandler {

    @Override
    public void handle(Throwable throwable, ObserverMethod<?> observerMethod, EventContext<?> eventContext) {
        // 异常信息
        Log.info("exception is - " + throwable);
        // 事件信息
        Log.info("observer type is - " + observerMethod.getObservedType().getTypeName());
    }
}
  • 此刻,咱们再执行一次单元测试,如下图所示,异常已经被NoopAsyncObserverExceptionHandler#handler处理,异常和事件相关的信息都能拿到,您可以按照实际的业务需求来进行定制了

  • 另外还要说明一下,自定义的全局异步事件异常处理器,其作用域只能是ApplicationScoped或者Singleton
  • 至此,《quarkus依赖注入》系列全部完成,与bean相关的故事也就此结束了,十三篇文章凝聚了欣宸对quarkus框架bean容器的思考和实践,希望能帮助您更快的掌握和理解quarkus最核心的领域
  • 虽然《quarkus依赖注入》已经终结,但是《quarkus实战》系列依然还在持续更新中,有了依赖注入的知识作为基础,接下来的quarkus之旅会更加轻松和高效

欢迎关注博客园:程序员欣宸

学习路上,你不孤单,欣宸原创一路相伴...

热门相关:流鱼无恙   后福   大妆   今天也没变成玩偶呢   未来兽世:买来的媳妇,不生崽