Example usage for org.springframework.util ReflectionUtils makeAccessible

List of usage examples for org.springframework.util ReflectionUtils makeAccessible

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.util.*
  5. ReflectionUtils
  6. makeAccessible

Introduction

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

Prototype

@SuppressWarnings("deprecation") 
public static void makeAccessible(Field field)

Source Link

Document

Make the given field accessible, explicitly setting it accessible if necessary.

Usage

From source file:com.ciphertool.genetics.algorithms.MultigenerationalGeneticAlgorithmTest.java

@Test
public void testDeterminePairsToCrossover() {
    int initialPopulationSize = 100;

    Population populationMock = mock(Population.class);
    when(populationMock.size()).thenReturn(initialPopulationSize);

    MultigenerationalGeneticAlgorithm multigenerationalGeneticAlgorithm = new MultigenerationalGeneticAlgorithm();
    multigenerationalGeneticAlgorithm.setPopulation(populationMock);

    GeneticAlgorithmStrategy strategyToSet = new GeneticAlgorithmStrategy();
    double crossoverRate = 0.5;
    strategyToSet.setCrossoverRate(crossoverRate);

    Field strategyField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class, "strategy");
    ReflectionUtils.makeAccessible(strategyField);
    ReflectionUtils.setField(strategyField, multigenerationalGeneticAlgorithm, strategyToSet);

    long pairsToCrossover = multigenerationalGeneticAlgorithm.determinePairsToCrossover(initialPopulationSize);

    assertEquals(50, pairsToCrossover);//from   w  w  w .  j a va 2 s.c o m
}

From source file:com.ciphertool.genetics.algorithms.MultigenerationalGeneticAlgorithmTest.java

@Test
public void testDeterminePairsToCrossover_SmallPopulation() {
    int initialPopulationSize = 100;
    int actualPopulationSize = 50;

    Population populationMock = mock(Population.class);
    when(populationMock.size()).thenReturn(actualPopulationSize);

    MultigenerationalGeneticAlgorithm multigenerationalGeneticAlgorithm = new MultigenerationalGeneticAlgorithm();
    multigenerationalGeneticAlgorithm.setPopulation(populationMock);

    GeneticAlgorithmStrategy strategyToSet = new GeneticAlgorithmStrategy();
    double crossoverRate = 0.5;
    strategyToSet.setCrossoverRate(crossoverRate);

    Field strategyField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class, "strategy");
    ReflectionUtils.makeAccessible(strategyField);
    ReflectionUtils.setField(strategyField, multigenerationalGeneticAlgorithm, strategyToSet);

    long pairsToCrossover = multigenerationalGeneticAlgorithm.determinePairsToCrossover(initialPopulationSize);

    assertEquals(25, pairsToCrossover);//from   w  w  w . j  av  a2 s. c  om
}

From source file:com.ciphertool.genetics.algorithms.MultigenerationalGeneticAlgorithmTest.java

@Test
public void testMutate() {
    int initialPopulationSize = 100;
    int index = 0;

    Population populationMock = mock(Population.class);
    when(populationMock.selectIndex()).thenReturn(index);
    when(populationMock.getIndividuals()).thenReturn(Arrays.asList(mock(Chromosome.class)));
    when(populationMock.size()).thenReturn(initialPopulationSize);

    MultigenerationalGeneticAlgorithm multigenerationalGeneticAlgorithm = new MultigenerationalGeneticAlgorithm();
    multigenerationalGeneticAlgorithm.setPopulation(populationMock);

    GeneticAlgorithmStrategy strategyToSet = new GeneticAlgorithmStrategy();
    double mutationRate = 0.5;
    strategyToSet.setMutationRate(mutationRate);

    Field strategyField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class, "strategy");
    ReflectionUtils.makeAccessible(strategyField);
    ReflectionUtils.setField(strategyField, multigenerationalGeneticAlgorithm, strategyToSet);

    MutationAlgorithm mutationAlgorithmMock = mock(MutationAlgorithm.class);
    Field mutationAlgorithmField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class,
            "mutationAlgorithm");
    ReflectionUtils.makeAccessible(mutationAlgorithmField);
    ReflectionUtils.setField(mutationAlgorithmField, multigenerationalGeneticAlgorithm, mutationAlgorithmMock);

    multigenerationalGeneticAlgorithm.mutate(initialPopulationSize);

    verify(populationMock, times(50)).selectIndex();
    verify(populationMock, times(50)).getIndividuals();
    verify(populationMock, times(50)).makeIneligibleForReproduction(index);
    verify(populationMock, times(50)).addIndividualAsIneligible(any(Chromosome.class));
    verify(populationMock, times(1)).size();
    verifyNoMoreInteractions(populationMock);

    verify(mutationAlgorithmMock, times(50)).mutateChromosome(any(Chromosome.class));
    verifyNoMoreInteractions(mutationAlgorithmMock);
}

From source file:com.ciphertool.genetics.algorithms.MultigenerationalGeneticAlgorithmTest.java

@Test
public void testMutate_SmallPopulation() {
    int initialPopulationSize = 100;
    int actualPopulationSize = 25;
    int index = 0;

    Population populationMock = mock(Population.class);
    when(populationMock.selectIndex()).thenReturn(index);
    when(populationMock.getIndividuals()).thenReturn(Arrays.asList(mock(Chromosome.class)));
    when(populationMock.size()).thenReturn(actualPopulationSize);

    MultigenerationalGeneticAlgorithm multigenerationalGeneticAlgorithm = new MultigenerationalGeneticAlgorithm();
    multigenerationalGeneticAlgorithm.setPopulation(populationMock);

    GeneticAlgorithmStrategy strategyToSet = new GeneticAlgorithmStrategy();
    double mutationRate = 0.5;
    strategyToSet.setMutationRate(mutationRate);

    Field strategyField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class, "strategy");
    ReflectionUtils.makeAccessible(strategyField);
    ReflectionUtils.setField(strategyField, multigenerationalGeneticAlgorithm, strategyToSet);

    MutationAlgorithm mutationAlgorithmMock = mock(MutationAlgorithm.class);
    Field mutationAlgorithmField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class,
            "mutationAlgorithm");
    ReflectionUtils.makeAccessible(mutationAlgorithmField);
    ReflectionUtils.setField(mutationAlgorithmField, multigenerationalGeneticAlgorithm, mutationAlgorithmMock);

    multigenerationalGeneticAlgorithm.mutate(initialPopulationSize);

    verify(populationMock, times(actualPopulationSize)).selectIndex();
    verify(populationMock, times(actualPopulationSize)).getIndividuals();
    verify(populationMock, times(actualPopulationSize)).makeIneligibleForReproduction(index);
    verify(populationMock, times(actualPopulationSize)).addIndividualAsIneligible(any(Chromosome.class));
    verify(populationMock, times(1)).size();
    verifyNoMoreInteractions(populationMock);

    verify(mutationAlgorithmMock, times(actualPopulationSize)).mutateChromosome(any(Chromosome.class));
    verifyNoMoreInteractions(mutationAlgorithmMock);
}

From source file:com.ciphertool.genetics.algorithms.MultigenerationalGeneticAlgorithmTest.java

@Test
public void testSpawnInitialPopulation() {
    GeneticAlgorithmStrategy strategyToSet = new GeneticAlgorithmStrategy();
    int populationSize = 100;
    strategyToSet.setPopulationSize(populationSize);

    Population populationMock = mock(Population.class);

    MultigenerationalGeneticAlgorithm multigenerationalGeneticAlgorithm = new MultigenerationalGeneticAlgorithm();
    multigenerationalGeneticAlgorithm.setPopulation(populationMock);

    Field strategyField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class, "strategy");
    ReflectionUtils.makeAccessible(strategyField);
    ReflectionUtils.setField(strategyField, multigenerationalGeneticAlgorithm, strategyToSet);

    multigenerationalGeneticAlgorithm.spawnInitialPopulation();

    verify(populationMock, times(1)).clearIndividuals();
    verify(populationMock, times(1)).breed(eq(populationSize));
    verify(populationMock, times(1)).evaluateFitness(null);
    verify(populationMock, times(1)).size();
    verifyNoMoreInteractions(populationMock);
}

From source file:com.ciphertool.genetics.algorithms.MultigenerationalGeneticAlgorithmTest.java

@Test
public void testPersistStatistics() {
    ExecutionStatisticsDao executionStatisticsDaoToSet = mock(ExecutionStatisticsDao.class);

    MultigenerationalGeneticAlgorithm multigenerationalGeneticAlgorithm = new MultigenerationalGeneticAlgorithm();
    multigenerationalGeneticAlgorithm.setExecutionStatisticsDao(executionStatisticsDaoToSet);

    ExecutionStatistics executionStatistics = new ExecutionStatistics();
    Field executionStatisticsField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class,
            "executionStatistics");
    ReflectionUtils.makeAccessible(executionStatisticsField);
    ReflectionUtils.setField(executionStatisticsField, multigenerationalGeneticAlgorithm, executionStatistics);

    multigenerationalGeneticAlgorithm.persistStatistics();

    verify(executionStatisticsDaoToSet, times(1)).insert(same(executionStatistics));
}

From source file:com.ciphertool.genetics.algorithms.MultigenerationalGeneticAlgorithmTest.java

@Test
public void testRequestStop() {
    MultigenerationalGeneticAlgorithm multigenerationalGeneticAlgorithm = new MultigenerationalGeneticAlgorithm();

    Field stopRequestedField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class,
            "stopRequested");
    ReflectionUtils.makeAccessible(stopRequestedField);
    boolean stopRequestedFromObject = (boolean) ReflectionUtils.getField(stopRequestedField,
            multigenerationalGeneticAlgorithm);

    assertEquals(false, stopRequestedFromObject);

    multigenerationalGeneticAlgorithm.requestStop();

    stopRequestedFromObject = (boolean) ReflectionUtils.getField(stopRequestedField,
            multigenerationalGeneticAlgorithm);

    assertEquals(true, stopRequestedFromObject);
}

From source file:com.migo.utils.ScheduleRunnable.java

@Override
public void run() {

    try {//from  w  w  w  . j  a  v  a2 s  .  co  m
        ReflectionUtils.makeAccessible(method);
        if (StringUtils.isNotBlank(params)) {
            method.invoke(target, params);
        } else {
            method.invoke(target);
        }
    } catch (Exception e) {
        throw new RRException("", e);
    }
}

From source file:com.mylife.hbase.mapper.HBaseEntityMapper.java

@SuppressWarnings("unchecked")
public <T> T objectFrom(final Result result, final Class<T> hBasePersistanceClass) {
    if (!annotatedClassToAnnotatedHBaseRowKey.containsKey(hBasePersistanceClass)) {
        throw new IllegalArgumentException(
                "Class passed to objectFrom(final Result result, final Class<T> hBasePersistanceClass) must be a correct HBase persistable class! If this class is annotaed with @HBasePersistance please see startup errors for why it might have been excluded. ");
    }//from ww w .ja  v  a2  s  . c  o m
    if (result.isEmpty()) {
        return null;
    }
    /*
     * Create new instance of our target class
     */
    final T type = Whitebox.newInstance(hBasePersistanceClass);
    final NavigableMap<byte[], NavigableMap<byte[], byte[]>> columnFamilyResultMap = result.getNoVersionMap();
    /*
     * Map results to fields annotated with @HBaseField
     */
    for (final Field field : annotatedClassToAnnotatedFieldMappingWithCorrespondingGetterMethod
            .get(hBasePersistanceClass).keySet()) {
        ReflectionUtils.makeAccessible(field);
        ReflectionUtils.setField(field, type,
                TypeHandler.getTypedValue(field.getType(),
                        columnFamilyResultMap.get(columnFamilyNameFromHBaseFieldAnnotatedField(field))
                                .remove(Bytes.toBytes(field.getName()))));
    }
    /*
     * Map results to fields annotated with @HBaseObjectField
     */
    for (final Field field : annotatedClassToAnnotatedObjectFieldMappingWithCorrespondingGetterMethod
            .get(hBasePersistanceClass).keySet()) {
        ReflectionUtils.makeAccessible(field);
        try {
            /*
             * We may purposely not want to populate certain fields by not including the column family
             */
            final byte[] columnFamily = columnFamilyNameFromHBaseObjectFieldAnnotatedField(field);
            if (columnFamilyResultMap.containsKey(columnFamily)) {
                ReflectionUtils.setField(field, type,
                        field.getAnnotation(HBaseObjectField.class).serializationStategy().deserialize(
                                columnFamilyResultMap.get(columnFamily).remove(Bytes.toBytes(field.getName())),
                                field));
            }
        } catch (Exception e) {
            /*
             *  We serialized this we should be able to de-serialize it. Did the serialization change?
             *  
             *  TODO: store serialization type so we can better guarantee de-serialization
             */
            LOG.error("Could not deserialize " + field.getName() + " for family map name: "
                    + columnFamilyNameFromHBaseObjectFieldAnnotatedField(field)
                    + " Did the serialization (KRYO/JSON) OR field type change from when you serialized the object?",
                    e);
        }
    }
    /*
     * Map results to fields annotated with @HBaseMapField
     */
    mapFieldBlock: {
        if (annotatedClassToAnnotatedMapFieldMappingWithCorrespondingGetterMethod
                .get(hBasePersistanceClass) != null) {
            final Field field = annotatedClassToAnnotatedMapFieldMappingWithCorrespondingGetterMethod
                    .get(hBasePersistanceClass).keySet().iterator().next();
            Map<String, String> map;
            if (field.getType().equals(Map.class)) {
                /*
                 *  If the object just calls for a Map give them a TreeMap();
                 */
                map = new TreeMap<String, String>();
            } else {
                /*
                 *  else try to create an instance of the Map class they are using
                 */
                try {
                    map = (Map<String, String>) Whitebox.getConstructor(field.getType())
                            .newInstance((Object[]) null);
                } catch (Exception e) {
                    /*
                     *  Done our best to guard against this but still possible
                     */
                    LOG.error("Could not create new instance of map.", e);
                    break mapFieldBlock;
                }
            }
            for (final Entry<byte[], byte[]> entry : columnFamilyResultMap
                    .get(columnFamilyNameFromHBaseMapFieldAnnotatedField(field)).entrySet()) {
                map.put(Bytes.toString(entry.getKey()), Bytes.toString(entry.getValue()));
            }
            ReflectionUtils.makeAccessible(field);
            ReflectionUtils.setField(field, type, map);
        }
    }

    return type;

}

From source file:com.opendesign.utils.CmnUtil.java

/**
 *  vo ? ?? / ? .//w w w. ja v a 2  s .  c  o  m
 * 
 * @param vo
 */
public static void setCmnDate(Object vo) {
    String curDateStr = Day.getCurrentDateString("yyyyMMddHHmm");
    Class<?> clazz = vo.getClass();
    // ??
    Field regTimeField = ReflectionUtils.findField(clazz, "registerTime");
    if (regTimeField != null) {
        ReflectionUtils.makeAccessible(regTimeField);
        ReflectionUtils.setField(regTimeField, vo, curDateStr);
    }
    // ?
    Field updTimeField = ReflectionUtils.findField(clazz, "updateTime");
    if (updTimeField != null) {
        ReflectionUtils.makeAccessible(updTimeField);
        ReflectionUtils.setField(updTimeField, vo, curDateStr);
    }
}