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

This article introduces the knowledge of "how to write a simple mvc framework". In the operation of practical cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Define an annotation Request

Related codes:

Import com.hebaibai.amvc.RequestType;import java.lang.annotation.*;/** * indicates that the method in this class with the @ Request annotation is mapped to a http address. * * @ author hjx * / @ Documented@Target ({ElementType.METHOD, ElementType.TYPE}) @ Retention (RetentionPolicy.RUNTIME) public @ interface Request {/ * request type * support GET,POST,DELETE,PUT * * @ return * / RequestType [] type () default {RequestType.GET, RequestType.POST, RequestType.DELETE, RequestType.PUT} When the / * * request address * is added to the class, the value in value is added before the value of @ Request.value () on other methods as the base address. * * @ return * / String value () default "/";}

To define an annotation, you need to use several things:

1:@interface: indicates that this class is an annotation.

2:@Retention: the retention policy of comments. There are several value ranges:

Code description @ Retention (RetentionPolicy.SOURCE) annotations exist only in source code @ Retention (RetentionPolicy.CLASS) annotations exist in class bytecode files @ Retention (RetentionPolicy.RUNTIME) annotations exist in class bytecode files and can be obtained by reflection at run time

Because we need to get custom annotations in the program, we use: RetentionPolicy.RUNTIME.

3:@Target: action target, indicating where comments can be added. The range of values are:

Code description @ Target (ElementType.TYPE) interface, class, enumeration, annotation @ Target (ElementType.FIELD) field, constant @ Target (ElementType.METHOD) method @ Target (ElementType.PARAMETER) method parameter @ Target (ElementType.CONSTRUCTOR) constructor @ Target (ElementType.LOCAL_VARIABLE) local variable @ Target (ElementType.ANNOTATION_TYPE) Note @ Target (ElementType.PACKAGE) package

3:@Documented: the main purpose of this is to keep custom comments in the document, which is of little practical significance and is usually added.

4:default: is to give a default value to the attribute in the annotation (it looks like a method, or it could be a method, but I just call it attribute, slightly ~).

The above gives a rough description of how to define a comment, and now that the note has been written, let's talk about the usefulness of this note.

First, this comment can be added to class and method. When added to class, it means that there will be a method in this class that will be treated as a UrlMethodMapping, and then the value attribute will be used as the base address of all UrlMethodMapping in this class, and the type attribute will not work. When added to the method, it means that the method will be processed as a UrlMethodMapping, and the two attributes of the annotation play its normal role.

Now that the notes have been written, let's change the configuration file.

Modify the configuration file of the framework

All you need to do is add an attribute, and the modified configuration file looks like this:

{"annotationSupport": true, "annotationPackage": "com.hebaibai.demo.web", / / "mapping": [/ {/ / "url": "/ index", / / "requestType": [/ / "get" / /], / / "method": "index", / / "objectClass": "com.hebaibai.demo.web.IndexController", / / "paramTypes": [/ / "java.lang.String" / / "int" / /] / /} / /]}

When the 1:annotationSupport value is true, the annotation is enabled.

2:annotationPackage indicates the path of the packet that needs to be scanned.

3: because of the annotation support, in order to prevent repeated registration of UrlMethodMapping, I commented out the following configuration.

Write a method for packet scanning

This method needs to find all the eligible class under the jar file and folder in the project, and will use recursion. The code in ClassUtils.java consists of three methods, which are:

1:void getClassByPackage (String packageName, Set

This method takes two parameters, one is the package name packageName, and the other is an empty Set (not null). After the method is executed, all the class under the package will be populated into the Set. The main purpose here is to determine which types of files are in the package and deal with them according to the file type.

Note: if it is the type of jar file, the obtained filePath is as follows:

FileRod HJX Universe IdeaIUDUBUBUBUBUBUBUIDARAR. JARTHERPUR

Need to turn around and tail, and then you can eat, chicken flavor! After the treatment, it looks like this:

/ home/hjx/idea-IU/lib/idea_rt.jar

Here is the method code:

/ * find all class * * @ param packageName * @ param classes * / @ SneakyThrows ({IOException.class}) public static void getClassByPackage (String packageName, Set classes) {Assert.notNull (classes); String packagePath = packageName.replace (DOT, SLASH); Enumeration resources = ClassUtils.getClassLoader (). GetResources (packagePath); while (resources.hasMoreElements ()) {URL url = resources.nextElement (); / / File Type String protocol = url.getProtocol () String filePath = URLDecoder.decode (url.getFile (), CHARSET_UTF_8); if (TYPE_FILE.equals (protocol)) {getClassByFilePath (packageName, filePath, classes);} if (TYPE_JAR.equals (protocol)) {/ / path to intercept the file filePath = filePath.substring (filePath.indexOf (":") + 1, filePath.indexOf ("!"); getClassByJarPath (packageName, filePath, classes);}

2:void getClassByFilePath (String packageName, String filePath, Set

Find all the qualified class in the folder and use it recursively. The absolute path of the class file needs to be truncated to the fully qualified name of class, as shown in the code:

/ * Recursively find the class * * @ param packageName * @ param filePath * @ param classes * / static void getClassByFilePath (String packageName, String filePath, Set classes) {File targetFile = new File (filePath) in the folder in the folder; if (! targetFile.exists ()) {return;} if (targetFile.isDirectory ()) {File [] files = targetFile.listFiles () For (File file: files) {String path = file.getPath (); getClassByFilePath (packageName, path, classes);} else {/ / if it is a class file boolean trueClass = filePath.endsWith (CLASS_MARK); if (trueClass) {/ / extract the complete class name filePath = filePath.replace (SLASH, DOT); int I = filePath.indexOf (packageName) String className = filePath.substring (I, filePath.length ()-6); / / is not an inner class boolean notInnerClass = className.indexOf ("$") = =-1; if (notInnerClass) {/ / loads the class object Class aClass = ClassUtils.forName (className) according to the class name; if (aClass! = null) {classes.add (aClass);}

3:void getClassByJarPath (String packageName, String filePath, Set

Find all eligible class in the jar file. There's nothing to say, here's the code:

/ * find the class * * @ param packageName * @ param filePath * @ param classes * / @ SneakyThrows ({IOException.class}) static void getClassByJarPath (String packageName, String filePath, Set classes) {JarFile jarFile = new URLJarFile (new File (filePath)) in this folder in the jar file; Enumeration entries = jarFile.entries (); while (entries.hasMoreElements ()) {JarEntry jarEntry = entries.nextElement () String jarEntryName = jarEntry.getName (). Replace (SLASH, DOT); / / class boolean trueClass = jarEntryName.endsWith (CLASS_MARK) & & jarEntryName.startsWith (packageName) under package; / / not an inner class boolean notInnerClass = jarEntryName.indexOf ("$") = =-1; if (trueClass & notInnerClass) {String className = jarEntryName.substring (0, jarEntryName.length ()-6); System.out.println (className) / / load the class object Class aClass = ClassUtils.forName (className) according to the class name; if (aClass! = null) {classes.add (aClass);}

In this way, getting the class under the package name is finished.

Modify UrlMethodMappingFactory

Add a new method here:

List, take the Class object obtained after scanning the package as a parameter, and return a UrlMethodMapping collection. The code is as follows:

/ * obtain mapping * * @ param aClass * @ return * / public List getUrlMethodMappingListByClass (Class aClass) {List mappings = new ArrayList (); Request request = aClass.getDeclaredAnnotation (Request.class); if (request = = null) {return mappings;} String basePath = request.value (); for (Method classMethod: aClass.getDeclaredMethods ()) {UrlMethodMapping urlMethodMapping = getUrlMethodMappingListByMethod (classMethod); if (urlMethodMapping = = null) {continue } / / use the path added in the Request on class as the base path String url = UrlUtils.makeUrl (basePath + "/" + urlMethodMapping.getUrl ()); urlMethodMapping.setUrl (url); mappings.add (urlMethodMapping);} return mappings } / * obtain mapping by parsing Method * Note * * @ param method * @ return * / private UrlMethodMapping getUrlMethodMappingListByMethod (Method method) {Request request = method.getDeclaredAnnotation (Request.class); if (request = = null) {return null;} Class declaringClass = method.getDeclaringClass (); String path = request.value () For (char c: path.toCharArray ()) {Assert.isTrue (c! ='', declaringClass + "." + method.getName () + "request path exception:" + path + "!") Return getUrlMethodMapping (path, request.type (), declaringClass, method, method.getParameterTypes ());}

The value of value in the annotation Request is verified here, and an exception is thrown if there is a space in the middle. The main purpose of the UrlUtils.makeUrl () method is to remove the extra "/" from url. The code looks like this:

Private static final String SLASH = "/"; / * deal with url * 1: remove the adjacent and repeated "/" in the connection, * 2: if there is no "/" at the beginning of the link, add it. * 3: remove the link if there is a "/" at the end of the link. * * @ param url * @ return * / public static String makeUrl (@ NonNull String url) {char [] chars = url.toCharArray (); StringBuilder newUrl = new StringBuilder (); if (! url.startsWith (SLASH)) {newUrl.append (SLASH);} for (int I = 0; I < chars.length; ionization +) {if (I! = 0 & chars [I] = = chars [I-1] & chars [I] = ='/') {continue } if (I = = chars.length-1 & & chars [I] ='/') {continue;} newUrl.append (chars [I]);} return newUrl.toString ();}

So the factory method for getting UrlMethodMapping through annotations is finished, and let's start modifying the code that loads the framework.

Modify init in Application

Since you have added a method to get UrlMethodMapping using annotations, create a new method:

Void addApplicationUrlMappingByAnnotationConfig (JSONObject configJson). Here, get the package name in the framework configuration and do some configuration verification. The code is as follows:

/ * use annotations to load UrlMethodMapping * * @ param configJson * / private void addApplicationUrlMappingByAnnotationConfig (JSONObject configJson) {String annotationPackage = configJson.getString (ANNOTATION_PACKAGE_NODE); Assert.notNull (annotationPackage, ANNOTATION_PACKAGE_NODE + NOT_FIND); / / get the class Set classes = new HashSet (); ClassUtils.getClassByPackage (annotationPackage, classes); Iterator iterator = classes.iterator (); while (iterator.hasNext ()) {Class aClass = iterator.next () List mappings = urlMethodMappingFactory.getUrlMethodMappingListByClass (aClass); if (mappings.size () = = 0) {continue;} for (UrlMethodMapping mapping: mappings) {addApplicationUrlMapping (mapping);}

After that, extract the previously written code that reads the urlMappin generated by the json configuration, and write a separate method:

Void addApplicationUrlMappingByJsonConfig (JSONObject configJson), which makes the function of each method in the code independent and looks neat and clear. The code is as follows:

/ * use file configuration to load UrlMethodMapping * if it is not found in the configuration, it will not be executed. * * @ param configJson * / private void addApplicationUrlMappingByJsonConfig (JSONObject configJson) {JSONArray jsonArray = configJson.getJSONArray (MAPPING_NODE); if (jsonArray = = null | | jsonArray.size () = 0) {return;} for (int I = 0; I < jsonArray.size (); iTunes +) {UrlMethodMapping mapping = urlMethodMappingFactory.getUrlMethodMappingByJson (jsonArray.getJSONObject (I)); addApplicationUrlMapping (mapping);}}

Finally, all you have to do is modify init () a little bit, which looks like this:

/ * initialize configuration * / @ SneakyThrows (IOException.class) protected void init () {String configFileName = applicationName + ".json"; InputStream inputStream = ClassUtils.getClassLoader () .getResourceAsStream (configFileName); byte [] bytes = new byte [inputStream.available ()]; inputStream.read (bytes); String config = new String (bytes, "utf-8"); / / Application configuration JSONObject configJson = JSONObject.parseObject (config) / / TODO: the factory class that generates the object (first defaults to new a new object each time) this.objectFactory = new AlwaysNewObjectFactory (); / / TODO: get the class with different input parameter names (currently defaults to asm) urlMethodMappingFactory.setParamNameGetter (new AsmParamNameGetter ()); / / load addApplicationUrlMappingByJsonConfig (configJson) through file configuration; / / whether to enable annotation support Boolean annotationSupport = configJson.getBoolean (ANNOTATION_SUPPORT_NODE) Assert.notNull (annotationSupport, ANNOTATION_SUPPORT_NODE + NOT_FIND); if (annotationSupport) {addApplicationUrlMappingByAnnotationConfig (configJson);}} "how to write a simple mvc framework" ends here, thank you for 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.