使用 Java 读取/写入 Windows 注册表
[英]Read/write to Windows registry using Java
问题描述
How is it possible to read/write to the Windows registry using Java?
如何使用 Java 读取/写入 Windows 注册表？
25 个解决方案
解决方案1
336 2011-05-28 18:42:28
I know this question is old, but it is the first search result on google to "java read/write to registry".我知道这个问题很老，但它是谷歌上“java读/写注册表”的第一个搜索结果。 Recently I found this amazing piece of code which:最近我发现了这段惊人的代码：
- Can read/write to ANY part of the registry.可以读/写注册表的任何部分。
- DOES NOT USE JNI.不使用 JNI。
- DOES NOT USE ANY 3rd PARTY/EXTERNAL APPLICATIONS TO WORK.不使用任何第 3 方/外部应用程序工作。
- DOES NOT USE THE WINDOWS API (directly)不使用 WINDOWS API（直接）
This is pure, Java code.这是纯粹的，Java代码。
It uses reflection to work, by actually accessing the private methods in the java.util.prefs.Preferences class.它使用反射来工作，通过实际访问java.util.prefs.Preferences class 中的私有方法。 The internals of this class are complicated, but the class itself is very easy to use.这个 class 的内部结构很复杂，但 class 本身非常易于使用。
For example, the following code obtains the exact windows distribution from the registry :例如，以下代码从注册表中获取准确的 windows 分布：
String value = WinRegistry.readString (
WinRegistry.HKEY_LOCAL_MACHINE, //HKEY
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", //Key
"ProductName"); //ValueName
System.out.println("Windows Distribution = " + value);
Here is the original class.这是原始的 class。 Just copy paste it and it should work:只需复制粘贴它，它应该可以工作：
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 final Preferences userRoot = Preferences.userRoot();
private static final Preferences systemRoot = Preferences.systemRoot();
private static final Class<? extends Preferences> userClass = userRoot.getClass();
private static final Method regOpenKey;
private static final Method regCloseKey;
private static final Method regQueryValueEx;
private static final Method regEnumValue;
private static final Method regQueryInfoKey;
private static final Method regEnumKeyEx;
private static final Method regCreateKeyEx;
private static final Method regSetValueEx;
private static final Method regDeleteKey;
private static final Method regDeleteValue;
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) {
throw new RuntimeException(e);
}
}
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;
}
}
Original Author: Apache.原作者：Apache。
Library Source: https://github.com/apache/npanday/tree/trunk/components/dotnet-registry/src/main/java/npanday/registry库来源： https://github.com/apache/npanday/tree/trunk/components/dotnet-registry/src/main/java/npanday/registry
解决方案2
134 2009-12-30 19:40:51
You don't actually need a 3rd party package.您实际上并不需要第 3 方 package。 Windows has a reg utility for all registry operations. Windows 具有用于所有注册表操作的 reg 实用程序。 To get the command format, go to the DOS propmt and type:要获取命令格式，go 到 DOS 属性并键入：
reg /?
You can invoke reg through the Runtime class:您可以通过运行时 class 调用reg ：
Runtime.getRuntime().exec("reg <your parameters here>");
Editing keys and adding new ones is straightforward using the command above.使用上面的命令可以直接编辑键和添加新键。 To read the registry, you need to get reg 's output, and it's a little tricky.要读取注册表，需要获取reg的 output，这有点棘手。 Here's the code:这是代码：
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
/**
* @author Oleg Ryaboy, based on work by Miguel Enriquez
*/
public class WindowsReqistry {
/**
*
* @param location path in the registry
* @param key registry key
* @return registry value or null if not found
*/
public static final String readRegistry(String location, String key){
try {
// Run reg query, then read output with StreamReader (internal class)
Process process = Runtime.getRuntime().exec("reg query " +
'"'+ location + "\" /v " + key);
StreamReader reader = new StreamReader(process.getInputStream());
reader.start();
process.waitFor();
reader.join();
String output = reader.getResult();
// Output has the following format:
// \n<Version information>\n\n<key>\t<registry type>\t<value>
if( ! output.contains("\t")){
return null;
}
// Parse out the value
String[] parsed = output.split("\t");
return parsed[parsed.length-1];
}
catch (Exception e) {
return null;
}
}
static class StreamReader extends Thread {
private InputStream is;
private StringWriter sw= new StringWriter();
public StreamReader(InputStream is) {
this.is = is;
}
public void run() {
try {
int c;
while ((c = is.read()) != -1)
sw.write(c);
}
catch (IOException e) {
}
}
public String getResult() {
return sw.toString();
}
}
public static void main(String[] args) {
// Sample usage
String value = WindowsReqistry.readRegistry("HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\"
+ "Explorer\\Shell Folders", "Personal");
System.out.println(value);
}
}
解决方案3
77 2011-06-09 03:19:59
Java Native Access (JNA) is an excellent project for working with native libraries and has support for the Windows registry in the platform library (platform.jar) through Advapi32Util and Advapi32 .Java Native Access (JNA)是使用原生库的优秀项目，并通过Advapi32Util和Advapi32支持平台库 (platform.jar) 中的 Windows 注册表。
Update: Here's a snippet with some examples of how easy it is to use JNA to work with the Windows registry using JNA 3.4.1,更新：这是一个片段，其中包含一些示例，说明使用 JNA 使用 JNA 3.4.1 与 Windows 注册表一起工作是多么容易，
import com.sun.jna.platform.win32.Advapi32Util;
import com.sun.jna.platform.win32.WinReg;
public class WindowsRegistrySnippet {
public static void main(String[] args) {
// Read a string
String productName = Advapi32Util.registryGetStringValue(
WinReg.HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "ProductName");
System.out.printf("Product Name: %s\n", productName);
// Read an int (& 0xFFFFFFFFL for large unsigned int)
int timeout = Advapi32Util.registryGetIntValue(
WinReg.HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Windows", "ShutdownWarningDialogTimeout");
System.out.printf("Shutdown Warning Dialog Timeout: %d (%d as unsigned long)\n", timeout, timeout & 0xFFFFFFFFL);
// Create a key and write a string
Advapi32Util.registryCreateKey(WinReg.HKEY_CURRENT_USER, "SOFTWARE\\StackOverflow");
Advapi32Util.registrySetStringValue(WinReg.HKEY_CURRENT_USER, "SOFTWARE\\StackOverflow", "url", "http://stackoverflow.com/a/6287763/277307");
// Delete a key
Advapi32Util.registryDeleteKey(WinReg.HKEY_CURRENT_USER, "SOFTWARE\\StackOverflow");
}
}
解决方案4
27 2012-08-07 22:15:55
I've incremented the Pure java code originally posted by David to allow acessing the 32-bits section of the registry from a 64-bit JVM, and vice-versa.我增加了最初由 David 发布的 Pure java 代码，以允许从 64 位 JVM 访问注册表的 32 位部分，反之亦然。 I don't think any of the other answers address this.我认为其他任何答案都没有解决这个问题。
Here it is:这里是：
/**
* Pure Java Windows Registry access.
* Modified by petrucio@stackoverflow(828681) to add support for
* reading (and writing but not creating/deleting keys) the 32-bits
* registry view from a 64-bits JVM (KEY_WOW64_32KEY)
* and 64-bits view from a 32-bits JVM (KEY_WOW64_64KEY).
*****************************************************************************/
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;
public static final int KEY_WOW64_32KEY = 0x0200;
public static final int KEY_WOW64_64KEY = 0x0100;
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
* @param wow64 0 for standard registry access (32-bits for 32-bit app, 64-bits for 64-bits app)
* or KEY_WOW64_32KEY to force access to 32-bit registry view,
* or KEY_WOW64_64KEY to force access to 64-bit registry view
* @return the value
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static String readString(int hkey, String key, String valueName, int wow64)
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException
{
if (hkey == HKEY_LOCAL_MACHINE) {
return readString(systemRoot, hkey, key, valueName, wow64);
}
else if (hkey == HKEY_CURRENT_USER) {
return readString(userRoot, hkey, key, valueName, wow64);
}
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
* @param wow64 0 for standard registry access (32-bits for 32-bit app, 64-bits for 64-bits app)
* or KEY_WOW64_32KEY to force access to 32-bit registry view,
* or KEY_WOW64_64KEY to force access to 64-bit registry view
* @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, int wow64)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException
{
if (hkey == HKEY_LOCAL_MACHINE) {
return readStringValues(systemRoot, hkey, key, wow64);
}
else if (hkey == HKEY_CURRENT_USER) {
return readStringValues(userRoot, hkey, key, wow64);
}
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
* @param wow64 0 for standard registry access (32-bits for 32-bit app, 64-bits for 64-bits app)
* or KEY_WOW64_32KEY to force access to 32-bit registry view,
* or KEY_WOW64_64KEY to force access to 64-bit registry view
* @return the value name(s)
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static List<String> readStringSubKeys(int hkey, String key, int wow64)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException
{
if (hkey == HKEY_LOCAL_MACHINE) {
return readStringSubKeys(systemRoot, hkey, key, wow64);
}
else if (hkey == HKEY_CURRENT_USER) {
return readStringSubKeys(userRoot, hkey, key, wow64);
}
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
* @param wow64 0 for standard registry access (32-bits for 32-bit app, 64-bits for 64-bits app)
* or KEY_WOW64_32KEY to force access to 32-bit registry view,
* or KEY_WOW64_64KEY to force access to 64-bit registry view
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static void writeStringValue
(int hkey, String key, String valueName, String value, int wow64)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException
{
if (hkey == HKEY_LOCAL_MACHINE) {
writeStringValue(systemRoot, hkey, key, valueName, value, wow64);
}
else if (hkey == HKEY_CURRENT_USER) {
writeStringValue(userRoot, hkey, key, valueName, value, wow64);
}
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
* @param wow64 0 for standard registry access (32-bits for 32-bit app, 64-bits for 64-bits app)
* or KEY_WOW64_32KEY to force access to 32-bit registry view,
* or KEY_WOW64_64KEY to force access to 64-bit registry view
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static void deleteValue(int hkey, String key, String value, int wow64)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException
{
int rc = -1;
if (hkey == HKEY_LOCAL_MACHINE) {
rc = deleteValue(systemRoot, hkey, key, value, wow64);
}
else if (hkey == HKEY_CURRENT_USER) {
rc = deleteValue(userRoot, hkey, key, value, wow64);
}
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, int wow64)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException
{
int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
new Integer(hkey), toCstr(key), new Integer(KEY_ALL_ACCESS | wow64)
});
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, int wow64)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException
{
int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
new Integer(hkey), toCstr(key), new Integer(KEY_READ | wow64)
});
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, int wow64)
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 | wow64)
});
if (handles[1] != REG_SUCCESS) {
return null;
}
int[] info = (int[]) regQueryInfoKey.invoke(root, new Object[] {
new Integer(handles[0])
});
int count = info[2]; // 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), wow64);
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, int wow64)
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 | wow64)
});
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, int wow64)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException
{
int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
new Integer(hkey), toCstr(key), new Integer(KEY_ALL_ACCESS | wow64)
});
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;
}
}
解决方案5
23 2008-09-15 14:10:46
I've done this before using jRegistryKey .我在使用jRegistryKey之前已经这样做了。 It is an LGPL Java/JNI library that can do what you need.它是一个 LGPL Java/JNI 库，可以满足您的需求。 Here's an example of how I used it to enabled Registry editing through regedit and also the "Show Folder Options" option for myself in Windows via the registry.这是我如何使用它通过 regedit 启用注册表编辑的示例，以及通过注册表在 Windows 中为我自己启用“显示文件夹选项”选项的示例。
import java.io.File;
import ca.beq.util.win32.registry.RegistryKey;
import ca.beq.util.win32.registry.RegistryValue;
import ca.beq.util.win32.registry.RootKey;
import ca.beq.util.win32.registry.ValueType;
public class FixStuff {
private static final String REGEDIT_KEY = "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System";
private static final String REGEDIT_VALUE = "DisableRegistryTools";
private static final String REGISTRY_LIBRARY_PATH = "\\lib\\jRegistryKey.dll";
private static final String FOLDER_OPTIONS_KEY = "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer";
private static final String FOLDER_OPTIONS_VALUE = "NoFolderOptions";
public static void main(String[] args) {
//Load JNI library
RegistryKey.initialize( new File(".").getAbsolutePath()+REGISTRY_LIBRARY_PATH );
enableRegistryEditing(true);
enableShowFolderOptions(true);
}
private static void enableShowFolderOptions(boolean enable) {
RegistryKey key = new RegistryKey(RootKey.HKEY_CURRENT_USER,FOLDER_OPTIONS_KEY);
RegistryKey key2 = new RegistryKey(RootKey.HKEY_LOCAL_MACHINE,FOLDER_OPTIONS_KEY);
RegistryValue value = new RegistryValue();
value.setName(FOLDER_OPTIONS_VALUE);
value.setType(ValueType.REG_DWORD_LITTLE_ENDIAN);
value.setData(enable?0:1);
if(key.hasValue(FOLDER_OPTIONS_VALUE)) {
key.setValue(value);
}
if(key2.hasValue(FOLDER_OPTIONS_VALUE)) {
key2.setValue(value);
}
}
private static void enableRegistryEditing(boolean enable) {
RegistryKey key = new RegistryKey(RootKey.HKEY_CURRENT_USER,REGEDIT_KEY);
RegistryValue value = new RegistryValue();
value.setName(REGEDIT_VALUE);
value.setType(ValueType.REG_DWORD_LITTLE_ENDIAN);
value.setData(enable?0:1);
if(key.hasValue(REGEDIT_VALUE)) {
key.setValue(value);
}
}
}
解决方案6
21 2008-09-15 12:18:30
Yes, using the java.util.Preferences API, since the Windows implementation of it uses the Registry as a backend.是的，使用 java.util.Preferences API，因为它的 Windows 实现使用注册表作为后端。
In the end it depends on what you're wanting to do: storing preferences for your app is what the Preferences does just great.最后，这取决于您想要做什么：为您的应用程序存储首选项是首选项所做的非常棒的事情。 If you're wanting to actually change registry keys not having to do with your app, you'll need some JNI app, as described by Mark (shameless steal here):如果您想实际更改与您的应用程序无关的注册表项，则需要一些 JNI 应用程序，如 Mark 所述（此处无耻窃取）：
From a quick google: Check the WinPack for JNIWrapper.
The WinPack Demo has Registry Viewer implemented as an example.
Check at http://www.teamdev.com/jniwrapper/winpack/#registry_access
And...
There is also try JNIRegistry @ http://www.trustice.com/java/jnireg/
There is also the option of invoking an external app, which is responsible for reading / writing the registry.
解决方案7
11 2008-09-15 12:20:09
From a quick google:从快速谷歌：
Check the WinPack for JNIWrapper.
The WinPack Demo has Registry Viewer implemented as an example.
Check at http://www.teamdev.com/jniwrapper/winpack/#registry_access
And...和...
There is also try JNIRegistry @ http://www.trustice.com/java/jnireg/
There is also the option of invoking an external app, which is responsible for reading / writing the registry.还有调用外部应用程序的选项，该应用程序负责读取/写入注册表。
解决方案8
10 2011-05-05 17:57:35
Here's a modified version of Oleg's solution.这是 Oleg 解决方案的修改版本。 I noticed that on my system (Windows server 2003), the output of "reg query" is not separated by tabs ('\t'), but by 4 spaces.我注意到在我的系统（Windows server 2003）上，“reg query”的 output 不是由制表符（'\t'）分隔，而是由 4 个空格分隔。
I also simplified the solution, as a thread is not required.我还简化了解决方案，因为不需要线程。
public static final String readRegistry(String location, String key)
{
try
{
// Run reg query, then read output with StreamReader (internal class)
Process process = Runtime.getRuntime().exec("reg query " +
'"'+ location + "\" /v " + key);
InputStream is = process.getInputStream();
StringBuilder sw = new StringBuilder();
try
{
int c;
while ((c = is.read()) != -1)
sw.append((char)c);
}
catch (IOException e)
{
}
String output = sw.toString();
// Output has the following format:
// \n<Version information>\n\n<key> <registry type> <value>\r\n\r\n
int i = output.indexOf("REG_SZ");
if (i == -1)
{
return null;
}
sw = new StringBuilder();
i += 6; // skip REG_SZ
// skip spaces or tabs
for (;;)
{
if (i > output.length())
break;
char c = output.charAt(i);
if (c != ' ' && c != '\t')
break;
++i;
}
// take everything until end of line
for (;;)
{
if (i > output.length())
break;
char c = output.charAt(i);
if (c == '\r' || c == '\n')
break;
sw.append(c);
++i;
}
return sw.toString();
}
catch (Exception e)
{
return null;
}
} }
解决方案9
8 2016-02-21 03:43:34
Thanks to original post.感谢原帖。 I have reskinned this utility class and come up over the flaws which it had earlier, thought it might help others so posting here.我重新设计了这个实用程序 class 并提出了它之前的缺陷，认为它可能会帮助其他人，所以在这里发布。 I have also added some extra utility methods.我还添加了一些额外的实用方法。 Now it is able to read any file in windows registry(including REG_DWORD, REG_BINARY, REG_EXPAND_SZ etc.).现在它可以读取 windows 注册表中的任何文件（包括 REG_DWORD、REG_BINARY、REG_EXPAND_SZ 等）。 All the methods work like a charm.所有方法都像魅力一样起作用。 Just copy and paste it and it should work.只需复制并粘贴它，它应该可以工作。 Here is the reskinned and modified class:这是重新设计和修改的 class：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
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.StringTokenizer;
import java.util.prefs.Preferences;
public class WinRegistry {
private static final int REG_SUCCESS = 0;
private static final int REG_NOTFOUND = 2;
private static final int KEY_READ = 0x20019;
private static final int REG_ACCESSDENIED = 5;
private static final int KEY_ALL_ACCESS = 0xf003f;
public static final int HKEY_CLASSES_ROOT = 0x80000000;
public static final int HKEY_CURRENT_USER = 0x80000001;
public static final int HKEY_LOCAL_MACHINE = 0x80000002;
private static final String CLASSES_ROOT = "HKEY_CLASSES_ROOT";
private static final String CURRENT_USER = "HKEY_CURRENT_USER";
private static final String LOCAL_MACHINE = "HKEY_LOCAL_MACHINE";
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();
}
}
/**
* Reads value for the key from given path
* @param hkey HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
* @param path
* @param key
* @return the value
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws IOException
*/
public static String valueForKey(int hkey, String path, String key)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, IOException {
if (hkey == HKEY_LOCAL_MACHINE)
return valueForKey(systemRoot, hkey, path, key);
else if (hkey == HKEY_CURRENT_USER)
return valueForKey(userRoot, hkey, path, key);
else
return valueForKey(null, hkey, path, key);
}
/**
* Reads all key(s) and value(s) from given path
* @param hkey HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
* @param path
* @return the map of key(s) and corresponding value(s)
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws IOException
*/
public static Map<String, String> valuesForPath(int hkey, String path)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, IOException {
if (hkey == HKEY_LOCAL_MACHINE)
return valuesForPath(systemRoot, hkey, path);
else if (hkey == HKEY_CURRENT_USER)
return valuesForPath(userRoot, hkey, path);
else
return valuesForPath(null, hkey, path);
}
/**
* Read all the subkey(s) from a given path
* @param hkey HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
* @param path
* @return the subkey(s) list
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static List<String> subKeysForPath(int hkey, String path)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
if (hkey == HKEY_LOCAL_MACHINE)
return subKeysForPath(systemRoot, hkey, path);
else if (hkey == HKEY_CURRENT_USER)
return subKeysForPath(userRoot, hkey, path);
else
return subKeysForPath(null, hkey, path);
}
/**
* 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 valueForKey(Preferences root, int hkey, String path, String key)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, IOException {
int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {new Integer(hkey), toCstr(path), new Integer(KEY_READ)});
if (handles[1] != REG_SUCCESS)
throw new IllegalArgumentException("The system can not find the specified path: '"+getParentKey(hkey)+"\\"+path+"'");
byte[] valb = (byte[]) regQueryValueEx.invoke(root, new Object[] {new Integer(handles[0]), toCstr(key)});
regCloseKey.invoke(root, new Object[] {new Integer(handles[0])});
return (valb != null ? parseValue(valb) : queryValueForKey(hkey, path, key));
}
private static String queryValueForKey(int hkey, String path, String key) throws IOException {
return queryValuesForPath(hkey, path).get(key);
}
private static Map<String,String> valuesForPath(Preferences root, int hkey, String path)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, IOException {
HashMap<String, String> results = new HashMap<String,String>();
int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {new Integer(hkey), toCstr(path), new Integer(KEY_READ)});
if (handles[1] != REG_SUCCESS)
throw new IllegalArgumentException("The system can not find the specified path: '"+getParentKey(hkey)+"\\"+path+"'");
int[] info = (int[]) regQueryInfoKey.invoke(root, new Object[] {new Integer(handles[0])});
int count = info[2]; // Fixed: info[0] was being used here
int maxlen = info[4]; // while info[3] was being used here, causing wrong results
for(int index=0; index<count; index++) {
byte[] valb = (byte[]) regEnumValue.invoke(root, new Object[] {new Integer(handles[0]), new Integer(index), new Integer(maxlen + 1)});
String vald = parseValue(valb);
if(valb == null || vald.isEmpty())
return queryValuesForPath(hkey, path);
results.put(vald, valueForKey(root, hkey, path, vald));
}
regCloseKey.invoke(root, new Object[] {new Integer(handles[0])});
return results;
}
/**
* Searches recursively into the path to find the value for key. This method gives
* only first occurrence value of the key. If required to get all values in the path
* recursively for this key, then {@link #valuesForKeyPath(int hkey, String path, String key)}
* should be used.
* @param hkey
* @param path
* @param key
* @param list
* @return the value of given key obtained recursively
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws IOException
*/
public static String valueForKeyPath(int hkey, String path, String key)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, IOException {
String val;
try {
val = valuesForKeyPath(hkey, path, key).get(0);
} catch(IndexOutOfBoundsException e) {
throw new IllegalArgumentException("The system can not find the key: '"+key+"' after "
+ "searching the specified path: '"+getParentKey(hkey)+"\\"+path+"'");
}
return val;
}
/**
* Searches recursively into given path for particular key and stores obtained value in list
* @param hkey
* @param path
* @param key
* @param list
* @return list containing values for given key obtained recursively
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws IOException
*/
public static List<String> valuesForKeyPath(int hkey, String path, String key)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, IOException {
List<String> list = new ArrayList<String>();
if (hkey == HKEY_LOCAL_MACHINE)
return valuesForKeyPath(systemRoot, hkey, path, key, list);
else if (hkey == HKEY_CURRENT_USER)
return valuesForKeyPath(userRoot, hkey, path, key, list);
else
return valuesForKeyPath(null, hkey, path, key, list);
}
private static List<String> valuesForKeyPath(Preferences root, int hkey, String path, String key, List<String> list)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, IOException {
if(!isDirectory(root, hkey, path)) {
takeValueInListForKey(hkey, path, key, list);
} else {
List<String> subKeys = subKeysForPath(root, hkey, path);
for(String subkey: subKeys) {
String newPath = path+"\\"+subkey;
if(isDirectory(root, hkey, newPath))
valuesForKeyPath(root, hkey, newPath, key, list);
takeValueInListForKey(hkey, newPath, key, list);
}
}
return list;
}
/**
* Takes value for key in list
* @param hkey
* @param path
* @param key
* @param list
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws IOException
*/
private static void takeValueInListForKey(int hkey, String path, String key, List<String> list)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, IOException {
String value = valueForKey(hkey, path, key);
if(value != null)
list.add(value);
}
/**
* Checks if the path has more subkeys or not
* @param root
* @param hkey
* @param path
* @return true if path has subkeys otherwise false
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
private static boolean isDirectory(Preferences root, int hkey, String path)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
return !subKeysForPath(root, hkey, path).isEmpty();
}
private static List<String> subKeysForPath(Preferences root, int hkey, String path)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
List<String> results = new ArrayList<String>();
int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {new Integer(hkey), toCstr(path), new Integer(KEY_READ)});
if (handles[1] != REG_SUCCESS)
throw new IllegalArgumentException("The system can not find the specified path: '"+getParentKey(hkey)+"\\"+path+"'");
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[] valb = (byte[]) regEnumKeyEx.invoke(root, new Object[] {new Integer(handles[0]), new Integer(index), new Integer(maxlen + 1)});
results.add(parseValue(valb));
}
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])});
}
/**
* Makes cmd query for the given hkey and path then executes the query
* @param hkey
* @param path
* @return the map containing all results in form of key(s) and value(s) obtained by executing query
* @throws IOException
*/
private static Map<String, String> queryValuesForPath(int hkey, String path) throws IOException {
String line;
StringBuilder builder = new StringBuilder();
Map<String, String> map = new HashMap<String, String>();
Process process = Runtime.getRuntime().exec("reg query \""+getParentKey(hkey)+"\\" + path + "\"");
BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
while((line = reader.readLine()) != null) {
if(!line.contains("REG_"))
continue;
StringTokenizer tokenizer = new StringTokenizer(line, " \t");
while(tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken();
if(token.startsWith("REG_"))
builder.append("\t ");
else
builder.append(token).append(" ");
}
String[] arr = builder.toString().split("\t");
map.put(arr[0].trim(), arr[1].trim());
builder.setLength(0);
}
return map;
}
/**
* Determines the string equivalent of hkey
* @param hkey
* @return string equivalent of hkey
*/
private static String getParentKey(int hkey) {
if(hkey == HKEY_CLASSES_ROOT)
return CLASSES_ROOT;
else if(hkey == HKEY_CURRENT_USER)
return CURRENT_USER;
else if(hkey == HKEY_LOCAL_MACHINE)
return LOCAL_MACHINE;
return null;
}
/**
*Intern method which adds the trailing \0 for the handle with java.dll
* @param str String
* @return byte[]
*/
private static byte[] toCstr(String str) {
if(str == null)
str = "";
return (str += "\0").getBytes();
}
/**
* Method removes the trailing \0 which is returned from the java.dll (just if the last sign is a \0)
* @param buf the byte[] buffer which every read method returns
* @return String a parsed string without the trailing \0
*/
private static String parseValue(byte buf[]) {
if(buf == null)
return null;
String ret = new String(buf);
if(ret.charAt(ret.length()-1) == '\0')
return ret.substring(0, ret.length()-1);
return ret;
}
}
Sample of using the methods is as follows:使用方法示例如下：
Below method retrieves the value of the key from the given path:下面的方法从给定的路径中检索键的值：
String hex = WinRegistry.valueForKey(WinRegistry.HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\WindowsUpdate\\Auto Update", "AUOptions");
This method retrieves all data for the specified path(in form of keys and values):此方法检索指定路径的所有数据（以键和值的形式）：
Map<String, String> map = WinRegistry.valuesForPath(WinRegistry.HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\WSMAN");
This method retrieves value recursively for the key from the given path:此方法从给定路径中递归检索键的值：
String val = WinRegistry.valueForKeyPath(WinRegistry.HKEY_LOCAL_MACHINE, "System", "TypeID");
and this one retrieves all values recursively for a key from the given path:这个从给定路径中递归检索键的所有值：
List<String> list = WinRegistry.valuesForKeyPath(
WinRegistry.HKEY_LOCAL_MACHINE, //HKEY "SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall", //path "DisplayName" //Key
);
Here in above code I retrieved all installed software names in windows system.在上面的代码中，我检索了 windows 系统中所有已安装的软件名称。
Note: See the documentation of these methods注意：请参阅这些方法的文档
And this one retrieves all subkeys of the given path:这个检索给定路径的所有子键：
List<String> list3 = WinRegistry.subKeysForPath(WinRegistry.HKEY_CURRENT_USER, "Software");
Important Note: I have modified only reading purpose methods in this process, not the writing purpose methods like createKey, deleteKey etc. They still are same as I recieved them.重要提示：我在此过程中仅修改了读取目的方法，而不是 createKey、deleteKey 等写入目的方法。它们仍然与我收到的相同。
解决方案10
6 2015-05-03 21:02:01
The best way to write to the register probably is using the reg import native Windows command and giving it the file path to the .reg file which has been generated by exporting something from the registry.写入寄存器的最佳方法可能是使用reg import native Windows 命令并为其提供通过从注册表导出某些内容而生成的.reg文件的文件路径。
Reading is done with the reg query command.使用reg query命令完成读取。 Also see the documentation: https://technet.microsoft.com/en-us/library/cc742028.aspx另请参阅文档： https://technet.microsoft.com/en-us/library/cc742028.aspx
Therefore the following code should be self-explanatory:因此，以下代码应该是不言自明的：
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
public class WindowsRegistry
{
public static void importSilently(String regFilePath) throws IOException,
InterruptedException
{
if (!new File(regFilePath).exists())
{
throw new FileNotFoundException();
}
Process importer = Runtime.getRuntime().exec("reg import " + regFilePath);
importer.waitFor();
}
public static void overwriteValue(String keyPath, String keyName,
String keyValue) throws IOException, InterruptedException
{
Process overwriter = Runtime.getRuntime().exec(
"reg add " + keyPath + " /t REG_SZ /v \"" + keyName + "\" /d "
+ keyValue + " /f");
overwriter.waitFor();
}
public static String getValue(String keyPath, String keyName)
throws IOException, InterruptedException
{
Process keyReader = Runtime.getRuntime().exec(
"reg query \"" + keyPath + "\" /v \"" + keyName + "\"");
BufferedReader outputReader;
String readLine;
StringBuffer outputBuffer = new StringBuffer();
outputReader = new BufferedReader(new InputStreamReader(
keyReader.getInputStream()));
while ((readLine = outputReader.readLine()) != null)
{
outputBuffer.append(readLine);
}
String[] outputComponents = outputBuffer.toString().split(" ");
keyReader.waitFor();
return outputComponents[outputComponents.length - 1];
}
}
解决方案11
5 2011-04-30 13:04:14
As has been noted, the Preferences API uses the registry to store preferences, but cannot be used to access the whole registry.如前所述，首选项 API 使用注册表来存储首选项，但不能用于访问整个注册表。
However, a pirate called David Croft has worked out that it's possible to use methods in Sun's implementation of the Preferences API for reading the Windows registry from Java without JNI .然而，一个名为 David Croft 的海盗发现，可以在 Sun 的 Preferences API 实现中使用方法来从 ZD52387880E1EA22817A72D375921389 中读取 Windows 注册表。 There are some dangers to that, but it is worth a look.这有一些危险，但值得一看。
解决方案12
5 2008-09-15 13:09:33
There are few JNDI service providers to work with windows registry.很少有 JNDI 服务提供者可以使用 windows 注册表。
One could observe http://java.sun.com/products/jndi/serviceproviders.html .可以观察http://java.sun.com/products/jndi/serviceproviders.html 。
解决方案13
4 2008-09-15 12:24:07
The Preferences API approach does not give you access to all the branches of the registry.首选项 API 方法不允许您访问注册表的所有分支。 In fact, it only gives you access to where the Preferences API stores its, well, preferences.事实上，它只允许您访问首选项 API 存储其首选项的位置。 It's not a generic registry handling API, like .NET's它不是处理 API 的通用注册表，如 .NET
To read/write every key I guess JNI or an external tool would be the approach to take, as Mark shows.正如 Mark 所示，我猜想 JNI 或外部工具可以读取/写入每个键。
解决方案14
3 2013-06-26 01:48:32
My previous edit to @David's answer was rejected.我之前对@David 的回答的编辑被拒绝了。 Here is some useful information about it.这里有一些关于它的有用信息。
This "magic" works because Sun implements the Preferences class for Windows as part of JDK, but it is package private .这个“魔法”之所以有效，是因为 Sun 为 Windows 实现了Preferences class 作为 JDK 的一部分，但它是package private 。 Parts of the implementation use JNI.部分实现使用 JNI。
- Package private class from JDK
java.util.prefs.WindowsPreferences: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7-b147/java/util/prefs/WindowsPreferences.javaPackage private class from JDK java.util.prefs.WindowsPreferences: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7-b147/java/util/prefs/WindowsPreferences.java - JNI: http://hg.openjdk.java.net/jdk7/jdk7/jdk/file/9b8c96f96a0f/src/windows/native/java/util/WindowsPreferences.c JNI： http://hg.openjdk.java.net/jdk7/jdk7/jdk/file/9b8c96f96a0f/src/windows/native/java/util/WindowsPreferences.Z4A8A08F09D37B73795649038408B5F3
The implementation is selected at runtime using a factory method here: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7-b147/java/util/prefs/Preferences.java#Preferences.0factory在运行时使用工厂方法选择实现： http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7-b147/java/util/prefs/Preferences.java#首选项.0工厂
The real question: Why doesn't OpenJDK expose this API to public?真正的问题：为什么 OpenJDK 不向公众公开这个 API？
解决方案15
3 2014-09-29 10:24:22
The java.util.prefs package provides a way for applications to store and retrieve user and system preferences and data configuration. java.util.prefs package 为应用程序提供了一种存储和检索用户和系统首选项以及数据配置的方法。 These preference data will be stored persistently in an implementation-dependent backing stored.这些偏好数据将永久存储在依赖于实现的支持存储中。 For example in Windows operating system in will stored in Windows registry.例如在 Windows 操作系统中将存储在 Windows 注册表中。
To write and read these data we use the java.util.prefs.Preferences class.要写入和读取这些数据，我们使用java.util.prefs.Preferences class。 Below code shows how to read and write to the HKCU and HKLM in the registry.下面的代码显示了如何在注册表中读取和写入HKCU和HKLM 。
import java.util.prefs.Preferences;
public class RegistryDemo {
public static final String PREF_KEY = "org.username";
public static void main(String[] args) {
//
// Write Preferences information to HKCU (HKEY_CURRENT_USER),
// HKCU\Software\JavaSoft\Prefs\org.username
//
Preferences userPref = Preferences.userRoot();
userPref.put(PREF_KEY, "xyz");
//
// Below we read back the value we've written in the code above.
//
System.out.println("Preferences = "
+ userPref.get(PREF_KEY, PREF_KEY + " was not found."));
//
// Write Preferences information to HKLM (HKEY_LOCAL_MACHINE),
// HKLM\Software\JavaSoft\Prefs\org.username
//
Preferences systemPref = Preferences.systemRoot();
systemPref.put(PREF_KEY, "xyz");
//
// Read back the value we've written in the code above.
//
System.out.println("Preferences = "
+ systemPref.get(PREF_KEY, PREF_KEY + " was not found."));
}
}
解决方案16
3 2009-05-18 15:34:36
解决方案17
2 2013-03-28 18:05:23
Yet another library...又一个图书馆……
https://code.google.com/p/java-registry/ https://code.google.com/p/java-registry/
This one launches reg.exe under the covers, reading/writing to temporary files.这个在幕后启动 reg.exe，读取/写入临时文件。 I didn't end up using it, but it looks like a pretty comprehensive implementation.我最终没有使用它，但它看起来是一个非常全面的实现。 If I did use it, I might dive in and add some better management of the child processes.如果我确实使用了它，我可能会深入研究并添加对子进程的更好管理。
解决方案18
0 2013-08-07 12:46:10
This was crazy... I took the code from one of the posts here, failed to see there were 18 more comments in which one stated that it does not read a dword value...这太疯狂了......我从这里的一篇帖子中获取了代码，没有看到还有 18 条评论，其中一条评论说它没有读取 dword 值......
In any case, I've refactored the hell of that code into something with less ifs and methods...无论如何，我已经将该代码的地狱重构为使用更少的 if 和方法的东西......
The Enum could be refined a bit, but as soon as I've fought my way to read a numeric value or byte array and failed, I've given up...枚举可以稍微改进一下，但是一旦我努力读取数值或字节数组并且失败了，我就放弃了......
So here it is:所以这里是：
package com.nu.art.software.utils;
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;
/**
*
* @author TacB0sS
*/
public class WinRegistry_TacB0sS {
public static final class RegistryException
extends Exception {
private static final long serialVersionUID = -8799947496460994651L;
public RegistryException(String message, Throwable e) {
super(message, e);
}
public RegistryException(String message) {
super(message);
}
}
public static final int KEY_WOW64_32KEY = 0x0200;
public static final int KEY_WOW64_64KEY = 0x0100;
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;
public enum WinRegistryKey {
User(Preferences.userRoot(), 0x80000001), ;
// System(Preferences.systemRoot(), 0x80000002);
private final Preferences preferencesRoot;
private final Integer key;
private WinRegistryKey(Preferences preferencesRoot, int key) {
this.preferencesRoot = preferencesRoot;
this.key = key;
}
}
private enum WinRegistryMethod {
OpenKey("WindowsRegOpenKey", int.class, byte[].class, int.class) {
@Override
protected void verifyReturnValue(Object retValue)
throws RegistryException {
int[] retVal = (int[]) retValue;
if (retVal[1] != REG_SUCCESS)
throw new RegistryException("Action Failed, Return Code: " + retVal[1]);
}
},
CreateKeyEx("WindowsRegCreateKeyEx", int.class, byte[].class) {
@Override
protected void verifyReturnValue(Object retValue)
throws RegistryException {
int[] retVal = (int[]) retValue;
if (retVal[1] != REG_SUCCESS)
throw new RegistryException("Action Failed, Return Code: " + retVal[1]);
}
},
DeleteKey("WindowsRegDeleteKey", int.class, byte[].class) {
@Override
protected void verifyReturnValue(Object retValue)
throws RegistryException {
int retVal = ((Integer) retValue).intValue();
if (retVal != REG_SUCCESS)
throw new RegistryException("Action Failed, Return Code: " + retVal);
}
},
DeleteValue("WindowsRegDeleteValue", int.class, byte[].class) {
@Override
protected void verifyReturnValue(Object retValue)
throws RegistryException {
int retVal = ((Integer) retValue).intValue();
if (retVal != REG_SUCCESS)
throw new RegistryException("Action Failed, Return Code: " + retVal);
}
},
CloseKey("WindowsRegCloseKey", int.class),
QueryValueEx("WindowsRegQueryValueEx", int.class, byte[].class),
EnumKeyEx("WindowsRegEnumKeyEx", int.class, int.class, int.class),
EnumValue("WindowsRegEnumValue", int.class, int.class, int.class),
QueryInfoKey("WindowsRegQueryInfoKey", int.class),
SetValueEx("WindowsRegSetValueEx", int.class, byte[].class, byte[].class);
private Method method;
private WinRegistryMethod(String methodName, Class<?>... classes) {
// WinRegistryKey.User.preferencesRoot.getClass().getMDeclaredMethods()
try {
method = WinRegistryKey.User.preferencesRoot.getClass().getDeclaredMethod(methodName, classes);
} catch (Exception e) {
System.err.println("Error");
System.err.println(e);
}
method.setAccessible(true);
}
public Object invoke(Preferences root, Object... objects)
throws RegistryException {
Object retValue;
try {
retValue = method.invoke(root, objects);
verifyReturnValue(retValue);
} catch (Throwable e) {
String params = "";
if (objects.length > 0) {
params = objects[0].toString();
for (int i = 1; i < objects.length; i++) {
params += ", " + objects[i];
}
}
throw new RegistryException("Error invoking method: " + method + ", with params: (" + params + ")", e);
}
return retValue;
}
protected void verifyReturnValue(Object retValue)
throws RegistryException {}
}
private WinRegistry_TacB0sS() {}
public static String readString(WinRegistryKey regKey, String key, String valueName)
throws RegistryException {
int retVal = ((int[]) WinRegistryMethod.OpenKey.invoke(regKey.preferencesRoot, regKey.key, toCstr(key),
new Integer(KEY_READ)))[0];
byte[] retValue = (byte[]) WinRegistryMethod.QueryValueEx.invoke(regKey.preferencesRoot, retVal,
toCstr(valueName));
WinRegistryMethod.CloseKey.invoke(regKey.preferencesRoot, retVal);
/*
* Should this return an Empty String.
*/
return (retValue != null ? new String(retValue).trim() : null);
}
public static Map<String, String> readStringValues(WinRegistryKey regKey, String key)
throws RegistryException {
HashMap<String, String> results = new HashMap<String, String>();
int retVal = ((int[]) WinRegistryMethod.OpenKey.invoke(regKey.preferencesRoot, regKey.key, toCstr(key),
new Integer(KEY_READ)))[0];
int[] info = (int[]) WinRegistryMethod.QueryInfoKey.invoke(regKey.preferencesRoot, retVal);
int count = info[2]; // count
int maxlen = info[3]; // value length max
for (int index = 0; index < count; index++) {
byte[] name = (byte[]) WinRegistryMethod.EnumValue.invoke(regKey.preferencesRoot, retVal,
new Integer(index), new Integer(maxlen + 1));
String value = readString(regKey, key, new String(name));
results.put(new String(name).trim(), value);
}
WinRegistryMethod.CloseKey.invoke(regKey.preferencesRoot, retVal);
return results;
}
public static List<String> readStringSubKeys(WinRegistryKey regKey, String key)
throws RegistryException {
List<String> results = new ArrayList<String>();
int retVal = ((int[]) WinRegistryMethod.OpenKey.invoke(regKey.preferencesRoot, regKey.key, toCstr(key),
new Integer(KEY_READ)))[0];
int[] info = (int[]) WinRegistryMethod.QueryInfoKey.invoke(regKey.preferencesRoot, retVal);
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[]) WinRegistryMethod.EnumValue.invoke(regKey.preferencesRoot, retVal,
new Integer(index), new Integer(maxlen + 1));
results.add(new String(name).trim());
}
WinRegistryMethod.CloseKey.invoke(regKey.preferencesRoot, retVal);
return results;
}
public static void createKey(WinRegistryKey regKey, String key)
throws RegistryException {
int[] retVal = (int[]) WinRegistryMethod.CreateKeyEx.invoke(regKey.preferencesRoot, regKey.key, toCstr(key));
WinRegistryMethod.CloseKey.invoke(regKey.preferencesRoot, retVal[0]);
}
public static void writeStringValue(WinRegistryKey regKey, String key, String valueName, String value)
throws RegistryException {
int retVal = ((int[]) WinRegistryMethod.OpenKey.invoke(regKey.preferencesRoot, regKey.key, toCstr(key),
new Integer(KEY_ALL_ACCESS)))[0];
WinRegistryMethod.SetValueEx.invoke(regKey.preferencesRoot, retVal, toCstr(valueName), toCstr(value));
WinRegistryMethod.CloseKey.invoke(regKey.preferencesRoot, retVal);
}
public static void deleteKey(WinRegistryKey regKey, String key)
throws RegistryException {
WinRegistryMethod.DeleteKey.invoke(regKey.preferencesRoot, regKey.key, toCstr(key));
}
public static void deleteValue(WinRegistryKey regKey, String key, String value)
throws RegistryException {
int retVal = ((int[]) WinRegistryMethod.OpenKey.invoke(regKey.preferencesRoot, regKey.key, toCstr(key),
new Integer(KEY_ALL_ACCESS)))[0];
WinRegistryMethod.DeleteValue.invoke(regKey.preferencesRoot, retVal, toCstr(value));
WinRegistryMethod.CloseKey.invoke(regKey.preferencesRoot, retVal);
}
// 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;
}
}
NOTE: THIS DOES NOT READ ANYTHING ELSE BUT STRINGS!!!!!注意：除了字符串之外，这不会读取任何其他内容！！！！！！！
解决方案19
0 2014-07-22 01:34:47
This uses the same Java internal APIs as in in David's answer , but I've rewritten it completely.这使用与David 的回答中相同的 Java 内部 API，但我已经完全重写了它。 It's shorter now and nicer to use.它现在更短，更好用。 I also added support for HKEY_CLASSES_ROOT and other hives.我还添加了对 HKEY_CLASSES_ROOT 和其他配置单元的支持。 It still has some of the other limitations though (such as no DWORD support and no Unicode support) which are due to the underlying API and are sadly unavoidable with this approach.它仍然有一些其他限制（例如不支持 DWORD 和不支持 Unicode），这是由于底层 API 造成的，遗憾的是这种方法是不可避免的。 Still, if you only need basic string reading/writing and don't want to load a native DLL, it's handy.尽管如此，如果您只需要基本的字符串读/写并且不想加载本机 DLL，那么它很方便。
I'm sure you can figure out how to use it.我相信你可以弄清楚如何使用它。
Public domain.公共区域。 Have fun.玩得开心。
import java.util.*;
import java.lang.reflect.Method;
/**
* Simple registry access class implemented using some private APIs
* in java.util.prefs. It has no other prerequisites.
*/
public final class WindowsRegistry {
/**
* Tells if the Windows registry functions are available.
* (They will not be available when not running on Windows, for example.)
*/
public static boolean isAvailable() {
return initError == null;
}
/** Reads a string value from the given key and value name. */
public static String readValue(String keyName, String valueName) {
try (Key key = Key.open(keyName, KEY_READ)) {
return fromByteArray(invoke(regQueryValueEx, key.handle, toByteArray(valueName)));
}
}
/** Returns a map of all the name-value pairs in the given key. */
public static Map<String,String> readValues(String keyName) {
try (Key key = Key.open(keyName, KEY_READ)) {
int[] info = invoke(regQueryInfoKey, key.handle);
checkError(info[INFO_ERROR_CODE]);
int count = info[INFO_COUNT_VALUES];
int maxlen = info[INFO_MAX_VALUE_LENGTH] + 1;
Map<String,String> values = new HashMap<>();
for (int i = 0; i < count; i++) {
String valueName = fromByteArray(invoke(regEnumValue, key.handle, i, maxlen));
values.put(valueName, readValue(keyName, valueName));
}
return values;
}
}
/** Returns a list of the names of all the subkeys of a key. */
public static List<String> readSubkeys(String keyName) {
try (Key key = Key.open(keyName, KEY_READ)) {
int[] info = invoke(regQueryInfoKey, key.handle);
checkError(info[INFO_ERROR_CODE]);
int count = info[INFO_COUNT_KEYS];
int maxlen = info[INFO_MAX_KEY_LENGTH] + 1;
List<String> subkeys = new ArrayList<>(count);
for (int i = 0; i < count; i++) {
subkeys.add(fromByteArray(invoke(regEnumKeyEx, key.handle, i, maxlen)));
}
return subkeys;
}
}
/** Writes a string value with a given key and value name. */
public static void writeValue(String keyName, String valueName, String value) {
try (Key key = Key.open(keyName, KEY_WRITE)) {
checkError(invoke(regSetValueEx, key.handle, toByteArray(valueName), toByteArray(value)));
}
}
/** Deletes a value within a key. */
public static void deleteValue(String keyName, String valueName) {
try (Key key = Key.open(keyName, KEY_WRITE)) {
checkError(invoke(regDeleteValue, key.handle, toByteArray(valueName)));
}
}
/**
* Deletes a key and all values within it. If the key has subkeys, an
* "Access denied" error will be thrown. Subkeys must be deleted separately.
*/
public static void deleteKey(String keyName) {
checkError(invoke(regDeleteKey, keyParts(keyName)));
}
/**
* Creates a key. Parent keys in the path will also be created if necessary.
* This method returns without error if the key already exists.
*/
public static void createKey(String keyName) {
int[] info = invoke(regCreateKeyEx, keyParts(keyName));
checkError(info[INFO_ERROR_CODE]);
invoke(regCloseKey, info[INFO_HANDLE]);
}
/**
* The exception type that will be thrown if a registry operation fails.
*/
public static class RegError extends RuntimeException {
public RegError(String message, Throwable cause) {
super(message, cause);
}
}
// *************
// PRIVATE STUFF
// *************
private WindowsRegistry() {}
// Map of registry hive names to constants from winreg.h
private static final Map<String,Integer> hives = new HashMap<>();
static {
hives.put("HKEY_CLASSES_ROOT", 0x80000000); hives.put("HKCR", 0x80000000);
hives.put("HKEY_CURRENT_USER", 0x80000001); hives.put("HKCU", 0x80000001);
hives.put("HKEY_LOCAL_MACHINE", 0x80000002); hives.put("HKLM", 0x80000002);
hives.put("HKEY_USERS", 0x80000003); hives.put("HKU", 0x80000003);
hives.put("HKEY_CURRENT_CONFIG", 0x80000005); hives.put("HKCC", 0x80000005);
}
// Splits a path such as HKEY_LOCAL_MACHINE\Software\Microsoft into a pair of
// values used by the underlying API: An integer hive constant and a byte array
// of the key path within that hive.
private static Object[] keyParts(String fullKeyName) {
int x = fullKeyName.indexOf('\\');
String hiveName = x >= 0 ? fullKeyName.substring(0, x) : fullKeyName;
String keyName = x >= 0 ? fullKeyName.substring(x + 1) : "";
Integer hkey = hives.get(hiveName);
if (hkey == null) throw new RegError("Unknown registry hive: " + hiveName, null);
return new Object[] { hkey, toByteArray(keyName) };
}
// Type encapsulating a native handle to a registry key
private static class Key implements AutoCloseable {
final int handle;
private Key(int handle) {
this.handle = handle;
}
static Key open(String keyName, int accessMode) {
Object[] keyParts = keyParts(keyName);
int[] ret = invoke(regOpenKey, keyParts[0], keyParts[1], accessMode);
checkError(ret[INFO_ERROR_CODE]);
return new Key(ret[INFO_HANDLE]);
}
@Override
public void close() {
invoke(regCloseKey, handle);
}
}
// Array index constants for results of regOpenKey, regCreateKeyEx, and regQueryInfoKey
private static final int
INFO_HANDLE = 0,
INFO_COUNT_KEYS = 0,
INFO_ERROR_CODE = 1,
INFO_COUNT_VALUES = 2,
INFO_MAX_KEY_LENGTH = 3,
INFO_MAX_VALUE_LENGTH = 4;
// Registry access mode constants from winnt.h
private static final int
KEY_READ = 0x20019,
KEY_WRITE = 0x20006;
// Error constants from winerror.h
private static final int
ERROR_SUCCESS = 0,
ERROR_FILE_NOT_FOUND = 2,
ERROR_ACCESS_DENIED = 5;
private static void checkError(int e) {
if (e == ERROR_SUCCESS) return;
throw new RegError(
e == ERROR_FILE_NOT_FOUND ? "Key not found" :
e == ERROR_ACCESS_DENIED ? "Access denied" :
("Error number " + e), null);
}
// Registry access methods in java.util.prefs.WindowsPreferences
private static final Method
regOpenKey = getMethod("WindowsRegOpenKey", int.class, byte[].class, int.class),
regCloseKey = getMethod("WindowsRegCloseKey", int.class),
regQueryValueEx = getMethod("WindowsRegQueryValueEx", int.class, byte[].class),
regQueryInfoKey = getMethod("WindowsRegQueryInfoKey", int.class),
regEnumValue = getMethod("WindowsRegEnumValue", int.class, int.class, int.class),
regEnumKeyEx = getMethod("WindowsRegEnumKeyEx", int.class, int.class, int.class),
regSetValueEx = getMethod("WindowsRegSetValueEx", int.class, byte[].class, byte[].class),
regDeleteValue = getMethod("WindowsRegDeleteValue", int.class, byte[].class),
regDeleteKey = getMethod("WindowsRegDeleteKey", int.class, byte[].class),
regCreateKeyEx = getMethod("WindowsRegCreateKeyEx", int.class, byte[].class);
private static Throwable initError;
private static Method getMethod(String methodName, Class<?>... parameterTypes) {
try {
Method m = java.util.prefs.Preferences.systemRoot().getClass()
.getDeclaredMethod(methodName, parameterTypes);
m.setAccessible(true);
return m;
} catch (Throwable t) {
initError = t;
return null;
}
}
@SuppressWarnings("unchecked")
private static <T> T invoke(Method method, Object... args) {
if (initError != null)
throw new RegError("Registry methods are not available", initError);
try {
return (T)method.invoke(null, args);
} catch (Exception e) {
throw new RegError(null, e);
}
}
// Conversion of strings to/from null-terminated byte arrays.
// There is no support for Unicode; sorry, this is a limitation
// of the underlying methods that Java makes available.
private static byte[] toByteArray(String str) {
byte[] bytes = new byte[str.length() + 1];
for (int i = 0; i < str.length(); i++)
bytes[i] = (byte)str.charAt(i);
return bytes;
}
private static String fromByteArray(byte[] bytes) {
if (bytes == null) return null;
char[] chars = new char[bytes.length - 1];
for (int i = 0; i < chars.length; i++)
chars[i] = (char)((int)bytes[i] & 0xFF);
return new String(chars);
}
}
One day, Java will have a built-in foreign function interface for easy access to native APIs, and this sort of hack will be unnecessary.有朝一日，Java 将内置一个国外的 function 接口，方便访问原生 API，这样的 hack 就没有必要了。
解决方案20
0 2022-09-01 20:19:58
I make my own code using enum.我使用枚举制作自己的代码。
public class Registry {
public static enum key {
HKEY_CURRENT_USER, HKEY_USERS, HKEY_LOCAL_MACHINE, HKEY_CURRENT_CONFIG;
};
public static enum dataType {
REG_BINARY, REG_DWORD, REG_EXPAND_SZ, REG_MULTI_SZ, REG_SZ, REG_RESOURCE_LIST, REG_RESOURCE_REQUIREMENTS_LIST, REG_FULL_RESOURCE_DESCRIPTOR, REG_NONE, REG_LINK, REG_QWORD;
}
public static enum userKey {
AppEvents, Console, Control_Panel, Enviroment, EUDC, Keyboard_Layout, Microsoft, Network, Printers, Software, System, Uninstall, Volatile_Enviroment;
}
public static void overWriteSoftwareInt(String key, String userKey, String path, String valueKey, String datatype, int value) {
try {
Process process = Runtime.getRuntime().exec("reg add " + key + "\\" + userKey + "\\" + path + " /t " + datatype + " /v \"" + valueKey + "\" /d " + value);
process.waitFor();
} catch (IOException ex) {
// Logger.getLogger(Registry.class.getName()).log(Level.SEVERE, null, ex);
} catch (InterruptedException ex) {
Logger.getLogger(Registry.class.getName()).log(Level.SEVERE, null, ex);
}
}
public static void overWriteSoftwareString(String key, String userKey, String path, String valueKey, String datatype, int value) {
try {
Process process = Runtime.getRuntime().exec("reg add " + key + "\\" + userKey + "\\" + path + " /t " + datatype + " /v \"" + valueKey + "\" /d \"" + value+"\"");
process.waitFor();
} catch (IOException ex) {
// Logger.getLogger(Registry.class.getName()).log(Level.SEVERE, null, ex);
} catch (InterruptedException ex) {
Logger.getLogger(Registry.class.getName()).log(Level.SEVERE, null, ex);
}
}
public static void deleteValue(String key, String userKey, String path, String valueKey) {
try {
Process process = Runtime.getRuntime().exec("reg delete " + key + "\\" + userKey + "\\" + path + " /v \"" + valueKey + "\" /f");
process.waitFor();
} catch (IOException ex) {
// Logger.getLogger(Registry.class.getName()).log(Level.SEVERE, null, ex);
} catch (InterruptedException ex) {
Logger.getLogger(Registry.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
You can use this class following this example.您可以按照此示例使用此 class。
Registry.deleteValue(Registry.key.HKEY_CURRENT_USER.name(), Registry.userKey.Software.name(), "path", "valueName");
Registry.overWriteSoftwareInt(Registry.key.HKEY_CURRENT_USER.name(), Registry.userKey.Software.name(), "path", "valueName", Registry.dataType.REG_DWORD.name(), 0);
解决方案21
0
The WinPack Demo has Registry Viewer implemented as an example.
Check at http://www.jniwrapper.com/winpack_features.jsp#registry
BTW, WinPack has been moved to the following address:顺便说一句，WinPack 已移至以下地址：
http://www.teamdev.com/jniwrapper/winpack/ http://www.teamdev.com/jniwrapper/winpack/
解决方案22
0 2012-01-21 19:03:31
Although this is pretty old, but i guess the better utility to use on windows platform would be regini :虽然这已经很老了，但我想在 windows 平台上使用的更好的实用程序是regini ：
A single call to process:一次调用处理：
Runtime.getRuntime().exec("regini <your script file abs path here>");
will do all the magic.会做所有的魔法。 I have tried it, while making jar as windows service using servany.exe which requires changes to made in registry for adding javaw.exe arguments and it works perfectly.我已经尝试过了，同时使用 servany.exe 将 jar 设置为 windows 服务，这需要在注册表中进行更改以添加 javaw.exe arguments，并且效果很好。 You might want to read this: http://support.microsoft.com/kb/264584您可能想阅读以下内容： http://support.microsoft.com/kb/264584
解决方案23
-2 2014-03-23 10:36:25
In response to David answer - I would do some enhancements:为了回应大卫的回答- 我会做一些改进：
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.Preferences;
public class WinRegistry {
public static final int HKEY_CURRENT_USER = 0x80000001,
HKEY_LOCAL_MACHINE = 0x80000002,
REG_SUCCESS = 0,
REG_NOTFOUND = 2,
REG_ACCESSDENIED = 5,
KEY_ALL_ACCESS = 0xf003f,
KEY_READ = 0x20019;
private static final Preferences userRoot = Preferences.userRoot(),
systemRoot = Preferences.systemRoot();
private static final Class<? extends Preferences> userClass = userRoot.getClass();
private static Method regOpenKey,
regCloseKey,
regQueryValueEx,
regEnumValue,
regQueryInfoKey,
regEnumKeyEx,
regCreateKeyEx,
regSetValueEx,
regDeleteKey,
regDeleteValue;
static {
try {
(regOpenKey = userClass.getDeclaredMethod("WindowsRegOpenKey", new Class[]{int.class, byte[].class, int.class})).setAccessible(true);
(regCloseKey = userClass.getDeclaredMethod("WindowsRegCloseKey", new Class[]{int.class})).setAccessible(true);
(regQueryValueEx = userClass.getDeclaredMethod("WindowsRegQueryValueEx", new Class[]{int.class, byte[].class})).setAccessible(true);
(regEnumValue = userClass.getDeclaredMethod("WindowsRegEnumValue", new Class[]{int.class, int.class, int.class})).setAccessible(true);
(regQueryInfoKey = userClass.getDeclaredMethod("WindowsRegQueryInfoKey1", new Class[]{int.class})).setAccessible(true);
(regEnumKeyEx = userClass.getDeclaredMethod("WindowsRegEnumKeyEx", new Class[]{int.class, int.class, int.class})).setAccessible(true);
(regCreateKeyEx = userClass.getDeclaredMethod("WindowsRegCreateKeyEx", new Class[]{int.class, byte[].class})).setAccessible(true);
(regSetValueEx = userClass.getDeclaredMethod("WindowsRegSetValueEx", new Class[]{int.class, byte[].class, byte[].class})).setAccessible(true);
(regDeleteValue = userClass.getDeclaredMethod("WindowsRegDeleteValue", new Class[]{int.class, byte[].class})).setAccessible(true);
(regDeleteKey = userClass.getDeclaredMethod("WindowsRegDeleteKey", new Class[]{int.class, byte[].class})).setAccessible(true);
} catch (NoSuchMethodException | SecurityException ex) {
Logger.getLogger(WinRegistry.class.getName()).log(Level.SEVERE, null, ex);
}
}
/**
* 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 {
switch (hkey) {
case HKEY_LOCAL_MACHINE:
return readString(systemRoot, hkey, key, valueName);
case HKEY_CURRENT_USER:
return readString(userRoot, hkey, key, valueName);
default:
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 {
switch (hkey) {
case HKEY_LOCAL_MACHINE:
return readStringValues(systemRoot, hkey, key);
case HKEY_CURRENT_USER:
return readStringValues(userRoot, hkey, key);
default:
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 {
switch (hkey) {
case HKEY_LOCAL_MACHINE:
return readStringSubKeys(systemRoot, hkey, key);
case HKEY_CURRENT_USER:
return readStringSubKeys(userRoot, hkey, key);
default:
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;
switch (hkey) {
case HKEY_LOCAL_MACHINE:
ret = createKey(systemRoot, hkey, key);
regCloseKey.invoke(systemRoot, new Object[]{ret[0]});
break;
case HKEY_CURRENT_USER:
ret = createKey(userRoot, hkey, key);
regCloseKey.invoke(userRoot, new Object[]{ret[0]});
break;
default:
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 {
switch (hkey) {
case HKEY_LOCAL_MACHINE:
writeStringValue(systemRoot, hkey, key, valueName, value);
break;
case HKEY_CURRENT_USER:
writeStringValue(userRoot, hkey, key, valueName, value);
break;
default:
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;
switch (hkey) {
case HKEY_LOCAL_MACHINE:
rc = deleteKey(systemRoot, hkey, key);
break;
case 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;
switch (hkey) {
case HKEY_LOCAL_MACHINE:
rc = deleteValue(systemRoot, hkey, key, value);
break;
case 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[]{hkey, toCstr(key), 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[]{handles[0], toCstr(value)}));
regCloseKey.invoke(root, new Object[]{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[]{hkey, toCstr(key)}));
return rc; //Can be 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[]{hkey, toCstr(key), KEY_READ});
if (handles[1] != REG_SUCCESS) {
return null;
}
byte[] valb = (byte[]) regQueryValueEx.invoke(root, new Object[]{handles[0], toCstr(value)});
regCloseKey.invoke(root, new Object[]{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<>();
int[] handles = (int[]) regOpenKey.invoke(root, new Object[]{hkey, toCstr(key), KEY_READ});
if (handles[1] != REG_SUCCESS) {
return null;
}
int[] info = (int[]) regQueryInfoKey.invoke(root, new Object[]{handles[0]});
int count = info[0]; //Count
int maxlen = info[3]; //Max value length
for (int index = 0; index < count; index++) {
byte[] name = (byte[]) regEnumValue.invoke(root, new Object[]{handles[0], index, maxlen + 1});
String value = readString(hkey, key, new String(name));
results.put(new String(name).trim(), value);
}
regCloseKey.invoke(root, new Object[]{handles[0]});
return results;
}
private static List<String> readStringSubKeys(Preferences root, int hkey, String key) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
List<String> results = new ArrayList<>();
int[] handles = (int[]) regOpenKey.invoke(root, new Object[]{hkey, toCstr(key), KEY_READ});
if (handles[1] != REG_SUCCESS) {
return null;
}
int[] info = (int[]) regQueryInfoKey.invoke(root, new Object[]{handles[0]});
int count = info[0];//Count
int maxlen = info[3]; //Max value length
for (int index = 0; index < count; index++) {
byte[] name = (byte[]) regEnumKeyEx.invoke(root, new Object[]{handles[0], index, maxlen + 1});
results.add(new String(name).trim());
}
regCloseKey.invoke(root, new Object[]{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[]{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[]{hkey, toCstr(key), KEY_ALL_ACCESS});
regSetValueEx.invoke(root, new Object[]{handles[0], toCstr(valueName), toCstr(value)});
regCloseKey.invoke(root, new Object[]{handles[0]});
}
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;
}
}
解决方案24
-2 2014-09-29 18:24:42
You can execute these "REG QUERY" command using java code.您可以使用java代码执行这些“REG QUERY”命令。
Try to execute this from command prompt and execute command from java code.尝试从命令提示符执行此操作并从 java 代码执行命令。
HKEY_LOCAL_MACHINE "SOFTWARE\Microsoft\Windows NT\CurrentVersion"
To Search details like productname version etc.. use /v amd "name".要搜索产品名称版本等详细信息，请使用 /v amd "name"。
HKEY_LOCAL_MACHINE "SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v "ProductName"
解决方案25
-5 2011-05-17 09:03:03
I prefer using java.util.prefs.Preferences class.我更喜欢使用java.util.prefs.Preferences class。
A simple example would be一个简单的例子是
// Write Operation
Preferences p = Preferences.userRoot();
p.put("key","value");
// also there are various other methods such as putByteArray(), putDouble() etc.
p.flush();
//Read Operation
Preferences p = Preferences.userRoot();
String value = p.get("key");
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.
相关问题
如何使用Java编写Windows注册表？ - How to write windows registry using Java?
使用JAVA和JNA在64位Win 7上读/写Windows注册表 - Read/Write windows registry on 64bit Win 7 using JAVA with JNA
如何使用 Java 从 Windows 注册表读取 integer 值？ - How to read integer value from Windows registry using Java?
如何使用java读取远程机器上的Windows注册表数据 - How to read windows registry data on remote machine using java
如何使用Java导出Windows注册表文件 - How To Export A Windows Registry File Using Java
使用Java检测Windows注册表事件 - Detect windows registry events using java
在Windows中使用java查找特定的注册表项 - Finding a specific registry key using java in windows
使用由SYSTEM帐户的Windows服务调用的Java更新Windows注册表 - Update windows registry using java invoked by a windows service of SYSTEM account
Java与Windows注册表 - Java with windows registry
使用 Jacob 从远程系统读取 Windows 注册表信息 - Read windows registry info from remote system using Jacob
相关标签