Java 读取类映射

设定bean类

public class TestAnnotation {
	/** The field descriptor map. 
	 * 返回由指定映射支持的同步（线程安全的）映射。为了保证按顺序访问，必须通过返回的映射完成所有对底层实现映射的访问
	 * 在返回映射的任意 collection 视图上进行迭代时，用户必须手工在返回的映射上进行同步
	 * */
	private static Map<String, Map<String, FieldDescriptor>> fieldDescriptorMap = Collections.synchronizedMap(new HashMap<String, Map<String, FieldDescriptor>>());
	
	@Column(name="id")
	private int id;
	
	@Column(name="name")
	private String name;
	
	@Column(name="age")
	private double age;
	
	@Column(name="birthday")
	private Date birthday;
	
	@Transient
	private String  wifeName;
               省略set和get方法
}

 读取该类的属性，使用方法

public static List<PropertyMapping> mappingProperty(Class<?> clazz,
			boolean simpleType) throws SQLException, ClassNotFoundException,
			InstantiationException, IllegalAccessException {
		List<PropertyMapping> mappingList = new ArrayList<PropertyMapping>();

		Map<String, FieldDescriptor> fieldMap = BeanUtils.getFieldDescriptors(clazz);
		if (fieldMap == null || fieldMap.isEmpty())
			return mappingList;

		Collection<FieldDescriptor> fields = fieldMap.values();

		// Field[] fields = clazz.getDeclaredFields();
		// if ( fields==null || fields.length==0 ) return mappingList;

		Class<?> fieldClass = null;
		int modifier = 0;
		boolean isSimpleType = true;

		PropertyMapping mapping = null;
		Field field = null;

		for (FieldDescriptor f : fields) {
			field = f.getField();
			fieldClass = field.getType();
			// field.getModifiers():以整数形式返回由此 Field 对象表示的字段的 Java 语言修饰符。应该使用
			// Modifier 类对这些修饰符进行解码。
			modifier = field.getModifiers();

			if ((modifier & Modifier.FINAL) > 0
					|| (modifier & Modifier.NATIVE) > 0
					|| (modifier & Modifier.STATIC) > 0
					|| (modifier & Modifier.TRANSIENT) > 0
					|| (modifier & Modifier.VOLATILE) > 0) {
				continue;
			}

			isSimpleType = BaseUtils.isBaseType(fieldClass);
			if (simpleType && isSimpleType) {
				// 基本类型
				mapping = fillBaseTypePropertyMapping(field);
				if (mapping != null)
					mappingList.add(mapping);
			} else if (!simpleType && !isSimpleType) {
				// 关联对象类型
				mapping = fillComplexTypePropertyMapping(field);
				if (mapping != null)
					mappingList.add(mapping);
			}
		}

		return mappingList;
	}

 判断类属性使用了匹配注解不，使用下列方法

/**
	 * Fill base type property mapping.
	 * 
	 * @param field
	 *            the field
	 * @return the property mapping
	 * @throws SQLException
	 *             the sQL exception
	 */
	private static PropertyMapping fillBaseTypePropertyMapping(Field field)
			throws SQLException {
		String propertyName = field.getName();
		Class<?> fieldClass = field.getType();

		PropertyMapping mapping = new PropertyMapping();
		mapping.setPropertyName(propertyName);
		mapping.setPropertyClass(fieldClass);

		ColumnMapping columnMapping = new ColumnMapping();
		mapping.setColumnMapping(columnMapping);

		Annotation annotation = null;

		// process for Column Annotation
		annotation = field.getAnnotation(Column.class);
		if (annotation != null) {
			String columnName = ((Column) annotation).name();
			if (columnName == null || columnName.length() == 0) {
				columnName = getDefaultColumn(propertyName);
			}
			columnMapping.setColumnName(columnName);

			String alias = ((Column) annotation).alias();
			if (alias != null && alias.length() > 0) {
				columnMapping.setAlias(alias);
			}
		} else {
			columnMapping.setColumnName(getDefaultColumn(propertyName));
		}

		// process for Transient Annotation
		annotation = field.getAnnotation(Transient.class);
		if (annotation != null) {
			mapping.setTransientField(true);
			return mapping;
		}

		// process for Id Annotation
		annotation = field.getAnnotation(Id.class);
		if (annotation != null) {
			mapping.setPrimaryKey(true);
			int strategy = ((Id) annotation).strategy();
			if (strategy == GenerationType.SEQUENCE) {
				String generator = ((Id) annotation).generator();
				mapping.setGenerateStrategy(strategy);
				if (!StringUtils.isBlank(generator)) {
					mapping.setGenerator(generator);
				}
			}
		}

		// process for Clob Annotation
		annotation = field.getAnnotation(Clob.class);
		if (annotation != null) {
			if (!"java.lang.String".equals(fieldClass.getName()))
				throw new SQLException("Clob column must mapping to String. ");
			columnMapping.setLobType(LobType.CLOB);
			columnMapping.setLobLazy(((Clob) annotation).lazy());
		}

		// process for Blob Annotation
		annotation = field.getAnnotation(Blob.class);
		if (annotation != null) {
			if (!"[B".equals(fieldClass.getName()))
				throw new SQLException("Blob column must mapping to byte[]");
			columnMapping.setLobType(LobType.BLOB);
			columnMapping.setLobLazy(((Blob) annotation).lazy());
		}

		annotation = field.getAnnotation(Search.class);
		if (annotation != null) {
			if (!((Search) annotation).exclude()) {
				ColumnSearch searchInfo = ColumnSearch
						.getDefaultInstance(fieldClass);
				searchInfo.setType(((Search) annotation).type());
				searchInfo.setFetch(((Search) annotation).fetch());
				searchInfo.setIgnoreValue(fieldClass.getName(),
						((Search) annotation).ignoreValue());
				columnMapping.setSearchInfo(searchInfo);
			}
		}

		if (columnMapping.getColumnName() == null) {
			columnMapping.setColumnName(getDefaultColumn(propertyName));
		}

		return mapping;
	}

 oneToMany 等

private static PropertyMapping fillComplexTypePropertyMapping(Field field)
			throws SQLException, ClassNotFoundException,
			InstantiationException, IllegalAccessException {
		String propertyName = field.getName();
		Class<?> fieldClass = field.getType();

		PropertyMapping mapping = new PropertyMapping();
		mapping.setPropertyName(propertyName);
		mapping.setPropertyClass(fieldClass);

		Annotation transientAnnotation = field.getAnnotation(Transient.class);
		Annotation oneToOneAnnotation = field.getAnnotation(OneToOne.class);
		Annotation oneToManyAnnotation = field.getAnnotation(OneToMany.class);
		Annotation manyToManyAnnotation = field.getAnnotation(ManyToMany.class);
		Annotation idAnnotation = field.getAnnotation(Id.class);
		Annotation columnAnnotation = field.getAnnotation(Column.class);

		if (oneToOneAnnotation != null || oneToManyAnnotation != null
				|| manyToManyAnnotation != null) {
			if (columnAnnotation == null)
				throw new SQLException(
						"must assign column for relation mapping");

			String foreignColumn = ((Column) columnAnnotation).name();
			if (StringUtils.isBlank(foreignColumn))
				throw new SQLException(
						"Relation Type must asign column name for "
								+ mapping.getPropertyName());

			mapping.setForeignColumn(foreignColumn);
			mapping.setComplexType(false);

			if (oneToOneAnnotation != null) {
				String refColumn = ((OneToOne) oneToOneAnnotation)
						.referenceColumn();
				boolean lazy = ((OneToOne) oneToOneAnnotation).lazy();

				PropertyMapping refPropertyMapping = null;
				if (refColumn == null) {
					EntityMapping refEntityMapping = EntityMappingFactory
							.getEntityMapping(fieldClass);
					refPropertyMapping = refEntityMapping.getIdMapping();
					refColumn = refPropertyMapping.getColumnName();
				}

				mapping.setReloationType(RelationType.oneToOne);
				mapping.setReferenceClass(fieldClass);
				mapping.setReferenceColumn(refColumn);
				mapping.setLoadLazy(lazy);
			} else if (oneToManyAnnotation != null) {
				String refColumn = ((OneToMany) oneToManyAnnotation)
						.referenceColumn();
				String orderBy = ((OneToMany) oneToManyAnnotation).orderBy();
				boolean lazy = ((OneToMany) oneToManyAnnotation).lazy();

				Type gType = field.getGenericType();
				if (!(gType instanceof ParameterizedType)) {
					throw new SQLException(
							"OneToMany mapping must be a ParameterizedType. reference column="
									+ refColumn);
				}

				ParameterizedType pType = (ParameterizedType) gType;
				Class<?> rowClass = (Class<?>) pType.getRawType();

				if (!"java.util.List".equals(rowClass.getName())) {
					throw new SQLException(
							"OneToMany mapping must be a List. reference column="
									+ refColumn);
				}

				Type[] args = pType.getActualTypeArguments();
				if (args.length != 1) {
					throw new SQLException(
							"ParameterizedType must have a argument. OneToMany mapping reference column="
									+ refColumn);
				}

				Class<?> refClass = (Class<?>) args[0];

				mapping.setReloationType(RelationType.oneToMany);
				mapping.setReferenceClass(refClass);
				mapping.setReferenceColumn(refColumn);
				mapping.setReferenceOrder(orderBy);
				mapping.setLoadLazy(lazy);
			} else {
				String refColumn = ((ManyToMany) manyToManyAnnotation)
						.referenceColumn();
				String orderBy = ((ManyToMany) manyToManyAnnotation).orderBy();
				String relationTable = ((ManyToMany) manyToManyAnnotation)
						.relationTable();
				String relationRefCol1 = ((ManyToMany) manyToManyAnnotation)
						.relationRefColumn1();
				String relationRefCol2 = ((ManyToMany) manyToManyAnnotation)
						.relationRefColumn2();
				boolean lazy = ((ManyToMany) manyToManyAnnotation).lazy();

				Type gType = field.getGenericType();
				if (!(gType instanceof ParameterizedType)) {
					throw new SQLException(
							"ManyToMany mapping must be a ParameterizedType. reference column="
									+ refColumn);
				}

				ParameterizedType pType = (ParameterizedType) gType;
				Class<?> rowClass = (Class<?>) pType.getRawType();

				if (!"java.util.List".equals(rowClass.getName())) {
					throw new SQLException(
							"MayToMany mapping must be a collection. reference column="
									+ refColumn);
				}

				Type[] args = pType.getActualTypeArguments();
				if (args.length != 1) {
					throw new SQLException(
							"ParameterizedType must have a argument. ManyToMany mapping reference column="
									+ refColumn);
				}

				Class<?> refClass = (Class<?>) args[0];

				mapping.setReloationType(RelationType.manyToMany);
				mapping.setReferenceClass(refClass);
				mapping.setReferenceColumn(refColumn);
				mapping.setReferenceOrder(orderBy);
				mapping.setRelationTable(relationTable);
				mapping.setRelationRefCol1(relationRefCol1);
				mapping.setRelationRefCol2(relationRefCol2);
				mapping.setLoadLazy(lazy);
			}
		} else {
			if (!EntityUtils.isEntity(fieldClass)) {
				return null;
			}

			mapping.setComplexType(true);

			if (transientAnnotation != null) {
				mapping.setTransientField(true);
			} else if (idAnnotation != null) {
				mapping.setPrimaryKey(true);
			}

			ObjectMapping objectMapping = EntityMappingFactory
					.loadObjectMapping(fieldClass);
			mapping.setObjectMapping(objectMapping);
			for (PropertyMapping pm : objectMapping.getPropertyMap().values()) {
				pm.setPrimaryKey(mapping.isPrimaryKey());
				pm.setTransientField(mapping.isTransientField());
			}
		}

		return mapping;
	}