Example #1
0
  @Test
  public void shouldEnableAndThenDisableAccessibility() throws Exception {
    // given
    Field privateField = SomeObject.class.getDeclaredField("privateField");
    assertFalse(privateField.isAccessible());

    // when
    tool.copyToMock(from, to);

    // then
    privateField = SomeObject.class.getDeclaredField("privateField");
    assertFalse(privateField.isAccessible());
  }
  public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {

    Object obj = context.currentObject();
    if (obj == null) {
      try {
        obj = context.getRequiredType().newInstance();
      } catch (Exception e) {
        throw new ObjectAccessException(
            "Cannot construct " + context.getRequiredType().getName(), e);
      }
    }

    Iterator attNames = reader.getAttributeNames();
    while (attNames.hasNext()) {
      String attName = (String) attNames.next();
      if (attName.equals(textName)) {
        continue;
      }

      try {
        Field field = obj.getClass().getDeclaredField(mapper.realMember(obj.getClass(), attName));
        if (!field.isAccessible()) {
          field.setAccessible(true);
        }
        String v = reader.getAttribute(attName);
        if (null == v || "".equals(v)) {
          continue;
        }
        Class fieldType = field.getType();
        Constructor strnum = fieldType.getDeclaredConstructor(String.class);
        field.set(obj, strnum.newInstance(v));
      } catch (Exception e) {
        e.printStackTrace();
        throw new ObjectAccessException("Cannot construct " + obj.getClass(), e);
      }
    }
    String value = reader.getValue();
    if (null != value && !"".equals(value)) {
      try {
        Field field = obj.getClass().getDeclaredField(mapper.realMember(obj.getClass(), textName));
        if (!field.isAccessible()) {
          field.setAccessible(true);
        }
        field.set(obj, value);
      } catch (Exception e) {
        e.printStackTrace();
        throw new ObjectAccessException("Cannot construct " + obj.getClass(), e);
      }
    }
    return obj;
  }
Example #3
0
 public static void CombinationValue(
     Object paramObject1, Object paramObject2, Class<?> paramClass) {
   if (paramObject1 == null) {
     throw new IllegalArgumentException("源对象为空无法拷贝!");
   }
   if (paramObject2 == null) {
     throw new IllegalArgumentException("目标对象为空无法拷贝!");
   }
   if ((paramObject2 instanceof HibernateProxy)) {
     HibernateProxy localObject1 = (HibernateProxy) paramObject2;
     paramObject2 =
         ((HibernateProxy) localObject1).getHibernateLazyInitializer().getImplementation();
   }
   Object localObject1 = getFieldList(paramObject1, paramClass);
   List localList = getFieldList(paramObject2, paramClass);
   Iterator localIterator1 = ((List) localObject1).iterator();
   while (localIterator1.hasNext()) {
     Field localField1 = (Field) localIterator1.next();
     Iterator localIterator2 = localList.iterator();
     while (localIterator2.hasNext()) {
       Field localField2 = (Field) localIterator2.next();
       if ((localField1.getName().equals(localField2.getName()))
           && (localField1.getType().equals(localField2.getType()))
           && (!Modifier.isFinal(localField2.getModifiers()))) {
         if (!localField1.isAccessible()) {
           localField1.setAccessible(true);
         }
         if (!localField2.isAccessible()) {
           localField2.setAccessible(true);
         }
         try {
           Object localObject2 = localField1.get(paramObject1);
           if (localObject2 == null) {
             break;
           }
           if ((localObject2 instanceof StandardModel)) {
             CombinationValue(localObject2, localField2.get(paramObject2));
           } else {
             localField2.set(paramObject2, localObject2);
           }
         } catch (IllegalArgumentException localIllegalArgumentException) {
           localIllegalArgumentException.printStackTrace();
         } catch (IllegalAccessException localIllegalAccessException) {
           localIllegalAccessException.printStackTrace();
         }
       }
     }
   }
 }
 /**
  * The value of field {@code field} of object {@code object}, returned with static type {@code
  * expectedType}. The value is read, even on private fields. The security settings must allow
  * this.
  */
 @MethodContract(
     pre = {
       @Expression("object != null"),
       @Expression("field != null"),
       @Expression("expectedType != null")
     },
     post = @Expression("field.get(object)"),
     exc =
         @Throw(
             type = ClassCastException.class,
             cond = @Expression("! fieldValue(object, field) instanceof expectedType")))
 public static final <_T_> _T_ fieldValue(Object object, Field field, Class<_T_> expectedType)
     throws ClassCastException {
   assert preArgumentNotNull(object, "object");
   assert preArgumentNotNull(field, "field");
   assert preArgumentNotNull(expectedType, "expectedType");
   boolean oldAccessible = field.isAccessible();
   field.setAccessible(true);
   _T_ result = null;
   try {
     result = expectedType.cast(field.get(object)); // ClassCastException
   } catch (IllegalArgumentException exc) {
     unexpectedException(exc);
   } catch (IllegalAccessException exc) {
     unexpectedException(exc);
   }
   field.setAccessible(oldAccessible);
   return result;
 }
  /**
   * Dynamically register a native library path. This relies on a specific implementation detail of
   * ClassLoader: it's usr_paths property.
   *
   * @param path Library path to add
   * @return {@code true} if the library path could be added successfully
   */
  protected boolean registerNativeLibraryPath(String path) {
    if (path == null) {
      throw new NullPointerException();
    }
    path = path.trim();
    try {
      Field f = ClassLoader.class.getDeclaredField("usr_paths");
      boolean accessible = f.isAccessible();
      f.setAccessible(true);
      try {
        String[] paths = (String[]) f.get(null);

        // Make sure the path isn't already registered
        for (String p : paths) {
          if (p.equals(path)) {
            return true; // Success, it's already there!
          }
        }

        String[] newPaths = new String[paths.length + 1];
        System.arraycopy(paths, 0, newPaths, 0, paths.length);
        newPaths[paths.length] = path;
        f.set(null, newPaths);
        // Success!
        return true;
      } finally {
        f.setAccessible(accessible);
      }
    } catch (Exception ex) {
      // Something went wrong, definitely not successful
      return false;
    }
  }
Example #6
0
 private void addFields(Class<?> clazz) {
   Field[] fields = clazz.getDeclaredFields();
   for (Field field : fields) {
     if (canAccessPrivateMethods()) {
       try {
         field.setAccessible(true);
       } catch (Exception e) {
         // Ignored. This is only a final precaution, nothing we can do.
       }
     }
     if (field.isAccessible()) {
       if (!setMethods.containsKey(field.getName())) {
         // issue #379 - removed the check for final because JDK 1.5 allows
         // modification of final fields through reflection (JSR-133). (JGB)
         // pr #16 - final static can only be set by the classloader
         int modifiers = field.getModifiers();
         if (!(Modifier.isFinal(modifiers) && Modifier.isStatic(modifiers))) {
           addSetField(field);
         }
       }
       if (!getMethods.containsKey(field.getName())) {
         addGetField(field);
       }
     }
   }
   if (clazz.getSuperclass() != null) {
     addFields(clazz.getSuperclass());
   }
 }
Example #7
0
 /**
  * 为对象的一个字段设值。 优先调用对象的 setter,如果没有,直接设置字段的值
  *
  * @param obj 对象
  * @param field 字段
  * @param value 值。如果为 null,字符和数字字段,都会设成 0
  * @throws FailToSetValueException
  */
 public void setValue(Object obj, Field field, Object value) throws FailToSetValueException {
   if (!field.isAccessible()) field.setAccessible(true);
   Class<?> ft = field.getType();
   // 非 null 值,进行转换
   if (null != value) {
     try {
       value = Castors.me().castTo(value, field.getType());
     } catch (FailToCastObjectException e) {
       throw makeSetValueException(obj.getClass(), field.getName(), value, e);
     }
   }
   // 如果是原生类型,转换成默认值
   else if (ft.isPrimitive()) {
     if (boolean.class == ft) {
       value = false;
     } else if (char.class == ft) {
       value = (char) 0;
     } else {
       value = (byte) 0;
     }
   }
   try {
     this.getSetter(field).invoke(obj, value);
   } catch (Exception e1) {
     try {
       field.set(obj, value);
     } catch (Exception e) {
       throw makeSetValueException(obj.getClass(), field.getName(), value, e);
     }
   }
 }
Example #8
0
 /**
  * 设置预编译参数
  *
  * @param ps 预编译
  * @param index 序号
  * @param t vo模型
  * @param f 字段
  * @throws IllegalArgumentException
  * @throws SQLException
  * @throws IllegalAccessException
  */
 private void setParamter(PreparedStatement ps, int index, T t, Field f)
     throws IllegalArgumentException, SQLException, IllegalAccessException {
   if (!f.isAccessible()) {
     f.setAccessible(true);
   }
   if (isBoolean(f)) {
     ps.setBoolean(index, f.getBoolean(t));
   } else if (isInt(f)) {
     ps.setInt(index, f.getInt(t));
   } else if (isLong(f)) {
     ps.setLong(index, f.getLong(t));
   } else if (isString(f)) {
     ps.setString(index, (String) f.get(t));
   } else if (isDate(f)) {
     Object o = f.get(t);
     if (o == null) {
       ps.setDate(index, null);
     } else {
       ps.setTimestamp(index, new java.sql.Timestamp(((Date) o).getTime()));
     }
   } else if (isByte(f)) {
     ps.setByte(index, f.getByte(t));
   } else if (isChar(f)) {
     ps.setInt(index, f.getChar(t));
   } else if (isDouble(f)) {
     ps.setDouble(index, f.getDouble(t));
   } else if (isFloat(f)) {
     ps.setFloat(index, f.getFloat(t));
   } else {
     ps.setObject(index, f.get(t));
   }
 }
  public Credentials readCredentials(String credentialsPath)
      throws IOException, IllegalArgumentException, IllegalAccessException {

    Properties prop = new Properties();
    ClassLoader loader = Thread.currentThread().getContextClassLoader();
    InputStream stream = loader.getResourceAsStream(credentialsPath);
    prop.load(stream);

    Credentials c = new Credentials();

    Field[] declaredFields = Credentials.class.getDeclaredFields();

    for (int x = 0, xMax = declaredFields.length; x < xMax; x++) {
      Field field = declaredFields[x];
      String value = prop.getProperty(field.getName(), null);

      if (value != null) {
        boolean accessible = field.isAccessible();
        // If it's a private field we can: get declared getter method and use it, or modify the
        // accessibility of the field and edit it
        field.setAccessible(true);
        field.set(c, value);
        field.setAccessible(accessible);
      }
    }

    return c;
  }
 private String translateToString(Packet packet, int pos) {
   String ptr = " ";
   if (pos == currentIndex) ptr = " \2474";
   if (packet == null) return (count + pos) + "null:[]";
   String trans = ptr + (count + pos) + "\247r: " + packet.getClass().getSimpleName() + ": [";
   int vars = 0;
   for (Field f : packet.getClass().getDeclaredFields()) {
     if (!Modifier.isStatic(f.getModifiers())) {
       if (!f.isAccessible()) f.setAccessible(true);
       try {
         Object obj = f.get(packet);
         String value = "null";
         if (obj != null) value = obj.toString();
         trans += " f" + vars + "=" + value + ",";
       } catch (IllegalArgumentException | IllegalAccessException e) {
         e.printStackTrace();
       }
     }
   }
   if (trans.endsWith(",")) {
     trans = trans.substring(0, trans.length() - 1);
   }
   trans += "]";
   return trans;
 }
Example #11
0
  @SuppressWarnings("unchecked")
  public static EntityTrackerEntry registerEntityTracker(
      Entity entity, int trackingRange, int updateFrequency, boolean sendVelocityUpdates) {
    WorldServer worldServer = getWorld(entity);
    CustomEntityTrackerEntry tracker =
        new CustomEntityTrackerEntry(entity, trackingRange, updateFrequency, sendVelocityUpdates);

    try {
      Field field = worldServer.tracker.getClass().getDeclaredField("c");
      if (!field.isAccessible()) {
        field.setAccessible(true);
      }

      Set<EntityTrackerEntry> list = (Set<EntityTrackerEntry>) field.get(worldServer.tracker);

      if (worldServer.tracker.trackedEntities.b(entity.getId())) { // if contains entity tracker
        // go to delete
        EntityTrackerEntry oldTracker = worldServer.tracker.trackedEntities.d(entity.getId());
        list.remove(oldTracker);
        oldTracker.a();
      }

      list.add(tracker);
      worldServer.tracker.trackedEntities.a(entity.getId(), tracker);
      tracker.scanPlayers(worldServer.players);
    } catch (NoSuchFieldException
        | SecurityException
        | IllegalArgumentException
        | IllegalAccessException e) {
      e.printStackTrace();
    }
    return tracker;
  }
Example #12
0
  public Object getField(Object target, String fieldName, boolean breakAccessibility)
      throws ReflectorException {
    try {
      Class targetClass = target.getClass();
      Field field = targetClass.getField(fieldName);

      boolean accessibilityBroken = false;
      if (!field.isAccessible() && breakAccessibility) {
        field.setAccessible(true);
        accessibilityBroken = true;
      }

      Object result = field.get(target);

      if (accessibilityBroken) {
        field.setAccessible(false);
      }

      return result;
    } catch (SecurityException e) {
      throw new ReflectorException(e);
    } catch (NoSuchFieldException e) {
      throw new ReflectorException(e);
    } catch (IllegalAccessException e) {
      throw new ReflectorException(e);
    }
  }
 public WorkItemInfo merge(WorkItemInfo workItemInfo) {
   if (this.pessimisticLocking) {
     if (em.contains(workItemInfo)) {
       em.lock(workItemInfo, LockModeType.PESSIMISTIC_FORCE_INCREMENT);
     } else {
       // Yes, this is a hack, but for detached entities, it's the only way to lock before merging
       WorkItemInfo dbWorkItemInfo =
           em.find(
               WorkItemInfo.class, workItemInfo.getId(), LockModeType.PESSIMISTIC_FORCE_INCREMENT);
       for (Field field : WorkItemInfo.class.getDeclaredFields()) {
         boolean access = field.isAccessible();
         field.setAccessible(true);
         try {
           field.set(dbWorkItemInfo, field.get(workItemInfo));
         } catch (Exception e) {
           logger.error(
               "Unable to set field " + field.getName() + " of unmerged WorkItemInfo instance!",
               e);
         }
         field.setAccessible(access);
       }
     }
   }
   return em.merge(workItemInfo);
 }
  /** Removed fields cache from original code. */
  protected static Collection<Field> getFields(Class<?> clazz) {
    Collection<Field> fields = ReflectUtil.getFields(clazz);
    Iterator<Field> iterator = fields.iterator();

    while (iterator.hasNext()) {
      Field field = iterator.next();
      if (!field.isAnnotationPresent(SpringBean.class)) {
        iterator.remove();
      } else if (!field.isAccessible()) {
        // If the field isn't public, try to make it accessible
        try {
          field.setAccessible(true);
        } catch (SecurityException se) {
          throw new StripesRuntimeException(
              "Field "
                  + clazz.getName()
                  + "."
                  + field.getName()
                  + "is marked "
                  + "with @SpringBean and is not public. An attempt to call "
                  + "setAccessible(true) resulted in a SecurityException. Please "
                  + "either make the field public, annotate a public setter instead "
                  + "or modify your JVM security policy to allow Stripes to "
                  + "setAccessible(true).",
              se);
        }
      }
    }

    return fields;
  }
Example #15
0
  private static <T> T getFieldInternal(Object instance, Class<?> fieldOwner, String fieldname) {
    Field target;
    try {
      target = fieldOwner.getDeclaredField(fieldname);
    } catch (NoSuchFieldException e) {
      throw Exceptions.newIllegalArgumentException("%s has no field named %s", instance, fieldname);
    }
    boolean alreadyAccessible = target.isAccessible();
    if (!alreadyAccessible) {
      target.setAccessible(true);
    }
    try {

      @SuppressWarnings("unchecked") // we've already left statically-typed land,
      // so we may as well make it convenient for callers
      T value = (T) target.get(instance);
      return value;
    } catch (IllegalAccessException e) {
      throw Throwables.propagate(e);
    } finally {
      if (!alreadyAccessible) {
        target.setAccessible(false);
      }
    }
  }
Example #16
0
 public static void setValue(Field field, Object target, Object value) {
   if (target == null) {
     throw new IllegalArgumentException("Parameter 'target' can't be null");
   }
   if (field == null) {
     throw new IllegalArgumentException("Parameter 'field' can't be null");
   }
   boolean accessible = field.isAccessible();
   if (!accessible) {
     field.setAccessible(true);
   }
   try {
     field.set(target, value);
   } catch (Exception ex) {
     throw new GrapheneTestEnricherException(
         "During enriching of "
             + NEW_LINE
             + target.getClass()
             + NEW_LINE
             + " the field "
             + NEW_LINE
             + field
             + " was not able to be set! Check the cause!",
         ex);
   }
   if (!accessible) {
     field.setAccessible(false);
   }
 }
 @Override
 public void enrich(final SearchContext searchContext, Object target) {
   Collection<Field> fields =
       ReflectionHelper.getFieldsWithAnnotation(target.getClass(), JavaScript.class);
   for (Field field : fields) {
     GrapheneContext grapheneContext =
         searchContext == null
             ? null
             : ((GrapheneProxyInstance) searchContext).getGrapheneContext();
     if (grapheneContext == null) {
       grapheneContext =
           GrapheneContext.getContextFor(ReflectionHelper.getQualifier(field.getAnnotations()));
     }
     if (!field.isAccessible()) {
       field.setAccessible(true);
     }
     try {
       field.set(target, JSInterfaceFactory.create(grapheneContext, field.getType()));
     } catch (Exception e) {
       throw new IllegalStateException(
           "Can't inject value to the field '"
               + field.getName()
               + "' declared in class '"
               + field.getDeclaringClass().getName()
               + "'",
           e);
     }
   }
 }
  @Before
  public void setup() throws Throwable {
    // Instantiating ScmSyncConfigurationPlugin instance
    ScmSyncConfigurationPlugin scmSyncConfigPluginInstance = new ScmSyncConfigurationPlugin();

    // Mocking PluginWrapper attached to current ScmSyncConfigurationPlugin instance
    PluginWrapper pluginWrapper = PowerMockito.mock(PluginWrapper.class);
    when(pluginWrapper.getShortName()).thenReturn("scm-sync-configuration");
    // Setting field on current plugin instance
    Field wrapperField = Plugin.class.getDeclaredField("wrapper");
    boolean wrapperFieldAccessibility = wrapperField.isAccessible();
    wrapperField.setAccessible(true);
    wrapperField.set(scmSyncConfigPluginInstance, pluginWrapper);
    wrapperField.setAccessible(wrapperFieldAccessibility);

    // Mocking Hudson root directory
    currentTestDirectory = createTmpDirectory("SCMSyncConfigTestsRoot");
    currentHudsonRootDirectory =
        new File(currentTestDirectory.getAbsolutePath() + "/hudsonRootDir/");
    if (!(currentHudsonRootDirectory.mkdir())) {
      throw new IOException(
          "Could not create hudson root directory: "
              + currentHudsonRootDirectory.getAbsolutePath());
    }
    FileUtils.copyDirectoryStructure(
        new ClassPathResource(getHudsonRootBaseTemplate()).getFile(), currentHudsonRootDirectory);

    // EnvVars env = Computer.currentComputer().getEnvironment();
    // env.put("HUDSON_HOME", tmpHudsonRoot.getPath() );

    // Creating local SVN repository...
    curentLocalSvnRepository = new File(currentTestDirectory.getAbsolutePath() + "/svnLocalRepo/");
    if (!(curentLocalSvnRepository.mkdir())) {
      throw new IOException(
          "Could not create SVN local repo directory: "
              + curentLocalSvnRepository.getAbsolutePath());
    }
    FileUtils.copyDirectoryStructure(
        new ClassPathResource("svnEmptyRepository").getFile(), curentLocalSvnRepository);

    // Mocking user
    User mockedUser = Mockito.mock(User.class);
    when(mockedUser.getId()).thenReturn("fcamblor");

    // Mocking Hudson singleton instance ...
    // Warning : this line will only work on Objenesis supported VMs :
    // http://code.google.com/p/objenesis/wiki/ListOfCurrentlySupportedVMs
    Hudson hudsonMockedInstance =
        spy((Hudson) new ObjenesisStd().getInstantiatorOf(Hudson.class).newInstance());
    PowerMockito.doReturn(currentHudsonRootDirectory).when(hudsonMockedInstance).getRootDir();
    PowerMockito.doReturn(mockedUser).when(hudsonMockedInstance).getMe();
    PowerMockito.doReturn(scmSyncConfigPluginInstance)
        .when(hudsonMockedInstance)
        .getPlugin(ScmSyncConfigurationPlugin.class);

    PowerMockito.mockStatic(Hudson.class);
    PowerMockito.doReturn(hudsonMockedInstance).when(Hudson.class);
    Hudson.getInstance();
    // when(Hudson.getInstance()).thenReturn(hudsonMockedInstance);
  }
Example #19
0
 /**
  * 把查询结果填充到vo中
  *
  * @param rs 查询结果,由调用负责游标
  * @param t vo
  * @throws IllegalArgumentException
  * @throws IllegalAccessException
  * @throws SQLException
  */
 private void fillVO(ResultSet rs, T t)
     throws IllegalArgumentException, IllegalAccessException, SQLException {
   for (Field f : listTableFields(t.getClass())) {
     String name = findFieldName(f);
     Object object = rs.getObject(name);
     if (object != null) {
       if (!f.isAccessible()) {
         f.setAccessible(true);
       }
       if (isBoolean(f)) {
         f.setBoolean(t, rs.getBoolean(name));
       } else if (isInt(f)) {
         f.setInt(t, rs.getInt(name));
       } else if (isLong(f)) {
         f.setLong(t, rs.getLong(name));
       } else if (isString(f)) {
         f.set(t, rs.getString(name));
       } else if (isDate(f)) {
         f.set(t, rs.getTimestamp(name));
       } else if (isByte(f)) {
         f.setByte(t, rs.getByte(name));
       } else if (isChar(f)) {
         f.setChar(t, rs.getString(name).charAt(0));
       } else if (isDouble(f)) {
         f.setDouble(t, rs.getDouble(name));
       } else if (isFloat(f)) {
         f.setFloat(t, rs.getFloat(name));
       } else {
         f.set(t, object);
       }
     }
   }
 }
Example #20
0
  private Field[] getAccessibleFields(boolean includeProtected, boolean includePrivate) {
    if (includePrivate || includeProtected) {
      try {
        List<Field> fieldsList = new ArrayList<Field>();
        Class<?> currentClass = cl;

        while (currentClass != null) {
          // get all declared fields in this class, make them
          // accessible, and save
          Field[] declared = currentClass.getDeclaredFields();
          for (Field field : declared) {
            int mod = field.getModifiers();
            if (includePrivate || isPublic(mod) || isProtected(mod)) {
              if (!field.isAccessible()) field.setAccessible(true);
              fieldsList.add(field);
            }
          }
          // walk up superclass chain. no need to deal specially with
          // interfaces, since they can't have fields
          currentClass = currentClass.getSuperclass();
        }

        return fieldsList.toArray(new Field[fieldsList.size()]);
      } catch (SecurityException e) {
        // fall through to !includePrivate case
      }
    }
    return cl.getFields();
  }
Example #21
0
 // obj: "object with properties" to write
 private void writeObject(Object obj)
     throws NoSuchMethodException, InstantiationException, InvocationTargetException,
         IllegalAccessException, SecurityException {
   // begin bean encoding:
   this.driver.startElement(DTD.ELEMENT_OBJECT);
   Class cls = obj.getClass();
   final String mappedName = this.context.aliasFor(cls);
   this.driver.setAttribute(
       DTD.ATTRIBUTE_CLASS, (mappedName != null ? mappedName : cls.getName()));
   // encode properties:
   while (cls != Object.class) { // process inheritance:
     for (Field f : cls.getDeclaredFields()) { // process composition:
       if (Modifier.isStatic(f.getModifiers())
           || !ReflectionUtil.hasClassFieldProperty(cls, f)
           || this.context.excluded(f)) {
         continue; // skip static or non-property or excluded field.
       }
       // get property field:
       if (!f.isAccessible()) {
         f.setAccessible(true);
       }
       // write property value:
       final String aliasedFieldName = this.context.aliasFor(f, f.getName());
       this.driver.startElement(aliasedFieldName);
       this.write0(f.get(obj));
       this.driver.endElement();
     }
     cls = cls.getSuperclass();
   }
   // end bean encoding:
   this.driver.endElement();
 }
Example #22
0
 private void applyElement() {
   Field[] fields = getClass().getDeclaredFields();
   for (Field field : fields) {
     StructMapping structMapping = field.getAnnotation(StructMapping.class);
     if (structMapping != null) {
       int length = structMapping.length();
       int offset = structMapping.offset();
       if (offset == -1) {
         throw new IllegalStateException(
             "StructMapping in "
                 + getClass()
                 + " named "
                 + field.getName()
                 + " must declare the offset.");
       }
       if (length == -1) {
         length = SizeOf.INT;
       }
       StructMember structVar = new StructMember(structAddress, offset, length);
       if (!field.isAccessible()) {
         field.setAccessible(true);
       }
       try {
         field.set(this, structVar);
       } catch (IllegalAccessException e) {
         throw new RuntimeException(e.getMessage());
       }
     }
   }
 }
Example #23
0
  private ObjectMap<String, FieldMetadata> cacheFields(Class type) {
    ArrayList<Field> allFields = new ArrayList();
    Class nextClass = type;
    while (nextClass != Object.class) {
      Collections.addAll(allFields, nextClass.getDeclaredFields());
      nextClass = nextClass.getSuperclass();
    }

    ObjectMap<String, FieldMetadata> nameToField = new ObjectMap();
    for (int i = 0, n = allFields.size(); i < n; i++) {
      Field field = allFields.get(i);

      int modifiers = field.getModifiers();
      if (Modifier.isTransient(modifiers)) continue;
      if (Modifier.isStatic(modifiers)) continue;
      if (field.isSynthetic()) continue;

      if (!field.isAccessible()) {
        try {
          field.setAccessible(true);
        } catch (AccessControlException ex) {
          continue;
        }
      }

      nameToField.put(field.getName(), new FieldMetadata(field));
    }
    typeToFields.put(type, nameToField);
    return nameToField;
  }
 public AbstractJaxbObject(T realObject, Class<?> objectInterface) {
   this(objectInterface);
   for (Method getIsMethod : objectInterface.getDeclaredMethods()) {
     String methodName = getIsMethod.getName();
     String fieldName;
     if (methodName.startsWith("get")) {
       fieldName = methodName.substring(3);
     } else if (methodName.startsWith("is")) {
       fieldName = methodName.substring(2);
     } else {
       continue;
     }
     // getField -> field (lowercase f)
     fieldName = fieldName.substring(0, 1).toLowerCase() + fieldName.substring(1);
     try {
       Field field = this.getClass().getDeclaredField(fieldName);
       boolean origAccessStatus = field.isAccessible();
       field.setAccessible(true);
       Object setObject = getIsMethod.invoke(realObject, new Object[0]);
       field.set(this, setObject);
       field.setAccessible(origAccessStatus);
     } catch (Exception e) {
       throw new RuntimeException(
           "Unable to initialize "
               + fieldName
               + " when creating "
               + this.getClass().getSimpleName()
               + ".",
           e);
     }
   }
 }
Example #25
0
 public static Map<String, String> objectToMap(Object object, String... ignore) {
   Map<String, String> tempMap = new LinkedHashMap<String, String>();
   for (Field f : object.getClass().getDeclaredFields()) {
     if (!f.isAccessible()) {
       f.setAccessible(true);
     }
     boolean ig = false;
     if (ignore != null && ignore.length > 0) {
       for (String i : ignore) {
         if (i.equals(f.getName())) {
           ig = true;
           break;
         }
       }
     }
     if (ig) {
       continue;
     } else {
       Object o = null;
       try {
         o = f.get(object);
       } catch (IllegalArgumentException e) {
         e.printStackTrace();
       } catch (IllegalAccessException e) {
         e.printStackTrace();
       }
       if (o != null) {
         tempMap.put(f.getName(), o.toString());
       }
     }
   }
   return tempMap;
 }
 public static Serializable getIdentifier(final Object obj) {
   if (obj instanceof BaseDO<?>) {
     return getIdentifier((BaseDO<?>) obj);
   }
   for (final Field field : obj.getClass().getDeclaredFields()) {
     if (field.isAnnotationPresent(Id.class) == true
         && field.isAnnotationPresent(GeneratedValue.class) == true) {
       final boolean isAccessible = field.isAccessible();
       try {
         field.setAccessible(true);
         final Object idObject = field.get(obj);
         field.setAccessible(isAccessible);
         if (idObject != null
             && Serializable.class.isAssignableFrom(idObject.getClass()) == true) {
           return (Serializable) idObject;
         }
       } catch (final IllegalArgumentException e) {
         e.printStackTrace();
       } catch (final IllegalAccessException e) {
         e.printStackTrace();
       }
     }
   }
   return null;
 }
Example #27
0
 public Field getField() {
   // To support private variables we simply make the field accessible.
   if (!field.isAccessible()) {
     field.setAccessible(true);
   }
   return field;
 }
Example #28
0
 public static <T> T collapseStructure(T object) {
   if (hasOnlyNullFields(object)) {
     return null;
   }
   List<Field> fields = getAllFields(object.getClass());
   try {
     for (Field field : fields) {
       if (!field.isAccessible()) {
         field.setAccessible(true);
       }
       if (field.get(object) != null) {
         if (field.getType().getName().contains("java.util.List")) {
           @SuppressWarnings("unchecked")
           List<Object> list = (List<Object>) field.get(object);
           List<Object> newList = new ArrayList<Object>(list.size());
           boolean isNull = true;
           for (int i = 0; i < list.size(); i++) {
             Object o = collapseStructure(list.get(i));
             if (o != null) {
               isNull = false;
               newList.add(o);
             }
           }
           field.set(object, isNull ? null : newList);
           continue;
         } else if (field.getType().getName().contains("java.lang.String")) {
           if ("".equals(((String) field.get(object)).trim())) {
             field.set(object, null);
           }
           continue;
         } else if (field.getType().getName().contains("CodeOrText")
             || field.getType().getName().contains("NameTypeAttribute")
             || field.getType().getName().contains("PlaceAuthority")
             || field.getType().getName().contains("Yes")) {
           Field auxField = field.getType().getDeclaredField("value");
           auxField.setAccessible(true);
           String s = (String) auxField.get(field.get(object));
           if ("".equals(s)) {
             field.set(object, null);
           }
           continue;
         } else {
           collapseStructure(field.get(object));
         }
       }
     }
   } catch (IllegalArgumentException e) {
     LOGGER.error("Unable to inspect the structure via reflection", e);
   } catch (IllegalAccessException e) {
     LOGGER.error("Unable to inspect the structure via reflection", e);
   } catch (SecurityException e) {
     LOGGER.error("Unable to inspect the structure via reflection", e);
   } catch (NoSuchFieldException e) {
     LOGGER.error("Unable to inspect the structure via reflection", e);
   }
   if (hasOnlyNullFields(object)) {
     return null;
   }
   return object;
 }
 protected Serializable fieldValue(final Object obj, final AnnotatedElement annotatedElement) {
   if (annotatedElement instanceof Field) { // a field
     final Field f = (Field) annotatedElement;
     if (!f.isAccessible()) {
       f.setAccessible(true);
     }
     try {
       return (Serializable) f.get(obj);
     } catch (final IllegalArgumentException e) {
       logger.warn("获取" + obj.getClass().getName() + "的id字段" + f.getName() + "的值失败。", e);
     } catch (final IllegalAccessException e) {
       logger.warn("获取" + obj.getClass().getName() + "的id字段" + f.getName() + "的值失败。", e);
     } catch (final ClassCastException e) {
       logger.warn(obj.getClass().getName() + "的id字段" + f.getName() + "不可序列化。", e);
     }
   } else { // a method
     final Method m = (Method) annotatedElement;
     if (!m.isAccessible()) {
       m.setAccessible(true);
     }
     try {
       return (Serializable) ReflectionUtils.invokeMethod(m, obj);
     } catch (final ClassCastException e) {
       logger.warn(obj.getClass().getName() + "的id字段" + m.getName() + "不可序列化。", e);
     }
   }
   return null;
 }
 @Override
 public TypedValue read(EvaluationContext context, Object target, String name)
     throws AccessException {
   if (this.member instanceof Method) {
     Method method = (Method) this.member;
     try {
       if (this.needsToBeMadeAccessible && !method.isAccessible()) {
         method.setAccessible(true);
       }
       Object value = method.invoke(target);
       return new TypedValue(value, this.typeDescriptor.narrow(value));
     } catch (Exception ex) {
       throw new AccessException(
           "Unable to access property '" + name + "' through getter method", ex);
     }
   } else {
     Field field = (Field) this.member;
     try {
       if (this.needsToBeMadeAccessible && !field.isAccessible()) {
         field.setAccessible(true);
       }
       Object value = field.get(target);
       return new TypedValue(value, this.typeDescriptor.narrow(value));
     } catch (Exception ex) {
       throw new AccessException("Unable to access field '" + name + "'", ex);
     }
   }
 }