java.lang.Class<T> -- 反射机制及动态代理

Interface ： Person

package java_.lang_.component.bean;

public interface Person {

String area = "earth";

public void userAxe();

public void personLaught();
}

Class ： Teacher

package java_.lang_.component.bean.impl;

import java_.lang_.component.bean.Person;

public class Teacher {
private String subject;
private Person[] sudents;

public String getSubject() {
return subject;
}

public void setSubject(String subject) {
this.subject = subject;
}

public Person[] getSudents() {
return sudents;
}

public void setSudents(Person[] sudents) {
this.sudents = sudents;
}
}

Class ： Chinese

package java_.lang_.component.bean.impl;

import java_.lang_.component.bean.Axe;
import java_.lang_.component.bean.Person;

public class Chinese extends Teacher implements Person {

private String name;
private Axe axe;
public String commonPro;

public Chinese(String name, Axe axe) {
super();
this.name = name;
this.axe = axe;
}

public String getCommonPro() {
return commonPro;
}

public void setCommonPro(String commonPro) {
this.commonPro = commonPro;
}

public Chinese() {
super();
// TODO Auto-generated constructor stub
}

@Override
public String toString() {
return "Chinese [name=" + name + ", axe=" + axe + "]";
}

@Override
public void userAxe() {
System.out.println(name + " 说 ： " + axe.chop());
}

public String getName() {
return name;
}

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

public Axe getAxe() {
return axe;
}

public void setAxe(Axe axe) {
this.axe = axe;
}

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

public void exception() throws InterruptedException{
Thread.sleep(1000);
}

}

Interface ：Axe

package java_.lang_.component.bean;

public interface Axe {

public String chop();
}

Class ： SteelAxe

package java_.lang_.component.bean.impl;

import java_.lang_.component.bean.Axe;

public class SteelAxe implements Axe {

@Override
public String chop() {
return "用钢斧砍柴真快";
}

}

Class ：Class_T

package java_.lang_;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;

import java_.lang_.component.bean.Axe;
import java_.lang_.component.bean.Person;
import java_.lang_.component.bean.impl.Chinese;
import java_.lang_.component.bean.impl.SteelAxe;
import java_.lang_.component.bean.impl.Teacher;

//T - 由此 Class 对象建模的类的类型。例如， String.class 的类型是 Class<String>。如果将被建模的类未知，则使用 Class<?>。
//Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，
//所有具有相同元素类型和维数的数组都共享该 Class 对象。
//基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。

//Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
public class Class_T {

public static void main(String[] args) throws Exception{
Chinese chinese = new Chinese();
System.out.println(chinese.getClass().getName());
System.out.println(chinese.getClass());
System.out.println("----------------------Class类的常用方法--------------");
//        传入完整的“包.类”名称实例化Class对象
Class<?> clazzChinese = Class.forName("java_.lang_.component.bean.impl.Chinese");
//        得到一个类中的全部构造方法,按类中构造方法的顺序排列：无参、有参：0、1
System.out.println("得到一个类中的全部构造方法");
Constructor[] constructorsChinese = clazzChinese.getConstructors();
for(Constructor<?> constructor : constructorsChinese){
System.out.println(constructor);
}
//        得到本类中单独定义的全部属性
System.out.println("得到本类中单独定义的全部属性");
Field[] fieldDeclaredsChinese = clazzChinese.getDeclaredFields();
for(Field fieldDeclared : fieldDeclaredsChinese){
System.out.println(fieldDeclared);
}
//        取得本类继承而来的全部属性
System.out.println("取得本类继承而来的全部属性");
Field[] fields = clazzChinese.getFields();
for(Field field : fields){
System.out.println(field);
}
//        得到一个类中的全部方法
System.out.println("得到一个类中的全部方法");
Method[] methods = clazzChinese.getMethods();
for(Method method : methods){
System.out.println(method);
}
//        返回一个Method对象，并设置一个方法中的所有参数类型
System.out.println("返回一个Method对象，并设置一个方法中的所有参数类型");
Method method = clazzChinese.getMethod("setName", String.class);
Chinese lime = (Chinese) clazzChinese.newInstance();
method.invoke(lime, "lime");
System.out.println(lime.getName());
//        得到一个类中所有实现的全部接口
System.out.println("得到一个类中所有实现的全部接口");
Class[] interfaces = clazzChinese.getInterfaces();
for(Class<?> interfaceClass : interfaces){
System.out.println(interfaceClass);
}
//        得到一个类完整的“包.类”名称
System.out.println("得到一个类完整的“包.类”名称");
System.out.println(clazzChinese.getName());
//        得到一个类的包
System.out.println("得到一个类的包");
System.out.println(clazzChinese.getPackage());
//        得到一个类的父类
System.out.println("得到一个类的父类");
System.out.println(clazzChinese.getSuperclass());
//        根据Class定义的类实例化对象
System.out.println("根据Class定义的类实例化对象");
Teacher teacher = (Teacher) clazzChinese.newInstance();
System.out.println(teacher);
//        返回表示数组类型的Class
System.out.println("返回表示数组类型的Class");
Class<? extends Person[]> clazzArray = new Person[]{}.getClass();
System.out.println(clazzArray);
//        判断此Class 是否是一个数组
System.out.println("判断此Class 是否是一个数组");
if(clazzArray.isArray()){
System.out.println("isArray");
}else{
System.out.println("not isArray");
}
System.out.println("budong");
//        通过无参构造实例化对象
System.out.println("通过无参构造实例化对象");
Chinese china = (Chinese) clazzChinese.newInstance();
System.out.println(china);
//        调用有参构造实例化对象
System.out.println("调用有参构造实例化对象");
Constructor[] constructorsChina = clazzChinese.getConstructors();
Person person = (Person) constructorsChina[0].newInstance("lime",new SteelAxe());
person.userAxe();
System.out.println("-------------Constructor常用方法--------------------");
//        得到构造方法的修饰符
System.out.println("得到构造方法的修饰符");
int modifier = constructorsChina[0].getModifiers();
System.out.println(modifier);
System.out.println(Modifier.toString(modifier));
//        得到构造方法的名称
System.out.println("得到构造方法的名称");
System.out.println(constructorsChina[0].getName());
//        得到构造方法中参数的类型
System.out.println("得到构造方法中参数的类型");
Class[] parameterTypes = constructorsChina[0].getParameterTypes();
for(Class<?> parameterType : parameterTypes){
System.out.println(parameterType);
}
//        返回此构造的信息
System.out.println("返回此构造的信息");
for(Constructor<?> constructor : constructorsChina){
System.out.println(constructor.toString());
}
//        向构造方法中传递参数，实例化对象
System.out.println("向构造方法中传递参数，实例化对象");
Chinese per = (Chinese) constructorsChina[0].newInstance("lime",new SteelAxe());
System.out.println(per.toString());

System.out.println("----------------------反射的应用------取得类的结构-----------------");

System.out.println("-----------------------取得全部方法--------------------");
System.out.println("---------------------Method类中的常用方法---------------");
//        取得本方法的访问修饰符
System.out.println("取得本方法的访问修饰符");
Method meth = clazzChinese.getDeclaredMethod("setName",String.class);
System.out.println(meth.getModifiers());
System.out.println(Modifier.toString(meth.getModifiers()));
//        获取方法的名称
System.out.println("获取方法的名称");
Method[] meths = clazzChinese.getDeclaredMethods();
for(Method metho : meths){
System.out.println(metho.getName());
}
//        得到方法的全部参数类型
System.out.println("得到方法的全部参数类型");
for(Method metho : meths){
System.out.println(metho.getName());
Class[] params = metho.getParameterTypes();
for(Class<?> param : params){
System.out.println(param);
}
}
//        得到方法的返回值类型
System.out.println("得到方法的返回值类型");
for(Method metho : meths){
System.out.print(Modifier.toString(metho.getModifiers()) + " ");
System.out.println(metho.getReturnType());
}
//        得到一个方法的全部抛出异常
System.out.println("得到一个方法的全部抛出异常");
Method methodException = clazzChinese.getMethod("exception");
System.out.print(Modifier.toString(methodException.getModifiers()) + " ");
System.out.print(methodException.getReturnType() + " ");
System.out.print(methodException.getName() + "(");
Class[] paramMethods = methodException.getParameterTypes();
if(paramMethods.length > 0){
for(int i = 0;i < paramMethods.length - 1;i++){
System.out.print(paramMethods[i].getName().substring(paramMethods[i].getName().lastIndexOf(".")) + ",");
}
System.out.print(paramMethods[paramMethods.length-1]);
}
System.out.print(") throws ");
Class[] exceptionClasses = methodException.getExceptionTypes();
if(exceptionClasses.length > 0){
for(int i = 0;i < exceptionClasses.length - 1;i++){
System.out.print(exceptionClasses[i].getName().substring(exceptionClasses[i].getName().lastIndexOf(".")) + ", ");
}
System.out.println(exceptionClasses[exceptionClasses.length-1].getName());
}
for(Class<?> exce : exceptionClasses){
System.out.println(exce);
}

System.out.println("---------------------------------------------");
System.out.println("--------------------获取全部属性-----------------");
System.out.println("----------------Field类的常用方法----------------");
//        得到一个对象中属性的具体内容
System.out.println("得到一个对象中属性的具体内容");
Chinese ch = (Chinese) clazzChinese.newInstance();
Field commonPro = clazzChinese.getDeclaredField("commonPro");
System.out.println(commonPro.getName() + " isAccessible " + commonPro.isAccessible());
commonPro.set(ch, "lime");
commonPro.get(ch);
System.out.println(ch.getCommonPro());
Field name = clazzChinese.getDeclaredField("name");
System.out.println(name.getName() + " isAccessible " + name.isAccessible());
if(name.isAccessible()){
}else{
name.setAccessible(true);
name.set(ch, "Oracle");
name.get(ch);
System.out.println(ch.getName());

}
//        设置指定对象中属性的具体内容
System.out.println("设置指定对象中属性的具体内容");
//        得到属性的修饰符
System.out.println("得到属性的修饰符");
System.out.println(commonPro.getModifiers());
System.out.println(Modifier.toString(commonPro.getModifiers()));
//        返回此属性的名称
System.out.println("返回此属性的名称");
System.out.println(commonPro.getName());
//        判断此属性是否可被外部访问
System.out.println("判断此属性是否可被外部访问");
System.out.print(Modifier.toString(commonPro.getModifiers()) + " ");
if(commonPro.isAccessible()){
System.out.println("isAccessible");
}else{
System.out.println("not isAccessible");
}
System.out.print(Modifier.toString(clazzChinese.getDeclaredField("name").getModifiers()) + " ");
if(clazzChinese.getDeclaredField("name").isAccessible()){
System.out.println("isAccessible");
}else{
System.out.println("not isAccessible");
}
//        设置一个属性是否可被外部访问
System.out.println("设置一个属性是否可被外部访问");
commonPro.setAccessible(true);
if(commonPro.isAccessible()){
System.out.println("isAccessible");
}else{
System.out.println("not isAccessible");
}
//        设置一组属性是否可被外部访问
System.out.println("设置一组属性是否可被外部访问");
Field[] fieldsAll = clazzChinese.getDeclaredFields();
System.out.println("设置前");
for(Field field : fieldsAll){
System.out.println(field.getName() + " isAccessible:" + field.isAccessible());
}
for(Field field : fieldsAll){
field.setAccessible(true);
}
System.out.println("全部设置为true");
for(Field field : fieldsAll){
System.out.println(field.getName() + " isAccessible:" + field.isAccessible());
}
//        获取属性的类型
System.out.println("获取属性的类型");
for(Field field : fieldsAll){
System.out.println(field.getName() + " " + field.getType());
}
//        获取继承父类的全部属性
System.out.println("获取继承父类的全部属性");
Field[] fieldsDeclared = clazzChinese.getFields();
for(Field field : fieldsDeclared){
System.out.println(field.getName());
}
System.out.println("----------------------------------------------");
System.out.println("-------------------Java反射机制的深入应用-------------");
System.out.println("-------------通过反射调用类中的方法-------------------");
//        通过反射调用类中的方法
System.out.println("通过反射调用类中的方法");
{
Method methodSetAxe = clazzChinese.getDeclaredMethod("setAxe", Axe.class);
Chinese chin = (Chinese) clazzChinese.newInstance();
methodSetAxe.invoke(chin, new SteelAxe());
System.out.println(chin.getAxe());
}
//        调用setter和getter方法
System.out.println("模拟setter和getter方法");
System.out.println("懒得写");
//        通过反射操作属性
System.out.println("通过反射操作属性");
//        得到一个对象中属性的具体内容
System.out.println("得到一个对象中属性的具体内容");
Chinese ch1 = (Chinese) clazzChinese.newInstance();
Field commonPro1 = clazzChinese.getDeclaredField("commonPro");
//        commonPro1.setAccessible(true);
commonPro1.set(ch1, "lime");
commonPro1.get(ch1);
System.out.println(ch1.getCommonPro());
System.out.println("-----------通过反射操作数组--------------");
System.out.println("-----------Array类的常用方法------------");
//        根据下标取得数组内容
System.out.println("根据下标取得数组内容");
int[] temp = {1,2,3};
Class<?> c = temp.getClass().getComponentType();
System.out.println("类型：" + c.getName());
System.out.println("长度：" + Array.getLength(temp));
System.out.println("第一个内容：" + Array.get(temp,0));
//        修改指定位置的内容
System.out.println("修改指定位置的内容");
Array.set(temp, 0, 6);
System.out.println("第一个内容：" + Array.get(temp,0));
//        根据已有的数组类型开辟新的数组对象
System.out.println("根据已有的数组类型开辟新的数组对象");
int[] newTemp = (int[]) Array.newInstance(temp.getClass().getComponentType(), Array.getLength(temp)*2);
System.arraycopy(temp, 0, newTemp, 0, temp.length);
for(int array : newTemp){
System.err.print(array);
}
System.out.println();
System.out.println(Array.getLength(newTemp));
for(int i = 0;i < Array.getLength(newTemp);i++){
System.out.print(Array.get(newTemp, i));
}
System.out.println("--------------------------------");
}
}

　　　　动态代理

　　　　　　通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。

　　　　　　在Java中想实现动态代理机制，则需要java.lang.reflect.InvocationHandler接口和java.lang.reflect.Proxy类的支持。

　　　　　　InvocationHandler接口的定义如下：

/*
* proxy : （此处有误吧？被代理的对象）应该是指最终生成的代理对象，打印出来是class $proxy0
* method : 要调用的方法
* args[] : 方法调用时所需要的参数。
*/
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;

　　　　　　Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类。

　　　　　　Proxy类提供了如下的操作方法：

//    通过newProxyInstance()方法可以动态地生成实现类
/*
* loader : 类加载器。Proxy.class.getClassLoader().getClass().getName();
* interfaces : 得到全部的接口。
* hander : 得到Invocationhandler接口的子类实例。
*/
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler handler) throws lllegalArgumentException{

}

　　　　　　Class ： MyInvocationHandler

package edu.pri.lime._7_8_3.demo.bean;

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

public class MyInvocationHandler implements InvocationHandler{

//    真实主题
private Object obj;
//    绑定真实操作主题
public Object bind(Object obj){
this.obj = obj;
//        Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类。
//        通过Proxy.newProxyInstance()可以动态地生成实现类
//        取得代理对象
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
}

//    动态调用方法
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//        调用方法，传入真实主题和参数
args[0] = "Oracle";
Object temp = method.invoke(this.obj, args);
//        返回方法的返回信息
return temp;
}

}

　　　　　　Interface ： Subject

package edu.pri.lime._7_8_3.demo.bean;

//定义Subject接口
public interface Subject {
//    定义抽象方法say
public String say(String name,int age);
}

　　　　　　Class ： RealSubject

package edu.pri.lime._7_8_3.demo.bean.impl;

import edu.pri.lime._7_8_3.demo.bean.Subject;

//定义真实主题实现类
//在操作时直接将真实主题类的对象传入到MyInvocationHandler类的bind()方法中即可
public class RealSubject implements Subject {

public String say(String name, int age) {
return "姓名:" + name + ", 年龄:" + age;
}

}

　　　　　　Class ： DynaProxyDemo

package edu.pri.lime._7_8_3.demo.main;

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

import edu.pri.lime._7_8_3.demo.bean.MyInvocationHandler;
import edu.pri.lime._7_8_3.demo.bean.Subject;
import edu.pri.lime._7_8_3.demo.bean.impl.RealSubject;

public class DynaProxyDemo {

public static void main(String[] args) {
{
// 实例化代理操作类
MyInvocationHandler handler = new MyInvocationHandler();
// 绑定对象
Subject sub = (Subject) handler.bind(new RealSubject());
// 通过动态代理调用方法
String info = sub.say("lime", 20);
System.out.println(info);
}
}
}

　　　　　　Console ：

姓名:Oracle, 年龄:20

啦啦啦

啦啦啦