精华内容
下载资源
问答
  • spring boot如何引入XML文件

    千次阅读 2018-11-14 17:05:02
    Spring boot框架建议我们使用Java配置的方式去配置系统的应用,但是如果有时候我们必须要使用到XML...注解的源代码如下,可以看到value和locations都是字符串数组,所以我们可以传递多个XML文件 @Retention(Ret...

    Spring boot框架建议我们使用Java配置的方式去配置系统的应用,但是如果有时候我们必须要使用到XML配置文件。
    那么可以在@SpringBootApplication这个注解标注的主类中使用@ImportResource注解去导入我们的XML配置文件

    注解的源代码如下,可以看到value和locations都是字符串数组,所以我们可以传递多个XML文件

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE})
    @Documented
    public @interface ImportResource {
        @AliasFor("locations")
        String[] value() default {};
    
        @AliasFor("value")
        String[] locations() default {};
    
        Class<? extends BeanDefinitionReader> reader() default BeanDefinitionReader.class;
    }

    关注微信公众号(程序员小兔)不定期分享技术

    展开全文
  • Java加载XML文件

    千次阅读 2007-10-16 22:36:00
    我们现在就讨论一下如何使用Java加载XML文件并访问其中的元素。 为了简化编写处理XML的应用程序,W3C已制订出多种编程接口,其中包含的DOM和SAX(Simple API for XML)较为典型。在Java应用程序中要需要

            一个单独的XML文件不能做任何的工作,它需要与应用程序结合起来实现各种功能,应用程序通过XML解析器和XML应用程序接口处理XML文件。我们现在就讨论一下如何使用Java加载XML文件并访问其中的元素。

            为了简化编写处理XML的应用程序,W3C已制订出多种编程接口,其中包含的DOM和SAX(Simple API for XML)较为典型。在Java应用程序中要需要使用JAXP(Java API for XML)创建DOM或是SAX解析器来访问XML文件。

            JAXP使得用Java开发处理XML数据的应用程序非常容易,JAXP包括语法分析器、标准SAX与DOM,可么选择以事件流或是建立对象表示来解析数据。JAXP1.1版本还支持XSLT标准,可以控制数据表表示,并可以将数据转换成其他的XML文件或格式,如HTML。

            JAXP提供的类和方法,可以让Java应用程序使用DOM解析或转换XML文件。在JDK 1.4支持的JAXP API 1.1版支持XML。

    说明

    Javax.xml.parsers 提供处理XML文件的类
    Javax.xml.transform 提供处理XSLT文件的类
    org.xml.sax 这是SAX解析器,提供以事件驱动方式解析XML文件的API
    org.xml.saxheplers 提供解析错误处理的相关类,可以帮助程序设计者使用SAX API
    org.w3c.dom 提供支持DOM建议规格的包


     

     

     

     

     

             在Java中想要加载XML文件,首先要引入与XML相关的类包

    import javax.xml.parsers.*;
    import org.xml.sax.*;
    import org.w3c.dom.*;
    import java.io.*;

            在JAXP中DOM解析器称为DocumentBuilder,可以通过工厂类DocumentBuilderFactory获得,而document对象则可以通过类DocumentBuild获得,使用try catch指令建立解析错误处理。在建立 DocumentBuild对象后,可以使用其Parser方法解析加载XML文件,file对象加载后就可以处理XML文件的结点内容,程序块的架构如下

    DocumentBuilderFactor dbf = DocumentBuilderFactory.newInstance();
    try {
      DocumentBuilder db 
    = dbf.newDocumentBuilder();
      document 
    = db.parser(new File(args[0]));
      .....
    }

    catch(SAXException se) {
      
    //解析过程错误
      Exception e = se;
      
    if (se.getException() != null{
        e 
    = se.getException();
        e.printStackTrack();
      }

    }

    catch(ParserConfigurationException pe) {
      
    //解析器设置错误
      pe.printStackTrace();
    }

    catch(IOException ie) {
      
    //文件处理错误
      ie.printStackTrace();
    }
            获得document实例后,就可以对DOM的文档树进行访问了,如果要遍历DOM文档,首先要获得根结点,然后获得根结点的子结点列表。
    //获取根结点
    Element element = document.getDocumentElement();
    //获取根结点的子结点列表
    NodeList = element.getChildNodes();
           
    展开全文
  • Java操作XML文件(写)

    千次阅读 2015-09-12 18:03:57
    Java操作XML文件(写),同XML文件的读取一样,生成或写入XML文件也有四种方式,分别为DOM,SAX,DOM4J和JDOM。

    一 概述

    同XML文件的读取一样,生成或写入XML文件也有四种方式,分别为DOM,SAX,DOM4J和JDOM,其中前两种为官方,后两种第三方API,需要相应jar包,其它详见Java操作XML文件(读)这篇文章,这里不是累述。

    二 DOM方式生成

    DOM方式的生成是基于树(tree)结构,首先生成树(root)节点,生成的DOM树会驻留在内存中,这样优点是方便随时增删改,所以如果XML需要频繁的修改,推荐这种方式。具体代码如下:

        package com.jamie.writer;
        import java.io.File;
        import javax.xml.parsers.DocumentBuilder;
        import javax.xml.parsers.DocumentBuilderFactory;
        import javax.xml.parsers.ParserConfigurationException;
        import javax.xml.transform.OutputKeys;
        import javax.xml.transform.Transformer;
        import javax.xml.transform.TransformerConfigurationException;
        import javax.xml.transform.TransformerException;
        import javax.xml.transform.TransformerFactory;
        import javax.xml.transform.dom.DOMSource;
        import javax.xml.transform.stream.StreamResult;
    
        import org.w3c.dom.Document;
        import org.w3c.dom.Element;
    
        public class DomWriter {
    
            public static void main(String[] args) {
                // 创建一个DocumentBuilderFactory对象
                DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
                // 创建DocumentBuilder对象
                try {
                    DocumentBuilder db = dbf.newDocumentBuilder();
                    // 获得一个Document对象,写入xml结构
                    Document document = db.newDocument();
                    // 去掉standalone属性
                    document.setXmlStandalone(true);
                    // 创建一个根节点
                    Element classElement = document.createElement("class");
                    // 生产根节点下的子节点,并添加属性
                    Element personElement = document.createElement("person");
                    personElement.setAttribute("id", "1");
                    // 添加name 标签,并赋值
                    Element nameElement = document.createElement("name");
                    nameElement.setTextContent("小明");
                    personElement.appendChild(nameElement);
                    // 将子节点person添加到根节点class
                    classElement.appendChild(personElement);
                    // 将根节点添加到document,生产一个dom树
                    document.appendChild(classElement);
    
                    // 创建xml文件,需要一个TransformerFactory对象
                    TransformerFactory tff = TransformerFactory.newInstance();
                    try {
                        // 创建一个Transformer对象
                        Transformer tf = tff.newTransformer();
                        tf.setOutputProperty(OutputKeys.INDENT, "yes");
                        tf.transform(new DOMSource(document), new StreamResult(
                                new File("clsss.xml")));
                    } catch (TransformerConfigurationException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (TransformerException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
    
                } catch (ParserConfigurationException e) {
                    e.printStackTrace();
                }
    
            }
        }

    三 SAX方式生成

    SAX方式生成XML是基于事件模型的,当把某一标签走完后,不能走回头路,因为它没有状态性可言,即无法返回修改某一完成的标签,但是SAX的效率很高。具体代码如下:

        package com.jamie.writer;
    
        import java.io.File;
        import java.io.FileNotFoundException;
        import java.io.FileOutputStream;
        import java.io.IOException;
    
        import javax.xml.transform.OutputKeys;
        import javax.xml.transform.Result;
        import javax.xml.transform.Transformer;
        import javax.xml.transform.TransformerConfigurationException;
        import javax.xml.transform.sax.SAXTransformerFactory;
        import javax.xml.transform.sax.TransformerHandler;
        import javax.xml.transform.stream.StreamResult;
    
        import org.xml.sax.SAXException;
        import org.xml.sax.helpers.AttributesImpl;
    
        public class SaxWrite {
            public static void main(String[] args) {
                // 创建一个SAXTransformerFactory
                SAXTransformerFactory stff = (SAXTransformerFactory) SAXTransformerFactory
                        .newInstance();
                try {
                    // 获取TransformerHandler对象
                    TransformerHandler handler = stff.newTransformerHandler();
                    // 通过handler创建Transformers对象
                    Transformer former = handler.getTransformer();
                    // 通过Transformer对象对生成的xml文件进行设置
                    former.setOutputProperty(OutputKeys.INDENT, "yes");
                    former.setOutputProperty(OutputKeys.ENCODING, "utf-8");
                    // 创建一个result对象,用于进行文件的创建和文件输出流的编写,并使其与handler对象关联
                    File f = new File("sax.xml");
                    if (!f.exists()) {
                        f.createNewFile();
                    }
                    Result rs = new StreamResult(new FileOutputStream(f));
                    handler.setResult(rs);
                    // 利用handler对象进行xml内容的编写
                    // 打开doument
                    handler.startDocument();
                    // 创建Attribute对象,用户重复利用
                    AttributesImpl attrs = new AttributesImpl();
                    handler.startElement("", "", "class", attrs);
                    attrs.clear();
                    attrs.addAttribute("", "", "id", "", "1");
                    // 创建person标签
                    handler.startElement("", "", "person", attrs);
                    attrs.clear();
                    // 创建name标签
                    handler.startElement("", "", "name", attrs);
                    String name = "小明";
                    handler.characters(name.toCharArray(), 0, name.length());
                    handler.endElement("", "", "name");
                    handler.endElement("", "", "person");
                    handler.endElement("", "", "class");
                    // 关闭document
                    handler.endDocument();
                } catch (TransformerConfigurationException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (SAXException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
    
            }
        }

    四 DOM4J方式生成

    DOM4J是基于底层API(也就是官方的提供的方式,DOM和SAX)的一种生成方式,效率一般来说仅次于SAX,并且在功能和使用的便捷方面都很强大,所以也是现实开发中比较常用的一种方式。具体代码如下,别忘了引入相应的jar:

        package com.jamie.writer;
        import java.io.File;
        import java.io.FileOutputStream;
        import java.io.IOException;
        import org.dom4j.*;
        import org.dom4j.io.OutputFormat;
        import org.dom4j.io.XMLWriter;
    
        public class Dom4jWriter {
    
            public static void main(String[] args) {
                // 调用生成方法
                Dom4jWriter dom4j = new Dom4jWriter();
                dom4j.createXml();
            }
    
            /**
             * 生成方法
             */
            public void createXml() {
                // 使用DocumentHelper创建Document对象,即整个xml文档
                Document document = DocumentHelper.createDocument();
                // 创建根节点class 及相应的节点,注意addElement方法的依属关系
                Element classEle = document.addElement("class");
                Element personEle = classEle.addElement("person");
                Element nameEle = personEle.addElement("name");
                personEle.addAttribute("id", "1");
                nameEle.setText("小明");
                // 设置生成xml内容的格式,换行
                OutputFormat of = OutputFormat.createPrettyPrint();
                System.out.println(document.asXML());
                // 设置编码
                of.setEncoding("UTF-8");
                File fileWriter;
                try {
                    // 创建文件
                    fileWriter = new File("dom4j.xml");
                    // dom4j提供的专门的文件写入对象XMLWriter
                    XMLWriter xmlWriter = new XMLWriter(
                            new FileOutputStream(fileWriter), of);
                    xmlWriter.write(document);
                    xmlWriter.flush();
                    xmlWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
        }

    五 JDOM方式生成

    与DOM4J类似JDOM也是一种第三方的基于底层API方式的一种操作XML文件的工具,它基于树型结构,利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。与其它方式相比,它使用起来更便捷,但是效率较低,建议在小文档情况下使用。代码如下:

        package com.jamie.writer;
    
        import java.io.File;
        import java.io.FileNotFoundException;
        import java.io.FileOutputStream;
        import java.io.IOException;
        import java.io.OutputStream;
        import java.io.OutputStreamWriter;
    
        import org.jdom2.Document;
        import org.jdom2.Element;
        import org.jdom2.output.Format;
        import org.jdom2.output.XMLOutputter;
    
        public class JdomWriter {
            public static void main(String[] args) {
                JdomWriter jd = new JdomWriter();
                jd.createXml();
            }
    
            public void createXml() {
                // 创建根节点
                Element root = new Element("class");
                // 生成一个document对象
                Document document = new Document(root);
                // 创建person节点
                Element person = new Element("person");
                person.setAttribute("id", "1");
                root.addContent(person);
                // 创建nam节点
                Element name = new Element("name");
                name.setText("小明");
                person.addContent(name);
                // 对xml进行排版格式化,两种方式
                Format format = Format.getPrettyFormat();
                /*
                 * Format format =Format.getCompactFormat(); format.setIndent("");
                 */
                // 创建XMLOutputter对象
                XMLOutputter out = new XMLOutputter(format);
                // 使用XMLOutputter对象将Document对象转成xml文档
                try {
                    out.output(document, new FileOutputStream(new File("jdom.xml")));
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    六 总结

    以上代码生成的xml文件内容都应该如下:

        <?xml version="1.0" encoding="UTF-8"?>
            <class>
              <person id="1">
                <name>小明</name>
              </person>
            </class>

    例子都比较简单,但是常用的涉及到了,几种方法中最常用的还是属于DOM4J的方式,现在很多框架中也使用这种方式。
    以上代码都是自己一个个敲的,一是让自己加深学习印象,二是如果可以也给需要的人做一个参考。因为自己还在初级学习阶段,如果有问题,希望有心人指出,相互交流学习,谢谢!

    展开全文
  • java获取xml文件中bean(包括自定义)

    千次阅读 2017-12-13 18:01:00
    java获取xml文件中bean(包括自定义)

    xml中声明自定义的bean和引入bean

    <bean name="SpringContextUtil" class="com.shiro.utils.SpringContextUtil" scope="singleton"/>
    	
    	<bean name="customBean" class="com.shiro.utils.customBean"/>

    引入bean中的内容,自定义bean代码随意

    package com.shiro.utils;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.NoSuchBeanDefinitionException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    
    /**
     * 上下文util
     * @author eadela
     *
     */
    public class SpringContextUtil implements ApplicationContextAware {
    	
    	private static ApplicationContext applicationContext; 
    
    	@Override
    	public void setApplicationContext(ApplicationContext applicationContext)
    			throws BeansException {
    		SpringContextUtil.applicationContext = applicationContext;
    	}
    
    	public static ApplicationContext getApplicationContext() {
    		return applicationContext;
    	}
    
    	public static Object getBean(String name) throws BeansException {
    		try {
    			return applicationContext.getBean(name);
    		} catch (Exception e) {
    			throw new RuntimeException("获取的Bean不存在!");
    		}
    	}
    
    	public static <T> T getBean(String name, Class<T> requiredType)
    			throws BeansException {
    		return applicationContext.getBean(name, requiredType);
    	}
    
    	public static boolean containsBean(String name) {
    		return applicationContext.containsBean(name);
    	}
    
    	public static boolean isSingleton(String name)
    			throws NoSuchBeanDefinitionException {
    		return applicationContext.isSingleton(name);
    	}
    
    	public static Class<? extends Object> getType(String name)
    			throws NoSuchBeanDefinitionException {
    		return applicationContext.getType(name);
    	}
    
    	public static String[] getAliases(String name)
    			throws NoSuchBeanDefinitionException {
    		return applicationContext.getAliases(name);
    	}
    }

    在需要的地方引入自定义bean

    public class CusUtil {
    	
    	final static CustomBean cus = SpringContextUtil.getBean("customBean", CustomBean.class);
    }
    这样在CusUtil中就可以引用CustomBean 内的内容



    展开全文
  • java一种简单的解析xml方法是用DOM进行解析, dom4j是一个Java的XML API,类似于jdom,用来读写XML文件的,dom4j用于处理xml是很常用的技术,本篇博客介绍xml文件表建立及读取环境搭建并采用DOM4J完成XML文件导入到...
  • XML文档定义分为DTD和Schema两种形式,二者都是对XML语法的约束,其本质区别在于Schema本身也是一个XML文件,可以被XML解析器解析,而且可以为XML承载的数据定义类型,约束能力较之DTD更强大。 对XML的解析主要有...
  • java解析xml文件,返回xml字符串

    千次阅读 2016-05-04 14:59:29
    public static String toStringFromDoc(Document document) { String result = null; if (document !...没有依赖什么第三方的jar,都是jdk自带,引入包就行了。
  • Java操作XML文件 dom4j 篇

    千次阅读 2008-02-10 20:38:00
    今天就来讲一下Java 中使用dom4j来操作XML文件。我们需要引入的包:/文件包 import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileWriter; //工具包 import java.util.Ite
  • SAXReader读取XML文档 使用SAXReader需要导入dom4j-full.jar包,DOM4J是一个优秀的Java XML API,具有性能优异、功能强大和易用的特点,同时它也是一个开放源代码的软件。 可以使用Maven的pom.xml引入包,或是你...
  • java使用JDOM接口解析xml文件,包含创建、增删查改、保存,读取等操作。需要引入jdom.jar,下载 xercesImpl.jar,下载测试代码 public static void main(String[] args) { Document docjdom = creat_xml();
  • java读取xml配置文件

    千次阅读 2017-05-03 11:37:06
    1.配置文件的好处, xml配置文件的优点, 当改变底层配置时 不需要改变和重新编译代码,只需要在xml中更改就可以了 2.先看下项目架构 3.static的作用 static表示“全局”或者“静态”的意思,用来修饰成员变量和成员...
  • 但是在实际应用中也会存在不得不添加配置文件的情况,例如集成其他框架或者需要配置一些中间件等,在这种情况下,我们就需要引入我们自定义的xml配置文件了。 正文 1.创建springboot项目,项目结构如下: 2....
  • Java 解析 XML

    千次阅读 2011-08-23 00:17:29
    XML 现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关  性,给数据集成与交互带来了极大的方便....方法,任何计算机高级语言都可以实现对 XML 的读写操作, 本节将学习 JavaXML
  • 简析JAVAXML编程(java-xml初学者)

    千次阅读 2006-04-19 16:59:00
    简析JAVAXML编程(java-xml初学者)作者名字忘了,當時時在網上找的一貼子,以后看到了再補上,對不住了。个人认为这篇文章通俗易懂,值得推荐。XML作为全球通用的结构化语言,越来越受人们青睐,各种开发平台(比如...
  • java 代码: //import android.support.v4.view.PagerAdapt //import android.support.v4.view.ViewPager; 新版本androidx包中改为 import androidx.viewpager.widget.PagerAdapter; import androidx.viewpager....
  • java实现xml读写操作

    千次阅读 2017-02-27 22:32:36
    DOM: 一次性将整个xml文件加载到内存中,进行解析 SAX: 逐层向下解析 需要引入对应的jar包 DOM4J, JDOM 读取xml我们分别做解析,先来看看需要我们解析的xml文件内容<?xml version="1.0" encoding="UTF-8"?> ...
  • Activity创建的java文件和xml文件 作用: Android布局以xml形式写在res/layout文件夹中,这样不光可以将将前台界面与业务逻辑区分开,让代码更加清晰,将这些控件放到xml文件中是android为了保证MVC架构的一个很重要...
  • 本文简要的讨论了Java语言编程中更新XML文档的四种常用方法,并且分析这四种方法的优劣。其次,本文还对如何控制Java程序输出的XML本文简要的讨论了Java语言编程中更新XML文档的四种常用方法,并且分析这四种方法的...
  • java学习——XML文件导入

    千次阅读 2015-10-06 14:30:33
    今天我们就来介绍一下导入XML文件。 在实际应用中,导入是一项很重要的功能,一般来说我们常用的是导入Excel,Word等,但是今天我们要导入的是XML文件,因为XML是一种纯文本文件,具有很好的兼容性和可扩展性,在...
  • 它使您能够快速检查输入内容是否大致符合您的期望,并快速拒绝任何与流程无法处理的文档。 如果数据有问题,最好早发现。 在可扩展标记语言(XML)的上下文中,验证通常涉及使用几种架构语言(例如,万维网联合会...
  • Java解析XML

    千次阅读 2014-03-06 13:55:44
    Java解析XML XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便.  W3C定义了XML的语法以及XML的读写操作方法,任何计算机高级语言都可以实现对XML...
  • XML文档引入外部DTD文件

    千次阅读 2012-01-08 10:55:33
    XML文档通过使用DOCTYPE声明语句(文档类型定义语句)来指明它所遵循的DTD文件, DOCTYPE声明语句紧跟在XML文档声明语句后面,有两种格式: 1. 2.   例如: 1. 2. "-//Sun Microsystems,Inc.//DTD Web ...
  • java读取xml和property配置文件的方法

    千次阅读 2017-06-14 11:46:05
    在软件开发过程中,有很多时候会有配置项的设置,通常配置项均是以key-value键值对的形式出现的,而比较常用的配置文件为Property和XML两种。 XML配置文件解析-DOM有以下配置文件config.xml,里面配置了不同的系统...
  • 找到一篇好博,其中方案二亲测有效,非常nice! ... 然后如果方法二找不到文件就把 JsonUtils.class.getResourceAsStream("student.xml") 改成 JsonUtils.class.g...
  • Java XML Schema

    千次阅读 2012-10-10 21:54:41
    XML Schema 也是一种用于定义和描述 XML文档结构与内容的模式语言,其出现是为了克服 DTD 的局限性 XML Schema VS DTD: XML Schema符合XML语法结构。 DOM、SAX等XML API很容易解析出XML Schema文档中的内容。 ...
  • Java】读取xml文件字段值

    千次阅读 2017-12-11 14:12:26
    需求:读取用户发送的xml文件,得到"BBZ001"节点的值。格式如下: xxx xxx 解决:引入“org.w3c.dom.Document”包通过document类得到xml的节点值 //1、创建一个DocumentBuilderFactory的对象 ...
  • Java加载XML的方法

    千次阅读 2009-02-25 13:41:00
    我们现在就讨论一下如何使用Java加载XML文件并访问其中的元素。 为了简化编写处理XML的应用程序,W3C已制订出多种编程接口,其中包含的DOM和SAX(Simple API for XML)较为典型。在Java应用程序中要需要使用JAXP(Ja
  • 今日目录 1、JDOM 引入 2、DOM4J 引入一、JDOM 引入 JDOM 是一种使用 XML(标准通用标记...下载地址:JDOM下载地址二、DOM4J 引入 dom4j 是一个 JavaXMLAPI,类似于 jdom,用来读写 XML 文件的。dom4j 是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 274,734
精华内容 109,893
关键字:

java引入xml文件

java 订阅