Spring控制反转
https://blog.csdn.net/qq_41376740/article/details/82454121
深入理解Java反射
https://www.cnblogs.com/luoxn28/p/5686794.html
一、什么是反射?
在运行状态中,对于任意一个类,都能够获取到这个类的所有属性和方法,对于任意一个对象,都能够调用它的任意一个方法和属性(包括私有的方法和属性),这种动态获取的信息以及动态调用对象的方法的功能就称为java语言的反射机制。通俗点讲,通过反射,该类对我们来说是完全透明的,想要获取任何东西都可以。
想要使用反射机制,就必须要先获取到该类的字节码文件对象(.class),通过字节码文件对象,就能够通过该类中的方法获取到我们想要的所有信息(方法,属性,类名,父类名,实现的所有接口等等),每一个类对应着一个字节码文件也就对应着一个Class类型的对象,也就是字节码文件对象。
获取字节码文件对象的三种方式。
1、Class clazz1 = Class.forName(“全限定类名”); //通过Class类中的静态方法forName,直接获取到一个类的字节码文件对象,此时该类还是源文件阶段,并没有变为字节码文件。
2、Class clazz2 = Person.class; //当类被加载成.class文件时,此时Person类变成了.class,在获取该字节码文件对象,也就是获取自己, 该类处于字节码阶段。
3、Class clazz3 = p.getClass(); //通过类的实例获取该类的字节码文件对象,该类处于创建对象阶段
有了字节码文件对象才能获得类中所有的信息,我们在使用反射获取信息时,也要考虑使用上面哪种方式获取字节码对象合理,视不同情况而定。下面介绍Class类的功能。
二、反射机制能够获取哪些信息?Class类的API详解。
2.1、通过字节码对象创建实例对象(无参创建实例)
Class class1 = Class.forName("Test.Hero");
Hero hero1 = (Hero) class1.newInstance();
2.2、获取指定构造器方法。constructor 如果没有无参构造,只有有参构造如何创建实例呢?看下面(有参创建实例)
Class class1 = Class.forName("Test.Hero");
Constructor constructor = class1.getConstructor(int.class,String.class);
Hero hero2 = (Hero) constructor.newInstance(1,"123");
class Hero{
String name;
public Hero(int i,String name) {
this.name = name;
}
}
总结上面创建实例对象:Class类的newInstance()方法是使用该类无参的构造函数创建对象, 如果一个类没有无参的构造函数, 就不能这样创建了,可以调用Class类的getConstructor(int.class,String.class)方法获取一个指定的构造函数然后再调用Constructor类的newInstance(1,“123”)方法创建对象。
获取全部构造方法
Class class1 = Class.forName("Test1.Hero");
Constructor[] constructor = class1.getConstructors();
for(int i = 0; i < constructor.length;i++) {
System.out.println(constructor[i].getName());
}
2.3、获取成员变量并使用 Field对象
Class class2 = Class.forName("Test1.Hero");
Field field = class2.getDeclaredField("name");
Hero hero = (Hero) class2.newInstance();
field.setAccessible(true);
field.set(hero, "xusong");
System.out.println(field.get(hero));//如果是int类型,是getInt()方法
Class.getField(String)方法可以获取类中的指定字段(可见的), 如果是私有的可以用getDeclaedField(“name”)方法获取,通过set(obj, “李四”)方法可以设置指定对象上该字段的值, 如果是私有的需要先调用setAccessible(true)设置访问权限,用获取的指定的字段调用get(obj)可以获取指定对象中该字段的值
获取全部成员变量
Class class2 = Class.forName("Test1.Hero");
Field[] field = class2.getDeclaredFields();
Hero hero = (Hero) class2.newInstance();
hero.setId(13);
hero.setName("xs");
for(int i = 0; i < field.length;i++) {
field[i].setAccessible(true);
System.out.println(field[i].get(hero));
}
2.4、获得方法并使用 Method
Class class2 = Class.forName("Test1.Hero");
Method method = class2.getDeclaredMethod("getId",String.class);
Hero hero = (Hero) class2.newInstance();
hero.setId(13);
hero.setName("xs");
method.setAccessible(true);
method.invoke(hero,"1");
/*for(int i = 0; i < field.length;i++) {
field[i].setAccessible(true);
System.out.println(field[i].get(hero));
}*/
Class class3 = Class.forName("Test1.Hero");
Method method2 = class3.getDeclaredMethod("cat", String.class);
method2.setAccessible(true);
method2.invoke(hero, "asd");
Class.getMethod(String, Class…) (获取父类和接口方法)和 Class.getDeclaredMethod(String, Class…)(获取私有方法)方法可以获取类中的指定方法。如果为私有方法,则需要打开一个权限。setAccessible(true);
用invoke(Object, Object…)可以调用该方法,
跟上面同理,也能一次性获得所有的方法
Class class2 = Class.forName("Test1.Hero");
Method[] method = class2.getDeclaredMethods();
Hero hero = (Hero) class2.newInstance();
hero.setId(13);
hero.setName("xs");
for(int i = 0 ; i< method.length;i++) {
method[i].setAccessible(true);
System.out.print(method[i].getName()+":");
Class<?>[] xClasses = method[i].getParameterTypes();
for(int j = 0 ;j < xClasses.length;j++) {
System.out.print(xClasses[j].getName()+",");
}
System.out.println();
}
2.5、获得该类的所有接口
Class[] getInterfaces():确定此对象所表示的类或接口实现的接口
返回值:接口的字节码文件对象的数组
2.6、获取指定资源的输入流
InputStream getResourceAsStream(String name)
return:一个 InputStream 对象;如果找不到带有该名称的资源,则返回 null
参数:所需资源的名称,如果以"/“开始,则绝对资源名为”/"后面的一部分。
2.7、动态代理的概述和实现
动态代理:一种设计模式,其非常简单,很容易理解,你自己可以做这件事,但是觉得自己做非常麻烦或者不方便,所以就叫一个另一个人(代理)来帮你做这个事情,而你就不用管了,这就是动态代理。举个例子,买火车票叫人代买。
在程序运行过程中产生的这个对象,而程序运行过程中产生对象其实就是我们刚才反射讲解的内容,所以,动态代理其实就是通过反射来生成一个代理。
在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口,通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib,Proxy类中的方法创建动态代理类对象。
分三步,但是注意JDK提供的代理正能针对接口做代理,也就是下面的第二步返回的必须要是一个接口。
1、new出代理对象,通过实现InvacationHandler接口,然后new出代理对象来。
2、通过Proxy类中的静态方法newProxyInstance,来将代理对象假装成那个被代理的对象,也就是如果叫人帮我们代买火车票一样,那个代理就假装成我们自己本人
3、执行方法,代理成功
public interface Student {
public void login();
public void submit();
}
public class StudentImp implements Student{
@Override
public void login() {
// TODO Auto-generated method stub
System.out.println("登录");
}
@Override
public void submit() {
// TODO Auto-generated method stub
System.out.println("提交");
}
}
public class MyInvocationHander implements InvocationHandler{
private Object proxy;
public MyInvocationHander(Object proxy) {
this.proxy = proxy;
}
@Override
public Object invoke(Object proxy,Method method,Object[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{
System.out.println("权限校验");
method.invoke(proxy, args);
System.out.println("日志记录");
return null;
}
}
public class Test {
public static void main(String[] args) {
StudentImp proxy = new StudentImp();
MyInvocationHander myInvocationHander = new MyInvocationHander(proxy);
Student student = (Student) Proxy.newProxyInstance(Student.class.getClassLoader(), new Class[] {Student.class}, myInvocationHander);
student.login();
student.submit();
}
}
注意newProxyInstance的三个参数,第一个,类加载器,第二个被代理对象的接口,第三个代理对象。
2.8、还有很多方法,比如获得类加载器,等等。具体还需要别的,就通过查看API文档来解决。
三、反射机制的应用实例
3.1、利用反射,在泛型为int的arryaList集合中存放一个String类型的对象
原理:集合中的泛型只在编译器有效,而到了运行期,泛型则会失效。
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
// list.add("qwe");编译错误
System.out.println(list);
Class class1 = list.getClass();
Method method = class1.getMethod("add", Object.class);
method.invoke(list, "qwe");
System.out.println(list);
3.2、利用反射,简化编写Servlet的个数。
什么意思呢?每当我们写一个功能时,就需要写一个对应的Servlet,导致最后Servlet有很多,自己都看不过来,所以对其进行了优化,两种方式,
3.2.1、每次从页面传过来一个参数,method=“xxx”; 然后编写一个Servlet,获得其参数method的值,进行判断,如果是add,则调用add方法,如果是delete,则调用delete方法,这样就可以写在一个servlet中实现所有的功能了。
jsp文件:
<form action="MyServlet">
请输入方法:<input type = "text" name = "method">
<input type = "submit" value = "提交">
</form>
Servlet文件:
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class MyServlet
*/
@WebServlet("/MyServlet")
public class MyServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
public MyServlet() {
super();
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String name = (String) request.getParameter("method");
if("add".equals(name)) {
add(request,response);
}else if("delete".equals(name)) {
delete(request,response);
}
}
public void add(HttpServletRequest request, HttpServletResponse response) {
System.out.println("执行add方法");
}
public void delete(HttpServletRequest request, HttpServletResponse response) {
System.out.println("执行delete方法");
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}
3.2.2、利用反射
编写一个BaseServlet继承HttpServlet,这是一个通用的BaseServlet。需要明白servlet的生命周期
编写具体实现的方法servlet类。
public class BaseServlet extends HttpServlet{
@Override
protected void service(HttpServletRequest arg0, HttpServletResponse arg1) throws ServletException, IOException {
System.out.println("BaseServlet的servlet方法1");
String name = arg0.getParameter("method");
Class class1 = this.getClass();
Method method = null;
try {
method = class1.getMethod(name,HttpServletRequest.class,HttpServletResponse.class);
} catch (NoSuchMethodException | SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String string = null;
try {
string = (String)method.invoke(this, arg0,arg1);
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(string != null) {
arg0.getRequestDispatcher(string).forward(arg0, arg1);
}
System.out.println("BaseServlet的servlet方法2");
}
}
编写具体实现的方法servlet类。MySerlvet001 extends BaseServlet
public class MyServlet1 extends BaseServlet{
public String add(HttpServletRequest request, HttpServletResponse response) {
System.out.println("执行add方法");
return "NewFile2.jsp";
}
public String delete(HttpServletRequest request, HttpServletResponse response) throws IOException {
System.out.println("执行delete方法");
response.sendRedirect("NewFile2.jsp");
return null;
}
public String findAll(HttpServletRequest request, HttpServletResponse response) {
System.out.println("执行findAll方法");
return null;
}
}
解释:需要明白servlet的生命周期,也就是service方法,因为是servlet,所以在访问的时候,会经过service方法,而子类MyServlet001中并没有,所以就到父类BaseServlet中找,发现有,然后获取参数即知道了需要调用什么方法,因为方法的编写都在子类中,所以通过反射,获取到子类中对应的方法并运行,其中需要注意的是this这个参数在BaseServlet中的用法。需要理解它。才能理解我们这个程序。
四、总结
反射基本上就这样讲完了,其实就是对其一些api进行讲解,不懂的就查看API,重要的思想,就要在实际中遇到了才能得到更好的理解。先这样过一遍,零零碎碎的知识。