Java BeanAccess类代码示例

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
@Override protected Set<Property> createPropertySet(Class<?> type, BeanAccess bAccess) {
  try {
    Set<Property> properties = super.createPropertySet(type, bAccess);
    if (Tape.class.isAssignableFrom(type)) {
      return sort(properties, "name", "interactions");
    } else if (YamlRecordedInteraction.class.isAssignableFrom(type)) {
      return sort(properties, "recorded", "request", "response");
    } else if (YamlRecordedRequest.class.isAssignableFrom(type)) {
      return sort(properties, "method", "uri", "headers", "body");
    } else if (YamlRecordedResponse.class.isAssignableFrom(type)) {
      return sort(properties, "status", "headers", "body");
    } else {
      return properties;
    }
  } catch (IntrospectionException e) {
    throw new RuntimeException(e);
  }
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
public void testArrayAsMapValue() {
    Yaml yaml2dump = new Yaml();
    yaml2dump.setBeanAccess(BeanAccess.FIELD);
    A data = createA();
    String dump = yaml2dump.dump(data);
    // System.out.println(dump);

    Yaml yaml2load = new Yaml();
    yaml2load.setBeanAccess(BeanAccess.FIELD);
    A loaded = (A) yaml2load.load(dump);

    assertEquals(data.meta.size(), loaded.meta.size());
    Set<Entry<String, String[]>> loadedMeta = loaded.meta.entrySet();
    for (Entry<String, String[]> entry : loadedMeta) {
        assertTrue(data.meta.containsKey(entry.getKey()));
        Assert.assertArrayEquals(data.meta.get(entry.getKey()), entry.getValue());
    }
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
public void testArrayAsMapValueWithTypeDespriptor() {
    Yaml yaml2dump = new Yaml();
    yaml2dump.setBeanAccess(BeanAccess.FIELD);
    A data = createA();
    String dump = yaml2dump.dump(data);
    // System.out.println(dump);

    TypeDescription aTypeDescr = new TypeDescription(A.class);
    aTypeDescr.putMapPropertyType("meta", String.class, String[].class);

    Constructor c = new Constructor();
    c.addTypeDescription(aTypeDescr);
    Yaml yaml2load = new Yaml(c);
    yaml2load.setBeanAccess(BeanAccess.FIELD);

    A loaded = (A) yaml2load.load(dump);

    assertEquals(data.meta.size(), loaded.meta.size());
    Set<Entry<String, String[]>> loadedMeta = loaded.meta.entrySet();
    for (Entry<String, String[]> entry : loadedMeta) {
        assertTrue(data.meta.containsKey(entry.getKey()));
        Assert.assertArrayEquals(data.meta.get(entry.getKey()), entry.getValue());
    }
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
public void testArrayAsListValueWithTypeDespriptor() {
    Yaml yaml2dump = new Yaml();
    yaml2dump.setBeanAccess(BeanAccess.FIELD);
    B data = createB();
    String dump = yaml2dump.dump(data);
    // System.out.println(dump);

    TypeDescription aTypeDescr = new TypeDescription(B.class);
    aTypeDescr.putListPropertyType("meta", String[].class);

    Constructor c = new Constructor();
    c.addTypeDescription(aTypeDescr);
    Yaml yaml2load = new Yaml(c);
    yaml2load.setBeanAccess(BeanAccess.FIELD);

    B loaded = (B) yaml2load.load(dump);

    Assert.assertArrayEquals(data.meta.toArray(), loaded.meta.toArray());
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
public void testErrorMessage() throws Exception {

        BeanA1 b = new BeanA1();
        b.setId(2l);
        b.setName("name1");

        Constructor c = new Constructor();
        Representer r = new Representer();

        PropertyUtils pu = new PropertyUtils();
        c.setPropertyUtils(pu);
        r.setPropertyUtils(pu);

        pu.getProperties(BeanA1.class, BeanAccess.FIELD);

        Yaml yaml = new Yaml(c, r);
        // yaml.setBeanAccess(BeanAccess.FIELD);
        String dump = yaml.dump(b);
        BeanA1 b2 = (BeanA1) yaml.load(dump);
        assertEquals(b.getId(), b2.getId());
        assertEquals(b.getName(), b2.getName());
    }
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
/**
 * Read a.yaml file according to a class type.
 *
 * @param file      File path of the configuration file
 * @param classType Class type of the.yaml bean
 * @param <T>       Class T
 * @return Config file bean
 * @throws CarbonIdentityMgtConfigException Error in reading configuration file
 */
public static <T> T readConfigFile(Path file, Class<T> classType)
        throws CarbonIdentityMgtConfigException {

    if (Files.exists(file)) {
        try {
            Reader in = new InputStreamReader(Files.newInputStream(file), StandardCharsets.UTF_8);
            CustomClassLoaderConstructor constructor =
                    new CustomClassLoaderConstructor(classType.getClassLoader());
            Yaml yaml = new Yaml(constructor);
            yaml.setBeanAccess(BeanAccess.FIELD);
            return yaml.loadAs(in, classType);
        } catch (IOException e) {
            throw new CarbonIdentityMgtConfigException(String.format("Error in reading file %s", file.toString())
                    , e);
        }
    } else {
        throw new CarbonIdentityMgtConfigException(String
                .format("Configuration file %s is not available.", file.toString()));
    }
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
/**
 * Read a.yaml file according to a class type.
 *
 * @param path          folder which contain the config files
 * @param classType     Class type of the.yaml bean
 * @param fileNameRegex file name regex
 * @param <T>           Class T
 * @return Config file bean
 * @throws CarbonIdentityMgtConfigException Error in reading configuration file
 */
public static <T> List<T> readConfigFiles(Path path, Class<T> classType, String fileNameRegex)
        throws CarbonIdentityMgtConfigException {

    List<T> configEntries = new ArrayList<>();
    if (Files.exists(path)) {
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(path, fileNameRegex)) {
            for (Path file : stream) {
                Reader in = new InputStreamReader(Files.newInputStream(file), StandardCharsets.UTF_8);
                CustomClassLoaderConstructor constructor =
                        new CustomClassLoaderConstructor(classType.getClassLoader());
                Yaml yaml = new Yaml(constructor);
                yaml.setBeanAccess(BeanAccess.FIELD);
                configEntries.add(yaml.loadAs(in, classType));
            }
        } catch (DirectoryIteratorException | IOException e) {
            throw new CarbonIdentityMgtConfigException(String.format("Failed to read identity connector files " +
                    "from path: %s", path.toString()), e);
        }
    }
    return configEntries;
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
public static <T> void writeConfigFiles(Path file, Object data)
        throws IdentityRecoveryException {

    if (Files.exists(file, new LinkOption[0])) {
        try {
            CustomClassLoaderConstructor constructor =
                    new CustomClassLoaderConstructor(FileUtil.class.getClassLoader());
            Yaml yaml = new Yaml(constructor);
            yaml.setBeanAccess(BeanAccess.FIELD);
            try (Writer writer = new OutputStreamWriter(new FileOutputStream(file.toFile()),
                                                        StandardCharsets.UTF_8)) {
                yaml.dump(data, writer);
            }
        } catch (IOException e) {
            throw new IdentityRecoveryException(
                    String.format("Error in reading file %s", new Object[] { file.toString() }), e);
        }
    } else {
        throw new IdentityRecoveryException(
                String.format("Configuration file %s is not available.", new Object[] { file.toString() }));
    }
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static Map<String, Object> readProperties(final InputStream in) throws IOException
{
    String inputStreamString = IOUtils.toString(new InputStreamReader(in, "UTF-8"));
    Yaml yaml = new Yaml();
    yaml.setBeanAccess(BeanAccess.FIELD);
    final Iterable<Object> iter = yaml.loadAll(substituteVariables(inputStreamString));

    final Map<String, Object> newProperties = new LinkedHashMap<>();

    iter.forEach(item -> {
        final Map<String, Object> section = (Map<String, Object>) item;
        newProperties.putAll(section);
    });

    return newProperties;
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
@Override
public List<MailReceiver> readMailReceiver() {
	File dir = git.getRepo().directory();
	File file = new File(dir, "/mailinglists.yml");
	if (!file.exists()) {
		return null;
	}
	try {
		Yaml yaml = new Yaml();
		yaml.setBeanAccess(BeanAccess.FIELD);
		return (List<MailReceiver>) yaml.load(FileUtils.readFileToString(file));
	} catch (IOException e) {
		log.error(e.getMessage(), e);
	}
	return null;
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
public ChronixSparkLoader() {
    Representer representer = new Representer();
    representer.getPropertyUtils().setSkipMissingProperties(true);

    Constructor constructor = new Constructor(YamlConfiguration.class);

    TypeDescription typeDescription = new TypeDescription(ChronixYAMLConfiguration.class);
    typeDescription.putMapPropertyType("configurations", Object.class, ChronixYAMLConfiguration.IndividualConfiguration.class);
    constructor.addTypeDescription(typeDescription);

    Yaml yaml = new Yaml(constructor, representer);
    yaml.setBeanAccess(BeanAccess.FIELD);

    InputStream in = this.getClass().getClassLoader().getResourceAsStream("test_config.yml");
    chronixYAMLConfiguration = yaml.loadAs(in, ChronixYAMLConfiguration.class);
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
public static TransportsConfiguration build(String nettyTransportsConfigFile) {
    TransportsConfiguration transportsConfiguration;
    File file = new File(nettyTransportsConfigFile);
    if (file.exists()) {
        try (Reader in = new InputStreamReader(new FileInputStream(file), StandardCharsets.ISO_8859_1)) {
            Yaml yaml = new Yaml();
            yaml.setBeanAccess(BeanAccess.FIELD);
            transportsConfiguration = yaml.loadAs(in, TransportsConfiguration.class);
        } catch (IOException e) {
            String msg = "Error while loading " + nettyTransportsConfigFile + " configuration file";
            throw new RuntimeException(msg, e);
        }
    } else { // return a default config
        log.warn("Netty transport configuration file not found in: " + nettyTransportsConfigFile);
        transportsConfiguration = TransportsConfiguration.getDefault();
    }

    return transportsConfiguration;
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
/**
 * Get the {@code TransportsConfiguration} represented by a particular configuration file
 *
 * @param configFileLocation configuration file location
 * @return TransportsConfiguration represented by a particular configuration file
 */
public TransportsConfiguration getConfiguration(String configFileLocation) {
    TransportsConfiguration transportsConfiguration;

    File file = new File(configFileLocation);
    if (file.exists()) {
        try (Reader in = new InputStreamReader(new FileInputStream(file), StandardCharsets.ISO_8859_1)) {
            Yaml yaml = new Yaml(new CustomClassLoaderConstructor
                    (TransportsConfiguration.class, TransportsConfiguration.class.getClassLoader()));
            yaml.setBeanAccess(BeanAccess.FIELD);
            transportsConfiguration = yaml.loadAs(in, TransportsConfiguration.class);
        } catch (IOException e) {
            throw new RuntimeException(
                    "Error while loading " + configFileLocation + " configuration file", e);
        }
    } else { // return a default config
        log.warn("Netty transport configuration file not found in: " + configFileLocation +
                 " ,hence using default configuration");
        transportsConfiguration = TransportsConfiguration.getDefault();
    }

    return transportsConfiguration;
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
public static TransportsConfiguration getConfiguration(String configFileLocation) {
    TransportsConfiguration transportsConfiguration;

    File file = new File(TestUtil.class.getResource(configFileLocation).getFile());
    if (file.exists()) {
        try (Reader in = new InputStreamReader(new FileInputStream(file), StandardCharsets.ISO_8859_1)) {
            Yaml yaml = new Yaml(new CustomClassLoaderConstructor
                                         (TransportsConfiguration.class,
                                          TransportsConfiguration.class.getClassLoader()));
            yaml.setBeanAccess(BeanAccess.FIELD);
            transportsConfiguration = yaml.loadAs(in, TransportsConfiguration.class);
        } catch (IOException e) {
            throw new RuntimeException(
                    "Error while loading " + configFileLocation + " configuration file", e);
        }
    } else { // return a default config
        log.warn("Netty transport configuration file not found in: " + configFileLocation +
                         " ,hence using default configuration");
        transportsConfiguration = TransportsConfiguration.getDefault();
    }

    return transportsConfiguration;
}
 

import org.yaml.snakeyaml.introspector.BeanAccess; //导入依赖的package包/类
@Override
protected Map<String, Property> getPropertiesMap(Class<?> type, BeanAccess bAccess) throws IntrospectionException {
    Map<String, Property> newPropertyMap = new LinkedHashMap<>();
    Map<String, Property> propertiesMap = super.getPropertiesMap(type, bAccess);
    for (Iterator<Map.Entry<String, Property>> iterator = propertiesMap.entrySet().iterator(); iterator.hasNext(); ) {
        Map.Entry<String, Property> entry = iterator.next();
        boolean updated = false;
        if (entry.getValue() instanceof FieldProperty) {
            try {
                Field field = type.getDeclaredField(entry.getValue().getName());
                Path path = field.getAnnotation(Path.class);
                if (path != null) {
                    newPropertyMap.put(path.value(), new CustomNameFieldProperty(field, path.value()));
                    updated = true;
                }
            } catch (NoSuchFieldException ignored) {
            }
        }
        if (!updated) {
            newPropertyMap.put(entry.getKey(), entry.getValue());
        }
    }

    return newPropertyMap;
}