How to use

getListener

method

in

org.springframework.batch.core.listener.StepListenerFactoryBean

/**
 * Register explicitly set item listeners and auto-register reader, processor and writer if applicable
 */
private void registerSkipListeners() {
  // auto-register reader, processor and writer
  for (Object itemHandler : new Object[] { getReader(), getWriter(), getProcessor() }) {
    if (StepListenerFactoryBean.isListener(itemHandler)) {
      StepListener listener = StepListenerFactoryBean.getListener(itemHandler);
      if (listener instanceof SkipListener<?, ?>) {
        @SuppressWarnings("unchecked")
        SkipListener<? super I, ? super O> skipListener = (SkipListener<? super I, ? super O>) listener;
        skipListeners.add(skipListener);
      }
    }
  }
}

protected void registerAsStreamsAndListeners(ItemReader<? extends I> itemReader,
    ItemProcessor<? super I, ? extends O> itemProcessor, ItemWriter<? super O> itemWriter) {
  for (Object itemHandler : new Object[] { itemReader, itemWriter, itemProcessor }) {
    if (itemHandler instanceof ItemStream) {
      stream((ItemStream) itemHandler);
    }
    if (StepListenerFactoryBean.isListener(itemHandler)) {
      StepListener listener = StepListenerFactoryBean.getListener(itemHandler);
      if (listener instanceof StepExecutionListener) {
        listener((StepExecutionListener) listener);
      }
      if (listener instanceof ChunkListener) {
        listener((ChunkListener) listener);
      }
      if (listener instanceof ItemReadListener<?> || listener instanceof ItemProcessListener<?, ?>
      || listener instanceof ItemWriteListener<?>) {
        itemListeners.add(listener);
      }
    }
  }
}

@Test
public void testProxiedAnnotationsFactoryMethod() throws Exception {
  Object delegate = new InitializingBean() {
    @BeforeStep
    public void foo(StepExecution execution) {
    }
    @Override
    public void afterPropertiesSet() throws Exception {
    }
  };
  ProxyFactory factory = new ProxyFactory(delegate);
  assertTrue("Listener is not of correct type",
      StepListenerFactoryBean.getListener(factory.getProxy()) instanceof StepExecutionListener);
}

@Test
public void testProxiedAnnotationsIsListener() throws Exception {
  Object delegate = new InitializingBean() {
    @BeforeStep
    public void foo(StepExecution execution) {
    }
    @Override
    public void afterPropertiesSet() throws Exception {
    }
  };
  ProxyFactory factory = new ProxyFactory(delegate);
  Object proxy = factory.getProxy();
  assertTrue(StepListenerFactoryBean.isListener(proxy));
  ((StepExecutionListener) StepListenerFactoryBean.getListener(proxy)).beforeStep(null);
}

@Test
public void testAnnotationsWithOrdered() throws Exception {
  Object delegate = new Ordered() {
    @BeforeStep
    public void foo(StepExecution execution) {
    }
    @Override
    public int getOrder() {
      return 3;
    }
  };
  StepListener listener = StepListenerFactoryBean.getListener(delegate);
  assertTrue("Listener is not of correct type", listener instanceof Ordered);
  assertEquals(3, ((Ordered) listener).getOrder());
}

@Test
public void testFactoryMethod() throws Exception {
  MultipleAfterStep delegate = new MultipleAfterStep();
  Object listener = StepListenerFactoryBean.getListener(delegate);
  assertTrue(listener instanceof StepExecutionListener);
  assertFalse(listener instanceof ChunkListener);
  ((StepExecutionListener) listener).beforeStep(stepExecution);
  assertEquals(1, delegate.callcount);
}

@Test
public void testAfterProcessFails_withAnnotatedListener() {
  StepListener listener = StepListenerFactoryBean.getListener(new AnnotationBasedStepListener());
  multicast.register(listener);
  try {
    multicast.afterProcess(null, null);
    fail("Expected StepListenerFailedException");
  } catch (StepListenerFailedException e) {
    // expected
    Throwable cause = e.getCause();
    String message = cause.getMessage();
    assertTrue(cause instanceof IllegalStateException);
    assertEquals("Wrong message: " + message, "listener error", message);
  }
}

@Test
public void testBeforeChunkFails_withAnnotatedListener() {
  StepListener listener = StepListenerFactoryBean.getListener(new AnnotationBasedStepListener());
  multicast.register(listener);
  try {
    multicast.beforeChunk(null);
    fail("Expected StepListenerFailedException");
  } catch (StepListenerFailedException e) {
    // expected
    Throwable cause = e.getCause();
    String message = cause.getMessage();
    assertTrue(cause instanceof IllegalStateException);
    assertEquals("Wrong message: " + message, "listener error", message);
  }
}

@Test
public void testBeforeProcessFails_withAnnotatedListener() {
  StepListener listener = StepListenerFactoryBean.getListener(new AnnotationBasedStepListener());
  multicast.register(listener);
  try {
    multicast.beforeProcess(null);
    fail("Expected StepListenerFailedException");
  } catch (StepListenerFailedException e) {
    // expected
    Throwable cause = e.getCause();
    String message = cause.getMessage();
    assertTrue(cause instanceof IllegalStateException);
    assertEquals("Wrong message: " + message, "listener error", message);
  }
}

@Test
public void testBeforeWriteFails_withAnnotatedListener() {
  StepListener listener = StepListenerFactoryBean.getListener(new AnnotationBasedStepListener());
  multicast.register(listener);
  try {
    multicast.beforeWrite(null);
    fail("Expected StepListenerFailedException");
  } catch (StepListenerFailedException e) {
    // expected
    Throwable cause = e.getCause();
    String message = cause.getMessage();
    assertTrue(cause instanceof IllegalStateException);
    assertEquals("Wrong message: " + message, "listener error", message);
  }
}

@Test
public void testAfterReadFails_withAnnotatedListener() {
  StepListener listener = StepListenerFactoryBean.getListener(new AnnotationBasedStepListener());
  multicast.register(listener);
  try {
    multicast.afterRead(null);
    fail("Expected StepListenerFailedException");
  } catch (StepListenerFailedException e) {
    // expected
    Throwable cause = e.getCause();
    String message = cause.getMessage();
    assertTrue(cause instanceof IllegalStateException);
    assertEquals("Wrong message: " + message, "listener error", message);
  }
}

@Test
public void testAfterWriteFails_withAnnotatedListener() {
  StepListener listener = StepListenerFactoryBean.getListener(new AnnotationBasedStepListener());
  multicast.register(listener);
  try {
    multicast.afterWrite(null);
    fail("Expected StepListenerFailedException");
  } catch (StepListenerFailedException e) {
    // expected
    Throwable cause = e.getCause();
    String message = cause.getMessage();
    assertTrue(cause instanceof IllegalStateException);
    assertEquals("Wrong message: " + message, "listener error", message);
  }
}

@Test
public void testAfterChunkFails_withAnnotatedListener() {
  StepListener listener = StepListenerFactoryBean.getListener(new AnnotationBasedStepListener());
  multicast.register(listener);
  try {
    multicast.afterChunk(null);
    fail("Expected StepListenerFailedException");
  } catch (StepListenerFailedException e) {
    // expected
    Throwable cause = e.getCause();
    String message = cause.getMessage();
    assertTrue(cause instanceof IllegalStateException);
    assertEquals("Wrong message: " + message, "listener error", message);
  }
}

@Test
public void testBeforeReadFails_withAnnotatedListener() {
  StepListener listener = StepListenerFactoryBean.getListener(new AnnotationBasedStepListener());
  multicast.register(listener);
  try {
    multicast.beforeRead();
    fail("Expected StepListenerFailedException");
  } catch (StepListenerFailedException e) {
    // expected
    Throwable cause = e.getCause();
    String message = cause.getMessage();
    assertTrue(cause instanceof IllegalStateException);
    assertEquals("Wrong message: " + message, "listener error", message);
  }
}

/**
 * Register explicitly set item listeners and auto-register reader, processor and writer if applicable
 */
private void registerSkipListeners() {
  // auto-register reader, processor and writer
  for (Object itemHandler : new Object[] { getReader(), getWriter(), getProcessor() }) {
    if (StepListenerFactoryBean.isListener(itemHandler)) {
      StepListener listener = StepListenerFactoryBean.getListener(itemHandler);
      if (listener instanceof SkipListener<?, ?>) {
        @SuppressWarnings("unchecked")
        SkipListener<? super I, ? super O> skipListener = (SkipListener<? super I, ? super O>) listener;
        skipListeners.add(skipListener);
      }
    }
  }
}

/**
 * Register explicitly set item listeners and auto-register reader, processor and writer if applicable
 */
private void registerSkipListeners() {
  // auto-register reader, processor and writer
  for (Object itemHandler : new Object[] { getReader(), getWriter(), getProcessor() }) {
    if (StepListenerFactoryBean.isListener(itemHandler)) {
      StepListener listener = StepListenerFactoryBean.getListener(itemHandler);
      if (listener instanceof SkipListener<?, ?>) {
        @SuppressWarnings("unchecked")
        SkipListener<? super I, ? super O> skipListener = (SkipListener<? super I, ? super O>) listener;
        skipListeners.add(skipListener);
      }
    }
  }
}

/**
 * Register explicitly set item listeners and auto-register reader, processor and writer if applicable
 */
private void registerSkipListeners() {
  // auto-register reader, processor and writer
  for (Object itemHandler : new Object[] { getReader(), getWriter(), getProcessor() }) {
    if (StepListenerFactoryBean.isListener(itemHandler)) {
      StepListener listener = StepListenerFactoryBean.getListener(itemHandler);
      if (listener instanceof SkipListener<?, ?>) {
        @SuppressWarnings("unchecked")
        SkipListener<? super I, ? super O> skipListener = (SkipListener<? super I, ? super O>) listener;
        skipListeners.add(skipListener);
      }
    }
  }
}

protected void registerAsStreamsAndListeners(ItemReader<? extends I> itemReader,
    ItemProcessor<? super I, ? extends O> itemProcessor, ItemWriter<? super O> itemWriter) {
  for (Object itemHandler : new Object[] { itemReader, itemWriter, itemProcessor }) {
    if (itemHandler instanceof ItemStream) {
      stream((ItemStream) itemHandler);
    }
    if (StepListenerFactoryBean.isListener(itemHandler)) {
      StepListener listener = StepListenerFactoryBean.getListener(itemHandler);
      if (listener instanceof StepExecutionListener) {
        listener((StepExecutionListener) listener);
      }
      if (listener instanceof ChunkListener) {
        listener((ChunkListener) listener);
      }
      if (listener instanceof ItemReadListener<?> || listener instanceof ItemProcessListener<?, ?>
      || listener instanceof ItemWriteListener<?>) {
        itemListeners.add(listener);
      }
    }
  }
}

protected void registerAsStreamsAndListeners(ItemReader<? extends I> itemReader,
    ItemProcessor<? super I, ? extends O> itemProcessor, ItemWriter<? super O> itemWriter) {
  for (Object itemHandler : new Object[] { itemReader, itemWriter, itemProcessor }) {
    if (itemHandler instanceof ItemStream) {
      stream((ItemStream) itemHandler);
    }
    if (StepListenerFactoryBean.isListener(itemHandler)) {
      StepListener listener = StepListenerFactoryBean.getListener(itemHandler);
      if (listener instanceof StepExecutionListener) {
        listener((StepExecutionListener) listener);
      }
      if (listener instanceof ChunkListener) {
        listener((ChunkListener) listener);
      }
      if (listener instanceof ItemReadListener<?> || listener instanceof ItemProcessListener<?, ?>
      || listener instanceof ItemWriteListener<?>) {
        itemListeners.add(listener);
      }
    }
  }
}

/**
 * Register listeners with step and chunk.
 */
private void registerStepListeners(TaskletStep step, RepeatOperations chunkOperations) {
  for (Object itemHandler : new Object[] { getItemReader(), itemWriter, itemProcessor }) {
    if (StepListenerFactoryBean.isListener(itemHandler)) {
      StepListener listener = StepListenerFactoryBean.getListener(itemHandler);
      if (listener instanceof StepExecutionListener) {
        step.registerStepExecutionListener((StepExecutionListener) listener);
      }
      if (listener instanceof ChunkListener) {
        step.registerChunkListener((ChunkListener) listener);
      }
    }
  }
  step.setStepExecutionListeners(BatchListenerFactoryHelper.getListeners(listeners, StepExecutionListener.class)
      .toArray(new StepExecutionListener[] {}));
  step.setChunkListeners(BatchListenerFactoryHelper.getListeners(listeners, ChunkListener.class).toArray(
      new ChunkListener[] {}));
}