java_反射_及其简单应用（2016-11-16）
话不多说直接上代码
接口：
package bean;
/**
* user接口
*/
public interface User {
public String getName();
public void setName(String name);
}
父类：
package bean;
/**
* 人 作为userImpl的父类
*/
public class Person {
private String name;
public String city;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
@Override
public String toString() {
return "Person [name=" + name + ", city=" + city + "]";
}
}
实现类：
package bean;
/**
* 用户实现类
* 当前类没有实现user中的方法，由父类中实现。
*/
public class UserImpl extends Person implements User{
/**
* 用户名
*/
private String userName;
/**
* 密码
*/
private String Password;
/**
* 是否富有
*/
boolean isRich;
/**
* 年龄
*/
protected int age;
/**
* 信息
*/
public StringBuffer info;
public UserImpl() {
super();
}
public UserImpl(String userName) {
super();
this.userName = userName;
}
@Override
public String toString() {
return "UserImpl [userName=" + userName + ", Password=" + Password
+ ", isRich=" + isRich + ", age=" + age + ", info=" + info
+ "]";
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return Password;
}
public void setPassword(String password) {
Password = password;
}
public boolean isRich() {
return isRich;
}
public void setRich(boolean isRich) {
this.isRich = isRich;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public StringBuffer getInfo() {
return info;
}
public void setInfo(StringBuffer info) {
this.info = info;
}
}
工厂接口：
package bean;
public interface Factory {
<T> T getBean(String name, Class<T> requiredType) throws Exception;
}
工厂：
package bean;
public class FactoryImpl implements Factory{
/**
* 获取实例
* @param class1
* @return
* @throws Exception
*/
@SuppressWarnings("unchecked")
@Override
public <T> T getBean(String name, Class<T> requiredType) throws Exception {
Object object = null;
try {
Class<?> clazz = Class.forName(name);
object = clazz.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
//如果obj是这个类的一个实例此方法返回true。
if (requiredType != null && !requiredType.isInstance(object)) {
throw new Exception("类不同，抛异常");
}
return (T)object;
}
}
测试类：
package bean;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
public class ReflectTest {
private String className = "bean.UserImpl";
/**
* 获取实例化Class类对象
*/
@Test
public void test01() throws ClassNotFoundException {
Class<?> class1 = null;
Class<?> class2 = null;
Class<?> class3 = null;
// 第一种方式：
class1 = Class.forName(className);// 一般采用这种形式
// 第二种方式：java中每个类型都有class 属性.
class2 = UserImpl.class;
// 第三种方式： java语言中任何一个java对象都有getClass 方法
class3 = new UserImpl().getClass();
System.out.println("类名称 " + class1.getName());
System.out.println("类名称 " + class2.getName());
System.out.println("类名称 " + class3.getName());
//?号的用法。
//T就是将类型固定，而?则不固定
//List<?> userList = new ArrayList<>();
}
/**
* 获取类以后我们来创建它的对象
*/
@Test
public void test02() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class<?> clazz = Class.forName(className);
// 创建此Class 对象所表示的类的一个新实例
Object object = clazz.newInstance(); // 调用无参数构造方法.
System.out.println(clazz);
System.out.println(object);
}
/**
* 获取对象继承的父类以及实现接口
* @throws ClassNotFoundException
*/
@Test
public void test03() throws ClassNotFoundException {
Class<?> clazz = Class.forName(className);
// 直接父类
Class<?> superclass = clazz.getSuperclass();
System.out.println("clazz的直接父类为：" + superclass.getName());//calzz的父类为：bean.Person
// 所有的接口
Class<?>[] interfaces = clazz.getInterfaces();
System.out.println("clazz实现的接口有：");
for (int i = 0; i < interfaces.length; i++) {
System.out.println((i + 1) + "：" + interfaces[i].getName());
}
// clazz实现的接口有：
// 1：bean.User
}
/**
* 获取某个类的全部属性
* @throws ClassNotFoundException
*/
@Test
public void test04() throws ClassNotFoundException {
Class<?> clazz = Class.forName(className);
System.out.println("=============== 当前类属性 field ===============");
// 取得本类的全部属性
Field[] declaredFields = clazz.getDeclaredFields();
for (Field field : declaredFields) {
// 权限修饰符
int modifiers = field.getModifiers();
String priv = Modifier.toString(modifiers);
// 属性类型
Class<?> type = field.getType();
System.out.println(priv + " " + type.getName() + " " + field.getName() + ";");
}
System.out.println("=============== 实现的接口或者父类的属性 field ==========");
System.out.println("=============== 当前类及其父类或接口的public类型属性 ==========");
// 取得实现的接口或者父类的属性
Field[] fields = clazz.getFields();
for (Field field : fields) {
// 权限修饰符
int modifiers = field.getModifiers();
String priv = Modifier.toString(modifiers);
// 属性类型
Class<?> type = field.getType();
System.out.println(priv + " " + type.getName() + " " + field.getName() + ";");
}
}
/**
* 获取某个类的全部方法
* @throws ClassNotFoundException
*/
@Test
public void test05() throws ClassNotFoundException {
Class<?> clazz = Class.forName(className);
System.out.println("=============== 当前类能调用的所有方法 ===============");
Method[] methods = clazz.getMethods();
for (Method method : methods) {
Class<?> returnType = method.getReturnType();
Class<?>[] parameterTypes = method.getParameterTypes();
Class<?>[] exceptionTypes = method.getExceptionTypes();
int modifiers = method.getModifiers();
String priv = Modifier.toString(modifiers);
StringBuffer content = new StringBuffer();
content.append(priv + " " + returnType.getName() + " " + method.getName() + "( ");
//方法参数类型集合
if (null != parameterTypes && parameterTypes.length > 0) {
for (Class<?> parameterType : parameterTypes) {
content.append(parameterType.getName() + " " + ",");
}
content.delete(content.length() - 1, content.length());
}
content.append(" )");
// 方法抛出的异常
if (null != exceptionTypes && exceptionTypes.length > 0) {
content.append(" throws ");
for (Class<?> exceptionType : exceptionTypes) {
content.append(exceptionType.getName() + " " + ",");
}
content.delete(content.length() - 1, content.length());
}
System.out.println(content);
}
}
/**
* 通过反射机制调用某个类的方法
* @throws SecurityException
* @throws NoSuchMethodException
* @throws IllegalAccessException
* @throws InstantiationException
* @throws InvocationTargetException
* @throws IllegalArgumentException
*/
@Test
public void test06() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Class<?> clazz = Class.forName(className);
System.out.println("=============== Java 反射机制 - 调用某个类的方法toString ===============");
Object obj = clazz.newInstance();
//调用userImpl的setUserName方法。前提：实例
Method method = clazz.getMethod("setUserName",String.class);
Object result = method.invoke(obj,"张三");
System.out.println("Java 反射机制 - 调用某个类的方法setUserName:" + result);
//调用userImpl的toString方法。前提：实例
Method method2 = clazz.getMethod("toString");
Object result2 = method2.invoke(obj);
System.out.println("Java 反射机制 - 调用某个类的方法toString:" + result2);
}
/**
* 通过反射机制操作某个类的属性
* @throws ClassNotFoundException
* @throws IllegalAccessException
* @throws InstantiationException
* @throws SecurityException
* @throws NoSuchFieldException
*/
@Test
public void test07() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException {
Class<?> clazz = Class.forName(className);
System.out.println("=============== Java 反射机制 - 操作某个类的属性 ===============");
Object obj = clazz.newInstance();
Field declaredField = clazz.getDeclaredField("userName");
// 可以直接对 private 的属性赋值
//java.lang.IllegalAccessException: Class bean.ReflectTest can not access a member of class bean.UserImpl with modifiers "private"
declaredField.setAccessible(true);
declaredField.set(obj, "Java反射机制");
System.out.println(declaredField.get(obj));
System.out.println(obj);
}
/**
* 获取构造函数
*/
@Test
public void test08() throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Class<?> clazz = Class.forName(className);
System.out.println("=============== Java 反射机制 - 获取构造函数 ===============");
Constructor<?>[] constructors = clazz.getConstructors();
if(null != constructors && constructors.length >0){
for (Constructor<?> constructor : constructors) {
System.out.println("构造方法： "+ constructor);
}
Object user1 = constructors[0].newInstance();
Object user2 = constructors[1].newInstance("用户名啊");
System.out.println(user1);
System.out.println(user2);
}
}
/**
* 调用set和get方法
* @throws ClassNotFoundException
* @throws IllegalAccessException
* @throws InstantiationException
*/
@Test
public void test09() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class<?> clazz = Class.forName(className);
System.out.println("=============== Java 反射机制 - 调用set和get方法 ===============");
Object obj = clazz.newInstance();
setter(obj, "userName", String.class, "名字呢");
System.out.println("set后的对象："+obj);
Object result = getter(obj, "userName");
System.out.println("get得到的内容：" + result);
}
/**
* 通过反射取得并修改数组的信息
*/
@Test
public void test10() {
int[] temps = { 1, 2, 3, 4, 5 };
System.out.println("=============== Java 反射机制 - 取得并修改数组的信息 ===============");
// 获得数组内部类型
Class<?> componentType = temps.getClass().getComponentType();
System.out.println("数组类型： " + componentType.getName());
System.out.println("数组长度： " + Array.getLength(temps));
System.out.println("数组的第一个元素: " + Array.get(temps, 0));
Array.set(temps, 0, 100);
System.out.println("修改之后数组第一个元素为： " + Array.get(temps, 0));
}
/**
* 通过反射机制修改数组的大小
*/
@Test
public void test11() {
System.out.println("=============== Java 反射机制 - 修改数组的大小 ===============");
int[] temps = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int[] newTemps = (int[]) modifyArrayLength(temps, 15);
printArray(newTemps);
String[] atr = { "a", "b", "c" };
String[] str1 = (String[]) modifyArrayLength(atr, 8);
printArray(str1);
}
/**
* 在泛型为Integer的ArrayList中存放一个String类型的对象。
* @throws SecurityException
* @throws NoSuchMethodException
* @throws InvocationTargetException
* @throws IllegalArgumentException
* @throws IllegalAccessException
*/
@Test
public void test12() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
System.out.println("=============== Java 反射机制 - 在泛型为Integer的ArrayList中存放一个String类型的对象。===============");
List<Integer> list = new ArrayList<Integer>();
@SuppressWarnings("rawtypes")
Class<? extends List> class1 = list.getClass();
Method method = class1.getMethod("add", Object.class);
method.invoke(list, "这是：String类型的对象");
System.out.println(list);
}
/**
* 将反射机制应用于工厂模式
* 模仿一下spring
* @throws Exception
*/
@Test
public void test13() throws Exception {
System.out.println("=============== Java 反射机制 - 将反射机制应用于工厂模式 ===============");
FactoryImpl factory = new FactoryImpl();
UserImpl user = factory.getBean(className,UserImpl.class);
System.out.println(user);
}
/**
* 反射机制的动态代理
*/
@Test
public void test14() {
System.out.println("=============== Java 反射机制 - 反射机制的动态代理===============");
MyInvocationHandler demo = new MyInvocationHandler();
UserImpl userImpl = new UserImpl();
User user = (User) demo.bind(userImpl);
user.setName("Rollen");
System.out.println(user);
}
/**
* 内部类
* 实现调用处理接口
* @author chenchuan
*
*/
class MyInvocationHandler implements InvocationHandler {
private Object obj = null;
public Object bind(Object obj) {
this.obj = obj;
ClassLoader classLoader = obj.getClass().getClassLoader();
Class<?>[] interfaces = obj.getClass().getInterfaces();//目标类的父类及即接口，可以发现执行目标方法时，先执行父类或接口对应的方法
return Proxy.newProxyInstance(classLoader,interfaces , this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("目标方法(" + method +")开始前...");
Object temp = method.invoke(this.obj, args);
System.out.println("目标方法(" + method+")结束后...");
return temp;
}
}
/**
* 打印
* @param obj
*/
public static void printArray(Object obj) {
Class<?> c = obj.getClass();
if (!c.isArray()) {
return;
}
System.out.println("数组长度为： " + Array.getLength(obj));
for (int i = 0; i < Array.getLength(obj); i++) {
System.out.print(Array.get(obj, i) + " ");
}
System.out.println();
}
/**
* 修改数组大小
* @param obj
* @param newLength
* @return
*/
public Object modifyArrayLength(Object obj, int newLength) {
Class<?> componentType = obj.getClass().getComponentType();
Object newArray = Array.newInstance(componentType, newLength);
int co = Array.getLength(obj);
System.arraycopy(obj, 0, newArray, 0, co);
return newArray;
}
/**
*
* 执行get方法
* @param obj 操作的对象
* @param fieldName操作的属性
*/
public Object getter(Object obj, String fieldName) {
StringBuffer methodName = new StringBuffer();
methodName.append("get");
// sb.append(fieldName.substring(0, 1).toUpperCase());
// sb.append(fieldName.substring(1));
methodName.append(getMethodName(fieldName));
Object invoke = null;
try {
Method method = obj.getClass().getMethod(methodName.toString());
invoke = method.invoke(obj, new Object[0]);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return invoke;
}
/**
* @param obj
* 操作的对象
* @param fieldName
* 操作的属性
* @param type
* 参数的属性
* @param value
* 设置的值
* */
public void setter(Object obj, String fieldName, Class<?> type, Object... value) {
StringBuffer methodName = new StringBuffer();
methodName.append("set");
// sb.append(fieldName.substring(0, 1).toUpperCase());
// sb.append(fieldName.substring(1));
methodName.append(getMethodName(fieldName));
try {
Method method = obj.getClass().getMethod(methodName.toString(), type);
method.invoke(obj, value);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
/**
* 把一个字符串的第一个字母大写、效率是最高的、
* @param fildeName
* @return
*/
private String getMethodName(String fildeName) {
byte[] items = fildeName.getBytes();
items[0] = (byte) ((char) items[0] - 'a' + 'A');
return new String(items);
}
}
