Junit单元测试

黑盒测试：

不需要写代码，只需要给输入值，看程序是否达到期望值

白盒测试：

需要写代码的，看程序执行的具体过程—-如：Junit单元测试
image.png
image.png
不能传参

@Before @After

image.png

  1. package com.igeek_01;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-18-9:29
  6.  */
  8. import org.junit.After;
  9. import org.junit.Before;
  10. import org.junit.Test;
  12. /**
  13.  * junit测试适用于代码的测试，是单元测试用于替代main方法
  14.  */
  15. public class JunitTest01 {
  17.     @Test
  18.     public void test01(){
  19.         System.out.println("运行1通过");
  20.     }
  21.     @Test
  22.     public void test02(){
  23.         System.out.println("运行2通过");
  24.     }
  26.     /**
  27.      * @Before
  28.      * @After
  29.      */
  30.     @Before
  31.     public void Before(){
  32.         System.out.println("在@Test方法之前运行");
  33.     }
  34.     @After
  35.     public void after(){
  36.         System.out.println("在@Test方法之后运行");
  37.     }
  38. }
  39. 运行结果：
  40. 在@Test方法之前运行
  41. 运行1通过
  42. 在@Test方法之后运行
  43. 在@Test方法之前运行
  44. 运行2通过
  45. 在@Test方法之后运行

image.png

  1. package com.igeek_01;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-18-10:00
  6.  */
  8. /**
  9.  * Junit测试类也是一个普通的类，也可以实例化
  10.  */
  11. public class JunitTest02 {
  12.     public static void main(String[] args) {
  13.         //实例化这个类
  14.         JunitTest01 test01=new JunitTest01();
  15.         test01.test01();
  16.         test01.after();
  17.         test01.Before();
  18.     }
  19. }
  20. 运行结果：
  21. 运行1通过
  22. 在@Test方法之后运行
  23. 在@Test方法之前运行

反射机制—reflect

定义：

  1. **   ****是在运行状态中，在任意一个类中，都能够知道他的所有的属性和方法；对于任意一个对象，都能够调用他的所有的属性和方法，这种动态获取的信息以及动态调用对象的方法的功能称之为java语言的反射机制。**<br />**       每一个类，都会被appclassloader加载到方法区，生成Class类型的对象**<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/2706946/1608257742267-bfac0e72-fb3b-4b95-8f8c-e8085272ecf2.png#align=left&display=inline&height=261&margin=%5Bobject%20Object%5D&name=image.png&originHeight=317&originWidth=905&size=198818&status=done&style=none&width=746)

获取类对象的方法

1.使用类：Class clazz=Student.class；
2.使用全类名（包名.类名）—比较常用—安全
Class clazz=Class.forName(“com.igeek_02.Student”);
3.使用对象：
Student s=new Student();
Class clazz=s.getClass();
image.png
image.png

  1. package com.igeek_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-18-10:11
  6.  */
  8. /**
  9.  * 实体类
  10.  * 用于测试反射
  11.  */
  12. public class Student {
  13.     //字段--属性
  14.     public int id;
  15.     private String name;
  17.     //构造
  18.     public Student() {
  19.         super();
  20.     }
  22.     public Student(int id, String name) {
  23.         super();
  24.         this.id = id;
  25.         this.name = name;
  26.     }
  28.     //方法
  30.     public int getId() {
  31.         return id;
  32.     }
  34.     public void setId(int id) {
  35.         this.id = id;
  36.     }
  38.     public String getName() {
  39.         return name;
  40.     }
  42.     //私有方法--用于测试
  43.     private void setName(String name) {
  44.         this.name = name;
  45.     }
  47.     //静态方法
  48.     public static int getCount(int c){
  49.         return c*10;
  50.     }
  52.     @Override
  53.     public String toString() {
  54.         return "Student{" +
  55.                 "id=" + id +
  56.                 ", name='" + name + '\'' +
  57.                 '}';
  58.     }
  59. }
  1. package com.igeek_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-18-10:04
  6.  */
  8. import org.junit.Test;
  10. /**
  11.  * java反射机制
  12.  *
  13.  * 目前讲反射是讲解反射的使用
  14.  */
  15. public class ReflectDemo {
  16.     //单元测试
  17.     @Test
  18.     public void test1(){
  19.         //已知明确的类型，获取Class对象
  20.         Class clazz=Student.class;
  21.         System.out.println(clazz);//class com.igeek_02.Student
  23.     }
  25.     @Test
  26.     public void test2(){
  27.         //已知对象，获取Class对象
  28.         Student s=new Student();
  29.         Class clazz=s.getClass();//getClass()是顶级父类Object中的方法
  30.         System.out.println(clazz);//class com.igeek_02.Student
  31.     }
  33.     @Test
  34.     public void test3() throws ClassNotFoundException {
  35.         //完全限定名（包名.类名），获取Class对象--比较常用--安全
  36.         String className="com.igeek_02.Student";
  37.         //forName()返回这个地址值所对应的类
  38.         Class clazz=Class.forName(className);
  39.         System.out.println(clazz);//class com.igeek_02.Student
  40.     }
  42.     //测试结果：通过不同的反射获取的对象是同一个!!
  43.     @Test
  44.     public void test4() throws ClassNotFoundException {
  45.         //第一种
  46.         Class clazz1=Student.class;
  48.         //第二种
  49.         Student s=new Student();
  50.         Class clazz2=s.getClass();
  52.         //第三种
  53.         String className="com.igeek_02.Student";
  54.         Class clazz3=Class.forName(className);
  56.         //比较
  57.         System.out.println(clazz1==clazz2);
  58.         System.out.println(clazz1==clazz3);
  59.         System.out.println(clazz3==clazz2);
  60.     }
  61. }
  1. package com.igeek_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-18-10:31
  6.  */
  8. import org.junit.Test;
  10. import java.lang.reflect.Constructor;
  11. import java.lang.reflect.InvocationTargetException;
  13. /**
  14.  * 通过java的反射机制构建对象的测试
  15.  */
  16. public class ReflectDemo2 {
  17.     @Test
  18.     public void test01() throws IllegalAccessException, InstantiationException {
  19.         //类中有无参构造
  20.         Class  clazz=Student.class;
  21.         Object obj=clazz.newInstance();//默认调用的是无参的--创建实例
  22.         System.out.println(clazz);//class com.igeek_02.Student
  23.         System.out.println(obj);//Student{id=0, name='null'}--
  24.         // 当前的object进行了向下转型给了反射获取到的类Student
  25.     }
  27.     @Test
  28.     public void test02() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
  29.         //获取Class类中的构造函数对象
  30.         Class clazz=Student.class;
  31.         //获取到有参构造函数
  32.         Constructor con= clazz.getConstructor(int.class, String.class);
  33.         Object obj = con.newInstance(20, "Tom");
  34.         System.out.println(obj);//Student{id=20, name='Tom'}
  35.     }
  37.     //演示普通的方式实例化对象做不到的事情
  38.     @Test
  39.     public void test03(){
  40.         Student s=new Student();
  41.         s.setId(1);
  42. //        s.setName();//不能进行name赋值，因为方法是私有的
  43.         System.out.println(s);//Student{id=1, name='null'}
  44.     }
  45. }
  1. package com.igeek_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-18-11:14
  6.  */
  8. import com.sun.deploy.xml.XMLable;
  9. import org.junit.Test;
  11. import java.lang.reflect.InvocationTargetException;
  12. import java.lang.reflect.Method;
  14. /**
  15.  * 反射处理静态方法
  16.  */
  17. public class ReflectDemo3 {
  18.     @Test
  19.     public void test01(){
  20.         //静态方法的调用--普通
  21.         int count=Student.getCount(10);
  22.         System.out.println(count);//100
  23.     }
  24.     @Test
  25.     public void test02() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
  26.         //静态方法的调用--利用反射机制处理
  27.         //1.创建Class
  28.         String className="com.igeek_02.Student";
  29.         Class clazz=Class.forName(className);
  30.         //2.调用静态方法
  31.         Method hetCount = clazz.getMethod("getCount", int.class);
  32.         //3.根据类型传参--invoke方法表示映射，这里因为不需要实例，所以可以传参null
  33.         Object obj=hetCount.invoke(null,2);
  34.         System.out.println(obj);//20
  36.     }
  37. }

获取字段—Field—-获取值和修改值

image.png
image.png
image.png

  1. package com.igeek.ziduan;
  3. import org.junit.Test;
  5. import java.lang.reflect.Field;
  7. /**
  8.  * @author Lynn
  9.  * @create 2020-12-21-9:31
  10.  */
  11. public class FieldTest01 {
  12.     //利用反射机制处理公共字段
  13.     @Test
  14.     public void test2() throws Exception{
  15.         //获取类
  16.         Class clazz=Class.forName("com.igeek.ziduan.Student");
  17.         //创建实例对象
  18.         Object o = clazz.newInstance();
  19.         //处理字段
  20.         Field id = clazz.getField("id");
  21.         id.set(o,30);
  22.         System.out.println(o);
  23.         //通过key获取值
  24.         Object o1 = id.get(o);
  25.         System.out.println(o1);
  27.     }
  28.     //利用反射机制处理私有字段
  29.     @Test
  30.     public void test3() throws Exception{
  31.         //获取类
  32.         Class clazz=Class.forName("com.igeek.ziduan.Student");
  33.         //创建实例对象
  34.         Object o = clazz.newInstance();
  35.         //处理字段
  36.         Field name = clazz.getDeclaredField("name");
  37.         System.out.println(name);//private java.lang.String com.igeek.ziduan.Student.name
  38.         //打破私有权限
  39.         name.setAccessible(true);
  40.         name.set(o,"Lynn");
  41.         System.out.println(o);//Student{id=0, name='Lynn'}
  42.         //通过key获取值
  43.         Object o1 = name.get(o);
  44.         System.out.println(o1);//Lynn
  46.     }
  47. }

获取方法—-invoke—用来调用

image.png

构造方法—-核心是用来构造对象的—new对象

image.png
image.png

讲解Properties使用

映射—在properties中使用Map—通过键找到值
image.png

  1. package com.igeek.properties;
  3. import org.junit.Test;
  5. import java.io.*;
  6. import java.util.Properties;
  8. /**
  9.  * @author Lynn
  10.  * @create 2020-12-21-9:47
  11.  */
  12. public class PropertiesDemo {
  13.     //第一种方式：添加内容，使用Map中的方法--put
  14.     @Test
  15.     public void test1() throws IOException {
  16.         //保存properties的数据到流中--void store(OutputStream out,String content)
  17.         Properties prop=new Properties();
  18.         prop.put("id","100");
  19.         prop.put("name","Lynn");
  20.         prop.store(new FileOutputStream("t.txt"),"要写入的内容");//内容的Unicode
  21.     }
  23.     //读取流--void load(InputStream in)
  24.     @Test
  25.     public void test2() throws IOException {
  26.         Properties prop=new Properties();
  27.         //读取
  28.         prop.load(new FileInputStream("t.txt"));
  29.         System.out.println(prop);//{name=Lynn, id=100}
  30.         //
  31.         String id = prop.getProperty("id");
  32.         System.out.println(id);
  33.         String name = prop.getProperty("name");
  34.         System.out.println(name);
  35.     }
  36.     //第二种方式：使用properties方法设置数据--setProperty
  37.     @Test
  38.     public void test3() throws IOException {
  39.         Properties prop=new Properties();
  40.         prop.setProperty("id","20");
  41.         prop.setProperty("name","Cheery");
  42.         prop.store(new FileOutputStream("t2.txt"),"过");
  43. //        System.out.println(prop);//{name=Cheery, id=20}
  44.         //通过key获取值
  45.         String id = prop.getProperty("id");
  46.         String name = prop.getProperty("name");
  47.         /*String id = prop.getProperty("id1");
  48.         System.out.println(id);*///如果key炸不到则返回null
  49. //        System.out.println(name);
  50.     }
  51.     //读取
  52.     @Test
  53.     public void test4() throws IOException {
  54.         Properties prop=new Properties();
  55.         prop.load(new FileInputStream("t2.txt"));
  56.         System.out.println(prop.get("id"));
  57.         System.out.println(prop.get("name"));
  59.     }
  60. }

配置文件—利用properties类实现不修改源码的基础上处理数据

注意：从**properties**中获取的都是字符串类型
image.png
image.png
image.png

  1. package com.igeek.config;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-21-10:32
  6.  */
  8. import org.junit.Test;
  10. import java.io.FileInputStream;
  11. import java.io.FileNotFoundException;
  12. import java.io.FileReader;
  13. import java.io.IOException;
  14. import java.lang.reflect.Constructor;
  15. import java.lang.reflect.InvocationTargetException;
  16. import java.util.Properties;
  18. /**
  19.  * 利用properties类实现不修改源码的基础上处理数据
  20.  */
  21. public class ConfigTest {
  22.     @Test
  23.     public void test1(){
  24.         //测试学生和老师的对象
  25.         Student s=new Student(54,"Lynn");
  26.         System.out.println(s);
  27.         Teacher t=new Teacher(54,"Lynn");
  28.         System.out.println(t);
  29.     }
  31.     /**
  32.      *从配置文件className中读取要获取哪一个类
  33.      * 好处：获取哪个类直接修改配置文件，不需要修改源代码
  34.      * 1.首先要获取配置文件
  35.      */
  36.     @Test
  37.     public void test2() throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
  38.         //从className中读取类名
  39.         Properties prop=new Properties();
  40.         //加载配置文件并且读取
  41.         prop.load(new FileReader("className.properties"));
  42.         //根据key获取value
  43.         String className= prop.getProperty("className");
  44.         System.out.println(className);//com.igeek.config.Teacher
  45.         //创建类的实例--反射
  46.         Class clazz=Class.forName(className);
  47.         //找到该类的构造器--有参
  48.         Constructor constructor = clazz.getConstructor(int.class, String.class);
  49.         //利用构造函数处理数据
  50.         Object o = constructor.newInstance(54, "Lynn");
  51.         System.out.println(o);
  52.     }
  54.     /**
  55.      * 从配置文件data.properties中读取数据并且填入实例
  56.      *
  57.      */
  58.     @Test
  59.     public void test3() throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
  60.         //从className中读取类名
  61.         Properties prop=new Properties();
  62.         //加载配置文件并且读取
  63.         prop.load(new FileReader("className.properties"));
  64.         //根据key找到value
  65.         String className = prop.getProperty("className");
  66.         //创建实例
  67.         Class clazz=Class.forName(className);
  68.         //构造函数中进行处理
  69.         //1.从data配置文件中获取数据
  70.         Properties prop_Data=new Properties();
  71.         prop_Data.load(new FileReader("data.properties"));
  72.         String v_id = prop_Data.getProperty("id");
  73.         String v_name = prop_Data.getProperty("name");
  74.         System.out.println(v_id+v_name);
  76.         //将数据写入对象
  77.         Constructor constructor = clazz.getConstructor(int.class, String.class);
  78.         //从properties中获取的都是字符串类型，所以要强制转换为int类型--parseInt
  79.         Object o = constructor.newInstance(Integer.parseInt(v_id),v_name);
  80.         System.out.println(o);
  81.     }
  82. }

BeanUtils工具类

image.png
image.png

  1. package com.igeek.user;
  3. import org.apache.commons.beanutils.BeanUtils;
  4. import org.junit.Test;
  6. import java.lang.reflect.InvocationTargetException;
  7. /**
  8.  * @author Lynn
  9.  * @create 2020-12-21-11:27
  10.  */
  12. public class BeanUtilsDemo {
  13.     //常规的--调用get/set方法
  14.     @Test
  15.     public void test1(){
  16.         User use=new User();
  17.         use.setUid("u001");
  18.         use.setUsername("Lynn");
  19.         System.out.println(use);//User{uid='u001', username='Lynn', password='null', hobbies=null, age=0}
  20.     }
  22.     //使用BeanUtils工具进行封装--底层调用的还是get/set方法
  23.     @Test
  24.     public void test2() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
  25.         User use=new User();
  26.         //
  27.         BeanUtils.setProperty(use,"uid","u002");
  28.         //封装配置文件
  29.         BeanUtils.setProperty(use,"username","Cheery");
  30.         BeanUtils.setProperty(use,"password","123");
  31.         System.out.println(use);//User{uid='u002', username='Cheery', password='123', hobbies=null, age=0}
  33.         //获取值
  34.         System.out.println(BeanUtils.getProperty(use, "username"));//Cheery
  35.         //如果找不到会报错
  36.         /*System.out.println(BeanUtils.getProperty(use, "username1"));
  37.         //java.lang.NoSuchMethodException: Unknown property 'username1' on class 'class com.igeek.user.User'*/
  38.     }
  39. }

image.png
BeanUtils**类的populate(Object bean, Map properties)：
将Map数据封装到指定Javabean中，一般用于将表单的所有数据封装到javabean。**

  1. package com.igeek.user;
  3. import org.apache.commons.beanutils.BeanUtils;
  4. import org.junit.Test;
  6. import java.lang.reflect.InvocationTargetException;
  7. import java.util.HashMap;
  8. import java.util.Map;
  9. /**
  10.  * @author Lynn
  11.  * @create 2020-12-21-11:27
  12.  */
  14. /**
  15.  * BeanUtils的方法讲解
  16.  */
  17. public class BeanUtilsDemo1 {
  18.     //使用populated方法进行填充数据方法1
  19.     @Test
  20.     public void test1() throws InvocationTargetException, IllegalAccessException {
  21.         //1.模拟数据，创建map，填充所需要的数据
  22.         Map<String,String[]> map=new HashMap<>();
  23.         map.put("uid",new String[]{"u007"});
  24.         map.put("username",new String[]{"王嘉尔"});
  25.         map.put("password",new String[]{"123"});
  27.         //2.使用populate方法进行填充
  28.         User user=new User();
  29.         BeanUtils.populate(user,map);
  30.         System.out.println(user);
  31.     }
  33.     //使用BeanUtils工具进行封装--底层调用的还是get/set方法
  34.     @Test
  35.     public void test2() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
  36.         Map<String,String[]> map=new HashMap<>();
  37.         map.put("uid",new String[]{"u008"});
  38.         //底层：就是调用了setUsername方法
  39.         map.put("username",new String[]{"郭靖","黄蓉"});
  40.         map.put("password",new String[]{"123"});
  41.         map.put("hobbies",new String[]{"降龙十八掌","碧海潮生曲","打狗十八式"});
  42.         map.put("age",new String[]{"45"});
  44.         //2.使用populate方法进行填充
  45.         /**
  46.          * 可以指定属性，统一进行填充，需要的类型是数组[]
  47.          * 如果属性不是数组，将使用map.value表示数组中的第一个数据--
  48.          * 黄蓉不是第一个数据，所以不见了
  49.          * BeanUtils支持的类型：基本类型和基本类型对应的包装类，
  50.          * 自动将字符串转换为基本类型--自己做的
  51.          */
  52.         User user=new User();
  53.         BeanUtils.populate(user,map);
  54.         System.out.println(user);//User{uid='u008', username='郭靖', password='123', hobbies=[降龙十八掌, 碧海潮生曲, 打狗十八式], age=45}
  56.     }
  57. }

自定义BeanUtils工具类

image.png

  1. package com.igeek.user;
  3. import org.apache.commons.beanutils.BeanUtils;
  4. import org.junit.Test;
  6. import java.lang.reflect.InvocationTargetException;
  7. import java.util.HashMap;
  8. import java.util.Map;
  9. /**
  10.  * @author Lynn
  11.  * @create 2020-12-21-11:27
  12.  */
  14. /**
  15.  * 自定义BeanUtils工具类
  16.  */
  17. public class BeanUtilsDemo2 {
  18.    //自动填充
  19.     public static void populate(Object bean,Map<String,String[]> properties){
  20.         try {
  21.             BeanUtils.populate(bean,properties);
  22.         } catch (Exception e) {
  23.             throw new RuntimeException(e);
  24.         }
  25.     }
  27.     //自动填充的方法，并且返回bean对象
  28.     public static Object populate(Class beanClass,Map<String,String[]> properties){
  29.         try {
  30.             Object bean = beanClass.newInstance();
  31.             //
  32.             BeanUtils.populate(bean,properties);
  33.             return bean;
  34.         } catch (Exception e) {
  35.             throw new RuntimeException(e);
  36.         }
  37.     }
  38. }
  1. package com.igeek.user;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-21-15:07
  6.  */
  8. import org.apache.commons.beanutils.BeanUtils;
  9. import org.junit.Test;
  11. import java.util.HashMap;
  12. import java.util.Map;
  14. /**
  15.  * 测试自定义的方法--populate
  16.  */
  17. public class MyBeanUtilsTest {
  18.     //测试没有返回值的方法
  19.     @Test
  20.     public void test1(){
  21.         Map<String,String[]> map=new HashMap<>();
  22.         map.put("uid",new String[]{"u007"});
  23.         map.put("username",new String[]{"王嘉尔"});
  24.         map.put("password",new String[]{"123"});
  26.         //2.使用populate方法进行填充
  27.         User user=new User();
  28.         BeanUtilsDemo2.populate(user,map);
  29.         System.out.println(user);
  30.     }
  32.     //测试有返回值的方法
  33.     @Test
  34.     public void test2(){
  35.         Map<String,String[]> map=new HashMap<>();
  36.         map.put("uid",new String[]{"u007"});
  37.         map.put("username",new String[]{"王嘉尔"});
  38.         map.put("password",new String[]{"123"});
  40.         //2.使用populate方法进行统一的填充--向下转型--因为自己封装的方法返回的是Object类型，
  41.         //所以如果要获取，指定的类型就必须向下转型
  42.         User user = (User) BeanUtilsDemo2.populate(User.class, map);//向下转型
  43.         System.out.println(user);
  44.     }
  45. }

带泛型的自定义工具类

  1. package com.igeek.MyBeanUtils;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-21-15:53
  6.  */
  8. import org.apache.commons.beanutils.BeanUtils;
  9. import org.apache.commons.beanutils.BeanUtilsBean;
  11. import java.lang.reflect.InvocationTargetException;
  12. import java.util.Map;
  14. /**
  15.  * MyBeanUtils泛型使用
  16.  */
  17. public class MyBeanUtils {
  18.     /**
  19.      *
  20.      * @param beanClass
  21.      * @param properties
  22.      * @return
  23.      *
  24.      * Class<T>此时这个T就是一个变量，在运行的时候，接收具体的类型。例如：User
  25.      * 变量必须先定义再使用
  26.      * 泛型变量的定义方式，修饰符<变量名> 返回值
  27.      */
  28.     public static <T> T populate(Class<T> beanClass, Map<String,String[]> properties){
  30.         try {
  31.             //1.使用反射机制实例化
  32.             T bean=beanClass.newInstance();
  33.             //2.填充数据
  34.             BeanUtils.populate(bean,properties);
  35.             //返回数据
  36.             return bean;
  37.         } catch (Exception e) {
  38.             throw new RuntimeException(e);
  39.         }
  41.     }
  42. }
  1. package com.igeek.MyBeanUtils;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-21-16:00
  6.  */
  8. import com.igeek.user.User;
  9. import org.junit.Test;
  11. import java.util.HashMap;
  12. import java.util.Map;
  14. /**
  15.  * 测试自定义泛型的BeanUtils
  16.  */
  17. public class MyBeanUtilsTest {
  18.     @Test
  19.     public void test1(){
  20.         Map<String,String[]> map=new HashMap<>();
  21.         map.put("uid",new String[]{"u007"});
  22.         map.put("username",new String[]{"王嘉尔","王一博"});
  23.         map.put("password",new String[]{"123"});
  25.         //数据填充--用到了泛型
  26.         User user = MyBeanUtils.populate(User.class, map);
  27.         System.out.println(user);
  29.     }
  30. }

xml文件

DOM4j工具

image.png

  1. package com.igeek.Dom4j;
  3. import org.dom4j.Document;
  4. import org.dom4j.DocumentException;
  5. import org.dom4j.Element;
  6. import org.dom4j.io.SAXReader;
  7. import org.junit.Test;
  9. import java.util.List;
  11. /**
  12.  * @author Lynn
  13.  * @create 2020-12-23-10:34
  14.  */
  15. public class DOM4jDemo {
  16.     //测试DOM4j解析
  17.     @Test
  18.     public void testParse() throws DocumentException {
  19.         //1.获取核心类--import org.dom4j.io.SAXReader;
  20.         SAXReader saxReader=new SAXReader();
  21.         //2.获取整个xml文档--import org.dom4j.Document;
  22.         Document document= saxReader.read("beans.xml");
  23.         //3.获取所有beans--import org.dom4j.DocumentException;
  24.         Element rootElement= document.getRootElement();
  25.         //4.获取所有的子节点
  26.         List<Element> allBeanElement = rootElement.elements("bean");
  27.         //遍历集合
  28.         for (Element beanEle:allBeanElement){
  29.             //根据自己设定的属性进行解析--bean
  30.             String id=beanEle.attributeValue("id");
  31.             String className=beanEle.attributeValue("className");
  32.             System.out.println("bean的属性："+id+","+className);
  34.             //获取子元素的property
  35.             List<Element> property = beanEle.elements("property");
  36.             for (Element propEle:property){
  37.                 String name=propEle.attributeValue("name");
  38.                 String value=propEle.attributeValue("value");
  39.                 System.out.println("property的属性："+name+","+value);
  40.             }
  41.         }
  42. //        System.out.println();//换行
  43.     }
  44. }

综合案例1—工厂模式

image.png
image.png
image.png

  1. package com.igeek.Dom4j_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-23-11:23
  6.  */
  8. import java.util.Properties;
  10. /**
  11.  * javaBean的配置对象
  12.  *
  13.  * BeanConfig文件用于将对应的xml的配置项，解析封装到对象中
  14.  * 属性：id,className,property
  15.  *
  16.  * 当前这个实体类的实例化beans.xml文件，相当于是一个属性配置的中转站
  17.  * 后面进行的操作都是通过中转站处理的
  18.  */
  19. public class BeanConfig {
  20.     private String id;
  21.     private String className;
  22.     //用于解析当前的这个bean中的所有的属性，所以直接创建一个properties的对象
  23.     private Properties props=new Properties();
  25.     public BeanConfig(){
  27.     }
  29.     public BeanConfig(String id, String className, Properties props) {
  30.         this.id = id;
  31.         this.className = className;
  32.         this.props = props;
  33.     }
  35.     public String getId() {
  36.         return id;
  37.     }
  39.     public void setId(String id) {
  40.         this.id = id;
  41.     }
  43.     public String getClassName() {
  44.         return className;
  45.     }
  47.     public void setClassName(String className) {
  48.         this.className = className;
  49.     }
  51.     public Properties getProps() {
  52.         return props;
  53.     }
  55.     public void setProps(Properties props) {
  56.         this.props = props;
  57.     }
  59.     @Override
  60.     public String toString() {
  61.         return "BeanConfig{" +
  62.                 "id='" + id + '\'' +
  63.                 ", className='" + className + '\'' +
  64.                 ", props=" + props +
  65.                 '}';
  66.     }
  67. }
  1. package com.igeek.Dom4j_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-23-14:00
  6.  */
  8. import org.apache.commons.beanutils.BeanUtils;
  9. import org.dom4j.Document;
  10. import org.dom4j.Element;
  11. import org.dom4j.io.SAXReader;
  12. import org.junit.Test;
  14. import java.util.HashMap;
  15. import java.util.List;
  16. import java.util.Map;
  18. /**
  19.  * 设计模式：23种，常用的有：
  20.  * 单例模式，工厂模式，代理模式，模板模式...
  21.  *
  22.  * 工厂模式：
  23.  */
  24. public class BeanFactory {
  25.     //1.提供map存放beans.xml中的配置文件内容，使用map，建议使用静态处理--好处是只要加载一次
  26.     private static Map<String,BeanConfig> cache=new HashMap<>();
  27.     //静态块进行处理数据添加--直接使用静态块一次性加载
  28.     static {
  29.         try {
  30.             //
  31.             SAXReader saxReader = new SAXReader();
  32.             Document document = saxReader.read("beans.xml");
  33.             //获取根元素
  34.             Element rootElement = document.getRootElement();
  35.             //获取所有的bean元素，当前子元素不止一个，使用list
  36.             List<Element> allBeanElement = rootElement.elements("bean");
  37.             //遍历集合
  38.             for (Element beanEle : allBeanElement) {
  39.                 //外层的bean的属性
  40.                 String id = beanEle.attributeValue("id");
  41.                 String className = beanEle.attributeValue("className");
  43.                 //创建BeanConfig,并且封装id和className
  44.                 BeanConfig beanConfig = new BeanConfig();
  45.                 beanConfig.setId(id);
  46.                 beanConfig.setClassName(className);
  48.                 //获取子标签property
  49.                 List<Element> allPropertyElement = beanEle.elements("property");
  50.                 for (Element propEle : allPropertyElement) {
  51.                     String name = propEle.attributeValue("name");
  52.                     String value = propEle.attributeValue("value");
  53.                     //将name和value保存到BeanConfig中--先拿到property
  54.                     beanConfig.getProps().setProperty(name, value);
  55.                 }//内层for循环
  57.                 //将封装好的数据保存到map集合
  58.                 cache.put(id, beanConfig);
  59.             }//外层for循环--end
  60.             System.out.println("初始化数据：" + cache);
  61.         } catch (Exception e) {
  62.             throw new RuntimeException(e);
  63.         }
  64.     }
  65.         //
  66.         public static Object getBean(String beanId){
  67.             BeanConfig beanConfig=cache.get(beanId);
  69.             //判断这个对象是否合法
  70.             if (beanConfig==null){
  71.                 throw new RuntimeException("获得的对象["+beanId+"]不存在");
  72.             }
  73.             //如果存在--通过反射机制进行获取
  74.             try {
  75.                 String className = beanConfig.getClassName();
  76.                 Class clazz=Class.forName(className);
  77.                 //获取实例对象
  78.                 Object obj = clazz.newInstance();
  80.                 //循环解析--BeanUtils
  81.                 //stringPropertyNames()方法是Properties的api中提供的，
  82.                 // 作用是获取到属性名字的字符串类型
  83.                 for (String name:beanConfig.getProps().stringPropertyNames()){
  84.                     //每遍历到一个name，就返回name对应的value
  85.                     String value=beanConfig.getProps().getProperty(name);
  86.                     //使用BeanUtils封装数据
  87.                     BeanUtils.setProperty(obj,name,value);
  88.                 }
  89.                 return obj;
  90.             }catch(Exception e){
  91.                 throw new RuntimeException(e);
  92.             }
  93.         }
  94. }
  1. package com.igeek.Dom4j_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-23-14:39
  6.  */
  8. import org.junit.Test;
  10. /**
  11.  * 测试类
  12.  */
  13. public class XMLTEst {
  14.     @Test
  15.     public void test(){
  16.         //通过实例化数据的方法获取
  17.         User user=(User)BeanFactory.getBean("userId01");
  18.         System.out.println(user);
  19.         Book book=(Book) BeanFactory.getBean("book02");
  20.         System.out.println(book);
  21.     }
  22. }

类加载器

演示类加载器的使用