/**
* SharedPreferences 储存, key加密储存，value加密储存
*
* @author gb 2017/9/7.
*/
public class SPUtils {
/**
* 保存在手机里面的文件名
*/
private static final String FILE_NAME = "jump";
private static final int MODE = Context.MODE_PRIVATE;
private static Context mContext;
private SPUtils() {
throw new RuntimeException("SPUtils cannot be initialized!");
}
public static void init(Context context) {
mContext = context;
}
/**
* 保存数据的方法，我们需要拿到保存数据的具体类型，然后根据类型调用不同的保存方法
*
* @param key
* @param value
*/
public static void put(String key, String value) {
SharedPreferences sp = mContext.getSharedPreferences(FILE_NAME, MODE);
SharedPreferences.Editor editor = sp.edit();
String encryptKey = encryptKey(key);
String encryptValue = "";
try {
encryptValue = SPUtilsAES.encrypt(value);//加密结果
} catch (Exception e) {
LogUtils.d(e.toString());
encryptValue = value;
}
LogUtils.d("sp.put加密结果key：" + key + ",加密后结果key：" + encryptKey);
LogUtils.d("sp.put加密结果value：" + value + ",加密后结果value：" + encryptValue);
editor.putString(encryptKey, encryptValue);
SharedPreferencesCompat.apply(editor);
}
/**
* 保存数据
*
* @param list
* @return
*/
public static boolean putArray(List<String> list) {
SharedPreferences sp = mContext.getSharedPreferences(SPConstant.SP_TABLE_NAME, MODE);
SharedPreferences.Editor edit = sp.edit();
edit.putInt("Status_size", list.size());
for (int i = 0; i < list.size(); i++) {
edit.remove("Status_" + i);
edit.putString("Status_" + i, list.get(i));
}
return edit.commit();
}
/**
* 取出数据
*
* @return
*/
public static List<String> getArray() {
List<String> list = new ArrayList<>();
SharedPreferences sp = mContext.getSharedPreferences(SPConstant.SP_TABLE_NAME, MODE);
int size = sp.getInt("Status_size", 0);
for (int i = 0; i < size; i++) {
list.add(sp.getString("Status_" + i, null));
}
return list;
}
/**
* 得到保存数据的方法，我们根据默认值得到保存的数据的具体类型，然后调用相对于的方法获取值
*
* @param key
* @param defaultValue
* @return
*/
public static String get(String key, String defaultValue) {
defaultValue = (defaultValue == null) ? "" : defaultValue;
SharedPreferences sp = mContext.getSharedPreferences(FILE_NAME, MODE);
String encryptKey = encryptKey(key);
String decryString = sp.getString(encryptKey, defaultValue);
// 调用AES解密方法
try {
if (!defaultValue.equalsIgnoreCase(decryString)) {
decryString = SPUtilsAES.decrypt(decryString);
} else {
decryString = defaultValue;
}
} catch (Exception e) {
LogUtils.d(e.toString());
decryString = defaultValue;
}
LogUtils.d("sp.get（）key=" + key + "解密结果：" + decryString);
return decryString;
}
/**
* 移除某个key值已经对应的值
*
* @param key
*/
public static void remove(String key) {
key = encryptKey(key);
SharedPreferences sp = mContext.getSharedPreferences(FILE_NAME, MODE);
SharedPreferences.Editor editor = sp.edit();
editor.remove(key);
SharedPreferencesCompat.apply(editor);
}
/**
* 清除所有数据
*/
public static void clear() {
SharedPreferences sp = mContext.getSharedPreferences(FILE_NAME, MODE);
SharedPreferences.Editor editor = sp.edit();
editor.clear();
SharedPreferencesCompat.apply(editor);
}
/**
* 查询某个key是否已经存在
*
* @param key
* @return
*/
public static boolean contains(String key) {
key = encryptKey(key);
SharedPreferences sp = mContext.getSharedPreferences(FILE_NAME, MODE);
return sp.contains(key);
}
/**
* 返回所有的键值对
*
* @return
*/
public static Map<String, ?> getAll() {
SharedPreferences sp = mContext.getSharedPreferences(FILE_NAME, MODE);
return sp.getAll();
}
/**
* 创建一个解决SharedPreferencesCompat.apply方法的一个兼容类
*
* @author zhy
*/
private static class SharedPreferencesCompat {
private static final Method sApplyMethod = findApplyMethod();
/**
* 反射查找apply的方法
*
* @return
*/
@SuppressWarnings({"unchecked", "rawtypes"})
private static Method findApplyMethod() {
try {
Class clz = SharedPreferences.Editor.class;
return clz.getMethod("apply");
} catch (NoSuchMethodException e) {
}
return null;
}
/**
* 如果找到则使用apply执行，否则使用commit
*
* @param editor
*/
public static void apply(SharedPreferences.Editor editor) {
try {
if (sApplyMethod != null) {
sApplyMethod.invoke(editor);
return;
}
} catch (IllegalArgumentException e) {
} catch (IllegalAccessException e) {
} catch (InvocationTargetException e) {
}
editor.commit();
}
}
/**
* sp的key 加密
*
* @param key
* @return encryptKey
*/
private static String encryptKey(String key) {
String encryptKey = "";
try {
encryptKey = SPUtilsAES.encrypt(key);//加密结果
} catch (Exception e) {
LogUtils.d(e.toString());
encryptKey = key;
}
return encryptKey;
}
}
加密如下：
/**
* SPUtilsAES.加密
*/
public class SPUtilsAES {
public static final String masterPassword = "jump"; // 设置加密密匙
// public static void main(String[] args) throws Exception {
// // 设置加密密匙
// String masterPassword = "sad sad 说";
// // 设置原文
// String originalText = "微信啊显示";
// // 调用AES加密方法
// String encryptingCode = encrypt(originalText);
// System.out.println("加密结果：" + encryptingCode);
// // 调用AES解密方法
// String decryString = decrypt(encryptingCode);
// System.out.println("解密结果：" + decryString);
// }
// AES加密
// encryptText为要加密的内容
// seed为密匙
public static String encrypt(String encryptText)
throws Exception {
byte[] rawKey = getRawKey(masterPassword.getBytes());
byte[] result = encrypt(rawKey, encryptText.getBytes());
return toHex(result);
}
/**
* AES解密
* decryptText为需要解密的内容
* seed为密匙
*
* @param decryptText
* @return
* @throws Exception
*/
public static String decrypt(String decryptText)
throws Exception {
byte[] rawKey = getRawKey(masterPassword.getBytes());
byte[] enc = toByte(decryptText);
byte[] result = decrypt(rawKey, enc);
return new String(result);
}
// 加密
private static byte[] encrypt(byte[] raw, byte[] bytes) throws Exception {
// 生成一组扩展密匙，并放入一个数组之中
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
Cipher cipher = Cipher.getInstance("AES");
// 用ENCRYPT_MODE模式,用skeySpec密码组，生成AES加密方法
cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
// 得到加密数据
byte[] encrypted = cipher.doFinal(bytes);
return encrypted;
}
// 解密
private static byte[] decrypt(byte[] rawKey, byte[] enc) throws Exception {
// 生成一组扩展密匙，并放入一个数组之中
SecretKeySpec skeyKeySpec = new SecretKeySpec(rawKey, "AES");
Cipher cipher = Cipher.getInstance("AES");
// 用DECRYPT_MODE模式,用skeySpec密码组，生成AES解密方法
cipher.init(Cipher.DECRYPT_MODE, skeyKeySpec);
// 得到解密数据
byte[] decrypted = cipher.doFinal(enc);
return decrypted;
}
// 对密匙进行编码
private static byte[] getRawKey(byte[] bytes) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
//SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");==》 改成
// SecureRandom sr = SecureRandom.getInstance("SHA1PRNG", "Crypto");
SecureRandom sr = SecureRandom.getInstance("SHA1PRNG", new CryptoProvider());
sr.setSeed(bytes);
kgen.init(128, sr); // 192 and 256 bits may not be available
SecretKey skey = kgen.generateKey();
byte[] raw = skey.getEncoded();
return raw;
}
/**
* 7.0的手机版本，加密报错
*/
public static class CryptoProvider extends Provider {
/**
* Creates a Provider and puts parameters
*/
public CryptoProvider() {
super("Crypto", 1.0, "HARMONY (SHA1 digest; SecureRandom; SHA1withDSA signature)");
put("SecureRandom.SHA1PRNG",
"org.apache.harmony.security.provider.crypto.SHA1PRNG_SecureRandomImpl");
put("SecureRandom.SHA1PRNG ImplementedIn", "Software");
}
}
// 将十六进制字符串为十进制字符串
private static String fromHex(String hex) {
return new String(toByte(hex));
}
// 将十六进制字符串为十进制字节数组
private static byte[] toByte(String hex) {
int len = hex.length() / 2;
byte[] result = new byte[len];
for (int i = 0; i < len; i++) {
result[i] = Integer.valueOf(hex.substring(2 * i, 2 * i + 2), 16)
.byteValue();
}
return result;
}
// 把一个十进制字节数组转换成十六进制
private static String toHex(String txt) {
return toHex(txt.getBytes());
}
// 把一个十进制字节数组转换成十六进制
private static String toHex(byte[] buf) {
if (buf == null)
return "";
StringBuffer result = new StringBuffer(2 * buf.length);
for (int i = 0; i < buf.length; i++) {
appendHex(result, buf[i]);
}
return result.toString();
}
private final static String HEX = "0123456789ABCDEF";
private static void appendHex(StringBuffer result, byte b) {
result.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0X0f));
}
}