Spring-框架-ClassUtils类isAssignable方法

喜欢ヅ旅行 2023-06-08 10:58 47阅读 0赞

### Spring的isAssignable方法源码： ###

isAssignable方法位于spring的org.springframework.util工具包的ClassUtils类中下

源码：

/**
 	 * Check if the right-hand side type may be assigned to the left-hand side
 	 * type, assuming setting by reflection. Considers primitive wrapper
 	 * classes as assignable to the corresponding primitive types.
 	 * @param lhsType the target type
 	 * @param rhsType the value type that should be assigned to the target type
 	 * @return if the target type is assignable from the value type
 	 * @see TypeUtils#isAssignable
 	 */
 	public static boolean isAssignable(Class<?> lhsType, Class<?> rhsType) {
 Assert.notNull(lhsType, "Left-hand side type must not be null");
 Assert.notNull(rhsType, "Right-hand side type must not be null");
 // 若左边类型 是右边类型的父类、父接口，或者左边类型等于右边类型
 if (lhsType.isAssignableFrom(rhsType)) {
 return true;
 }
 // 左边入参是否是基本类型
 if (lhsType.isPrimitive()) {
 //primitiveWrapperTypeMap是从包装类型到基本类型的map，将右边入参转化为基本类型
 Class<?> resolvedPrimitive = primitiveWrapperTypeMap.get(rhsType);
 if (lhsType == resolvedPrimitive) {
 return true;
 }
 }
 else {
 // 将右边入参转化为包装类型
 Class<?> resolvedWrapper = primitiveTypeToWrapperMap.get(rhsType);
 if (resolvedWrapper != null && lhsType.isAssignableFrom(resolvedWrapper)) 
 {
 return true;
 }
 }
 return false;
 }

`ClassUtils.isAssignable()`方法扩展了`Class的isAssignableFrom()`方法，即将`Java`的基本类型和包装类型做了兼容。

### java的isAssignableFrom方法源码： ###

/**
 * Determines if the class or interface represented by this
 * {@code Class} object is either the same as, or is a superclass or
 * superinterface of, the class or interface represented by the specified
 * {@code Class} parameter. It returns {@code true} if so;
 * otherwise it returns {@code false}. If this {@code Class}
 * object represents a primitive type, this method returns
 * {@code true} if the specified {@code Class} parameter is
 * exactly this {@code Class} object; otherwise it returns
 * {@code false}.
 *
 * Specifically, this method tests whether the type represented by the
 * specified {@code Class} parameter can be converted to the type
 * represented by this {@code Class} object via an identity conversion
 * or via a widening reference conversion. See The Java Language
 * Specification, sections 5.1.1 and 5.1.4 , for details.
 *
 * @param cls the {@code Class} object to be checked
 * @return the {@code boolean} value indicating whether objects of the
 * type {@code cls} can be assigned to objects of this class
 * @exception NullPointerException if the specified Class parameter is
 * null.
 * @since JDK1.1
 */
 public native boolean isAssignableFrom(Class<?> cls);

实现：

/**
 * Instances of the class {@code Class} represent classes and
 * interfaces in a running Java application. An enum is a kind of
 * class and an annotation is a kind of interface. Every array also
 * belongs to a class that is reflected as a {@code Class} object
 * that is shared by all arrays with the same element type and number
 * of dimensions. The primitive Java types ({@code boolean},
 * {@code byte}, {@code char}, {@code short},
 * {@code int}, {@code long}, {@code float}, and
 * {@code double}), and the keyword {@code void} are also
 * represented as {@code Class} objects.
 *
 * {@code Class} has no public constructor. Instead {@code Class}
 * objects are constructed automatically by the Java Virtual Machine as classes
 * are loaded and by calls to the {@code defineClass} method in the class
 * loader.
 *
 * The following example uses a {@code Class} object to print the
 * class name of an object:
 *
 * <blockquote><pre>
 * void printClassName(Object obj) {
 * System.out.println("The class of " + obj +
 * " is " + obj.getClass().getName());
 * }
 * </pre></blockquote>
 *
 * It is also possible to get the {@code Class} object for a named
 * type (or for void) using a class literal. See Section 15.8.2 of
 * <cite>The Java™ Language Specification</cite>.
 * For example:
 *
 * <blockquote>
 * {@code System.out.println("The name of class Foo is: "+Foo.class.getName());}
 * </blockquote>
 *
 * @param <T> the type of the class modeled by this {@code Class}
 * object. For example, the type of {@code String.class} is {@code
 * Class<String>}. Use {@code Class<?>} if the class being modeled is
 * unknown.
 *
 * @author unascribed
 * @see java.lang.ClassLoader#defineClass(byte[], int, int)
 * @since JDK1.0
 */
 public final class Class<T> implements java.io.Serializable,
 GenericDeclaration,
 Type,
 AnnotatedElement {
 private static final int ANNOTATION= 0x00002000;
 private static final int ENUM = 0x00004000;
 private static final int SYNTHETIC = 0x00001000;
 
 private static native void registerNatives();
 static {
 registerNatives();
 }

实现调用的是java Native方法，这里不继续展开。

与instanceof（）方法对比：

A instanceof  B ：判断A对象是否为B类或接口的实例或者子类或子接口的对象   
A.isAssignableFrom(B) ：判断A Class对象所代表的类或者接口 是否为B Class对象所代表的类或者接口

PS：简单说就是 instanceof是判断A是否继承B，isAssignableFrom是判断B是否继承A

测试：

package com.auuzee.test1;
    
    class A {
    }
    
    class B extends A {
    }
    
    public class Test1 {
        public static void main(String[] args) {
    
            A a = new A();
            B b = new B();
            A ba = new B();
            System.out.println("1-------------");
            System.out.println(A.class.isAssignableFrom(a.getClass()));
            System.out.println(B.class.isAssignableFrom(b.getClass()));
            System.out.println(A.class.isAssignableFrom(b.getClass()));
            System.out.println(B.class.isAssignableFrom(a.getClass()));
            System.out.println(A.class.isAssignableFrom(ba.getClass()));
            System.out.println(B.class.isAssignableFrom(ba.getClass()));
            System.out.println("2-------------");
            System.out.println(a.getClass().isAssignableFrom(A.class));
            System.out.println(b.getClass().isAssignableFrom(B.class));
            System.out.println(a.getClass().isAssignableFrom(B.class));
            System.out.println(b.getClass().isAssignableFrom(A.class));
            System.out.println(ba.getClass().isAssignableFrom(A.class));
            System.out.println(ba.getClass().isAssignableFrom(B.class));
            System.out.println("3-------------");
            System.out.println(Object.class.isAssignableFrom(b.getClass()));
            System.out.println(Object.class.isAssignableFrom("abc".getClass()));
            System.out.println("4-------------");
            System.out.println("a".getClass().isAssignableFrom(Object.class));
            System.out.println("abc".getClass().isAssignableFrom(Object.class));
        }
    }

结果:

![format_png][]

PS:

1.class2是不是class1的子类或者子接口

2.Object是所有类的父类

参考文章：[https://www.cnblogs.com/greatfish/p/6097507.html][https_www.cnblogs.com_greatfish_p_6097507.html]  测试用

[format_png]: /images/20230531/bcfc18ca489646699de3ab6dc7a63514.png
[https_www.cnblogs.com_greatfish_p_6097507.html]: https://www.cnblogs.com/greatfish/p/6097507.html