`

使用appfuse的基本开发步骤

    博客分类：
  • web
AppfuseHibernateAntDAOXML 
阅读更多

在appfuse手册中的开发步骤是先建立数据库表，然后通过自动化的工具产生pojo以及其他的对象。但是对于复杂的pojo，用数据库表现出来就显得力不从心。因此，适当的方法应当是先去写pojo，然后自动产生其他的代码。这里是我总结的开发步骤。

1。首先编写pojo，继承BaseObject，通过自动化工具产生set/get方法，以及hashCode(), toString(), equals()方法。我用了网上的一段开源代码放到我的工程里面，在eclipse里面直接调用：

java 代码
  1. package org.appfuse.tools;   
  2.   
  3. import java.lang.reflect.Field;   
  4. import java.lang.reflect.Modifier;   
  5. import java.util.ArrayList;   
  6. import java.util.List;   
  7.   
  8. /**  
  9.  * A utility class that generates source code for good   
  10.  * boolean equals(), int hashCode(), and   
  11.  * String toString() implementations.  
  12.  *   
  13.  * 

     

     
  14.  * The algorithms used here are based largely on those presented in   
  15.  * "Effective Java" by   
  16.  * Josh Bloch, with some variations based on conversations with colleagues.  
  17.  * 

     

     
  18.  *   
  19.  * @author Erick G. Reid  
  20.  */  
  21. public class SourcecodeGenerator {   
  22.            
  23.   /**  
  24.    * Returns a String representing usable   
  25.    * boolean equals(Object) sourcecode for the given   
  26.    * Class.   
  27.    *  
  28.    * @param source the Class to inspect.  
  29.    * @return a String representing usable   
  30.    *        boolean equals(Object) sourcecode for the given   
  31.    *        Class.  
  32.    */  
  33.   public static String getEqualsSourceCode(Class source) {   
  34.     Field[] fields = _getEligibleFields(source);   
  35.     StringBuffer sb = new StringBuffer();   
  36.     String className = _getClassName(source);   
  37.     sb.append("/**\n");   
  38.     sb.append(" * Compares this object to the specified object.  The result is\n");   
  39.     sb.append(" * true if and only if the argument is not null\n");   
  40.     sb.append(" * and is an instance of " which represents a\n" + className + ");   
  41.     sb.append(" * value equivalent to this ".\n" + className + ");   
  42.     sb.append(" *\n");   
  43.     sb.append(" * @param object the object to compare with.\n");   
  44.     sb.append(" * @return true if the objects are the same,\n)");   
  45.     sb.append(" *     returns false otherwise.\n");   
  46.     sb.append(" */\n");   
  47.     sb.append("public boolean equals(Object object) {\n");   
  48.     sb.append("  if (object != this) {\n");   
  49.     if (fields.length == 0) {   
  50.       sb.append(   
  51.           "    return object != null && getClass().equals(object.getClass());\n");   
  52.     }   
  53.     else {   
  54.       sb.append("    if (object != null && getClass().equals(object.getClass())) {\n");   
  55.       sb.append("      final " + className + " other = (" + className + ") object;\n");   
  56.       for (int i = 0; i < fields.length; i++) {   
  57.         if (i == 0) sb.append("      return ");    
  58.         else sb.append("          ");    
  59.         if (fields[i].getType().isPrimitive()) {   
  60.           sb.append("(" + fields[i].getName() + " == other." + fields[i].getName() + ")");   
  61.         }   
  62.         else {   
  63.           sb.append("(" + fields[i].getName() + " == null ? other." +    
  64.               fields[i].getName() + " == null : " + fields[i].getName() +    
  65.               ".equals(other." + fields[i].getName() + "))");   
  66.         }   
  67.         if (i == fields.length - 1) sb.append(";\n");    
  68.         else sb.append(" &&\n");    
  69.       }   
  70.       sb.append("    }\n");   
  71.       sb.append("    return false;\n");   
  72.     }   
  73.     sb.append("  }\n");   
  74.     sb.append("  return true;\n");   
  75.     sb.append("}\n");   
  76.     return sb.toString();   
  77.   }   
  78.        
  79. /**  
  80.  * Returns a String representing usable hashCode()   
  81.  * sourcecode for the given Class.   
  82.  *  
  83.  * @param source the Class to inspect.  
  84.  * @return a String representing usable hashCode()   
  85.  *      sourcecode for the given Class.  
  86.  */  
  87. public static String getHashCodeSourceCode(Class source) {   
  88.   Field[] fields = _getEligibleFields(source);   
  89.   String className = _getClassName(source);   
  90.   StringBuffer sb = new StringBuffer();   
  91.   sb.append("/**\n");   
  92.   sb.append(" * Returns a hash code value for this ".\n" +    
  93.       className + ");   
  94.   sb.append(" *\n");   
  95.   sb.append(" * @return a hash code value for this ".\n" +    
  96.       className + ");   
  97.   sb.append(" */\n");   
  98.   sb.append("public int hashCode() {\n");   
  99.   sb.append("  int hashCode = " + source.getName().hashCode() +    
  100.       "; // result of getClass().getName().hashCode() \n");   
  101.   for (int i = 0; i < fields.length; i++) {   
  102.     if (fields[i].getType().isArray()) {   
  103.       sb.append("  for (int i = 0; i < " +    
  104.           fields[i].getName() + ".length; i++) {\n");   
  105.       _appendFieldHashCalculation(   
  106.           sb, fields[i].getType().getComponentType(),    
  107.           fields[i].getName() + "[i]", "      ");   
  108.       sb.append("  }\n");   
  109.       continue;   
  110.     }   
  111.     _appendFieldHashCalculation(   
  112.         sb, fields[i].getType(), fields[i].getName(), "    ");   
  113.   }   
  114.   sb.append("  return hashCode;\n");   
  115.   sb.append("}\n");   
  116.   return sb.toString();   
  117. }   
  118.        
  119.   /**  
  120.    * Returns a String representing usable   
  121.    * String toString() sourcecode for the given Class.   
  122.    *  
  123.    * @param source the Class to inspect.  
  124.    * @return a String representing usable   
  125.    *        String toString() sourcecode for the given   
  126.    *        Class.  
  127.    */  
  128.   public static String getToStringSourceCode(Class source) {   
  129.     Field[] fields = _getEligibleFields(source);   
  130.     StringBuffer sb = new StringBuffer();   
  131.     String className = _getClassName(source);   
  132.     sb.append("/**\n");   
  133.     sb.append(" * Returns a String representation of this ".\n" +    
  134.         className + ");   
  135.     sb.append(" *\n");   
  136.     sb.append(" * @return a String representation of this ".\n" +    
  137.         className + ");   
  138.     sb.append(" */\n");   
  139.     sb.append("public String toString() {\n");   
  140.     if (fields.length == 0) {   
  141.       sb.append("  return \"" + className + "()\";\n");   
  142.     }   
  143.     else {   
  144.       sb.append("  StringBuffer buffer = new StringBuffer(\"" +    
  145.           className + "(\");\n");   
  146.       for (int i = 0; i < fields.length; i++) {   
  147.         sb.append("  buffer.append(\"" + fields[i].getName() + "=\" + " +    
  148.             fields[i].getName());   
  149.         if (i == fields.length - 1) sb.append(" + \")\");\n");    
  150.         else sb.append(" + \",\");\n");    
  151.       }   
  152.       sb.append("  return buffer.toString();\n");   
  153.     }   
  154.     sb.append("}\n");   
  155.     return sb.toString();   
  156.   }   
  157.        
  158.   //--------------------------------------------------   
  159.   // implementation:   
  160.   //--------------------------------------------------   
  161.      
  162.   private static void _appendFieldHashCalculation(   
  163.       StringBuffer sb, Class type, String fieldName, String indent) {   
  164.        
  165.     if (type.isPrimitive()) {   
  166.       if (Boolean.TYPE.equals(type)) {   
  167.         sb.append(indent +    
  168.             "hashCode = 37 * hashCode + (" + fieldName + " ? 0 : 1);\n");             
  169.       }   
  170.       else if (Byte.TYPE.equals(type) || Character.TYPE.equals(type) ||    
  171.           Short.TYPE.equals(type) || Integer.TYPE.equals(type)) {   
  172.         sb.append(indent + "hashCode = 37 * hashCode + " +    
  173.             (Integer.TYPE.equals(type) ? "" : "(int) ") + fieldName + ";\n");             
  174.       }   
  175.       else if (Long.TYPE.equals(type)) {   
  176.         sb.append(indent + "hashCode = 37 * hashCode + (int)(" + fieldName +    
  177.             " ^ (" + fieldName + " >>> 32));\n");             
  178.       }   
  179.       else if (Float.TYPE.equals(type)) {   
  180.         sb.append(indent + "hashCode = 37 * hashCode + Float.floatToIntBits(" +    
  181.             fieldName + ");\n");             
  182.       }   
  183.       else if (Double.TYPE.equals(type)) {   
  184.         sb.append(indent + "long longBits = Double.doubleToLongBits(" +    
  185.             fieldName + ");\n");             
  186.         sb.append(indent +    
  187.             "hashCode = 37 * hashCode + (int)(longBits ^ (longBits >>> 32));\n");             
  188.       }   
  189.       return;   
  190.     }   
  191.     sb.append(indent + "hashCode = 37 * hashCode + (" +    
  192.         fieldName + " == null ? 0 : " + fieldName + ".hashCode());\n");   
  193.   }   
  194.   
  195.   /**  
  196.    * Returns all instance fields from the given class that are found to be   
  197.    * non-public.  
  198.    */  
  199.   private static Field[] _getEligibleFields(Class source) {   
  200.     Field[] fields = source.getDeclaredFields();   
  201.     List<field></field> eligibleFields = new ArrayList<field></field>();   
  202.     for (int i = 0; i < fields.length; i++) {   
  203.       int modifiers = fields[i].getModifiers();   
  204.       if (!Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers)) {   
  205.         eligibleFields.add(fields[i]);   
  206.       }   
  207.     }   
  208.     return (Field[]) eligibleFields.toArray(new Field[eligibleFields.size()]);   
  209.   }   
  210.      
  211.   private static String _getClassName(Class source) {   
  212.     String className = source.getName();   
  213.     return className.substring(className.lastIndexOf(".") + 1);   
  214.   }   
  215.      
  216.   public static void main(String[] args) {   
  217.       Class source=null;   
  218.       //reslove object   
  219.       try {   
  220.         source=Class.forName(args[0]);   
  221.     } catch (ClassNotFoundException e) {   
  222.         // TODO Auto-generated catch block   
  223.         e.printStackTrace();   
  224.         return;   
  225.     }   
  226.          
  227.       System.out.println(SourcecodeGenerator.getEqualsSourceCode(source));   
  228.       System.out.println(SourcecodeGenerator.getHashCodeSourceCode(source));   
  229.       System.out.println(SourcecodeGenerator.getToStringSourceCode(source));   
  230.   }   
  231. }   

 

产生pojo以后，加上xdoclet的tag，主要包含@hibernate以及◎spring.validator两方面的tag。通过tag的增加，规定了如何产生数据库的表。

2。运行ant hibernatedoclet自动产生hbm文件，在build/dao/gen/目录下。

3。通过如下的脚本工具可以根据指定的hbm文件创建数据库，当然也可以使用hibernate的schemaexport工具。

java 代码
  1. import java.io.FileInputStream;   
  2. import java.io.InputStream;   
  3. import java.util.Properties;   
  4.   
  5. import org.appfuse.util.XmlTools;   
  6. import org.hibernate.cfg.Configuration;   
  7. import org.hibernate.tool.hbm2ddl.SchemaExport;   
  8. import org.w3c.dom.Document;   
  9.   
  10. /**  
  11.  *   
  12.  * @author Cheney Yuan  
  13.  *  
  14.  */  
  15. public class HibernateSchemaExport {   
  16.   
  17.     /**  
  18.      * @param args  
  19.      */  
  20.     public static void main(String[] args) {   
  21.         if (args.length < 1) {   
  22.             System.err.println("Usage: HibernateSchemaExport [full file path]hibernate.cfg.xml/database.properties "  
  23.                 + "[resource path]mapping.hbm.xml\n");   
  24.             System.exit(-1);   
  25.         }   
  26.   
  27.         Configuration config=new Configuration();   
  28.         Properties properties=new Properties();   
  29.   
  30.         String fullPathName=args[0];   
  31.         try {   
  32.             if (fullPathName.indexOf(".xml")>0) {   
  33.                 System.out.println("use xml file to configure.");   
  34.                 Document doc = null;   
  35.                 doc = XmlTools.getDocumentFromXmlFile(fullPathName);   
  36.                 config.configure(doc);   
  37.             }else if (fullPathName.indexOf(".properties")>0) {   
  38.                 System.out.println("use properties to configure.");   
  39.                 Properties props = new Properties();   
  40.                 props.putAll( config.getProperties() );   
  41.                 props.load( new FileInputStream( fullPathName ) );   
  42.                 config.setProperties( props );   
  43.   
  44.             }   
  45.         } catch (Exception e) {   
  46.             e.printStackTrace();   
  47.             return;   
  48.         }   
  49.   
  50.         //add hbm resources   
  51.         for (int i=1;i
  52.             config.addResource(args[i]);   
  53.         }   
  54.         /**  
  55.          * @param script print the DDL to the console  
  56.          * @param export export the script to the database  
  57.          */  
  58.         new SchemaExport(config).create(true, false);   
  59.   
  60.     }   
  61.   
  62. }  

4。到extras/appgen下面运行ant install-detailed产生其他的类和测试程序。

5。applicationContext-hibernate.xml里面的hbm文件必须自己添加，该文件的位置在src/dao/org/appfuse/dao/hibernate/目录下。

6。运行ant deploy即可完成整个开发步骤。

分享到：
| appfuse中菜单的配置
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    使用 AppFuse 快速构建 java

    为了开始使用AppFuse，首先需要准备一个合适的开发环境。以下是一些基本步骤： 1. **下载AppFuse**: 从AppFuse的官方网站下载最新版本的源码包（本文使用的版本是appfuse-tapestry-1.9.3-src.zip）。将其解压至所需...

    玩转appfuse--使用appfuse建设MVC网站

    在提供的压缩包中，"基于appfuse开发网站.doc"很可能是详细的开发指南，涵盖了AppFuse的使用方法、配置步骤以及常见问题。"CertsManSys"可能是一个实际的AppFuse应用示例，包含了完整的源代码，你可以运行这个例子来...

    Appfuse教程Appfuse开发.pdf

    1. **集成流行框架**：Appfuse 将 Hibernate、Struts、Spring 等框架进行了深度集成，为开发者提供了一个统一的开发平台，降低了学习和使用这些框架的门槛。 2. **提供常用功能**：框架内已经预设了如用户认证、角色...

    appfuse开发框架(myapp)使用说明文档

    以上步骤提供了关于如何使用AppFuse框架进行开发的基本指南，包括配置环境、导入项目以及生成CRUD操作所需的代码模板。这些指南对于初学者来说尤其有用，可以帮助他们快速上手并高效地进行应用程序的开发。

    appfuse 学习笔记

    ### Appfuse 学习笔记 #### 一、Appfuse 简介 Appfuse 是一个开源框架，...通过以上步骤，可以成功搭建起基于 Appfuse 2.0 的开发环境，并创建出各种类型的应用项目。接下来可以根据实际需求进行更深入的学习和开发。

    appfuse开发文档

    AppFuse的使用流程通常包括以下几个步骤： 1. **下载或从CVS获取源码**：可以从官方站点下载最新版本的AppFuse，或者通过CVS命令直接检出项目源码。 2. **创建新应用**：运行Ant命令，指定应用名和数据库名，生成...

    使用AppFuse快速构建J2EE应用.doc

    AppFuse 是一个开源项目，旨在帮助开发者快速构建J2EE应用...本文提供的示例和步骤是基于一个使用Tapestry、Hibernate和Spring的简单应用，但AppFuse也支持其他技术栈，如Struts、JSF等，可以根据项目需求进行选择。

    建立项目原型骨架的步骤(最新版本appfuse)appfuse2.1.0-M2

    在最新的版本2.1.0-M2中，AppFuse 提供了基本（basic）和模块化（modular）两种类型的原型，以便于开发者根据项目需求选择合适的方式来创建项目。 建立项目原型骨架的步骤如下： 1. 首先，通过Maven的archetype...

    MAVEN 搭建APPFUSE

    【MAVEN 搭建APPFUSE】是一个关于使用Maven构建基于...总之，通过这个教程，你将掌握如何使用Maven与AppFuse相结合，高效地构建和管理Java Web应用，从而提升开发效率，减少重复工作，使你的项目更加规范和易于维护。

    Appfuse开发教程

    ### Appfuse开发教程详解 #### 第一部分：在AppFuse建立DAO和POJO Appfuse是一个开源的Java EE应用框架，其目标是简化企业级应用程序的开发过程，通过提供一系列预构建的功能模块，如用户管理、权限控制等，帮助...

    appfuse2学习日记

    通过使用 AppFuse，开发人员可以在构建新的 Web 项目时大大节省在项目结构设置上的时间。 - **定位**：AppFuse 更像是一个项目的骨架或模板，它通过集成各种工具和技术（如 Java, Maven, Struts 等），提供了快速...

    AppFuse Primer

    ### AppFuse Primer 相关知识点 ...综上所述，《AppFuse Primer》是一本非常适合希望使用AppFuse框架进行Java Web应用开发的读者的书籍。无论是初学者还是有经验的开发者，都可以从中获取到有价值的信息和实践技巧。

    appfuse 配置说明 doc 格式

    根据给定的文件信息，我们可以详细解析如何配置和使用AppFuse进行开发。以下是详细的配置步骤： ##### 1. **搭建开发环境** - **下载AppFuse源码**：从官方网站下载`appfuse-1.9.3-src.zip`，并将其解压至`D:\...

    appfuse-beginner

    尽管具体的博客内容无法在这里直接展示，但我们可以推测这篇文章会涵盖 AppFuse 的基本概念、安装步骤、创建第一个应用的过程以及如何利用 AppFuse 的特性来简化开发工作。 标签“源码”和“工具”暗示了这个压缩包...

    appfuse-documentation-2.1.0官方文档

    这部分内容对于初学者尤为重要，因为它覆盖了如何从零开始搭建基于 AppFuse 的项目，并介绍了 Maven 的基本概念，例如依赖管理、构建生命周期等。 #### 商业支持 (Commercial Support) 除了免费的社区支持之外，...

Magicbox
Global site tag (gtag.js) - Google Analytics