XML：可扩展的标记语言。

  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <!-- xml中的标签名和属性名都可以自定义 -->
  3. <bean id="xx" className="zz">
  4.   <property name="xml" value="xx">
  5.   </property>
  6. </bean>
  7. <!-- 如果在xml中需要处理注释 - 注释过后的文件内容不会被解析，要将xml代码注释 -->
  8. <![CDATA[ .........]]>

DOM4J：用来解析xml

dom4j是一个第三方的提供的一种专门用于解析xml的工具类，功能十分强大。
4：for
j：java

使用步骤：**

  1. 获取核心类
  2. 获取document（整个xml文档）
  3. 获取beans
  4. 获取所有的子元素bean - bean属性
  5. image.png
  6. ** ```java package day2.demo.xml;

import org.dom4j.Document; import org.dom4j.DocumentException; import org.dom4j.Element; import org.dom4j.io.SAXReader; import org.junit.Test;

import java.util.List;

public class DOM4JDemo { @Test public void testParse() throws DocumentException { //1.获取核心类 SAXReader saxReader = new SAXReader(); //2.获取document（整个xml文档） Document document = saxReader.read(“src/day2/demo/xml/beans.xml”); //3.获取beans Element rootElement = document.getRootElement(); //4.获取所有的子元素bean List allBeanElement = rootElement.elements(“bean”); //遍历list for (Element element : allBeanElement) { //根据自己设定的属性进行解析 String id = element.attributeValue(“id”); String className = element.attributeValue(“class”); System.out.println(id+”—“+className); //获取子元素的property List propertys = element.elements(“property”); for (Element property : propertys) { String name = property.attributeValue(“name”); System.out.println(“xx”+name); } } } }

  1. <a name="aLI2Y"></a>
  2. # 设计模式：工厂模式
  3. **设计模式：23种，常用的有：单例模式、工厂模式、代理模式、模板模式...**
  5. **工厂模式：相当于工厂的作用，创建出对象，之后如果需要这个对象，可以直接去工厂拿就行。**<br />**<br />**当前案例的操作是将xml中的数据封装到BeanConfig中，使用工厂模式的概念。**
  7. - **1.BeanFactory首先加载xml配置文件 - 静态代码块**
  8. - **2.将每一个bean标签配置内容，封装到BeaConfig中去**
  9. - **3.最后将整个xml中的内容封装到一个容器中，便于快速查询，map进行数据存储**
  10. ```java
  11. package day2.demo.ba3;
  13. import org.apache.commons.beanutils.BeanUtils;
  14. import org.dom4j.Document;
  15. import org.dom4j.Element;
  16. import org.dom4j.io.SAXReader;
  17. import org.junit.Test;
  19. import java.util.HashMap;
  20. import java.util.List;
  21. import java.util.Map;
  23. public class BeanFactory {
  24.     //1.提供map存放beans.xml中的配置文件内容，使用map，建议使用静态处理 - 好处是只要加载一次
  25.     private static Map<String,BeanConfig> cache = new HashMap<>();
  26.     //静态代码块处理数据添加
  27.     static{
  28.         try{
  29.             //加载xml，获取document
  30.             SAXReader saxReader = new SAXReader();//使用DOM4J工具
  31.             Document document = saxReader.read("src/day2/demo/ba3/beans.xml");
  32.             //获取根节点
  33.             Element rootElement = document.getRootElement();
  34.             //获取根下的bean
  35.             List<Element> allBeanElement = rootElement.elements("bean");
  36.             //遍历list
  37.             for (Element beanElement : allBeanElement) {
  38.                 //获取bean中的属性
  39.                 String id = beanElement.attributeValue("id");
  40.                 String className = beanElement.attributeValue("className");
  41.                 //创建BeanConfig，并且封装id和className
  42.                 BeanConfig beanConfig = new BeanConfig();
  43.                 beanConfig.setId(id);
  44.                 beanConfig.setClassName(className);
  46.                 //再获取bean下的子标签
  47.                 List<Element> allProperty = beanElement.elements("property");
  48.                 for (Element prop : allProperty) {
  49.                     //获取属性：name value
  50.                     String name = prop.attributeValue("name");
  51.                     String value = prop.attributeValue("value");
  52.                     //将name和value保存到BeanConfig
  53.                     beanConfig.getProps().setProperty(name,value);
  54.                 }//内存for
  55.                 //将封装好的数据存放到map中
  56.                 cache.put(id,beanConfig);
  57.             }//外层for
  58.             //测试
  59.             System.out.println("初始化数据:"+cache);
  60.         } catch(Exception e){
  61.             throw new RuntimeException(e);
  62.         }
  63.     }
  65.     //因为这是一个工厂，需要提供对象的方法 - 外面需要的时候可以通过这个方法来拿对象
  66.     //通过指定的beanId来获取相对应的BeanConfig
  67.     public static Object getBean(String beanId){
  68.         //创建beanId获取相应的BeanConfig
  69.         BeanConfig beanConfig = cache.get(beanId);
  70.         //判断这个对象是不是合法
  71.         if(beanConfig == null){
  72.             throw new RuntimeException("获得的对象["+beanId+"]不存在");
  73.         }else{
  74.             //如果存在 - 通过反射机制进行获取
  75.             try{
  76.                 String className = beanConfig.getClassName();
  77.                 Class cla = Class.forName(className);
  78.                 Object obj = cla.newInstance();//获取实例对象
  79.                 //循环解析 - BeanUtils
  80.                 for(String name:beanConfig.getProps().stringPropertyNames()){
  81.                     //每遍历到一个name，就返回name对应的value
  82.                     String value = beanConfig.getProps().getProperty(name);
  83.                     //使用BeanUtils封装数据
  84.                     BeanUtils.setProperty(obj,name,value);
  85.                 }
  86.                 return obj;
  87.             } catch (Exception e){
  88.                 throw new RuntimeException(e);
  89.             }
  90.         }
  91.     }
  92. }

stringPropertyNames()方法用于获取此属性列表中存在的所有键，并且此处的键及其所需值是字符串，并且默认属性列表中存在唯一键以在Set中进行查看。

静态代码块

  1. 它是随着类的加载而执行，只执行一次，并优先于主函数。具体说，静态代码块是由类调用的。类调用时，先执行静态代码块，然后才执行主函数的。
  2. 静态代码块其实就是给类初始化的，而构造代码块是给对象初始化的。
  3. 静态代码块中的变量是局部变量，与普通函数中的局部变量性质没有区别。
  4. 一个类中可以有多个静态代码块

static{
//静态代码块
}

在代码设计中可以用来创建可以单例的对象，不用每次调用一个相同的对象时都要重新new一次，提高性能