private void readColumn(Column columnAnn, DeployBeanProperty prop) {
if (!isEmpty(columnAnn.name())) {
String dbColumn = databasePlatform.convertQuotedIdentifiers(columnAnn.name());
prop.setDbColumn(dbColumn);
}
prop.setDbInsertable(columnAnn.insertable());
prop.setDbUpdateable(columnAnn.updatable());
prop.setNullable(columnAnn.nullable());
prop.setUnique(columnAnn.unique());
if (columnAnn.precision() > 0) {
prop.setDbLength(columnAnn.precision());
} else if (columnAnn.length() != 255) {
// set default 255 on DbTypeMap
prop.setDbLength(columnAnn.length());
}
prop.setDbScale(columnAnn.scale());
prop.setDbColumnDefn(columnAnn.columnDefinition());
String baseTable = descriptor.getBaseTable();
String tableName = columnAnn.table();
if (tableName.equals("") || tableName.equalsIgnoreCase(baseTable)) {
// its a base table property...
} else {
// its on a secondary table...
prop.setSecondaryTable(tableName);
// DeployTableJoin tableJoin = info.getTableJoin(tableName);
// tableJoin.addProperty(prop);
}
}
/**
* 解析字段定义<br>
* <功能详细描述>
*
* @param type
* @param pd
* @return [参数说明]
* @return JPAEntityColumnDef [返回类型说明]
* @exception throws [异常类型] [异常说明]
* @see [类、类#方法、类#成员]
*/
private static JPAEntityColumnDef doAnalyzeCoumnDef(
String tableName, Class<?> type, PropertyDescriptor pd) {
JPAEntityColumnDef colDef = null;
String columnComment = "";
String propertyName = pd.getName();
String columnName = propertyName;
Class<?> javaType = pd.getPropertyType();
int size = 0;
int scale = 0;
boolean required = false;
// 获取字段
Field field = FieldUtils.getField(type, propertyName, true);
if (field != null) {
if (field.isAnnotationPresent(Transient.class)) {
// 如果含有忽略的字段则跳过该字段
return null;
}
if (field.isAnnotationPresent(OneToMany.class)) {
// 如果含有忽略的字段则跳过该字段
return null;
}
if (field.isAnnotationPresent(Column.class)) {
Column columnAnno = field.getAnnotation(Column.class);
columnName = columnAnno.name();
required = !columnAnno.nullable();
size = Math.max(columnAnno.length(), columnAnno.precision());
scale = columnAnno.scale();
}
}
// 获取读方法
Method readMethod = pd.getReadMethod();
if (readMethod != null) {
if (readMethod.isAnnotationPresent(Transient.class)) {
// 如果含有忽略的字段则跳过该字段
return null;
}
if (readMethod.isAnnotationPresent(OneToMany.class)) {
// 如果含有忽略的字段则跳过该字段
return null;
}
if (readMethod.isAnnotationPresent(Column.class)) {
Column columnAnno = readMethod.getAnnotation(Column.class);
columnName = columnAnno.name();
required = !columnAnno.nullable();
size = Math.max(columnAnno.length(), columnAnno.precision());
scale = columnAnno.scale();
}
}
JdbcTypeEnum jdbcType = JPAEntityTypeRegistry.getJdbcType(javaType); // 获取对应的jdbcType
colDef = new JPAEntityColumnDef(columnName, javaType, jdbcType, size, scale, required);
colDef.setComment(columnComment);
return colDef;
}
@SuppressWarnings({"rawtypes", "unchecked"})
public static <X> X buildMockObject(Class<X> clazz) {
X x = null;
try {
x = clazz.newInstance();
for (Method method : clazz.getDeclaredMethods()) {
String mn = method.getName();
if (mn.startsWith("set")) {
Class[] parameters = method.getParameterTypes();
if (parameters.length == 1) {
Method getMethod =
MethodUtils.getAccessibleMethod(clazz, "get" + mn.substring(3), null);
if (getMethod != null) {
if (getMethod.getName().equals("getId")) {
continue;
}
Object value = null;
Class parameter = parameters[0];
if (parameter.isAssignableFrom(String.class)) {
Column column = getMethod.getAnnotation(Column.class);
int columnLength = 32;
if (column != null && column.length() < columnLength) {
columnLength = column.length();
}
Size size = getMethod.getAnnotation(Size.class);
if (size != null && size.min() < columnLength) {
columnLength = size.min();
}
value = RandomStringUtils.randomAlphabetic(columnLength);
} else if (parameter.isAssignableFrom(Date.class)) {
value = new Date();
} else if (parameter.isAssignableFrom(BigDecimal.class)) {
value = new BigDecimal(new Random().nextDouble());
} else if (parameter.isAssignableFrom(Integer.class)) {
value = new Random().nextInt();
} else if (parameter.isAssignableFrom(Boolean.class)) {
value = new Random().nextBoolean();
} else if (parameter.isEnum()) {
Method m = parameter.getDeclaredMethod("values", null);
Object[] result = (Object[]) m.invoke(parameter.getEnumConstants()[0], null);
value = result[new Random().nextInt(result.length)];
}
if (value != null) {
MethodUtils.invokeMethod(x, mn, value);
logger.debug("{}={}", method.getName(), value);
}
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return x;
}
/**
* シーケンスのデータ型を返します。
*
* @param propertyMeta プロパティメタデータ
* @return シーケンスのデータ型
*/
protected String getDataType(PropertyMeta propertyMeta) {
ValueType valueType = valueTypeProvider.provide(propertyMeta);
int sqlType = valueType.getSqlType();
Column column = getColumn(propertyMeta);
return dialect
.getSqlType(sqlType)
.getDataType(column.length(), column.precision(), column.scale(), false);
}
/**
* 主キー記述を処理します。
*
* @param entityMeta エンティティメタデータ
* @param propertyMeta プロパティメタデータ
* @param tableDesc テーブル記述
* @param generator テーブルジェネレータ
*/
protected void doPrimaryKeyColumn(
EntityMeta entityMeta, TableDesc tableDesc, TableGenerator generator) {
String pkColumnName = generator.pkColumnName();
if (StringUtil.isEmpty(pkColumnName)) {
pkColumnName = TableIdGenerator.DEFAULT_PK_COLUMN_NAME;
}
PrimaryKeyDesc primaryKeyDesc = new PrimaryKeyDesc();
primaryKeyDesc.addColumnName(pkColumnName);
tableDesc.setPrimaryKeyDesc(primaryKeyDesc);
ColumnDesc columnDesc = new ColumnDesc();
columnDesc.setName(pkColumnName);
SqlType sqlType = dialect.getSqlType(Types.VARCHAR);
columnDesc.setSqlType(sqlType);
Column column = AnnotationUtil.getDefaultColumn();
columnDesc.setDefinition(sqlType.getDataType(column.length(), 0, 0, false));
tableDesc.addColumnDesc(columnDesc);
}
public static Map<String, UiConfigImpl> getUiConfigs(Class<?> entityClass) {
Map<String, UiConfigImpl> map = cache.get(entityClass);
if (map == null || AppInfo.getStage() == Stage.DEVELOPMENT) {
GenericGenerator genericGenerator =
AnnotationUtils.getAnnotatedPropertyNameAndAnnotations(
entityClass, GenericGenerator.class)
.get("id");
boolean idAssigned =
genericGenerator != null && "assigned".equals(genericGenerator.strategy());
Map<String, NaturalId> naturalIds =
AnnotationUtils.getAnnotatedPropertyNameAndAnnotations(entityClass, NaturalId.class);
Set<String> hides = new HashSet<String>();
map = new HashMap<String, UiConfigImpl>();
PropertyDescriptor[] pds =
org.springframework.beans.BeanUtils.getPropertyDescriptors(entityClass);
for (PropertyDescriptor pd : pds) {
String propertyName = pd.getName();
if (pd.getReadMethod() == null
|| pd.getWriteMethod() == null
&& pd.getReadMethod().getAnnotation(UiConfig.class) == null) continue;
Class<?> declaredClass = pd.getReadMethod().getDeclaringClass();
Version version = pd.getReadMethod().getAnnotation(Version.class);
if (version == null)
try {
Field f = declaredClass.getDeclaredField(propertyName);
if (f != null) version = f.getAnnotation(Version.class);
} catch (Exception e) {
}
if (version != null) continue;
Transient trans = pd.getReadMethod().getAnnotation(Transient.class);
if (trans == null)
try {
Field f = declaredClass.getDeclaredField(propertyName);
if (f != null) trans = f.getAnnotation(Transient.class);
} catch (Exception e) {
}
SearchableProperty searchableProperty =
pd.getReadMethod().getAnnotation(SearchableProperty.class);
if (searchableProperty == null)
try {
Field f = declaredClass.getDeclaredField(propertyName);
if (f != null) searchableProperty = f.getAnnotation(SearchableProperty.class);
} catch (Exception e) {
}
SearchableId searchableId = pd.getReadMethod().getAnnotation(SearchableId.class);
if (searchableId == null)
try {
Field f = declaredClass.getDeclaredField(propertyName);
if (f != null) searchableId = f.getAnnotation(SearchableId.class);
} catch (Exception e) {
}
UiConfig uiConfig = pd.getReadMethod().getAnnotation(UiConfig.class);
if (uiConfig == null)
try {
Field f = declaredClass.getDeclaredField(propertyName);
if (f != null) uiConfig = f.getAnnotation(UiConfig.class);
} catch (Exception e) {
}
if (uiConfig != null && uiConfig.hidden()) continue;
if ("new".equals(propertyName)
|| !idAssigned && "id".equals(propertyName)
|| "class".equals(propertyName)
|| "fieldHandler".equals(propertyName)
|| pd.getReadMethod() == null
|| hides.contains(propertyName)) continue;
Column columnannotation = pd.getReadMethod().getAnnotation(Column.class);
if (columnannotation == null)
try {
Field f = declaredClass.getDeclaredField(propertyName);
if (f != null) columnannotation = f.getAnnotation(Column.class);
} catch (Exception e) {
}
Basic basic = pd.getReadMethod().getAnnotation(Basic.class);
if (basic == null)
try {
Field f = declaredClass.getDeclaredField(propertyName);
if (f != null) basic = f.getAnnotation(Basic.class);
} catch (Exception e) {
}
Lob lob = pd.getReadMethod().getAnnotation(Lob.class);
if (lob == null)
try {
Field f = declaredClass.getDeclaredField(propertyName);
if (f != null) lob = f.getAnnotation(Lob.class);
} catch (Exception e) {
}
UiConfigImpl uci = new UiConfigImpl(pd.getPropertyType(), uiConfig);
if (idAssigned && propertyName.equals("id")) uci.addCssClass("required checkavailable");
if (Attributable.class.isAssignableFrom(entityClass) && pd.getName().equals("attributes")) {
uci.setType("attributes");
}
if (trans != null) {
uci.setExcludedFromCriteria(true);
uci.setExcludedFromLike(true);
uci.setExcludedFromOrdering(true);
}
if (lob != null) {
uci.setExcludedFromCriteria(true);
if (uci.getMaxlength() == 0) uci.setMaxlength(2 * 1024 * 1024);
}
if (columnannotation != null && !columnannotation.nullable()
|| basic != null && !basic.optional()) uci.setRequired(true);
if (columnannotation != null && columnannotation.length() != 255 && uci.getMaxlength() == 0)
uci.setMaxlength(columnannotation.length());
if (lob != null || uci.getMaxlength() > 255) uci.setExcludedFromOrdering(true);
Class<?> returnType = pd.getPropertyType();
if (returnType.isEnum()) {
uci.setType("enum");
try {
returnType.getMethod("getName");
uci.setListKey("name");
} catch (NoSuchMethodException e) {
uci.setListKey("top");
}
try {
returnType.getMethod("getDisplayName");
uci.setListValue("displayName");
} catch (NoSuchMethodException e) {
uci.setListValue(uci.getListKey());
}
map.put(propertyName, uci);
continue;
} else if (Persistable.class.isAssignableFrom(returnType)) {
JoinColumn joincolumnannotation = pd.getReadMethod().getAnnotation(JoinColumn.class);
if (joincolumnannotation == null)
try {
Field f = declaredClass.getDeclaredField(propertyName);
if (f != null) joincolumnannotation = f.getAnnotation(JoinColumn.class);
} catch (Exception e) {
}
if (joincolumnannotation != null && !joincolumnannotation.nullable())
uci.setRequired(true);
ManyToOne manyToOne = pd.getReadMethod().getAnnotation(ManyToOne.class);
if (manyToOne == null)
try {
Field f = declaredClass.getDeclaredField(propertyName);
if (f != null) manyToOne = f.getAnnotation(ManyToOne.class);
} catch (Exception e) {
}
if (manyToOne != null && !manyToOne.optional()) uci.setRequired(true);
uci.setType("listpick");
uci.setExcludeIfNotEdited(true);
if (StringUtils.isBlank(uci.getPickUrl())) {
String url = AutoConfigPackageProvider.getEntityUrl(returnType);
StringBuilder sb =
url != null
? new StringBuilder(url)
: new StringBuilder("/")
.append(StringUtils.uncapitalize(returnType.getSimpleName()));
sb.append("/pick");
Set<String> columns = new LinkedHashSet<String>();
columns.addAll(
AnnotationUtils.getAnnotatedPropertyNameAndAnnotations(returnType, NaturalId.class)
.keySet());
Map<String, UiConfigImpl> configs = getUiConfigs(returnType);
for (String column : "fullname,name,code".split(","))
if (configs.containsKey(column)
&& (!columns.contains("fullname") && column.equals("name")
|| !column.equals("name"))) columns.add(column);
for (Map.Entry<String, UiConfigImpl> entry : configs.entrySet())
if (entry.getValue().isShownInPick()) columns.add(entry.getKey());
if (!columns.isEmpty()) {
sb.append("?columns=" + StringUtils.join(columns, ','));
}
uci.setPickUrl(sb.toString());
}
map.put(propertyName, uci);
continue;
}
if (returnType == Integer.TYPE
|| returnType == Short.TYPE
|| returnType == Long.TYPE
|| returnType == Double.TYPE
|| returnType == Float.TYPE
|| Number.class.isAssignableFrom(returnType)) {
if (returnType == Integer.TYPE
|| returnType == Integer.class
|| returnType == Short.TYPE
|| returnType == Short.class) {
uci.setInputType("number");
uci.addCssClass("integer");
} else if (returnType == Long.TYPE || returnType == Long.class) {
uci.setInputType("number");
uci.addCssClass("long");
} else if (returnType == Double.TYPE
|| returnType == Double.class
|| returnType == Float.TYPE
|| returnType == Float.class
|| returnType == BigDecimal.class) {
uci.setInputType("number");
uci.addCssClass("double");
}
Set<String> cssClasses = uci.getCssClasses();
if (cssClasses.contains("double") && !uci.getDynamicAttributes().containsKey("step"))
uci.getDynamicAttributes().put("step", "0.01");
if (cssClasses.contains("positive") && !uci.getDynamicAttributes().containsKey("min")) {
uci.getDynamicAttributes().put("min", "1");
if (cssClasses.contains("double")) uci.getDynamicAttributes().put("min", "0.01");
if (cssClasses.contains("zero")) uci.getDynamicAttributes().put("min", "0");
}
} else if (Date.class.isAssignableFrom(returnType)) {
Temporal temporal = pd.getReadMethod().getAnnotation(Temporal.class);
if (temporal == null)
try {
Field f = declaredClass.getDeclaredField(propertyName);
if (f != null) temporal = f.getAnnotation(Temporal.class);
} catch (Exception e) {
}
String temporalType = "date";
if (temporal != null)
if (temporal.value() == TemporalType.TIMESTAMP) temporalType = "datetime";
else if (temporal.value() == TemporalType.TIME) temporalType = "time";
uci.addCssClass(temporalType);
// uci.setInputType(temporalType);
if (StringUtils.isBlank(uci.getCellEdit())) uci.setCellEdit("click," + temporalType);
} else if (String.class == returnType
&& pd.getName().toLowerCase().contains("email")
&& !pd.getName().contains("Password")) {
uci.setInputType("email");
uci.addCssClass("email");
} else if (returnType == Boolean.TYPE || returnType == Boolean.class) {
uci.setType("checkbox");
}
if (columnannotation != null && columnannotation.unique()) uci.setUnique(true);
if (searchableProperty != null || searchableId != null) uci.setSearchable(true);
if (naturalIds.containsKey(pd.getName())) {
uci.setRequired(true);
if (naturalIds.size() == 1) uci.addCssClass("checkavailable");
}
map.put(propertyName, uci);
}
List<Map.Entry<String, UiConfigImpl>> list =
new ArrayList<Map.Entry<String, UiConfigImpl>>(map.entrySet());
Collections.sort(list, comparator);
Map<String, UiConfigImpl> sortedMap = new LinkedHashMap<String, UiConfigImpl>();
for (Map.Entry<String, UiConfigImpl> entry : list)
sortedMap.put(entry.getKey(), entry.getValue());
map = sortedMap;
cache.put(entityClass, Collections.unmodifiableMap(map));
}
return map;
}
@SuppressWarnings({"resource", "rawtypes", "unchecked"})
public static void main(String[] args) throws Exception {
Configuration cfg = new Configuration();
// 设置FreeMarker的模版文件位置
cfg.setClassForTemplateLoading(
SourceCodeFrameworkBuilder.class, "/lab/s2jh/tool/builder/freemarker");
cfg.setDefaultEncoding("UTF-8");
String rootPath = args[0];
Set<String> entityNames = new HashSet<String>();
String entityListFile = rootPath + "entity_list.properties";
BufferedReader reader = new BufferedReader(new FileReader(entityListFile));
String line;
while ((line = reader.readLine()) != null) {
if (StringUtils.isNotBlank(line) && !line.startsWith("#")) {
entityNames.add(line);
}
}
new File(rootPath + "\\codes").mkdir();
new File(rootPath + "\\codes\\integrate").mkdir();
new File(rootPath + "\\codes\\standalone").mkdir();
for (String entityName : entityNames) {
String integrateRootPath = rootPath + "\\codes\\integrate\\";
String standaloneRootPath = rootPath + "\\codes\\standalone\\";
String rootPackage = StringUtils.substringBetween(entityName, "[", "]");
String rootPackagePath = StringUtils.replace(rootPackage, ".", "\\");
String className = StringUtils.substringAfterLast(entityName, ".");
String classFullName =
StringUtils.replaceEach(entityName, new String[] {"[", "]"}, new String[] {"", ""});
String modelName = StringUtils.substringBetween(entityName, "].", ".entity");
String modelPath = StringUtils.replace(modelName, ".", "/");
modelPath = "/" + modelPath;
String modelPackagePath = StringUtils.replace(modelName, ".", "\\");
modelPackagePath = "\\" + modelPackagePath;
Map<String, Object> root = new HashMap<String, Object>();
String nameField = propertyToField(StringUtils.uncapitalize(className)).toLowerCase();
root.put("model_name", modelName);
root.put("model_path", modelPath);
root.put("entity_name", className);
root.put("entity_name_uncapitalize", StringUtils.uncapitalize(className));
root.put("entity_name_field", nameField);
root.put("root_package", rootPackage + "." + modelName);
root.put("action_package", rootPackage);
root.put("table_name", "T_TODO_" + className.toUpperCase());
root.put("base", "${base}");
Class entityClass = Class.forName(classFullName);
root.put("id_type", entityClass.getMethod("getId").getReturnType().getSimpleName());
MetaData classEntityComment = (MetaData) entityClass.getAnnotation(MetaData.class);
if (classEntityComment != null) {
root.put("model_title", classEntityComment.value());
} else {
root.put("model_title", entityName);
}
debug("Entity Data Map=" + root);
Set<Field> fields = new HashSet<Field>();
Field[] curfields = entityClass.getDeclaredFields();
for (Field field : curfields) {
fields.add(field);
}
Class superClass = entityClass.getSuperclass();
while (superClass != null && !superClass.equals(BaseEntity.class)) {
Field[] superfields = superClass.getDeclaredFields();
for (Field field : superfields) {
fields.add(field);
}
superClass = superClass.getSuperclass();
}
// 定义用于OneToOne关联对象的Fetch参数
Map<String, String> fetchJoinFields = Maps.newHashMap();
List<EntityCodeField> entityFields = new ArrayList<EntityCodeField>();
int cnt = 1;
for (Field field : fields) {
if ((field.getModifiers() & Modifier.FINAL) != 0 || "id".equals(field.getName())) {
continue;
}
debug(" - Field=" + field);
Class fieldType = field.getType();
EntityCodeField entityCodeField = null;
if (fieldType.isEnum()) {
entityCodeField = new EntityCodeField();
entityCodeField.setListFixed(true);
entityCodeField.setListWidth(80);
entityCodeField.setListAlign("center");
} else if (fieldType == Boolean.class) {
entityCodeField = new EntityCodeField();
entityCodeField.setListFixed(true);
entityCodeField.setListWidth(60);
entityCodeField.setListAlign("center");
} else if (PersistableEntity.class.isAssignableFrom(fieldType)) {
entityCodeField = new EntityCodeField();
entityCodeField.setFieldType("Entity");
} else if (Number.class.isAssignableFrom(fieldType)) {
entityCodeField = new EntityCodeField();
entityCodeField.setListFixed(true);
entityCodeField.setListWidth(60);
entityCodeField.setListAlign("right");
} else if (fieldType == String.class) {
entityCodeField = new EntityCodeField();
// 根据Hibernate注解的字符串类型和长度设定是否列表显示
Method getMethod = entityClass.getMethod("get" + StringUtils.capitalize(field.getName()));
Column fieldColumn = getMethod.getAnnotation(Column.class);
if (fieldColumn != null) {
int length = fieldColumn.length();
if (length > 255) {
entityCodeField.setList(false);
entityCodeField.setListWidth(length);
}
}
Lob fieldLob = getMethod.getAnnotation(Lob.class);
if (fieldLob != null) {
entityCodeField.setList(false);
entityCodeField.setListWidth(Integer.MAX_VALUE);
}
} else if (fieldType == Date.class) {
entityCodeField = new EntityCodeField();
entityCodeField.setListFixed(true);
// 根据Json注解设定合理的列宽
entityCodeField.setListWidth(120);
Method getMethod = entityClass.getMethod("get" + StringUtils.capitalize(field.getName()));
JsonSerialize fieldJsonSerialize = getMethod.getAnnotation(JsonSerialize.class);
if (fieldJsonSerialize != null) {
if (DateJsonSerializer.class.equals(fieldJsonSerialize.using())) {
entityCodeField.setListWidth(80);
}
}
entityCodeField.setListAlign("center");
}
if (entityCodeField != null) {
if (fieldType.isEnum()) {
entityCodeField.setEnumField(true);
}
if (StringUtils.isBlank(entityCodeField.getFieldType())) {
entityCodeField.setFieldType(fieldType.getSimpleName());
}
entityCodeField.setFieldName(field.getName());
EntityAutoCode entityAutoCode = field.getAnnotation(EntityAutoCode.class);
if (entityAutoCode != null) {
entityCodeField.setListHidden(entityAutoCode.listHidden());
entityCodeField.setEdit(entityAutoCode.edit());
entityCodeField.setList(entityAutoCode.listHidden() || entityAutoCode.listShow());
entityCodeField.setOrder(entityAutoCode.order());
} else {
entityCodeField.setTitle(field.getName());
entityCodeField.setOrder(cnt++);
}
MetaData entityMetaData = field.getAnnotation(MetaData.class);
if (entityMetaData != null) {
entityCodeField.setTitle(entityMetaData.value());
}
Method getMethod = entityClass.getMethod("get" + StringUtils.capitalize(field.getName()));
JsonProperty fieldJsonProperty = getMethod.getAnnotation(JsonProperty.class);
if (fieldJsonProperty != null) {
entityCodeField.setList(true);
}
if (entityCodeField.getList() || entityCodeField.getListHidden()) {
JoinColumn fieldJoinColumn = getMethod.getAnnotation(JoinColumn.class);
if (fieldJoinColumn != null) {
if (fieldJoinColumn.nullable() == false) {
fetchJoinFields.put(field.getName(), "INNER");
} else {
fetchJoinFields.put(field.getName(), "LEFT");
}
}
}
entityFields.add(entityCodeField);
}
}
Collections.sort(entityFields);
root.put("entityFields", entityFields);
if (fetchJoinFields.size() > 0) {
root.put("fetchJoinFields", fetchJoinFields);
}
integrateRootPath = integrateRootPath + rootPackagePath + modelPackagePath;
// process(cfg.getTemplate("Entity.ftl"), root, integrateRootPath + "\\entity\\", className +
// ".java");
process(
cfg.getTemplate("Dao.ftl"), root, integrateRootPath + "\\dao\\", className + "Dao.java");
process(
cfg.getTemplate("Service.ftl"),
root,
integrateRootPath + "\\service\\",
className + "Service.java");
process(
cfg.getTemplate("Controller.ftl"),
root,
integrateRootPath + "\\web\\action\\",
className + "Controller.java");
process(
cfg.getTemplate("Test.ftl"),
root,
integrateRootPath + "\\test\\service\\",
className + "ServiceTest.java");
process(
cfg.getTemplate("JSP_Index.ftl"),
root,
integrateRootPath + "\\jsp\\",
nameField + "-index.jsp");
process(
cfg.getTemplate("JSP_Input_Tabs.ftl"),
root,
integrateRootPath + "\\jsp\\",
nameField + "-inputTabs.jsp");
process(
cfg.getTemplate("JSP_Input_Basic.ftl"),
root,
integrateRootPath + "\\jsp\\",
nameField + "-inputBasic.jsp");
process(
cfg.getTemplate("JSP_View_Tabs.ftl"),
root,
integrateRootPath + "\\jsp\\",
nameField + "-viewTabs.jsp");
process(
cfg.getTemplate("JSP_View_Basic.ftl"),
root,
integrateRootPath + "\\jsp\\",
nameField + "-viewBasic.jsp");
standaloneRootPath =
standaloneRootPath + rootPackagePath + modelPackagePath + "\\" + className;
// process(cfg.getTemplate("Entity.ftl"), root, standaloneRootPath + "\\entity\\", className +
// ".java");
process(
cfg.getTemplate("Dao.ftl"), root, standaloneRootPath + "\\dao\\", className + "Dao.java");
process(
cfg.getTemplate("Service.ftl"),
root,
standaloneRootPath + "\\service\\",
className + "Service.java");
process(
cfg.getTemplate("Controller.ftl"),
root,
standaloneRootPath + "\\web\\action\\",
className + "Controller.java");
process(
cfg.getTemplate("Test.ftl"),
root,
standaloneRootPath + "\\test\\service\\",
className + "ServiceTest.java");
process(
cfg.getTemplate("JSP_Index.ftl"),
root,
standaloneRootPath + "\\jsp\\",
nameField + "-index.jsp");
process(
cfg.getTemplate("JSP_Input_Tabs.ftl"),
root,
standaloneRootPath + "\\jsp\\",
nameField + "-inputTabs.jsp");
process(
cfg.getTemplate("JSP_Input_Basic.ftl"),
root,
standaloneRootPath + "\\jsp\\",
nameField + "-inputBasic.jsp");
process(
cfg.getTemplate("JSP_View_Tabs.ftl"),
root,
standaloneRootPath + "\\jsp\\",
nameField + "-viewTabs.jsp");
process(
cfg.getTemplate("JSP_View_Basic.ftl"),
root,
standaloneRootPath + "\\jsp\\",
nameField + "-viewBasic.jsp");
}
}