How to use

StepListenerFactoryBean

in

org.springframework.batch.core.listener

/**
 * Convenience method to wrap any object and expose the appropriate
 * {@link StepListener} interfaces.
 *
 * @param delegate a delegate object
 * @return a StepListener instance constructed from the delegate
 */
public static StepListener getListener(Object delegate) {
  StepListenerFactoryBean factory = new StepListenerFactoryBean();
  factory.setDelegate(delegate);
  return (StepListener) factory.getObject();
}

/**
 * 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);
      }
    }
  }
}

@Test(expected = IllegalArgumentException.class)
public void testWrongSignatureNamedMethod() {
  AbstractTestComponent delegate = new AbstractTestComponent() {
    @SuppressWarnings("unused")
    public void aMethod(Integer item) {
      executed = true;
    }
  };
  factoryBean.setDelegate(delegate);
  Map<String, String> metaDataMap = new HashMap<>();
  metaDataMap.put(AFTER_WRITE.getPropertyName(), "aMethod");
  factoryBean.setMetaDataMap(metaDataMap);
  factoryBean.getObject();
}

@Test(expected = IllegalArgumentException.class)
public void testWrongSignatureAnnotation() {
  AbstractTestComponent delegate = new AbstractTestComponent() {
    @AfterWrite
    public void aMethod(Integer item) {
      executed = true;
    }
  };
  factoryBean.setDelegate(delegate);
  factoryBean.getObject();
}

@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 testAnnotationsIsListener() throws Exception {
  assertTrue(StepListenerFactoryBean.isListener(new Object() {
    @BeforeStep
    public void foo(StepExecution execution) {
    }
  }));
}

@Before
public void setUp() {
  factoryBean = new StepListenerFactoryBean();
}

@Test
public void testNonListener() throws Exception {
  Object delegate = new Object();
  factoryBean.setDelegate(delegate);
  assertTrue(factoryBean.getObject() instanceof StepListener);
}

@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 testInterfaceIsListener() throws Exception {
  assertTrue(StepListenerFactoryBean.isListener(new ThreeStepExecutionListener()));
}

/**
 * Registers objects using the annotation based listener configuration.
 *
 * @param listener the object that has a method configured with listener annotation
 * @return this for fluent chaining
 */
public B listener(Object listener) {
  Set<Method> stepExecutionListenerMethods = new HashSet<>();
  stepExecutionListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), BeforeStep.class));
  stepExecutionListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), AfterStep.class));
  if(stepExecutionListenerMethods.size() > 0) {
    StepListenerFactoryBean factory = new StepListenerFactoryBean();
    factory.setDelegate(listener);
    properties.addStepExecutionListener((StepExecutionListener) factory.getObject());
  }
  @SuppressWarnings("unchecked")
  B result = (B) this;
  return result;
}

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 testEmptySignatureAnnotation() {
  AbstractTestComponent delegate = new AbstractTestComponent() {
    @AfterWrite
    public void aMethod() {
      executed = true;
    }
  };
  factoryBean.setDelegate(delegate);
  @SuppressWarnings("unchecked")
  ItemWriteListener<String> listener = (ItemWriteListener<String>) factoryBean.getObject();
  listener.afterWrite(Arrays.asList("foo", "bar"));
  assertTrue(delegate.isExecuted());
}

@Test
public void testAnnotatingInterfaceResultsInOneCall() throws Exception {
  MultipleAfterStep delegate = new MultipleAfterStep();
  factoryBean.setDelegate(delegate);
  Map<String, String> metaDataMap = new HashMap<>();
  metaDataMap.put(AFTER_STEP.getPropertyName(), "afterStep");
  factoryBean.setMetaDataMap(metaDataMap);
  StepListener listener = (StepListener) factoryBean.getObject();
  ((StepExecutionListener) listener).afterStep(stepExecution);
  assertEquals(1, delegate.callcount);
}

@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 testMixedIsListener() throws Exception {
  assertTrue(StepListenerFactoryBean.isListener(new MultipleAfterStep()));
}

/**
 * Registers objects using the annotation based listener configuration.
 *
 * @param listener the object that has a method configured with listener annotation
 * @return this for fluent chaining
 */
@Override
@SuppressWarnings("unchecked")
public SimpleStepBuilder<I, O> listener(Object listener) {
  super.listener(listener);
  Set<Method> skipListenerMethods = new HashSet<>();
  skipListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), OnSkipInRead.class));
  skipListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), OnSkipInProcess.class));
  skipListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), OnSkipInWrite.class));
  if(skipListenerMethods.size() > 0) {
    StepListenerFactoryBean factory = new StepListenerFactoryBean();
    factory.setDelegate(listener);
    skipListeners.add((SkipListener) factory.getObject());
  }
  @SuppressWarnings("unchecked")
  SimpleStepBuilder<I, O> result = this;
  return result;
}

@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 testRightSignatureAnnotation() {
  AbstractTestComponent delegate = new AbstractTestComponent() {
    @AfterWrite
    public void aMethod(List<String> items) {
      executed = true;
      assertEquals("foo", items.get(0));
      assertEquals("bar", items.get(1));
    }
  };
  factoryBean.setDelegate(delegate);
  @SuppressWarnings("unchecked")
  ItemWriteListener<String> listener = (ItemWriteListener<String>) factoryBean.getObject();
  listener.afterWrite(Arrays.asList("foo", "bar"));
  assertTrue(delegate.isExecuted());
}

@Test
public void testAllThreeTypes() throws Exception {
  // Test to make sure if someone has annotated a method, implemented the
  // interface, and given a string
  // method name, that all three will be called
  ThreeStepExecutionListener delegate = new ThreeStepExecutionListener();
  factoryBean.setDelegate(delegate);
  Map<String, String> metaDataMap = new HashMap<>();
  metaDataMap.put(AFTER_STEP.getPropertyName(), "destroy");
  factoryBean.setMetaDataMap(metaDataMap);
  StepListener listener = (StepListener) factoryBean.getObject();
  ((StepExecutionListener) listener).afterStep(stepExecution);
  assertEquals(3, delegate.callcount);
}