MySQL-Backup-Tabellenvorgang basierend auf Java

Der Kern ist mysqldump und Runtime
Der Vorgang ist eigentlich nicht sehr schwierig. Erstellen Sie eine Klasse, um den Sicherungsvorgang durchzuführen. Markieren Sie die Tabelle nach dem Empfang des Sicherungsaufrufs als gesichert und erstellen Sie dann einen untergeordneten Thread, um den Sicherungsvorgang durchzuführen. Die benötigten Konfigurationsinformationen werden aus der Konfigurationsdatei ausgelesen, wobei auch auf Pfadprobleme unter Windows und Linux zu achten ist.

Die Konfigurationsdateien lauten wie folgt:

Java-Codesammlungscode
# Datenbankadresse
dbAddress=lokaler Host
# Name der zu sichernden Datenbank
Datenbankname=nms
# Datenbank-Benutzername
Benutzername = root
# Datenbankkennwort
Passwort = root
#mysqldump-PfadLinux
mysqlpath = /usr/bin/
# Speicherort der Sicherungsdatei Linux
sqlFilePath = /MySQlBack/
#mysqldump-Pfad Windows
#mysqlpath = C\://Programme//MySQL//MySQL Server 5.5//bin//
# Speicherort der Sicherungsdatei Windows
#sqlFilePath =C\://MySQl//

Die Codeklasse, die die Funktion ausführt, ist wie folgt:

Java-Codesammlungscode
Paket com.nms.common.db;
importiere java.io.File;
importiere java.io.IOException;
importiere java.io.InputStream;
importiere java.util.Map;
importiere java.util.Properties;
importiere java.util.concurrent.ConcurrentHashMap;
importiere org.apache.commons.logging.Log;
importiere org.apache.commons.logging.LogFactory;
/**
* Für Datenbanksicherungsvorgänge
*/
öffentliche Klasse DbBackUpMethod {
privater statischer Loglogger = LogFactory.getLog(DbBackUpMethod.class);
private statische Eigenschaften pros = getPprVue("db.properties");
öffentliche statische Map<String, String> backUpTableList = neue ConcurrentHashMap<String, String>();
private statische DbBackUpMethod backObj = neue DbBackUpMethod();
öffentliche statische DbBackUpMethod getDbBackUpMethod(){
gib BackObj zurück;
}
öffentliche void Backup (String Tabellenname) {
wenn(null != backUpTableList.get(tableName)) return;
backUpTableList.put(tableName, tableName); // Als bereits für Backup verwendet markieren
neuer Thread(neuer DbBackUpThread(Tabellenname)).start();
}
/**
* Wird verwendet, um eine Sicherung einer Tabelle durchzuführen
*/
Klasse DbBackUpThread implementiert Runnable {
Zeichenfolge Tabellenname = null;
öffentliche DbBackUpThread(String tableName){
this.tableName = Tabellenname;
}
@Überschreiben
öffentliche Leere ausführen() {
versuchen {
String-Benutzername = pros.getProperty("Benutzername");
String-Passwort = pros.getProperty("Passwort");
Zeichenfolge mysqlpaths = pros.getProperty("mysqlpath");
Zeichenfolgeadresse = pros.getProperty("dbAddress");
String Datenbankname = pros.getProperty("Datenbankname");
Zeichenfolge sqlpath = pros.getProperty("sqlFilePath");
Datei Backupath = neue Datei (SQL-Pfad);
wenn (!backupath.exists()) {
Backupath.mkdir();
}
StringBuffer sb = neuer StringBuffer();
sb.append(mysqlpfade);
sb.append("mysqldump ");
sb.anhängen("--opt ");
sb.append("-h ");
sb.anhängen(Adresse);
sb.anhängen(" ");
sb.anhängen("--user=");
sb.append(Benutzername);
sb.anhängen(" ");
sb.append("--password=");
sb.append(Passwort);
sb.anhängen(" ");
sb.append("--lock-all-tables=true");
sb.append("--result-file=");
sb.append(sqlpfad);
sb.append(Tabellenname+".sql");
sb.anhängen(" ");
sb.append("--default-character-set=utf8");
sb.append(Datenbankname);
sb.anhängen(" ");
sb.append(Tabellenname);
Laufzeit cmd = Runtime.getRuntime();
Prozess p = cmd.exec(sb.toString());
p.waitFor(); // Mit dieser Anweisung wird markiert, dass der Thread weiter wartet, wenn die Sicherung nicht abgeschlossen ist
} Fang (Ausnahme e) {
logger.error("Beim Sicherungsvorgang ist ein Problem aufgetreten", e);
}Endlich{
backUpTableList.remove(tableName); // wird eventuell entfernt
}
}
}
öffentliche statische Eigenschaften getPprVue(String propertyName) {
InputStream inputStream = DbBackUpMethod.class.getClassLoader().getResourceAsStream(properName);
Eigenschaften p = neue Eigenschaften();
versuchen {
p.load(Eingabestream);
inputStream.schließen();
} Fang (IOException e) {
logger.error("Konfigurationsdatei für Sicherungsdaten konnte nicht gelesen werden", e);
}
Rückgabe p;
}
}

In Aktion können Sie die Methode für den Sicherungsvorgang direkt aufrufen:

Java-Codesammlungscode
DbBackUpMethod.getDbBackUpMethod().backup(tableName); // Backup aufrufen

Wenn die Seite über eine Operation zum Löschen der Tabelle verfügt, sollten Sie gleichzeitig feststellen, ob die Tabelle vor der Operation gesichert wird.

Java-Codesammlungscode
wenn(null != DbBackUpMethod.backUpTableList.get(tableName))

Wenn dann die Seiten-JSP aufgerufen wird, kann eine Antwortaufforderung ausgegeben werden. Meiner Einschätzung nach kann nur eine Tabelle gelöscht werden:

Funktion deleteTableByTableName(){
	var pk = table.getSelectedKeys();
	wenn(""==pk){
		alert("Bitte wählen Sie einen Datensatz aus!");
		gibt false zurück;
	}
	wenn(pk.length > 1){
		alert("Bitte wählen Sie einen Datensatz aus!");
		gibt false zurück;
	}
	var Zeilen = Tabelle.get(pk);
	var Tabellenname = Zeilen.Tabellenname;
	if(confirm("Möchten Sie diese Tabelle wirklich löschen?")) {
		if(confirm("Müssen Sie die Tabelle vor dem Löschen sichern?\n\nNachdem Sie die Sicherung ausgewählt haben, führt das System entsprechende Vorgänge im Hintergrund aus!\nWährend dieser Zeit können Sie die Tabelle nicht löschen!\nDer Sicherungsvorgang kann mehrere Stunden dauern! Bitte beachten Sie!"")) {
			document.form1.action="backUpTable.action?tableName=" + Tabellenname;
			Dokument.form1.submit();
		}anders{
			if(confirm("Sind Sie sicher, dass Sie den Vorgang absenden möchten? Die Tabelle wird gelöscht!")) {
				document.form1.action="del.action?tableName=" + Tabellenname;
				Dokument.form1.submit();
			}
		}
	}
}

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.