2686

Committed 01 Feb 2025 09:55PM UTC coverage: 87.093% (-0.1%) from 87.217%

Build # 2686

Build Type

Pull #3379

github

Committed by

web-flow

Commit Message

Merge c97c5c598 into 3d71c862a

Pull Request Pull Request #3379: Resolve type handler based on `java.lang.reflect.Type` instead of `Class` and respect runtime JDBC type

Run Details

3825 of 4663 branches covered (82.03%)

515 of 579 new or added lines in 36 files covered. (88.95%)

28 existing lines in 6 files now uncovered.

9912 of 11381 relevant lines covered (87.09%)

0.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.15

/src/main/java/org/apache/ibatis/reflection/MetaClass.java

/*
 *    Copyright 2009-2025 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       https://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.reflection;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.ibatis.reflection.invoker.Invoker;
import org.apache.ibatis.reflection.property.PropertyTokenizer;

/**
 * @author Clinton Begin
 */
public class MetaClass {

  private final ReflectorFactory reflectorFactory;
  private final Reflector reflector;

  private MetaClass(Type type, ReflectorFactory reflectorFactory) {
    this.reflectorFactory = reflectorFactory;
    this.reflector = reflectorFactory.findForClass(type);
  }

  public static MetaClass forClass(Type type, ReflectorFactory reflectorFactory) {
    return new MetaClass(type, reflectorFactory);
  }

  public MetaClass metaClassForProperty(String name) {
    Class<?> propType = reflector.getGetterType(name);
    return MetaClass.forClass(propType, reflectorFactory);
  }

  public String findProperty(String name) {
    StringBuilder prop = buildProperty(name, new StringBuilder());
    return prop.length() > 0 ? prop.toString() : null;
  }

  public String findProperty(String name, boolean useCamelCaseMapping) {
    if (useCamelCaseMapping) {
      name = name.replace("_", "");
    }
    return findProperty(name);
  }

  public String[] getGetterNames() {
    return reflector.getGetablePropertyNames();
  }

  public String[] getSetterNames() {
    return reflector.getSetablePropertyNames();
  }

  public Class<?> getSetterType(String name) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
      MetaClass metaProp = metaClassForProperty(prop.getName());
      return metaProp.getSetterType(prop.getChildren());
    }
    return reflector.getSetterType(prop.getName());
  }

  public Entry<Type, Class<?>> getGenericSetterType(String name) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
      MetaClass metaProp = metaClassForProperty(prop);
      return metaProp.getGenericSetterType(prop.getChildren());
    }
    return reflector.getGenericSetterType(prop.getName());
  }

  public Class<?> getGetterType(String name) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
      MetaClass metaProp = metaClassForProperty(prop);
      return metaProp.getGetterType(prop.getChildren());
    }
    return getGetterType(prop).getValue();
  }

  public Entry<Type, Class<?>> getGenericGetterType(String name) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
      MetaClass metaProp = metaClassForProperty(prop);
      return metaProp.getGenericGetterType(prop.getChildren());
    }
    return getGetterType(prop);
  }

  private MetaClass metaClassForProperty(PropertyTokenizer prop) {
    Class<?> propType = getGetterType(prop).getValue();
    return MetaClass.forClass(propType, reflectorFactory);
  }

  private Entry<Type, Class<?>> getGetterType(PropertyTokenizer prop) {
    // Resolve the type inside a Collection Object
    // https://github.com/mybatis/old-google-code-issues/issues/506
    Entry<Type, Class<?>> pair = reflector.getGenericGetterType(prop.getName());
    if (prop.getIndex() != null && Collection.class.isAssignableFrom(pair.getValue())) {
      Type returnType = pair.getKey();
      if (returnType instanceof ParameterizedType) {
        Type[] actualTypeArguments = ((ParameterizedType) returnType).getActualTypeArguments();
        if (actualTypeArguments != null && actualTypeArguments.length == 1) {
          returnType = actualTypeArguments[0];
          if (returnType instanceof Class) {
            return Map.entry(returnType, (Class<?>) returnType);
          } else if (returnType instanceof ParameterizedType) {
            return Map.entry(returnType, (Class<?>) ((ParameterizedType) returnType).getRawType());
          }
        }
      }
    }
    return pair;
  }

  public boolean hasSetter(String name) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (!prop.hasNext()) {
      return reflector.hasSetter(prop.getName());
    }
    if (reflector.hasSetter(prop.getName())) {
      MetaClass metaProp = metaClassForProperty(prop.getName());
      return metaProp.hasSetter(prop.getChildren());
    }
    return false;
  }

  public boolean hasGetter(String name) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (!prop.hasNext()) {
      return reflector.hasGetter(prop.getName());
    }
    if (reflector.hasGetter(prop.getName())) {
      MetaClass metaProp = metaClassForProperty(prop);
      return metaProp.hasGetter(prop.getChildren());
    }
    return false;
  }

  public Invoker getGetInvoker(String name) {
    return reflector.getGetInvoker(name);
  }

  public Invoker getSetInvoker(String name) {
    return reflector.getSetInvoker(name);
  }

  private StringBuilder buildProperty(String name, StringBuilder builder) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
      String propertyName = reflector.findPropertyName(prop.getName());
      if (propertyName != null) {
        builder.append(propertyName);
        builder.append(".");
        MetaClass metaProp = metaClassForProperty(propertyName);
        metaProp.buildProperty(prop.getChildren(), builder);
      }
    } else {
      String propertyName = reflector.findPropertyName(name);
      if (propertyName != null) {
        builder.append(propertyName);
      }
    }
    return builder;
  }

  public boolean hasDefaultConstructor() {
    return reflector.hasDefaultConstructor();
  }

}

1	/*
2	* Copyright 2009-2025 the original author or authors.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* https://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package org.apache.ibatis.reflection;
17
18	import java.lang.reflect.ParameterizedType;
19	import java.lang.reflect.Type;
20	import java.util.Collection;
21	import java.util.Map;
22	import java.util.Map.Entry;
23
24	import org.apache.ibatis.reflection.invoker.Invoker;
25	import org.apache.ibatis.reflection.property.PropertyTokenizer;
26
27	/**
28	* @author Clinton Begin
29	*/
30	public class MetaClass {
31
32	private final ReflectorFactory reflectorFactory;
33	private final Reflector reflector;
34
35	private MetaClass(Type type, ReflectorFactory reflectorFactory) {	1✔
36	this.reflectorFactory = reflectorFactory;	1✔
37	this.reflector = reflectorFactory.findForClass(type);	1✔
38	}	1✔
39
40	public static MetaClass forClass(Type type, ReflectorFactory reflectorFactory) {
41	return new MetaClass(type, reflectorFactory);	1✔
42	}
43
44	public MetaClass metaClassForProperty(String name) {
45	Class<?> propType = reflector.getGetterType(name);	1✔
46	return MetaClass.forClass(propType, reflectorFactory);	1✔
47	}
48
49	public String findProperty(String name) {
50	StringBuilder prop = buildProperty(name, new StringBuilder());	1✔
51	return prop.length() > 0 ? prop.toString() : null;	1✔
52	}
53
54	public String findProperty(String name, boolean useCamelCaseMapping) {
55	if (useCamelCaseMapping) {	1✔
56	name = name.replace("_", "");	1✔
57	}
58	return findProperty(name);	1✔
59	}
60
61	public String[] getGetterNames() {
62	return reflector.getGetablePropertyNames();	1✔
63	}
64
65	public String[] getSetterNames() {
66	return reflector.getSetablePropertyNames();	1✔
67	}
68
69	public Class<?> getSetterType(String name) {
70	PropertyTokenizer prop = new PropertyTokenizer(name);	1✔
71	if (prop.hasNext()) {	1✔
72	MetaClass metaProp = metaClassForProperty(prop.getName());	1✔
73	return metaProp.getSetterType(prop.getChildren());	1✔
74	}
75	return reflector.getSetterType(prop.getName());	1✔
76	}
77
78	public Entry<Type, Class<?>> getGenericSetterType(String name) {
79	PropertyTokenizer prop = new PropertyTokenizer(name);	1✔
80	if (prop.hasNext()) {	1✔
81	MetaClass metaProp = metaClassForProperty(prop);	1✔
82	return metaProp.getGenericSetterType(prop.getChildren());	1✔
83	}
84	return reflector.getGenericSetterType(prop.getName());	1✔
85	}
86
87	public Class<?> getGetterType(String name) {
88	PropertyTokenizer prop = new PropertyTokenizer(name);	1✔
89	if (prop.hasNext()) {	1✔
90	MetaClass metaProp = metaClassForProperty(prop);	1✔
91	return metaProp.getGetterType(prop.getChildren());	1✔
92	}
93	return getGetterType(prop).getValue();	1✔
94	}
95
96	public Entry<Type, Class<?>> getGenericGetterType(String name) {
97	PropertyTokenizer prop = new PropertyTokenizer(name);	1✔
98	if (prop.hasNext()) {	1✔
99	MetaClass metaProp = metaClassForProperty(prop);	1✔
100	return metaProp.getGenericGetterType(prop.getChildren());	1✔
101	}
102	return getGetterType(prop);	1✔
103	}
104
105	private MetaClass metaClassForProperty(PropertyTokenizer prop) {
106	Class<?> propType = getGetterType(prop).getValue();	1✔
107	return MetaClass.forClass(propType, reflectorFactory);	1✔
108	}
109
110	private Entry<Type, Class<?>> getGetterType(PropertyTokenizer prop) {
111	// Resolve the type inside a Collection Object
112	// https://github.com/mybatis/old-google-code-issues/issues/506
113	Entry<Type, Class<?>> pair = reflector.getGenericGetterType(prop.getName());	1✔
114	if (prop.getIndex() != null && Collection.class.isAssignableFrom(pair.getValue())) {	1!
115	Type returnType = pair.getKey();	1✔
116	if (returnType instanceof ParameterizedType) {	1✔
117	Type[] actualTypeArguments = ((ParameterizedType) returnType).getActualTypeArguments();	1✔
118	if (actualTypeArguments != null && actualTypeArguments.length == 1) {	1!
119	returnType = actualTypeArguments[0];	1✔
120	if (returnType instanceof Class) {	1!
121	return Map.entry(returnType, (Class<?>) returnType);	1✔
122	} else if (returnType instanceof ParameterizedType) {	×
NEW 123	return Map.entry(returnType, (Class<?>) ((ParameterizedType) returnType).getRawType());	×
124	}
125	}
126	}
127	}
128	return pair;	1✔
129	}
130
131	public boolean hasSetter(String name) {
132	PropertyTokenizer prop = new PropertyTokenizer(name);	1✔
133	if (!prop.hasNext()) {	1✔
134	return reflector.hasSetter(prop.getName());	1✔
135	}
136	if (reflector.hasSetter(prop.getName())) {	1!
137	MetaClass metaProp = metaClassForProperty(prop.getName());	1✔
138	return metaProp.hasSetter(prop.getChildren());	1✔
139	}
140	return false;	×
141	}
142
143	public boolean hasGetter(String name) {
144	PropertyTokenizer prop = new PropertyTokenizer(name);	1✔
145	if (!prop.hasNext()) {	1✔
146	return reflector.hasGetter(prop.getName());	1✔
147	}
148	if (reflector.hasGetter(prop.getName())) {	1✔
149	MetaClass metaProp = metaClassForProperty(prop);	1✔
150	return metaProp.hasGetter(prop.getChildren());	1✔
151	}
152	return false;	1✔
153	}
154
155	public Invoker getGetInvoker(String name) {
156	return reflector.getGetInvoker(name);	1✔
157	}
158
159	public Invoker getSetInvoker(String name) {
160	return reflector.getSetInvoker(name);	1✔
161	}
162
163	private StringBuilder buildProperty(String name, StringBuilder builder) {
164	PropertyTokenizer prop = new PropertyTokenizer(name);	1✔
165	if (prop.hasNext()) {	1✔
166	String propertyName = reflector.findPropertyName(prop.getName());	1✔
167	if (propertyName != null) {	1!
168	builder.append(propertyName);	1✔
169	builder.append(".");	1✔
170	MetaClass metaProp = metaClassForProperty(propertyName);	1✔
171	metaProp.buildProperty(prop.getChildren(), builder);	1✔
172	}
173	} else {	1✔
174	String propertyName = reflector.findPropertyName(name);	1✔
175	if (propertyName != null) {	1✔
176	builder.append(propertyName);	1✔
177	}
178	}
179	return builder;	1✔
180	}
181
182	public boolean hasDefaultConstructor() {
183	return reflector.hasDefaultConstructor();	1✔
184	}
185
186	}

mybatis / mybatis-3 / 2686

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous