精华内容
下载资源
问答
  • 超大xml文件解析

    千次阅读 2011-02-25 15:59:08
    对于普通大小xml解析,现在有许多的插件能很好的支持,比如dom4j,JDOM等,由于已经做过一层封装。因此,用起来也很方便。 当然对于这样的xml解析没有什么问题,也不必花费笔墨去探讨了。 前两天遇到一个300多M的...

    对于普通大小xml的解析,现在有许多的插件能很好的支持,比如dom4j,JDOM等,由于已经做过一层封装。因此,用起来也很方便。

    当然对于这样的xml解析没有什么问题,也不必花费笔墨去探讨了。

    前两天遇到一个300多M的超大xml解析,基本用什么编辑器打开,什么编辑器就崩溃的。

    如果用类似dom4j等解析方式,在解析之前需要把文件先加载到内存

     File xmlFile = new File(fileName);

     

      SAXReader saxReader = new SAXReader();
     Document document = saxReader.read(xmlFile);
    由于文件超大,基本什么服务器都会OutOfMemory;不给力了啊····结果也可想而知

    后来使用了 SAX处理方式,解析一点文件读取一点到内存,这样就不会再出现内存溢出情况,具体请看代码
    AnalyticElongHotelXml analyticElongHotelXml = new AnalyticElongHotelXml(elongHotelsDAO);
       SAXParserFactory sf = SAXParserFactory.newInstance();
       SAXParser sp = sf.newSAXParser();
      import com.mm.components.elong.dao.ElongHotelsDAO;
     


    import com.mm.components.elong.domain.ElongHotels;
    import com.mm.components.elong.domain.ElongImages;
    import com.mm.components.elong.domain.ElongRooms;
    import com.mm.exception.MMException;
    import com.mm.util.StringUtils;
    import org.xml.sax.Attributes;
    import org.xml.sax.InputSource;
    import org.xml.sax.SAXException;
    import org.xml.sax.helpers.DefaultHandler;
    
    import javax.xml.parsers.SAXParser;
    import javax.xml.parsers.SAXParserFactory;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /**
     * 解析elong Hotel_cn.xml文件
     * <p>Title: </p>
     * <p>Description: </p>
     * <p>Copyright: Copyright (c) 2011</p>
     * <p>Company: Yododo</p>
     * <p>Date: 2011-2-15</p>
     * <p>Time: 15:01:14</p>
     *
     * @author eng
     *         $Header: $
     *         $Revision: $
     *         $Author: $
     */
    public class AnalyticElongHotelXml extends DefaultHandler {
    
        private ElongHotelsDAO elongHotelsDAO = null;
    
        java.util.Stack tags = new java.util.Stack();
    
        private String fatherQName = "";
        private boolean isFromEndElement = false;
    
        private static List<ElongHotels> hotels = null;
        private static List<ElongImages> images = null;
        private static List<ElongRooms> rooms = null;
    
        private ElongHotels hotel = null;
        private ElongImages image = null;
        private ElongRooms room = null;
    
        public AnalyticElongHotelXml() {
            super();
        }
    
        public AnalyticElongHotelXml(ElongHotelsDAO elongHotelsDAO) {
            super();
            this.elongHotelsDAO = elongHotelsDAO;
        }
    
        @Override
        public void characters(char ch[], int start, int length) throws SAXException {
    
            String tag = (String) tags.peek();
            String value = new String(ch, start, length);
            
            if(isFromEndElement){
                if(fatherQName.equals("image")){
                    initImageMsg(tag,value);
                }else if(fatherQName.equals("airportPickUpService")){
    
                }else if(fatherQName.equals("generalAmenities")){
                    if("Overview".equals(tag)){
                        hotel.setGeneralamenities(value);
                    }
                }
            }
        }
    
        @Override
        public void startElement(String uri,String localName,String qName, Attributes attrs) {
            tags.push(qName);
    
            isFromEndElement = true;
            if(qName.equals("HotelDetail")){
                hotel = new ElongHotels();
            }else if(qName.equals("image")){
                fatherQName = "image";
                image = new ElongImages();
            }
        }
    
        @Override
        public void endElement(String uri,String localName,String qName)
                throws SAXException {
    
            isFromEndElement = false;
            
            if(qName.equals("HotelDetail")){
                hotel.setImgurl(getoneimage());
                hotels.add(hotel);
                if(qName.equals("image")){
                image.setHotelid(hotel.getHotelid());
                images.add(image);
                fatherQName = "";
                image = null;
            }else if(qName.equals("airportPickUpService")){
                fatherQName = "";
            }
        }
    
        private void initHotelMsg(String tag , String value){
            if("id".equals(tag)){
                hotel.setHotelid(value);
            }else if("dateUpdated".equals(tag)){
    
            }else if("name".equals(tag)){
                hotel.setName(value);
            }
        }
    
        private void initImageMsg(String tag , String value){
            if("imgUrl".equals(tag)){
                image.setImgurl(value);
            }else if("imgType".equals(tag)){
                image.setImgtype(Integer.parseInt(value));
            }else if("title".equals(tag)){
                image.setTitle(value);
            }
        }
    
        private void initRoomMsg(String tag , String value){
            if("roomTypeId".equals(tag)){
                room.setRoomtypeid(value);
            }else if("roomName".equals(tag)){
                room.setRoomname(value);
            }else if("roomTypeNum".equals(tag)){
                room.setRoomtypenum(Integer.parseInt(value));
            }
        }
    
        public static List<ElongRooms> getRooms() {
            return rooms;
        }
    
        public static List<ElongImages> getImages() {
            return images;
        }
    
        public static List<ElongHotels> getHotels() {
            return hotels;
        }
    
        public static void main(String args[]) {
            long lasting = System.currentTimeMillis();
            try {
                SAXParserFactory sf = SAXParserFactory.newInstance();
                SAXParser sp = sf.newSAXParser();
                AnalyticElongHotelXml reader = new AnalyticElongHotelXml();
                sp.parse(new InputSource("D:\\Projects\\tour\\src\\com\\elong\\message\\Hotel_cn.xml"), reader);
                System.out.println("success");
    
                for(ElongHotels s : hotels){
                    if(s.getHotelid().equals("03")){
                        System.out.println(s.getName());
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("运行时间:" + (System.currentTimeMillis() - lasting) + "毫秒");
        }
    } 
     sp.parse(new InputSource("D:\\Projects\\tour\\src\\com\\elong\\message\\Hotel_cn.xml"),analyticElongHotelXml);



    我们可以重写DefaultHandler类的characters,startElement等方法,在里面实现自己需要的业务逻辑

     

     

    展开全文
  • android 加载,解析xml文件源码解析

    千次阅读 2017-01-15 18:36:58
    在activity中,经常需要利用setContentView方法加载xml文件来显示界面,界面的流程图如下, setContentView方法如下, public void setContentView(int layoutResID) { // Note: FEATURE_CONTENT_TRANSITIONS may...

    1, setContentView

    在activity中,经常需要利用setContentView方法加载xml文件来显示界面,界面的流程图如下,


    setContentView方法如下,

    public void setContentView(int layoutResID) {
            // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
            // decor, when theme attributes and the like are crystalized. Do not check the feature
            // before this happens.
            if (mContentParent == null) {
                installDecor(); // 初始化 mContentParent
            } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
                mContentParent.removeAllViews();
            }
    
            if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
                final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,
                        getContext());
                transitionTo(newScene);
            } else {
                mLayoutInflater.inflate(layoutResID, mContentParent); // 解析xml文件资源
            }
            mContentParent.requestApplyInsets();
            final Callback cb = getCallback(); // 其实就是activity
            if (cb != null && !isDestroyed()) {
                cb.onContentChanged(); // 回调
            }
        }

    本文的重点在于解析 xml文件资源,所以其他的就略过。

    public View inflate(@LayoutRes int resource, @Nullable ViewGroup root, boolean attachToRoot) {
            final Resources res = getContext().getResources();
            if (DEBUG) {
                Log.d(TAG, "INFLATING from resource: \"" + res.getResourceName(resource) + "\" ("
                        + Integer.toHexString(resource) + ")");
            }
    
            final XmlResourceParser parser = res.getLayout(resource); 
            try {
                return inflate(parser, root, attachToRoot);// 主要利用XmlResourceParser来解析
            } finally {
                parser.close();
            }
        }
    public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {
            synchronized (mConstructorArgs) {
                Trace.traceBegin(Trace.TRACE_TAG_VIEW, "inflate");
    
                final Context inflaterContext = mContext;
                final AttributeSet attrs = Xml.asAttributeSet(parser);
                Context lastContext = (Context) mConstructorArgs[0];
                mConstructorArgs[0] = inflaterContext;
                View result = root;
    
                try {
                    // Look for the root node.
                    int type;
                    while ((type = parser.next()) != XmlPullParser.START_TAG &&
                            type != XmlPullParser.END_DOCUMENT) {
                        // Empty
                    }
                      // xml错误类型检查
                    if (type != XmlPullParser.START_TAG) {
                        throw new InflateException(parser.getPositionDescription()
                                + ": No start tag found!");
                    }
    
                    final String name = parser.getName();
                    
                    if (DEBUG) {
                        System.out.println("**************************");
                        System.out.println("Creating root view: "
                                + name);
                        System.out.println("**************************");
                    }
    
                    if (TAG_MERGE.equals(name)) { //处理merge tag的情况(APP的xml性能优化)
                        if (root == null || !attachToRoot) {
                            throw new InflateException("<merge /> can be used only with a valid "
                                    + "ViewGroup root and attachToRoot=true");
                        }
    
                      rInflate(parser, root, inflaterContext, attrs, false); //递归inflate方法调运
                    } else {
                        // Temp is the root view that was found in the xml
                        final View temp = createViewFromTag(root, name, inflaterContext, attrs);
                          //xml文件中的root view,根据tag节点创建view对象
                        ViewGroup.LayoutParams params = null;
    
                        if (root != null) {
                            if (DEBUG) {
                                System.out.println("Creating params from root: " +
                                        root);
                            }
                            // Create layout params that match root, if supplied
                            params = root.generateLayoutParams(attrs);
                             //根据root生成合适的LayoutParams实例
                            if (!attachToRoot) {
                                // Set the layout params for temp if we are not
                                // attaching. (If we are, we use addView, below)
                                // 调用view的setLayoutParams方法
                                temp.setLayoutParams(params);
                            }
                        }
    
                        if (DEBUG) {
                            System.out.println("-----> start inflating children");
                        }
    
                        // Inflate all children under temp against its context.
                        rInflateChildren(parser, temp, attrs, true);
                             // 也会调用rInflate方法
                        if (DEBUG) {
                            System.out.println("-----> done inflating children");
                        }
    
                        // We are supposed to attach all the views we found (int temp)
                        // to root. Do that now.
                        if (root != null && attachToRoot) {
                            root.addView(temp, params);
                        }
    
                        // Decide whether to return the root that was passed in or the
                        // top view found in xml.
                        if (root == null || !attachToRoot) {
                            result = temp;
                        }
                    }
    
                } catch (XmlPullParserException e) {
                    InflateException ex = new InflateException(e.getMessage());
                    ex.initCause(e);
                    throw ex;
                } catch (Exception e) {
                    InflateException ex = new InflateException(
                            parser.getPositionDescription()
                                    + ": " + e.getMessage());
                    ex.initCause(e);
                    throw ex;
                } finally {
                    // Don't retain static reference on context.
                    mConstructorArgs[0] = lastContext;
                    mConstructorArgs[1] = null;
                }
    
                Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    
                return result;
            }
        }
    void rInflate(XmlPullParser parser, View parent, Context context,
                AttributeSet attrs, boolean finishInflate) throws XmlPullParserException, IOException {
    
            final int depth = parser.getDepth();
            int type;
    
            while (((type = parser.next()) != XmlPullParser.END_TAG ||
                    parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {
    
                if (type != XmlPullParser.START_TAG) {
                    continue;
                }
    
                final String name = parser.getName();
                
                if (TAG_REQUEST_FOCUS.equals(name)) {
                    parseRequestFocus(parser, parent);
                } else if (TAG_TAG.equals(name)) {
                    parseViewTag(parser, parent, attrs);
                } else if (TAG_INCLUDE.equals(name)) {
                    if (parser.getDepth() == 0) {
                        throw new InflateException("<include /> cannot be the root element");
                    }
                    parseInclude(parser, context, parent, attrs);
                } else if (TAG_MERGE.equals(name)) {
                    throw new InflateException("<merge /> must be the root element");
                } else {
                    final View view = createViewFromTag(parent, name, context, attrs);
                    final ViewGroup viewGroup = (ViewGroup) parent;
                    final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);
                    rInflateChildren(parser, view, attrs, true);
                    viewGroup.addView(view, params);
                }
            }
    
            if (finishInflate) {
                parent.onFinishInflate();
            }
        }

    通过上面的源码分析可以发现,xml文件解析实质是递归控件,解析属性的过程。所以说嵌套过深不仅效率低下还可能引起调运栈溢出。同时在解析那些tag时也有一些特殊处理,从源码看编写xml还是有很多要注意的地方的。所以说对于Android的xml来说是有一些优化技巧的(PS:布局优化可以通过hierarchyviewer来查看,通过lint也可以自动检查出来一些),如下:

    尽量使用相对布局,减少不必要层级结构。不用解释吧?递归解析的原因。

    使用merge属性。使用它可以有效的将某些符合条件的多余的层级优化掉。使用merge的场合主要有两处:自定义View中使用,父元素尽量是FrameLayout,当然如果父元素是其他布局,而且不是太复杂的情况下也是可以使用的;Activity中的整体布局,根元素需要是FrameLayout。但是使用merge标签还是有一些限制的,具体是:merge只能用在布局XML文件的根元素;使用merge来inflate一个布局时,必须指定一个ViewGroup作为其父元素,并且要设置inflate的attachToRoot参数为true。(参照inflate(int, ViewGroup, boolean)方法);不能在ViewStub中使用merge标签;最直观的一个原因就是ViewStub的inflate方法中根本没有attachToRoot的设置。

    使用ViewStub。一个轻量级的页面,我们通常使用它来做预加载处理,来改善页面加载速度和提高流畅性,ViewStub本身不会占用层级,它最终会被它指定的层级取代。ViewStub也是有一些缺点,譬如:ViewStub只能Inflate一次,之后ViewStub对象会被置为空。按句话说,某个被ViewStub指定的布局被Inflate后,就不能够再通过ViewStub来控制它了。所以它不适用 于需要按需显示隐藏的情况;ViewStub只能用来Inflate一个布局文件,而不是某个具体的View,当然也可以把View写在某个布局文件中。如果想操作一个具体的view,还是使用visibility属性吧;VIewStub中不能嵌套merge标签。

    使用include。

    2, createViewFromTag

    循环遍历xml时,会调用createViewFromTag根据xml文件构造对应的view对象,


    public final View createView(String name, String prefix, AttributeSet attrs)
                throws ClassNotFoundException, InflateException {
            Constructor<? extends View> constructor = sConstructorMap.get(name);
            Class<? extends View> clazz = null;
    
            try {
                Trace.traceBegin(Trace.TRACE_TAG_VIEW, name);
    
                if (constructor == null) {
                    // Class not found in the cache, see if it's real, and try to add it
                    clazz = mContext.getClassLoader().loadClass(
                            prefix != null ? (prefix + name) : name).asSubclass(View.class);
                    
                    if (mFilter != null && clazz != null) {
                        boolean allowed = mFilter.onLoadClass(clazz);
                        if (!allowed) {
                            failNotAllowed(name, prefix, attrs);
                        }
                    }
                    constructor = clazz.getConstructor(mConstructorSignature);
                    constructor.setAccessible(true);
                    sConstructorMap.put(name, constructor);
                } else {
                    // If we have a filter, apply it to cached constructor
                    if (mFilter != null) {
                        // Have we seen this name before?
                        Boolean allowedState = mFilterMap.get(name);
                        if (allowedState == null) {
                            // New class -- remember whether it is allowed
                            clazz = mContext.getClassLoader().loadClass(
                                    prefix != null ? (prefix + name) : name).asSubclass(View.class);
                            
                            boolean allowed = clazz != null && mFilter.onLoadClass(clazz);
                            mFilterMap.put(name, allowed);
                            if (!allowed) {
                                failNotAllowed(name, prefix, attrs);
                            }
                        } else if (allowedState.equals(Boolean.FALSE)) {
                            failNotAllowed(name, prefix, attrs);
                        }
                    }
                }
    
                Object[] args = mConstructorArgs;
                args[1] = attrs;
    
                final View view = constructor.newInstance(args);
                if (view instanceof ViewStub) {
                    // Use the same context when inflating ViewStub later.
                    final ViewStub viewStub = (ViewStub) view;
                    viewStub.setLayoutInflater(cloneInContext((Context) args[0]));
                }
                return view;
    •••
    }

    直接根据解析后的view信息利用反射创建对应的view对象。

    3,获取XmlResourceParser

    分析XmlResourceParser的源码, XmlResourceParser只是一个接口,真正的XmlResourceParser是啥呢? getLayout方法调用流程图如下,




    最后得到的是XmlBlock的内部类Parser,定义如下,

    final class Parser implements XmlResourceParser {

    平时解析代码时,构造XmlResourceParser对象如下,

    方法1,

    private String filePath = "/system/jsr_test_item_config_temp.xml";  // 文件路径
    
    XmlPullParser mXmlPullParser = null;
    try {
    		XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
    	         factory.setNamespaceAware(true);
    	         mXmlPullParser = factory.newPullParser();
    
    File file = new File(filePath);
    	         FileInputStream fis = new FileInputStream(file); 
    	         InputStreamReader isr = new InputStreamReader(fis);
    
                    mXmlPullParser.setInput(isr);
    •••}

    方法2,

    XmlResourceParser xmlParser = context.getResources().getXml(xmlResourceID);
    

    Int xmlResourceID = R.xml.qwerty_keyboard;  // xml文件

    当然,除了这些方法之外,还有其他获取XmlResourceParser对象的方法。

    并且,解析xml文件还有其他的另外2种典型的类,在其他文档中总结。

    4 findViewById

    根据id获取view的findViewById流程图下,


    首先看看view的findViewById方法,

    public final View findViewById(@IdRes int id) {
            if (id < 0) {
                return null;
            }
            return findViewTraversal(id);
        }
    protected View findViewTraversal(@IdRes int id) {
            if (id == mID) {
                return this;
            }
            return null;
        }

    如果id 和mID变量相等就直接返回,根据id获取view的流程没有这么容易吧,至少得有个遍历啊.原来ViewGroup实现了findViewTraversal方法,所以先调用ViewGroup的findViewTraversal方法,如下,

    protected View findViewTraversal(@IdRes int id) {
            if (id == mID) {
                return this;
            }
    
            final View[] where = mChildren;
            final int len = mChildrenCount;
    
            for (int i = 0; i < len; i++) {  // 逐个循环遍历。
                View v = where[i];
    
                if ((v.mPrivateFlags & PFLAG_IS_ROOT_NAMESPACE) == 0) {
                    v = v.findViewById(id);
    
                    if (v != null) {
                        return v;
                    }
                }
            }
    
            return null;
        }

    这样子循环遍历才是正确的,由源码也可发现,如果xml布局层次太深,查找View就会多花费CPU,影响效率,因此,很有必要对布局进行优化。

    那么mID变量是什么时候赋值的呢?

    在解析完成之后,构造view时,会对各种属性变量赋值。

    mID = a.getResourceId(attr, NO_ID);

    在View中,还可以通过setId方法给mID赋值,

    public void setId(@IdRes int id) {
            mID = id;
            if (mID == View.NO_ID && mLabelForId != View.NO_ID) {
                mID = generateViewId();
            }
        }
    
    public static int generateViewId() {
            for (;;) {
                final int result = sNextGeneratedId.get();
                // aapt-generated IDs have the high byte nonzero; clamp to the range under that.
                int newValue = result + 1;
                if (newValue > 0x00FFFFFF) newValue = 1; // Roll over to 1, not 0.
                if (sNextGeneratedId.compareAndSet(result, newValue)) {
                    return result;
                }
            }
        }

    在开发的时候,调用setId方法也可以直接对view进行赋值。

    展开全文
  • (2) 解压Xml Tools 2.4.8 Unicode.zip,关闭Notepad++ ...2. XML文件格式化 安装完毕后,启动Notepad++,点击插件选项卡,可以看到XML Tools插件已加载。如要格式化XML文件,选择Pretty print开头的一系列选项均可。
  • pom.xml文件元素解析

    千次阅读 2016-12-22 10:55:03
    概念:pom.xml---Project Object Model,是一种项目对象模型,通过xml格式保存,在maven中的作用类似于ant的build.xml文件,但是功能更加强大。 作用:该文件用于管理:源代码、配置文件、开发者的信息和角色、问题...

    概念:pom.xml---Project Object Model,是一种项目对象模型,通过xml格式保存,在maven中的作用类似于ant的build.xml文件,但是功能更加强大。

    作用:该文件用于管理:源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。

    位置:Maven项目的根目录下

    结构:一个完整的pom文件大概包括6个部分,如下所示,其中后面四个部分是主要的,分别是properties、dependencyManagement、dependencies、build等四个元素标签,下面对其一一解说。

    先贴一个常规的pom.xml文件配置,可以跳过不看这个,主要看下面的基础解析部分。

     

    <!-- 1-->
    <projectxmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0http://maven.apache.org/maven-v4_0_0.xsd">
        <!-- 2-->
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.my.mavenweb</groupId>
      <artifactId>testWeb</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <packaging>war</packaging>
        <name>testWebMaven Webapp</name>
         <url>http://maven.apache.org</url>
         <descriprion></descriprion>
         <developers></developers>
         <licenses></licenses>
         <organization></organization>
        
    <!-- 3-->
       <properties> 
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 
            <springversion>3.1.1.RELEASE</springversion> 
            <junitversion>3.8.1</junitversion> 
        </properties> 
    
    
    
    <!-- 4-->
        <dependencyManagement>
          <dependencies>
            <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-framework-bom</artifactId>
               <version>${spring.version}</version>
               <type>pom</type>
               <scope>import</scope>
            </dependency>
          </dependencies>   
        </dependencyManagement>
    
    
    
    
    
    <!-- 5-->
        <dependencies>     
                  <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
          </dependency>
          <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
          </dependency>
          <dependency>
            <groupId>commons-fileupload</groupId>
             <artifactId>commons-fileupload</artifactId>
             <version>1.3.1</version>
          </dependency>
        </dependencies>
    
    
    
    
    
    
    
    <!-- 6-->
      <build>
        <finalName>testWebName</finalName>
    <plugins>
            <plugin>
               <groupId>org.eclipse.jetty</groupId>
               <artifactId>jetty-maven-plugin</artifactId>
               <version>9.2.2.v20140723</version>
               <executions>
                     <execution>
                     <phase>package</phase>
                     <goals>
                        <goal>run</goal>
                     </goals>
                  </execution>
               </executions>
            </plugin>
          </plugins>  
    </build>
      <parent></parent>
      <modules></modules>
    </project>

     

    pom基础元素解析

    第一部分:根

          这是对Project添加一些根元素的约束信息

     <!-- 1-->

    <projectxmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0http://maven.apache.org/maven-v4_0_0.xsd">

     

    第二部分:pom属性

    这是对当前pom文件添加自己的属性,如下:

     <!-- 2-->

    <!-- 制定了当前pom的版本,是必不可少的-->  

    <modelVersion>4.0.0</modelVersion>   


    <!-- 项目坐标(groupIdartifactIdversion):定义pom文件属于哪个maven项目

            maven项目是一种模块化的概念,里面将项目划分为模块。

            groupId=反写公司网址.项目名

            artifactId=项目名-模块名

            version=0.0.1SNAPSHOP

            (第一个0表示大本版号,第二个0表示分支版本号,第三个0表示小版本号)

            (版本除了snapshop快照版本之外,还有alpha--α内测版本、beta--β公测版本、Release稳定版本、GA发布版本)

          -->

      <groupId>com.my.mavenweb</groupId>

      <artifactId>testWeb</artifactId>

       <version>0.0.1-SNAPSHOT</version>


    <!-- packaging:指定了项目的打包方式,如果内容为空,默认指定打包为Jar包,此外,还要warzippom等类型-->

    <packaging>war</packaging>


    <!-- name:指定了项目的描述名,一般在产生对象文档的时候才会使用 -->

        <name>testWebMaven Webapp</name>


     <!--URl:指定了项目的Url -->

         <url>http://maven.apache.org</url>

       

    <!-- description:项目描述信息

         developers:开发人员信息

         licenses:开源框架的许可证信息

         organization:组织信息    

         -->

         <descriprion></descriprion>

         <developers></developers>

         <licenses></licenses>

         <organization></organization>

     

    第三部分:properties

    properties列表用于声明一些软件包的版本。当工程比较繁杂庞大的时候,则可以通过这个配置比较清晰的指导依赖包的版本,方便我们做一些气的处理。

    如下所示:生命了源文件的编码格式为UTF-8,spring框架依赖包的版本为3.1.1.RELEASE,Junit的版本为3.8.1。

    <!-- 3-->

       <properties> 

            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 

            <springversion>3.1.1.RELEASE</springversion> 

            <junitversion>3.8.1</junitversion> 

        </properties>

     

    第四部分:dependencyManagement

    dependencyManagement属性列表,用于依赖管理,声明使用指定版本的包,重在声明依赖,可以不引入实际的依赖项。

    又叫做多模块依赖项版本控制:主要是针对父模块列出依赖项进行管理,使得下面需要某个父模块的模块直接继承该依赖,  不用进行传递依赖这么麻烦,但是该标签不会引入到执行当中,只起到一个说明作用。

     

    第五部分:dependencies

    dependencies属性表示在依赖列表当中加入项目中所要使用的依赖包,需要加入坐标,还可以加入其他的属性。

     <!--

     dependencies:依赖信息列表

     dependency:依赖项

     groupIdartifactIdversion:依赖项的位置坐标,方便查找依赖。

     type:依赖项的类型,jar/war/zip/pom等类型

     scope:依赖范围,是指当前依赖项在哪个范围内有效。

     potional:依赖是否可选,默认为false,则项目可以继承该依赖;如果为true,则子项目必须显式引入该依赖

     exclusions:排除依赖的传递列表

     exclusion:排除依赖,例如排除传递依赖中自己不需要的依赖项

     -->

    <!-- 5-->

        <dependencies>     

                  <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-webmvc</artifactId>

          </dependency>

          <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>3.8.1</version>

            <scope>test</scope>

          </dependency>

          <dependency>

            <groupId>commons-fileupload</groupId>

             <artifactId>commons-fileupload</artifactId>

             <version>1.3.1</version>

          </dependency>

        </dependencies>

     

    第六部分:build

    build元素标签用于引入项目中需要用到的插件

      <!--

     build:系统项目构建行为知识

      plugins:引入的插件的列表

      plugin:插件,这个标签下需要声明插件的坐标,

     -->

      <!--

       parent:通常用于子模块对父模块POM的集成

      modules:用于聚合运行多个项目,指定多个模块一起编译。

      -->

    <!-- 6-->

      <build>

        <finalName>testWebName</finalName>

    <plugins>

            <plugin>

               <groupId>org.eclipse.jetty</groupId>

               <artifactId>jetty-maven-plugin</artifactId>

               <version>9.2.2.v20140723</version>

               <executions>

                     <execution>

                     <phase>package</phase>

                     <goals>

                      <goal>run</goal>

                     </goals>

                  </execution>

               </executions>

            </plugin>

          </plugins>  

    </build>

      <parent></parent>

      <modules></modules>

    </project>

     

     

    dependencyManagement和dependencies的区别


             1)      dependencies:自动引入声明在dependencies里的所有依赖,并默认被所有的子项目继承。如果项目中不写依赖项,则会从父项目继承(属性全部继承)声明在父项目dependencies里的依赖项。         

            2)      dependencyManagement里只是声明依赖,并不实现引入,因此子项目需要显式的声明需要的依赖。如果不在子项目中声明依赖,是不会从父项目中继承的;只有在子项目中写了该依赖项,并且没有指定具体版本,才会从父项目中继承该项,并且version和scope都读取自父pom;如果子项目中指定了版本号,那么会使用子项目中指定的jar版本。同时dependencyManagement让子项目引用依赖,而不用显式的列出版本号。Maven会沿着父子层次向上走,直到找到一个拥有dependencyManagement元素的项目,然后它就会使用在这个dependencyManagement元素中指定的版本号,实现所有子项目使用的依赖项为同一版本。

           3)      dependencyManagement中的 dependencies 并不影响项目的依赖项;而独立dependencies元素则影响项目的依赖项。只有当外层的dependencies元素中没有指明版本信息时,dependencyManagement中的 dependencies 元素才起作用。一个是项目依赖,一个是maven项目多模块情况时作依赖管理控制的。

           4)      pluginManagement和plugins 区别相似,只不过它们用于管理plugin。

     





    展开全文
  • 扩展PlugIn插件解析XML

    2009-03-15 00:09:30
    接口利用Digester类解析Xml文件为对象 个人感觉简单易懂,如有问题,还请多多指教。
  • PLSQL解析XML文件

    千次阅读 2014-01-13 17:08:36
     参考网上资料学习汇总 在PL/SQL中利用XML ,Oracle提供了几个组件,让开发...它是使用Xpath(XML标准的另一个元素)说明语法在内存中搜索XML文档的实用程序。 SLT 处理器。 它在Oracle数据库中支持XSLT,
    

    参考网上资料学习汇总

    PL/SQL中利用XML ,Oracle提供了几个组件,让开发人员能轻松地利用XML技术。这些组件包括:

     1.  XML 分析程序。即用来分析、构造和验证XML文档。.

    2. XPath 引擎。 它是使用XpathXML标准的另一个元素)说明语法在内存中搜索XML文档的实用程序。 SLT 处理器。 它在Oracle数据库中支持XSLT,允许您把XML文档转换成其他格式。

    3. XML SQL 实用程序。可以使用SQL产生XML文档,使您可以在Oracle数据库表格中轻松地插入基于XML的数据。 XSQL 页。一项可以汇集声明性XML数据然后通过XSLT公布这些数据的技术。 对于PL/SQL开发人员而言,XML分析程序是最重要的组件。通过它,您可以在Oracle数据库中分析、操纵和转换XML文档。ML分析程序由一套APIs(应用程序编程接口)构成。


    XML结构


    XML常用分析函数


    XMLParser


    包括分析XML文档所需的数据类型和程序。XML Parsing Process


    想知道Oracleparser是如何调用Java来做解析的,请查看Oracle® XMLDeveloper's Kit Programmer's Guide
    10g Release 2 (10.2)

    Part Number B14252-01

    网址: http://download.oracle.com/docs/cd/B19306_01/appdev.102/b14252/adx_j_parser.htm#i1013320

    程序中常用的方法:

    Nodelist := dbms_xslprocessor.selectnodesrootnode, xpath

    dbms_xslprocessor.valueof(节点,节点下的元素,)


    XMLDOM


    包括管理和建立XML文档对象模型(DOM)元素所需的数据类型和程序

    Comparing DOM (Tree-Based) and SAX (Event-Based) APIs

    XMLDOM 这个程序包,其实是通过封装Java 程序来解析XML 的一个PL/SQL的包。具体的作用还是要参考Oracle® Database PL/SQLPackages and Types Reference
    10g Release 2 (10.2)

    Part Number B14258-02

    网址: http://download.oracle.com/docs/cd/B19306_01/appdev.102/b14258/d_xmldom.htm


    实例

    <?xml version="1.0" encoding="UTF-8"?>
    <Dfile Status="3">
    <RecCount>200</RecCount>
    <FailCount>1</FailCount>
     <FailInfo>
      <FItem RecErrCode="2901">
         <Item>
           <Name>名称1</Name>
           <Comment>中国银行</Comment>
         </Item>
         <Item>
           <Name>名称2</Name>
           <Comment>建设银行</Comment>
         </Item>
      </FItem>
     </FailInfo>
     <FailInfo>
      <FItem RecErrCode="2902">
         <Item>
           <Name>名称3</Name>
           <Comment>招商银行</Comment>
         </Item>
         <Item>
           <Name>名称4</Name>
           <Comment>平安银行</Comment>
         </Item>
         <Item>
           <Name>名称5</Name>
           <Comment>工商银行</Comment>
         </Item>
      </FItem>
     </FailInfo>
    


    文件的结构



    解析方案


    XML DOM的解析过程中, 如果想找某个节点(Fitem)的属性(RecErrCode),而该节点又不是根节点时,需要从最小的节点往上找父节点,一直到节点Fitem,然后在得到其属性。如果节点是根节点,则可以直接得到根节点的元素和属性的值。

    根据上图所示,我们要找根节点Dfile的元素和属性的值,直接调用


    Oracle通过调用API xmldomdbms_xmlparser来做XML文件的解析。


    . 建立一个Directory ,假如在EBS上实现则需要在EBS DB的服务器上建立路径 如:


      CreateOr Replace Directory FTP_XXX As '/var/tmp/ftp' 直接在APPS下就可以新建


    要查找当前建立的Directory 可以使用 Select * From all_directories 查找当前系统中的所有的 Directory .

    DECLARE
      p_max_size NUMBER := dbms_lob.lobmaxsize;
      src_offset NUMBER := 1;
      dst_offset NUMBER := 1;
      lang_ctx   NUMBER := nls_charset_id('UTF8');
      default_csid CONSTANT INTEGER := nls_charset_id('ZHS16GBK');
      warning         NUMBER;
      l_file_number   PLS_INTEGER := 0;
      l_count         NUMBER;
      l_bfile         BFILE;
      l_clob          CLOB;
      l_commitelement xmldom.domelement;
      l_parser        dbms_xmlparser.parser;
      l_doc           dbms_xmldom.domdocument;
      l_nl            dbms_xmldom.domnodelist;
      l_n             dbms_xmldom.domnode;
      rootnode        dbms_xmldom.domnode;
      parent_rootnode dbms_xmldom.domnode;
      file_length     NUMBER;
      block_size      BINARY_INTEGER;
      l_rootnode_name VARCHAR2(200);
      l_status        VARCHAR2(1000);
      l_recerrcode    VARCHAR2(1000);
      l_failcount     VARCHAR2(200);
      l_reccount      VARCHAR2(200);
      l_name          VARCHAR2(1000);
      l_comments      VARCHAR2(2000);
      l_exists        BOOLEAN;
    
      FUNCTION convertclobtoxmlelement(p_document IN CLOB)
        RETURN xmldom.domelement IS
        x_commitelement xmldom.domelement;
        l_parser        xmlparser.parser;
      BEGIN
        l_parser := xmlparser.newparser;
        xmlparser.parseclob(l_parser, p_document);
        x_commitelement := xmldom.getdocumentelement(xmlparser.getdocument(l_parser));
        RETURN x_commitelement;
      END convertclobtoxmlelement;
    BEGIN
      -- 检查XML是否在路径FTP_XXX下是否存在
      utl_file.fgetattr('FTP_XXX',
                        'simanhe_test.xml',
                        l_exists,
                        file_length,
                        block_size);
    
      IF NOT l_exists THEN
        dbms_output.put_line('XML文件不存在');
        RETURN;
      END IF;
    
      l_bfile := bfilename('FTP_XXX', 'simanhe_test.xml');
      -- 创建一个Clob
      dbms_lob.createtemporary(l_clob, TRUE);
      dbms_lob.open(l_bfile, dbms_lob.lob_readonly);
      -- 将XML文件上载并转换为Clob类型
      dbms_lob.loadclobfromfile(l_clob,
                                l_bfile,
                                p_max_size,
                                dst_offset,
                                src_offset,
                                default_csid, -- UTF8
                                lang_ctx, -- GBK
                                warning);
      l_file_number := dbms_lob.fileexists(l_bfile);
      IF l_file_number = 0 THEN
        dbms_output.put_line('XML文件未被转换成功');
        RETURN;
      END IF;
      dbms_lob.close(l_bfile);
      -- Create a parser.
      l_parser := dbms_xmlparser.newparser;
      BEGIN
        -- Parse the document and create a new DOM document.
        dbms_xmlparser.parseclob(l_parser, l_clob);
      EXCEPTION
        WHEN OTHERS THEN
          dbms_output.put_line('XML文件不完整');
          RETURN;
      END;
      l_doc := dbms_xmlparser.getdocument(l_parser);
      -- Free resources associated with the CLOB and Parser now they are no longer needed.
      dbms_lob.freetemporary(l_clob);
      -- 得到根节点 
      rootnode        := xmldom.makenode(xmldom.getdocumentelement(xmlparser.getdocument(l_parser)));
      l_rootnode_name := xmldom.getnodename(rootnode);
      dbms_output.put_line('XML文件当前的节点名称为 ' || l_rootnode_name);
      -- 得到根节点元素的值
      dbms_xslprocessor.valueof(rootnode, 'RecCount/text()', l_reccount);
      dbms_xslprocessor.valueof(rootnode, 'FailCount/text()', l_failcount);
      dbms_output.put_line('XML文件当前的节点名称为 ' || l_rootnode_name ||
                           '的要素RecCount,FailCount值为' || l_reccount || ',' ||
                           l_failcount);
      -- 得到根节点Dfile的属性Status的值
      l_status := xmldom.getattribute(xmldom.makeelement(rootnode), 'Status');
      dbms_output.put_line('XML文件当前的节点名称为 ' || l_rootnode_name ||
                           '的属性Status的值为' || l_status);
    
      /*取节点Item下各元素的值,先将Items节点全部存放在 l_nl中 */
      l_nl    := dbms_xmldom.getelementsbytagname(l_doc, 'Item');
      l_count := dbms_xmldom.getlength(l_nl);
      FOR cur_emp IN 0 .. dbms_xmldom.getlength(l_nl) - 1 LOOP
        l_n := dbms_xmldom.item(l_nl, cur_emp);
        -- 得到节点Item下元素的值
        dbms_xslprocessor.valueof(l_n, 'Name/text()', l_name);
        dbms_xslprocessor.valueof(l_n, 'Comment/text()', l_comments);
        -- 得到节点Item的父节点FItem
        parent_rootnode := dbms_xmldom.getparentnode(l_n);
        l_rootnode_name := xmldom.getnodename(parent_rootnode);
        -- 得到节点FItem的属性RecErrCode的值
        l_recerrcode := xmldom.getattribute(xmldom.makeelement(parent_rootnode),
                                            'RecErrCode');
      
        dbms_output.put_line('Name :' || l_name || ' ,Comment = ' ||
                             l_comments || ' ,RecErrCode = ' || l_recerrcode);
      
      END LOOP;
      -- 释放分析函数的资源
      dbms_xmlparser.freeparser(l_parser);
      -- 将DOC清空,释放资源
      dbms_xmldom.freedocument(l_doc);
      /*  utl_file.frename('FTP_XXX',
      'simanhe_test.xml',
      'FTP_XXX',
      'D_simanhe_test.xml',
      FALSE);*/ -- XML文件解析完成后重命名
      /*utl_file.fremove('FTP_XXX', 'simanhe_test.xml'); */ -- -- XML文件解析完成后删除文件
    EXCEPTION
      WHEN OTHERS THEN
        dbms_lob.freetemporary(l_clob);
        dbms_xmlparser.freeparser(l_parser);
        dbms_xmldom.freedocument(l_doc);
    END;
    







    展开全文
  • python解析xml文件工具

    千次阅读 2019-05-05 13:21:40
    XML是一种广泛使用的格式,Python自身附带了一个完整的XML解析工具包,它支持SAX和DOM解析模式,此外还有一个名为ElementTree的包。这是特定于Python的专门用于解析和构造XML的API。除了基本的解析,开源领域还提供...
  • Spring容器启动,在创建BeanFactory时,需要加载和解析当前ApplicationContext对应的配置文件applicationContext.xml,从而获取bean相关的配置信息。 在内部实现的调用关系为:ApplicationContext通过...
  • C#解析XML文件并用WinForm显示

    热门讨论 2011-08-10 16:00:25
    自己写的,运用dot net解析XML文件,并在用WinForm进行显示。。。。。
  • xmllite.dll是Vista中的XML解析引擎的动态链接库文件 visio的插件和ie的插件文件放到C:\WINDOWS\system32
  • wireshark抓包对应xml文件解析

    千次阅读 2017-09-24 22:57:01
    最近在搭建内部平台的时候,需设计一个脚本,将pcap/pcapng文件转化成xml文件,并且需要从xml提取有效数据,将其插入Mongo数据库,实现语言为java,具体实现时引入了一些第三方库,最后生成一个auto.jar文件,因为...
  • 基于QT实现XML文件读写,解析操作
  • 首先我们来看看mapper.xml文件的加载方式 第一种:基于mapper接口类具体路径配置 这种情况下,如果是非注解模式的话xml配置文件必须和这个类在同一级目录,且与Mapper类同名。项目结构类似 第二种:基于...
  • mybatis-Config.xml全局配置文件解析

    千次阅读 2016-09-19 12:06:01
    一:mybatis-Config.xml配置文件的内容和配置顺序如下 properties(属性)settings(全局配置参数)typeAiases(类型别名)typeHandlers(类型处理器)objectFactory(对象工厂)plugins(插件)environments(环境集合属性...
  • 解析xml文件有好多种方式,今天介绍下XmlPullParser怎么解析xml文件,既然是要解析xml文件首先得需要一个xml文件
  • 相关知识点:Unity3D如何配置全局xml配置文件并进行读取解析C#读取xml文件时如何忽略掉注释部分总结网上的读取方式大致... 然后使用mono.xml插件进行解析2, 将xml文件放在Assets/Resources 文件下, 然后通过 Resource...
  • java中采用dom4j解析xml文件

    万次阅读 2019-05-22 11:18:55
    在最近的开发中用到了dom4j来解析xml文件,以前听说过来解析xml文件的几种标准方式;但是从来的没有应用过来,所以可以在google中搜索dmo4j解析xml文件的方式,学习一下dom4j解析xml的具体操作。 二.代码详情 ...
  • Struts逐步学习(3)-struts-config.xml文件解析

    千次阅读 热门讨论 2013-11-27 21:10:23
    struts-config.xml是Struts的主要配置文件,在该文件中,可以配置数据源、form-bean、action和plug-in(插件)和资源文件的信息。文件(Struts1.2版本)主要结构如下所示:
  • SAX方式解析xml文件查看天气

    千次阅读 2014-06-04 18:27:09
    1.SAX方式解析xml文件的步骤: ①创建解析器工厂对象 ②使用当前配置的工厂参数创建SAXParser对象 ③解析xml文件 ④利用DefaultHandler创建事件驱动者 2.对于标签对象进行引用怎么办? ①定义当前解析的标签:...
  • 此notpade++ 包含notepade安装文件xml\json格式化插件 安装说明: 一、NppTextPad7580.zip 是安装文件 没有可以选择安装 二、xmltools_2.3.2_r908_unicode_beta4.zip 是 xml格式化插件 解压后 XMLTools.dll 放入...
  • 1.MyBatis是通过xml或注解的方式将需要执行的statement对象配置起来,通过java对象和statement对象中的sql进行映射,生成最终的sql语句,然后由MyBatis框架执行sql并将结果映射成java对象并返回。 2.MyBatis的配置...
  • 【vue】vue使用x2js解析xml文件

    千次阅读 2019-02-20 10:57:18
    一、功能需求 ...jq使用get或ajax解析xml文件在vue框架里似乎行不通了。搜索发现了x2js插件,用于在XML和JavaScript对象之间进行转换的库。 二、x2js安装配置 可以使用npm安装或者到https://github...
  • JavaScript 解析 xml 文件 如 rss订阅

    千次阅读 2010-12-10 18:10:00
    jFeed 是一个通用的 RSS/ATOM 解析器jQuery插件jFeed 支持 RSS 0.91, 0.92, 1.0, 2.0 和 Atom 1.0 等格式。使用方法:jQuery.getFeed(options); 参数: * url: the feed URL (required). * data: data to be sent ...
  • 前端js中解析XML文件(一)

    千次阅读 2011-07-27 11:35:26
    IE浏览器中的XML解析器是通过ActiveX控件所实现的,,通过以下的代码来引用XML解析器。var xmldoc = new ActiveXObject("Microsoft.XML...以上的代码可以创建一个XMLDOM对象,使用该对象可以加载一个XML文件,加载方式
  • unity3d读取xml插件XMLParser

    热门讨论 2014-03-27 00:03:14
    unity3d读取xml插件XMLParser,用于读取xml文件
  • 利用jsoup解析网页和xml文件

    千次阅读 2014-11-29 15:40:23
    当我们需要从网页上抓取自己想要的数据时,...今天要解析的是搜狐新闻:http://pinglun.sohu.com/ 代码如下: private static void parse() { try { Document doc = Jsoup.connect("http://pinglun.sohu.co
  • 解析xml文件,修改Jenkins的配置

    千次阅读 2018-03-27 16:59:26
    转载自:https://www.cnblogs.com/chongyou/p/7600547.html最近因为服务器移动,在Jenkins中配置的一些地址之类的,都要改变,如图,我因为...如图:要改变成地址为:192.168.11.11,因为Jenkins的文件配置都是xml文...
  • 您无需在项目中编写任何Java或Kotlin代码即可使其工作,并且仍然可以像在XML文件中手动添加任何其他字符串一样访问“已解析”字符串。 换句话说,如果您要执行以下操作: 输入: < string xss=removed>My App
  • java解析、验证、生成XML文件(上)

    千次阅读 2017-04-05 14:54:20
    在java中,我们有非常多的包提供了对XML语言的解析、验证、生成等一系列操作。(一)XML的起源和基本写法当谈到XML时我们不得不提W3C。W3C是“万维网联盟”的简称,它创建于1994年,是Web技术领域最具权威和影响力的...
  • react native XML解析

    千次阅读 2018-06-01 15:09:27
    我就直接网上百度搜寻react native的xml解析,但是这一次万能的百度也不管用了,我也加了两个rn开发讨论群,问了大佬得知rn没有xml解析,要么后台改,要么原生开发,还有一种就是插件库来解析了。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,988
精华内容 33,995
关键字:

xml大文件解析插件