在android上找不到java.beans.propertydescriptor

我的应用程序使用另一个项目，其中包含对类的引用，如java.beans.propertydescriptor，它不包含在android库中。 下一种情况是：我的项目包含.jar文件，另一个项目作为库。我读到解决方案是使用开源类。我找到了，但是我不知道如何将这个类添加到android.jar文件中。那么，如何将这个类添加到android java.beans库中呢？ 这是我发现的类：

package java.beans;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Vector;
import org.apache.harmony.beans.internal.nls.Messages;

public class PropertyDescriptor extends FeatureDescriptor {
private Method getter;
private Method setter;
private Class<?> propertyEditorClass;
private boolean constrained;
private boolean bound;

public PropertyDescriptor(String propertyName, Class<?> beanClass,
        String getterName, String setterName) throws IntrospectionException {
    super();
    if (beanClass == null) {
        throw new IntrospectionException(Messages.getString("beans.03")); //$NON-NLS-1$
    }
    if (propertyName == null || propertyName.length() == 0) {
        throw new IntrospectionException(Messages.getString("beans.04")); //$NON-NLS-1$
    }
    this.setName(propertyName);
    this.setDisplayName(propertyName);
    if (setterName != null) {
        if (hasMethod(beanClass, setterName)) {
            setWriteMethod(beanClass, setterName);
        } else {
            throw new IntrospectionException(Messages.getString("beans.20")); //$NON-NLS-1$
        }
    }
    if (getterName != null) {
        if (hasMethod(beanClass, getterName)) {
            setReadMethod(beanClass, getterName);
        } else {
            throw new IntrospectionException(Messages.getString("beans.1F")); //$NON-NLS-1$
        }
    }
}

public PropertyDescriptor(String propertyName, Method getter, Method setter)
        throws IntrospectionException {
    super();
    if (propertyName == null || propertyName.length() == 0) {
        throw new IntrospectionException(Messages.getString("beans.04")); //$NON-NLS-1$
    }
    this.setName(propertyName);
    this.setDisplayName(propertyName);
    setWriteMethod(setter);
    setReadMethod(getter);
}

public PropertyDescriptor(String propertyName, Class<?> beanClass)
        throws IntrospectionException {
    String getterName;
    String setterName;
    if (beanClass == null) {
        throw new IntrospectionException(Messages.getString("beans.03")); //$NON-NLS-1$
    }
    if (propertyName == null || propertyName.length() == 0) {
        throw new IntrospectionException(Messages.getString("beans.04")); //$NON-NLS-1$
    }
    this.setName(propertyName);
    this.setDisplayName(propertyName);
    getterName = createDefaultMethodName(propertyName, "is"); //$NON-NLS-1$
    if (hasMethod(beanClass, getterName)) {
        setReadMethod(beanClass, getterName);
    } else {
        getterName = createDefaultMethodName(propertyName, "get"); //$NON-NLS-1$
        if (hasMethod(beanClass, getterName)) {
            setReadMethod(beanClass, getterName);
        }
    }
    setterName = createDefaultMethodName(propertyName, "set"); //$NON-NLS-1$
    if (hasMethod(beanClass, setterName)) {
        setWriteMethod(beanClass, setterName);
    }
    if (getter == null && setter == null) {
        throw new IntrospectionException(Messages.getString(
                "beans.01", propertyName)); //$NON-NLS-1$
    }
}

public void setWriteMethod(Method setter) throws IntrospectionException {
    if (setter != null) {
        int modifiers = setter.getModifiers();
        if (!Modifier.isPublic(modifiers)) {
            throw new IntrospectionException(Messages.getString("beans.05")); //$NON-NLS-1$
        }
        Class<?>[] parameterTypes = setter.getParameterTypes();
        if (parameterTypes.length != 1) {
            throw new IntrospectionException(Messages.getString("beans.06")); //$NON-NLS-1$
        }
        Class<?> parameterType = parameterTypes[0];
        Class<?> propertyType = getPropertyType();
        if (propertyType != null && !propertyType.equals(parameterType)) {
            throw new IntrospectionException(Messages.getString("beans.07")); //$NON-NLS-1$
        }
    }
    this.setter = setter;
}

public void setReadMethod(Method getter) throws IntrospectionException {
    if (getter != null) {
        int modifiers = getter.getModifiers();
        if (!Modifier.isPublic(modifiers)) {
            throw new IntrospectionException(Messages.getString("beans.0A")); //$NON-NLS-1$
        }
        Class<?>[] parameterTypes = getter.getParameterTypes();
        if (parameterTypes.length != 0) {
            throw new IntrospectionException(Messages.getString("beans.08")); //$NON-NLS-1$
        }
        Class<?> returnType = getter.getReturnType();
        if (returnType.equals(Void.TYPE)) {
            throw new IntrospectionException(Messages.getString("beans.33")); //$NON-NLS-1$
        }
        Class<?> propertyType = getPropertyType();
        if ((propertyType != null) && !returnType.equals(propertyType)) {
            throw new IntrospectionException(Messages.getString("beans.09")); //$NON-NLS-1$
        }
    }
    this.getter = getter;
}

public Method getWriteMethod() {
    return setter;
}

public Method getReadMethod() {
    return getter;
}

@Override
public boolean equals(Object object) {
    boolean result = (object != null && object instanceof PropertyDescriptor);
    if (result) {
        PropertyDescriptor pd = (PropertyDescriptor) object;
        boolean gettersAreEqual = (this.getter == null)
                && (pd.getReadMethod() == null) || (this.getter != null)
                && (this.getter.equals(pd.getReadMethod()));
        boolean settersAreEqual = (this.setter == null)
                && (pd.getWriteMethod() == null) || (this.setter != null)
                && (this.setter.equals(pd.getWriteMethod()));
        boolean propertyTypesAreEqual = this.getPropertyType() == pd
                .getPropertyType();
        boolean propertyEditorClassesAreEqual = this
                .getPropertyEditorClass() == pd.getPropertyEditorClass();
        boolean boundPropertyAreEqual = this.isBound() == pd.isBound();
        boolean constrainedPropertyAreEqual = this.isConstrained() == pd
                .isConstrained();
        result = gettersAreEqual && settersAreEqual
                && propertyTypesAreEqual && propertyEditorClassesAreEqual
                && boundPropertyAreEqual && constrainedPropertyAreEqual;
    }
    return result;
}

public void setPropertyEditorClass(Class<?> propertyEditorClass) {
    this.propertyEditorClass = propertyEditorClass;
}

public Class<?> getPropertyType() {
    Class<?> result = null;
    if (getter != null) {
        result = getter.getReturnType();
    } else if (setter != null) {
        Class<?>[] parameterTypes = setter.getParameterTypes();
        result = parameterTypes[0];
    }
    return result;
}

public Class<?> getPropertyEditorClass() {
    return propertyEditorClass;
}

public void setConstrained(boolean constrained) {
    this.constrained = constrained;
}

public void setBound(boolean bound) {
    this.bound = bound;
}

public boolean isConstrained() {
    return constrained;
}

public boolean isBound() {
    return bound;
}

boolean hasMethod(Class<?> beanClass, String methodName) {
    Method[] methods = findMethods(beanClass, methodName);
    return (methods.length > 0);
}

String createDefaultMethodName(String propertyName, String prefix) {
    String result = null;
    if (propertyName != null) {
        String bos = propertyName.substring(0, 1).toUpperCase();
        String eos = propertyName.substring(1, propertyName.length());
        result = prefix + bos + eos;
    }
    return result;
}

Method[] findMethods(Class<?> aClass, String methodName) {
    Method[] allMethods = aClass.getMethods();
    Vector<Method> matchedMethods = new Vector<Method>();
    Method[] result;
    for (Method method : allMethods) {
        if (method.getName().equals(methodName)) {
            matchedMethods.add(method);
        }
    }
    result = new Method[matchedMethods.size()];
    for (int j = 0; j < matchedMethods.size(); ++j) {
        result[j] = matchedMethods.elementAt(j);
    }
    return result;
}

void setReadMethod(Class<?> beanClass, String getterName) {
    boolean result = false;
    Method[] getters = findMethods(beanClass, getterName);
    for (Method element : getters) {
        try {
            setReadMethod(element);
            result = true;
        } catch (IntrospectionException ie) {
        }
        if (result) {
            break;
        }
    }
}

void setWriteMethod(Class<?> beanClass, String setterName)
        throws IntrospectionException {
    boolean result = false;
    Method[] setters = findMethods(beanClass, setterName);
    for (Method element : setters) {
        try {
            setWriteMethod(element);
            result = true;
        } catch (IntrospectionException ie) {
        }
        if (result) {
            break;
        }
    }
}

public PropertyEditor createPropertyEditor(Object bean) {
    PropertyEditor editor;
    if (propertyEditorClass == null) {
        return null;
    }
    if (!PropertyEditor.class.isAssignableFrom(propertyEditorClass)) {
        // beans.48=Property editor is not assignable from the
        // PropertyEditor interface
        throw new ClassCastException(Messages.getString("beans.48")); //$NON-NLS-1$
    }
    try {
        Constructor<?> constr;
        try {
            // try to look for the constructor with single Object argument
            constr = propertyEditorClass.getConstructor(Object.class);
            editor = (PropertyEditor) constr.newInstance(bean);
        } catch (NoSuchMethodException e) {
            // try no-argument constructor
            constr = propertyEditorClass.getConstructor();
            editor = (PropertyEditor) constr.newInstance();
        }
    } catch (Exception e) {
        // beans.47=Unable to instantiate property editor
        RuntimeException re = new RuntimeException(
                Messages.getString("beans.47"), e); //$NON-NLS-1$
        throw re;
    }
    return editor;
    }
}

包java.bean；
导入java.lang.reflect.Constructor；
导入java.lang.reflect.Method；
导入java.lang.reflect.Modifier；
导入java.util.Vector；
导入org.apache.harmony.beans.internal.nls.Messages；
公共类PropertyDescriptor扩展了FeatureDescriptor{
私有方法getter；
私有方法设置器；
私有类propertyEditorClass；
私有布尔约束；
私有布尔界；
公共PropertyDescriptor（字符串propertyName，类beanClass，
字符串getterName、字符串setterName）引发内省异常{
超级（）；
if（beanClass==null）{
抛出新的内省异常（Messages.getString（“beans.03”）；//$NON-NLS-1$
}
如果（propertyName==null | | propertyName.length（）==0）{
抛出新的内省异常（Messages.getString（“beans.04”）；//$NON-NLS-1$
}
this.setName（propertyName）；
此.setDisplayName（propertyName）；
if（setterName！=null）{
if（hasMethod（beanClass，setterName））{
setWriteMethod（beanClass，setterName）；
}否则{
抛出新的内省异常（Messages.getString（“beans.20”）；//$NON-NLS-1$
}
}
if（getterName！=null）{
if（hasMethod（beanClass，getterName））{
setReadMethod（beanClass、getterName）；
}否则{
抛出新的内省异常（Messages.getString（“beans.1F”）；//$NON-NLS-1$
}
}
}
公共PropertyDescriptor（字符串propertyName、方法getter、方法setter）
抛出内省异常{
超级（）；
如果（propertyName==null | | propertyName.length（）==0）{
抛出新的内省异常（Messages.getString（“beans.04”）；//$NON-NLS-1$
}
this.setName（propertyName）；
此.setDisplayName（propertyName）；
setWriteMethod（setter）；
setReadMethod（getter）；
}
公共PropertyDescriptor（字符串propertyName，类beanClass）
抛出内省异常{
字符串getterName；
字符串setterName；
if（beanClass==null）{
抛出新的内省异常（Messages.getString（“beans.03”）；//$NON-NLS-1$
}
如果（propertyName==null | | propertyName.length（）==0）{
抛出新的内省异常（Messages.getString（“beans.04”）；//$NON-NLS-1$
}
this.setName（propertyName）；
此.setDisplayName（propertyName）；
getterName=createDefaultMethodName（propertyName，“is”）；//$NON-NLS-1$
if（hasMethod（beanClass，getterName））{
setReadMethod（beanClass、getterName）；
}否则{
getterName=createDefaultMethodName（propertyName，“get”）；//$NON-NLS-1$
if（hasMethod（beanClass，getterName））{
setReadMethod（beanClass、getterName）；
}
}
setterName=createDefaultMethodName（propertyName，“set”）；//$NON-NLS-1$
if（hasMethod（beanClass，setterName））{
setWriteMethod（beanClass，setterName）；
}
if（getter==null&&setter==null）{
抛出新的内省异常（Messages.getString(
“beans.01”，propertyName））；//$NON-NLS-1$
}
}
public void setWriteMethod（方法设置器）引发内省异常{
if（setter！=null）{
int modifiers=setter.getModifiers（）；
如果（！Modifier.isPublic（修饰符））{
抛出新的内省异常（Messages.getString（“beans.05”）；//$NON-NLS-1$
}
类[]parameterTypes=setter.getParameterTypes（）；
如果（parameterTypes.length！=1）{
抛出新的内省异常（Messages.getString（“beans.06”）；//$NON-NLS-1$
}
类参数类型=参数类型[0]；
类propertyType=getPropertyType（）；
if（propertyType！=null&！propertyType.equals（parameterType））{
抛出新的内省异常（Messages.getString（“beans.07”）；//$NON-NLS-1$
}
}
this.setter=setter；
}
public void setReadMethod（方法getter）引发内省异常{
if（getter！=null）{
int modifiers=getter.getModifiers（）；
如果（！Modifier.isPublic（修饰符））{
抛出新的内省异常（Messages.getString（“beans.0A”）；//$NON-NLS-1$
}
类[]parameterTypes=getter.getParameterTypes（）；
如果（parameterTypes.length！=0）{
抛出新的内省异常（Messages.getString（“beans.08”）；//$NON-NLS-1$
}
类returnType=getter.getReturnType（）；
if（returnType.equals（Void.TYPE））{
抛出新的内省异常（Messages.getString（“beans.33”）；//$NON-NLS-1$
}
类propertyType=getPropertyType（）；
如果（（propertyType！=null）&&！returnType.equals（propertyType））{
抛出新的内省异常（Messages.getString（“beans.09”）；//$NON-NLS-1$
}
}
this.getter=getter；
}
公共方法getWriteMethod（）{
回程设定器；
}
公共方法getReadMethod（）{
回程吸气剂；
}
@凌驾
公共布尔等于（对象）{
布尔结果=（对象！=null&&PropertyDescriptor的对象实例）；
如果（结果）{
PropertyDescriptor pd=（PropertyDescriptor）对象；
布尔gettersaleequal=（this.getter==null）
&&（pd.getReadMethod（）==null）| |（this.getter！=null）
&&（this.getter.equals（pd.getReadMethod（））；
布尔settersarequal=（this.setter==null）
&&（pd.getWriteMethod（）==null）| |（this.setter！=null）