❶ java读取配置文件的方法(xml)
#include <XMLDoc.hpp>
——相关说明
_di_IXMLDocument 为模板类
typedef System::DelphiInterface< IXMLDocument > _di_IXMLDocument;
_di_IXMLNode
typedef System::DelphiInterface< IXMLNode > _di_IXMLNode;
_di_IXMLNodeList 同
——类方法
//设置参数
void TXXX::setOptions(String name,String value){
//创建文档对象
_di_IXMLDocument XMLDoc = LoadXMLDocument(L"文件路径");
XMLDoc->Active=true;
//文档根节点
_di_IXMLNode root = XMLDoc->DocumentElement;
//想要查找节点
_di_IXMLNode tempNode;
//调用搜索方法
searchXml(name,root,tempNode);
// 处理
if(tempNode!=NULL)
tempNode->SetText(value);
XMLDoc->SaveToFile(L"文件路径");
}
//递归搜索参数节点树
void TXXX::searchXml(String name,_di_IXMLNode &Parent_Node,_di_IXMLNode& tempNode){
_di_IXMLNode Child_Node; //子结点
//子节点列表
_di_IXMLNodeList list = Parent_Node->ChildNodes;
for(int i=0;i<list->Count;i++)
{
Child_Node = list->Get(i);
//递归结束条件
if(Child_Node->GetNodeName()==name)
{
tempNode = Child_Node;
break;
}
else
{
//递归函数
searchXml(name,Child_Node,tempNode);
}
}
}
❷ java 读取和修改本地xml配置文件
dom4j解析
package demo;
import java.io.*;
import org.dom4j.*;
import org.dom4j.io.*;
import java.util.*;
public class WriteXML {
public void writer(){
//在内存中创建一个文档对象
Document doc=DocumentHelper.createDocument();
//往文档对象中添加一个元素
Element root=doc.addElement("users");
//将上面创建元素的设为根元素
doc.setRootElement(root);
//为根元素添加一个名称为user的子元素
Element user1=root.addElement("user");
//为user子元素添加一个id的属性 并赋值
user1.addAttribute("id","1");
//为user子元素添加一个子元素
Element name1=user1.addElement("name");
//为name子元素设置文本
name1.setText("zz");
Element config1=user1.addElement("config");
config1.setText("fullscreen");
Element user2=root.addElement("user");
//为user子元素添加一个id的属性 并赋值
user2.addAttribute("id","2");
//为user子元素添加一个子元素
Element name2=user2.addElement("name");
//为name子元素设置文本
name2.setText("xx");
Element config2=user2.addElement("config");
config2.setText("widescreen");
//下面将会进行输出产生XML文件
OutputFormat format=OutputFormat.createPrettyPrint();
format.setEncoding("GBK");
format.setIndent(true);
format.setNewLineAfterNTags(1);
format.setNewlines(true);
try {
XMLWriter writer=new XMLWriter(new FileOutputStream("users.xml"),format);
writer.write(doc);
writer.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
/*
Element user2=user1.createCopy();
user2.attribute("id").setValue("2");
Iterator it=user2.elementIterator();
while(it.hasNext()){
it.next();
}*/
}
}
❸ Java如何读取XML文件 具体实现
xml的解析
1.解析式为了得到里面的内容，进行增,删，改查的操作
XML的解析方式
SAX(Simple API for XML)xml文档的一种简单的解析方式
DOM(Document Object Model)
DOM4J
SAX：基于事件的解析方式
DOM: 基于对象的解析方式
事件监听三要素
1.事件源
2.监听器
3.事件
SAX 基于事件的解析
优点: 简单 效率高
缺点:顺序执行,不能得到某个元素 不能逆向执行
不能进行增，与删的操作
SAX解析方式工作原理：
通过时间源xml文档创建SAXParseFactory
SAXParserFactory factory=SAXParserFactory.newInstance();
得到一个解析器
SAXParser parse=factory.newSAXParser();
对xml文件进行解析
得到解析的文件对象
File file=new File("employees.xml");
通过监听器进行解析
MyListener listener=new MyListener();
parse.parse(file,listener);
对于监听器有5个方法：监听器所在的类实现的接口有：
org.xml.sax.hepers.DefaultHandler
org.xml.sax
通过查看API文档中的DefaultHandler类中的下面5个方法
startDocument() 对于文档开始的解析
public void startDocument()throws SAXException{
System.out.println("文档开始解析啦!!!!");
}
startElement()元素开始的解析其中几个名词
url:命名空间的url
localName:命名空间的前缀
qName:元素
attributes:元素里的属性
public void startElement(String url,String localName,String qName,Attributes attributes)throws SAXException{
StringBuffer sb=new StringBuffer();
sb.append("<"+qName);
for(int i=0;i<attributes.getLength();i++){
String attName=attributes.getQName(i);获得元素属性名称其中的i为元素的第几个属性
String attValue=attributes.getValue(i);获得元素属性的值其中的i为元素的第几个属性的值
sb.append(attName+"="+attValue);
}
sb.append(">");
System.out.print(sb.toString());
}
character()获得元素的内容体
public void characters(char[]ch,int start,int length)throws SAXException{
System.out.print(new String(ch,start,length));
}
endElement()获得元素的结束事件
public void endElement(String url,String localName,String qName)throws SAXException{
System.out.print("</"+qName+">");
}
endDocument()获得文档的结束事件
public void endDocument(){
System.out.println("文档解析结束啦!!!!");
}
对于SAX解析只能逐行解析不能越行解析
DOM:基于对象的
优点:灵活,能进行增删的操作
缺点:读取速度慢，效率低 占用的内容多
对于DOM解析：不需要添加监听器，按级解析从根元素、一级子元素、二级子元素......
同SAX解析相同刚开始也是要得到一个解析器;
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance() ;
因为构造方法不可用不可以new对象只能用newInstance()方法得到解析器对象
DocumentBuilder builder=factory.newDocumentBuilder() ;得到一个解析器
对于document可以有两种方法得到：
Document document= builder.parse(new File(文件路径));通过parse方法解析一个已有的xml文档
Document document=builder.newDocument();可以得到一个空的document对象
得到根节点
Element root=document.getDocumentElement();
如果不存在根节点即为一个空document对象的时候只能添加跟节点
Element root=document.createElement(根节点的名字)
得到根节点下面的所有一级子元素
NodeList list=root.getElementsByTagName(根节点的名字可以用root.getTagName或者root.getNodeName()得到根节点的名字)();
{
对与document可以添加一级子元素
不管document是否为空都可以添加
Element firstElements =root.creatElement(一级子元素的名字);
当然也可以为一级子元素添加属性
一级子元素的名字.setAttribute("属性名","属性值");
}
通过遍历list集合
for(int i=0;i<list.getLength();i++){
Element first_elements=(Element)list.item(i);
可以得到一级资源的属性的值当知道属性的时候
String attribute=first_elements.getAttribute("属性的名字");
得到一级子元素的名字
String first_elements_name=first_elements.getNodeName();
得到一级子元素下面所有的元素如id 第一个id元素当然也可有很多个id
通过item()来确定要取那个id
Element id_element=(Element)first_elements.getElementByName("id").item(0);
得到id的值
String id_value=id_element.getFirstChild().getTextContent();
通过这个遍历集合可以拿到所有子元素
}
DOM添加或删除元素：
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance() ;
因为构造方法不可用不可以new对象只能用newInstance()方法得到解析器对象
DocumentBuilder builder=factory.newDocumentBuilder() ;得到一个解析器
对于document可以有两种方法得到：
Document document= builder.parse(new File(文件路径));通过parse方法解析一个已有的xml文档
Document document=builder.newDocument();可以得到一个空的document对象
得到根节点
Element root=document.getDocumentElement();
如果不存在根节点即为一个空document对象的时候只能添加跟节点
Element root=document.createElement(根节点的名字)
对与document可以添加一级子元素
不管document是否为空都可以添加
Element firstElements =root.creatElement(一级子元素的名字);
当然也可以为一级子元素添加属性
一级子元素的名字.setAttribute("属性名","属性值");
添加二级子元素
Element secondElements=firstElements.creatElement("二级子元素的名字");
挂载组装
一级子元素firstElements.append(secondElements);
根节点root.appendChild(firstElements);
将document对象树写入磁盘
TransformerFactory tf=TransformerFactory.newInstance();
Transformer former=tf.newTransformer();
DOMSource source=new DOMSource(document);
StreamResult result= new StreamResult(new File("10.xml"));结果集
former.transform(source,result);
完毕
DOM4j需要借助外部jar包
需要借助外部jar包就必须设置环境变量中的classpath把classpath设置成
dom4j jar包存在的路径（绝对路径）
例如:
set classpath=.;C:\Documents and Settings\Administrator\桌面\day3\dom4j.jar
import org.dom4j.io.*;
import java.io.*;
import java.util.*;
import org.dom4j.*;
public static void read_XML(String fileName){
try{
//得到一个解析器，相当于SAX,DOM里面的解析器工厂，与解析器
SAXReader reader=new SAXReader();
//得到一个对象树
Document document=reader.read(new File(fileName));
//得到一个根元素
Element root=document.getRootElement();
System.out.println(root.getName());
//得到所有的一级子元素
List firstElements=root.elements();
Iterator it=firstElements.iterator();
while(it.hasNext()){
//依次得到每一个一级子元素
Element firstElement=(Element)it.next();
System.out.println(firstElement.getName());
//得到所有的属性
List attributes=firstElement.attributes();
for(Object obj:attributes){
//依次得到每一个属性
Attribute att=(Attribute)obj;
System.out.println(att.getName()+"="+att.getValue());
}
//得到一级子元素下面的所有元素，及其附带值
List second_Elements=firstElement.elements();
Iterator second_Element=second_Elements.iterator();
while(second_Element.hasNext()){
Element sec_Element=(Element)second_Element.next();
System.out.println(sec_Element.getName()+":"+sec_Element.getText());
}
System.out.println("----------");
}
}catch(Exception e){
}
}
public static void write(String fileName){
try{
Document document = DocumentHelper.createDocument();
//创造一级子元素
Element books=document.addElement("books");
books.addComment("The book is J2EE");
Element book=books.addElement("book");
创建元素的属性
book.addAttribute("show","yes");
book.addAttribute("page","100");
创建二级子元素
Element book_name=book.addElement("bookName");
创建元素的内容体
book_name.setText("xml");
Element book_price=book.addElement("bookPrice");
book_price.setText("3000");
Element book_press=book.addElement("bookPress");
book_press.setText("etoak");
Element book_author=book.addElement("bookAuthor");
book_author.setText("Robin");
//挂载另一个一级子元素
book=books.addElement("book");
book.addAttribute("show","NO");
book.addAttribute("page","200");
book_name=book.addElement("bookName");
book_name.setText("葵花宝典");
book_price=book.addElement("bookPrice");
book_price.setText("无价之宝");
book_press.addElement("bookPress");
book_press.setText("华山派");
book_author=book.addElement("bookAuthor");
book_author.setText("林平之");
//创建xml文件输出的路径
OutputFormat format=OutputFormat.createPrettyPrint();
format.setEncoding("gbk");
XMLWriter xw=new XMLWriter(new FileOutputStream(fileName),
format);
//XMLWriter xx= new XMLWriter(System.out,OutputFormat.createPrettyPrint());
xw.write(document);
xw.flush();
xw.close();
}catch(Exception e){
对于DOM4j添加子元素，是一级一级的添加的而在DOM中是先创造
子元素然后再挂载的DOM4j在创建子元素的时候就确定好了顺序
对于文件的输出各有千秋各有特色其中SAX是需要添加监听器的
}
}
public static void update(String fileName){
try{
SAXReader reader= new SAXReader();
Document document = reader.read(new File(fileName));
Element root = document.getRootElement();
System.out.println(root.getName());
在根节点上添加一级子元素
Element student=root.addElement("student");
Element id=student.addElement("id");
id.setText("007");
OutputStream os= new FileOutputStream(fileName);
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter xw = new XMLWriter(os,format);
xw.write(document);
xw.flush();
xw.close();
}catch(Exception e){
和创建一个新的document对象类似只不过这个的根节点已经存在
直接可以在根节点上添加一级子元素；
}
}
❹ java中如何读取xml中数据。多节点的。给我一个例子，谢谢。
在我们的程序中,通常要有一些根据主机环境确定的变量.比如数据库访问用户名和密码,不同的主机可能设置不一样.只要更改XML配置文件,就可以正常运行.
localhost
sqlname
username
password
上面这个myenv.xml配置文件一般是放在tomcat的WEB-INF/classes目录下.
我们编制一个Java程序直接读取,将dbhost dbuser dbpassword提取出来供其他程序访问数据库用.
目前使用SAX比较的多,与DOM主要区别是 SAX是一行一行读取XML文件进行分析,适合比较大文件,DOM是一次性读入内存,显然不能对付大文件.这里我们使用SAX解析,由于SAX解析器不断在发展,网上有不少文章是针对老版本的.假如你使用JDK1.4 ,可以参考 使用SAX处理XML文档 一文.这里的程序是根据其改进并且经过实践调试得来的.
对上面myenv.xml读取的Java程序:
import org.xml.sax.Attributes;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.SAXException;
import java.util.Properties;
//使用DefaultHandler的好处 是 不必陈列出所有方法,
public class ConfigParser extends DefaultHandler {
////定义一个Properties 用来存放 dbhost dbuser dbpassword的值
private Properties props;
private String currentSet;
private String currentName;
private StringBuffer currentValue = new StringBuffer();
//构建器初始化props
public ConfigParser() {
this.props = new Properties();
}
public Properties getProps() {
return this.props;
}
//定义开始解析元素的方法. 这里是将中的名称xxx提取出来.
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException {
currentValue.delete(0, currentValue.length());
this.currentName =qName;
}
//这里是将之间的值加入到currentValue
public void characters(char[] ch, int start, int length) throws SAXException {
currentValue.append(ch, start, length);
}
//在碰到结束后,将之前的名称和值一一对应保存在props中
public void endElement(String uri, String localName, String qName) throws SAXException {
props.put(qName.toLowerCase(), currentValue.toString().trim());
}
}
上面的这个解析程序比较简单吧? 其实解析XML就是这么简单.
现在我们已经将dbhost dbuser dbpassword的值localhost sqlname username password提取了出来.但是这只是在在解析器内部,我们的程序还不能访问.需要再编制一个程序.
import java.util.Properties;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.net.URL;
public class ParseXML{
//定义一个Properties 用来存放 dbhost dbuser dbpassword的值
private Properties props;
//这里的props
public Properties getProps() {
return this.props;
}
public void parse(String filename) throws Exception {
//将我们的解析器对象化
ConfigParser handler = new ConfigParser();
//获取SAX工厂对象
SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setNamespaceAware(false);
factory.setValidating(false);
//获取SAX解析
SAXParser parser = factory.newSAXParser();
//得到配置文件myenv.xml所在目录. tomcat中是在WEB-INF/classes
//下例中BeansConstants是用来存放xml文件中配置信息的类,可以自己代替或定义
URL confURL = BeansConstants.class.getClassLoader().getResource(filename);
try
{
//将解析器和解析对象myenv.xml联系起来,开始解析
parser.parse(confURL.toString(), handler);
//获取解析成功后的属性 以后 我们其他应用程序只要调用本程序的props就可以提取出属性名称和值了
props = handler.getProps();
}finally{
factory=null;
parser=null;
handler=null;
}
}
}
由于我们的XML文件是使用最简单的形式 ,因此解析器相对简单,但是这已经足够对付我们的配置文件了.
❺ java 怎么读取配置文件
一.读取xml配置文件
(一)新建一个java bean(HelloBean. java)
java代码
(二)构造一个配置文件(beanConfig.xml)
xml 代码
(三)读取xml文件
1.利用
java代码
2.利用FileSystemResource读取
java代码
二.读取properties配置文件
这里介绍两种技术：利用spring读取properties 文件和利用java.util.Properties读取
(一)利用spring读取properties 文件
我们还利用上面的HelloBean. java文件，构造如下beanConfig.properties文件:
properties 代码
helloBean.class=chb.demo.vo.HelloBean
helloBean.helloWorld=Hello!chb!
属性文件中的"helloBean"名称即是Bean的别名设定，.class用于指定类来源。
然后利用org.springframework.beans.factory.support.来读取属性文件
java代码
(二)利用java.util.Properties读取属性文件
比如，我们构造一个ipConfig.properties来保存服务器ip地址和端口，如：
properties 代码
ip=192.168.0.1
port=8080
三.读取位于Jar包之外的properties配置文件
下面仅仅是列出读取文件的过程，剩下的解析成为properties的方法同上
1 FileInputStream reader = new FileInputStream("config.properties");
2 num = reader.read(byteStream);
3 ByteArrayInputStream inStream = new ByteArrayInputStream(byteStream, 0, num);
四.要读取的配置文件和类文件一起打包到一个Jar中
String currentJarPath = URLDecoder.decode(YourClassName.class.getProtectionDomain().getCodeSource().getLocation().getFile(), "UTF-8"); //获取当前Jar文件名，并对其解码，防止出现中文乱码
JarFile currentJar = new JarFile(currentJarPath);
JarEntry dbEntry = currentJar.getJarEntry("包名/配置文件");
InputStream in = currentJar.getInputStream(dbEntry);
//以上YourClassName是class全名，也就是包括包名
修改：
JarOutputStream out = new FileOutputStream(currentJarPath);
out.putNextEntry(dbEntry);
out.write(byte[] b, int off, int len); //写配置文件
。。。
out.close();
❻ java如何读取xml文件
// 读取输入流
SAXReader reader = new SAXReader();
Document document = reader.read(inputStream);
// 得到xml根元素
Element root = document.getRootElement();
// 得到根元素的所有子节点
List<Element> elementList = root.elements();
// 遍历所有子节点
for (Element e : elementList)
map.put(e.getName(), e.getText());
// 释放资源
inputStream.close();
inputStream = null;
参考http://blog.csdn.net/lyq8479/article/details/8949088
❼ java如何读取XML配置文件
学一下jdom吧，很简单的，可以很方便的提取xml的值，网上很多相关教程（推荐张龙的xml培训视频）
❽ JAVA技术:XML配置文件的读取处理
Java和XML是黄金组合，网上已经有很多文章介绍，XML作为电子商务中数据交换，已经有其不可替代的作用，但是在平时系统开发中，我们不一定都用到数据交换，是不是无法使用XML了？
当然不是，现在已经有一个新趋势，java程序的配置文件都开始使用XML格式，以前是使用类似windows的INI格式。（Java中也有Propertiesy这样的类专门处理这样的属性配置文件）。使用XML作为Java的配置文件有很多好处，从Tomcat的安装配置文件和J2ee的配置文件中，我们已经看到XML的普遍应用，让我们也跟随流行趋旦饥势用XML武装起来。
现在关键是如何读取XML配置模余返文件？有好几种XML解析器：主要有DOM和SAX ，这些区别网上文章介绍很多。
在apache的XML项目组中，目前有Xerces Xalan Cocoon几个开毁让发XML相关技术的project.Tomcat本身使用的是 Sun 的 JAXP，而其XSL Taglib project中使用Xerces解析器。
好了，上面都是比较烦人的理论问题，还是赶快切入XML的配置文件的读取吧。
在我们的程序中，通常要有一些根据主机环境确定的变量。比如数据库访问用户名和密码，不同的主机可能设置不一样。只要更改XML配置文件，就可以正常运行。
localhost
sqlname
username
password
上面这个myenv.xml配置文件一般是放在tomcat的WEB-INF/classes目录下。
我们编制一个Java程序直接读取，将dbhost dbuser dbpassword提取出来供其他程序访问数据库用。
目前使用SAX比较的多，与DOM主要区别是 SAX是一行一行读取XML文件进行分析，适合比较大文件，DOM是一次性读入内存，显然不能对付大文件。这里我们使用SAX解析，由于SAX解析器不断在发展，网上有不少文章是针对老版本的。如果你使用JDK1.4 ，可以参考 使用SAX处理XML文档 一文。这里的程序是根据其改进并且经过实践调试得来的。
对上面myenv.xml读取的Java程序：
import org.xml.sax.Attributes;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.SAXException;
import java.util.Properties;
//使用DefaultHandler的好处 是 不必陈列出所有方法,
public class ConfigParser extends DefaultHandler {
////定义一个Properties 用来存放 dbhost dbuser dbpassword的值
private Properties props;
private String currentSet;
private String currentName;
private StringBuffer currentValue = new StringBuffer();
//构建器初始化props
public ConfigParser() {
this.props = new Properties();
}
public Properties getProps() {
return this.props;
}
//定义开始解析元素的方法. 这里是将中的名称xxx提取出来.
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException {
currentValue.delete(0, currentValue.length());
this.currentName =qName;
}
//这里是将之间的值加入到currentValue
public void characters(char[] ch, int start, int length) throws SAXException {
currentValue.append(ch, start, length);
}
//在遇到结束后,将之前的名称和值一一对应保存在props中
public void endElement(String uri, String localName, String qName) throws SAXException {
props.put(qName.toLowerCase(), currentValue.toString().trim());
}
}
上面的这个解析程序比较简单吧？ 其实解析XML就是这么简单。
现在我们已经将dbhost dbuser dbpassword的值localhost sqlname username password提取了出来。但是这只是在在解析器内部，我们的程序还不能访问。需要再编制一个程序。
import java.util.Properties;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import .URL;
public class ParseXML{
//定义一个Properties 用来存放 dbhost dbuser dbpassword的值
private Properties props;
//这里的props
public Properties getProps() {
return this.props;
}
public void parse(String filename) throws Exception {
//将我们的解析器对象化
ConfigParser handler = new ConfigParser();
//获取SAX工厂对象
SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setNamespaceAware(false);
factory.setValidating(false);
//获取SAX解析
SAXParser parser = factory.newSAXParser();
//得到配置文件myenv.xml所在目录. tomcat中是在WEB-INF/classes
//下例中BeansConstants是用来存放xml文件中配置信息的类,可以自己代替或定义
URL confURL = BeansConstants.class.getClassLoader().getResource(filename);
try
{
//将解析器和解析对象myenv.xml联系起来,开始解析
parser.parse(confURL.toString(), handler);
//获取解析成功后的属性 以后 我们其他应用程序只要调用本程序的props就可以提取出属性名称和值了
props = handler.getProps();
}finally{
factory=null;
parser=null;
handler=null;
}
}
}
由于我们的XML文件是使用最简单的形式 ，因此解析器相对简单，但是这已经足够对付我们的配置文件了。
❾ Java读取xml配置文件:
你用DOM把账号节点取出来
然后用String中的split方法做切割
就可以放到数组里了
如果单纯是想看账号是不是在这个里面
你也可以直接String.indexof查找读出来的信息中有没有你要的账号