java动态代理与反射

一、通过反射的方式可以获取class对象中的属性、方法、构造函数等

public class MyReflect {
	public String className = null;
	@SuppressWarnings("rawtypes")
	public Class personClass = null;
	/**
	 * 反射Person类
	 * @throws Exception 
	 */
	@Before
	public void init() throws Exception {
		className = "cn.zekun_reflect.Person";
		personClass = Class.forName(className);
	}
	/**
	 *获取某个class文件对象
	 */
	@Test
	public void getClassName() throws Exception {
		System.out.println(personClass);
	}
	/**
	 *获取某个class文件对象的另一种方式
	 */
	@Test
	public void getClassName2() throws Exception {
		System.out.println(Person.class);
	}
	/**
	 *创建一个class文件表示的实例对象，底层会调用空参数的构造方法
	 */
	@Test
	public void getNewInstance() throws Exception {
		System.out.println(personClass.newInstance());
	}
	/**
	 *获取非私有的构造函数
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Test
	public void getPublicConstructor() throws Exception {
		Constructor  constructor  = personClass.getConstructor(Long.class,String.class);
		Person person = (Person)constructor.newInstance(100L,"zhangsan");
		System.out.println(person.getId());
		System.out.println(person.getName());
	}
	/**
	 *获得私有的构造函数
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Test
	public void getPrivateConstructor() throws Exception {
		Constructor con = personClass.getDeclaredConstructor(String.class);
		con.setAccessible(true);//强制取消Java的权限检测
		Person person2 = (Person)con.newInstance("zhangsan");
		System.out.println("**"+person2.getName());
	}
	/**
	 *访问非私有的成员变量
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Test
	public void getNotPrivateField() throws Exception {
		Constructor  constructor  = personClass.getConstructor(Long.class,String.class);
		Object obj = constructor.newInstance(100L,"zhangsan");
		
		Field field = personClass.getField("name");
		field.set(obj, "lisi");
		System.out.println(field.get(obj));
	}
	/**
	 *访问私有的成员变量
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Test
	public void getPrivateField() throws Exception {
		Constructor  constructor  = personClass.getConstructor(Long.class);
		Object obj = constructor.newInstance(100L);
		
		Field field2 = personClass.getDeclaredField("id");
		field2.setAccessible(true);//强制取消Java的权限检测
		field2.set(obj,10000L);
		System.out.println(field2.get(obj));
	}
	/**
	 *获取非私有的成员函数
	 */
	@SuppressWarnings({ "unchecked" })
	@Test
	public void getNotPrivateMethod() throws Exception {
		System.out.println(personClass.getMethod("toString"));
		
		Object obj = personClass.newInstance();//获取空参的构造函数
		Method toStringMethod = personClass.getMethod("toString");
		Object object = toStringMethod.invoke(obj);
		System.out.println(object);
	}
	/**
	 *获取私有的成员函数
	 */
	@SuppressWarnings("unchecked")
	@Test
	public void getPrivateMethod() throws Exception {
		Object obj = personClass.newInstance();//获取空参的构造函数
		Method method = personClass.getDeclaredMethod("getSomeThing");
		method.setAccessible(true);
		Object value = method.invoke(obj);
		System.out.println(value);

	}
	/**
	 *
	 */
	@Test
	public void otherMethod() throws Exception {
		//当前加载这个class文件的那个类加载器对象
		System.out.println(personClass.getClassLoader());
		//获取某个类实现的所有接口
		Class[] interfaces = personClass.getInterfaces();
		for (Class class1 : interfaces) {
			System.out.println(class1);
		}
		//反射当前这个类的直接父类
		System.out.println(personClass.getGenericSuperclass());
		/**
		 * getResourceAsStream这个方法可以获取到一个输入流，这个输入流会关联到name所表示的那个文件上。
		 */
		//path 不以’/'开头时默认是从此类所在的包下取资源，以’/'开头则是从ClassPath根下获取。其只是通过path构造一个绝对路径，最终还是由ClassLoader获取资源。
		System.out.println(personClass.getResourceAsStream("/log4j.properties"));
		System.out.println(personClass.getResourceAsStream("log4j.properties"));
		
		//判断当前的Class对象表示是否是数组
		System.out.println(personClass.isArray());
		System.out.println(new String[3].getClass().isArray());
		
		//判断当前的Class对象表示是否是枚举类
		System.out.println(personClass.isEnum());
		System.out.println(Class.forName("cn.zekun_reflect.City").isEnum());
		
		//判断当前的Class对象表示是否是接口
		System.out.println(personClass.isInterface());
		System.out.println(Class.forName("cn.zekun_reflect.TestInterface").isInterface());
	}
}

二、动态代理
动态代理：在不修改原业务的基础上，基于原业务方法，进行重新的扩展，实现新的业务。
java动态代理与反射
代理实现流程：
1、书写代理类和代理方法，在代理方法中实现代理Proxy.newProxyInstance
2、代理中需要的参数分别为：被代理的类的类加载器soneObjectclass.getClassLoader()，被代理类的所有实现接口new Class[] { Interface.class }，句柄方法new InvocationHandler()
3、在句柄方法中复写invoke方法，invoke方法的输入有3个参数Object proxy（代理类对象）, Method method（被代理类的方法）,Object[] args（被代理类方法的传入参数），在这个方法中，我们可以定制化的开发新的业务。
4、获取代理类，强转成被代理的接口
5、最后，我们可以像没被代理一样，调用接口的认可方法，方法被调用后，方法名和参数列表将被传入代理类的invoke方法中，进行新业务的逻辑流程

public interface IBoss {//接口
	int yifu(String size);
}

public class Boss implements IBoss{
	public int yifu(String size){
		System.err.println("天猫小强旗舰店，老板给客户发快递----衣服型号："+size);
		//这件衣服的价钱，从数据库读取
		return 50;
	}
	public void kuzi(){
		System.err.println("天猫小强旗舰店，老板给客户发快递----裤子");
	}
}

public class SaleAction {
	/**
	 * 不使用代理，直接调用方法
	 * 方法中规定什么业务，就只能调用什么业务，规定什么返回值，就只能输出什么返回值
	 */
	@Test
	public void saleByBossSelf() throws Exception {
		IBoss boss = new Boss();
		System.out.println("老板自营！");
		int money = boss.yifu("xxl");// 老板自己卖衣服，不需要客服，结果就是没有聊天记录
		System.out.println("衣服成交价：" + money);
	}
}

public class ProxyBoss {
	/**
	 * 对接口方法进行代理
	 */
	@SuppressWarnings("unchecked")
	public static <T> T getProxy(final int discountCoupon,
			final Class<?> interfaceClass, final Class<?> implementsClass)
			throws Exception {
		return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(),
				new Class[] { interfaceClass }, new InvocationHandler() {
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						Integer returnValue = (Integer) method.invoke(
								implementsClass.newInstance(), args);// 调用原始对象以后返回的值
						return returnValue - discountCoupon;
					}
				});
	}
}

/**
 * 什么是动态代理？ 简单的写一个模板接口，剩下的个性化工作，好给动态代理来完成！
 */
public class ProxySaleAction {
	/**
	 *使用代理，在这个代理中，只代理了Boss的yifu方法
	 *定制化业务，可以改变原接口的参数、返回值等
	 */
	@Test
	public void saleByProxy() throws Exception {
		IBoss boss = ProxyBoss.getProxy(10,IBoss.class,Boss.class);// 将代理的方法实例化成接口
		//IBoss boss = new Boss();// 将代理的方法实例化成接口
		System.out.println("代理经营！");
		int money = boss.yifu("xxl");// 调用接口的方法，实际上调用方式没有变
		System.out.println("衣服成交价：" + money);
	}
}

java动态代理与反射

相关推荐