org.springframework.context.ApplicationEventPublisher Java Examples

public SqsMessageQueueReceiverEndpoint(final @Nonnull String channelName,
                                       final @Nonnull MessageInterceptorRegistry interceptorRegistry,
                                       final @Nonnull SqsAsyncClient sqsAsyncClient,
                                       final @Nonnull ExecutorService executorService,
                                       final @Nullable ApplicationEventPublisher eventPublisher) {
    super(channelName, interceptorRegistry, eventPublisher);
    this.sqsAsyncClient = sqsAsyncClient;
    this.executorService = executorService;
    try {
        this.queueUrl = sqsAsyncClient.getQueueUrl(GetQueueUrlRequest
                .builder()
                .queueName(channelName)
                .overrideConfiguration(AwsRequestOverrideConfiguration.builder()
                        .apiCallAttemptTimeout(ofMillis(2000))
                        .build())
                .build())
                .get()
                .queueUrl();
    } catch (Exception e) {
        stopped.complete(null);
        throw new RuntimeException(e.getMessage(), e);
    }
}
 

public BackupServiceImpl(AttachmentService attachmentService, CategoryService categoryService, CommentBlackListService commentBlackListService, JournalService journalService, JournalCommentService journalCommentService, LinkService linkService, LogService logService, MenuService menuService, OptionService optionService, PhotoService photoService, PostService postService, PostCategoryService postCategoryService, PostCommentService postCommentService, PostMetaService postMetaService, PostTagService postTagService, SheetService sheetService, SheetCommentService sheetCommentService, SheetMetaService sheetMetaService, TagService tagService, ThemeSettingService themeSettingService, UserService userService, OneTimeTokenService oneTimeTokenService, HaloProperties haloProperties, ApplicationEventPublisher eventPublisher) {
    this.attachmentService = attachmentService;
    this.categoryService = categoryService;
    this.commentBlackListService = commentBlackListService;
    this.journalService = journalService;
    this.journalCommentService = journalCommentService;
    this.linkService = linkService;
    this.logService = logService;
    this.menuService = menuService;
    this.optionService = optionService;
    this.photoService = photoService;
    this.postService = postService;
    this.postCategoryService = postCategoryService;
    this.postCommentService = postCommentService;
    this.postMetaService = postMetaService;
    this.postTagService = postTagService;
    this.sheetService = sheetService;
    this.sheetCommentService = sheetCommentService;
    this.sheetMetaService = sheetMetaService;
    this.tagService = tagService;
    this.themeSettingService = themeSettingService;
    this.userService = userService;
    this.oneTimeTokenService = oneTimeTokenService;
    this.haloProperties = haloProperties;
    this.eventPublisher = eventPublisher;
}
 

JobService(final JobRepository jobRepository,
           final JobMetaService jobMetaService,
           final List<JobRunnable> jobRunnables,
           final ScheduledExecutorService executor,
           final ApplicationEventPublisher applicationEventPublisher,
           final Clock clock,
           final SystemInfo systemInfo,
           final UuidProvider uuidProvider) {
    this.jobRepository = jobRepository;
    this.jobMetaService = jobMetaService;
    this.jobRunnables = jobRunnables;
    this.executor = executor;
    this.applicationEventPublisher = applicationEventPublisher;
    this.clock = clock;
    this.systemInfo = systemInfo;
    this.uuidProvider = uuidProvider;
}
 

@Test
public void shouldWriteConfigurationFile() throws IOException {
    new ObjectMapper().writeValue(rewritableJoalFoldersPath.getConfPath().resolve("config.json").toFile(), defaultConfig);
    try {
        final JoalConfigProvider provider = new JoalConfigProvider(new ObjectMapper(), rewritableJoalFoldersPath, Mockito.mock(ApplicationEventPublisher.class));
        final Random rand = new Random();
        final AppConfiguration newConf = new AppConfiguration(
                rand.longs(1, 200).findFirst().getAsLong(),
                rand.longs(201, 400).findFirst().getAsLong(),
                rand.ints(1, 5).findFirst().getAsInt(),
                RandomStringUtils.random(60),
                false
        );

        provider.saveNewConf(newConf);

        assertThat(provider.loadConfiguration()).isEqualTo(newConf);
    } finally {
        Files.deleteIfExists(rewritableJoalFoldersPath.getConfPath().resolve("config.json"));
    }
}
 

@Bean(destroyMethod = "shutdown")
public DefaultDecodedClientMessageHandler defaultDecodedClientMessageHandler(MessageHandler handler,
                                                                             DeviceMessageConnector messageConnector,
                                                                             DeviceSessionManager deviceSessionManager,
                                                                             ApplicationEventPublisher eventPublisher) {
    DefaultDecodedClientMessageHandler clientMessageHandler = new DefaultDecodedClientMessageHandler(handler, deviceSessionManager,
        EmitterProcessor.create(false)
    );
    // TODO: 2019/12/31 应该统一由消息网关处理
    clientMessageHandler
        .subscribe()
        .parallel()
        .runOn(Schedulers.parallel())
        .flatMap(msg -> messageConnector.onMessage(msg).onErrorContinue((err, r) -> log.error(err.getMessage(), err)))
        .subscribe();

    return clientMessageHandler;
}
 

public NamespaceController(
    final NamespaceLockService namespaceLockService,
    final NamespaceService namespaceService,
    final AppNamespaceService appNamespaceService,
    final ApplicationEventPublisher publisher,
    final UserService userService) {
  this.namespaceLockService = namespaceLockService;
  this.namespaceService = namespaceService;
  this.appNamespaceService = appNamespaceService;
  this.publisher = publisher;
  this.userService = userService;
}
 

@Bean( "org.hisp.dhis.pushanalysis.PushAnalysisStore" )
public HibernateIdentifiableObjectStore<PushAnalysis> indicatorTypeStore( SessionFactory sessionFactory,
    JdbcTemplate jdbcTemplate, ApplicationEventPublisher publisher, CurrentUserService currentUserService,
    AclService aclService )
{
    return new HibernateIdentifiableObjectStore<PushAnalysis>( sessionFactory,
        jdbcTemplate, publisher, PushAnalysis.class, currentUserService, aclService, false );
}
 

@SuppressWarnings({"unchecked", "ResultOfMethodCallIgnored"})
@Test
public void shouldRemoveAnnouncerFromRunningListOnTooManyFailsAndEnqueueAnother() {
    final AppConfiguration appConfiguration = this.createMockedConf();
    doReturn(1).when(appConfiguration).getSimultaneousSeed();

    final TorrentFileProvider torrentFileProvider = createMockedTorrentFileProviderWithTorrent(Lists.newArrayList(
            MockedTorrentTest.createOneMock("abc"),
            MockedTorrentTest.createOneMock("def")
    ));

    final DelayQueue<AnnounceRequest> delayQueue = mock(DelayQueue.class);
    final AnnouncerFactory mockedAnnouncerFactory = createMockedAnnouncerFactory();

    final Client client = (Client) ClientBuilder.builder()
            .withAnnouncerFactory(mockedAnnouncerFactory)
            .withBandwidthDispatcher(mock(BandwidthDispatcher.class))
            .withAppConfiguration(appConfiguration)
            .withTorrentFileProvider(torrentFileProvider)
            .withEventPublisher(mock(ApplicationEventPublisher.class))
            .withDelayQueue(delayQueue)
            .build();

    final AnnouncerExecutor announcerExecutor = mock(AnnouncerExecutor.class);
    client.setAnnouncerExecutor(announcerExecutor);
    final ArgumentCaptor<AnnounceRequest> argumentCaptor = ArgumentCaptor.forClass(AnnounceRequest.class);

    client.start();
    verify(delayQueue, times(1)).addOrReplace(argumentCaptor.capture(), anyInt(), any(TemporalUnit.class));
    assertThat(client.getCurrentlySeedingAnnouncer()).hasSize(1);

    final Announcer firstAnnouncer = argumentCaptor.getValue().getAnnouncer();

    client.onTooManyFailedInARaw(firstAnnouncer);
    verify(torrentFileProvider, times(1)).moveToArchiveFolder(eq(firstAnnouncer.getTorrentInfoHash()));
    verify(delayQueue, times(2)).addOrReplace(argumentCaptor.capture(), anyInt(), any(TemporalUnit.class));
    assertThat(argumentCaptor.getValue().getInfoHash()).isNotEqualTo(firstAnnouncer.getTorrentInfoHash());
    assertThat(argumentCaptor.getValue().getInfoHash().value()).isEqualTo("def");
    assertThat(client.getCurrentlySeedingAnnouncer()).hasSize(1);
}
 

private void setupWatchThrowException(ApplicationEventPublisher eventPublisher, String context) {
    ConsulClient consul = mock(ConsulClient.class);
    OperationException operationException = new OperationException(403, null, null);
    when(consul.getKVValues(ArgumentMatchers.eq(context), nullable(String.class),
            ArgumentMatchers.any(QueryParams.class))).thenThrow(operationException);

    LinkedHashMap<String, Long> initialIndexes = new LinkedHashMap<>();
    initialIndexes.put(context, 0L);
    startWatch(eventPublisher, consul, initialIndexes);
}
 

public AssetService(
        DefaultRepository rep,
        PlatformTransactionManager txm,
        AuditHandler audit,
        IdLockHandler idLock,
        ApplicationEventPublisher event) {
    this.rep = rep;
    this.txm = txm;
    this.audit = audit;
    this.idLock = idLock;
    this.event = event;
}
 

@PostConstruct
public void initByLookup() {
    getBean(BeanFactory.class);
    getBean(ApplicationContext.class);
    getBean(ResourceLoader.class);
    getBean(ApplicationEventPublisher.class);
}
 

@Autowired
public RelationLayerSupport(FeatureSupportRegistry aFeatureSupportRegistry,
        ApplicationEventPublisher aEventPublisher,
        LayerBehaviorRegistry aLayerBehaviorsRegistry)
{
    super(aFeatureSupportRegistry);
    eventPublisher = aEventPublisher;
    layerBehaviorsRegistry = aLayerBehaviorsRegistry;
}
 

public SecurityService(JPAQueryFactory jpaQueryFactory,
		PasswordEncoder passwordEncoder, MailService mailService,
		ApplicationEventPublisher applicationEventPublisher) {
	this.jpaQueryFactory = jpaQueryFactory;
	this.passwordEncoder = passwordEncoder;
	this.mailService = mailService;
	this.applicationEventPublisher = applicationEventPublisher;
}
 

public ThemeServiceImpl(HaloProperties haloProperties,
                        OptionService optionService,
                        AbstractStringCacheStore cacheStore,
                        ThemeConfigResolver themeConfigResolver,
                        RestTemplate restTemplate,
                        ApplicationEventPublisher eventPublisher) {
    this.optionService = optionService;
    this.cacheStore = cacheStore;
    this.themeConfigResolver = themeConfigResolver;
    this.restTemplate = restTemplate;

    themeWorkDir = Paths.get(haloProperties.getWorkDir(), THEME_FOLDER);
    this.eventPublisher = eventPublisher;
}
 

@Autowired
public EventSourcingServiceImpl(
        EventStoreRepository eventStore,
        EventSerializer eventSerializer,
        ApplicationEventPublisher eventPublisher
) {
    this.eventStoreRepository = eventStore;
    this.eventSerializer = eventSerializer;
}
 

@Autowired
public AttendanceUploadService(
        AttendanceUploadAdapter attendanceUploadAdapter,
        AttendanceService attendanceService, ApplicationEventPublisher eventPublisher) {
    this.attendanceUploadAdapter = attendanceUploadAdapter;
    this.attendanceService = attendanceService;
    this.eventPublisher = eventPublisher;
}
 

/**
 * Constructs an instance.
 *
 * @param logbackAccessProperties the configuration properties for Logback-access.
 * @param environment the environment.
 * @param applicationEventPublisher the application event publisher.
 */
public LogbackAccessTomcatValve(
        LogbackAccessProperties logbackAccessProperties,
        Environment environment,
        ApplicationEventPublisher applicationEventPublisher
) {
    this.logbackAccessContext = new LogbackAccessContext(
            logbackAccessProperties, environment, applicationEventPublisher);
    setAsyncSupported(true);
    if (logbackAccessProperties.getTomcat().getEnableRequestAttributes() != null) {
        setRequestAttributesEnabled(logbackAccessProperties.getTomcat().getEnableRequestAttributes());
    }
}
 

public HibernateMinMaxDataElementStore( SessionFactory sessionFactory, JdbcTemplate jdbcTemplate,
    ApplicationEventPublisher publisher, QueryParser queryParser, QueryPlanner queryPlanner, SchemaService schemaService )
{
    super( sessionFactory, jdbcTemplate, publisher, MinMaxDataElement.class, false );

    checkNotNull(queryParser);
    checkNotNull(queryPlanner);
    checkNotNull(schemaService);

    this.queryParser = queryParser;
    this.queryPlanner = queryPlanner;
    this.schemaService = schemaService;
}
 

public HibernateDataApprovalAuditStore( SessionFactory sessionFactory, JdbcTemplate jdbcTemplate,
    ApplicationEventPublisher publisher, CurrentUserService currentUserService )
{
    super( sessionFactory, jdbcTemplate, publisher, DataApprovalAudit.class, false );

    checkNotNull( currentUserService );

    this.currentUserService = currentUserService;
}
 

@Autowired
public TkTask(
        TkService tkService,
		ApplicationEventPublisher publisher) {
    this.tkService = tkService;
    this.publisher = publisher;
}
 

@Override
public void init(ServiceProviderBuilder builder) throws Exception {
    authenticationManager = builder.getSharedObject(AuthenticationManager.class);
    config = builder.getSharedObject(SAMLSSOProperties.class);
    endpoints = builder.getSharedObject(ServiceProviderEndpoints.class);
    
    if ( config.isEnableEventPublisher() )
        eventPublisher = builder.getSharedObject(ApplicationEventPublisher.class);
    else eventPublisher = null;
}
 

@SuppressWarnings({"ResultOfMethodCallIgnored", "unchecked"})
@Test
public void shouldClearDelayQueueOnStopAndSendStopAnnounceToExecutor() throws AnnounceException, TooMuchAnnouncesFailedInARawException {
    final AppConfiguration appConfiguration = this.createMockedConf();
    doReturn(1).when(appConfiguration).getSimultaneousSeed();

    final TorrentFileProvider torrentFileProvider = createMockedTorrentFileProviderWithTorrent(Lists.newArrayList(
            MockedTorrentTest.createOneMock("abc")
    ));

    final DelayQueue<AnnounceRequest> delayQueue = mock(DelayQueue.class);
    doReturn(Lists.newArrayList(AnnounceRequest.createRegular(null))).when(delayQueue).drainAll();
    final AnnouncerFactory mockedAnnouncerFactory = mock(AnnouncerFactory.class);

    final Client client = (Client) ClientBuilder.builder()
            .withAnnouncerFactory(mockedAnnouncerFactory)
            .withBandwidthDispatcher(mock(BandwidthDispatcher.class))
            .withAppConfiguration(appConfiguration)
            .withTorrentFileProvider(torrentFileProvider)
            .withEventPublisher(mock(ApplicationEventPublisher.class))
            .withDelayQueue(delayQueue)
            .build();

    final AnnouncerExecutor announcerExecutor = mock(AnnouncerExecutor.class);
    client.setAnnouncerExecutor(announcerExecutor);

    client.start();
    verify(delayQueue, times(1)).addOrReplace(any(AnnounceRequest.class), anyInt(), any(TemporalUnit.class));
    Thread.yield();

    client.stop();
    verify(delayQueue, times(1)).drainAll();
    verify(announcerExecutor, times(1)).execute(argThat(new ArgumentMatcher<AnnounceRequest>() {
        @Override
        public boolean matches(final AnnounceRequest argument) {
            return argument.getEvent() == RequestEvent.STOPPED;
        }
    }));
}
 

public TelemetryServiceImpl(
        @Lazy @Autowired(required = false) List<TelemetrySupport> aTelemetrySupports,
        ApplicationEventPublisher aEventPublisher)
{
    telemetrySupportsProxy = aTelemetrySupports;
    eventPublisher = aEventPublisher;
}
 

public AdminServiceImpl(PostService postService,
                        SheetService sheetService,
                        AttachmentService attachmentService,
                        PostCommentService postCommentService,
                        SheetCommentService sheetCommentService,
                        JournalCommentService journalCommentService,
                        OptionService optionService,
                        UserService userService,
                        LinkService linkService,
                        MailService mailService,
                        AbstractStringCacheStore cacheStore,
                        RestTemplate restTemplate,
                        HaloProperties haloProperties,
                        ApplicationEventPublisher eventPublisher) {
    this.postService = postService;
    this.sheetService = sheetService;
    this.attachmentService = attachmentService;
    this.postCommentService = postCommentService;
    this.sheetCommentService = sheetCommentService;
    this.journalCommentService = journalCommentService;
    this.optionService = optionService;
    this.userService = userService;
    this.linkService = linkService;
    this.mailService = mailService;
    this.cacheStore = cacheStore;
    this.restTemplate = restTemplate;
    this.haloProperties = haloProperties;
    this.eventPublisher = eventPublisher;
}
 

public CloudEurekaClient(ApplicationInfoManager applicationInfoManager,
		EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs<?> args,
		ApplicationEventPublisher publisher) {
	super(applicationInfoManager, config, args);
	this.applicationInfoManager = applicationInfoManager;
	this.publisher = publisher;
	this.eurekaTransportField = ReflectionUtils.findField(DiscoveryClient.class,
			"eurekaTransport");
	ReflectionUtils.makeAccessible(this.eurekaTransportField);
}
 

protected ArangoExtCursor(final InternalArangoDatabase<?, ?> db, final ArangoCursorExecute execute,
	final Class<T> type, final CursorEntity result, final ArangoConverter converter,
	final ApplicationEventPublisher eventPublisher) {
	super(db, execute, type, result);
	final ArangoExtCursorIterator<?> it = (ArangoExtCursorIterator<?>) iterator;
	it.setConverter(converter);
	it.setEventPublisher(eventPublisher);
}
 

public EurekaStatusSubscriber(
    ApplicationEventPublisher publisher, EventBus eventBus, DiscoveryClient discoveryClient) {
  this.publisher = Objects.requireNonNull(publisher, "publisher");
  this.eventBus = Objects.requireNonNull(eventBus, "eventBus");
  publish(
      new StatusChangeEvent(
          InstanceInfo.InstanceStatus.UNKNOWN, discoveryClient.getInstanceRemoteStatus()));
  try {
    eventBus.registerSubscriber(this);
  } catch (InvalidSubscriberException ise) {
    throw new SystemException(ise);
  }
}
 

@Test
public void watchPublishesEvent() {
    ApplicationEventPublisher eventPublisher = mock(ApplicationEventPublisher.class);

    setupWatch(eventPublisher, "/app/");

    verify(eventPublisher, times(1)).publishEvent(ArgumentMatchers.any(RefreshEvent.class));
}
 

@Autowired(required = false)
public AppAuthServiceImpl(final AppAuthMapper appAuthMapper,
                          final ApplicationEventPublisher eventPublisher,
                          final AuthParamMapper authParamMapper,
                          final AuthPathMapper authPathMapper) {
    this.appAuthMapper = appAuthMapper;
    this.eventPublisher = eventPublisher;
    this.authParamMapper = authParamMapper;
    this.authPathMapper = authPathMapper;
}
 

@Autowired
public EventPublishingEntityListenerAdapter(EntityManager eventRepository, ApplicationEventPublisher eventPublisher,
    ObjectMapper objectMapper) {
    this.eventRepository = eventRepository;
    this.eventPublisher = eventPublisher;
    this.objectMapper = objectMapper;
}