write a line into test.file

docs/spring/cs774586e8-85e0-11ee-b23a-acde48001122.java

@@ -0,0 +1,345 @@
+/**
+ * Copyright 2009-2019 the original author or authors.
+ * <p>
+ * 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.*;
+import java.util.Arrays;
+
+/**
+ * @author Iwao AVE!
+ */
+public class TypeParameterResolver {
+
+    private TypeParameterResolver() {
+        super();
+    }
+
+    /**
+     * @return The field type as {@link Type}. If it has type parameters in the declaration,<br>
+     * they will be resolved to the actual runtime {@link Type}s.
+     */
+    public static Type resolveFieldType(Field field, Type srcType) {
+        // 获取需要解析的字段
+        Type fieldType = field.getGenericType();
+        // 获取字段类型
+        Class<?> declaringClass = field.getDeclaringClass();
+        // 解析方式
+        return resolveType(fieldType, srcType, declaringClass);
+    }
+
+    /**
+     * @return The return type of the method as {@link Type}. If it has type parameters in the declaration,<br>
+     * they will be resolved to the actual runtime {@link Type}s.
+     */
+    public static Type resolveReturnType(Method method, Type srcType) {
+        // 获取返回值类型
+        Type returnType = method.getGenericReturnType();
+        // 获取方法的类型
+        Class<?> declaringClass = method.getDeclaringClass();
+        return resolveType(returnType, srcType, declaringClass);
+    }
+
+    /**
+     * @return The parameter types of the method as an array of {@link Type}s. If they have type parameters in the declaration,<br>
+     * they will be resolved to the actual runtime {@link Type}s.
+     */
+    public static Type[] resolveParamTypes(Method method, Type srcType) {
+        // 获取方法参数类型
+        Type[] paramTypes = method.getGenericParameterTypes();
+        // 方法定义类型
+        Class<?> declaringClass = method.getDeclaringClass();
+        Type[] result = new Type[paramTypes.length];
+        for (int i = 0; i < paramTypes.length; i++) {
+            // 遍历接信息
+            result[i] = resolveType(paramTypes[i], srcType, declaringClass);
+        }
+        return result;
+    }
+
+    private static Type resolveType(Type type, Type srcType, Class<?> declaringClass) {
+        if (type instanceof TypeVariable) {
+            return resolveTypeVar((TypeVariable<?>) type, srcType, declaringClass);
+        } else if (type instanceof ParameterizedType) {
+            return resolveParameterizedType((ParameterizedType) type, srcType, declaringClass);
+        } else if (type instanceof GenericArrayType) {
+            return resolveGenericArrayType((GenericArrayType) type, srcType, declaringClass);
+        } else {
+            return type;
+        }
+    }
+
+    private static Type resolveGenericArrayType(GenericArrayType genericArrayType, Type srcType, Class<?> declaringClass) {
+        Type componentType = genericArrayType.getGenericComponentType();
+        Type resolvedComponentType = null;
+        if (componentType instanceof TypeVariable) {
+            // TypeVariable 类型解析
+            resolvedComponentType = resolveTypeVar((TypeVariable<?>) componentType, srcType, declaringClass);
+        } else if (componentType instanceof GenericArrayType) {
+            // GenericArrayType 类型解析
+            resolvedComponentType = resolveGenericArrayType((GenericArrayType) componentType, srcType, declaringClass);
+        } else if (componentType instanceof ParameterizedType) {
+            // ParameterizedType 类型解析
+            resolvedComponentType = resolveParameterizedType((ParameterizedType) componentType, srcType, declaringClass);
+        }
+        if (resolvedComponentType instanceof Class) {
+            // class 类型解析
+            return Array.newInstance((Class<?>) resolvedComponentType, 0).getClass();
+        } else {
+            // 直接返回
+            return new GenericArrayTypeImpl(resolvedComponentType);
+        }
+    }
+
+    /**
+     * 解析 ParameterizedType
+     *
+     * @param parameterizedType
+     * @param srcType
+     * @param declaringClass
+     * @return
+     */
+    private static ParameterizedType resolveParameterizedType(ParameterizedType parameterizedType, Type srcType, Class<?> declaringClass) {
+        // 获取参数类型
+        Class<?> rawType = (Class<?>) parameterizedType.getRawType();
+        // 实际参数获取
+        Type[] typeArgs = parameterizedType.getActualTypeArguments();
+        Type[] args = typesToArgs(srcType, declaringClass, typeArgs);
+        return new ParameterizedTypeImpl(rawType, null, args);
+    }
+
+    /**
+     * 提取的方法 不是原始的方便注释代码 ^_^
+     * @param srcType
+     * @param declaringClass
+     * @param typeArgs
+     * @return
+     */
+    private static Type[] typesToArgs(Type srcType, Class<?> declaringClass, Type[] typeArgs) {
+        Type[] args = new Type[typeArgs.length];
+        // 实际参数处理ß
+        for (int i = 0; i < typeArgs.length; i++) {
+            // 参数类型校验
+            if (typeArgs[i] instanceof TypeVariable) {
+                args[i] = resolveTypeVar((TypeVariable<?>) typeArgs[i], srcType, declaringClass);
+            } else if (typeArgs[i] instanceof ParameterizedType) {
+                args[i] = resolveParameterizedType((ParameterizedType) typeArgs[i], srcType, declaringClass);
+            } else if (typeArgs[i] instanceof WildcardType) {
+                args[i] = resolveWildcardType((WildcardType) typeArgs[i], srcType, declaringClass);
+            } else {
+                args[i] = typeArgs[i];
+            }
+        }
+        return args;
+    }
+
+    private static Type resolveWildcardType(WildcardType wildcardType, Type srcType, Class<?> declaringClass) {
+        Type[] lowerBounds = resolveWildcardTypeBounds(wildcardType.getLowerBounds(), srcType, declaringClass);
+        Type[] upperBounds = resolveWildcardTypeBounds(wildcardType.getUpperBounds(), srcType, declaringClass);
+        return new WildcardTypeImpl(lowerBounds, upperBounds);
+    }
+
+    private static Type[] resolveWildcardTypeBounds(Type[] bounds, Type srcType, Class<?> declaringClass) {
+        Type[] result = typesToArgs(srcType, declaringClass, bounds);
+        return result;
+    }
+
+    private static Type resolveTypeVar(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass) {
+        Type result;
+        Class<?> clazz;
+        if (srcType instanceof Class) {
+            clazz = (Class<?>) srcType;
+        } else if (srcType instanceof ParameterizedType) {
+            ParameterizedType parameterizedType = (ParameterizedType) srcType;
+            clazz = (Class<?>) parameterizedType.getRawType();
+        } else {
+            throw new IllegalArgumentException("The 2nd arg must be Class or ParameterizedType, but was: " + srcType.getClass());
+        }
+
+        if (clazz == declaringClass) {
+            Type[] bounds = typeVar.getBounds();
+            if (bounds.length > 0) {
+                return bounds[0];
+            }
+            return Object.class;
+        }
+        /**
+         * 获取父类类型，如果父类是泛型，则这里返回的是参数化类型ParameterizedType
+         */
+        Type superclass = clazz.getGenericSuperclass();
+        result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superclass);
+        if (result != null) {
+            return result;
+        }
+        /**
+         * 获取实现的接口
+         */
+        Type[] superInterfaces = clazz.getGenericInterfaces();
+        for (Type superInterface : superInterfaces) {
+            result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superInterface);
+            if (result != null) {
+                return result;
+            }
+        }
+        return Object.class;
+    }
+
+    /**
+     * 扫描 上级类型
+     *
+     * @param typeVar
+     * @param srcType
+     * @param declaringClass
+     * @param clazz
+     * @param superclass
+     * @return
+     */
+    private static Type scanSuperTypes(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass, Class<?> clazz, Type superclass) {
+        if (superclass instanceof ParameterizedType) {
+            ParameterizedType parentAsType = (ParameterizedType) superclass;
+            Class<?> parentAsClass = (Class<?>) parentAsType.getRawType();
+            TypeVariable<?>[] parentTypeVars = parentAsClass.getTypeParameters();
+            if (srcType instanceof ParameterizedType) {
+                parentAsType = translateParentTypeVars((ParameterizedType) srcType, clazz, parentAsType);
+            }
+            if (declaringClass == parentAsClass) {
+                for (int i = 0; i < parentTypeVars.length; i++) {
+                    if (typeVar == parentTypeVars[i]) {
+                        return parentAsType.getActualTypeArguments()[i];
+                    }
+                }
+            }
+            if (declaringClass.isAssignableFrom(parentAsClass)) {
+                return resolveTypeVar(typeVar, parentAsType, declaringClass);
+            }
+        } else if (superclass instanceof Class && declaringClass.isAssignableFrom((Class<?>) superclass)) {
+            return resolveTypeVar(typeVar, superclass, declaringClass);
+        }
+        return null;
+    }
+
+    private static ParameterizedType translateParentTypeVars(ParameterizedType srcType, Class<?> srcClass, ParameterizedType parentType) {
+        Type[] parentTypeArgs = parentType.getActualTypeArguments();
+        Type[] srcTypeArgs = srcType.getActualTypeArguments();
+        TypeVariable<?>[] srcTypeVars = srcClass.getTypeParameters();
+        Type[] newParentArgs = new Type[parentTypeArgs.length];
+        boolean noChange = true;
+        for (int i = 0; i < parentTypeArgs.length; i++) {
+            if (parentTypeArgs[i] instanceof TypeVariable) {
+                for (int j = 0; j < srcTypeVars.length; j++) {
+                    if (srcTypeVars[j] == parentTypeArgs[i]) {
+                        noChange = false;
+                        newParentArgs[i] = srcTypeArgs[j];
+                    }
+                }
+            } else {
+                newParentArgs[i] = parentTypeArgs[i];
+            }
+        }
+        return noChange ? parentType : new ParameterizedTypeImpl((Class<?>) parentType.getRawType(), null, newParentArgs);
+    }
+
+    static class ParameterizedTypeImpl implements ParameterizedType {
+        private Class<?> rawType;
+
+        private Type ownerType;
+
+        private Type[] actualTypeArguments;
+
+        public ParameterizedTypeImpl(Class<?> rawType, Type ownerType, Type[] actualTypeArguments) {
+            super();
+            this.rawType = rawType;
+            this.ownerType = ownerType;
+            this.actualTypeArguments = actualTypeArguments;
+        }
+
+        /**
+         * 获取参数列表的泛型
+         *
+         * @return
+         */
+        @Override
+        public Type[] getActualTypeArguments() {
+            return actualTypeArguments;
+        }
+
+        @Override
+        public Type getOwnerType() {
+            return ownerType;
+        }
+
+        /**
+         * 获取<>前面的类型，即基本类型
+         *
+         * @return
+         */
+        @Override
+        public Type getRawType() {
+            return rawType;
+        }
+
+        @Override
+        public String toString() {
+            return "ParameterizedTypeImpl [rawType=" + rawType + ", ownerType=" + ownerType + ", actualTypeArguments=" + Arrays.toString(actualTypeArguments) + "]";
+        }
+    }
+
+    static class WildcardTypeImpl implements WildcardType {
+        /**
+         * 数据类型下限 super
+         */
+        private Type[] lowerBounds;
+
+        /**
+         * 数据类型上限  extend
+         */
+        private Type[] upperBounds;
+
+        WildcardTypeImpl(Type[] lowerBounds, Type[] upperBounds) {
+            super();
+            this.lowerBounds = lowerBounds;
+            this.upperBounds = upperBounds;
+        }
+
+        @Override
+        public Type[] getLowerBounds() {
+            return lowerBounds;
+        }
+
+        @Override
+        public Type[] getUpperBounds() {
+            return upperBounds;
+        }
+    }
+
+    static class GenericArrayTypeImpl implements GenericArrayType {
+        private Type genericComponentType;
+
+        GenericArrayTypeImpl(Type genericComponentType) {
+            super();
+            this.genericComponentType = genericComponentType;
+        }
+
+        /**
+         * 获取元素
+         *
+         * @return
+         */
+        @Override
+        public Type getGenericComponentType() {
+            return genericComponentType;
+        }
+    }
+}

docs/spring/cs7785046c-85e0-11ee-b23a-acde48001122.java

@@ -0,0 +1,13 @@
+package org.example.domain.event.exception;
+
+public class EventException extends RuntimeException {
+
+	private final Error error;
+
+
+	protected EventException(Error error) {
+		super(error.msg());
+		this.error = error;
+	}
+
+}