JAVA---反射

package java0;

import com.sun.org.apache.xpath.internal.SourceTree;
import org.junit.Test;

import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 *
 *
 * @create 2022-04-15 11:34
 */
public class ReflectionTest {
    //反射之前，对于person的操作
    @Test
    public void test1() {
        //1.创建person类的对象
        Person p1 = new Person("TOM", 11);
        //2.通过对象，调用其内部的属性、方法
        p1.age=10;
        System.out.println(p1.toString());
        p1.show();
        //在person类外部，不可以通过person类的对象调用其内部私有结构，
    }

    //反射之后，对于person的操作
    @Test
    public void test2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        Class clazz = Person.class;
        //1.通过反射，创建person类的对象
        Constructor cons = clazz.getConstructor(String.class, int.class);
        Object obj = cons.newInstance("TOM", 11);
        Person p=(Person)obj;
        System.out.println(p.toString());
        //2.通过反射，调用对象指定的属性、方法
        //调用属性
        Field age = clazz.getDeclaredField("age");
        age.set(p,10);
        System.out.println(p);

        //调用方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);
        System.out.println("**************");

        //通过反射，可以调用Person类的私有结构，比如：私有的构造器、方法、属性
        //调用私有的构造器
        Constructor cons1 = clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p1 = (Person) cons1.newInstance("Jerry");
        System.out.println(p1);

        //调用私有的属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1,"hahahaha");
        System.out.println(p1);

        //调用私有的方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        String nation = (String) showNation.invoke(p1, "中国");
        System.out.println(nation);
    }

    /*
        关于java.lang.Class类的理解
        1.类的加载过程：
        程序经过javac.exe命令以后，会生成一个或多个字节码文件（.class结尾）
        然后使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件
        加载到内存中。此过程称为类的加载。加载到内存中的类，就称为运行时类。
        此运行时类，就作为Class的一个实例。

        2.加载到内存中的运行时类，会缓存一定的时间。在此时间之内，可以通过不同的方式来获取此运行时类

     */

    //获取Class的实例的方式
    @Test
    public void test3() throws ClassNotFoundException {
        //方式一：调用运行时类的属性：.class
        Class clazz1 = Person.class;
        System.out.println(clazz1);

        //方式二：通过运行时类的对象，调用getClass()
        Person p1=new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);

        //方式三：调用class的静态方法，forName(String classPath)
        Class clazz3 = Class.forName("java0.Person");
        System.out.println(clazz3);


        System.out.println(clazz1==clazz2);
        System.out.println(clazz1==clazz3);

        //方式四：实用类的加载器：ClassLoader
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class clazz4 = classLoader.loadClass("java0.Person");
        System.out.println(clazz4);

        System.out.println(clazz1=clazz4);

    }



    //class实例可以是哪些结构的说明:
    @Test
    public void test4(){
        Class c1=Object.class;
        Class<Comparable> comparableClass = Comparable.class;
        Class<String[]> aClass = String[].class;
        Class<int[][]> aClass1 = int[][].class;
        Class<ElementType> elementTypeClass = ElementType.class;
        Class<Override> overrideClass = Override.class;
        Class<Integer> integerClass = int.class;
        Class<Void> voidClass = void.class;
        Class<Class> classClass = Class.class;


        int[] a=new int[10];
        int[] b=new int[100];

        Class<? extends int[]> aClass2 = a.getClass();
        Class<? extends int[]> aClass3 = b.getClass();
        //只要数组的元素类型与维度一样，就是同一个Class
        System.out.println(aClass2==aClass3);
    }




}

---

package java0;

import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * @create 2022-04-15 12:55
 */
public class ClassLoaderTest {
    @Test
    public void test1(){
        //对于自定义类，使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);
        //调用系统类加载器的getParent():获取扩展类加载器
        ClassLoader classLoader1 = classLoader.getParent();
        System.out.println(classLoader1);
        //调用扩展类加载器的getParent():无法获取引导类加载器
        //引导类加载器主要负责加载java的核心类库，无法加载自定义类的。
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println(classLoader2);

        ClassLoader classLoader3 = String.class.getClassLoader();
        System.out.println(classLoader3);
    }


    @Test
    public void test2() throws IOException {
        Properties pros=new Properties();

        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
        pros.load(is);

        String user=pros.getProperty("user");
        String password=pros.getProperty("password");
        System.out.println(user+"---"+password);


    }

}

---

package java0;

import org.junit.Test;

import java.util.Random;

/**
 *通过反射创建对应的运行时类的对象
 * @create 2022-04-15 18:23
 */
public class NewInstanceTest {
    @Test
    public void test1() throws IllegalAccessException, InstantiationException {
        Class<Person> clazz = Person.class;
        /*
            newInstance():调用此方法，创建对应的运行时类的对象。
                    内部调用了运行时类的空参的构造器
            要想此方法正常的创建运行时类的对象，要求：
            1.运行时类必须提供空参的构造器
            2.空参的构造器的访问权限得够。通常，设置为public。

            在javabean中要求提供一个public的空参构造器。原因：
            1.便于通过反射，创建运行时类的对象。
            2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器。


         */
        Person person = clazz.newInstance();
        System.out.println(person);
    }

    //体会反射的动态性
    @Test
    public void test2() throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        for(int i=0;i<100;i++){
            int num = new Random().nextInt(3);
            String classPath="";
            switch (num){
                case 0:
                    classPath="java.util.Date";
                    break;
                case 1:
                    classPath="java.lang.Object";
                    break;
                case 2:
                    classPath="java0.Person";
                    break;
            }
            Object instance = getInstance(classPath);
            System.out.println(instance);


        }
    }

    public Object getInstance(String classPath) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Class<?> aClass = Class.forName(classPath);
        return aClass.newInstance();
    }

}

---

package java2;

import java1.Person;
import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 *  调查当前运行时类的属性结构
 * @create 2022-04-15 21:54
 */
public class FieldTest {
    @Test
    public void test1(){
        Class<Person> clazz = Person.class;
        //获取属性结构
        //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for(Field f:fields){
            System.out.println(f);
        }
        System.out.println();
        //getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f:declaredFields){
            System.out.println(f);
        }


    }


    //权限修饰符     数据类型  变量名
    @Test
    public void test2(){
        Class<Person> clazz = Person.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f:declaredFields){
            //1.权限修饰符
            int modifiers = f.getModifiers();
            System.out.print(Modifier.toString(modifiers)+"\t");

            //2.数据类型
            Class<?> type = f.getType();
            System.out.print(type.getName()+"\t");

            //3.变量名
            String name = f.getName();
            System.out.println(name);
            
            

            System.out.println();
        }
    }
}

---

package java2;

import java1.Person;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 *  获取运行时类的方法结构
 * @create 2022-04-15 22:23
 */
public class MethodTest {
    @Test
    public void test1(){
        Class<Person> clazz = Person.class;
        //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
        Method[] methods = clazz.getMethods();
        for(Method m:methods){
            System.out.println(m);
        }

        System.out.println();

        //getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m:declaredMethods){
            System.out.println(m);
        }




    }

    @Test
    public void test2(){
        Class<Person> clazz = Person.class;
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m:declaredMethods){
            //1.获取方法声明的注释
            Annotation[] annotations = m.getAnnotations();
            for(Annotation a: annotations){
                System.out.println(a);
            }

            //权限修饰符
            System.out.print(Modifier.toString(m.getModifiers())+"\t");

            //返回值类型
            System.out.print(m.getReturnType().getName()+"\t");

            //方法名
            System.out.print(m.getName());
            System.out.print("(");

            //形参列表
            Class<?>[] parameterTypes = m.getParameterTypes();
            if(parameterTypes.length>0){
                for(int i=0;i<parameterTypes.length;i++){

                    if(i == parameterTypes.length - 1){
                        System.out.print(parameterTypes[i].getName() + " args_" + i);
                        break;
                    }
                    System.out.print(parameterTypes[i].getName() + " args_" + i + ",");

                }

            }

            System.out.print(")");


            //抛出的异常

            Class<?>[] exceptionTypes = m.getExceptionTypes();
            if(exceptionTypes.length>0){
                System.out.print("throws");
                for(int i=0;i<exceptionTypes.length;i++){
                    if(i==exceptionTypes.length-1){
                        System.out.println(exceptionTypes[i].getName());
                        break;
                    }
                    System.out.println(exceptionTypes[i].getName()+",");
                }
            }
            System.out.println();
        }
    }
}

---

package java2;

import java1.Person;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 *
 *
 * @create 2022-04-16 11:40
 */
public class OtherTest {

    /*
        获取构造器结构

     */

    @Test
    public void test1() throws NoSuchMethodException {
        Class<Person> clazz = Person.class;
        //getConstructors()：获取当前运行时类中声明为public的构造器
        Constructor<?>[] constructors = clazz.getConstructors();
        for(Constructor c:constructors){
            System.out.println(c);
        }
        System.out.println();

        //getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
        Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor c:declaredConstructors){
            System.out.println(c);
        }

    }

    /*
        获取运行时类的父类

     */

    @Test
    public void test2(){
        Class<Person> clazz = Person.class;
        Class<? super Person> superclass = clazz.getSuperclass();
        System.out.println(superclass);

    }

    /*
        获取运行时类的带泛型的父类

     */

    @Test
    public void test3(){
        Class<Person> clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);
    }

    /*
        获取运行时类的带泛型的父类的泛型
     */
    @Test
    public void test4(){
        Class<Person> clazz = Person.class;

        Type genericSuperclass = clazz.getGenericSuperclass();
        ParameterizedType paramType= (ParameterizedType) genericSuperclass;

        Type[] actualTypeArguments = paramType.getActualTypeArguments();

        System.out.println(actualTypeArguments[0].getTypeName());
    }

    /*
        获取运行时类实现的接口
     */
    @Test
    public void test5(){
        Class<Person> clazz = Person.class;

        Class<?>[] interfaces = clazz.getInterfaces();
        for(Class c:interfaces){
            System.out.println(c);
        }

        System.out.println();

        //获取运行时类的父类实现的接口
        Class<?>[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for(Class c:interfaces1){
            System.out.println(c);
        }

    }

    /*
        获取运行时类所在的包
     */
    @Test
    public void test6(){
        Class<Person> clazz = Person.class;

        Package aPackage = clazz.getPackage();
        System.out.println(aPackage);
    }

    /*
        获取运行时类声明的注释
     */
    @Test
    public void test7(){
        Class<Person> personClass = Person.class;
        Annotation[] annotations = personClass.getAnnotations();
        for(Annotation annos:annotations){
            System.out.println(annos);
        }
        
    }
}

---

package java2;

import java1.Person;
import org.junit.Test;

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

/**
 * @create 2022-04-16 18:36
 */
public class ReflectionTest {

    @Test
    public void testField() throws IllegalAccessException, InstantiationException, NoSuchFieldException {
        Class<Person> clazz = Person.class;
        //创建运行时类的对象
        Person p = clazz.newInstance();

        //获取指定的属性
        Field id = clazz.getField("id");

        /*
            设置当前属性的值
                set():参数1：指明设置哪个对象的属性  参数2：将此属性值设置为多少
         */
        id.set(p,1001);
        //获取当前属性的值
        //get()
        int pId = (int) id.get(p);
        System.out.println(pId);
    }

    @Test
    public void testField1() throws IllegalAccessException, InstantiationException, NoSuchFieldException {
        Class<Person> clazz = Person.class;
        Person p = clazz.newInstance();

        //getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
        Field name = clazz.getDeclaredField("name");
        //保证当前属性是可访问的
        name.setAccessible(true);
        //获取、设置指定对象的此属性值
        name.set(p,"Tom");
        System.out.println(name.get(p));

    }

    //操作指定运行时类中指定的方法

    @Test
    public void testMethod() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class<Person> clazz = Person.class;
        Person p = clazz.newInstance();
        //获取指定的某个方法
        //getDeclaredMethod():参数1：指明获取的方法的名称  参数2：指明获取的方法的形参列表
        Method show = clazz.getDeclaredMethod("show", String.class);
        //保证当前方法是可访问的
        show.setAccessible(true);

        //调用方法的invoke():参数1：方法的调用者  参数2：给方法形参赋值的实参
            //invoke()的返回值即为对应类中调用的方法的返回值
        Object returnValue = show.invoke(p, "CHN");
        System.out.println(returnValue);

        System.out.println("如何调用静态方法");

        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        Object returnValue1 = showDesc.invoke(Person.class);
        System.out.println(returnValue1);


    }

    /*
        如何调用运行时类中的指定的构造器
     */
    @Test
    public void testConstructor() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<Person> clazz = Person.class;
        Constructor<Person> declaredConstructor = clazz.getDeclaredConstructor(String.class);
        //保证此构造器是可访问的
        declaredConstructor.setAccessible(true);

        //调用此构造器创建运行时类的对象
        Person tom = declaredConstructor.newInstance("Tom");
        System.out.println(tom);


    }


}

---

package java0;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 *动态代理举例
 *
 * @create 2022-04-17 12:50
 */

interface human{
    String getBelief();

    void eat(String food);
}
//被代理类
class superMan implements human{

    @Override
    public String getBelief() {
        return "I believe I can fly!";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃"+food);
    }
}

/*
    要实现动态代理，需要解决的问题？
    1.如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象
    2.当通过代理类的对象调用方法a时，如何动态的调用被代理类中的同名方法a。
 */

class ProxyFactory{
    //调用此方法，返回一个代理类的对象。解决问题一
    public static Object getProxyInstance(Object obj){
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
        myInvocationHandler.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),myInvocationHandler);

    }
}

class MyInvocationHandler implements InvocationHandler{

    private Object obj;//需要使用被代理类的对象进行赋值
    public void bind(Object obj){
        this.obj=obj;
    }
    //当通过代理类的对象调用方法a时，就会自动的调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能声明在invoke()中。

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj：被代理类的对象
        Object returnValue = method.invoke(obj, args);

        //上述方法的返回值就作为当前类中的invoke()的返回值
        return returnValue;
    }
}

public class ProxyTest {

    public static void main(String[] args) {
        superMan superMan = new superMan();
        human proxyInstance = (human) ProxyFactory.getProxyInstance(superMan);
        String belief = proxyInstance.getBelief();
        System.out.println(belief);

        proxyInstance.eat("麻食");

        System.out.println("********************");

        NikeClothFactory nikeClothFactory = new NikeClothFactory();
        ClothFactory proxyInstance1 = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
        proxyInstance1.produceCloth();

    }
}

---