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

Mybatis source code how to analyze the reflection module, many novices are not very clear about this, in order to help you solve this problem, the following editor will explain in detail for you, people with this need can come to learn, I hope you can gain something.

The reflection module of mybatis, corresponding to the reflection package. As the basic support layer of myabits, the reflection module encapsulates the native reflection of java, provides a simple and easy-to-use api to facilitate the upper layer to call, and makes a series of optimizations for reflection operations, such as caching class metadata to improve the performance of reflection operations.

Today we will focus on the Reflector class.

Org.apache.ibatis.reflection.Reflector, reflector, each Reflector corresponds to a class. Reflector caches class information needed for reflection operations, such as constructors, property names, setting/getting methods, and so on.

Public class Reflector {/ * corresponding class * / private final Class type; / * readable attribute array * / private final String [] readablePropertyNames; / * writable attribute array * / private final String [] writablePropertyNames; / * mapping of setting method corresponding to attribute * key: attribute name * value:Invoker object * / private final Map setMethods = new HashMap () / * Mapping of getting method corresponding to attribute * key: attribute name * value:Invoker object * / private final Map getMethods = new HashMap (); / * Mapping of method parameter type of setting method corresponding to attribute * key: attribute name * value: method parameter type * / private final Map > getTypes = new HashMap () / * * default construction method * / private Constructor defaultConstructor; / * case-insensitive attribute collection * / private Map caseInsensitivePropertyMap = new HashMap (); public Reflector (Class clazz) {/ / set the corresponding class type = clazz; / / initialize defaultConstructor addDefaultConstructor (clazz) / initialize getMethods and getTypes, by traversing the getting method addGetMethods (clazz); / initialize setMethods and setTypes, by traversing the setting method. AddSetMethods (clazz); / initialize getMethods + getTypes and setMethods + setTypes by traversing the fields property. AddFields (clazz); / / initialize readablePropertyNames, writeablePropertyNames, caseInsensitivePropertyMap attributes readablePropertyNames = getMethods.keySet (). ToArray (new String [getMethods.keySet (). Size ()]); writeablePropertyNames = setMethods.keySet (). ToArray (new String [setMethods.keySet (). Size ()]); for (String propName: readablePropertyNames) {caseInsensitivePropertyMap.put (propName.toUpperCase (Locale.ENGLISH), propName) } for (String propName: writeablePropertyNames) {caseInsensitivePropertyMap.put (propName.toUpperCase (Locale.ENGLISH), propName);}} addGetMethods

AddGetMethods (Class cls), the code is as follows:

Mapping between private void addGetMethods (Class cls) {/ / attribute and its getting method Map conflictingGetters = new HashMap (); / / get all methods Method [] methods = getClassMethods (cls); for (Method method: methods) {/ / parameter is greater than 0, which means it is not a getting method, ignoring if (method.getParameterTypes (). Length > 0) {continue } / / begins with get or is, indicating that the getting method String name = method.getName (); if ((name.startsWith ("get") & & name.length () > 3) | | (name.startsWith ("is") & & name.length () > 2) {/ / get attribute name = PropertyNamer.methodToProperty (name) / / add to conflictingGetters addMethodConflict (conflictingGetters, name, method);}} / / conflict resolution method of getting (one attribute, only one corresponding method) resolveGetterConflicts (conflictingGetters);}

At: Map conflictingGetters: variable, the mapping of the attribute to its getting method. Because both the parent and subclasses may define getting methods with the same properties, the value will be an array.

The addMethodConflict method uses Map's computeIfAbsent method, which is supported only by jdk1.8. This method is highly recommended. It's a shame that although 1.8 has been used for a long time, many of the convenient methods provided by jdk are still not used. I've learned it here.

Private void addMethodConflict (Map conflictingMethods, String name, Method method) {List list = conflictingMethods.computeIfAbsent (name, k-> new ArrayList ()); list.add (method);}

Next, focus on the resolveGetterConflicts method

Private void resolveGetterConflicts (Map conflictingGetters) {/ / iterate through each attribute to find its best match. Because a subclass can override the methods of the parent class, a property may correspond to multiple getting methods for (Entry entry: conflictingGetters.entrySet ()) {Method winner = null; / / the best matching method String propName = entry.getKey () For (Method candidate: entry.getValue ()) {/ / winner is empty, indicating that candidate is the best matching method if (winner = = null) {winner = candidate; continue;} / / based on return type comparison Class winnerType = winner.getReturnType (); Class candidateType = candidate.getReturnType () / / same type if (candidateType.equals (winnerType)) {/ / return value of the same type, which should have been merged in the getClassMethods method. So throw the ReflectionException exception if (! boolean.class.equals (candidateType)) {throw new ReflectionException ("Illegal overloaded getter method with ambiguous type for property" + propName + "in class" + winner.getDeclaringClass () + ". This breaks the JavaBeans specification and can cause unpredictable results. "); / / Select the is method of type boolean} else if (candidate.getName () .startsWith (" is ")) {winner = candidate } / / does not match the select subclass} else if (candidateType.isAssignableFrom (winnerType)) {/ / OK getter type is descendant / / matches the selected subclass. Because the subclass can modify the magnified return value. For example, the return value of a method of the parent class is List, and the return value of the method can be overridden as ArrayList by the subclass. } else if (winnerType.isAssignableFrom (candidateType)) {winner = candidate / / return type conflict, throw ReflectionException exception} else {throw new ReflectionException ("Illegal overloaded getter method with ambiguous type for property" + propName + "in class" + winner.getDeclaringClass () + ". This breaks the JavaBeans specification and can cause unpredictable results. ");}} / / add addGetMethod (propName, winner) to getMethods and getTypes;}}

Based on the return type. The emphasis is on the case of and, because the subclass can modify the magnified return value, so when this occurs, select the method of the subclass. For example, the return value of a method of the parent class is List, and the return value of the method by the subclass can be overridden as ArrayList.

Is it helpful for you to read the above content? If you want to know more about the relevant knowledge or read more related articles, please follow the industry information channel, thank you for your support.

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.