//Class<T> clazz = Class.forName("類的全限定名");這是通過Class類中的靜態(tài)方法forName直接獲取一個(gè)Class的對(duì)象
Class<?> clazz1 = null;
try {
    clazz1 = Class.forName("reflect.Person");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}
System.out.println(clazz1); //class reflect.Person

//Class<T> clazz = xxx.getClass(); //通過類的實(shí)例獲取類的Class對(duì)象
Class<?> clazz3 = new Person().getClass();
System.out.println(clazz3); //class reflect.Person

Class<?> stringClass = "string".getClass();
System.out.println(stringClass); //class java.lang.String

/**
 * [代表數(shù)組，
 * B代表byte；
 * I代表int；
 * Z代表boolean；
 * L代表引用類型
 * 組合起來就是指定類型的一維數(shù)組，如果是[[就是二維數(shù)組
 */
Class<?> arrClass = new byte[20].getClass();
System.out.println(arrClass); //class [B

Class<?> arrClass1 = new int[20].getClass();
System.out.println(arrClass1); //class [I

Class<?> arrClass2 = new boolean[20].getClass();
System.out.println(arrClass2); //class [Z

Class<?> arrClass3 = new Person[20].getClass();
System.out.println(arrClass3); //class [Lreflect.Person;

Class<?> arrClass4 = new String[20].getClass();
System.out.println(arrClass4); //class [Ljava.lang.String;

//Class<T> clazz = XXXClass.class; 當(dāng)類已經(jīng)被加載為.class文件時(shí)候，
Class<Person> clazz2 = Person.class;
System.out.println(clazz2);
System.out.println(int [][].class);//class [[I
System.out.println(Integer.class);//class java.lang.Integer

/**
     * The {@code Class} instance representing the primitive type
     * {@code int}.
     *
     * @since   JDK1.1
     */
    @SuppressWarnings("unchecked")
    public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

Class c0 = Byte.TYPE; //byte
Class c1 = Integer.TYPE; //int
Class c2 = Character.TYPE; //char
Class c3 = Boolean.TYPE; //boolean
Class c4 = Short.TYPE; //short
Class c5 = Long.TYPE; //long
Class c6 = Float.TYPE; //float
Class c7 = Double.TYPE; //double
Class c8 = Void.TYPE; //void

Class c1 = Integer.class;
Class par = c1.getSuperclass();
System.out.println(par); //class java.lang.Number

package reflect;

interface Test {
    String test = "interface";
}

public class Person  implements Test{

    private String id;
    private String name;

    public void sing(String name) {
        System.out.println(getName() + "會(huì)唱" + name +"歌");
    }

    private void dance(String name) {
        System.out.println(getName() + "會(huì)跳" + name + "舞");
    }

    public void playBalls() {
        System.out.println(getName() + "會(huì)打籃球");
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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


    public Person() {
    }

    public Person(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public Person(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}
//Person

public void test4() throws Exception{
    Class clazz =Class.forName("reflect.Person");
    Person person = (Person)clazz.newInstance();
    System.out.println(person);
}

@Test
public void test5() throws Exception {
    Class clazz = Class.forName("reflect.Person");
    //獲取帶參構(gòu)造器
    Constructor constructor = clazz.getConstructor(String.class, String .class);
    //通過構(gòu)造器來實(shí)例化對(duì)象
    Person person = (Person) constructor.newInstance("p1", "person");
    System.out.println(person);
}

@Test
public void test6() throws Exception {
    Class clazz1 = Class.forName("reflect.Person");
    Constructor[] constructors = clazz1.getConstructors();
    for (Constructor constructor : constructors) {
        Class[] parameters = constructor.getParameterTypes();
        System.out.println("構(gòu)造函數(shù)名：" + constructor + "\n" + "參數(shù)");
        for (Class c: parameters) {
            System.out.print(c.getName() + " ");
        }
        System.out.println();
    }
}

@Test
public void test7() throws Exception {
    Class clazz1 = Class.forName("reflect.Person");
    //獲得實(shí)例對(duì)象
    Person person = (Person) clazz1.newInstance();
    /**
     * 獲得類的屬性信息
     * 使用getField(name),通過指定的屬性name獲得
     * 如果屬性不是public的，使用getDeclaredField(name)獲得
     */
    Field field = clazz1.getDeclaredField("id");
    //如果是private的，需要設(shè)置權(quán)限為可訪問
    field.setAccessible(true);
    //設(shè)置成員變量的屬性值
    field.set(person, "person1");
    //獲取成員變量的屬性值，使用get方法，其中第一個(gè)參數(shù)表示獲得字段的所屬對(duì)象，第二個(gè)參數(shù)表示設(shè)置的值
    System.out.println(field.get(person)); //這里的field就是id屬性，打印person對(duì)象的id屬性的值
}

@Test
public void test8() throws Exception{
    Class clazz1 = Class.forName("reflect.Person");
    //獲得實(shí)例對(duì)象
    Person person = (Person) clazz1.newInstance();
    person.setId("person1");
    person.setName("person1_name");
    Field[] fields = clazz1.getDeclaredFields();
    for (Field f : fields) {
        //打開private成員變量的可訪問權(quán)限
        f.setAccessible(true);
        System.out.println(f+ ":" + f.get(person));
    }
}

@Test
public void test9() throws Exception{
    Class clazz1 = Class.forName("reflect.Person");
    //獲得實(shí)例對(duì)象
    Person person = (Person) clazz1.newInstance();
    person.setName("Person");
    //①不帶參數(shù)的public方法
    Method playBalls = clazz1.getMethod("playBalls");
    //調(diào)用獲得的方法，需要指定是哪一個(gè)對(duì)象的
    playBalls.invoke(person);

    //②帶參的public方法：第一個(gè)參數(shù)是方法名，后面的可變參數(shù)列表是參數(shù)類型的Class類型
    Method sing = clazz1.getMethod("sing",String.class);
    //調(diào)用獲得的方法，調(diào)用時(shí)候傳遞參數(shù)
    sing.invoke(person,"HaHaHa...");

    //③帶參的private方法：使用getDeclaredMethod方法
    Method dance = clazz1.getDeclaredMethod("dance", String.class);
    //調(diào)用獲得的方法，需要先設(shè)置權(quán)限為可訪問
    dance.setAccessible(true);
    dance.invoke(person,"HaHaHa...");
}

@Test
public void test10() throws Exception{
    Class clazz1 = Class.forName("reflect.Person");
    //獲得實(shí)例對(duì)象
    Person person = (Person) clazz1.newInstance();
    person.setName("Person");
    Method[] methods = clazz1.getDeclaredMethods();
    for (Method method: methods) {
        System.out.print("方法名" + method.getName() + "的參數(shù)是：");
        //獲得方法參數(shù)
        Class[] params = method.getParameterTypes();
        for (Class c : params) {
            System.out.print(c.getName() + " ");
        }
        System.out.println();
    }
}

@Test
public void test11() throws Exception{
    Class clazz1 = Class.forName("reflect.Person");
    Class[] interfaces = clazz1.getInterfaces();
    for (Class inter : interfaces) {
        System.out.println(inter);
    }
}

@Test
public void test12() throws Exception {
    ClassLoader loader = this.getClass().getClassLoader();
    System.out.println(loader);//sun.misc.Launcher$AppClassLoader@18b4aac2 ,應(yīng)用程序類加載器
    System.out.println(loader.getParent());//sun.misc.Launcher$ExtClassLoader@31befd9f ,擴(kuò)展類加載器
    System.out.println(loader.getParent().getParent());//null ,不能獲得啟動(dòng)類加載器

    Class clazz = Person.class;//自定義的類
    ClassLoader loader2 = clazz.getClassLoader();
    System.out.println(loader2);//sun.misc.Launcher$AppClassLoader@18b4aac2

    //下面是獲得InputStream的例子
    ClassLoader inputStreamLoader = this.getClass().getClassLoader();
    InputStream inputStream = inputStreamLoader.getResourceAsStream("person.properties");
    Properties properties = new Properties();
    properties.load(inputStream);
    System.out.println("id:" + properties.get("id"));
    System.out.println("name:" + properties.get("name"));
}

package proxy;

/**
 * 靜態(tài)代理
 */
//產(chǎn)品接口
interface ProductFactory {
    void action();
}

//一個(gè)具體產(chǎn)品的實(shí)現(xiàn)類,作為一個(gè)被代理類
class TeaProduct implements ProductFactory{
    @Override
    public void action() {
        System.out.println("我是生產(chǎn)茶葉的......");
    }
}

//TeaProduct的代理類
class ProxyTeaProduct implements ProductFactory {
    //我們需要ProductFactory的一個(gè)實(shí)現(xiàn)類，去代理這個(gè)實(shí)現(xiàn)類中的方法（多態(tài)）
    ProductFactory productFactory;

    //通過構(gòu)造器傳入實(shí)際被代理類的對(duì)象，這時(shí)候代理類調(diào)用action的時(shí)候就可以在其中執(zhí)行被代理代理類的方法了
    public ProxyTeaProduct(ProductFactory productFactory) {
        this.productFactory = productFactory;
    }

    @Override
    public void action() {
        System.out.println("我是代理類，我開始代理執(zhí)行方法了......");
        productFactory.action();
    }
}
public class TestProduct {

    public static void main(String[] args) {
        //創(chuàng)建代理類的對(duì)象
        ProxyTeaProduct proxyTeaProduct = new ProxyTeaProduct(new TeaProduct());
        //執(zhí)行代理類代理的方法
        proxyTeaProduct.action();
    }
}

package proxy;

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

/**
 * JDK中的動(dòng)態(tài)代理
 */
//第一個(gè)接口
interface TargetOne {
    void action();
}
//第一個(gè)接口的被代理類
class TargetOneImpl implements TargetOne{
    @Override
    public void action() {
        System.out.println("我會(huì)實(shí)現(xiàn)父接口的方法...action");
    }
}


//動(dòng)態(tài)代理類
class DynamicProxyHandler implements InvocationHandler {
    //接口的一個(gè)引用，多態(tài)的特性會(huì)使得在程序運(yùn)行的時(shí)候，它實(shí)際指向的是實(shí)現(xiàn)它的子類對(duì)象
    private TargetOne targetOne;
    //我們使用Proxy類的靜態(tài)方法newProxyInstance方法，將代理對(duì)象偽裝成那個(gè)被代理的對(duì)象
    /**
     * ①這個(gè)方法會(huì)將targetOne指向?qū)嶋H實(shí)現(xiàn)接口的子類對(duì)象
     * ②根據(jù)被代理類的信息返回一個(gè)代理類對(duì)象
     */
    public Object setObj(TargetOne targetOne) {
        this.targetOne = targetOne;
        //    public static Object newProxyInstance(ClassLoader loader, //被代理類的類加載器
        //                                          Class<?>[] interfaces, //被代理類實(shí)現(xiàn)的接口
        //                                          InvocationHandler h) //實(shí)現(xiàn)InvocationHandler的代理類對(duì)象
        return Proxy.newProxyInstance(targetOne.getClass().getClassLoader(),targetOne.getClass().getInterfaces(),this);
    }
    //當(dāng)通過代理類的對(duì)象發(fā)起對(duì)接口被重寫的方法的調(diào)用的時(shí)候，都會(huì)轉(zhuǎn)換為對(duì)invoke方法的調(diào)用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("這是我代理之前要準(zhǔn)備的事情......");
        /**
         *      這里回想一下在靜態(tài)代理的時(shí)候，我們顯示指定代理類需要執(zhí)行的是被代理類的哪些方法；
         *      而在這里的動(dòng)態(tài)代理實(shí)現(xiàn)中，我們并不知道代理類會(huì)實(shí)現(xiàn)什么方法，他是根據(jù)運(yùn)行時(shí)通過反射來
         *  知道自己要去指定被代理類的什么方法的
         */
        Object returnVal = method.invoke(this.targetOne,args);//這里的返回值，就相當(dāng)于真正調(diào)用的被代理類方法的返回值
        System.out.println("這是我代理之后要處理的事情......");
        return returnVal;
    }
}
public class TestProxy {
    public static void main(String[] args) {
        //創(chuàng)建被代理類的對(duì)象
        TargetOneImpl targetOneImpl = new TargetOneImpl();
        //創(chuàng)建實(shí)現(xiàn)了InvocationHandler的代理類對(duì)象，然后調(diào)用其中的setObj方法完成兩項(xiàng)操作
        //①將被代理類對(duì)象傳入，運(yùn)行時(shí)候調(diào)用的是被代理類重寫的方法
        //②返回一個(gè)類對(duì)象，通過代理類對(duì)象執(zhí)行接口中的方法
        DynamicProxyHandler dynamicProxyHandler = new DynamicProxyHandler();
        TargetOne targetOne = (TargetOne) dynamicProxyHandler.setObj(targetOneImpl);
        targetOne.action(); //調(diào)用該方法運(yùn)行時(shí)都會(huì)轉(zhuǎn)為對(duì)DynamicProxyHandler中的invoke方法的調(diào)用
    }
}

package aop;

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

//基于jdk的針對(duì)接口實(shí)現(xiàn)動(dòng)態(tài)代理，要求的接口
interface Target {
    void login();

    void logout();
}

//被代理類
class TargetImpl implements Target {
    @Override
    public void login() {
        System.out.println("log......");
    }

    @Override
    public void logout() {
        System.out.println("logout......");
    }
}

class Util {
    public void printLog() {
        System.out.println("我是記錄打印日志功能的方法......");
    }

    public void getProperties() {
        System.out.println("我是獲取配置文件信息功能的方法......");
    }
}

//實(shí)現(xiàn)了InvocationHandler的統(tǒng)一代理類
class DynamicProxyHandler implements InvocationHandler {
    private Object object;

    /**
     * 參數(shù)為obj，是應(yīng)對(duì)對(duì)不同的被代理類，都能綁定與該代理類的代理關(guān)系
     * 這個(gè)方法會(huì)將targetOne指向?qū)嶋H實(shí)現(xiàn)接口的子類對(duì)象,即當(dāng)前代理類實(shí)際要去代理的那個(gè)類
     */
    public void setObj(Object obj) {
        this.object = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Util util = new Util();
        util.getProperties();
        Object object = method.invoke(this.object, args); //這個(gè)方法是個(gè)動(dòng)態(tài)的方法，可以是login,可以是logout，具體在測(cè)試調(diào)用中調(diào)用不同方法
        util.printLog();
        return object;
    }
}

//該類的主要作用就是動(dòng)態(tài)的創(chuàng)建一個(gè)代理類的對(duì)象，同時(shí)需要執(zhí)行被代理類
class MyDynamicProxyUtil {
    //參數(shù)obj表示動(dòng)態(tài)的傳遞進(jìn)來被代理類的對(duì)象
    public static Object getProxyInstance(Object object) {
        //獲取代理類對(duì)象
        DynamicProxyHandler dynamicProxyHandler = new DynamicProxyHandler();
        dynamicProxyHandler.setObj(object);
        //設(shè)置好代理類與被代理類之間的關(guān)系后，返回一個(gè)代理類的對(duì)象
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), dynamicProxyHandler);
    }
}

public class TestAop {
    public static void main(String[] args) {
        //獲得被代理類
        Target target = new TargetImpl();
        //通過代理類工具類，設(shè)置實(shí)際與代理類綁定的被代理類，并返回一個(gè)代理類對(duì)象執(zhí)行實(shí)際的方法
        Target execute = (Target) MyDynamicProxyUtil.getProxyInstance(target);
        execute.login();
        execute.logout();
    }
}