java19(反射)

反射

        终极手段。规则破坏者

        1.calss

                 定义类关键字

        2. Construtor

                 构造函数的描述符

                 Class clazz = Person.class;

                 Constructor ctor = clazz.getConstructor(...);

                 ctor.setAccessible(true);

                 ctor.newInstance(...);

        3. field

                 字段（成员变量）描述符

                Field f = clazz.getDeclaredField("name");

        4. method

                方法描述符

                静态方法也可以通过反射访问

　　　　 Method m = clazz.getDeclearMethod("run");

　　　　 m.invoke(null);

        5. Modifier

                修饰符，判断是否含有指定的修饰符

                Modifier.isStatic(m.getModifier());

// Person.java

package com.hzg.reflect;

public class Person {
    private String name;
    private int age;
    public Person() {
        System.out.println("new Person()");
    }
    public Person(String name) {
        this.name = name;
        System.out.println("new Person(String name)");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        System.out.println("setName("+name+")");
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void sayHello() {
        System.out.println("hello");
    }
}

TestPerson.java

package com.hzg.reflect.test;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.URL;

import org.junit.Test;

import com.hzg.reflect.Person;

public class TestPerson {
    
    /**
     * 创建对象
     */
    @Test
    public void newObject() {
/*        Person p = new Person();
        p.setName("tom");
        p.setAge(20);
        p.sayHello();*/
    }
    
    /**
     * 通过反射创建对象
     */
    @Test
    public void newObjectInReflect() throws Exception{
        Class<Person> clazz = Person.class;
        // getName()是类的完整类名
        //String name = clazz.getName();
        String sname = clazz.getSimpleName();
        System.out.println(sname);
        Person person = clazz.newInstance();
        System.out.println(person);
    }
    
    @Test
    public void testConstructor() throws Exception{
        Class<Person> clazz = Person.class;
        // 得到类的构造函数
        Constructor<Person> ctor = clazz.getDeclaredConstructor();
        ctor.setAccessible(true);
        Object obj = ctor.newInstance();
        System.out.println(obj);
    }
    
    @Test
    public void testConstructor2() throws Exception{
        Class<Person> clazz = Person.class;
        // 得到类的构造函数
        Constructor<Person> ctor = clazz.getDeclaredConstructor(String.class);
        Object obj = ctor.newInstance("jerry");
        System.out.println(obj);
    }
    
    @Test
    public void testMethod() throws Exception{
        Class<Person> clazz = Person.class;
        
        Object obj = clazz.newInstance();
        Method m = clazz.getMethod("setName", String.class);
        // p.setName("tomas");
        m.invoke(obj, "tomas");
        System.out.println("over");
        System.out.println(obj);
    }
    
    @Test
    public void getMethods() throws Exception {
        Class<Person> clazz = Person.class;
        //Method[] methods = clazz.getDeclaredMethods();//类中声明的方法
        Method[] methods = clazz.getMethods();//获得类的公有方法
        for (Method m: methods) {
            String name = m.getName();
            System.out.println(name);
            //System.out.println(m);
        }
    }
    
    /**
     * 字段描述符
     */
    @Test
    public void testField() throws Exception {
        Class<Person> clazz = Person.class;
        Person obj = clazz.newInstance();
        
        // 获得字段描述符
        Field f = clazz.getDeclaredField("name");
        
        // 设置可访问性
        f.setAccessible(true);
        
        // 设置字段值 === this.name = "tom";
        f.set(obj, "tom");
        
        // 取出字段值
        Object object = f.get(obj);
        
        System.out.println(object);
        
        System.out.println(obj.getName());
        
    }
    
    /**
     * Modifier:修饰符
     * @throws IllegalAccessException 
     * @throws InstantiationException 
     */
    @Test
    public void testModifer() throws Exception {
        Class<Person> clazz = Person.class;
        Method m = clazz.getDeclaredMethod("setName", String.class);
        // 得到方法的修饰符总和
        int modifer = m.getModifiers();
        System.out.println(Modifier.isPublic(modifer));
    }
    
    /**
     * 得到指定包下的所有类
     * @throws Exception 
     */
    @Test
    public void getclasses() throws Exception {
        Class clazz = Person.class;
        ClassLoader loader = clazz.getClassLoader();
        // 统一资源定位符
        URL url = loader.getResource("com/hzg/reflect");
        
        // 文件夹
        File file = new File(url.toURI());
        File[] files = file.listFiles();
        for (File f : files) {
            String fname = f.getName();
            if (!fname.endsWith(".class")) {
                continue;
            }
            String className = fname.substring(0, fname.lastIndexOf("."));
            className = "com.hzg.reflect." + className;
            clazz = Class.forName(className);
            System.out.println(clazz);
        }
        
    }
    
    /**
     * 属性复制
     * @throws IllegalAccessException 
     * @throws IllegalArgumentException 
     */
    @Test
    public void testPropertyCopy() throws Exception {
        // 源对象
        Person src = new Person();
        src.setName("tom");
        src.setAge(20);
        
        // 目标对象
        Person target = new Person();
        
        Class clazz = Person.class;
        Field[] fs = clazz.getDeclaredFields();
        for (Field f : fs) {
            String fname = f.getName();
            // 判断是否可以访问，设置可访问性
            if (!f.isAccessible()) {
                f.setAccessible(true);
            }
            // 获得该字段在src对象上对应的值
            Object fvalue = f.get(src);
            f.set(target, fvalue);
        }
        System.out.println("over");
        
    }
}

 内省

        专业操作javabean

对象复制

// Animal.java

package com.hzg.reflect;

public abstract class Animal {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
}

// Dog.java

package com.hzg.reflect;

public class Dog extends Animal{

    private String blood;

    public String getBlood() {
        return blood;
    }

    public void setBlood(String blood) {
        this.blood = blood;
    }
    
}

// TestPerson2.java

package com.hzg.reflect.test;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.URL;

import org.junit.Test;

import com.hzg.reflect.Dog;
import com.hzg.reflect.Person;

public class TestPerson2 {

    /**
     * 属性复制
     * 
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     */
    @Test
    public void testPropertyCopy2() throws Exception {
        // 源对象
        Dog src = new Dog();
        src.setName("tom");
        src.setBlood("A");

        // 目标对象
        Dog target = new Dog();

        Class clazz = Dog.class;
        Field[] fs = clazz.getDeclaredFields();
        for (Field f : fs) {
            String fname = f.getName();
            Class<?> type = f.getType();
            System.out.println(type);
            // 判断是否可以访问，设置可访问性
            if (!f.isAccessible()) {
                f.setAccessible(true);
            }
            // 获得该字段在src对象上对应的值
            Object fvalue = f.get(src);
            f.set(target, fvalue);
        }
        System.out.println("over");

    }

    /**
     * 得到整个类家族树定义的所有字段
     */
    @Test
    public void getAllFields() {
        Class clazz = Dog.class;
        printFields(clazz);
    }

    /**
     * 打印字段
     */
    private void printFields(Class clazz) {
        /*if (clazz == Object.class) {
            return;
        }*/
        if (clazz == null) {
            return;
        }
        Field[] fs = clazz.getDeclaredFields();
        if (fs != null && fs.length > 0) {
            for (Field f : fs) {
                Class ftype = f.getType();
                String fname = f.getName();
                System.out.println(ftype + " " + fname);
            }
        }

        clazz = clazz.getSuperclass();
        printFields(clazz);
        
        
    }
}

// TestIntrospector.java

package com.hzg.reflect.test;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;

import org.junit.Test;

import com.hzg.reflect.Dog;

/**
 * 内省，专业操作javabean
 * @author zhengguohuang
 *
 */
public class TestIntrospector {
    /**
     * 
     * @throws Exception
     */
    @Test
    public void testIntrospective() throws Exception{
        // 得到bean信息
        BeanInfo bi = Introspector.getBeanInfo(Dog.class);
        PropertyDescriptor[] pds = bi.getPropertyDescriptors();
        for (PropertyDescriptor pd : pds) {
            // getXxx()
            Method getter = pd.getReadMethod();
            System.out.println(getter);
            // setXxx()
            Method setter = pd.getWriteMethod();
            System.out.println(setter);
            //getter.invoke(, args)
            //System.out.println(pd.getName());
        }
    }
}

使用内省实现对象的属性复制

package com.hzg.reflect.test;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.URISyntaxException;
import java.net.URL;

import org.junit.Test;

/**
 * 测试类加载器
 * 
 * @author zhengguohuang
 *
 */
public class TestClassLoader {

    /**
     * 获得资源url
     * @throws Exception 
     * 
     */
    @Test
    public void testClassLoader1() throws Exception {
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        // 搜索类路径获取资源
        URL url = loader.getResource("com/hzg/reflect/background.jpg");
        File file = new File(url.toURI());
        System.out.println(file.length());
        System.out.println(loader);
    }
    
    /**
     * 获得资源流
     * @throws Exception 
     * 
     */
    @Test
    public void testResourceStream() throws Exception {
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        // 搜索类路径获取资源
        InputStream is = loader.getResourceAsStream("com/hzg/reflect/background.jpg");
        
        byte[] bytes = new byte[is.available()];
        is.read();
        is.close();
        new FileOutputStream("d:/xxx.jpg").write(bytes);
        System.out.println(loader);
    }

    /**
     * 获得系统资源
     * @throws Exception 
     * 
     */
    @Test
    public void testSystemResource() throws Exception {
        InputStream is = ClassLoader.getSystemResourceAsStream("java/lang/String.class");
        System.out.println(is.available());
    }
    
    /**
     * @throws Exception
     * 
     */
    @Test
    public void testLuncher() throws Exception {
        // have not access
        // sun.misc.Launcher l = new sun.misc.Launcher();
        Class clazz = Class.forName("sun.misc.Launcher");
        Object object = clazz.newInstance();
        System.out.println(object);// sun.misc.Launcher@4459eb14
        
    }
}

动态代理

        不改变源码，增加新的功能

// Person.java

package com.hzg.reflect;

public class Person {
    private String name;
    private int age;
    public Person() {
        System.out.println("new Person()");
    }
    public Person(String name) {
        this.name = name;
        System.out.println("new Person(String name)");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        System.out.println("setName("+name+")");
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void sayHello() {
        System.out.println("hello");
    }
}

// PersonDao.java

package com.hzg.reflect.proxy;

import com.hzg.reflect.Person;

/**
 * Dao:data access object
 * @author zhengguohuang
 *
 */
public interface PersonDao {

    public void insert(Person p);
    
    public void update(Person p);
}

// PersonDao2.java

package com.hzg.reflect.proxy;

import com.hzg.reflect.Person;

/**
 * Dao:data access object
 * @author zhengguohuang
 *
 */
public interface PersonDao2 {

    public void insert2(Person p);
    
    public void update2(Person p);
}

// PersonDaoImpl.java

package com.hzg.reflect.proxy;

import com.hzg.reflect.Person;

/**
 * Dao实现类
 * @author zhengguohuang
 *
 */
public class PersonDaoImpl implements PersonDao, PersonDao2{

    @Override
    public void insert(Person p) {
        System.out.println("insert");
    }

    @Override
    public void update(Person p) {
        System.out.println("update");
    }

    @Override
    public void insert2(Person p) {
        System.out.println("insert2");
    }

    @Override
    public void update2(Person p) {
        System.out.println("update2");
    }

}

// MyInvovationHandler.java

package com.hzg.reflect.proxy;

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

public class MyInvocationHandler implements InvocationHandler {

    private Object target;
    
    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("hello");// 调用方法之前
        Object ret = method.invoke(target, args);
        System.out.println("over");// To do ... after invoke
        return ret;
    }

}

// App.java

package com.hzg.reflect.proxy;

import java.lang.reflect.Proxy;

import com.hzg.reflect.Person;

public class App {

    public static void main(String[] args) {
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        Class[] interfaces = {PersonDao.class, PersonDao2.class};
        PersonDao dao = new PersonDaoImpl();
        MyInvocationHandler h = new MyInvocationHandler(dao);
        
        Object proxy = (PersonDao)Proxy.newProxyInstance(loader, interfaces, h);
        ((PersonDao)proxy).insert(new Person());
        ((PersonDao)proxy).update(null);
        ((PersonDao2)proxy).insert2(null);
        ((PersonDao2)proxy).update2(null);
    }

}