Einführung in diesen Abschnitt:
In diesem Abschnitt wird die zweite Möglichkeit zum Speichern von Benutzerdaten vorgestellt: die Verwendung von SharedPreferences (Speichern von Benutzereinstellungsparametern) zum Speichern von Daten. Wenn unsere App einige Benutzereinstellungsparameter speichern möchte, z. B. ob automatisch angemeldet werden soll, ob Konto und Passwort gemerkt werden sollen, ob nur unter WLAN eine Verbindung zum Netzwerk hergestellt werden soll usw., wäre die Verwendung einer Datenbank übertrieben! Wir bezeichnen die oben genannten Konfigurationsinformationen als Benutzereinstellungen, d. h. Einstellungen, die Benutzer bevorzugen, und diese Konfigurationsinformationen werden normalerweise in bestimmten Dateien gespeichert! Beispielsweise verwendet Windows ini-Dateien, während J2SE properties-Dateien und xml-Dateien verwendet, um Softwarekonfigurationsinformationen zu speichern; unter Android verwenden wir jedoch normalerweise eine leichtgewichtige Speicherklasse – SharedPreferences –, um Benutzereinstellungsparameter zu speichern! SharedPreferences verwendet ebenfalls xml-Dateien und speichert dann wie eine Map-Sammlung Daten in Form von Schlüssel-Wert-Paaren; wir müssen nur SharedPreferences' getXxx(name) aufrufen, um den entsprechenden Wert anhand des Schlüssels zu erhalten! Die Verwendung ist sehr praktisch!
1. Beispiel für die Verwendung von SharedPreferences:
Ablaufdiagramm zur Verwendung:

Beispiel für den Implementierungscode:
Screenshot des Laufeffekts:
Der Ablauf ist: Konto und Passwort eingeben, auf Anmelden klicken, die Informationen in der SharedPreference-Datei speichern, dann die App neu starten und sehen, dass die Daten bereits im Textfeld angezeigt werden.

Darüber hinaus können wir nach dem Speichern data/data/<package name> im Datei-Explorer öffnen und sehen, dass im Verzeichnis shared_prefs eine xml-Datei erzeugt wurde (da das N5 nicht gerootet ist, habe ich hier den vorherigen Screenshot gefunden):

Klicken Sie auf Exportieren auf den Desktop, um den Inhalt darin zu sehen:

Code-Implementierung:
Layoutdateiactivity_main.xmlschreiben:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MyActivity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="用户登陆" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="10dp"
android:text="请输入用户名" />
<EditText
android:id="@+id/editname"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="用户名" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="请输入密码" />
<EditText
android:id="@+id/editpasswd"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="密码"
android:inputType="textPassword" />
<Button
android:id="@+id/btnlogin"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="登录" />
</LinearLayout>
Eine einfache SP-Hilfsklasse schreiben:SharedHelper.java:
/**
* Created by Jay on 2015/9/2 0002.
*/
public class SharedHelper {
private Context mContext;
public SharedHelper() {
}
public SharedHelper(Context mContext) {
this.mContext = mContext;
}
//定义一个保存数据的方法
public void save(String username, String passwd) {
SharedPreferences sp = mContext.getSharedPreferences("mysp", Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
editor.putString("username", username);
editor.putString("passwd", passwd);
editor.commit();
Toast.makeText(mContext, "信息已写入SharedPreference中", Toast.LENGTH_SHORT).show();
}
//定义一个读取SP文件的方法
public Map<String, String> read() {
Map<String, String> data = new HashMap<String, String>();
SharedPreferences sp = mContext.getSharedPreferences("mysp", Context.MODE_PRIVATE);
data.put("username", sp.getString("username", ""));
data.put("passwd", sp.getString("passwd", ""));
return data;
}
}
Zum SchlussMainActivity.javadie zugehörige Logik implementieren:
public class MainActivity extends AppCompatActivity {
private EditText editname;
private EditText editpasswd;
private Button btnlogin;
private String strname;
private String strpasswd;
private SharedHelper sh;
private Context mContext;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mContext = getApplicationContext();
sh = new SharedHelper(mContext);
bindViews();
}
private void bindViews() {
editname = (EditText)findViewById(R.id.editname);
editpasswd = (EditText)findViewById(R.id.editpasswd);
btnlogin = (Button)findViewById(R.id.btnlogin);
btnlogin.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
strname = editname.getText().toString();
strpasswd = editpasswd.getText().toString();
sh.save(strname,strpasswd);
}
});
}
@Override
protected void onStart() {
super.onStart();
Map<String,String> data = sh.read();
editname.setText(data.get("username"));
editpasswd.setText(data.get("passwd"));
}
}
2. SharedPreferences anderer Anwendungen lesen
Kern:Holen Sie sich den Context anderer Apps, und dieser Context stellt die Schnittstelle für den Zugriff auf die globalen Informationen dieser App dar, und die eindeutige Kennung, die eine App bestimmt, ist ihr Paketname, daher können wir den Context der entsprechenden App über den Paketnamen abrufen. Ein weiterer zu beachtender Punkt ist: Die Voraussetzung dafür, ob SP-Dateien anderer Anwendungen gelesen oder geschrieben werden können, ist, ob die SP-Datei festgelegte Lese- oder Schreibberechtigungen hat. Diejenige, die wir oben mit MODE_PRIVATE erstellt haben, kann nicht gelesen oder geschrieben werden~ Das Lesen von Daten aus fremden SP ist also sehr schwierig. Außerdem sind einige wichtige Informationen, wie in SP gespeicherte Passwörter, normalerweise verschlüsselt, sodass man sie nur selbst schreiben und verwenden kann~ Später sprechen wir über die häufig verwendete MD5-Verschlüsselungsmethode!
Implementierungs-Flussdiagramm:

Codebeispiel:
Screenshot des Laufeffekts:

Code-Implementierung:
Wir legen den Vorgang des Lesens von SP in MainActivity.java ab. Nach dem Klicken auf die Schaltfläche liest es SP und zeigt es via Toast an:
public class MainActivity extends AppCompatActivity {
private Context othercontext;
private SharedPreferences sp;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button btnshow = (Button) findViewById(R.id.btnshow);
btnshow.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//获得第一个应用的包名,从而获得对应的Context,需要对异常进行捕获
try {
othercontext = createPackageContext("com.jay.sharedpreferencedemo", Context.CONTEXT_IGNORE_SECURITY);
} catch (PackageManager.NameNotFoundException e) {
e.printStackTrace();
}
//根据Context取得对应的SharedPreferences
sp = othercontext.getSharedPreferences("mysp", Context.MODE_WORLD_READABLE);
String name = sp.getString("username", "");
String passwd = sp.getString("passwd", "");
Toast.makeText(getApplicationContext(), "Demo1的SharedPreference存的\n用户名为:" + name + "\n密码为:" + passwd, Toast.LENGTH_SHORT).show();
}
});
}
}
3. Verwenden von MD5 zum Verschlüsseln wichtiger Daten in SharedPreference
Hehe, oben haben wir Konto und Passwort einfach so direkt in SP gespeichert. Wenn das Telefon nicht gerootet ist, können andere Anwendungen nicht darauf zugreifen. Wenn es gerootet ist, können die Daten von anderen Anwendungen abgerufen werden, und dann verursacht das einige Konsequenzen... das ist nicht unsere Schuld, haha, wer hat dir gesagt, du sollst rooten~ Wir übernehmen nicht die Schuld. So ist es! Aber als verantwortungsvoller APP-Entwickler können wir das nicht einfach so lassen, oder? Wir können einige Verschlüsselungsalgorithmen verwenden, um Benutzerpasswörter zu verschlüsseln. Außerdem verschlüsseln wir normalerweise das Passwort des Benutzers! Im Folgenden zeichne ich ein einfaches Diagramm, damit alle den Ablauf der Verschlüsselungsverarbeitung verstehen:
1. Einfacher Ablauf der Verschlüsselungsverarbeitung
Das Flussdiagramm ist wie folgt:

Analyse des Flussdiagramms:
- Schritt 11. Der Benutzer registriert ein Konto und ein Passwort. Nachdem Konto und Passwort validiert wurden (ob das Konto doppelt vorhanden ist, Passwortlänge > 6 usw.), sind Konto und Passwort gültig. Nach erfolgreicher Registrierung übermitteln wir das Konto an den Server, zusammen mit dem lokal verschlüsselten Passwort!
- Schritt 22. Die Serverseite speichert das vom Benutzer übermittelte Konto und das verschlüsselte Passwort in der serverseitigen Datenbank, das heißt, der Server speichert unser Klartextpasswort (Originalpasswort) nicht!
- Schritt 33. Zurück zur Client-Seite. Wenn die Registrierung oder Anmeldung erfolgreich ist und du das Konto und das Passwort in SP speichern möchtest, muss das gespeicherte Passwort ebenfalls einen Verschlüsselungsprozess durchlaufen! Das heißt, Klartextpasswort -> verschlüsseln, dann speichern! Wenn du es nicht speicherst, muss bei jeder Anfrage auch das Klartextpasswort einen Verschlüsselungsprozess durchlaufen, und dann muss mit dem verschlüsselten Passwort eine Anfrage an den Server gesendet werden!
- Schritt 44. Der Server überprüft das Konto und das verschlüsselte Passwort. Bei Erfolg weist er dem Client eine Sitzungskennung zu. Später kann der Client diese Sitzung verwenden, um auf zugehörige Dienste zuzugreifen, die vom Server bereitgestellt werden!
Hehe, verstanden? Es gibt viele Verschlüsselungsmethoden. Xiaozhu ist auf diesem Gebiet auch kein Experte. Die Verschlüsselungsmethode, die ich früher verwendet habe, ist die MD5-Verschlüsselung. In diesem Abschnitt wird die MD5-Verschlüsselung kurz vorgestellt und ihre Verwendung demonstriert~
2. Kurze Einführung in MD5:
1) Was zum Teufel ist MD5?:
Antwort: Message-Digest-Algorithmus MD5 (chinesischer Name: Message-Digest Algorithm Fifth Edition) ist eine weit verbreitete Hashfunktion im Bereich der Computersicherheit, um die Integrität von Nachrichten zu gewährleisten — zitiert aus Baidu Baike. Einfach gesagt, es ist ein Verschlüsselungsalgorithmus. Nachdem eine Zeichenkette, eine Datei oder ein komprimiertes Archiv mit MD5 verschlüsselt wurde, entsteht eine Zeichenkette mit einer festen Länge von 128 Bit! Diese Zeichenkette ist im Grunde einzigartig! Außerdem wissen wir alle, dass eine Hexadezimalziffer 4 Bit zur Darstellung benötigt, daher ist die entsprechende MD5-Zeichenkettenlänge: 128 / 4 = 32 Zeichen! Darüber hinaus sieht man vielleicht, dass einige MD5-Hashes 16 Zeichen haben; das sind einfach die 32-stelligen MD5-Codes, bei denen die ersten acht und die letzten acht Zeichen entfernt wurden! Glaubst du das nicht? Lass uns versuchen, bei Baidu zu suchen: md5 online decryption, der erste:http://www.cmd5.com/
2) Kann MD5 geknackt werden?
Antwort: MD5 ist irreversibel, das heißt, es gibt keinen entsprechenden Algorithmus, um den generierten MD5-Wert umzukehren und die ursprünglichen Daten zu erhalten! Außer natürlich durch Brute-Force-Knacken. Nach einer einfachen MD5-Verschlüsselung kann man MD5-Datenbanken durchsuchen~
3) Ist der MD5-Wert eindeutig?
Antwort: Nicht eindeutig. Ein ursprünglicher Datensatz entspricht nur einem MD5-Wert, aber ein MD5-Wert kann mehreren ursprünglichen Datensätzen entsprechen!
3. Beispiel einer MD5-Verschlüsselungsimplementierung:
Eigentlich gibt es online viele fertige MD5-Beispiele. Eine Baidu- oder Google-Suche liefert jede Menge. Hier stelle ich die MD5-Verschlüsselungs-Hilfsklasse bereit, die Xiaozhu verwendet!
Md5Util.java:
/**
* Created by Jay on 2015/9/2 0002.
*/
public class MD5 {
public static String getMD5(String content) {
try {
MessageDigest digest = MessageDigest.getInstance("MD5");
digest.update(content.getBytes());
return getHashString(digest);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return null;
}
private static String getHashString(MessageDigest digest) {
StringBuilder builder = new StringBuilder();
for (byte b : digest.digest()) {
builder.append(Integer.toHexString((b >> 4) & 0xf));
builder.append(Integer.toHexString(b & 0xf));
}
return builder.toString();
}
}
MainActivity.javaRufen Sie direkt die statische Methode getMD5 auf:
Log.e("HeHe", MD5.getMD5("呵呵"));
Wir können in Logcat sehen, dass ausgegeben wird:

Dies ist das verschlüsselte "hehe". Wir können diesen Geheimtext auf die oben genannte MD5-Online-Entschlüsselungswebsite kopieren:

Hehe, tatsächlich wird eine nur einmalige Verschlüsselung direkt geknackt. Das scheint etwas unsicher zu sein. Dann verschlüsseln wir 100 Mal. Das heißt, die verschlüsselte Zeichenkette erneut verschlüsseln, 100 Mal wiederholt. Auf der ursprünglichen Grundlage fügen wir eine Methode hinzu, um 100 Mal zu verschlüsseln:
public static String getMD5x100(String content){
String s1 = content;
for(int i = 0;i < 100;i++){
s1 = getMD5(s1);
}
return s1;
}
Dann rufen wir es auf und stellen fest, dass das Log Folgendes ausgibt:

Kopiere es auf die Website:

Na gut, eine erfolgreiche Angeberei~
4. SharedPreference-Hilfsklasse:
Jedes Mal müssen wir SP-bezogene Klassen selbst instanziieren, was definitiv mühsam ist. Hier ist eine SP-Hilfsklasse. Jeder kann sie in seine eigenen Projekte einfügen. Diese Hilfsklasse stammt aus dem Blog des Meisters Hongyang~
SPUtils.java
package com.jay.sharedpreferencedemo3;
import android.content.Context;
import android.content.SharedPreferences;
import java.util.Map;
/**
* Created by Jay on 2015/9/2 0002.
*/
public class SPUtils {
/**
* 保存在手机里的SP文件名
*/
public static final String FILE_NAME = "my_sp";
/**
* 保存数据
*/
public static void put(Context context, String key, Object obj) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
if (obj instanceof Boolean) {
editor.putBoolean(key, (Boolean) obj);
} else if (obj instanceof Float) {
editor.putFloat(key, (Float) obj);
} else if (obj instanceof Integer) {
editor.putInt(key, (Integer) obj);
} else if (obj instanceof Long) {
editor.putLong(key, (Long) obj);
} else {
editor.putString(key, (String) obj);
}
editor.commit();
}
/**
* 获取指定数据
*/
public static Object get(Context context, String key, Object defaultObj) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, context.MODE_PRIVATE);
if (defaultObj instanceof Boolean) {
return sp.getBoolean(key, (Boolean) defaultObj);
} else if (defaultObj instanceof Float) {
return sp.getFloat(key, (Float) defaultObj);
} else if (defaultObj instanceof Integer) {
return sp.getInt(key, (Integer) defaultObj);
} else if (defaultObj instanceof Long) {
return sp.getLong(key, (Long) defaultObj);
} else if (defaultObj instanceof String) {
return sp.getString(key, (String) defaultObj);
}
return null;
}
/**
* 删除指定数据
*/
public static void remove(Context context, String key) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
editor.remove(key);
editor.commit();
}
/**
* 返回所有键值对
*/
public static Map<String, ?> getAll(Context context) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, context.MODE_PRIVATE);
Map<String, ?> map = sp.getAll();
return map;
}
/**
* 删除所有数据
*/
public static void clear(Context context) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
editor.clear();
editor.commit();
}
/**
* 检查key对应的数据是否存在
*/
public static boolean contains(Context context, String key) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, context.MODE_PRIVATE);
return sp.contains(key);
}
}
5. Code-Download:
SharedPreferenceDemo.zip:Download SharedPreferenceDemo.zip SharedPreferenceDemo2.zip:Download SharedPreferenceDemo2.zip SharedPreferenceDemo3.zip:Download SharedPreferenceDemo3.zip
Zusammenfassung dieses Abschnitts:
Also gut, das war alles über die zweite Möglichkeit, Daten in Android zu speichern: SharedPreference zum Speichern von Benutzerpräferenzparametern. Es sollte deinen täglichen Entwicklungsbedarf bei der Verwendung von SP decken. Falls etwas fehlt, weise bitte gerne darauf hin. Danke~
