MAX_VALUE
MAX_VALUE

反射模块

动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。反射的基本术语：Class、Constructor、Field、Method。

一、Reflector和ReflectorFactory

Reflector用于存储类的基本信息，是反射模块的基础，每个Reflector对象都对应一个类，Reflector中缓存反射需要的类的元信息。

  //类的Class类型     
  private Class type;
  //可读属性，存在getter方法的属性
  private String[] readablePropertyNames = EMPTY_STRING_ARRAY;
  //可写属性，存在setter方法的属性
  private String[] writeablePropertyNames = EMPTY_STRING_ARRAY;
  //setter方法，key是属性名，value是Invoker,是对Method的封装
  private Map setMethods = new HashMap();
  //getter方法，key是属性名，value是Invoker，是对Method的封装
  private Map getMethods = new HashMap();
  //属性settter方法的参数值类型，key是属性名，value是参数类型
  private Map> setTypes = new HashMap>();
  //属性getter方法的参数值类型，key是属性名，value是返回值类型
  private Map> getTypes = new HashMap>();
  //无参构造
  private Constructor defaultConstructor;
  //类中所有的属性，key是属性名的大写，value是属性名
  private Map caseInsensitivePropertyMap = new HashMap();

在Reflector的构造方法中初始化上述的字段值。

  public Reflector(Class clazz) {
    type = clazz;
    addDefaultConstructor(clazz);
    //处理clazz的getter方法，填充getMethods集合和getTypes集合
    addGetMethods(clazz);
    //处理clazz的setter方法，填充setMethods集合和setTypes集合
    addSetMethods(clazz);
    //处理没有getter/setter方法的字段
    addFields(clazz);
    //根据getMethods/setMethods方法，初始化可读/可写属性名称集合
    readablePropertyNames = getMethods.keySet().toArray(new String[getMethods.keySet().size()]);
    writeablePropertyNames = setMethods.keySet().toArray(new String[setMethods.keySet().size()]);
    //caseInsensitivePropertyMap中记录属性的大写名称
    for (String propName : readablePropertyNames) {
      caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
    }
    for (String propName : writeablePropertyNames) {
      caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
    }
  }

举个例子，获取一个简单的JavaBean的Reflector信息。

//price没有对应的getter/setter方法
//存在getBuyTime/setBuyTime方法，但是未显示定义buyTime字段
class Car {
    private String carNo;
    private Integer price;

    public String getCarNo() {
        return carNo;
    }

    public void setCarNo(String carNo) {
        this.carNo = carNo;
    }

    public String getBuyTime() {
        return "2019-11-04";
    }

    public void setBuyTime(String time) {

    }
}

反射模块_第1张图片

ReflectorFactory是创建Reflector的接口，mybatis的唯一实现是DefaultReflectorFactory，可以完成对Reflector的创建和缓存。通过自定义ReflectorFactory实现类完成功能的扩展。

public class DefaultReflectorFactory implements ReflectorFactory {
  //是否允许缓存类的Reflector对象
  private boolean classCacheEnabled = true;
  //使用map进行缓存，key是类的Class类型，vlaue是Reflector对象
  private final ConcurrentMap, Reflector> reflectorMap = new ConcurrentHashMap, Reflector>();

  public DefaultReflectorFactory() {
  }

  @Override
  public boolean isClassCacheEnabled() {
    return classCacheEnabled;
  }

  @Override
  public void setClassCacheEnabled(boolean classCacheEnabled) {
    this.classCacheEnabled = classCacheEnabled;
  }

  @Override
  public Reflector findForClass(Class type) {
    if (classCacheEnabled) {
      //允许使用缓存，先从缓存中查找，没有则新建Reflector对象，然后放入缓存中。
      // synchronized (type) removed see issue #461
      Reflector cached = reflectorMap.get(type);
      if (cached == null) {
        cached = new Reflector(type);
        reflectorMap.put(type, cached);
      }
      return cached;
    } else {
      //不允许使用缓存，新建reflector对象
      return new Reflector(type);
    }
  }

}

在获取一个类的getter方法时，会获取该类的所有方法再进行过滤，在获取所有方法的过程中会先获取该类的所有方法，为每个方法生成唯一的方法签名，同样会查询该类的所有接口的方法，该类的父类的所有方法。

  private Method[] getClassMethods(Class cls) {
    Map uniqueMethods = new HashMap();
    Class currentClass = cls;
    while (currentClass != null) {
      //为每个公共方法生成唯一的方法签名，uniqueMethods的key就是方法的签名
      //如：java.util.List#getNames
      addUniqueMethods(uniqueMethods, currentClass.getDeclaredMethods());

      // we also need to look for interface methods -
      // because the class may be abstract
      //查找接口方法
      Class[] interfaces = currentClass.getInterfaces();
      for (Class anInterface : interfaces) {
        addUniqueMethods(uniqueMethods, anInterface.getMethods());
      }

      //查找父类方法
      currentClass = currentClass.getSuperclass();
    }

    Collection methods = uniqueMethods.values();

    return methods.toArray(new Method[methods.size()]);
  }

reflector.resovleGetterConflicts()方法，用于解决一个属性对应两个方法的问题。比如类SubA继承了A，A中有getNames方法，其返回值为List，SubA重写了getNames方法，返回值为ArrayList，mybatis会为这个属性对应的方法生成不同的签名java.util.List#getNames，java.util.ArrayList#getNames，因为SubA对方法getNames进行了重写，故添加到getMethods中的是SubA中的getNames方法。

二、TypeParameterResolver

当存在复杂的继承关系以及泛型定义时，TypeParameterResolver可以帮助我们解析字段，参数列表、返回值的类型，这是Reflector的基础。

TypeParameterResolver作为类型解析的工具类，所有方法的返回值都是Type类型，因此我们先从Type说起。Type是所有类型的公共接口，Class（实现类），ParameterizedType，GenericArrayType，TypeVariable、WildcardType。

ParameterizedType：泛型类型，如Map,List。getRawType返回原始类型，如List中的List；

getActualTypeArguments获取泛型类型，如String。

TypeVariable：类型变量，如List中的T、T/K/V/E等。getBounds后去类型变量的上边界，未指定则为Object，List则上边界为Person；getGenericDeclaration获取原始类型如List为List；getName返回源码中定义的泛型如List为T。

WildcardType：通配符类型，如List，List。getUpperBounds获取上边界类型，getLowerBounds获取下边界类型。

GenericArrayType：泛型数组类型，元素类型需要是ParameterizedType或TypeVariable，如List[]、T[]、List[]。

getGenericComponentType返回数值元素的类型，如List[]为List即ParameterizedType。

Class：普通类型，除上述之外的类型。

类型存在嵌套。比如：

List外层是ParameterizedType类型，里面又是Class类型。

List外层是ParameterizedType类型，里面是TypeVariable类型。

List[]外层是GenericArrayType类型，里面是ParameterizedType类型，再里面是TypeVariable类型。

List外层是ParameterizedType类型，里面是WildcardType类型。

介绍一种泛型特殊的使用场景：

public class MapperRegistry {

  //泛型没有定义在类型，方法中使用到了泛型T（不管是参数列表还是返回值）,因此需要在该方法上
  //定义泛型，若方法中没有使用到泛型，可以不用写
  @SuppressWarnings("unchecked")
  public  T getMapper(Class type, SqlSession sqlSession) {
    final MapperProxyFactory mapperProxyFactory = (MapperProxyFactory) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }

  //Class和Class的区别
  //Class: T类型
  //Class: 通配类型，比如Class[]则数组中的元素可以是任意类型的Class
  //Class[]则数组中的元素可以是T类型的Class
  public void addMappers(String packageName, Class superType) {
    ResolverUtil> resolverUtil = new ResolverUtil>();
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set>> mapperSet = resolverUtil.getClasses();
    for (Class mapperClass : mapperSet) {
      addMapper(mapperClass);
    }
  }
}

下面通过一个例子，解析如何在复杂的类继承关系和泛型定义中确认字段的类型，确定泛型的实际类型。

class ClassA {
    protected Map map;
}

class SubClassA extends ClassA {
}

class TestType {
    SubClassA sa = new SubClassA<>();

    public static void main(String[] args) throws NoSuchFieldException {
        //确定map中泛型的具体类型
        Field f = ClassA.class.getDeclaredField("map");
        Type type = TypeParameterResolver.resolveFieldType(f, TestType.class.getDeclaredField("sa").getGenericType());
        System.out.println(type);
    }
}

//打印结果：ParameterizedTypeImpl [rawType=interface java.util.Map, ownerType=null,actualTypeArguments=[class java.lang.Long, class java.lang.Long]]
//这是一个泛型类型，rawType是Map类型，k,v都是Long类型。

  public static Type resolveFieldType(Field field, Type srcType) {
    //获取map的声明类型，Map
    Type fieldType = field.getGenericType();
    //获取map所在类的Class类型，ClassA
    Class declaringClass = field.getDeclaringClass();
    //srcType表示确定K,V类型查找的开始位置。
    return resolveType(fieldType, srcType, declaringClass);
  }
  private static Type resolveType(Type type, Type srcType, Class declaringClass) {
    //根据type的类型选择合适的方法解析
    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 ParameterizedType resolveParameterizedType(ParameterizedType parameterizedType, Type srcType, Class declaringClass) {
    //获取Map的原始类型，Map
    Class rawType = (Class) parameterizedType.getRawType();
    //获取Map的实际类型，K/V
    Type[] typeArgs = parameterizedType.getActualTypeArguments();
    //args是实际确认的类型，此处是Long,Long
    Type[] args = new Type[typeArgs.length];
    for (int i = 0; i < typeArgs.length; i++) {
      if (typeArgs[i] instanceof TypeVariable) {
        //K,V是类型变量，走这个分支
        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];
      }
    }
    //返回ParameterizedTypeResolver的内部类，rawType:Map,args:Long,Long
    return new ParameterizedTypeImpl(rawType, null, args);
  }
  private static Type resolveTypeVar(TypeVariable typeVar, Type srcType, Class declaringClass) {
    Type result = null;
    Class clazz = null;
    if (srcType instanceof Class) {
      clazz = (Class) srcType;
    } else if (srcType instanceof ParameterizedType) {
      //srcType的原始类型是SubClassA
      ParameterizedType parameterizedType = (ParameterizedType) srcType;
      clazz = (Class) parameterizedType.getRawType();
    } else {
      throw new IllegalArgumentException("The 2nd arg must be Class or ParameterizedType, but was: " + srcType.getClass());
    }

    //相等表示需要解析的字段map是在SubClassA中，不使用上述示例
    if (clazz == declaringClass) {
      Type[] bounds = typeVar.getBounds();
      if(bounds.length > 0) {
        return bounds[0];
      }
      return Object.class;
    }

    //获取父类的声明类型，ClassA
    Type superclass = clazz.getGenericSuperclass();
    //递归整个继承结构，完成变量的解析工作
    //类型对应：K,SubClassA,ClassA,SubClassA,ClassA
    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;
  }
 //见下图的解析流程  
 private static Type scanSuperTypes(TypeVariable typeVar, Type srcType, Class declaringClass, Class clazz, Type superclass) {
    Type result = null;
    if (superclass instanceof ParameterizedType) {
      ParameterizedType parentAsType = (ParameterizedType) superclass;
      Class parentAsClass = (Class) parentAsType.getRawType();
      if (declaringClass == parentAsClass) {
        Type[] typeArgs = parentAsType.getActualTypeArguments();
        TypeVariable[] declaredTypeVars = declaringClass.getTypeParameters();
        for (int i = 0; i < declaredTypeVars.length; i++) {
          if (declaredTypeVars[i] == typeVar) {
            if (typeArgs[i] instanceof TypeVariable) {
              TypeVariable[] typeParams = clazz.getTypeParameters();
              for (int j = 0; j < typeParams.length; j++) {
                if (typeParams[j] == typeArgs[i]) {
                  if (srcType instanceof ParameterizedType) {
                    result = ((ParameterizedType) srcType).getActualTypeArguments()[j];
                  }
                  break;
                }
              }
            } else {
              result = typeArgs[i];
            }
          }
        }
      } else if (declaringClass.isAssignableFrom(parentAsClass)) {
        result = resolveTypeVar(typeVar, parentAsType, declaringClass);
      }
    } else if (superclass instanceof Class) {
      if (declaringClass.isAssignableFrom((Class) superclass)) {
        result = resolveTypeVar(typeVar, superclass, declaringClass);
      }
    }
    return result;
  }

反射模块_第2张图片

三、ObjectFactory

mybatis中很多地方都会用到ObjectFactory，通过对象工厂可创建指定类型的对象。DefaultObjectFactory是ObjectFactory的唯一实现。通过mybatis-config.xml中的配置可自定义ObjectFactory实现类。

四、Property工具集

PropertyTokenizer：解析mapper文件中的"."和"[]"符号。继承Iterator，可迭代处理。

//以orders[0].id为例，第一次调用PropertyTokenizer的构造方法时
//name:orders
//indexedName:orders[0]
//index:0
//children:id
public class PropertyTokenizer implements Iterator {
  private String name;
  private String indexedName;
  private String index;
  private String children;

  public PropertyTokenizer(String fullname) {
    int delim = fullname.indexOf('.');
    if (delim > -1) {
      name = fullname.substring(0, delim);
      children = fullname.substring(delim + 1);
    } else {
      name = fullname;
      children = null;
    }
    indexedName = name;
    delim = name.indexOf('[');
    if (delim > -1) {
      index = name.substring(delim + 1, name.length() - 1);
      name = name.substring(0, delim);
    }
  }
}

当需要解析的属性很复杂时，需要对PropertyTokenizer进行迭代处理。迭代的效果如下图。

  public PropertyTokenizer next() {
    return new PropertyTokenizer(children);
  }

反射模块_第3张图片

PropertyNamer：主要完成类中方法名到属性名的转换，具体实现主要是将方法中的set/get/is前缀去除。

PropertyCopier：属性拷贝工具类，主要完成相同类型的两个对象的属性拷贝。类似于BeanUtils、BeanCopier。

五、MetaClass

通过Reflector和PropertyTokenizer的组合，完成了对复杂属性表达式的解析。也可判断复杂属性是否有getter/setter方法。假设有一个用户对象User，订单对象Order，一个用户可以持有多个订单。

  //reflectorFactory的缓存中取reflector信息
  private ReflectorFactory reflectorFactory;
  //类的元信息
  private Reflector reflector;

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

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

MetaClass的主要方法有findProperty(name)、hasGetter(name)、hasSetter(name)方法，下面逐一讲解。

findProperty(name)：完成复杂属性的验证工作（只查找 . 的导航的属性，不检查下标），如从User实体类中查找order.id属性是否存在，这里并不是直接验证User类中是否有order.id属性，而是先判断User中是否有order属性，再判断Order中是否有id属性。（注：User中持有Order对象）

  //以order.id为例， 验证order.id是否有效，无效返回null，有效返回order.id
  public String findProperty(String name) {
    StringBuilder prop = buildProperty(name, new StringBuilder());
    return prop.length() > 0 ? prop.toString() : null;
  }

  private StringBuilder buildProperty(String name, StringBuilder builder) {
    //属性做分割，name:order,children:id
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
      //从reflector中查找属性，为查到直接结束
      String propertyName = reflector.findPropertyName(prop.getName());
      if (propertyName != null) {
        builder.append(propertyName);
        builder.append(".");
        //查到后获取order对应的类型，Order
        MetaClass metaProp = metaClassForProperty(propertyName);
        //递归查找id属性是否在Order中有效
        metaProp.buildProperty(prop.getChildren(), builder);
      }
    } else {
      //简单属性走这步，这也是递归的出口
      String propertyName = reflector.findPropertyName(name);
      if (propertyName != null) {
        builder.append(propertyName);
      }
    }
    //结果是order.id
    return builder;
  }

  //根据属性的类型，创建对应的MetaClass对象。
  public MetaClass metaClassForProperty(String name) {
    Class propType = reflector.getGetterType(name);
    return MetaClass.forClass(propType, reflectorFactory);
  }

hasGetter(name)：判断复杂属性是否存在getter方法，如orders[0].id，先判断User中orders是否有getter方法，再判断Order中id是否有getter方法。

 //以orders[0].id为例
 public boolean hasGetter(String name) {
    //name: orders, indexedName: orders[0], index: 0, children: id
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
      //存在children，判断User的orders属性是否存在
      if (reflector.hasGetter(prop.getName())) {
        //判断orders属性的类型，注意我们这里希望查找到的是Order类型，而不是List类型
        //因为id属性应该是在Order类中的。
        MetaClass metaProp = metaClassForProperty(prop);
        //递归判断children是否有getter方法
        return metaProp.hasGetter(prop.getChildren());
      } else {
        return false;
      }
    } else {
      //递归的出口
      return reflector.hasGetter(prop.getName());
    }
  }

  //获取orders的实际类型，根据此类型创建MetaClass对象。
  private MetaClass metaClassForProperty(PropertyTokenizer prop) {
    Class propType = getGetterType(prop);
    return MetaClass.forClass(propType, reflectorFactory);
  }
  //获取属性的getter方法返回类型  
  private Class getGetterType(PropertyTokenizer prop) {
    //type为集合类型，prop为orders[0]带有索引下标
    Class type = reflector.getGetterType(prop.getName());
    if (prop.getIndex() != null && Collection.class.isAssignableFrom(type)) {
      //获取orders的类型，应该是List
      Type returnType = getGenericGetterType(prop.getName());
      if (returnType instanceof ParameterizedType) {
        //泛型的具体类型Order
        Type[] actualTypeArguments = ((ParameterizedType) returnType).getActualTypeArguments();
        if (actualTypeArguments != null && actualTypeArguments.length == 1) {
          returnType = actualTypeArguments[0];
          if (returnType instanceof Class) {
            type = (Class) returnType;
          } else if (returnType instanceof ParameterizedType) {
            type = (Class) ((ParameterizedType) returnType).getRawType();
          }
        }
      }
    }
    //简单属性，直接返回类型
    return type;
  }


  //如果属性orders有getter方法，TypeParameterResolver从getter方法中获取返回值类型
  //属性无getter方法，TypeParameterResolver从orders字段定义中获取类型
  private Type getGenericGetterType(String propertyName) {
    try {
      Invoker invoker = reflector.getGetInvoker(propertyName);
      if (invoker instanceof MethodInvoker) {
        Field _method = MethodInvoker.class.getDeclaredField("method");
        _method.setAccessible(true);
        Method method = (Method) _method.get(invoker);
        return TypeParameterResolver.resolveReturnType(method, reflector.getType());
      } else if (invoker instanceof GetFieldInvoker) {
        Field _field = GetFieldInvoker.class.getDeclaredField("field");
        _field.setAccessible(true);
        Field field = (Field) _field.get(invoker);
        return TypeParameterResolver.resolveFieldType(field, reflector.getType());
      }
    } catch (NoSuchFieldException e) {
    } catch (IllegalAccessException e) {
    }
    return null;
  }

hasSetter(name)：递归判断复杂属性是否有setter方法。

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

  public MetaClass metaClassForProperty(String name) {
    //直接从reflector中获取属性的类型
    Class propType = reflector.getGetterType(name);
    return MetaClass.forClass(propType, reflectorFactory);
  }

六、ObjectWrapper

通过ObjectWrapperFactory创建ObjectWrapper，ObjectWrapperFactory的实现类DefaultObjectWrapperFactory不可用，需要自己通过mybatis-config.xml扩展自定义的实现类。ObjectWrapper的实现类包含是BaseWrapper(抽象类)、CollectionWrapper。它们是解析复杂属性表达式的最终处理类，提供了set、get等方法。

BaseWrapper是抽象类，封装了MetaObject(解析复杂属性表达式解析类)，其实现类包含BeanWrapper、MapWrapper。

BeanWrapper封装了Object object；MapWrapper封装了Map object；CollectionObject封装了Collection object。

复杂属性值的获取最终是从ObjectWrapper封装的对象中拿到的。

七、MetaObject

解析复杂属性表达式解析类，它描述了解析的过程。如orders[0].id; order.id; orders[0]等表达式的解析。在MetaObject中类级别的方法一般是调用MetaClass完成的，对象级别的方法一般配合ObjectWrapper完成。

public class MetaObject {
  //原始javabean对象
  private Object originalObject;
  //objectWrapper对象，封装了originalObject
  private ObjectWrapper objectWrapper;
  //实例化originalObject的工厂类
  private ObjectFactory objectFactory;
  //创建objectWrapper的工厂对象
  private ObjectWrapperFactory objectWrapperFactory;
  //创建并缓存reflector的工厂对象
  private ReflectorFactory reflectorFactory;
}

 

你可能感兴趣的:(Mybatis源码分析)

  • mybatis源码分析-资源加载-下篇 cjxz
    处理mapper节点构造函数中已经有很多很多默认类型匹配。这就是为什么在写sql的时候返回类型会自动映射到相应的java类型上面，这里已经处理好了。继续看最复杂的mapper在上面处理configuration节点的最后一句mapperElement(root.evalNode("mappers"));。这个是配置文件里面最复杂的，所以再处理上面Mybatis多写了两个类专门处理mapper数据X
  • 2.10、mybatis源码分析之sql执行过程以select为例 小manong
    在研究select执行过程之前先来介绍一个重要的类一、SqlNode和SqlSource在myabtis初始化过程中可以知道，映射配置文件中的sql节点会被解析为MappedStatement对象，其中sql语句解析成SqlSource对象，sql语句中定义的Sql节点、文本节点等，则由SqlNode接口的响应实现。1、SqlSource接口SqlSource接口结构publicinterface
  • Mybatis系列-tkmybatis源码分析-01-mybatis、mybatis-spring和tkmybatis的关系 tinygodd MybatisspringboottkMybatismybatismybatis-spring
    mybatis、mybatis-spring和tkmybatis的关系定义MyBatis是一款优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。MyBatis可以通过简单的XML或注解来配置和映射原始类型、接口和JavaPOJO（PlainOldJavaObjects，普通老式Java对象）为数据库中的记录。MyB
  • MyBatis 源码分析（五）：异常模块 小徐很努力 源码解读mybatisjava开发语言
    1、前言上一篇我们解了Mybatis解析器模块，本篇我们来了解反射模块。本文，我们来分享MyBatis的异常模块。对应exceptions包，如下图所示：在MyBatis源码分析（二）：项目结构中，简单介绍了这个模块：定义了MyBatis专有的PersistenceException和TooManyResultsException异常。实际上，MyBatis不仅仅在exceptions包下有异常，
  • MyBatis源码分析（六）：数据源模块 小徐很努力 源码解读mybatis
    1.概述本文，我们来分享MyBatis的数据源模块，对应datasource包。如下图所示：在MyBatis源码分析（二）：项目结构中，简单介绍了这个模块如下：数据源是实际开发中常用的组件之一。现在开源的数据源都提供了比较丰富的功能，例如，连接池功能、检测连接状态等，选择性能优秀的数据源组件对于提升ORM框架乃至整个应用的性能都是非常重要的。MyBatis自身提供了相应的数据源实现，当然MyBat
  • MyBatis源码分析（二）：项目结构 小徐很努力 源码解读mybatisjava开发语言
    目录1、前言2、代码统计3、整体架构3.1、基础支持层3.1.1、反射模块3.1.2、类型模块3.1.3、日志模块3.1.4、IO模块3.1.5、解析器模块3.1.6、数据源模块3.1.7、缓存模块3.1.8、Binding模块3.1.9、注解模块3.1.10、异常模块3.2、核心处理层3.2.1、配置解析模块3.2.2、SQL解析模块3.2.3、插件模块3.3、接口层3.3.1、session模
  • MyBatis 源码分析（四）：反射模块 小徐很努力 源码解读java开发语言mybatis
    前言上一篇我们了解了Mybatis解析器模块，MyBatis源码分析（三）：解析器模块本篇我们来了解反射模块。相比parsing包来说，reflection包的代码量大概是2-3倍。当然，不要慌，都是比较简单的代码。当然，这是一篇非常非常非常长的博客，如果想要比较好的理解这个模块，一定要基于MyBatis提供的这个模块的单元测试，多多调试。对应reflection包。如下图所示：在MyBatis源
  • MyBatis源码分析（三）：解析器模块 小徐很努力 源码解读mybatisjava开发语言
    目录1、前言2、源码分析2.1、XPathParser2.1.1、属性讲解2.1.2、构造方法讲解2.2、eval方法2.2.1、eval元素2.2.2、eval节点2.3、XMLMapperEntityResolver2.4、PropertyParser2.5、GenericTokenParser2.6、TokenHandler2.6.1VariableTokenHandler2.6.2hand
  • MyBatis源码分析（一）：搭建调试环境 小徐很努力 源码解读mybatis
    目录拉取源码安装环境调试测试1、mybatis-config.xml2、AutoConstructorMapper.xml3、AutoConstructorMapper4、CreateDB.sql5、POJO5.1AnnotatedSubject5.2、PrimitiveSubject5.3、BadSubject5.4、ExtensiveSubject6、AutoConstructorTest6.
  • Mybatis源码分析:@Mapkey的使用 辰鬼丫 SpringSpringMVCMyBatisjavajavaspring
    @Mapkey的使用在多值查询的时候,通常要把方法返回类型设置为List类型,Mybatis为我们提供了另一种解决方式,通过K-V的形式将查询结果保存在Map中,这种实现方式只需要在方法上标注为@Mapkey即可。如下代码:查询一个学生表,包含id,name,age三个字段，使用@mapkey将id号作为K,查询结果作为V.使用@Mapkey时最好将K设置为唯一的,否则后续的结果将会覆盖已查询到的
  • Mybatis 使用记录 antRain Spring+springbootmybatis
    Mybatis使用记录Mybatis下载源码编译democonfig.propertiesmybatis-config.xmlUserMapper.xml测试代码mybatis-spring下载编译demomybatis-spring-boot-starter测试demomybatisplus编译Mybatis下载源码编译参考mybatis源码分析00：获取源码及demo准备org.mybatis
  • MyBatis源码分析之核心流程介绍(下) 波波烤鸭 深入浅出Mybatis专栏mybatis源码分析
      接上一篇我们继续来介绍1.SqlSession程序每一次操作数据库，都需要创建一个会话，我们用openSession()方法来创建。接下来我们看看SqlSession创建过程中做了哪些操作SqlSessionsqlSession=factory.openSession();通过前面创建的DefaultSqlSessionFactory的openSession方法来创建@Overridepubl
  • MyBatis源码分析之核心流程介绍(上) 波波烤鸭 深入浅出Mybatis专栏mybatis源码分析
      本文我们来看看MyBatis的核心流程核心流程分析  首先来看看MyBatis的主要工作流程图  分析源码我们还是从编程式的Demo入手/***MyBatisgetMapper方法的使用*/@Testpublicvoidtest2()throwsException{//1.获取配置文件InputStreami
  • Mybatis源码分析——结果集ResultSet自动映射成实体类对象 小波同学
    前言上一篇文章我们已经将SQL发送到了数据库，并返回了ResultSet，接下来就是将结果集ResultSet自动映射成实体类对象。这样使用者就无需再手动操作结果集，并将数据填充到实体类对象中。这可大大降低开发的工作量，提高工作效率。映射结果入口我们来看看上次看源码的位置publicclassPreparedStatementHandlerextendsBaseStatementHandler{@
  • Mybatis 源码分析（四）之 Mybatis 的执行流程梳理 挂机的啊洋zzZ
    mybatis.pngMybatis源码分析（四）之Mybatis整体的执行流程前面了解到Mybatis的执行流程，首先读取我们的mybatis-config.xml配置文件，然后构建Configuration类，这个类会像上下文信息一样会传来传去，以便我们获取其中的信息。构建Configuration过程中，会读取我们的配置信息，其中包含读取我们的mapper的配置，并将mapper的信息以ke
  • [MyBatis源码分析 - 数据源模块] 小胡_鸭
    一、简介  数据源是实际开发中常用的组件之一。现在开源的数据源都提供了比较丰富的功能，例如，连接池功能、检测连接状态等，选择性能优秀的数据源组件对于提升ORM框架乃至整个应用的性能都是非常重要的。  MyBatis自身提供了相应的数据源实现，当然MyBatis也提供了与第三方数据源集成的接口，这些功能都位于数据源模块之中，该模块位于org.apache.ibatis.datasource包中，相关
  • MyBatis源码分析 拧螺丝专业户 mybatis
    MyBatis源码分析MyBatis是常用的持久层框架，帮助我们减少了很多的访问数据库的代码。这次我们就来看看MyBatis是怎么做到这些的？看看它里面用到了哪些值得我们借鉴的技术。一、示例程序为了方便后续在本地进行debug调试，首先准备一个示例程序。1、项目工程结构2、父工程pom.xml文件内容：4.0.0org.examplekeepLearnOnMavenpom1.0-SNAPSHOTs
  • 8 Mybatis源码分析 刺豚灬 #Springspring
    1.3.2源码执行流程1.通过@MapperScan导入了MapperScannerRegistrar类2.MapperScannerRegistrar类实现了ImportBeanDefinitionRegistrar接口，所以Spring在启动时会调用MapperScannerRegistrar类中的registerBeanDefinitions方法3.在registerBeanDefiniti
  • Mybatis源码分析(01)-JDBC操作回顾，Mybatis整体架构概览 couthz
    一JDBC的规范操作及问题回顾假设数据库test中有一张表account直接使用JDBC，dao层的实现类可能会是如下的写法：publicclassAccountDaoImplimplementsAccountDao{//问题1:数据库配置信息，存在硬编码问题，修改信息就要重新编译privateStringdriver="com.mysql.jdbc.driver";privateStringur
  • Mybatis源码分析（二）Mybatis-config.xml的初始化 长安不及十里 #Mybatis源码分析mybatisjava源码分析学习文件读写
    目录一环境搭建二配置文件初始化2.1ClassLoader2.1.1Java类加载器2.2获取配置文件三扩展3.1VFS3.1.1DefaultVFS3.1.2JBoss6VFS3.2ResolverUtil工具类（重庆）涂鸦一条街系列文章：文章状态时间描述（一）Mybatis基本使用已复习2022-12-14对Mybtais的基本使用，能够开发（二）Mybatis-config.xml的初始化已
  • mybatis源码分析一(加载配置文件) 为梦想前进
    最近一直在看mybatis源码,稍有心得,接下来就然我们一起看下springboot整合mybatis的源码的步骤是怎样的废话不多说,咱们就一起看看源码吧首先,咱们看下配置文件,下面是我配置的配置文件,没什么多说的,都是基本配置,映射文件的位置,实体类的位置,数据库的基本信息等之前一直有个疑问,就是咱们在配置文件中写这些配置的时候都会自动提示,一直不知道是怎么回事,看了源码,才知道原因,原来,在s
  • Mybatis源码分析-一级缓存【BaseExecutor】 你看起来很好吃_fb4a
    本文主题：Executor执行体系回顾为什么要有一级缓存？一级缓存、二级缓存有什么区别？一级缓存属于通用逻辑，那么结构上它是如何设计的？一级缓存是用什么实现的？一级缓存命中条件有哪些？一级缓存有哪些清空场景？Spring和Mybatis整合一级缓存失效？一级缓存的注意事项Executor执行体系Executor执行体系.png这是从SqlSession到Executor实现的执行体系图，从图中可以
  • 一周学完MyBatis源码，万字总结 互联网全栈架构 数据库mybatismysqlspringjava
    关注公众号“java后端技术全栈”回复“000”获取优质面试资料大家好，我是老田。之前，我给大家分享给很多MyBatis源码分析的一系列文章。今天，就自己的感受来做一个整体的总结。众所周知，MyBatis是对JDBC进行封装而成的产品，所以，聊MyBatis源码之前我们得先了解JDBC。推荐：JDBC这个问题，问的小伙伴一脸懵逼JDCBJDBC案例：public class JdbcDemo { 
  • Redis学习、缓存、持久化、哨兵模式 程序dunk 面试专题redisnosql数据库
    总结不易，如果对你有帮助，请点赞关注支持一下微信搜索程序dunk，关注公众号，获取博客源码我写代码是为了更好的表达自我，这是艺术创作，而不单单是为了把事情搞定。—Antirez序号内容1Java基础面试题2JVM面试题3Java并发编程面试4计算机网络知识点汇总5MySQL面试题6Mybatis源码分析+面试7Spring面试题8SpringMVC面试题9SpringBoot面试题10Spring
  • MyBatis源码分析 森火123 java架构javaintellij-ideamaven
    分析完了MyBatis的架构和执行流程，终于到了源码分析的章节，估计很多小伙伴的大刀都已经饥渴难耐了，好了接下来咱么就要开始“DoubleKill”了。这篇文章咱么主要根据MyBatis的执行流程，通过Debug的方式，来一步步非常详细的带着大家看下MyBatis的从加载配置文件、解析配置文件、创建四大核心对象（Executor、ParameterHandler、ResultSetHandler、
  • mybatis源码分析（一）：自己动手写一个简单的mybaits框架 猫清扬
    框架解决了什么问题目前主流的JavaWeb项目都采用SSM(springspringmvcmybatis)框架，其中mybatis框架源码是最简单的，想入手源码学习的同学很推荐从mybatis开始。本系列文章是我对mybatis源码学习的一些梳理总结，可以帮助你更高效得理解mybatis。在学习一个框架源码之前你首先要问自己几个问题。1.这个框架解决了什么问题？2.为了解决这个问题，你是如何设计的
  • Mybatis源码分析（十四）Mybatis的设计模式梳理 长安不及十里 #Mybatis源码分析mybatis设计模式java源码分析缓存
    目录一工厂模式1.1案例说明1.2源码设计模式分析二单例模式2.1案例说明2.2源码设计模式分析三代理模式3.1动态代理案例3.2源码设计模式分析四建造者模式4.1案例4.2源码设计模式分析五装饰器模式5.1代码案例5.2源码设计模式分析六组合模式6.1案例6.2源码设计模式分析系列文章：文章状态时间描述（一）Mybatis基本使用已复习2022-12-14对Mybtais的基本使用，能够开发（二
  • Mybatis源码分析 不知名的艾坤 SSMSpringBoot源码分析mybatisjava开发语言
    1.Mybatis整体三层设计SSM中，Spring、SpringMVC已经在前面文章源码分析总结过了，Mybatis源码相对Spring和SpringMVC而言是的简单的，只有一个项目，项目下分了很多包。从宏观上了解Mybatis的整体框架分为三层，分别是基础支持层、核心处理层、和接口层。如下图MyBatis的主要工作流程图2.1接口层首先接口层是我们打交道最多的。核心对象是SqlSession
  • Mybatis源码分析一-Mybatis基础架构以及设计模式，java工厂模式教程视频 m0_64383449 程序员面试java后端
    1、mybatis源码下载地址MyBatis源码下载地址：https://github.com/MyBatis/MyBatis-32、源码包导入过程：下载Mybatis源码检查Maven版本，必须是3.25以上Mybatis工程是Maven项目，JDK必须是1.8版本pom文件汇总添加true全部改为false在工程目录下执行mvncleaninstall-Dmaven.test.skip=tru
  • Mybatis源码分析一-Mybatis基础架构以及设计模式，javase项目实战 m0_65483457 程序员面试java后端
    MyBatis源码下载地址：https://github.com/MyBatis/MyBatis-32、源码包导入过程：下载Mybatis源码检查Maven版本，必须是3.25以上Mybatis工程是Maven项目，JDK必须是1.8版本pom文件汇总添加true全部改为false在工程目录下执行mvncleaninstall-Dmaven.test.skip=true将当前工程安装到本地仓库二、
  • java线程的无限循环和退出 3213213333332132 java
    最近想写一个游戏，然后碰到有关线程的问题，网上查了好多资料都没满足。 突然想起了前段时间看的有关线程的视频，于是信手拈来写了一个线程的代码片段。 希望帮助刚学java线程的童鞋 package thread; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date
  • tomcat 容器 BlueSkator tomcatWebservlet
    Tomcat的组成部分 1、server A Server element represents the entire Catalina servlet container. (Singleton) 2、service service包括多个connector以及一个engine，其职责为处理由connector获得的客户请求。   3、connector 一个connector
  • php递归,静态变量,匿名函数使用 dcj3sjt126com PHP递归函数匿名函数静态变量引用传参
      <!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <title>Current To-Do List</title> </head> <body>
  • 属性颜色字体变化 周华华 JavaScript
    function changSize(className){ var diva=byId("fot") diva.className=className; } </script> <style type="text/css"> .max{ background: #900; color:#039;
  • 将properties内容放置到map中 g21121 properties
    代码比较简单： private static Map<Object, Object> map; private static Properties p; static { //读取properties文件 InputStream is = XXX.class.getClassLoader().getResourceAsStream("xxx.properti
  • [简单]拼接字符串 53873039oycg 字符串
             工作中遇到需要从Map里面取值拼接字符串的情况，自己写了个，不是很好，欢迎提出更优雅的写法，代码如下：           import java.util.HashMap; import java.uti
  • Struts2学习 云端月影
    最近开始关注struts2的新特性，从这个版本开始，Struts开始使用convention-plugin代替codebehind-plugin来实现struts的零配置。 配置文件精简了，的确是简便了开发过程，但是，我们熟悉的配置突然disappear了，真是一下很不适应。跟着潮流走吧，看看该怎样来搞定convention-plugin。 使用Convention插件，你需要将其JAR文件放
  • Java新手入门的30个基本概念二 aijuans java新手java 入门
    基本概念:　　1.OOP中唯一关系的是对象的接口是什么,就像计算机的销售商她不管电源内部结构是怎样的,他只关系能否给你提供电就行了,也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的,不同的对象的访问通过函数调用来完成,对象间所有的交流都是通过方法调用,通过对封装对象数据,很大限度上提高复用率。　　2.OOP中最重要的思想是类,类是模板是蓝图,
  • jedis 简单使用 antlove javarediscachecommandjedis
    jedis.RedisOperationCollection.java package jedis; import org.apache.log4j.Logger; import redis.clients.jedis.Jedis; import java.util.List; import java.util.Map; import java.util.Set; pub
  • PL/SQL的函数和包体的基础 百合不是茶 PL/SQL编程函数包体显示包的具体数据包
    由于明天举要上课,所以刚刚将代码敲了一遍PL/SQL的函数和包体的实现(单例模式过几天好好的总结下再发出来);以便明天能更好的学习PL/SQL的循环,今天太累了,所以早点睡觉,明天继续PL/SQL总有一天我会将你永远的记载在心里,,,   函数; 函数:PL/SQL中的函数相当于java中的方法;函数有返回值 定义函数的 --输入姓名找到该姓名的年薪 create or re
  • Mockito(二)--实例篇 bijian1013 持续集成mockito单元测试
            学习了基本知识后，就可以实战了，Mockito的实际使用还是比较麻烦的。因为在实际使用中，最常遇到的就是需要模拟第三方类库的行为。         比如现在有一个类FTPFileTransfer，实现了向FTP传输文件的功能。这个类中使用了a
  • 精通Oracle10编程SQL(7)编写控制结构 bijian1013 oracle数据库plsql
    /* *编写控制结构 */ --条件分支语句 --简单条件判断 DECLARE v_sal NUMBER(6,2); BEGIN select sal into v_sal from emp where lower(ename)=lower('&name'); if v_sal<2000 then update emp set
  • 【Log4j二】Log4j属性文件配置详解 bit1129 log4j
    如下是一个log4j.properties的配置   log4j.rootCategory=INFO, stdout , R log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appe
  • java集合排序笔记 白糖_ java
    public class CollectionDemo implements Serializable,Comparable<CollectionDemo>{ private static final long serialVersionUID = -2958090810811192128L; private int id; private String nam
  • java导致linux负载过高的定位方法 ronin47
    定位java进程ID 可以使用top或ps -ef |grep java ![图片描述][1] 根据进程ID找到最消耗资源的java pid 比如第一步找到的进程ID为5431 执行 top -p 5431 -H ![图片描述][2] 打印java栈信息 $ jstack -l 5431 > 5431.log 在栈信息中定位具体问题 将消耗资源的Java PID转
  • 给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数 bylijinnan 函数
    import java.util.ArrayList; import java.util.List; import java.util.Random; public class RandNFromRand5 { /** 题目：给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数。 解法1： f(k) = (x0-1)*5^0+(x1-
  • PL/SQL Developer保存布局 Kai_Ge
          近日由于项目需要，数据库从DB2迁移到ORCAL，因此数据库连接客户端选择了PL/SQL Developer。由于软件运用不熟悉，造成了很多麻烦，最主要的就是进入后，左边列表有很多选项，自己删除了一些选项卡，布局很满意了，下次进入后又恢复了以前的布局，很是苦恼。在众多PL/SQL Developer使用技巧中找到如下这段：   &n
  • [未来战士计划]超能查派[剧透,慎入] comsci 计划
           非常好看,超能查派,这部电影......为我们这些热爱人工智能的工程技术人员提供一些参考意见和思想........        虽然电影里面的人物形象不是非常的可爱....但是非常的贴近现实生活....    &nbs
  • Google Map API V2 dai_lm google map
    以后如果要开发包含google map的程序就更麻烦咯 http://www.cnblogs.com/mengdd/archive/2013/01/01/2841390.html 找到篇不错的文章，大家可以参考一下 http://blog.sina.com.cn/s/blog_c2839d410101jahv.html 1. 创建Android工程 由于v2的key需要G
  • java数据计算层的几种解决方法2 datamachine javasql集算器
    2、SQL     SQL/SP/JDBC在这里属于一类，这是老牌的数据计算层，性能和灵活性是它的优势。但随着新情况的不断出现，单纯用SQL已经难以满足需求，比如： JAVA开发规模的扩大，数据量的剧增，复杂计算问题的涌现。虽然SQL得高分的指标不多，但都是权重最高的。     成熟度：5星。最成熟的。   
  • Linux下Telnet的安装与运行 dcj3sjt126com linuxtelnet
    Linux下Telnet的安装与运行   linux默认是使用SSH服务的 而不安装telnet服务  如果要使用telnet 就必须先安装相应的软件包  即使安装了软件包 默认的设置telnet 服务也是不运行的 需要手工进行设置 如果是redhat9，则在第三张光盘中找到 telnet-server-0.17-25.i386.rpm
  • PHP中钩子函数的实现与认识 dcj3sjt126com PHP
    假如有这么一段程序： function fun(){ fun1(); fun2(); }   首先程序执行完fun1()之后执行fun2()然后fun()结束。   但是，假如我们想对函数做一些变化。比如说，fun是一个解析函数，我们希望后期可以提供丰富的解析函数，而究竟用哪个函数解析，我们希望在配置文件中配置。这个时候就可以发挥钩子的力量了。   我们可以在fu
  • EOS中的WorkSpace密码修改 蕃薯耀 修改WorkSpace密码
    EOS中BPS的WorkSpace密码修改 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 201
  • SpringMVC4零配置--SpringSecurity相关配置【SpringSecurityConfig】 hanqunfeng SpringSecurity
     SpringSecurity的配置相对来说有些复杂，如果是完整的bean配置，则需要配置大量的bean，所以xml配置时使用了命名空间来简化配置，同样，spring为我们提供了一个抽象类WebSecurityConfigurerAdapter和一个注解@EnableWebMvcSecurity，达到同样减少bean配置的目的，如下：   applicationContex
  • ie 9 kendo ui中ajax跨域的问题 jackyrong AJAX跨域
    这两天遇到个问题，kendo ui的datagrid，根据json去读取数据，然后前端通过kendo ui的datagrid去渲染，但很奇怪的是，在ie 10,ie 11,chrome,firefox等浏览器中，同样的程序， 浏览起来是没问题的，但把应用放到公网上的一台服务器， 却发现如下情况： 1） ie 9下，不能出现任何数据，但用IE 9浏览器浏览本机的应用，却没任何问题
  • 不要让别人笑你不能成为程序员 lampcy 编程程序员
    在经历六个月的编程集训之后，我刚刚完成了我的第一次一对一的编码评估。但是事情并没有如我所想的那般顺利。 说实话，我感觉我的脑细胞像被轰炸过一样。 手慢慢地离开键盘，心里很压抑。不禁默默祈祷：一切都会进展顺利的，对吧？至少有些地方我的回答应该是没有遗漏的，是不是？ 难道我选择编程真的是一个巨大的错误吗——我真的永远也成不了程序员吗？ 我需要一点点安慰。在自我怀疑，不安全感和脆弱等等像龙卷风一
  • 马皇后的贤德 nannan408
       马皇后不怕朱元璋的坏脾气，并敢理直气壮地吹耳边风。众所周知，朱元璋不喜欢女人干政，他认为“后妃虽母仪天下，然不可使干政事”，因为“宠之太过，则骄恣犯分，上下失序”，因此还特地命人纂述《女诫》，以示警诫。但马皇后是个例外。 　　有一次，马皇后问朱元璋道：“如今天下老百姓安居乐业了吗？”朱元璋不高兴地回答：“这不是你应该问的。”马皇后振振有词地回敬道：“陛下是天下之父，
  • 选择某个属性值最大的那条记录（不仅仅包含指定属性，而是想要什么属性都可以） Rainbow702 sqlgroup by最大值max最大的那条记录
    好久好久不写SQL了，技能退化严重啊！！！   直入主题： 比如我有一张表，file_info， 它有两个属性（但实际不只，我这里只是作说明用）： file_code, file_version 同一个code可能对应多个version 现在，我想针对每一个code，取得它相关的记录中，version 值 最大的那条记录， SQL如下： select *
  • VBScript脚本语言 tntxia VBScript
      VBScript 是基于VB的脚本语言。主要用于Asp和Excel的编程。   VB家族语言简介   Visual Basic 6.0           源于BASIC语言。           由微软公司开发的包含协助开发环境的事
  • java中枚举类型的使用 xiao1zhao2 javaenum枚举1.5新特性
    枚举类型是j2se在1.5引入的新的类型,通过关键字enum来定义,常用来存储一些常量.   1.定义一个简单的枚举类型 public enum Sex { MAN, WOMAN }   枚举类型本质是类,编译此段代码会生成.class文件.通过Sex.MAN来访问Sex中的成员,其返回值是Sex类型.   2.常用方法 静态的values()方