How to use

getObject

method

in

org.springframework.batch.core.listener.StepListenerFactoryBean

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

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

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

/**
 * 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
 */
@SuppressWarnings("unchecked")
@Override
public SimpleStepBuilder<I, O> listener(Object listener) {
  super.listener(listener);
  Set<Method> itemListenerMethods = new HashSet<>();
  itemListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), BeforeRead.class));
  itemListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), AfterRead.class));
  itemListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), BeforeProcess.class));
  itemListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), AfterProcess.class));
  itemListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), BeforeWrite.class));
  itemListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), AfterWrite.class));
  itemListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), OnReadError.class));
  itemListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), OnProcessError.class));
  itemListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), OnWriteError.class));
  if(itemListenerMethods.size() > 0) {
    StepListenerFactoryBean factory = new StepListenerFactoryBean();
    factory.setDelegate(listener);
    itemListeners.add((StepListener) factory.getObject());
  }
  @SuppressWarnings("unchecked")
  SimpleStepBuilder<I, O> result = this;
  return result;
}

/**
 * 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
public B listener(Object listener) {
  super.listener(listener);
  Set<Method> chunkListenerMethods = new HashSet<>();
  chunkListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), BeforeChunk.class));
  chunkListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), AfterChunk.class));
  chunkListenerMethods.addAll(ReflectionUtils.findMethod(listener.getClass(), AfterChunkError.class));
  if(chunkListenerMethods.size() > 0) {
    StepListenerFactoryBean factory = new StepListenerFactoryBean();
    factory.setDelegate(listener);
    this.listener((ChunkListener) factory.getObject());
  }
  @SuppressWarnings("unchecked")
  B result = (B) this;
  return result;
}

@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 testNonListener() throws Exception {
  Object delegate = new Object();
  factoryBean.setDelegate(delegate);
  assertTrue(factoryBean.getObject() instanceof StepListener);
}

@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
public void testEmptySignatureNamedMethod() {
  AbstractTestComponent delegate = new AbstractTestComponent() {
    @SuppressWarnings("unused")
    public void aMethod() {
      executed = true;
    }
  };
  factoryBean.setDelegate(delegate);
  Map<String, String> metaDataMap = new HashMap<>();
  metaDataMap.put(AFTER_WRITE.getPropertyName(), "aMethod");
  factoryBean.setMetaDataMap(metaDataMap);
  @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 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);
}

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

@Test
public void testVanillaInterfaceWithProxy() throws Exception {
  MultipleAfterStep delegate = new MultipleAfterStep();
  ProxyFactory factory = new ProxyFactory(delegate);
  factoryBean.setDelegate(factory.getProxy());
  Object listener = factoryBean.getObject();
  assertTrue(listener instanceof StepExecutionListener);
  ((StepExecutionListener) listener).beforeStep(stepExecution);
  assertEquals(1, delegate.callcount);
}

@Test
public void testVanillaInterface() throws Exception {
  MultipleAfterStep delegate = new MultipleAfterStep();
  factoryBean.setDelegate(delegate);
  Object listener = factoryBean.getObject();
  assertTrue(listener instanceof StepExecutionListener);
  ((StepExecutionListener) listener).beforeStep(stepExecution);
  assertEquals(1, delegate.callcount);
}

Integer writeItem = 2;
List<Integer> writeItems = Arrays.asList(writeItem);
StepListener listener = (StepListener) factoryBean.getObject();
((StepExecutionListener) listener).beforeStep(stepExecution);
((StepExecutionListener) listener).afterStep(stepExecution);

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

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

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