mysql annotations_自定义注解与MYSQL

packageannotationK.util;importjava.lang.annotation.Annotation;importjava.lang.reflect.Field;importjava.util.ArrayList;importjava.util.List;importorg.junit.Test;importannotationK.annotation.AnnotationEnum;importannotationK.annotation.Column;importannotationK.annotation.Comment;importannotationK.annotation.Entity;importannotationK.annotation.GeneratedValue;importannotationK.annotation.GenerationType;importannotationK.annotation.Id;importannotationK.annotation.Table;/***注解反射帮助类

**/

public final classAnnotationReflectionUtil {

@Testpublic void test()throwsException{/*EntityBean entity=parserClass(User.class);

entity=TypeUtils.reflecJdbcTypeAll(entity);

for(ColumnBean columnBean:entity.getColumnBean()){

System.out.println(column.getFieldName());

System.out.println("level="+column.getLeve()+",name="+column.getColumnName()+",type="+column.getColumnType()+",length="+column.getColumnLength()+",defalutvalue="+column.getDefaultValue()+",comment="+column.getComment());

System.out.println("--------------------------------------------------------------------");

}*/}/*** 抛出异常 目前暂定将不属于自定义的注解,全部抛出,返回值布尔值

**/

private booleanputExceptionAnnotationToField(Field field){boolean tag=true;

Annotation annotations []=field.getAnnotations();if(annotations.length>0){for(Annotation annotation:annotations){

String annotationName=annotation.annotationType().getName();if(annotationName.contains("javax")||annotationName.contains("hibernate")||annotationName.contains("ejb3")){

tag=false;throw new RuntimeException(field.getName()+"该字段请注入规定注解");

}

}

}returntag;

}/*** 解析实体bean并将数据封装至TableBean

**/

public EntityBean parserClass(Class clazz) throwsClassNotFoundException{//解析头部

EntityBean entityBean=parserAnnotationClassTop(clazz);if(entityBean.isEntityBO()){

Field fields []=clazz.getDeclaredFields();

List columnList=new ArrayList();

ColumnBean column=null;for(Field field:fields){

putExceptionAnnotationToField(field);

column=newColumnBean(field);

Annotation annotations []=field.getAnnotations();

column.setAnnotations(annotations);

column.setFieldName(field.getName());

column.setFileType(field.getType());

column.setFieldTypeName(field.getType().getSimpleName());boolean tag=true;if(annotations.length>0){//该字段根据头部注解区分对待

for(Annotation annotation:annotations){

String annotationName=annotation.annotationType().getSimpleName();if(AnnotationEnum.forType("ID").equals(annotationName)){

column=parserAnnotationId(column);

}if(AnnotationEnum.forType("GENERATEDVALUE").equals(annotationName)){

column=parserAnnotationGeneratedValue(column);

}if(AnnotationEnum.forType("COLUMN").equals(annotationName)){

column=parserAnnotationColumn(column);

}if(AnnotationEnum.forType("TEMPORAL").equals(annotationName)){

column=parserAnnotationDate(column);

}if(AnnotationEnum.forType("COMMENT").equals(annotationName)){

column=parserAnnotationComment(column);

}if(AnnotationEnum.forType("TRANSIENT").equals(annotationName)){

tag=false;

}

}

}else{//该字段为缺省为cloumn注解类型,属于映射字段

column=parserAnnotationColumnNot(column);

}if(tag)

columnList.add(column);

}

entityBean.setColumnBean(columnList);

}returnentityBean;

}/*** 解决注释注解

**/

privateColumnBean parserAnnotationComment(ColumnBean column){

Field field=column.getField();

Comment comment=field.getAnnotation(Comment.class);

String msg=comment.value();if(msg!=null){

column.setComment(msg);

}returncolumn;

}/*** 解决无注解字段处理,但是其头部有entity注解

**/

privateColumnBean parserAnnotationColumnNot(ColumnBean column){

Field field=column.getField();

column.setColumnName(field.getName());returncolumn;

}/*** 解析日期类注解

**/

privateColumnBean parserAnnotationDate(ColumnBean column){

Field field=column.getField();

column.setColumnName(field.getName());returncolumn;

}/*** 解析字段Column 注解

**/

privateColumnBean parserAnnotationColumn(ColumnBean columns){

Field field=columns.getField();

Column column=field.getAnnotation(Column.class);if(!column.columnType().equals("")){

columns.setColumnType(column.columnType());

}

columns.setDefaultValue(column.defaultVaule());

columns.setColumnName(column.name().equals("")?field.getName():column.name());

columns.setColumnLength(column.length());

columns.setUnique(column.unique());

columns.setInsertable(column.insertable());

columns.setNullableBoo(column.nullable());

columns.setUpdatableBoo(column.updatable());

columns.setTableName(column.table());

columns.setPrecision(column.precision());

columns.setScale(column.scale());returncolumns;

}/*** 解析主键

**/

privateColumnBean parserAnnotationId(ColumnBean column){

Field field=column.getField();

Id id=field.getAnnotation(Id.class);

String className=id.annotationType().getName();if(!className.contains("javax")||!className.contains("hibernate")){

column.setLeve(2);if(column.getColumnName()==null){

column.setColumnName(field.getName());

}

}returncolumn;

}/*** 解析主键自增类型 strategy 主键生成规则,配合主键生成策略

**/

privateColumnBean parserAnnotationGeneratedValue(ColumnBean column){

Field field=column.getField();

GeneratedValue generated=field.getAnnotation(GeneratedValue.class);//自增辅助策略//String generator=generated.generator().toString();//自增主策略

String generatedValue=generated.strategy().toString();if(generatedValue==GenerationType.AUTO.toString()){

column.setLeve(3);

}returncolumn;

}/*** 解析头部注解

**/

private EntityBean parserAnnotationClassTop(Classclazz){

EntityBean entityBean=new EntityBean();

Annotation annotations []=clazz.getAnnotations();for(Annotation annotation:annotations){

String annotationName=annotation.annotationType().getSimpleName();if(AnnotationEnum.forType("ENTITY").equals(annotationName)){

String entityName=parserAnnotationEntity(clazz,annotation);

entityBean.setEntityBO(true);

entityBean.setEntityName(entityName);

}if(AnnotationEnum.forType("TABLE").equals(annotationName)){

String tableName=parserAnnotationTable(clazz,annotation);

entityBean.setTableBO(true);

entityBean.setTableName(tableName);

}

}if(entityBean.isEntityBO()&&!entityBean.isTableBO()){

entityBean.setTableName(clazz.getSimpleName());

}returnentityBean;

}/*** 解析Entity注解

**/

private String parserAnnotationEntity(Classclazz,Annotation annotation){

String entityName="";

Entity entity= clazz.getAnnotation(Entity.class);

entityName=entity.name();if(entityName==null||entityName.equals("")){

entityName=clazz.getSimpleName();

}returnentityName;

}/*** 解析Table注解

**/

private String parserAnnotationTable(Classclazz,Annotation annotation){

String tableName="";

Table table= clazz.getAnnotation(Table.class);

tableName=table.name();if(tableName==null||tableName.equals("")){

tableName=clazz.getSimpleName();

}returntableName;

}

}