java类javax.persistence.Table的实例源码

private static void registerEntityTypes(Configuration config)
{
    Reflections reflections = new Reflections("pl.mmorpg.prototype.server.database.entities");
    Set<Class<?>> entityTypes = reflections.getTypesAnnotatedWith(Table.class);
    for (Class<?> type : entityTypes)
        config = config.addAnnotatedClass(type);
}

public static String tableName(Class<?> klass) {
    Table t = klass.getAnnotation(Table.class);
    if (t != null) {
        return t.name();
    }
    return klass.getSimpleName();
}

static String getTableName(Class<?> clazz) {
    Table table = clazz.getAnnotation(Table.class);
    if (table == null) {
        return clazz.getSimpleName();
    }
    return table.name().isEmpty() ? clazz.getSimpleName() : table.name();
}

String getTableName(Class<?> clazz) {
    Table t = clazz.getAnnotation(Table.class);
    if (t != null && !t.name().isEmpty()) {
        return t.name();
    }
    return clazz.getSimpleName();
}

private static EntityDefinition parseDefinition(Class<?> clazz) {
    if (!clazz.isAnnotationPresent(Entity.class)) {
        throw new IllegalArgumentException("Class "+clazz+" is not an @Entity");
    }
    EntityDefinition.Builder edb = new EntityDefinition.Builder(clazz);
    try {
        Constructor<?> constructor = clazz.getConstructor();
        edb.withConstructor(constructor);
    } catch (Exception e) {
        throw new IllegalArgumentException("Entity must have an empty constructor");
    }       
    if (clazz.isAnnotationPresent(Table.class)) {
        Table tableAnnotation = clazz.getAnnotation(Table.class);
        edb.withTable(tableAnnotation.name());
    }
    Field[] fields = clazz.getFields();
    if (fields != null) {
        int index = 0;
        for (Field f : fields) {
            if ((f.getModifiers() & Modifier.STATIC) == 0) {
                if (f.isAnnotationPresent(Id.class)) {
                    edb.withIdField(parseField(f));
                } else {
                    if (f.isAnnotationPresent(Transient.class)) {
                        continue;
                    } else if (f.isAnnotationPresent(JoinColumn.class)) {
                        JoinColumn c = f.getAnnotation(JoinColumn.class);
                        edb.withField(FieldInfo.entity(index++, f, c.name(), c.required()));
                    } else {
                        edb.withField(parseField(f));                           
                    }                       
                }
            }
        }
    }
    return edb.create();
}

private ArrayList<String[]> _getFieldsFromUniqueConstraint(Object value){
    ArrayList<String[]> result = new ArrayList<>();

    if(value.getClass().isAnnotationPresent(Table.class)){
        Table ta = value.getClass().getAnnotation(Table.class);
        for(UniqueConstraint uc : ta.uniqueConstraints()){
            result.add(uc.columnNames());
        }
    }

    return result;
}

public ModelController registerDbOrFileModel(Class<? extends Model> model, Class<? extends ModelController> controller, String bucket) {
    Table anno = model.getAnnotation(Table.class);
    if (anno == null) {
        throw new UsageException("A @Table annotation is required on the model " + model.getCanonicalName() + " in order to register it.");
    }
    bucket = or(bucket, anno.name());
    String table = anno.name();
    DataAccessRegistration registration = new DataAccessRegistration()
            .setDatabaseBacked(true)
            .setPersisterClass(DbPersister.class)
            .setBucket(bucket)
            .setTableName(table)
            .setControllerClass(controller)
            .setStashClass(PartialStash.class)
            .setModelClass(model);
    if (!DB.available()) {
        registration
                .setDatabaseBacked(false)
                .setPersisterClass(JsonFilePersister.class)
                .setStashClass(LocalMemoryStash.class)
                .setPath(bucket)
                .setUseDataFolder(true)
                .setShouldWatch(true)
                .setWritable(true)
                ;
    }
    return register(registration);
}

public static RDBTableMetaData parseMetaDataFromEntity(Class entityClass) {
    Table table = AnnotationUtils.findAnnotation(entityClass, Table.class);
    if (table == null) {
        return null;
    }
    RDBTableMetaData tableMetaData = new RDBTableMetaData();
    tableMetaData.setName(table.name());

    PropertyDescriptor[] descriptors = BeanUtilsBean.getInstance()
            .getPropertyUtils()
            .getPropertyDescriptors(entityClass);
    for (PropertyDescriptor descriptor : descriptors) {
        Column column = getAnnotation(entityClass, descriptor, Column.class);
        if (column == null) {
            continue;
        }
        RDBColumnMetaData columnMetaData = new RDBColumnMetaData();
        columnMetaData.setName(column.name());
        columnMetaData.setAlias(descriptor.getName());
        columnMetaData.setLength(column.length());
        columnMetaData.setPrecision(column.precision());
        columnMetaData.setJavaType(descriptor.getPropertyType());
        JDBCType type = jdbcTypeMapping.get(descriptor.getPropertyType());
        if (type == null) {
            type = jdbcTypeConvert.stream()
                    .map(func -> func.apply(entityClass, descriptor))
                    .filter(Objects::nonNull)
                    .findFirst()
                    .orElse(JDBCType.OTHER);
        }
        columnMetaData.setJdbcType(type);
        tableMetaData.addColumn(columnMetaData);
    }
    return tableMetaData;
}

private static String getUniqueColumns(Class<?> clazz, String name) {
    return Optional.of(clazz)
        .map(c -> c.getAnnotation(Table.class))
        .map(Table::uniqueConstraints)
        .map(Stream::of)
        .flatMap(s -> s
            .filter(uc -> uc.name().equals(name))
            .findAny()
            .map(UniqueConstraint::columnNames))
        .map(Stream::of)
        .map(s -> s.collect(Collectors.joining(", ")))
        .get();
}

public static String getTableName(Class<? extends BaseMybatisModel> modelClass) {
      if (modelClass.isAnnotationPresent(Table.class)) {
          return ((Table) modelClass.getAnnotation(Table.class)).name();
      }
if (modelClass.getSuperclass().isAnnotationPresent(Table.class)) {
    return ((Table) modelClass.getSuperclass().getAnnotation(Table.class)).name();
}
      return null;
  }