Java反射机制

Java反射----reflect.

		String action = request.getParameter("action");
		try {
			Class clazz = this.getClass();
			Class[] pTypes = new Class[] { HttpServletRequest.class, HttpServletResponse.class };// 创建方法的参数类型
			Method method = clazz.getMethod(action, pTypes);
			method.invoke(this, request, response);
		} catch (Exception e) {
			e.printStackTrace();
		}

这个机制允许运行中的程序“自省”，也可以说“自审”。

这种机制主要运用于开发者自己编写框架供其他开发人员进行二次开发。

利用reflect可以动态调用java类(对象)中的方法和属性，既然是调用就要有方法。

在这里需要用到 Class和Method这两个类。

利用Class中的 **.forName("***")、**.getClass()等方法得到所需类的对象，由于需要调用某个方法，为了避免重载的函数导致混乱的调用就一定需要知道该方法的参数类型，这样就利用 

例如：Class[] pTypes = new Class[] { HttpServletRequest.class, HttpServletResponse.class }

设置需要的参数类型的数组。现在，就该用到Method这个类了，实例化一个Method类的对象，利用之前回去的所需类的对象调用**.getMethod(action, pTypes);这个方法，并将所需的参数值和参数类型传入进去。

最后就需要利用到Method中的 

 method.invoke(this, request, response);来调用 this 对象下的 形参值为 request和response的方法

在Servlet中使用Java反射机制

Servlet的生命周期

每个Servlet文件都必须继承HttpServlet类，在Servlet底层的运行机制中，需要先运行init方法，用于初始化一下操作。

然后执行service方法，在service方法中将会判断请求是get方式的还是post方式的，然后自动执行相对应的 doGet()方法或

doPost()方法。

这样，只要写一个公共的BaseServlet文件，将service方法重写，然后在每个Servlet中继承这个BaseServlet文件，即

可省去在每个Servlet中都需要写的doGet()方法和doPost()方法，减少了代码量，又增加的程序的可读性。

//BaseServlet.java

public class BaseServlet extends HttpServlet {

	protected void service(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		String action = request.getParameter("action");
		//action = doLogin;
		try {
			Class clazz = this.getClass();
			Class[] pTypes = new Class[] { HttpServletRequest.class, HttpServletResponse.class };
			Method method = clazz.getMethod(action, pTypes);
			method.invoke(this, request, response);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

并且，这样可以省去很多的if  else判断来确定需要调用的方法。

Pay attention!

注意：

为什么执行每个Servlet文件都会先执行BaseServlet中的service方法呢？

这就涉及到面向对象中多态方面的知识点了。

例如

public class A{
	public void A(){
              System.out.println("A..."); 
       }
       public void  C(){
              System.out.println("A...C"); 
      }
}
public class B extends A{
	public void B(){
                System.out.println("B..."); 
       }
       public void  C(){
              System.out.println("B...C"); 
      }
}
public class Test{
      	B b = new B();
        b.C();
}

在这个例子中，创建了一个B类的对象，那么会得到什么样的输出呢？

A...

B...

这样就可以得出一个结论，就是：

如果一个类(子类)继承到另外一个类(父类)，那么在创建一个子类的对象的时候，系统会自动为你创建一个父类的对象，所以一定会先调用父类的构造方法，然后再调用子类的构造方法。

用一个通俗的方法解释就是： 没有爸爸，哪来的儿子呢？

接下来 b.C()会输出什么呢？

B...C

我们可以得出的另外一个结论就是：

如果子类中有和父类重名的方法，那么在创建的子类对象调用该方法的时候，调用的是子类的方法，而不是父类的方法。