Spring篇--05 反射及反射实例

最新推荐文章于 2022-05-30 20:25:52 发布

原创最新推荐文章于 2022-05-30 20:25:52 发布

· 627 阅读

0 ·

版权

文章标签：

#反射

javaweb的学习路径同时被 2 个专栏收录

84 篇文章

订阅专栏

javaweb封神之路

54 篇文章

订阅专栏

Spring篇--05 反射及反射实例

一、反射

1.是Java API，是Java提供的现成的类

2.是Java提供的动态执行机制，动态加载类，动态创建对象，动态访问属性，动态调用方法。

二、静态和动态

静态：事先约定的规则，执行期间按照固定规则执行。

动态：事先没有约定，在执行期间动态确定执行规则。

Java中的静态执行：编译已经就确定执行规则（执行次序），在运行期间按照编译结果顺序执行。

Java中的动态执行：运行期间才能确定加载哪些类，创建哪些对象，执行哪些方法。

三、动态创建对象

语法：cls.newInstance()

执行cls引用的类信息中的无参数构造器，动态创建实例，如果类没有无参数构造器，则抛出异常！

提示：反射可以调用有参数构造器

四、动态查询类的方法信息

package demo;

import java.lang.reflect.Method;
import java.util.Scanner;

/**
 * 动态加载类
 * @author LvChaoZhang
 *
 */
public class Demo1 {
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		Scanner in = new Scanner(System.in);
		System.out.println("输入类名:");
		String className = in.nextLine();
		//动态加载类
		Class class1=Class.forName(className);
		System.out.println(class1);
		//动态创建对象
		Object obj = class1.newInstance();
		System.out.println(obj);
		//动态获取类的信息
		//从class1代表的类信息中获取全部的方法信息
		Method[] ary = class1.getDeclaredMethods();
		//每一个method代表一个方法信息
		for(Method method:ary) {
			//获取方法的详细信息
			System.out.println(method);
			System.out.println(method.getName());
			//检查一个字符串是否以test开头
			String name=method.getName();
			if(name.startsWith("test")) {
				System.out.println("已test开头");
			}
		}
	}
}

五、动态执行方法

invoke：调用语法：method.invoke(执行方法的对象，传递的参数)

必须在对象上执行一个非静态方法，调用方法时候必须有对象。

package demo;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Scanner;

/**
 * 执行一个类中全部以test为开头的方法
 * @author LvChaoZhang
 *
 */
public class Demo2 {
	@SuppressWarnings("resource")
	public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException ,InvocationTargetException, InstantiationException {
		//动态加载类
		Scanner in = new Scanner(System.in);
		System.out.print("请输入类名");
		String className = in.nextLine();
		Class class1 = Class.forName(className);
		//动态获取类的全部方法信息
		Method[] methods = class1.getDeclaredMethods();
		//迭代全部方法查找以test为开头的方法
		Object obj=class1.newInstance();
		for(Method method:methods) {
			String name=method.getName();
			if(name.startsWith("test")) {
				//动态执行方法
				method.invoke(obj);
			}
		}
	}
}

六、执行私有方法

public class Demo3 {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		Scanner in=new Scanner(System.in);
		System.out.println("输入类名:");
		String className=in.nextLine();
		Class class1 = Class.forName(className);
		//1.找到demo方法
		//Class提供了根据方法签名找到指定方法信息的API
		String name="demo";//方法名
		//类型列表Class[] String.class 表示字符串的类型  int.class表示int类型
		Class[] types= {String.class,int.class};
		//根据方法签名在class1查找方法信息
		Method method = class1.getDeclaredMethod(name, types);
		//找到了私有方法
		System.out.println(method);
		//执行私有方法
		method.setAccessible(true);
		Object object = class1.newInstance();
		Object object2 = method.invoke(object, "Tom",12);
		System.out.println(object2);
	}
}

七、反射用途

1.eclipse中解析类的结构使用了反射

2.JUinit识别被测试方法使用了反射

JUnit3利用反射查找test开头的方法

JUnit4利用反射解析@Test查找测试方法

3.Spring管理Bean对象，注入Bean属性使用了反射

利用反射创建Bean对象实例

利用反射注入Bean的属性

4.注解的解析使用了反射

案例：

package demo;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface Demo {

}

package demo;
/**
 * 执行一个类中全部以@Demo标注的方法
 * @author LvChaoZhang
 *
 */
public class TestCase {
	@Demo
	public void hello() {
		System.out.println("hello");
	}
	@Demo
	public void helloKitty() {
		System.out.println("hello Kitty");
	}
	public void test() {
		System.out.println("test");
	}
}

package demo;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Scanner;

/**
 * 动态执行一个类中全部以@Demo注解标注的方法 
 * @author LvChaoZhang
 *
 */
public class Demo4 {
	public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
		//动态加载类
		//动态获取全部方法
		//动态检查方法的注解信息
		Scanner scanner = new Scanner(System.in);
		System.out.print("类名:");
		String className = scanner.nextLine();
		Class class1 = Class.forName(className);
		Method[] methods = class1.getDeclaredMethods();
		Object obj =class1.newInstance();
		for(Method method:methods) {
			//检查一个方法的注解信息
			//method.getAnnotation(被检查的注解类型)
			//返回注解类型，如果为空，表示没有注解，不为空，表示找到了被检查的注解
			Demo ann = method.getAnnotation(Demo.class);
			if(ann!=null) {			
				method.invoke(obj);
			}
		}
	}
}

八、反射的例子--spring容器

ApplicationContext.xml

package demo;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class ApplicationContext {
	
	//缓存spring容器的Bean对象
	private Map<String, Object> beans=new HashMap<String, Object>();
	/*
	 * 利用配置文件初始化当前容器
	 * 利用xml配置文件，初始化全部的bean
	 */
	public ApplicationContext(String xml) throws DocumentException, IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
		//利用dom4j读取xml
		//解析xml文件内容，得到bean的类名和bean的id：
		//根据类名动态加载类并且创建对象，将对象和对应的id添加到map中
		
		//从Resource（classpath）中读取流
		InputStream in=getClass().getClassLoader().getResourceAsStream(xml);
		SAXReader reader = new SAXReader();
		Document doc = reader.read(in);
		in.close();
		//解析xml<beans><bean><bean>...
		Element root = doc.getRootElement();
		//读取根元素中全部的bean子元素
		List<Element> list = root.elements("bean");
		for(Element e:list) {
			//e就是bean元素
			String id = e.attributeValue("id");
			String className = e.attributeValue("class");
			//动态加载类，动态创建对象
			Class class1 = Class.forName(className);
			Object bean = class1.newInstance();
			beans.put(id, bean);
		}
	}
	public Object getBean(String id) {
		//根据id在map查找对象，并返回对象
		return beans.get(id);
	}
	//泛型方法：优点是可以减少一次类型转换
	public <T> T getBean(String id,Class<T> class1) {
		return (T) beans.get(id);
	}
}

spring-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>
	<bean id="foo" class="demo.Foo">
	</bean>
	<bean id="date" class="java.util.Date">
	</bean>
	<bean id="testCase" class="demo.TestCase">
	</bean>
</beans>

Demo5.java

package demo;

import java.io.IOException;

import org.dom4j.DocumentException;

public class Demo5 {
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, DocumentException, IOException {
		ApplicationContext ctx = new ApplicationContext("spring-context.xml");
		Foo foo = ctx.getBean("foo",Foo.class);
		System.out.println(foo);
	}
}