Hypercell ein ] Hypercell aus ] Zeige Navigation ] Verstecke Navigation ]
c++.net  
   

Die mobilen Seiten von c++.net:
https://m.c-plusplus.net

  
C++ Forum :: Java ::  Konfigurationsdatei parsen und auswerten     Zeige alle Beiträge auf einer Seite Auf Beitrag antworten
Autor Nachricht
JavaFanboy
Unregistrierter




Beitrag JavaFanboy Unregistrierter 13:59:49 10.04.2018   Titel:   Konfigurationsdatei parsen und auswerten            Zitieren

Hey, für meinen selbstgebautes InetServer-Utility habe ich eine simple Klasse geschrieben. die Konfigurationseinträge liest und auswertet.

Eine Konfigurationsdatei sieht z.B. so aus.
Code:
1
2
3
4
5
6
7
8
9
*** set ftp params and start ftp server ***
ftp-port :: 21
ftp-path :: C:\ftproot\
ftp-start
 
*** set http params and start web server ***
http-port :: 80
http-path :: C:\web\
http-start

Relevante Zeilen beginnen mit einem Schlüsselwort und nachstehenden Argumenten, getrennt durch ::
Was Schlüsselwort ist wird zur Laufzeit bestimmt.
Das sieht dann so aus:
Java:
1
2
3
4
5
6
7
8
9
        // Exec config file
        ConfigFile cf = new ConfigFile("serversettings.txt");
        cf.setAction("ftp-port", strings -> ftp.setPortTxt(strings[0]));
        cf.setAction("ftp-path", strings -> ftp.setPathTxt(strings[0]));
        cf.setAction("ftp-start", strings -> ftp.start());
        cf.setAction("http-port", strings -> web.setPortTxt(strings[0]));
        cf.setAction("http-path", strings -> web.setPathTxt(strings[0]));
        cf.setAction("http-start", strings -> web.start());
        cf.execute();

Das zweite Argument von "setAction" ist die Handler-Funktion, die die einzelnen Argumente aus der Config-Datei als String[] bekommt.

Die Klasse selbst ist hier:
Java:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
import java.io.IOException;
import java.nio.file.Files;

import java.nio.file.Paths;

import java.util.ArrayList;

import java.util.function.Consumer;

import java.util.stream.Stream;

 
/**
 * A line of the config file is organised as following:
 * keyword :: p1 :: p2 :: p3 ... pn
 *
 * :: is the delimiter
 * The arguments p1 ... pn are optional
 * Whitespaces are ignored
 * Lines that do not start with a known keyword are ignored
 * Blank lines are also ignored
 *
 * The usage is:
 *         ConfigFile cf = new ConfigFile("file_name_on_disk");
 *         cf.setAction("any_string", strings -> Command(strings));
 *         cf.setAction("other_string", strings -> Command(strings));
 *         ...
 *         cf.execute(); // Parse file and execute commands
 *
 * Commands are functions/methods that take a single String[] as argument
 *
 */

public class ConfigFile
{
    private final String _path;
    private final ArrayList<Action> _list = new ArrayList<>();
 
    /**
     * Constructor
     * @param path set file path
     */

    public ConfigFile (String path)
    {
        _path = path;
    }
 
    /**
     * Action element
     */

    private class Action
    {
        final String name;
        final Consumer<String[]> function;
 
        Action (String n, Consumer<String[]> r)
        {
            name = n;
            function = r;
        }
    }
 
    /**
     * Submit a new action command
     * @param name Keyword
     * @param r Handler function
     */

    public void setAction (String name, Consumer<String[]> r)
    {
        _list.add(new Action (name, r));
    }
 
    /**
     * Parse line of config file and execute command
     * @param line the line
     */

    private void handleLine (String line)
    {
        line = line.replaceAll("\\s+","");
        String[] splits = line.split("::");
        for (Action a : _list)
        {
            if (splits[0].equals(a.name))
            {
                String[] args = new String[splits.length-1];
                System.arraycopy(splits, 1, args, 0, args.length);
                a.function.accept(args);
            }
        }
    }
 
    /**
     * Parse whole config file and execute it line by line
     */

    public void execute()
    {
        try (Stream<String> stream = Files.lines(Paths.get(_path)))
        {
            stream.forEach(this::handleLine);
        }
        catch (IOException e)
        {
            System.out.println(e);
        }
    }
}


Läuft ab Java 8 aufwärts.
Viel Spaß damit! :)
JavaFanboy
Unregistrierter




Beitrag JavaFanboy Unregistrierter 17:05:47 10.04.2018   Titel:              Zitieren

Ich habe die ArrayList gegen eine Hashmap getauscht. Dadurch entfällt die Action-Hilfsklasse und der Code ist kürzer. An der Funktionalität ändert sich aber nichts.

Wenn jemanden die neue Version interessiert, werde ich sie posten.
C++ Forum :: Java ::  Konfigurationsdatei parsen und auswerten   Auf Beitrag antworten

Zeige alle Beiträge auf einer Seite




Nächstes Thema anzeigen
Vorheriges Thema anzeigen
Sie können Beiträge in dieses Forum schreiben.
Sie können auf Beiträge in diesem Forum antworten.
Sie können Ihre Beiträge in diesem Forum nicht bearbeiten.
Sie können Ihre Beiträge in diesem Forum nicht löschen.
Sie können an Umfragen in diesem Forum nicht mitmachen.

Powered by phpBB © 2001, 2002 phpBB Group :: FI Theme

c++.net ist Teilnehmer des Partnerprogramms von Amazon Europe S.à.r.l. und Partner des Werbeprogramms, das zur Bereitstellung eines Mediums für Websites konzipiert wurde, mittels dessen durch die Platzierung von Werbeanzeigen und Links zu amazon.de Werbekostenerstattung verdient werden kann.

Die Vervielfältigung der auf den Seiten www.c-plusplus.de, www.c-plusplus.info und www.c-plusplus.net enthaltenen Informationen ohne eine schriftliche Genehmigung des Seitenbetreibers ist untersagt (vgl. §4 Urheberrechtsgesetz). Die Nutzung und Änderung der vorgestellten Strukturen und Verfahren in privaten und kommerziellen Softwareanwendungen ist ausdrücklich erlaubt, soweit keine Rechte Dritter verletzt werden. Der Seitenbetreiber übernimmt keine Gewähr für die Funktion einzelner Beiträge oder Programmfragmente, insbesondere übernimmt er keine Haftung für eventuelle aus dem Gebrauch entstehenden Folgeschäden.