dom4j 的使用与 模拟Spring中的 IOC 容器实现

最新推荐文章于 2022-11-07 10:48:14 发布
最新推荐文章于 2022-11-07 10:48:14 发布
阅读量246 收藏 2
点赞数
分类专栏： Web开发 文章标签： java dom4j xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/growl_jie_/article/details/105521469
版权

虽然现在 JSON 大法贼好，但是有时候你需要调用的接口还是 xml 格式的奥，所以这边写一下 dom4j 的使用，（emmmmmm 公司墙很高，只让用 CSDN，你猜是哪家）。

这边我使用 maven 构建工程
在这里插入图片描述
找到 pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="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.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>studyDom4j</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>studyDom4j</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-classic -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.7</version>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-core</artifactId>
      <version>1.1.7</version>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-access</artifactId>
      <version>1.1.7</version>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.1.7</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
    <dependency>
      <groupId>dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>1.6.1</version>
    </dependency>
  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

这里还用了日志工具 sfl4j + logback

<!-- 级别从高到低 OFF 、 FATAL 、 ERROR 、 WARN 、 INFO 、 DEBUG 、 TRACE 、 ALL -->
<!-- 日志输出规则 根据当前ROOT 级别，日志输出时，级别高于root默认的级别时 会输出 -->
<!-- 以下 每个配置的 filter 是过滤掉输出文件里面，会出现高级别文件，依然出现低级别的日志信息，通过filter 过滤只记录本级别的日志 -->
<!-- scan 当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。 -->
<!-- scanPeriod 设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug 当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <!-- 动态日志级别 -->
    <jmxConfigurator />
    <!-- 定义日志文件 输出位置 -->
    <!-- <property name="log_dir" value="C:/test" />-->
    <property name="log_dir" value="./log" />
    <!-- 日志最大的历史 30天 -->
    <property name="maxHistory" value="30" />

    <!-- ConsoleAppender 控制台输出日志 -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>
                <!-- 设置日志输出格式 -->
                %d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n
            </pattern>
        </encoder>
    </appender>

    <!-- ERROR级别日志 -->
    <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 RollingFileAppender -->
    <appender name="ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 过滤器，只记录WARN级别的日志 -->
        <!-- 果日志级别等于配置级别，过滤器会根据onMath 和 onMismatch接收或拒绝日志。 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 设置过滤级别 -->
            <level>ERROR</level>
            <!-- 用于配置符合过滤条件的操作 -->
            <onMatch>ACCEPT</onMatch>
            <!-- 用于配置不符合过滤条件的操作 -->
            <onMismatch>DENY</onMismatch>
        </filter>
        <!-- 最常用的滚动策略，它根据时间来制定滚动策略.既负责滚动也负责出发滚动 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志输出位置 可相对、和绝对路径 -->
            <fileNamePattern>
                ${log_dir}/error/%d{yyyy-MM-dd}/error-log.log
            </fileNamePattern>
            <!-- 可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件假设设置每个月滚动，且<maxHistory>是6， 则只保存最近6个月的文件，删除之前的旧文件。注意，删除旧文件是，那些为了归档而创建的目录也会被删除 -->
            <maxHistory>${maxHistory}</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>
                <!-- 设置日志输出格式 -->
                %d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n
            </pattern>
        </encoder>
    </appender>

    <!-- WARN级别日志 appender -->
    <appender name="WARN" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 过滤器，只记录WARN级别的日志 -->
        <!-- 果日志级别等于配置级别，过滤器会根据onMath 和 onMismatch接收或拒绝日志。 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 设置过滤级别 -->
            <level>WARN</level>
            <!-- 用于配置符合过滤条件的操作 -->
            <onMatch>ACCEPT</onMatch>
            <!-- 用于配置不符合过滤条件的操作 -->
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志输出位置 可相对、和绝对路径 -->
            <fileNamePattern>${log_dir}/warn/%d{yyyy-MM-dd}/warn-log.log</fileNamePattern>
            <maxHistory>${maxHistory}</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- INFO级别日志 appender -->
    <appender name="INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>INFO</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log_dir}/info/%d{yyyy-MM-dd}/info-log.log</fileNamePattern>
            <maxHistory>${maxHistory}</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- DEBUG级别日志 appender -->
    <appender name="DEBUG" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>DEBUG</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log_dir}/debug/%d{yyyy-MM-dd}/debug-log.log</fileNamePattern>
            <maxHistory>${maxHistory}</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- TRACE级别日志 appender -->
    <appender name="TRACE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>TRACE</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log_dir}/trace/%d{yyyy-MM-dd}/trace-log.log</fileNamePattern>
            <maxHistory>${maxHistory}</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- root级别 DEBUG -->
    <root>
        <!-- 打印debug级别日志及以上级别日志 -->
        <level value="debug" />
        <!-- 控制台输出 -->
        <appender-ref ref="console" />
        <!-- 文件输出 -->
        <appender-ref ref="ERROR" />
        <appender-ref ref="INFO" />
        <appender-ref ref="WARN" />
        <appender-ref ref="DEBUG" />
        <appender-ref ref="TRACE" />
    </root>
</configuration>

然后就可以开启 dom4j 玩转 xml 大法了。

使用 InputStream 从本地读 xml 文件进行解析
package org.example;


import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

/**
 * Hello world!
 *
 */
public class App 
{
    private static Logger logger = LoggerFactory.getLogger(App.class);
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
        try {
            useInputStreamOperaXML();
        }catch (FileNotFoundException | DocumentException e){
            e.printStackTrace();
        }

    }

    /**
     * 使用 InputStream 从本地读 xml 文件进行解析
     */
    private static void useInputStreamOperaXML() throws FileNotFoundException, DocumentException {
        logger.info("使用 InputStream 从本地读 xml 文件进行解析 start");
        SAXReader reader = new SAXReader();
        File file = new File("book.xml");
        if(file.exists()){
            InputStream in = new FileInputStream(file);
            Document document = reader.read(file);
            logger.info(document.asXML());
        }
        logger.info("使用 InputStream 从本地读 xml 文件进行解析 end");

    }
}

输出

2020-04-14 21:39:05.491 INFO  org.example.App - 使用 InputStream 从本地读 xml 文件进行解析 start
2020-04-14 21:39:05.586 INFO  org.example.App - <?xml version="1.0" encoding="UTF-8"?>
<books>
    <books id="book1" date="2020">
        <author>腾讯</author>
        <category>产品</category>
    </books>
    <books id="book1" date="2020">
        <author>阿里</author>
        <category>运营</category>
    </books>
    <books id="book1" date="2020">
        <author>华为</author>
        <category>技术</category>
    </books>
</books>
2020-04-14 21:39:05.587 INFO  org.example.App - 使用 InputStream 从本地读 xml 文件进行解析 end
通过DocumentHelper创建（解析）一个Document对象,并为Document添加元素
/**
     * 通过DocumentHelper创建（解析）一个Document对象,并为Document添加元素
     */
    private static void useDocumentCreateXML() {
        logger.info("----------- org.example.App.useDocumentCreateXML start");
        Document document = DocumentHelper.createDocument();
        Element root = document.addElement("root");
        Element p1 =root.addElement("person")
                    .addAttribute("age", "18")
                .addText("张三");
        Element p2 =root.addElement("person")
                .addAttribute("age", "19")
                .addText("李四");
        Element p3 =root.addElement("person")
                .addAttribute("age", "20")
                .addText("王五");
        logger.info(document.asXML());
        logger.info("----------- org.example.App.useDocumentCreateXML end");

    }

输出

2020-04-14 21:51:06.405 INFO  org.example.App - ----------- org.example.App.useDocumentCreateXML start
2020-04-14 21:51:06.406 INFO  org.example.App - <?xml version="1.0" encoding="UTF-8"?>
<root><person age="18">张三</person><person age="19">李四</person><person age="20">王五</person></root>
2020-04-14 21:51:06.406 INFO  org.example.App - ----------- org.example.App.useDocumentCreateXML end
解析XML字符串获取Document对象 public static Document parseText(String text) throws DocumentException {…}
 private static void useDocumentParseText() throws DocumentException {
        logger.info("----------- org.example.App.useDocumentParseText start");
        Document document = DocumentHelper.parseText("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
                "<root><person age=\"18\">张三</person><person age=\"19\">李四</person><person age=\"20\">王五</person></root>");
        logger.info(document.asXML());
        logger.info("----------- org.example.App.useDocumentParseText end");
    }

输出

2020-04-14 22:06:04.718 INFO  org.example.App - ----------- org.example.App.useDocumentParseText start
2020-04-14 22:06:04.759 INFO  org.example.App - <?xml version="1.0" encoding="UTF-8"?>
<root><person age="18">张三</person><person age="19">李四</person><person age="20">王五</person></root>
2020-04-14 22:06:04.759 INFO  org.example.App - ----------- org.example.App.useDocumentParseText end
模拟SpringIOC 依赖注入机制(通过反射实现)，有如下spring_core.xml配置,主要使用了反射机制

首先在项目当前目录中创建 spring-ioc.xml 文件模拟

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean id="testBean" class="com.just.Test"/>
</beans>

 // 模拟SpringIOC 依赖注入机制(通过反射实现)，有如下spring_core.xml配置,主要使用了反射机制
    private static void simulateIOC() throws FileNotFoundException, DocumentException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        logger.info("----------- org.example.App.simulateIOC start");
        SAXReader reader = new SAXReader();
        // File file =new File("logback.xml");
        File file = new File("spring-ioc.xml");
        if(file.exists()){
            InputStream in = new FileInputStream(file);
            Document document = reader.read(in);
            logger.info(document.asXML());
            Element root = document.getRootElement();
            Element foo;
            for (Iterator i = root.elementIterator("bean"); i.hasNext();){
                foo = (Element) i.next();
                //针对每一个bean实例获取id和name属性
                Attribute id = foo.attribute("id");
                Attribute clazz = foo.attribute("class");

                //利用反射，通过class名称获取class对象
                Class bean = Class.forName(clazz.getText());
                Object object = bean.newInstance();
                Method method = bean.getMethod("sayHello");
                Object result = method.invoke(object);
                logger.info(result.toString());
                // other 省略无关的反射操作
            }

            logger.info("----------- org.example.App.simulateIOC end");

        }
    }

输出

2020-04-14 22:55:43.869 INFO  org.example.App - ----------- org.example.App.simulateIOC start
2020-04-14 22:55:43.919 INFO  org.example.App - <?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="testBean" class="org.example.HelloWorld"/>
</beans>
2020-04-14 22:55:43.921 INFO  org.example.App - hello
2020-04-14 22:55:43.923 INFO  org.example.App - ----------- org.example.App.simulateIOC end
将Document写出
 // 将 document对象 输出为xml文件
    private static void outPutDocumentXML() throws Exception {
        logger.info("----------- org.example.App.outPutDocumentXML start");
        String xmlStr = "<books>"
                + "<book><title>AAA</title><author>aaa</author></book>"
                + "<book><title>BBB</title><author>bbb</author></book>"
                + "<book><title>CCC</title><author>ccc</author></book>"
                + "</books>";
        // 解析字符串获取document对象
        Document document = DocumentHelper.parseText(xmlStr);
        //设置输出样式（整洁）
        OutputFormat format = OutputFormat.createPrettyPrint();
        // 将document写出到output.xml中,并指定输出样式
        XMLWriter writer = new XMLWriter(new FileOutputStream("output.xml"),format);
        writer.write(document);
        // 使用pretty（整洁）样式输出到控制台
        writer = new XMLWriter(System.out, format);
        writer.write(document);
        System.out.println("--------------------------------------------------------------");
        // 使用紧凑样式输出到控制台
        format = OutputFormat.createCompactFormat();
        writer = new XMLWriter(System.out, format);
        writer.write(document);
        logger.info("----------- org.example.App.outPutDocumentXML end");
    }

输出

2020-04-14 22:59:59.308 INFO  org.example.App - ----------- org.example.App.outPutDocumentXML start
<?xml version="1.0" encoding="UTF-8"?>

<books>
  <book>
    <title>AAA</title>
    <author>aaa</author>
  </book>
  <book>
    <title>BBB</title>
    <author>bbb</author>
  </book>
  <book>
    <title>CCC</title>
    <author>ccc</author>
  </book>
</books>
--------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<books><book><title>AAA</title><author>aaa</author></book><book><title>BBB</title><author>bbb</author></book><book><title>CCC</title><author>ccc</author></book></books>2020-04-14 22:59:59.350 INFO  org.example.App - ----------- org.example.App.outPutDocumentXML end

源码地址: https://github.com/weijieqiu/iStudy/tree/master/studyDom4j/studyDom4j

AlterIt
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java ioc 简单实现原理_手动实现IOC容器：SpringIOC底层实现原理
weixin_36389909的博客
02-19 262
面试官特别爱问SpringIOC底层实现，Spring源码晦涩难懂怎么办呢? 跟着老师手动实现一个mini ioc容器吧，实现后再回头看Spring源码事半功倍哦，就算直接和面试官讲也完全可以哦，类名完全按照源码设计，话不多说开干~!手动实现IOC容器的设计需要实现的IOC功能：·可以通过xml配置bean信息·可以通过容器getBean获取对象·能够根据Bean的依赖属性实现依赖注入·可以配置B...
模拟实现spring IOC AOP的例子
09-16
不要忘记添加dom4j库，因为Spring在处理XML配置时会用到这个库。 在`springIocSimulation`项目中，你会看到如何通过XML配置文件定义Bean，以及如何使用ApplicationContext加载和管理这些Bean。同时，项目可能还包含...
dom4j简单实现IoC
Code-Zhao
09-28 1157
IoC：控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用传递给它。也可...
模拟实现IoC容器
一枚叶子
03-08 274
Spring的IoC核心就是控制反转，将对实现对象的操作控制器交出来，由IoC容器来管理，从配置文件中获取配置信息，Java对XML文档提供了完美的支持，dom4j功能强大，而下面我就用JDOM这一开源项目，利用它可以纯Java技术实现对XML文档的解析、生成、序列化来模拟实现IoC容器。 一、传统方式完成项目。 1.定义接口 package com.decipher.c...
使用dom4j模拟Spring解析
菜鸡的奋斗
10-13 232
需要解析的xml文件，注意引用ref。 &lt;?xml version="1.0" encoding="UTF-8" ?&gt; &lt;beans&gt; &lt;bean id="board1" class="模拟Spring.Board"&gt; &lt;property name="brand" value="华硕"&am
【Spring】使用dom4j与反射实现Spring IOC
HTN_MK的博客
08-29 877
使用dom4j解析xml文件，使用反射创建bean对象，再通过解析的属性name找到set方法，把value传进bean对象是Spring IOC的实现原理。 这里就用相同的方式手写代码实现Spring IOC。 配置文件 config.xml User.java public class User { private String
java练习之模拟SPRING IOC，我的SUMMER
01-25
在模拟Spring IoC的过程中，我们需要实现以下功能： - 创建一个容器类，用于存储和管理Bean。 - 解析上述XML配置文件，将Bean的定义加载到容器中。 - 实现根据ID获取Bean的方法。 - 实现依赖注入（Dependency ...
java 解析xml，模拟spring框架ioc
03-10
在提供的压缩包文件"xml_bean"中，可能包含了示例的XML配置文件和相关的Java类，你可以通过分析这些文件来加深对Java解析XML和模拟Spring IOC的理解。实际项目中，Spring框架提供了更高级的功能，如自动扫描、注解...
spring 3 依赖包_part3
10-02
Spring 3 依赖包是Java开发中至关重要的组成部分，它为开发者提供了丰富的功能，支持了面向切面编程（AOP）、依赖注入（DI）以及IoC容器等核心特性。在这个"spring 3 依赖包_part3"中，包含了多个第三方库，这些库在...
利用反射自实现IOC容器
12-26
利用dom4j解析xml文件+反射创建对象 这是个maven项目，jdk1.8，Tomcat8.5
Java反射机制模拟Spring IOC容器
学习亦游戏
12-23 1468
ref：Java反射机制深入研究  java反射机制 package reflection; import java.lang.reflect.Method; public class InvokeTest { public String add(int param1, int param2) { return param1 + " + " + param2
简单实现Spring的IOC容器
m0_49282106的博客
10-19 268
本文就通过dom4j解析xml文件，反射实例化对象，将对象存入hashmap，该容器可以解析通过属性注入的方式来实例化对象的xml文件
dom4j+反射机制 手写spring ioc
chuanyou3193的博客
12-29 172
SpringIOC原理： 1. 读取bean的XML配置文件 2. 使用beanId查找bean配置，并获取配置文件中class地址。 3. 使用Java反射技术实例化对象 4. 获取属性配置，使用反射技术进行赋值。 实现步骤 1. 利用传入的参数获取xml文件的流,并且利用dom4j解析成D...
spring&dom4j
aaazhyzmx的博客
10-27 796
一、技术：DOM4J 1.1)DOM4J简介：用于读取XML文件 1.2)读取配置文件需要的jar包:官网下载: http://www.dom4j.org/dom4j-1.6.1/ 1.3)dom4j相关方法介绍: (1).获取XML文档(Document类型) SAXReader reader=new SAXReader(); //读取xml文件的方式,当然，
慕课Spring学习笔记--实现一个极简IoC容器
blook12的博客
11-06 198
实现极简IoC容器
使用java反射机制+dom4j实现SpringIOC原理
zp的博客
08-27 707
SpringIOC的底层原理: 1、解析xml文件——使用dom4j 2、通过bean id查找到对象的xml节点，并获取该xml上class节点属性——获取根节点后遍历得到二级节点 3、通过java的反射机制初始化类 4、使用java的反射机制为私有属性赋值——遍历二级节点获得三级节点 API对应:List&lt;Element&gt; ele3 = element.elements(...
02-Spring底层技术之Dom4j
最新发布
小魏快起床的博客
11-07 269
之前给小伙伴们分享了一下什么是Spring，概念固然重要，但是还是要有技术支撑才能有更深的了解，那么在Spring中有哪些技术呢，这里小魏给大家讲一个dom4j，他是Spring的底层技术之一，主要是用来解析xml文档，下面就带大家一起来看看他是怎么使用的
使用java反射机制和dom4j写一个简版spring-ioc
weixin_42181142的博客
05-15 119
1.新建一个springboot项目 <groupId>com.springioc</groupId> <artifactId>spring-ioc</artifactId> <version>1.0-SNAPSHOT</version> 2.在pom文件中引入 <dependency> <groupId>org.apache.commons</groupId
Spring框架中的IOC与DI原理及容器实现
"第02章 IOC和bean的配置主要探讨了Spring框架中的核心概念——IOC（Inversion of Control，反转控制）和DI（Dependency Injection，依赖注入），以及它们在Spring中的实现方式。Spring是一个旨在简化企业级开发的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值