Java Configuration类代码示例

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
/**
 * Saves a scoreboard to a configuration file.
 *
 * @param config
 *            The configuration file.
 * @param scoreboard
 *            The scoreboard.
 */
public void saveScoreboard(Configuration config, Scoreboard scoreboard) {
	// Save teams
	ConfigurationSection teamsSection = config.createSection("teams");
	scoreboard.getTeams().forEach(team -> {
		ConfigurationSection teamSection = teamsSection.createSection(team.getName());
		saveTeam(teamSection, team);
	});

	// Save objectives
	ConfigurationSection objectivesSection = config.createSection("objectives");
	scoreboard.getObjectives().forEach(objective -> {
		ConfigurationSection objectiveSection = objectivesSection.createSection(objective.getName());
		objectiveSection.set("criteria", objective.getCriteria());
		objectiveSection.set("display_name", objective.getDisplayName());
		objectiveSection.set("display_slot", objective.getDisplaySlot().toString().toLowerCase());
	});

	// Save scores
	ConfigurationSection scoresSection = config.createSection("scores");
	scoreboard.getEntries().forEach(playerName -> {
		ConfigurationSection playerSection = scoresSection.createSection(playerName);
		scoreboard.getScores(playerName)
				.forEach(score -> playerSection.set(score.getObjective().getName(), score.getScore()));
	});
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
/**
 * Creates a new map manager with a specified map rotation.
 */
@Inject MatchManager(Loggers loggers,
                     @Named("pluginData") Path pluginDataFolder,
                     Provider<Configuration> config,
                     MapLibrary mapLibrary,
                     MapLoader mapLoader,
                     MapErrorTracker mapErrorTracker,
                     FileRotationProviderFactory fileRotationProviderFactory,
                     EventBus eventBus,
                     MatchLoader matchLoader) throws MapNotFoundException {

    this.pluginDataFolder = pluginDataFolder;
    this.mapErrorTracker = mapErrorTracker;
    this.fileRotationProviderFactory = fileRotationProviderFactory;
    this.log = loggers.get(getClass());
    this.config = config;
    this.mapLibrary = mapLibrary;
    this.mapLoader = mapLoader;
    this.eventBus = eventBus;
    this.matchLoader = matchLoader;
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
@Inject QuotaConfig(Configuration root) {
    this.config = root.getConfigurationSection("match-quotas");
    if(config == null) {
        quotas = new TreeSet<>();
    } else {
        quotas = new TreeSet<>(Collections2.transform(
            config.getKeys(false),
            new Function<String, Entry>() {
                @Override
                public Entry apply(@Nullable String key) {
                    return new Entry(config.getConfigurationSection(key));
                }
            }
        ));
    }
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
public Set<RotationProviderInfo> parse(MapLibrary mapLibrary, Path dataPath, Configuration config) {
    ConfigurationSection base = config.getConfigurationSection("rotation.providers.file");
    if(base == null) return Collections.emptySet();

    Set<RotationProviderInfo> providers = new HashSet<>();
    for(String name : base.getKeys(false)) {
        ConfigurationSection provider = base.getConfigurationSection(name);

        Path rotationFile = Paths.get(provider.getString("path"));
        if(!rotationFile.isAbsolute()) rotationFile = dataPath.resolve(rotationFile);

        int priority = provider.getInt("priority", 0);

        if(Files.isRegularFile(rotationFile)) {
            providers.add(new RotationProviderInfo(new FileRotationProvider(mapLibrary, name, rotationFile, dataPath), name, priority));
        } else if(minecraftService.getLocalServer().startup_visibility() == ServerDoc.Visibility.PUBLIC) {
            // This is not a perfect way to decide whether or not to throw an error, but it's the best we can do right now
            mapLibrary.getLogger().severe("Missing rotation file: " + rotationFile);
        }
    }

    return providers;
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
public void loadConfig() {
    Configuration configuration = YamlConfiguration.loadConfiguration(configFile);
    ConfigurationSection bungeeSection;
    if (configuration.contains("bungee")){
        bungeeSection = configuration.getConfigurationSection("bungee");
    } else {
        getLogger().warning("The section 'bungee' in the configuration is not found, " +
                "defaults will be assumed. Delete the config file and restart to have a " +
                "clean valid configuration file.");
        bungeeSection = configuration.createSection("bungee");
    }
    boolean serverSocketEnabled = configuration.getBoolean("server-socket", true);
    boolean serverPortAuto = configuration.getBoolean("port-automatic", true);
    int serverPort = configuration.getInt("port", 3112);
    String host = bungeeSection.getString("host");
    int port = bungeeSection.getInt("port");
    char[] password = bungeeSection.getString("password", "").toCharArray();
    int heartbeatSeconds = bungeeSection.getInt("heartbeat-seconds", 30);
    int reconnectAttempts = bungeeSection.getInt("reconnect-attempts", 7);
    bungeeMasterSpigotConfig = new BungeeMasterSpigotConfig(serverSocketEnabled, serverPortAuto, serverPort, host, port, password, heartbeatSeconds, reconnectAttempts);
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
private void checkConfigVersions(Configuration config, Path dataFolder) {
    if (config.getInt("config-version", 0) < TradeConfiguration.CURRENT_CONFIG_VERSION) {
        Path configSource = dataFolder.resolve(TradeConfiguration.DESTINATION_FILE_NAME);
        Path configTarget = dataFolder.resolve("config_old.yml");

        try {
            Files.move(configSource, configTarget, StandardCopyOption.REPLACE_EXISTING);
            URL configResource = getClass().getResource(TradeConfiguration.CLASSPATH_RESOURCE_NAME);

            copyResource(configResource, configSource.toFile());

            ConsoleCommandSender sender = Bukkit.getConsoleSender();
            sender.sendMessage(ChatColor.RED + "Due to a SimpleTrading update your old configuration has been renamed");
            sender.sendMessage(ChatColor.RED + "to config_old.yml and a new one has been generated. Make sure to");
            sender.sendMessage(ChatColor.RED + "apply your old changes to the new config!");
        } catch (IOException e) {
            getLogger().log(Level.SEVERE, "Could not create updated configuration due to an IOException", e);
        }
    }
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
/**
 * Gets a configuration file from the jar file.
 *
 * @param path
 *            Path in the jar file.
 * @return The configuration file.
 */
private Configuration getJarConfig(String path) {
    InputStream resource = getResource(path);
    if (resource == null) {
        // Not found
        return new YamlConfiguration();
    }
    Reader reader = new InputStreamReader(resource, Charsets.UTF_8);
    Configuration config = YamlConfiguration.loadConfiguration(reader);
    try {
        resource.close();
    } catch (IOException e) {
        getLogger().log(Level.SEVERE, "Failed to close stream", e);
    }
    return config;
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
private Translator loadTranslations(String fileName) {
    File file = new File(getDataFolder(), fileName);
    Configuration config = YamlConfiguration.loadConfiguration(file);
    config.addDefaults(getJarConfig(Config.DEFAULT_TRANSLATIONS_FILE));

    ConfigTranslator translator = new ConfigTranslator(config);
    if (translator.needsSave()) {
        getLogger().info("Saving translations");
        try {
            translator.save(file);
        } catch (IOException e) {
            getLogger().log(Level.SEVERE, "Failed to save translation file", e);
        }
    }
    return translator;
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
/**
 * Initialize mod config based on the configuration file
 *
 * @param config
 */
public ModConfig(Configuration config) {
    m_isInitialized = false;
    if (config == null) {
        m_blocks = null;
        m_mobs = null;
        m_modIdRegex = null;
        m_textureRes = 0;
        m_versionRegex = null;
        return;
    }

    m_name = config.getString("DisplayName", null);
    m_blocks = config.getConfigurationSection("Blocks");
    m_mobs = config.getConfigurationSection("Mobs");
    m_modIdRegex = config.getString("ModId", null);
    m_alternativeId = config.getString("ModIdAlternative", null);
    m_versionRegex = config.getString("Version", null);
    m_textureRes = config.getInt("TextureRes", 0);
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
/**
 * Load palette from file
 *
 * @param file
 * @return
 */
public static Palette load(File file) {
    Configuration config = YamlConfiguration.loadConfiguration(file);

    String name = config.getString("name", null);
    BlockEntry[] blockEntries = parseBlocksSection(config);
    
    if (name == null) {
        MCPainterMain.log("* " + file.getName() + "...invalid file format, no name palette defined.");
        return null;
    }
    
    name = name.toLowerCase();
    if (blockEntries == null || blockEntries.length < 2) {
        MCPainterMain.log("* " + name + "...invalid file format, minimum number of blocks in palette is 2.");
        return null;
    }
    
    MCPainterMain.log("* " + name + "..." + blockEntries.length + " blocks defined.");
    return new Palette(name, blockEntries);
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
/**
 * Parse blocks section entry
 *
 * @param configuration
 * @return
 */
private static BlockEntry[] parseBlocksSection(Configuration configuration) {
    List<BlockEntry> blocks = new ArrayList();
    for (String string : configuration.getStringList("blocks")) {
        try {
            BlockEntry entry = BlockEntry.parse(string);
            if (entry == null) {
                MCPainterMain.log("* Error parsing block entry: " + string);
            } else {
                blocks.add(entry);
            }
        } catch (Exception e) {
            MCPainterMain.log("* Error parsing block entry: " + string);
        }
    }
    return blocks.toArray(new BlockEntry[0]);
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
public void load() {
    BukkitScheduler scheduler = plugin.getServer().getScheduler();
    if (task != null) {
        task.cancel();
        task = null;
    }
    ConfigurationSection arenaConfiguration = loadDataFile("arenas");
    load(arenaConfiguration);

    ConfigurationSection arenaData = loadDataFile("data");
    loadData(arenaData);

    plugin.reloadConfig();
    Configuration config = plugin.getConfig();
    pathTemplate = config.getString("path_template", pathTemplate);
    tickInterval = config.getInt("tick_interval", 40);

    task = scheduler.runTaskTimer(plugin, this, 1, tickInterval);
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
@Override
public boolean isSTBItem(ItemStack stack, Class<? extends BaseSTBItem> c) {
    if (stack == null || !stack.hasItemMeta()) {
        return false;
    }
    ItemMeta im = stack.getItemMeta();
    if (im.hasLore()) {
        List<String> lore = im.getLore();
        if (!lore.isEmpty() && lore.get(0).startsWith(LORE_PREFIX)) {
            if (c != null) {
                Configuration conf = getItemAttributes(stack);
                ReflectionDetails details = reflectionDetailsMap.get(conf.getString("*TYPE"));
                return details != null && c.isAssignableFrom(details.clazz);
            } else {
                return true;
            }
        }
    }
    return false;
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
private Configuration getItemAttributes(ItemStack stack) {
    AttributeStorage storage = AttributeStorage.newTarget(stack, STB_ATTRIBUTE_ID);
    YamlConfiguration conf = new YamlConfiguration();
    try {
        String s = storage.getData("");
        if (s != null) {
            conf.loadFromString(s);
            if (Debugger.getInstance().getLevel() > 2) {
                Debugger.getInstance().debug(3, "get item attributes for " + STBUtil.describeItemStack(stack) + ":");
                for (String k : conf.getKeys(false)) {
                    Debugger.getInstance().debug(3, "- " + k + " = " + conf.get(k));
                }
            }
            return conf;
        } else {
            throw new IllegalStateException("ItemStack " + stack + " has no STB attribute data!");
        }
    } catch (InvalidConfigurationException e) {
        e.printStackTrace();
        return new MemoryConfiguration();
    }
}
 

import org.bukkit.configuration.Configuration; //导入依赖的package包/类
private RpChar loadCharacter(File playerFile)
   {
       OfflinePlayer player = Bukkit.getOfflinePlayer(UUID.fromString(playerFile.getName().substring(0, playerFile.getName().length() - 4)));
       RpChar character = new RpChar(player,plugin);

	Configuration playerConfig = YamlConfiguration.loadConfiguration(playerFile);
		
       for (Field field : plugin.getCharacterManager().getFields().values())
       {
           if (!playerConfig.isSet(field.getName()))
               continue;

           character.setField(field.getName(), playerConfig.getString(field.getName()));
       }

       return character;
}