io.micronaut.context.event.BeanCreatedEvent Java Examples

@Override
public FlywayConfigurationProperties onCreated(BeanCreatedEvent<FlywayConfigurationProperties> event) {
    FlywayConfigurationProperties config = event.getBean();
    String name = config.getNameQualifier();

    if (config.isEnabled()) {
        if (config.hasAlternativeDatabaseConfiguration()) {
            DataSource dataSource = new DriverDataSource(Thread.currentThread().getContextClassLoader(), null, config.getUrl(), config.getUser(), config.getPassword());
            run(config, dataSource);
        } else {
            if (!applicationContext.containsBean(DataSource.class, Qualifiers.byName(name))) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("* Flyway bean not created for identifier [" + name + "] because no data source was found with a named qualifier of the same name.");
                }
            }
        }
    }

    return config;
}
 

@Override
public DataSource onCreated(BeanCreatedEvent<DataSource> event) {
    DataSource dataSource = dataSourceResolver.resolve(event.getBean());

    if (event.getBeanDefinition() instanceof NameResolver) {
        ((NameResolver) event.getBeanDefinition())
                .resolveName()
                .ifPresent(name -> {
                    applicationContext
                            .findBean(FlywayConfigurationProperties.class, Qualifiers.byName(name))
                            .ifPresent(flywayConfig -> run(flywayConfig, dataSource));
                });
    }

    return dataSource;
}
 

@Override
public EntityManagerFactory onCreated(BeanCreatedEvent<EntityManagerFactory> event) {
    EntityManagerFactory entityManagerFactory = event.getBean();
    String sessionFactoryName = event.getBeanIdentifier().getName();
    MeterRegistry meterRegistry = meterRegistryProvider.get();
    if (entityManagerFactory instanceof SessionFactory) {

        HibernateMetrics.monitor(
                meterRegistry,
                (SessionFactory) entityManagerFactory,
                sessionFactoryName,
                tags
        );
    }

    return entityManagerFactory;
}
 

@Override
public JpaConfiguration onCreated(BeanCreatedEvent<JpaConfiguration> event) {
    JpaConfiguration jpaConfiguration = event.getBean();
    Map<String, Object> jpaProperties = jpaConfiguration.getProperties();
    jpaProperties.put(ConfigSettings.CACHE_MANAGER, cacheManager);
    return jpaConfiguration;
}
 

@Override
public JpaConfiguration onCreated(BeanCreatedEvent<JpaConfiguration> event) {
    JpaConfiguration jpaConfiguration = event.getBean();
    jpaConfiguration.getProperties().putIfAbsent(
            AvailableSettings.PHYSICAL_NAMING_STRATEGY, physicalNamingStrategy
    );
    return jpaConfiguration;
}
 

@Override
public DataSource onCreated(BeanCreatedEvent<DataSource> event) {
    final BeanIdentifier beanIdentifier = event.getBeanIdentifier();
    String name = beanIdentifier.getName();
    if (name.equalsIgnoreCase("primary")) {
        name = "default";
    }
    this.qualifier = name;
    return new DataSourceProxy(event.getBean());
}
 

@Override
public HibernateDatastore onCreated(BeanCreatedEvent<HibernateDatastore> event) {
    HibernateDatastore hibernateDatastore = event.getBean();

    hibernateDatastore.getConnectionSources().forEach(connectionSource -> {
        String qualifier = connectionSource.getName();
        DataSource dataSource = ((HibernateConnectionSource) connectionSource).getDataSource();

        applicationContext
                .findBean(FlywayConfigurationProperties.class, Qualifiers.byName(qualifier))
                .ifPresent(flywayConfig -> run(flywayConfig, dataSource));
    });

    return hibernateDatastore;
}
 

@Override
public ObjectMapper onCreated(BeanCreatedEvent<ObjectMapper> event) {
    final ObjectMapper mapper = event.getBean();
    mapper.registerModule(new JavaTimeModule());
    mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    return mapper;
}
 

/**
 * Method to add a default metric reporter if not otherwise defined.
 *
 * @param event                         The event for bean created of type AbstractKafkaConfiguration
 * @param kafkaMetricsReporterClassName The class name to use for kafka metrics registration
 * @return The bean
 */
T addKafkaMetrics(BeanCreatedEvent<T> event, String kafkaMetricsReporterClassName) {
    Properties props = event.getBean().getConfig();
    if (!props.containsKey(CommonClientConfigs.METRIC_REPORTER_CLASSES_CONFIG)) {
        props.put(CommonClientConfigs.METRIC_REPORTER_CLASSES_CONFIG, kafkaMetricsReporterClassName);
        if (LOG.isDebugEnabled()) {
            LOG.debug(String.format("Adding kafka property:value of %s:%s", ProducerConfig.METRIC_REPORTER_CLASSES_CONFIG, kafkaMetricsReporterClassName));
        }
    }
    return event.getBean();
}
 

@Override
public DataSource onCreated(BeanCreatedEvent<DataSource> event) {
    DataSource dataSource = event.getBean();
    if (dataSource instanceof TransactionAwareDataSourceProxy) {
        return dataSource;
    } else {
        return new TransactionAwareDataSourceProxy(dataSource);
    }
}
 

@Override
public JacksonConfiguration onCreated(BeanCreatedEvent<JacksonConfiguration> event) {
    JacksonConfiguration jacksonConfiguration = event.getBean();
    jacksonConfiguration.setModuleScan(false);
    jacksonConfiguration.setBeanIntrospectionModule(true);
    return jacksonConfiguration;
}
 

@Override
public S3ClientBuilder onCreated(BeanCreatedEvent<S3ClientBuilder> event) {
    S3ClientBuilder builder = event.getBean();
    builder.overrideConfiguration(ClientOverrideConfiguration.builder().retryPolicy(RetryMode.LEGACY).build());

    return builder;
}
 

@Override
public ObjectMapper onCreated(BeanCreatedEvent<ObjectMapper> event) {
    ObjectMapper objectMapper = event.getBean();
    // register modules manually
    objectMapper.registerModule(new JavaTimeModule());
    objectMapper.registerModule(new Jdk8Module());
    return objectMapper;
}
 

@Override
public Object onCreated(BeanCreatedEvent<Object> event) {
    final Object bean = event.getBean();
    return onBeanCreated(bean);
}
 

@Override
public ServerBuilder<?> onCreated(BeanCreatedEvent<ServerBuilder<?>> event) {
    final ServerBuilder<?> builder = event.getBean();
    builder.maxInboundMessageSize(1024);
    return builder;
}
 

@Override
public ManagedChannelBuilder<?> onCreated(BeanCreatedEvent<ManagedChannelBuilder<?>> event) {
    final ManagedChannelBuilder<?> channelBuilder = event.getBean();
    channelBuilder.maxInboundMessageSize(1024);
    return channelBuilder;
}
 

@Override
public ServerBuilder<?> onCreated(BeanCreatedEvent<ServerBuilder<?>> event) {
    final ServerBuilder<?> builder = event.getBean();
    builder.maxInboundMessageSize(1024);
    return builder;
}
 

@Override
public ManagedChannelBuilder<?> onCreated(BeanCreatedEvent<ManagedChannelBuilder<?>> event) {
    final ManagedChannelBuilder<?> channelBuilder = event.getBean();
    channelBuilder.maxInboundMessageSize(1024);
    return channelBuilder;
}
 

@Override
public Consumer<?, ?> onCreated(BeanCreatedEvent<Consumer<?, ?>> event) {
    return kafkaTracing.consumer(event.getBean());
}
 

@Override
public Producer<?, ?> onCreated(BeanCreatedEvent<Producer<?, ?>> event) {
    return kafkaTracing.producer(event.getBean());
}
 

@Override
public Consumer<?, ?> onCreated(BeanCreatedEvent<Consumer<?, ?>> event) {
    final Consumer<?, ?> consumer = event.getBean();
    return new TracingKafkaConsumer<>(consumer, tracerProvider.get());
}
 

@Override
public Producer<?, ?> onCreated(BeanCreatedEvent<Producer<?, ?>> event) {
    final Producer<?, ?> kafkaProducer = event.getBean();
    return new TracingKafkaProducer<>(kafkaProducer, tracerProvider.get());
}
 

@Override
public AbstractKafkaProducerConfiguration onCreated(BeanCreatedEvent<AbstractKafkaProducerConfiguration> event) {
    beanLocator.findBean(MeterRegistry.class).ifPresent(METER_REGISTRIES::add);
    return addKafkaMetrics(event, ProducerKafkaMetricsReporter.class.getName());
}
 

@Override
public AbstractKafkaConsumerConfiguration onCreated(BeanCreatedEvent<AbstractKafkaConsumerConfiguration> event) {
    beanLocator.findBean(MeterRegistry.class).ifPresent(METER_REGISTRIES::add);
    return addKafkaMetrics(event, ConsumerKafkaMetricsReporter.class.getName());
}
 

@Override
public ManagedChannelBuilder<?> onCreated(BeanCreatedEvent<ManagedChannelBuilder<?>> event) {
    final ManagedChannelBuilder<?> channelBuilder = event.getBean();
    channelBuilder.maxInboundMessageSize(1024);
    return channelBuilder;
}
 

@Override
public ServerBuilder<?> onCreated(BeanCreatedEvent<ServerBuilder<?>> event) {
    final ServerBuilder<?> builder = event.getBean();
    builder.maxInboundMessageSize(1024);
    return builder;
}
 

@Override
public ManagedChannelBuilder<?> onCreated(BeanCreatedEvent<ManagedChannelBuilder<?>> event) {
    final ManagedChannelBuilder<?> channelBuilder = event.getBean();
    channelBuilder.maxInboundMessageSize(1024);
    return channelBuilder;
}
 

@Override
public ServerBuilder<?> onCreated(BeanCreatedEvent<ServerBuilder<?>> event) {
    final ServerBuilder<?> builder = event.getBean();
    builder.maxInboundMessageSize(1024);
    return builder;
}