Shulou(Shulou.com)06/02 Report--

I hope you can read it carefully and be able to achieve something!

Throw new RenderTemplate (template, templateBinding.data)

Here we use the constructor of RenderTemplate to new a RenderTemplate object

And then. It's out.

To see what's thrown here, let's go in and take a look at the implementation of the RenderTemplate class:

Public class RenderTemplate extends Result {

Look at Result again.

Public abstract class Result extends RuntimeException {

It turns out that RenderTemplate is a RuntimeException

@

About RuntimeException

Http://java.sun.com/docs/books/tutorial/essential/exceptions/runtime.html

When it comes to RuntimeException, we are probably most familiar with NullPointerException, which is thrown when a null pointer is accessed due to a programming error.

Let's write the simplest code, that's all.

Public class TestString {

Public static void main (String [] args) {

TestNull (null)

}

Public static void testNull (String a) {

A.charAt (0)

}

}

A null is passed to testNull in the main method, but the charAt method requires String obj, and at this time it is null, triggering NullPointerException to exit the program.

Take a look at console's message:

Exception in thread "main" java.lang.NullPointerException

At com.langtest.TestString.testNull (TestString.java:9)

At com.langtest.TestString.main (TestString.java:6)

The main thread throws a null pointer exception, and the program does not have the logic to handle the exception when it arrives at main, causing the program to exit and print error messages on the console.

The exception object after throw is thrown back along the method stack (that is, the method that calls this method), and if no exception has been intercepted, it is thrown all the way to the bottom of the stack.

Since it is an exception, the next step is to throw it to the superior caller and go down, and we find out where the "non-abnormal exception" was intercepted. no, no, no. (compared to the extremely cautious statement on the runtime on JAVA's official website, this is a bit of a # #, or because I'm too lame to understand the cleverness of using it.)

After Debug F6, the program goes to the catch statement in the invoke method of play.mvc.ActionInvoker.

Result actionResult = null; ControllerInstrumentation.initActionCall (); try {Java.invokeStatic (actionMethod, getActionMethodArgs (actionMethod));} catch (InvocationTargetException ex) {/ / It's a Result? (expected) if (ex.getTargetException () instanceof Result) {actionResult = (Result) ex.getTargetException ();} else {/ / @ Catch Object [] args = new Object [] {ex.getTargetException ()}; List catches = Java.findAllAnnotatedMethods (Controller.getControllerClass (), Catch.class); Collections.sort (catches, new Comparator () {

Try... In the catch block:

Try block: using JAVA's reflection mechanism invoke static method, this is actually invoke the index method we wrote in the controller.

@

If you don't understand reflection, you must first understand that the source code of any framework and the common interface to implement some common object instantiation or method calls basically use reflection = = #

Make up the most vulgar way to understand reflection to help students understand reflection (may not be accurate):

Reflection said, "I am an omnipotent object generator and method caller. As long as you give me the class name, method name and corresponding parameters, I can help you new out the object or call the corresponding method."

But everything is a double-edged sword, the ability of reflection is too powerful, you can generate and manipulate objects arbitrarily, so it gives programmers the possibility of Do evil.

The design of JAVA itself is as safe as possible, there is no pointer operation, the virtual machine helps organize memory, and the exception mechanism makes it easier to make robust programs, so I think the reflection mechanism is still not a small challenge for the overall design idea of JAVA.

The two parameters of the invokeStatic method here can be seen using the watch function of the debug tool

ActionMethod is the way to be invoke by reflection.

Catch block: intercepts InvocationTargetException, this exception is when the method throw exception of invoke by reflection, the reflection mechanism will trigger the exception and save the exception from the upper-level throw as the taget variable of the exception.

The process of this example is that the Play framework invoke the index method (Application.index ()) in the controller by reflection, then go to render (), call the renderTemplate method in the render method, and throw the RenderTemplate exception (sweat again) in this method. The reflection mechanism finds that an exception is thrown, then throws the InvocationTargetException exception, and stores the RenderTemplate in the target variable of InvocationTargetException. Play catch this exception using the reflection invoke method. Then take out the RenderTemplate referenced by target and get the template completed by render.

From Java Api

InvocationTargetException is a checked exception that wraps an exception thrown by an invoked method or constructor.

@

Although I understand the purpose of this weird code here, it is actually just the beginning of learning. I think the introduction to learning is to understand, to be able to apply is the second, to be able to think critically about something (to know what is good or bad, to know where to apply at a higher level).

At any time, we must have the spirit of going back to the root. Here are a few questions:

Why is the framework so designed by ①?

If ② can, think of an alternative implementation, and compare it with this one to see why you use such a weird design.

ActionInvoker source code analysis

Now that Debug is in ActionInvoker, take a look at this class:

By the comments on the class:

Invoke an action after an HTTP request.

This class is based on the corresponding action of Http request Invoke.

This class has no member variables and functions, only three common static methods, which are (explained by annotated methods):

Public class ActionInvoker {/ / the main function of the response request, in fact, the main purpose of the ActionInvoker class is to place this method, so this class also does not have an object-oriented class. This class focuses on the logical public static void invoke (Http.Request request, Http.Response response) {/ / in response to the HTTP request to get the corresponding method through the passed action (ie:Application.index). So that when reflecting, invoke uses public static Object [] getActionMethod (String fullAction) {/ / to fetch the parameters of the method from the method, and both get methods are calling services for reflection. Public static Object [] getActionMethodArgs (Method method) throws Exception {}

It can be seen that invoke is the core control for the operation of the Play framework (it is said that the core is because the main responsibility of the web framework is to complete the process of processing HTTP requests).

To understand the core running mechanism of Play, we disconnect the debug thread, set a breakpoint on the invoke method, and run Debug again.

Enter the method, and the two parameters passed in are passed by the execute method of the inner class MinaInvocation of the previous caller HttpHandler.

Public static void invoke (Http.Request request, Http.Response response) {Monitor monitor = null; try {if (! Play.started) {return;} Http.Request.current.set (request); Http.Response.current.set (response); Scope.Params.current.set (new Scope.Params ()) Scope.RenderArgs.current.set (new Scope.RenderArgs ()); Scope.Session.current.set (Scope.Session.restore ()); Scope.Flash.current.set (Scope.Flash.restore ()); }

First new a Monitor for monitoring.

Then determine whether the Play is started.

This is followed by a series of xxx.xxx.current.set methods

The current variables here are all ThreadLocal:

Public static ThreadLocal current = new ThreadLocal ()

@

/ / for Java development, ThreadLocal is a concept that must be understood. / / ThreadLocal is an object, but the set method of ThreadLocal does not store things in the ThreadLocal object / * Sets the current thread's copy of this thread-local variable * to the specified value. Many applications will have no need for * this functionality, relying solely on the {@ link # initialValue} * method to set the values of thread-locals. * * @ param value the value to be stored in the current threads' copy of * this thread-local. * / public void set (T value) {Thread t = Thread.currentThread (); ThreadLocalMap map = getMap (t); if (map! = null) map.set (this, value); else createMap (t, value);} / / as you can see above, the set method first gets the current Thread object, and then the ThreadLocalMap of the thread. If map is not empty, write to map, take the current ThreadLocal object as key, and store the passed value in map. / / this is only an introduction, and it may be difficult to understand what has no concept. After all, ThreadLocal is not something that I can explain in a few words. I suggest students to read more, use more and experience more.

After putting references to Request,Response and Scope into the current thread, you actually complete the initialization process of the thread.

/ / 1. Route and resolve format if not already done if (request.action = = null) {for (PlayPlugin plugin: Play.plugins) {plugin.routeRequest (request);} Router.route (request);} request.resolveFormat ()

Router.route (request); find the corresponding action in router based on the requested URL and assign the name of action to request.action.

Request.resolveFormat (); at this time, format in request is html, and if format in request is null, the corresponding format is obtained according to the http header.

Go down:

/ / 2. Find the action method Method actionMethod = null; try {Object [] ca = getActionMethod (request.action); actionMethod = (Method) ca [1]; request.controller = ((Class) ca [0]). GetName (). Substring (12); request.actionMethod = actionMethod.getName (); request.action = request.controller + "." + request.actionMethod; request.invokedMethod = actionMethod } catch (ActionNotFoundException e) {throw new NotFound (String.format ("% s action not found", e.getAction ();}

GetActionMethod (request.action) mentioned earlier that the String of request.action is used to get the obj array containing the corresponding Method object of the application.index () method.

After getting the Method object (ca [1], ca [0] holds the Class object corresponding to controllers.Application), assign the member variables related to Action in the request object.

Here: the request.controller value is Application, the request.actionMethod value is index, and the next two variables, one is the action spelled out from the first two, and the other is the Method object passed in.

Continue: the following code is the parameters used to merge the action:

/ 3. Prepare request params Scope.Params.current (). _ _ mergeWith (request.routeArgs); / / add parameters from the URI querystring Scope.Params.current (). _ mergeWith (UrlEncodedParser.parseQueryString (new ByteArrayInputStream (request.querystring.getBytes ("utf-8"); Lang.resolvefrom (request)

RouteArgs is an additional http parameter in route:

/ * Additinal HTTP params extracted from route * / public Map routeArgs

The following Lang.resolvefrom (request) does not take a closer look at the implementation. It is related to i18n in the package name of Lang. Later, let's focus on the implementation of internationalization (continue to owe).

In the following code, we see the shocking fragment again.

/ / 4. Easy debugging... If (Play.mode = = Play.Mode.DEV) {Controller.class.getDeclaredField ("params") .set (null, Scope.Params.current ()); Controller.class.getDeclaredField ("request") .set (null, Http.Request.current ()); Controller.class.getDeclaredField ("response") .set (null, Http.Response.current ()); Controller.class.getDeclaredField ("session") .set (null, Scope.Session.current ()) Controller.class.getDeclaredField ("flash") .set (null, Scope.Flash.current ()); Controller.class.getDeclaredField ("renderArgs") .set (null, Scope.RenderArgs.current (); Controller.class.getDeclaredField ("validation") .set (null, Java.invokeStatic (Validation.class, "current"));}

!

Controller.class.getDeclaredField ("xxx") .set (null,xxx)

Here Play uses reflection to force the value of the protected static variable in Controller!

@

If it is temporarily understood as a strategy to implement the result of the program as a runtime exception and throw it directly after the result is produced, it is simply rude and very different from the teachings in the various classic books we read.

But also set their own access to variables and then violently crack the assignment.

However, the author added a sentence / / 4. Easy debugging to the note, which may be a helpless explanation for this practice.

It reminds me of the phrase "keywords in Java are only for compilers."

But when you think about it, this may also be one of the features of open source projects. If you write this kind of code in an enterprise and directly destroy the framework, you don't know how black the boss's face will be-|.

There is so much nonsense here because we students often like alternative codes at school, so our younger brothers and sisters need to be eye-catching:

Think carefully

Do we admire the students who have worked out the iTunes 3 ~ (th) k = (ionization +) + (+ + I) + (ionization +) when we first started programming?

Have we ever admired the if else that can read 16 layers of nesting and whose variable names have no meaning?

Do we have great respect for students who can write dizzy pointer operations?

You can play by yourself, but if you work in the future, the life of a code may be accompanied by the life of the enterprise.

Writing some alternative code has many consequences, the most obvious of which is that it is difficult to maintain.

As for the dangerous behavior like modifying private variables, although it is more cool, it is not advocated for individual learning, and try not to inculcate yourself with the idea of solving problems in abnormal ways. But here, it doesn't mean that play is bad, but for us, the ability to understand the language at the student stage is still too poor, and we need to keep on learning. Over time, it is certainly a good thing to have technical critical thinking and be able to use these java features properly.

I digress again and return to the subject. This part is to judge the mode of play (play has two running modes: DEV and actual running mode, and the file configuration is switched in config). In the development mode, request,response and scope are directly assigned to the corresponding static variables of the Cotroller class.

It may be convenient to access these values when actually using the invoke controller.

The function of the class ControllerInstrumentation is to operate on the flag bit allow. Allow is a ThreadLocal, and its set value stores its reference in the current Thread. In other words, Thread is actually marked.

Public static class ControllerInstrumentation {public static boolean isActionCallAllowed () {return allow.get ();} public static void initActionCall () {allow.set (true);} public static void stopActionCall () {allow.set (false);} static ThreadLocal allow = new ThreadLocal ();}

The beforeActionInvocation method is what Plugin does before action, and here I take a look at all the empty implementations.

# Open monitor

/ / Monitoring monitor = MonitorFactory.start (request.action + "()")

# find the method marked @ Before Annotation and execute it before action invoke.

/ 5. Invoke the action try {/ / @ Before List befores = Java.findAllAnnotatedMethods (Controller.getControllerClass (), Before.class); Collections.sort (befores, new Comparator () {public int compare (Method M1, Method m2) {Before before1 = m1.getAnnotation (Before.class); Before before2 = m2.getAnnotation (Before.class); return before1.priority ()-before2.priority () })

The Controller.getControllerClass () method returns class controllers.Application.

Java.findAllAnnotatedMethods () finds all the methods with @ Before Annotation.

Then sort the Method in befores according to the priority of each method.

The comparator is implemented here using anonymous inner classes that are sorted by Before's priority.

@ Retention (RetentionPolicy.RUNTIME) @ Target (ElementType.METHOD) public @ interface Before {/ * Does not intercept these actions * / String [] unless () default {}; / * * Interceptor priority (0 is high priority) * / int priority () default 0;}

In addition to the member variable priority, Annotation Before also has a String array variable unless, which holds the name of action, indicating that these action are not intercepted.

Look at the implementation of this part.

ControllerInstrumentation.stopActionCall (); / / traverses the method for (Method before: befores) containing Before Annotation {/ / fetches the unless array of the current Before action String [] unless = before.getAnnotation (Before.class). Unless (); / / sets the flag bit boolean skip = false / / traversing the unless array for (String un: unless) {if (! un.contains (".")) {un = before.getDeclaringClass () .getName () .substring (12) + "." + un } / / if unless has the same name as the currently called action, the flag bit skip is set to true and exit the loop if (un.equals (request.action)) {skip = true; break }} / / if skip is false, call the before method if (! skip) {/ / add a protection to determine whether the called method is static, because invokeStatic.. is used below

After passing the Before interceptor, further down is where we saw earlier where the Action was actually executed:

/ / declare a Result variable to hold the structure of the method call Result actionResult = null; / / contrary to the previous stopActionCall (), call initActionCall () here to set allow to true, which means to allow this thread to invoke method ControllerInstrumentation.initActionCall (); try {/ / invoke action Java.invokeStatic (actionMethod, getActionMethodArgs (actionMethod)) } catch (InvocationTargetException ex) {/ / It's a Result? (expected) if (ex.getTargetException () instanceof Result) {/ / get the Result actionResult = (Result) ex.getTargetException () returned after calling action; / / else is not covered in this example, skip regardless} else {.

After executing the action, the following code part is the After interceptor, which is basically the same as Before, and will not be discussed.

Then close the monitor.

After that. Continue to throw the return result up.

/ / Ok, rethrow the original action result if (actionResult! = null) {throw actionResult;} throw new NoResult (); catch (InvocationTargetException ex) {/ / It's a Result? (expected) if (ex.getTargetException () instanceof Result) {throw (Result) ex.getTargetException ();} / / Rethrow the enclosed exception if (ex.getTargetException () instanceof PlayException) {throw (PlayException) ex.getTargetException () } StackTraceElement element = PlayException.getInterestingStrackTraceElement (ex.getTargetException ()); if (element! = null) {throw new JavaExecutionException (Play.classes.getApplicationClass (element.getClassName ()), element.getLineNumber (), ex.getTargetException ()) } throw new JavaExecutionException (Http.Request.current (). Action, ex);}

All the way to the first try..catch block of the invoke method.

Public static void invoke (Http.Request request, Http.Response response) {Monitor monitor = null; try {. } catch (Result result) {/ / traverses the onActionInvocationResult () method that executes plugin, and processes the result for (PlayPlugin plugin: Play.plugins) {plugin.onActionInvocationResult (result);} / Ok there is a result to apply / / Save session & flash scope now Scope.Session.current () .save () Scope.Flash.current () .save (); / / the apply method of the corresponding result, where result is actually a RenderTemplate object, and its apply method produces the final HTML output result.apply (request, response) / / it can be seen here that the function of Plugin is very flexible, because it appears at almost every stage of the action life cycle. In fact, PlugIn can be found almost everywhere. Otherwise, how can it be called a framework plug-in = # for (PlayPlugin plugin: Play.plugins) {plugin.afterActionInvocation ();}

Finally, take a look at the RenderTemplate class

Public class RenderTemplate extends Result {private Template template; private String content; Map args; public RenderTemplate (Template template, Map args) {this.template = template; this.args = args; this.content = template.render (args) } / / the apply method executes the code public void apply (Request request, Response response) {try {setContentTypeIfNotSet (response, MimeTypes.getContentType (template.name, "text/plain")) after the invoke method intercepts the template.name and confirms that it is the desired return result; response.out.write (content.getBytes ("utf-8")) } catch (Exception e) {throw new UnexpectedException (e);}

/ / @ Finally / / I don't know the significance of this if judgment. When I was in get action, I was looking for the action method of Application (Controller Class). How can I get null here? I'll explain it later when I understand it better. If (Controller.getControllerClass ()! = null) {try {List allFinally = Java.findAllAnnotatedMethods (Controller.getControllerClass (), Finally.class); / / followed by @ before and @ after}

However, some core codes related to the play hot loading function are found, as follows:

Byte [] bc = BytecodeCache.getBytecode (name, applicationClass.javaSource); if (bc! = null) {applicationClass.enhancedByteCode = bc; applicationClass.javaClass = defineClass (applicationClass.name, applicationClass.enhancedByteCode, 0, applicationClass.enhancedByteCode.length, protectionDomain); resolveClass (applicationClass.javaClass) Logger.trace ("% sms to load class% s from cache", System.currentTimeMillis ()-start, name); return applicationClass.javaClass;}

You can probably see that play can dynamically generate java class by reading the java source code directly. This should be related to the fact that Play modifies the code to run without compilation.

Summary: at this point, you have learned the modules of the Play framework for handling and responding to requests at two levels.

The innermost layer is the Controller layer, which is Application, and here is the action of the final invoke of Request.

The outer layer is ActionInvoker, which is responsible for judging the action to be called through Http Request and executing the call. In addition, it also acts as an interceptor for action to intercept and execute methods with corresponding Annotation in several stages of the life cycle of action, Before,After and Finally, respectively. In addition to the above two functions, ActionInvoker is also responsible for implementing PlugIn. You can see that the responsibility of ActionInvoker is to control action.

It is easy to think that there should be another layer outside the ActionInvoker, which is responsible for actually getting the client's HTTP Request and transferring it to ActionInvoker. Yes, this class is HttpHandler, which I will analyze in detail in the next article.

Draw a picture to show the process of entering Play from Request on the client to returning to Response and jumping out of Play

This is the end of the content of "how to do ActionInvoker source code analysis". Thank you for your reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.