Java反射、注解、动态代理、XML解析

Java反射、注解、动态代理、XML解析

反射

• 通过反射可以直接访问类内部的所有属性与方法

获取类对象

// 通过类名进行加载
Class<?> aClass = Class.forName("com.lmx.ReflectionDomo.Student");
// 通过类名.class的方式加载
Class<Student> studentClass = Student.class;
Student student = new Student();
// 通过getclass的方法获取
Class<? extends Student> aClass1 = student.getClass();

获取构造器对象

// 获取构造器,获取所有私有的构造器
        Constructor<?>[] constructors = studentClass.getConstructors();
        //获取所有的构造器，不区分私有、共有
        Constructor<?>[] declaredConstructors = studentClass.getDeclaredConstructors();

• 使用获取到的构造器对象，创建学生对象

//        打开权限，直接进行暴力反射,当构造方法为私有时，需要打开权限才能进行暴力反射
        declaredConstructor.setAccessible(true);
        // 使用newintence方法创建对象
        Student testsutdent = declaredConstructor.newInstance("1", "2", "3");

成员变量

Field[] field = studentClass.getFields();//获取全部的成员变量，共有的
  
        Field[] declarefield = studentClass.getDeclaredFields();//获取全部成员变量，不区分共有私有
        Field age = studentClass.getDeclaredField("age");
        System.out.println(age.getType());
//        进行赋值的操作
//        打开权限，取消访问检查，进行暴力反射
        age.setAccessible(true);
//        进行赋值的操作
        age.set(testsutdent, "23");

方法对象

• 获取方法对象

//        获取方法对象
        Method[] methods = studentClass.getMethods();

• 获取到的方法对象可以通过invoke函数进行调用，例如：add.invoke(list, “李满祥”);
• 使用案例，向集合框架中添加不类型的元素

```//        通过反射实现向集合框架中添加内容
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        System.out.println(list);

        Class<? extends ArrayList> aClass2 = list.getClass();
        Method add = aClass2.getMethod("add", Object.class);

        add.invoke(list, "李满祥");
//        System.out.println(list)

注解

注解的定义

• 使用@interfance关键字进行定义

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME) // 运行时生效
public @interface Bool {
    String name();

    String autor();

    String[] character();

}

• @Traget注解为元注解，指定该注解可以使用的位置，例如，类（type），方法（method），属性（Feild）等
• @Retention注解，指定该注解生效的区域，在运行时与字节码生效
• 核心方法：getDeclaredAnnotation（），返回值为注解对象；
• isAnnotationPresent（），判断是否具有该注解
• 使用案例
  • 获取标注了指定注解的方法

package com.lmx.zhujie;

import com.lmx.proxy.proxy_Annation.Mytest;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class MoNiJUnite {
    public void test1() {
        System.out.println("test1");
    }


    public void test2() {
        System.out.println("test2");
    }

//    @Mytest
    public void test3() {
        System.out.println("test3");
    }

//    @Mytest
    public void test4() {
        System.out.println("test4");
    }

    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException, InstantiationException {
        Class<MoNiJUnite> moNiJUniteClass = MoNiJUnite.class;
        Constructor<MoNiJUnite> constructor = moNiJUniteClass.getConstructor();
        MoNiJUnite moNiJUnite = constructor.newInstance();
        Method[] declaredMethods = moNiJUniteClass.getDeclaredMethods();
        for (Method m : declaredMethods) {
            if (m.isAnnotationPresent(Mytest.class)) {
                m.invoke(moNiJUnite);
            }
        }
    }
}

• 获取注解中添加的信息

public static void main(String[] args) throws NoSuchMethodException {
        Class<ZhuJie> zhuJieClass = ZhuJie.class;
        if (zhuJieClass.isAnnotationPresent(Bool.class)) {
            // 获取注解对象
            Bool declaredAnnotation = zhuJieClass.getDeclaredAnnotation(Bool.class);
            System.out.println(declaredAnnotation.autor());
            System.out.println(declaredAnnotation.name());
            System.out.println(declaredAnnotation.character());
        }

动态代理

• 再不改变原有方法的基础上，增强方法的功能
• 通过Proxy.newProxyInstance（）方法获取动态代理对象，传入参数为，预备代理对象的类加载器，预备代理对象的接口，实现一个InvocationHandler匿名内部类
• obj.getClass().getInterfaces()方法可以获取指定对象实现的接口

 public static Object getProxy(Object obj) {
            return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                long l = System.currentTimeMillis();

                Arrays.stream(method.getAnnotations()).forEach(x-> System.out.println(x));
                Object invoke = method.invoke(obj, args);
                long l1 = System.currentTimeMillis();
                System.out.println(method.getName() + "方法运行时长是：" + (l1 - l) + "ms" + "\t结果是：" + invoke);
                return invoke;
            }
        });
    }

• 调用方法

Service service = new Serviceiml();
        Service proxy1 = (Service) getProxy(service);
        proxy1.updateUser();

xml解析

• 需要使用的dom4j.jar的jar包

//        创建saxreader对象
        SAXReader saxReader = new SAXReader();
        InputStream resourceAsStream = xml_Dom4j.class.getResourceAsStream("/resoursesss/test.xml");
        Document read = saxReader.read(resourceAsStream);
//        获取根节点
        Element rootElement = read.getRootElement();
//获取根元素下所有的指定标签元素
        List<Element> elements = rootElement.elements("student");
//        获取学生元素的列表
        ArrayList<Student> students = new ArrayList<>();
        for (Element e : elements) {
            Student student = new Student();
            student.setId(Integer.valueOf(e.attributeValue("id")));
            student.setVip(Boolean.valueOf(e.elementTextTrim("vip")));
            student.setAge(Integer.valueOf(e.elementText("age")));
            student.setAddress(e.elementText("adress"));
            student.setName(e.elementText("name"));
            students.add(student);
        }
        System.out.println(students);
//        System.o

• Xpath检索
  • xml_Xpath.class.getClassLoader().getResourceAsStream(“resoursesss/test.xml”)，该方法获取的是以src为根目录

//        使用dom4j将文档加载成document对象
        SAXReader saxReader = new SAXReader();
        try {
            Document read = saxReader.read(xml_Xpath.class.getClassLoader().getResourceAsStream("resoursesss/test.xml"));
//            全路径解析
//            List<Node> nodes = read.selectNodes("/students/student/name");
//            相对路径解析
            Element rootElement = read.getRootElement();
//            相对路径解析
            List<Node> nodes = read.selectNodes("//student[@id='3']/name");
//            查找属性
            List<Node> nodes1 = read.selectNodes("//@id");
            for (Node node :nodes1){
                Attribute attribute=(Attribute) node;
                System.out.println(attribute.getName() + "=====>" + attribute.getValue());
            }
//            System.out.println(nodes);
            for (Node node: nodes){
                Element element=(Element) node;
                System.out.println(element.getTextTrim());
//                System.out.println(element);
//                String s = element.getText();
//                System.out.println(s);
            }
            //            Element rootElement = read.getRootElement();
//            System.out.println(rootElement);
        } catch (DocumentException e) {
            e.printStackTrace();
        }