Example usage for org.springframework.util ReflectionUtils getField

Introduction

In this page you can find the example usage for org.springframework.util ReflectionUtils getField.

Prototype

@Nullable
public static Object getField(Field field, @Nullable Object target)

Source Link

Document

Get the field represented by the supplied Field field object on the specified Object target object .

Usage

From source file:io.pivotal.poc.gateway.filters.AbstractFilter.java

protected StandardMultipartHttpServletRequest extractMultipartRequest(HttpServletRequest request) {
    while (request != null) {
        log.info("request class: {}", request.getClass());
        if (StandardMultipartHttpServletRequest.class.isAssignableFrom(request.getClass())) {
            return (StandardMultipartHttpServletRequest) request;
        }/*from   w  ww. j  a va2s. co m*/
        try {
            request = (HttpServletRequest) ReflectionUtils.getField(requestField, request);
        } catch (Exception e) {
            break;
        }
    }
    return null;
}

From source file:com.ciphertool.sentencebuilder.dao.FrequencyWordListDaoTest.java

@Test
@SuppressWarnings("unchecked")
public void testConstructor() {
    WordDao wordDaoMock = mock(WordDao.class);
    when(wordDaoMock.findAllUniqueWords()).thenReturn(wordsToReturn);

    FrequencyWordListDao frequencyWordListDao = new FrequencyWordListDao(wordDaoMock);

    Field wordListField = ReflectionUtils.findField(FrequencyWordListDao.class, "wordList");
    ReflectionUtils.makeAccessible(wordListField);
    List<Word> wordListFromObject = (List<Word>) ReflectionUtils.getField(wordListField, frequencyWordListDao);

    assertEquals(7, wordListFromObject.size());
    assertTrue(wordListFromObject.containsAll(wordsToReturn));
    assertTrue(wordsToReturn.containsAll(wordListFromObject));
    assertEquals(5, countOccurrences(word1, wordListFromObject));
    assertEquals(1, countOccurrences(word2, wordListFromObject));
    assertEquals(1, countOccurrences(word3, wordListFromObject));
    verify(wordDaoMock, times(1)).findAllUniqueWords();
}

From source file:com.ciphertool.genetics.dao.ExecutionStatisticsDaoTest.java

@Test
public void testSetSessionFactory() {
    ExecutionStatisticsDao executionStatisticsDao = new ExecutionStatisticsDao();
    executionStatisticsDao.setSessionFactory(sessionFactoryMock);

    Field sessionFactoryField = ReflectionUtils.findField(ExecutionStatisticsDao.class, "sessionFactory");
    ReflectionUtils.makeAccessible(sessionFactoryField);
    SessionFactory sessionFactoryFromObject = (SessionFactory) ReflectionUtils.getField(sessionFactoryField,
            executionStatisticsDao);/* w w w.j  av  a 2 s. com*/

    assertSame(sessionFactoryMock, sessionFactoryFromObject);
}

From source file:com.ciphertool.zodiacengine.dao.ForcedWordGeneDaoTest.java

@Test
public void testSetWordListDao() {
    ForcedWordGeneDao forcedWordGeneDao = new ForcedWordGeneDao();
    forcedWordGeneDao.setWordListDao(wordListDaoMock);

    Field wordListDaoField = ReflectionUtils.findField(ForcedWordGeneDao.class, "wordListDao");
    ReflectionUtils.makeAccessible(wordListDaoField);
    WordListDao wordListDaoFromObject = (WordListDao) ReflectionUtils.getField(wordListDaoField,
            forcedWordGeneDao);//  w w w .j av a  2s  .  c  o  m

    assertSame(wordListDaoMock, wordListDaoFromObject);
}

From source file:com.ciphertool.genetics.algorithms.crossover.ConservativeUnevaluatedCrossoverAlgorithmTest.java

@SuppressWarnings({ "rawtypes", "unchecked" })
@Test//from w  w w  . ja v  a 2s.  c  o  m
public void testSetMutationAlgorithm() {
    MutationAlgorithm mutationAlgorithmToSet = mock(MutationAlgorithm.class);

    ConservativeUnevaluatedCrossoverAlgorithm conservativeUnevaluatedCrossoverAlgorithm = new ConservativeUnevaluatedCrossoverAlgorithm();
    conservativeUnevaluatedCrossoverAlgorithm.setMutationAlgorithm(mutationAlgorithmToSet);

    Field mutationAlgorithmField = ReflectionUtils.findField(ConservativeUnevaluatedCrossoverAlgorithm.class,
            "mutationAlgorithm");
    ReflectionUtils.makeAccessible(mutationAlgorithmField);
    MutationAlgorithm mutationAlgorithmFromObject = (MutationAlgorithm) ReflectionUtils
            .getField(mutationAlgorithmField, conservativeUnevaluatedCrossoverAlgorithm);

    assertSame(mutationAlgorithmToSet, mutationAlgorithmFromObject);
}

From source file:org.jdal.annotation.AnnotatedElementAccessor.java

public static Object getValue(AnnotatedElement element, Object target) {
    if (element instanceof Field) {
        ReflectionUtils.makeAccessible((Field) element);
        return ReflectionUtils.getField((Field) element, target);
    } else if (element instanceof Method) {
        Method method = (Method) element;
        String name = method.getName();

        if (name.startsWith("set")) {
            return PropertyAccessorFactory.forBeanPropertyAccess(target)
                    .getPropertyValue(getPropertyName(name));
        }//w ww.j a  v  a  2 s  .co m
    }

    return null;
}

From source file:com.ciphertool.genetics.algorithms.crossover.LowestCommonGroupUnevaluatedCrossoverAlgorithmTest.java

@Test
public void testSetCoin() {
    Coin coinToSet = mock(Coin.class);
    LowestCommonGroupUnevaluatedCrossoverAlgorithm lowestCommonGroupUnevaluatedCrossoverAlgorithm = new LowestCommonGroupUnevaluatedCrossoverAlgorithm();
    lowestCommonGroupUnevaluatedCrossoverAlgorithm.setCoin(coinToSet);

    Field coinField = ReflectionUtils.findField(LowestCommonGroupUnevaluatedCrossoverAlgorithm.class, "coin");
    ReflectionUtils.makeAccessible(coinField);
    Coin coinFromObject = (Coin) ReflectionUtils.getField(coinField,
            lowestCommonGroupUnevaluatedCrossoverAlgorithm);

    assertSame(coinToSet, coinFromObject);
}

From source file:com.ryantenney.metrics.spring.GaugeAnnotationBeanPostProcessor.java

@Override
public Object postProcessAfterInitialization(final Object bean, String beanName) {
    final Class<?> targetClass = AopUtils.getTargetClass(bean);

    ReflectionUtils.doWithFields(targetClass, new FieldCallback() {
        @Override/*from w ww  .j ava  2  s . c o  m*/
        public void doWith(final Field field) throws IllegalAccessException {
            ReflectionUtils.makeAccessible(field);

            final Gauge annotation = field.getAnnotation(Gauge.class);
            final String metricName = Util.forGauge(targetClass, field, annotation);

            metrics.register(metricName, new com.codahale.metrics.Gauge<Object>() {
                @Override
                public Object getValue() {
                    Object value = ReflectionUtils.getField(field, bean);
                    if (value instanceof com.codahale.metrics.Gauge) {
                        value = ((com.codahale.metrics.Gauge<?>) value).getValue();
                    }
                    return value;
                }
            });

            LOG.debug("Created gauge {} for field {}.{}", metricName, targetClass.getCanonicalName(),
                    field.getName());
        }
    }, FILTER);

    ReflectionUtils.doWithMethods(targetClass, new MethodCallback() {
        @Override
        public void doWith(final Method method) throws IllegalAccessException {
            if (method.getParameterTypes().length > 0) {
                throw new IllegalStateException(
                        "Method " + method.getName() + " is annotated with @Gauge but requires parameters.");
            }

            final Gauge annotation = method.getAnnotation(Gauge.class);
            final String metricName = Util.forGauge(targetClass, method, annotation);

            metrics.register(metricName, new com.codahale.metrics.Gauge<Object>() {
                @Override
                public Object getValue() {
                    return ReflectionUtils.invokeMethod(method, bean);
                }
            });

            LOG.debug("Created gauge {} for method {}.{}", metricName, targetClass.getCanonicalName(),
                    method.getName());
        }
    }, FILTER);

    return bean;
}

From source file:com.ciphertool.genetics.algorithms.selection.modes.TournamentSelectorTest.java

@Test
public void testSetSelectionAccuracy() {
    Double selectionAccuracyToSet = 0.9;

    TournamentSelector tournamentSelector = new TournamentSelector();
    tournamentSelector.setSelectionAccuracy(selectionAccuracyToSet);

    Field selectionAccuracyField = ReflectionUtils.findField(TournamentSelector.class, "selectionAccuracy");
    ReflectionUtils.makeAccessible(selectionAccuracyField);

    assertEquals(selectionAccuracyToSet, ReflectionUtils.getField(selectionAccuracyField, tournamentSelector));
}

From source file:com.ciphertool.genetics.util.KeylessChromosomeHelperTest.java

@Test
public void testSetGeneDao() {
    KeylessChromosomeHelper keylessChromosomeHelper = new KeylessChromosomeHelper();
    keylessChromosomeHelper.setGeneDao(geneDaoMock);

    Field geneDaoField = ReflectionUtils.findField(KeylessChromosomeHelper.class, "geneDao");
    ReflectionUtils.makeAccessible(geneDaoField);
    GeneDao geneDaoFromObject = (GeneDao) ReflectionUtils.getField(geneDaoField, keylessChromosomeHelper);

    assertSame(geneDaoMock, geneDaoFromObject);
}