純java實現讀寫windows注冊表代碼

c6g3 9年前發布 | 3K 次閱讀 Java
java有一些類庫可以實現讀寫windows注冊表的方法，但是下面的類沒有引用任何現成的類庫，是純java實現的。
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.ArrayList;
import java.util.List;
import java.util.prefs.Preferences;
public class WinRegistry {
  public static final int HKEY_CURRENT_USER = 0x80000001;
  public static final int HKEY_LOCAL_MACHINE = 0x80000002;
  public static final int REG_SUCCESS = 0;
  public static final int REG_NOTFOUND = 2;
  public static final int REG_ACCESSDENIED = 5;
private static final int KEY_ALL_ACCESS = 0xf003f;
  private static final int KEY_READ = 0x20019;
  private static Preferences userRoot = Preferences.userRoot();
  private static Preferences systemRoot = Preferences.systemRoot();
  private static Class<? extends Preferences> userClass = userRoot.getClass();
  private static Method regOpenKey = null;
  private static Method regCloseKey = null;
  private static Method regQueryValueEx = null;
  private static Method regEnumValue = null;
  private static Method regQueryInfoKey = null;
  private static Method regEnumKeyEx = null;
  private static Method regCreateKeyEx = null;
  private static Method regSetValueEx = null;
  private static Method regDeleteKey = null;
  private static Method regDeleteValue = null;
static {
    try {
      regOpenKey = userClass.getDeclaredMethod("WindowsRegOpenKey",
          new Class[] { int.class, byte[].class, int.class });
      regOpenKey.setAccessible(true);
      regCloseKey = userClass.getDeclaredMethod("WindowsRegCloseKey",
          new Class[] { int.class });
      regCloseKey.setAccessible(true);
      regQueryValueEx = userClass.getDeclaredMethod("WindowsRegQueryValueEx",
          new Class[] { int.class, byte[].class });
      regQueryValueEx.setAccessible(true);
      regEnumValue = userClass.getDeclaredMethod("WindowsRegEnumValue",
          new Class[] { int.class, int.class, int.class });
      regEnumValue.setAccessible(true);
      regQueryInfoKey = userClass.getDeclaredMethod("WindowsRegQueryInfoKey1",
          new Class[] { int.class });
      regQueryInfoKey.setAccessible(true);
      regEnumKeyEx = userClass.getDeclaredMethod(

          "WindowsRegEnumKeyEx", new Class[] { int.class, int.class,

              int.class });

      regEnumKeyEx.setAccessible(true);
      regCreateKeyEx = userClass.getDeclaredMethod(

          "WindowsRegCreateKeyEx", new Class[] { int.class,

              byte[].class });

      regCreateKeyEx.setAccessible(true);

      regSetValueEx = userClass.getDeclaredMethod(

          "WindowsRegSetValueEx", new Class[] { int.class,

              byte[].class, byte[].class });

      regSetValueEx.setAccessible(true); 
      regDeleteValue = userClass.getDeclaredMethod(

          "WindowsRegDeleteValue", new Class[] { int.class,

              byte[].class });

      regDeleteValue.setAccessible(true); 
      regDeleteKey = userClass.getDeclaredMethod(

          "WindowsRegDeleteKey", new Class[] { int.class,

              byte[].class });

      regDeleteKey.setAccessible(true); 
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }
private WinRegistry() {  }
/**

Read a value from key and value name
@param hkey   HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
@param key
@param valueName
@return the value
@throws IllegalArgumentException
@throws IllegalAccessException
@throws InvocationTargetException
*/
public static String readString(int hkey, String key, String valueName) 
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
if (hkey == HKEY_LOCAL_MACHINE) {
 return readString(systemRoot, hkey, key, valueName);
}
else if (hkey == HKEY_CURRENT_USER) {
 return readString(userRoot, hkey, key, valueName);
}
else {
 throw new IllegalArgumentException("hkey=" + hkey);
}
}
/**

Read value(s) and value name(s) form given key 
@param hkey  HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
@param key
@return the value name(s) plus the value(s)
@throws IllegalArgumentException
@throws IllegalAccessException
@throws InvocationTargetException
*/
public static Map<String, String> readStringValues(int hkey, String key) 
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
if (hkey == HKEY_LOCAL_MACHINE) {
 return readStringValues(systemRoot, hkey, key);
}
else if (hkey == HKEY_CURRENT_USER) {
 return readStringValues(userRoot, hkey, key);
}
else {
 throw new IllegalArgumentException("hkey=" + hkey);
}
}
/**

Read the value name(s) from a given key
@param hkey  HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
@param key
@return the value name(s)
@throws IllegalArgumentException
@throws IllegalAccessException
@throws InvocationTargetException
*/
public static List<String> readStringSubKeys(int hkey, String key) 
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
if (hkey == HKEY_LOCAL_MACHINE) {
 return readStringSubKeys(systemRoot, hkey, key);
}
else if (hkey == HKEY_CURRENT_USER) {
 return readStringSubKeys(userRoot, hkey, key);
}
else {
 throw new IllegalArgumentException("hkey=" + hkey);
}
}
/**

Create a key
@param hkey  HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
@param key
@throws IllegalArgumentException
@throws IllegalAccessException
@throws InvocationTargetException
*/
public static void createKey(int hkey, String key) 
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
int [] ret;
if (hkey == HKEY_LOCAL_MACHINE) {
 ret = createKey(systemRoot, hkey, key);
 regCloseKey.invoke(systemRoot, new Object[] { new Integer(ret[0]) });
}
else if (hkey == HKEY_CURRENT_USER) {
 ret = createKey(userRoot, hkey, key);
 regCloseKey.invoke(userRoot, new Object[] { new Integer(ret[0]) });
}
else {
 throw new IllegalArgumentException("hkey=" + hkey);
}
if (ret[1] != REG_SUCCESS) {
 throw new IllegalArgumentException("rc=" + ret[1] + "  key=" + key);
}
}
/**

Write a value in a given key/value name
@param hkey
@param key
@param valueName
@param value
@throws IllegalArgumentException
@throws IllegalAccessException
@throws InvocationTargetException
*/
public static void writeStringValue
(int hkey, String key, String valueName, String value) 
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
if (hkey == HKEY_LOCAL_MACHINE) {
 writeStringValue(systemRoot, hkey, key, valueName, value);
}
else if (hkey == HKEY_CURRENT_USER) {
 writeStringValue(userRoot, hkey, key, valueName, value);
}
else {
 throw new IllegalArgumentException("hkey=" + hkey);
}
}
/**

Delete a given key
@param hkey
@param key
@throws IllegalArgumentException
@throws IllegalAccessException
@throws InvocationTargetException
*/
public static void deleteKey(int hkey, String key) 
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
int rc = -1;
if (hkey == HKEY_LOCAL_MACHINE) {
 rc = deleteKey(systemRoot, hkey, key);
}
else if (hkey == HKEY_CURRENT_USER) {
 rc = deleteKey(userRoot, hkey, key);
}
if (rc != REG_SUCCESS) {
 throw new IllegalArgumentException("rc=" + rc + "  key=" + key);
}
}
/**

delete a value from a given key/value name
@param hkey
@param key
@param value
@throws IllegalArgumentException
@throws IllegalAccessException
@throws InvocationTargetException
*/
public static void deleteValue(int hkey, String key, String value) 
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
int rc = -1;
if (hkey == HKEY_LOCAL_MACHINE) {
 rc = deleteValue(systemRoot, hkey, key, value);
}
else if (hkey == HKEY_CURRENT_USER) {
 rc = deleteValue(userRoot, hkey, key, value);
}
if (rc != REG_SUCCESS) {
 throw new IllegalArgumentException("rc=" + rc + "  key=" + key + "  value=" + value);
}
}
// =====================
private static int deleteValue
(Preferences root, int hkey, String key, String value)
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
   new Integer(hkey), toCstr(key), new Integer(KEY_ALL_ACCESS) });
if (handles[1] != REG_SUCCESS) {
 return handles[1];  // can be REG_NOTFOUND, REG_ACCESSDENIED
}
int rc =((Integer) regDeleteValue.invoke(root,

   new Object[] {

 new Integer(handles[0]), toCstr(value) 
 })).intValue();

regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
return rc;
}
private static int deleteKey(Preferences root, int hkey, String key) 
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
int rc =((Integer) regDeleteKey.invoke(root,

   new Object[] { new Integer(hkey), toCstr(key) })).intValue();
return rc;  // can REG_NOTFOUND, REG_ACCESSDENIED, REG_SUCCESS
}
private static String readString(Preferences root, int hkey, String key, String value)
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
   new Integer(hkey), toCstr(key), new Integer(KEY_READ) });
if (handles[1] != REG_SUCCESS) {
 return null; 
}
byte[] valb = (byte[]) regQueryValueEx.invoke(root, new Object[] {
   new Integer(handles[0]), toCstr(value) });
regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
return (valb != null ? new String(valb).trim() : null);
}
private static Map<String,String> readStringValues
(Preferences root, int hkey, String key)
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
HashMap<String, String> results = new HashMap<String,String>();
int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
   new Integer(hkey), toCstr(key), new Integer(KEY_READ) });
if (handles[1] != REG_SUCCESS) {
 return null;
}
int[] info = (int[]) regQueryInfoKey.invoke(root,
   new Object[] { new Integer(handles[0]) });
int count = info[0]; // count

int maxlen = info[3]; // value length max
for(int index=0; index<count; index++)  {
 byte[] name = (byte[]) regEnumValue.invoke(root, new Object[] {

 new Integer
   (handles[0]), new Integer(index), new Integer(maxlen + 1)});

String value = readString(hkey, key, new String(name));
 results.put(new String(name).trim(), value);
}
regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
return results;
}
private static List<String> readStringSubKeys
(Preferences root, int hkey, String key)
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
List<String> results = new ArrayList<String>();
int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
   new Integer(hkey), toCstr(key), new Integer(KEY_READ) 
   });
if (handles[1] != REG_SUCCESS) {
 return null;
}
int[] info = (int[]) regQueryInfoKey.invoke(root,
   new Object[] { new Integer(handles[0]) });
int count  = info[0]; // Fix: info[2] was being used here with wrong results. Suggested by davenpcj, confirmed by Petrucio
int maxlen = info[3]; // value length max
for(int index=0; index<count; index++)  {
 byte[] name = (byte[]) regEnumKeyEx.invoke(root, new Object[] {

 new Integer
   (handles[0]), new Integer(index), new Integer(maxlen + 1)
 });

results.add(new String(name).trim());
}
regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
return results;
}
private static int [] createKey(Preferences root, int hkey, String key)
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
return  (int[]) regCreateKeyEx.invoke(root,
   new Object[] { new Integer(hkey), toCstr(key) });
}
private static void writeStringValue 
(Preferences root, int hkey, String key, String valueName, String value) 
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException 
{
int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
   new Integer(hkey), toCstr(key), new Integer(KEY_ALL_ACCESS) });
regSetValueEx.invoke(root,

   new Object[] {

 new Integer(handles[0]), toCstr(valueName), toCstr(value) 
 }); 

regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
}
// utility
private static byte[] toCstr(String str) {
byte[] result = new byte[str.length() + 1];
for (int i = 0; i < str.length(); i++) {
 result[i] = (byte) str.charAt(i);
}
result[str.length()] = 0;
return result;
}
}</pre> 

 
 使用方法如下：  
String value = WinRegistry.readString (
WinRegistry.HKEY_LOCAL_MACHINE,                             //HKEY
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",           //Key
"ProductName");                                              //ValueName
System.out.println("Windows Distribution = " + value);
本文由用戶 c6g3 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。
轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。
本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！
本文地址：http://www.baiduhome.net/code/view/1424008434968
Java
純java實現讀寫windows注冊表代碼

相關代碼

相關文檔

相關經驗

目錄
