예제 #1
0
 private void settingsElement(XNode context) throws Exception {
   if (context != null) {
     Properties props = context.getChildrenAsProperties();
     // Check that all settings are known to the configuration class
     MetaClass metaConfig = MetaClass.forClass(Configuration.class);
     for (Object key : props.keySet()) {
       if (!metaConfig.hasSetter(String.valueOf(key))) {
         throw new BuilderException(
             "The setting "
                 + key
                 + " is not known.  Make sure you spelled it correctly (case sensitive).");
       }
     }
     configuration.setAutoMappingBehavior(
         AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
     configuration.setCacheEnabled(booleanValueOf(props.getProperty("cacheEnabled"), true));
     configuration.setProxyFactory(
         (ProxyFactory) createInstance(props.getProperty("proxyFactory")));
     configuration.setLazyLoadingEnabled(
         booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
     configuration.setAggressiveLazyLoading(
         booleanValueOf(props.getProperty("aggressiveLazyLoading"), true));
     configuration.setMultipleResultSetsEnabled(
         booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
     configuration.setUseColumnLabel(booleanValueOf(props.getProperty("useColumnLabel"), true));
     configuration.setUseGeneratedKeys(
         booleanValueOf(props.getProperty("useGeneratedKeys"), false));
     configuration.setDefaultExecutorType(
         ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));
     configuration.setDefaultStatementTimeout(
         integerValueOf(props.getProperty("defaultStatementTimeout"), null));
     configuration.setMapUnderscoreToCamelCase(
         booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
     configuration.setSafeRowBoundsEnabled(
         booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
     configuration.setLocalCacheScope(
         LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));
     configuration.setJdbcTypeForNull(
         JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
     configuration.setLazyLoadTriggerMethods(
         stringSetValueOf(
             props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
     configuration.setSafeResultHandlerEnabled(
         booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
     configuration.setDefaultScriptingLanguage(
         resolveClass(props.getProperty("defaultScriptingLanguage")));
     configuration.setCallSettersOnNulls(
         booleanValueOf(props.getProperty("callSettersOnNulls"), false));
     configuration.setLogPrefix(props.getProperty("logPrefix"));
     configuration.setLogImpl(resolveClass(props.getProperty("logImpl")));
     configuration.setConfigurationFactory(
         resolveClass(props.getProperty("configurationFactory")));
   }
 }
예제 #2
0
  public static <T> T populate(
      Configuration configuration,
      Class<?> entityClass,
      T entity,
      Map<String, Object> resultMap,
      boolean isMapUnderscoreToCamelCase) {
    MetaClass metaClass = MetaClass.forClass(entityClass, configuration.getReflectorFactory());

    for (String key : resultMap.keySet()) {
      String property = metaClass.findProperty(key, isMapUnderscoreToCamelCase);
      if (property == null) {
        property =
            metaClass.findProperty(
                key.replace("_id", ""),
                isMapUnderscoreToCamelCase); // just for association entity property
        if (property == null) {
          property = getPropertyNameForAssociationEntity(entityClass, metaClass, key);
        }
      }

      if (property != null && metaClass.hasSetter(property)) {
        Object value = resultMap.get(key);
        try {
          Method getterMethod = findGetterMethod(property, entityClass);

          // Handle the property that annotated by {#link Enumerated}.
          Enumerated enumrated = AnnotationUtils.findAnnotation(getterMethod, Enumerated.class);
          if (enumrated != null) {
            Class<?> returnType = getterMethod.getReturnType();
            if (enumrated.value() == EnumType.STRING) {
              value = Enum.valueOf(returnType.asSubclass(Enum.class), String.valueOf(value));
            } else {
              value = returnType.asSubclass(Enum.class).getEnumConstants()[(int) value];
            }
          }

          // Handler the property that annotated by {#link Association}
          Association association = AnnotationUtils.findAnnotation(getterMethod, Association.class);
          if (association != null) {
            Class<?> returnType = getterMethod.getReturnType();
            MetaClass associationMetaClass =
                MetaClass.forClass(returnType, configuration.getReflectorFactory());
            Invoker m = associationMetaClass.getSetInvoker("id");
            Object associationEntity = returnType.newInstance();
            Object[] params = {value};
            m.invoke(associationEntity, params);
            value = associationEntity;
          }

          Invoker method = metaClass.getSetInvoker(property);
          Object[] params = {value};
          try {
            method.invoke(entity, params);
          } catch (Throwable t) {
            throw ExceptionUtil.unwrapThrowable(t);
          }
        } catch (Throwable t) {
          throw new ReflectionException(
              "Could not set property '"
                  + property
                  + "' of '"
                  + entityClass
                  + "' with value '"
                  + value
                  + "' Cause: "
                  + t.toString(),
              t);
        }
      }
    }

    return entity;
  }