设计模式：23种
    常用的由：单例模式，工厂模式，代理模式，模板模式……

    工厂模式：相当于是工厂的作用，创建出对象，之后如果需要用到对象，可以直接去工厂拿就行。
    当前案例使用工厂模式是因为beans不止一个，所以使用工厂模式。
    当前安利的操作是将xml中的数据封装到BeanConfig中，使用工厂模式的概念

    1.BeanFactory首先加载xml配置文件 - 静态代码块
    2.将每一个bean标签配置内容，封装到BeanConfig中去
    2.最后将xml中的内容封装到一个容器中去，便于快速查询，map进行数据存储

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <beans>
    3.     <bean id="userID001" className="Day02_Demo.Demo02.User">
    4.         <property name = "uid" value = "u001">
    6.         </property>
    7.         <property name = "userName" value = "jack">
    9.         </property>
    10.         <property name = "passWord" value = "1234165">
    12.         </property>
    13.     </bean>
    14.     <bean id = "bookId002" className="Day02_Demo.Demo02.Book">
    15.         <property name = "bid" value = "u001">
    16.         </property>
    18.         <property name = "title" value = "java从入门到放弃">
    20.         </property>
    21.         <property name = "price" value = "88">
    23.         </property>
    24.     </bean>
    25. </beans>
    1. package Day02_Demo.Demo02;/*
    3.     @create 2020--12--23--11:19
    4. */
    6. public class Book {
    7.     private String bid;
    8.     private String title;
    9.     private Integer price;
    11.     public Book() {
    12.     }
    14.     public Book(String bid, String title, Integer price) {
    15.         this.bid = bid;
    16.         this.title = title;
    17.         this.price = price;
    18.     }
    20.     @Override
    21.     public String toString() {
    22.         return "Book{" +
    23.                 "bid='" + bid + '\'' +
    24.                 ", title='" + title + '\'' +
    25.                 ", price=" + price +
    26.                 '}';
    27.     }
    29.     public String getBid() {
    30.         return bid;
    31.     }
    33.     public void setBid(String bid) {
    34.         this.bid = bid;
    35.     }
    37.     public String getTitle() {
    38.         return title;
    39.     }
    41.     public void setTitle(String title) {
    42.         this.title = title;
    43.     }
    45.     public Integer getPrice() {
    46.         return price;
    47.     }
    49.     public void setPrice(Integer price) {
    50.         this.price = price;
    51.     }
    52. }
    1. package Day02_Demo.Demo02;/*
    3.     @create 2020--12--23--11:21
    4. */
    6. public class User {
    7.     private String uid;
    8.     private String userName;
    9.     private String passWord;
    11.     @Override
    12.     public String toString() {
    13.         return "User{" +
    14.                 "uid='" + uid + '\'' +
    15.                 ", userName='" + userName + '\'' +
    16.                 ", passWord='" + passWord + '\'' +
    17.                 '}';
    18.     }
    20.     public String getUid() {
    21.         return uid;
    22.     }
    24.     public void setUid(String uid) {
    25.         this.uid = uid;
    26.     }
    28.     public String getUserName() {
    29.         return userName;
    30.     }
    32.     public void setUserName(String userName) {
    33.         this.userName = userName;
    34.     }
    36.     public String getPassWord() {
    37.         return passWord;
    38.     }
    40.     public void setPassWord(String passWord) {
    41.         this.passWord = passWord;
    42.     }
    44.     public User(String uid, String userName, String passWord) {
    45.         this.uid = uid;
    46.         this.userName = userName;
    47.         this.passWord = passWord;
    48.     }
    50.     public User() {
    52.     }
    53. }
    1. package Day02_Demo.Demo02;/*
    3.     @create 2020--12--23--11:23
    4. */
    6. import java.util.Properties;
    8. /**
    9.  * javaBean的配置对象
    10.  * BeanConfig文件用于将对应的xml的配置项，解析封装到xml对象中
    11.  * 属性：id，className，properties
    12.  *
    13.  * 当前实体类的实例化bean.xml文件，相当于是一个属性配置文件的中转站
    14.  * 后面进行的操作都是通过这个中转站处理
    15.  */
    16. public class BeanConfig {
    17.     private String id;
    18.     private String className;
    19.     //用于解析当前的这个bean中所有的属性，所以直接创建一个properties对象
    20.     private Properties props = new Properties();
    22.     public BeanConfig() {
    24.     }
    26.     public BeanConfig(String id, String className, Properties props) {
    27.         this.id = id;
    28.         this.className = className;
    29.         this.props = props;
    30.     }
    32.     public String getId() {
    33.         return id;
    34.     }
    36.     public void setId(String id) {
    37.         this.id = id;
    38.     }
    40.     public String getClassName() {
    41.         return className;
    42.     }
    44.     public void setClassName(String className) {
    45.         this.className = className;
    46.     }
    48.     public Properties getProps() {
    49.         return props;
    50.     }
    52.     public void setProps(Properties props) {
    53.         this.props = props;
    54.     }
    56.     @Override
    57.     public String toString() {
    58.         return "BeanConfig{" +
    59.                 "id='" + id + '\'' +
    60.                 ", className='" + className + '\'' +
    61.                 ", props=" + props +
    62.                 '}';
    63.     }
    64. }
    1. package Day02_Demo.Demo02;/*
    3.     @create 2020--12--23--14:00
    4. */
    6. import org.apache.commons.beanutils.BeanUtils;
    7. import org.dom4j.Document;
    8. import org.dom4j.Element;
    9. import org.dom4j.io.SAXReader;
    11. import javax.management.relation.RoleUnresolved;
    12. import java.lang.annotation.ElementType;
    13. import java.util.HashMap;
    14. import java.util.List;
    15. import java.util.Map;
    17. /**
    18.  * 设计模式：23种
    19.  * 常用的由：单例模式，工厂模式，代理模式，模板模式……
    20.  * <p>
    21.  * 工厂模式：相当于是工厂的作用，创建出对象，之后如果需要用到对象，可以直接去工厂拿就行。
    22.  * 当前案例使用工厂模式是因为beans不止一个，所以使用工厂模式。
    23.  * 当前安利的操作是将xml中的数据封装到BeanConfig中，使用工厂模式的概念
    24.  * <p>
    25.  * 1.BeanFactory首先加载xml配置文件 - 静态代码块
    26.  * 2.将每一个bean标签配置内容，封装到BeanConfig中去
    27.  * 2.最后将xml中的内容封装到一个容器中去，便于快速查询，map进行数据存储
    28.  */
    29. public class BeanFactory {
    30.     //1.提供Map存放beans.xml中的配置文件内容，使用Map，建议使用静态处理 - 好处是只要加载一次
    31.     private static Map<String, BeanConfig> cache = new HashMap<>();
    32.     //静态块处理数据添加 - 直接使用静态块一次性加载
    34.     static{
    35.         try {
    36.             //加载xml，获取document
    37.             SAXReader saxReader = new SAXReader();
    38.             Document document = saxReader.read("xml//bean.xml");
    39.             //获取根元素
    40.             Element rootElement = document.getRootElement();
    41.             //获取所有的bean元素，当前子元素不止一个，所以使用list
    42.             List<Element> allBeanElement = rootElement.elements("bean");
    43.             //遍历集合
    44.             for (Element beanElement : allBeanElement) {
    45.                 //属性：id className
    46.                 String id = beanElement.attributeValue("id");
    47.                 String className = beanElement.attributeValue("className");
    49.                 //创建beanConfig，并且封装id和className
    50.                 BeanConfig beanConfig = new BeanConfig();
    51.                 beanConfig.setId(id);
    52.                 beanConfig.setClassName(className);
    54.                 //获取子标签 - property
    55.                 List<Element> allProperty = beanElement.elements("property");
    56.                 for (Element propElement : allProperty) {
    57.                     //获取属性：name value
    58.                     String name = propElement.attributeValue("name");
    59.                     String value = propElement.attributeValue("value");
    60.                     //将name和value保存到BeanConfig
    61.                     beanConfig.getProps().setProperty(name, value);
    62.                 }//内层for
    63.                 //将封装好的数据保存到map中
    64.                 cache.put(id, beanConfig);
    65.             }//外层for
    66.             System.out.println("初始化数据：" + cache);
    67.         } catch (Exception e) {
    68.             throw new RuntimeException(e);
    69.         }
    70.     }
    72.     //因为这是一个工厂，得有提供对象的方法 - 外面需要的时候可以通过这个方法来拿对象
    73.     //通过指定的beanId来获取相对应的BeanConfig
    74.     public static Object getBean(String beanId) {
    75.         //创建beanId获取相应的BeanConfig
    76.         BeanConfig beanConfig = cache.get(beanId);
    78.         //判断这个对象是不是合法
    79.         if (beanConfig == null) {
    80.             throw new RuntimeException("获得的对象[" + beanId + "]不存在");
    81.         }
    82.         //如果存在 - 通过反射机制进行获取
    83.         try {
    84.             String className = beanConfig.getClassName();
    85.             Class clazz = Class.forName(className);
    86.             Object obj = clazz.newInstance();//获取实例对象
    88.             //循环解析 - beanUtils
    89.             //stringPropertyNames()方法是从Properties的api中提供的，作用是获取到属性名字的字符串类型
    90.             for (String name : beanConfig.getProps().stringPropertyNames()) {
    91.                 //每遍历到一个name，就返回name对应的value
    92.                 String value = beanConfig.getProps().getProperty(name);
    93.                 //使用BeanUtils封装数据
    94.                 BeanUtils.setProperty(obj, name, value);
    95.             }
    96.             return obj;
    97.         } catch (Exception e) {
    98.             throw new RuntimeException(e);
    99.         }
    100.     }
    101. }
    1. package Day02_Demo.Demo02;/*
    3.     @create 2020--12--23--14:39
    4. */
    6. import org.junit.Test;
    8. /**
    9.  * 测试类
    10.  */
    11. public class XMLTest {
    12.     @Test
    13.     public void test() {
    14.         //通过实例化数据的方法获取
    15.         User user = (User) BeanFactory.getBean("userID001");
    16.         System.out.println(user);
    18.         Book book = (Book) BeanFactory.getBean("bookId002");
    19.         System.out.println(book);
    20.     }
    21. }