使用Java对Windows注册表进行读/写操作 – 开发百科-程序代码问答平台

如何使用Java读取/写入Windows注册表

我知道这个问题由来已久，但这是谷歌上第一个“java读/写注册表”的搜索结果。最近，我发现了这段惊人的代码：

可以读取/写入注册表的任何部分
不使用JNI
不使用任何第三方/外部应用程序工作
不使用WINDOWS API（直接）

这是纯Java代码

它通过实际访问java.util.prefs.Preferences类中的私有方法，使用反射来工作。这个类的内部结构很复杂，但是这个类本身很容易使用

例如，下面的代码从注册表中获取准确的windows分布：

String value=WinRegistry.readString(
WinRegistry.HKEY\u本地\u计算机，//HKEY
“软件\\Microsoft\\Windows NT\\CurrentVersion”，//键
“产品名称”）//值名
System.out.println（“Windows分布=”+值）；

这是原来的课程。只需复制粘贴它，它就会工作：

导入java.lang.reflect.InvocationTargetException；
导入java.lang.reflect.Method；
导入java.util.HashMap；
导入java.util.Map；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.prefs.Preferences；
公共类WinRegistry{
公共静态最终int HKEY_CURRENT_USER=0x8000001；
公共静态最终内部HKEY_本地_机器=0x8000002；
公共静态最终整数注册成功=0；
公共静态最终整数REG_NOTFOUND=2；
公共静态最终整数REG_ACCESSDENIED=5；
私有静态最终整数密钥\u ALL\u访问=0xf003f；
私有静态最终整型密钥_READ=0x20019；
私有静态最终首选项userRoot=Preferences.userRoot（）；
private static final Preferences systemRoot=Preferences.systemRoot（）；
私有静态最终类&lt；？扩展首选项&gt；userClass=userRoot.getClass（）；
私有静态最终方法regOpenKey；
私有静态final方法regCloseKey；
私有静态final方法regQueryValueEx；
私有静态最终方法regEnumValue；
私有静态final方法regQueryInfoKey；
私有静态最终方法regEnumKeyEx；
私有静态final方法regCreateKeyEx；
私有静态最终方法regSetValueEx；
私有静态最终方法regDeleteKey；
私有静态最终方法regDeleteValue；
静止的{
试一试{
regOpenKey=userClass.getDeclaredMethod（“WindowsRegOpenKey”，
新类[]{int.Class，字节[].Class，int.Class}）；
regOpenKey.setAccessible（true）；
regCloseKey=userClass.getDeclaredMethod（“WindowsRegCloseKey”，
新类[]{int.Class}）；
regCloseKey.setAccessible（true）；
regQueryValueEx=userClass.getDeclaredMethod（“WindowsRegQueryValueEx”，
新类[]{int.Class，字节[].Class}）；
regQueryValueEx.setAccessible（true）；
regEnumValue=userClass.getDeclaredMethod（“WindowsRegEnumValue”，
新类[]{int.Class，int.Class，int.Class}）；
regEnumValue.setAccessible（真）；
regQueryInfoKey=userClass.getDeclaredMethod（“WindowsRegQueryInfoKey1”，
新类[]{int.Class}）；
regQueryInfoKey.setAccessible（true）；
regEnumKeyEx=userClass.getDeclaredMethod（
“WindowsRegEnumKeyEx”，新类[]{int.Class，int.Class，
int.class}）；
regEnumKeyEx.setAccessible（真）；
regCreateKeyEx=userClass.getDeclaredMethod（
“WindowsRegCreateKeyEx”，新类[]{int.Class，
字节[].class}）；
regCreateKeyEx.setAccessible（true）；
regSetValueEx=userClass.getDeclaredMethod（
“WindowsRegSetValueEx”，新类[]{int.Class，
字节[].class，字节[].class}）；
regSetValueEx.setAccessible（true）；
regDeleteValue=userClass.getDeclaredMethod（
“WindowsRegDeleteValue”，新类[]{int.Class，
字节[].class}）；
regDeleteValue.setAccessible（true）；
regDeleteKey=userClass.getDeclaredMethod（
“WindowsRegDeleteKey”，新类[]{int.Class，
字节[].class}）；
regDeleteKey.setAccessible（true）；
}
捕获（例外e）{
抛出新的运行时异常（e）；
}
}
私有WinRegistry（）{}
/**
*从键和值名称中读取值
*@param hkey hkey_当前用户/hkey_本地机器
*@param-key
*@param valueName
*@返回值
*@galargumentException
*@galacessException
*@targetException
*/
公共静态字符串readString（int-hkey、字符串键、字符串值名称）
抛出IllegalArgumentException，IllegalAccessException，
调用目标异常
{
if（hkey==hkey_本地_机器）{
返回readString（systemRoot、hkey、key、valueName）；
}
else if（hkey==hkey\U当前用户）{
返回readString（userRoot、hkey、key、valueName）；
}
否则{
抛出新的IllegalArgumentException（“hkey=“+hkey”）；
}
}
/**
*从给定键读取值和值名称
*@param hkey hkey_当前用户/hkey_本地机器
*@param-key
*@返回值名称加上值
*@galargumentException
*@galacessException
*@targetException
*/
公共静态映射&lt；字符串，字符串&gt；readStringValues（int-hkey，字符串键）
抛出IllegalArgumentException，IllegalAccessException，
调用目标异常
{
if（hkey==hkey_本地_机器）{
返回readStringValues（systemRoot、hkey、key）；
}
else if（hkey==hkey\U当前用户）{
返回readStringValues（userRoot、hkey、key）；
}
否则{
抛出新的IllegalArgumentException（“hkey=“+hkey”）；
}
}
/**
*从给定键读取值名称
*@param hkey hkey_当前用户/hkey_本地机器
*@param-key
*@返回值名称
*@galargumentException
*@galacessException
*@targetException
*/
公共静态列表&lt；字符串&gt；readStringSubKeys（int-hkey，字符串键）
抛出IllegalArgumentException，IllegalAccessException，
调用目标异常
{
if（hkey==hkey_本地_机器）{
返回readStringSubkey（systemRoot、hkey、key）；
}
else if（hkey==hkey\U当前用户）{
返回ReadStringSubkey（userRoot、hkey、key）；
}
否则{
抛出新的IllegalArgumentException（“hkey=“+hkey”）；
}
}
/**
*创建密钥
*@param hkey hkey_当前用户/hkey_本地机器
*@param-key
*@galargumentException
*@galacessException
*@targetException
*/
公共静态void createKey（int-hkey，字符串键）
抛出IllegalArgumentException，IllegalAccessException，
调用目标异常
{
int[]ret；
if（hkey==hkey_本地_机器）{
ret=createKey（systemRoot，hkey，key）；
invoke（systemRoot，新对象[]{newinteger（ret[0]）}）；
}
else if（hkey==hkey\U当前用户）{
ret=createKey（userRoot，hkey，key）；
invoke（userRoot，新对象[]{newinteger（ret[0]）}）；
}
否则{
抛出新的IllegalArgumentException（“hkey=“+hkey”）；
}
如果（ret[1]！=REG_成功）{
抛出新的IllegalArgumentException（“rc=“+ret[1]+”key=“+key”）；
}
}
/**
*在给定的键/值名称中写入值
*@param-hkey
*@param-key
*@param valueName
*@param值
*@galargumentException
*@galacessException
*@targetException
*/
公共静态void writeStringValue
（int-hkey，字符串键，字符串值名称，字符串值）
抛出IllegalArgumentException，IllegalAccessException，
调用目标异常
{
if（hkey==hkey_本地_机器）{
writeStringValue（systemRoot、hkey、key、valueName、value）；
}
else if（hkey==hkey\U当前用户）{
writeStringValue（userRoot、hkey、key、valueName、value）；
}
否则{
抛出新的IllegalArgumentException（“hkey=“+hkey”）；
}
}
/**
*删除给定的密钥
*@param-hkey
*@param-key
*@galargumentException
*@galacessException
*@targetException
*/
公共静态void deleteKey（int-hkey，字符串键）
抛出IllegalArgumentException，IllegalAccessException，
调用目标异常
{
int rc=-1；
if（hkey==hkey_本地_机器）{
rc=deleteKey（systemRoot，hkey，key）；
}
else if（hkey==hkey\U当前用户）{
rc=deleteKey（userRoot，hkey，key）；
}
如果（rc！=注册成功）{
抛出新的IllegalArgumentException（“rc=“+rc+”key=“+key”）；
}
}
/**
*从给定的键/值名称中删除值
*@param-hkey
*@param-key
*@param值
*@galargumentException
*@galacessException
*@targetException
*/
公共静态void deleteValue（int-hkey、字符串键、字符串值）
抛出IllegalArgumentException，IllegalAccessException，
调用目标异常
{
int rc=-1；
if（hkey==hkey_本地_机器）{
rc=删除值（systemRoot、hkey、key、value）；
}
else if（hkey==hkey\U当前用户）{
rc=deleteValue（userRoot、hkey、key、value）；
}
如果（rc！=注册成功）{
抛出新的IllegalArgumentException（“rc=“+rc+”key=“+key+”value=“+value”）；
}
}
// =====================
私有静态删除值
（首选项根、int-hkey、字符串键、字符串值）
抛出IllegalArgumentException，IllegalAccessException，
调用目标异常
{
int[]句柄=（int[]）regOpenKey.invoke（根，新对象[]）{
新整数（hkey）、toCstr（key）、新整数（key\u ALL\u ACCESS）}）；
如果（处理[1]！=注册成功）{
返回句柄[1]；//可以是REG\u NOTFOUND，REG\u ACCESSDENIED
}
在里面

相关文章：

发表评论 取消回复

发表评论取消回复