精华内容
下载资源
问答
  • Java开源Web开发框架

    千次阅读 2009-08-21 15:27:00
    WebWork WebWork是由OpenSymphony组织开发的,致力于组件化和代码重用的拉出式MVC模式J2EE Web框架。WebWork目前最新版本是2.1,现在的WebWork2.x前身是Rickard Oberg开发的WebWork,但现在WebWork已经被拆分成了...

     WebWork 

    WebWork是由OpenSymphony组织开发的,致力于组件化和代码重用的拉出式MVC模式J2EE Web框架。WebWork目前最新版本是2.1,现在的WebWork2.x前身是Rickard Oberg开发的WebWork,但现在WebWork已经被拆分成了Xwork1和WebWork2两个项目。 Xwork简洁、灵活功能强大,它是一个标准的Command模式实现,并且完全从web层脱离出来。 Xwork提供了很多核心功能:前端拦截机(interceptor),运行时表单属性验证,类型转换,强大的表达式语言(OGNL – the Object Graph Notation Language),IoC(Inversion of Control倒置控制)容器等。 WebWork2建立在Xwork之上,处理HTTP的响应和请求。WebWork2使用ServletDispatcher将HTTP请求的变成Action(业务层Action类), session(会话)application(应用程序)范围的映射,request请求参数映射。WebWork2支持多视图表示,视图部分可以使用JSP, Velocity, FreeMarker, JasperReports,XML等。在WebWork2.2中添加了对AJAX的支持,这支持是构建在DWR与Dojo这两个框架的基础之上.【EclipseWork 用于WebWork辅助开发的一个Eclipse插件

    更多WebWork信息

     Struts 

    Struts是一个基于Sun J2EE平台的MVC框架,主要是采用Servlet和JSP技术来实现的。由于Struts能充分满足应用开发的需求,简单易用,敏捷迅速,在过去的一年中颇受关注。Struts把Servlet、JSP、自定义标签和信息资源(message resources)整合到一个统一的框架中,开发人员利用其进行开发时不用再自己编码实现全套MVC模式,极大的节省了时间,所以说Struts是一个非常不错的应用框架。【StrutsIDE 用于Struts辅助开发的一个Eclipse插件

    更多Struts信息

     EasyJWeb 

    EasyJWeb是基于java技术,应用于WEB应用程序快速开发的MVC框架,框架设计构思来源于国内众多项目实践,框架充分借签了当前主要流行的开源Web框架(Struts、JSF、Tapestry 、Webwork),吸取了其优点及精华,利用Velocity作为模板页面引擎,是一个实现了页面及代码完全分离的MVC开发框架。是一个能实现中小型Web应用系统快速开发的简易Web框架。

      通过EasyJWeb Tools提供的配套开发工具,可以实现基于EasyJWeb框架的Web应用快速开发,包括常用应用软件的代码自生成、数据库添删改查(CRUD)代码生成、自动页面模版生成、配置文件管理等。

      框架特点:

      1、零配文件置支持 。以前我们每接触一个框架,开始总都要被他的配置文件折腾一番。EasyJWeb实现零配置支持,可以不写一句配置文件就在框架基础上构建你的运用。(适合小型网站系统)。

      2、简易的模板页面设计支持 :放弃使用jsp,使用简单Velocity脚本语言作为页面模板。

      3、页面程序完全分离: 实现显示页面与程序逻辑的完全分离,克服了传统jsp页面难于维护的问题。

      4、基于页面组件的框架。 灵活的页面组件配置,可以直接通过配置文件设置字段级的事件组件。

      5、快速开发支持: 通过EasyJWeb Tools,可以自动生成应用软件模板代码,定制并管理自己的J2EE代码模板,代码生成模板支持最流行的实用Java开发框架(如hibernate、Spring等)实现快速开发。

    更多EasyJWeb信息

     Tapestry 

    Tapestry是一个开源的基于servlet的应用程序框架,它使用组件对象模型来创建动态的,交互的web应用。一个组件就是任意一个带有jwcid属性的html标记。其中jwc的意思是Java Web Component。Tapestry使得java代码与html完全分离,利用这个框架开发大型应用变得轻而易举。并且开发的应用很容易维护和升级。Tapestry支持本地化,其错误报告也很详细。Tapestry主要利用javabean和xml技术进行开发。【Spindle :Tapestry辅助开发Eclipse插件】.

    更多Tapestry信息

     Cocoon 

    Stefano Mazzocchi于1999年1月创建了Cocoon项目,将其作为ASF之下的开放源代码项目。Cocoon的目标是帮助分离内容格式、逻辑和对基于XML网站的管理功能。Cocoon使用XML, Extensible Stylesheet Language Transformations (XSLT), 以及 Simple API for XML (SAX) 技术,以帮助创建、部署和维护XML服务器应用程序。它支持大多数类型的数据源,包括RDBMS、LDAP和文件系统。在Eclipseh下进行开发的插件

    更多Cocoon信息

     Echo 

    Echo是为用Java开发Web应用程序提供的一个面向对象,事件驱动的框架。使用Echo 框架来编程类似于使用Swing API来开发应用程序或applets 。

    更多Echo信息

     Turbine 

    Turbine是基于Servlet的框架包,也是开放源代码Jakarta项目。目前还没有关于Turbine的大量文档。它类似于Struts,但是有一些主要区别。突出的一点就是它并没有与JSP耦合。Turbine的特点是它提供了大量可重用的组件。此框架包中包含了大量组件,但是这些组件是离散的。它似乎应该给出更多的组件库,但是由于它缺少文档,所以很难掌握完整的体系结构。

    更多Turbine信息

     MyFaces 

    MyFaces是JavaServer(tm) Faces(JSF) Web框架 (JSR 127)的一个实现。JavaServer(tm) Faces Web框架是一个新的实现MVC模式的规范.它可以与Struts框架相媲美甚至的一些特性与观念已经超过了Struts.【FacesIDE :Eclipse下的一个辅助开发插件】.

    更多MyFaces信息

     JPublish 

    JPublish是一个功能强大的Web发布系统,设计为确保开发者角色的清晰的分离。JPublish 支持多模板引擎,包括Jakarta Apache's Velocity, FreeMarker and WebMacro。JPublish支持众多脚本语言,包括Python, BeanShell, and JavaScript。

    更多JPublish信息

     Japple 

    Japple是一个建造Web应用程序和服务的快速应用程序开发环境。Japple在Java2平台和开放标准之上建造,和传统方法相比可以让你更快、更容易、更有效地开发和部署Web应用程序。

    更多Japple信息

     Jaffa 

    是为快速应用程序开发提供的一个企业Java框架。JAFFA 是一个Java Web应用程序开发框架,用基于MVC为基础的Web窗口部件来扩展现存的项目。

    更多Jaffa信息

     Anvil 

    Anvil是一个基于Java的为Web程序开发的平台,独立或伺服式都是可部署的。它包括大量功能齐全的面向对象的编程语言。语言的一个子集也可用于一个以tag为基础的模板语言。所有的脚本和模板都被汇编为Java比特代码。

    更多Anvil信息

     SiteMesh 

    SiteMesh 是一个网页布局和修饰的框架,利用它可以将网页的内容和页面结构分离,以达到页面结构共享的目的。Sitemesh是由一个基于Web页面布局、装饰以及与现存Web应用整合的框架。它能帮助我们在由大量页面构成的项目中创建一致的页面布局和外观,如一致的导航条,一致的banner,一致的版权,等等。
    它不仅仅能处理动态的内容,如jsp,php,asp等产生的内容,它也能处理静态的内容,如htm的内容,使得它的内容也符合你的页面结构的要求。甚至于它能将HTML文件象include那样将该文件作为一个面板的形式嵌入到别的文件中去。
    index_example-diagram.jpg

    更多SiteMesh信息

     Barracuda 

    Barracuda是一个HTML DOM Component + Event/Listener结构的框架。根据模板文件或配置文件生成静态Java类,并在代码中使用这些生成类,Barracuda需要用XMLC项目把所有的HTML或WML模板文件,静态编译成DOM结构的Java类,作为页面组件。XMLC会根据HTML元素的id定义,生成相应DOM结点的简便操作方法。Barracuda的事件类也需要用Barracuda Event Builder工具把event.xml编译成Java类,引入到工程中。Barracuda直接用Java类的继承关系映射事件之间的父子层次关系。比如,ChildEvent是ParentEvent的子类。Barracuda的事件分为两类:Request Events(Control Events)和Response Events(View Events)。Barracuda事件处理过程类似于Windows系统消息队列的处理机制。

    更多Barracuda信息

     Maverick 

    Maverick是一个轻量而完备的MVC Model 2框架。Maverick的Action称作Controller。Controller只接受一个ControllerContext参数。request,response, servlet config, servelt context等输入信息都包装在ControllerContext里面,而且Model也通过ControllerContext的model属性返回。整个编程结构清晰。但由于ControllerContext只有一个model属性可以传递数据,程序员必须把所有需要的数据都打包在一个对象里面设置到model属性里。这种麻烦自然而然会导致这样的可能用法,直接把Controller本身设置为model,这又回到了Controller(Action)和Model一体。

    更多Maverick信息

     Spring MVC 

    Spring MVC是结构最清晰的MVC Model 2实现。它的Action也不叫Action,而是称做Controller;Controller接收request, response参数,然后返回ModelAndView(其中的Model不是Object类型,而是Map类型)。但在其它的Web Framework中,Action返回值一般都只是一个View Name;Model则需要通过其它的途径(如request.attribute,Context参数,或Action本身的属性数据)传递上去。

    更多Spring MVC信息

     Shocks 

    Shocks 是一个开放源码的开发框架,目的是减少 Java Servlet 应用的复杂性。Shocks 并不是 MVC 模式的开发框架,而是采用下一代的体系结构,明确分开了内部各个组件的角色。该项目目前还不够成熟,但值得关注。这里只是简单介绍,如果你要快速了解 Shocks,请阅读 Shocks 的 FAQ,里面讲解了 Shocks 与 Struts,Webwork,Spring 的关系和差异。

    更多Shocks信息

     WebCream 

    WebCream提供基于Java应用程序和Applet的web GUI,允许开发人员利用AWT和Swing实现GUI前端应用程序,同时自动地使HTML访问该应用程序。

    更多WebCream信息

     AppFuse 

    AppFuse是一个集成了众多当前最流行开源框架与工具(包括Hibernate、ibatis、Struts、Spring、DBUnit、Ant、Log4J、Struts Menu、Xdoclet、SiteMesh、OSCache、JUnit、JSTL)于一身的Web开发框架。AppFuse提供了Web系统开发过程中都需要开发的一些功能,如登陆、用户密码加密,用户管理、根据不同的用户可以展现不同的菜单.J2EE开发者也可以在此基础上开发加入自己的功能模块。利用这个框架可以大幅度的提高开发速度。

    更多AppFuse信息

     VRaptor2 

    VRaptor2是一个MVC与IOC的Web框架.它采用了许多框的思想包括:JBoss Seam,Stripes,Webwork,Hibernate Annotations等。VRaptor2充分利用Java5注释使得可以通过简单的方式来处理Web编程。你的商业逻辑类不需要与javax.servlet API联系,并且与其它框架相比它只需要很少配置。

    更多VRaptor2信息

     Chrysalis 

    Chrysalis是一个Java Web开发框架.它有一个不同于大多数MVC Web框架的地方.Chrysalis的控制器类跟正常的Java类一样有着多个方法,客户端请求的URLs被映射到这些控制器方法.

    更多Chrysalis信息

     Verge 

    Verge框架是一个开源J2EE应用程序框架完全采用Java开发只使用到标准的J2EE APIs.这个开源项目的目的为开发企业应用程序提供一个非常灵活和可扩展的框架.

    更多Verge信息

     WebOnSwing 

    WebOnSwing是一个革命性的多环境应用程序框架.它允许你创建web 应用程序并可用同样的方式开发一个桌面程序.它不需要使用Jsp文件,特殊的标签,XML文件, requests, posts等,所有的都是Java与直接来自图形设计的HTML文件.这个框架使用Swing组件来构造和处理HTML页面,并允许使用MVC设计模式.所有在Web上的工具都可以由Swing 提供.

    更多WebOnSwing信息

     RIFE 

    RIFE为开发和设计Web应用程序提供了另外一种途径。它基于Java平台构建,但它提供了所有需要的工具和AIPs用统一的风格,快速地实现所有web程序各开发角色之间的任务联系。RIFE被设计成在整个开发周期中完全分离了开发角色之间的任务,每个developer,dba和designer只需关注它们自己的任务,整个开发工作随时都可以很容易的与其它团队的工作相结合,使得这样子开发出来的将是一个松耦合的健壮的系统。RIFE由许多标准的组件组成,它们包括:
    *Web程序引擎 
    *结合Web扩展 
    *多格式模板引擎选择(html, xml, sql, java, txt, ...)
    *支持内容导出(比如导出为XSLT格式)
    *验证框架
    *数据库查询构建器
    *简单的持久层
    *JDBC优化与连接池
    *可配置框架等。
     用它可以轻松的解决Http's无状态连接问题与CGI的接口。这个框架已经成功的应用在许多网站上如:Bla-bla List ,Netwerk ,Caosity ,Dag Allemaal ,GreenEnergy 等。

    更多RIFE信息

     Wicket 

    Wicket是一个基于Java 的Web开发框架,与Struts,WebWork,Tapestry 相类似。其特点在于对Html和代码进行了有效的分离(有利于程序员和美工的合作),基于规则的配置(减少了XML 等配置文件的使用),学习曲线较低(开发方式与C/S相似),更加易于调试(错误类型比较少,而且容易定位。一个结合Eclipse工具的Demo 可以引导你如何利用Wicket来发开Web应用程序。

    更多Wicket信息

     Beehive 

    Beehive用于简化Java 2 Platform, Enterprise Edition(J2EE)以及Web服务编程。 
    Apache Beehive支持以下功能: 
    *Java Page Flow(JPF)技术,也称为(NetUI) 
    *轻量级的组件框架
    *基于Java Specification Request(JSR)181的Web 服务

    更多Beehive信息

     JSPWidget 

    JSPWidget是一个Jsp框架,它提供了事件驱动,视图状态保留(view state retained),服务端GUI控制来使得JSP开发能够像在传统的窗体客户端与基于客户端的web应用程序中一样直观.

    更多JSPWidget信息

     JNex 

    JNex是实现MVC设计模式的纯Java框架.它可以使用三种视图(view):Swing,HTML,和Canoo ULC.

    更多JNex信息

     WFNM 

    WebFlow Navigation Manager (WFNM)是一个轻量级的Web框架.它允许WebFlow定义,服务端历史向导(navigation history),自动动Session清除.WFNM框架把web应用程序分离几个WebFlow,服务端保持访问过的页面和WebFlow的历史记录,可以动态地返回到访问过的页面与WebFlow.

    更多WFNM信息

     OPS 

    OPS(Orbeon PresentationServer)是一个开源的基于J2EE平台且是以XML为中心的Web框架.OPS是围绕XHTML, XForms,XSLT,XML pipelines,与Web Services进行构建的.可以利用OPS来开发检索,处理,表达XML数据的应用程序.不像其它流行Web框架如Struts或WebWork,它们都是基于Java对象与JSP的,OPS是基于XML文档与XML技术.这种结构将为处理,表达,检索以XML为格式的信息提供一个更好的方案,并且几乎是在实现你表达层的时候不需要写任何Java代码.

    更多OPS信息

     

     Aurora 

    Aurora是一个开源的,可配置的,完全面向对象的MVC框架。Aurora的form控制器用的是Spring框架.

    更多Aurora信息

     Pustefix 

    Pustefix是一个web应用程序框架.它包含一个基于XML/XSLT的视图生成系统与一个清晰MVC模式的后端系统.前台UI可以利用XSLT模板构建并可包含部分的HTML或XML代码.

    更多Pustefix信息

     Mentawai 

    Mentawai是一个MVC Web框架用来简化Web应用程序的开发.它的主要特点是小(它只解决了web开发过程中碰到的最基本问题),简单(它的所有配置都是用纯Java代码实现,没有绑定额外的XML文件),灵活(整个框架容易按自己的需要进行扩展).

    更多Mentawai信息

     Click 

    Click一个高性能的J2EE Web应用程序框架适用商业Java开发者。它具有:
     ◆ 简单易学,
     ◆ 面向页面与组件设计,
     ◆ 基于事件编程模型,
     ◆ 自动表单验证,
     ◆ 使用Velocity模板作为页面视图,
     ◆ 漂亮的错误报告功能,
     ◆ 使用Rico (一个开源的JavaScript库,它提供对AJAX完全支持并可让Web应用程序支持拖放操作等其它功能)来对AJAX的支持等。

    更多Click信息

     jZonic 

    jZonic是一个Web应用程序框架.它由许多部分组成:
    ◆ 工作流引擎,
    ◆ 用户管理,
    ◆ 访问控制与综合权限管理,
    ◆ 一个配置框架(jConfig),
    ◆ 支持JSP,XML,XSL,velocity,freemarker等,
    ◆ i18n支持,
    ◆ 用户剖析(profiling),
    ◆ jcron(指定在某一个时间运行Jobs)等.
    jzForum 论坛就采用这个框架开发。

    更多jZonic信息

     Swingweb 

    Swingweb是一个web框架,它能够在一个Web容器中操作AWT/Swing应用程序并把它作为一个纯HTML/CSS/javascript的Web应用程序呈现给浏览器.

    更多Swingweb信息

     Calyxo 

    Calyxo一个基于MVC模式的Web框架.它为开发真正模块化的应用程序提供支持.它还包括支持i18n,一个灵活视图管理器和一个强大验证引擎等.Calyxo被分成五个组件分别为:1.Calyxo Base,2.Calyxo Control,3.Calyxo Panels,4.Calyxo Forms,5.Calyxo Struts(这个组件的目的是让Calyxo的其它组件可结合到Struts框架中,比如Calyxo Panels与Calyxo Forms可被用来替代Struts Tiles与Struts Validator在Struts中的使用).

    更多Calyxo信息

     jWic 

    jWic是一个Java框架用于开发基于事件的Web应用程序.它能够让你的应用程序脱离与URLs和页面流(page flows)的联系.

    更多jWic信息

     JVC 

    JVC(Java View Control) Java(视图-控制)开发框架的目的是构建一个快速开发、可维护的、稳定的web开发框架,并开放源代码,互相促进开发技术。 目前比较流行的web开发框架有WebWork、Struts、Spring,这几个都是非常好的开发框架,都能实现MVC模式.参考上述几个框架的思想,开发简化了的视图-控制框架,弱化了模型层,为什么要弱化模型层,这是因为往往在模型中大部分是重复的工作。 项目主要的特点是 
     1.开发简单快速:大部分开发不需要写javabean,系统自带的Action能满足90%需求,只需要编写page文件(控制文件)与视图jsp。 
     2.提供了Web系统开发过程中都需要开发的通用用户权限管理:可以控制角色对每个Command的访问权 
     3.提供功能强大的验证框架:使用表达式编写验证公式,支持所有逻辑表达式,并且前台jsp(生成javascript脚本)和后台Servlet(提交到后台的request参数)均可以调用。 
     4.可维护性:一般修改了数据库表需要同时修改M、V,需要重新编译,虽然简单,但带来了繁琐的操作,而且有可能引起其他错误,而jvc框架弱化了M,不需要编写对象关系映射的类,而是用命名规范使得对于大部分的修改只是需要修改V(jsp页面)。 
     5.自定义Action可独立调试,一般Action由于需要从requset得到参数而无法进行独立调试,而jvc框架借鉴了WebWork方法把HTTP请求的封装为ActionContent类,除了交互和使用上的方便外,实现了往往开发web比较困难的独立调试。并且为下一步升级到Web+EJB或其他分布式架构做好准备。

    更多JVC信息

     Java Server Faces(JSF) 

    JavaServer(TM) Faces技术简化了JavaServer应用程序用户界面的开发.各种技术水平的开发者都能够快速创建web应用程序通过在一个页面中装配一些可重复使用UI组件;并可把这些组件与应用程序的数据源连接起来;也可把客户端产生的事件与服务端事件处理者连接起来.这个项目是Sun对JSF技术规范的最完整实现.

    更多Java Server Faces(JSF)信息

     XMoon 

    XMoon扩展自Jakarta Struts框架用于开发处理基于XML或一些脚本语言(如: BeanShell, JRuby, JudoScript, Jython,Rhino)的Web应用程序.它还提供一个用于展示该框架宠物店Demo.

    更多XMoon信息

     Stripes 

    Stripes是一个视图框架用于利用最新的Java技术来构建Web应用程序.它具有以下特点:不需要对每一page/action进行映射配置(ActionBeans将自动被发现,它利用注释进行配置),强大的绑定引擎用于构建复杂并脱离请求参数(request parameter)的web对象,易于使用并可本地化的验证与类型转换系统.可重复使用ActionBean作为视图帮助类.支持一个form对应多个事件.透明的文件上传能力.支持持续开发(比如在构思你的ActionBean之前可以先构建与测试JSP)等.

    更多Stripes信息

     RIFE/Crud 

    RIFE/Crud是RIFE Web框架的一个扩展模块,它可以用给定的POJOs自动生成CRUD web应用程序。它没有生成任何文件所有的事件都是在运行期进行.利用RIFE提供的 site-structure可以把它与你应用程序的数据流与逻辑流相结合.

    更多RIFE/Crud信息

     Simple Web Framework 

    Simple Web Framework (SWF)是一个基于事件的web框架.它很适合于那些想要开发胖客户端Web应用程序但又不想转向JSF的Struts开发人员。SWF跟Struts一样也是构建在Jakarta commons基础之上,但使用一个不同的request processor。SWF事件模型支持基于XmlHttpRequest的事件提交。

    更多Simple Web Framework信息

     wingS 

    wingS是一个基于Java Servlets的Web框架,它采用类似于Swing API的MVC模式和面向事件驱动的设计原理。它利用到Swing的模型(models),事件(events),和事件监听。像在Swing中,组件被排列在一个具有分层次的容器中,而其中的root容器被挂在frame中。wingS也支持AJAX。

    更多wingS信息

     JBlooming 

    JBlooming是一个Java Web开发框架,这个框架尽可能得使用Java API和面向对象的思想来设计接口,所以没有使用标签。而是使用面向对象的Jsp模板技术。JBlooming主要的特点包括:灵活和强大:这个框架能够让你在任何情况下都可以使用java/jsp/html/js (包括AJAX)技术。 一组成熟,漂亮的html组件并且可以很方便地切换到其它皮肤。提供自身校验功能。不需要使用XML,所有的配置都放在JSP中。这个框架还易于使用,而且确实能够提高我们的开发效率和程序的可维护性。

    更多JBlooming信息

     GenAndRun 

    GenAndRun(Generate And Run)是一个表格驱动开发工具,它与Ruby on Rails(RoR)框架相类似。GenAndRun项目的主要目标是让Java Web开发简单化,利用这个框架来开发让我们只需关注应用程序的商业逻辑和界面,让GenAndRun生成大部份项目所需要的ORM与controller代码。GenAndRun当前使用Spring作为IOC引擎,IBatis作为ORM引擎,JSP/JSTL作为view。在将来新的版本中将会新增对现存其它技术的支持。

    更多GenAndRun信息

     Sails 

    Sails是一个动态,开源的Web框架,采用测试驱动进行设计。它的配置,urls到Actions的映射与处理后转向的页面都是采用约定俗成的方式。Sails包括:
     反转控制器Rigging ,
     模板语言Viento ,
     框架的核心Sails ,
     Eclipse平台上的开发插件Shipyard ,
     范例程序Dock

    更多Sails信息

     Frame2 

    Frame2是一个可以代替Struts来开发Web应用程序的框架。它也支持web services在一个MVC上下文(context)中。Frame2还提供一个在Eclipse上进行开发的插件。

    更多Frame2信息

     Helma 

    Helma是一个用来开发快速,稳定Web应用程序的开源框架。它使用JavaScript 来作为服务端脚本环境,从而可以除去编译周期。Helma是应用程序对象到数据库表格映射零代码化与简单化的先驱,此外一个内嵌的面向对象数据库可以完成未映射对象数据的自动持久化。Helma已被成功运用于许多大流量网站的开发如:antville.org,twoday.net,和blogger.de等网站。

    更多Helma信息

     Brill Framework 

    这是一个让你只需用Java与XHTML技术就能够开发交互式Web站点的开源框架。它目的就是开发出一个简单,支持WYSIWYG页面编辑而不需要编写Java代码或在JSP页中使用特殊标签的框架。开发基于Java的Web应用程序通常是使用MVC设计模式和JSP技术,而Brill Framework虽然也使用MVC设计模式但在页面技术上它使用XHTML来代替JSP。XHTML的使用能够提高开发Web应用程序的效率与质量,从而减少了成本。

    更多Brill Framework信息

     XX Framework 

    XX Framework是一个可配置,以XML为核心实现MVC开发模式的Web框架。这个框架能够让HTML表单直接映射到数据库字段来显示或更新数据而不需要编写额外的代码。它用XML文件进行配置并用XSL来显示。一些开源的工具也被运用到其中比如Hibernate和Castor。XX Framework的优势在于:
     1.使用非常简单。
     2.围绕一些Web标准(包括:J2EE, XHTML,XML,XSL,CSS)进行构建。
     3.内置用于优化性能可配置的数据缓存和线程池功能。
     4.与Web服务/本地Java class相结合。
     5.使用一个基于"Portal"的方式来进行页面设置,以易于功能的划分。

    更多XX Framework信息

     Equinox 

    Equinox是AppFuse的一个轻量级版本。Equinox使用Spring MVC与Hibernate作为默认实现(数据库为:PostgreSQL)。但是你可以把Web框架改成JSF, Struts,Tapestry或WebWork。也可以把持久层框改成iBATIS,JDO(JPOX),Spring JDBC或OJB()。同时支持Ant和Maven2进行构建与测试。AppFuse与Equinox的不同之处在于AppFuse有以下特性:
     1.使用Acegi Security进行授权和认证;
     2.用户管理;
     3.为基于增删改查(CRUD)的应用程序自动生成代码;
     4.文件上传;
    Demo:
  • Spring   ·  Spring w/ Ajax
  • JSF
  • Struts
  • Tapestry
  • WebWork
  • 更多Equinox信息

     Facelets 

    Facelets是一种表现层/视图技术,它使用Tapestry用户所熟悉的概念来构建JSF组件树。

    更多Facelets信息

     Millstone 

    Millstone是一个Web用户界面组件包。用户界面完全采用面向对象服务端编程方式实现。利用这个包你就可以开发出高质量基于Web的UI而不需要关心XHTML,CSS,JavaScript,浏览器兼容等问题。可通其提供的一个在线Demo 来了解各个UI组件的特性。Millstone还提供一个可在Eclipse平台上创建和运行Millstone项目的插件

    更多Millstone信息

     SOFIA 

    SOFIA是为J2EE提供的一个快速应用程序开发工具。它集成了各种优秀的Java框架来为开发高质量的数据库驱动的Web应用程序提供一个解决方案。

    更多SOFIA信息

     SpringSide 

    SpringSide--Pragmatic Enterprise Application KickStart and Common Library Stack,这么长的一个名字下来,不用解释大家都知道是做什么的了----以Spring Framework为core,提供一个Pragmatic的企业应用开发基础和最佳实践展示。 
    1.项目架构:
    主要包含4部分,从脚往上扫是:
     1).Common Library栈。提供一个经测试的、版本般配的Library及配置文件的组合。
     2).Spring大叔一时没管到的少量必要的基类、utils类和glue code。
     3).以一个Amazon式的网上书店,演示企业应用中各个主题的Best Pratice,各种框架类库组合的Config file&Sample code。
     4).开发指南文档。
        此部重要性不亚于上面三部,涉及企业应用开发的方方面面,将以独立版本号单独发行。

    2.Featrue List
        mvc、orm、web service、jms、定时任务、全文索引、report & BI report、规则引擎、动态语言、安全权限管理、ajax、cache、logging、i18n....

    更多SpringSide信息

     Groovy on Rails (Grails) 

    Grails是一套用于快速开发Web应用系统的框架,基于Groovy动态语言。并构建在开源技术如:Spring,Hibernate和SiteMesh之上。它提供一个类似于Rails的平台可以无缝与Java平台相集成使得开发者能利用当前在Java和JDK方面的投入。Grails提供一个完整的开发平台包括内置Jetty web服务器并提供了一些强大的功能比如简单的对象关系映射(ORM),自动重新加载应用程序,为CRUD(新增,查询,修改,删除)操作提供代码自动生成支架(scaffolding)。此外Grails还提供了一些在Java中惯用的语法包括:运用AOP思想的拦截器,动态标签库,JSP和GSP(Groovy Servers Pages)支持。

    更多Groovy on Rails (Grails)信息

     Waffle 

    Waffle是一个类似于Rails的Web框架支持基于POJO的Actions,依赖注入,并且它没有依赖任何XML配置文件。采用waffle开发应用程序将比其它Web框架更加简单,而且易于测试。利用Waffle框架来开发Web应用程序只需要知道三件事情: 
     *.Actions - 在Waffle框架中的action不需要继承或实现任何特定的类或接口。因为一个action就是一个(Pojo)。
     *.Events - 在Waffle框架中一个事件对应Action类中的一个方法。使用任何方法可以不管它的标记(signature)或返回类型。Waffle将会根据事件的返回作出不同的响应。
     *.Registrar - Registrar是你要注册Actions与其它公共组件的地方而当前大多数web框架需要你的应用程序创建特定的XML文件来做这些事件。使用Waffle可以让你把更多的时间发在开发程序逻辑上。
    还可以很方便地扩展Waffle来添加对AJAX的支持。

    更多Waffle信息

     Tasian 

    使用Tasian框架可以使得J2EE的开发人员可以开发出类似桌面应用具有丰富UI的B/S应用程序,具有高性能、友好、快捷的特点。该框架2.0版本之前主要是面向企业级应用程序的开发,而非网站应用,该框架将会在3.0版融入Web开放接口,以满足网站应用的开发,当然这并不是说Tasian当然的版本不能开发出类似的网站应用,实际上通过Tasian当前的API仍然能做出类似网站的应用。同时,Tasian也将慢慢向J2ee等主流开放框架靠近,使得用户在使用时不必担心其以后的扩展性。 Tasian框架提供给开发人员一个面向对象的、事件驱动的Web应用开发的体系架构,它使得开发人员不需要考虑以页面为中心的应用程序,他们只需象开发C/S应用程序一样关心组件及应用逻辑,而不必关心HTML、HTTP以JavaScript等网络技术,所有的这些都在框架内部为开发人员实现了。Tasian目前也提供了一个非常简单的IDE开发环境,是一个Eclipse插件,也是属于开源代码,在一定程度上提高了开发效率。 Tasian框架是一个轻量级的框架,在设计之初就考虑到Tasian将会运用于网站,将会有大量的用户访问,所以,它不会占用服务器资源,完全是客户端状态保存机制,而没有采用Session机制。

    更多Tasian信息

     

     Aranea 

    Aranea是一个开源,面向组件,事件驱动的Java MVC Web框架。它提供一种通用简单的方式来构建Web应用程序组件,复用自义定或一般的GUI逻辑,扩展该框架。Aranea强调必须使用POJOs面向对象的技术,并且提供一个Jsp标签库来帮助开发web GUI界面。

    更多Aranea信息

     2step 

    2step是一个用于开发完整Web应用程序(包括web服务)的框架。作为一个Servlet框架,它的特性有:访问控制、logging、I18N、数据库访问,XML/XSL支持等,还用到Jetty,FOP和jCharts开源项目。该框架提供一个用于辅助开发的Eclipse插件。

    更多2step信息

     Rhino in Spring 

    Rhino in Spring这个项目把Rhino JavaScript解释器与Spring框架相结合。目的是提供一个把脚本(动态)语言快速开发的优点、灵活与Java平台和Spring框架的强大功能、高扩展性相结合的系统。这个项目发布了一个Spring MVC控制器(controller)组件用于把由Web应用程序多个web页面生成的复杂控制流用JavaScript表示成单一结构的工作流。

    更多Rhino in Spring信息

     Pushlets 

    Pushlets是一个基于HTTP的发布/订阅框架,它实现了一种能够直接从服务端Java对象主动发送数据给浏览器端的HTML页面而不需要使用Java applets或插件的机制。这个框架当前使用两种方式实现:1.在servlet或jsp中将Javascript代码以流的形式传递给一个隐藏的frame。2.采用AJAX实现。

    更多Pushlets信息

     jsf-comp 

    jsf-comp一组JSF组件:
    Chart Creator 用于在JSF页面中操作JFreeChart
    Client Validators 用于JSF客户端校验
    Acegi-JSF JSF版的acegi标签
    Excel Creator 用于导出数据到excel中
    OnLoad 通过页面访问代替form提交来运行JSF Action

    更多jsf-comp信息

     jbullet 

    jbullet一个基于约定俗成没有XML的Java开源web框架,保持简单是它的原则,Struts是它的灵感,RubyOnRails是它的挑战。jbullet之所以简单是因为你所要做得只是编写简单的Java classe然后把剩下的交给该框架。约定俗成是驱动因素,JSP标签库是标准HTML标签的一个镜像,控制流非常流畅和明了。

    更多jbullet信息

     ROMA 

    ROMA是一个完全基于POJO的Web框架。整个框架采用Ruby On Rails的设计思想,利用该框架能够实现Ajax数据库Web Apps的快速开发。

    更多ROMA信息

     Shale 

    Shale是一个基于JSF的web开发框架。Shale重用了大量的Struts基础代码,因此可以称Struts为它的"父"框架,但Shale是面向服务架构,它与Struts最大不同之处在于:Struts与JSF集成,而Shale则是建立在JSF之上。 Struts实质上是一个巨大的、复杂的请求处理器;而Shale则是一组可以以任何方式进行组合的服务。此外Shale加入了一些新的特性比如:
    1.与Spring框架相集成可以使用Spring的依赖注入机制来创建JSF Managed bean。
    2.提供一种可选的类似于Tapestry与Facelets使用纯HTML来定义视图。
    3.提供测试框架,一组mock object和JUnit test case基类可以帮助测试自身框架的classe和在构建在该框架之上的应用组件。
    4.提供AJAX的服务端支持。
    5.Tiger扩展等。

    更多Shale信息

     Wicket Stuff 

    这是一个把第三方组件集成到Wicket Web组件框架中的开源项目。这个项目当前提供的组件包括:
  • Dojo Toolkit   AJAX components integration
  • Hibernate(2.1 and 3) components
  • fValidate integration
  • Groovy integration components
  • Velocity Panel
  • Freemarker   integration
  • JasperReports   integration
  • TinyMCE   WYSIWYG JavaScript editor integration
  • Yahoo UI components   integration
  • 更多Wicket Stuff信息

     Wedge 

    Wedge是一个基于POJO面向组件的Web框架。它利用运行期代码生成和习惯命名来简化Web应用的开发。Wedge页面模板是包含一些关键字的简单xhtml文档与页面相对应的后台类是没有层次之分POJO。在运行期,wedge会生成并编译一个第三方class,这个class与页面模板和页面后台类相绑定。这个自动生成的class是在一个单独的class loader中加载,所以当页面模板或页面后台类变化时将被丢弃。Wedge在运行期能够重新加载模板和页面类的java源代码,这意味着你可以随意你页面类的java源代码(新增,修改,删除或重命名方法和属性),然后只要刷新浏览器就可以看到修改后的结果。

    更多Wedge信息

     OpenBlueLab 

    OpenBlueLab是一个用于构建Web2.0 Portal系统的快速开发框架。其主页就是采用该框架开发的一个Demo。Portal布局可以通过UI进行配置。Widget将自动组装,在运行期不需要编写任何数据库交互代码就能够使它们自动实现数据感知。基于Ajax与HTML的form也将从XML widget定义自动构建。XML widget定义可以从描述信息系统设计的UML模型快速生成。这个框架让你只需关注信息系统的设计,而form和portal的系统架构将自动生成。

    更多OpenBlueLab信息

     ztemplates 

     ztemplates这是一个基于Java1.5的Web框架并使用反射,注释和泛型来确保你可以基于POJO进行开发。这意味着你不需要实现任何接口或继承特殊的class。它的特点包括:
    1.不需要XML配置文件,除了web.xml。
    2.Type safety:在需要的地方使用泛型(generics)。
    3.Url safety:Url用Java编码创建而不是在模板中,所以你不可能创建坏掉的链接。
    4.灵活性:支持不同的表现层引擎如:velocity,jsp等。
    5.支持i18n,form校验(利用Ajax和http),数据绑定。
    6.提供安全机制,模板引擎。
    7.此外ztemplates还实现了一些可扩展的Web UI组件如tree和tabpane等。

    更多ztemplates信息

     qwicket 

    qwicket:采用wicket+spring+hibernate搭建一个Web应用基础框架。类似于appfuse

    更多qwicket信息

     Apusic OperaMasks  

    Apusic OperaMasks包括一个提供原生Ajax支持的JSF引擎,以及在此引擎上开发的富客户端组件(Rich Component)。Apusic OperaMasks在引擎级别提供对Ajax的良好支持,并提供一组功能丰富的UI组件,旨在降低Web开发的复杂度,真正使Web开发变得轻松起来。 Apusic OperaMasks提供以下的功能特性:
    • 标准兼容的JSF引擎
    不依赖于应用服务器,在Servlet 2.5兼容的容器中均能运行。
    • 容器级别Ajax支持
    在引擎级别对Ajax予以支持,实现了对Ajax的无缝集成。
    • Annotation形式的ManagedBean声明
      无须维护faces-config.xml文件,在POJO类上声明 @ManagedBean 即可定义一个ManagedBean,使得开发更加快捷。
    • 统一的资源和皮肤管理
      依赖于特有的资源管理机制,Apusic OperaMasks的皮肤管理独立于应用之外,灵活并具备非常好的扩展能力。
    • 丰富的UI组件
      提供一组功能丰富的UI组件(Rich Components),包括BorderLayout,Menu,Tree,DataGrid,DataView,ComboBox,DateFiled,CaculatorField等。

    更多Apusic OperaMasks 信息

     jxyz 

    pojo的mvc框架,使用java注解,使用ognl传输上下文,使用hivemind做ioc容器,使用spring简化hibernate操作,使用泛型来减少重复代码。 有以下几个特点。 
    1.Pojo。任何一个java类都可以做Action(logic),为了改造现在常用的ssh,tsh,wsh框架成sh,支持spring bean做Action(logic) 
    2.0配置,根据命名规范来查找Action类和view 
    3.和web环境松耦合,从理论上讲可以用在swing里 
    4.支持tdd开发,框架本身就是以tdd开发方式开发 
    5.代码少,一般mvc需要5个类,xyz只要3个,还可以通过GenericDAO,GenericLogic来减少重复代码
    6.对开发者来说,一切实现都可以自己定制,由于hivemind支持迭代开

    更多jxyz信息

     Strecks 

    针对Java 5.0开发人员设计,扩展自Struts的一个Web框架。它的特点包括:POJO action,注释式校验,数据绑定和转换,依赖注入,拦截器等。

    更多Strecks信息

     Ruby on Spring 

    Ruby on Spring是一个采用Ruby on Rails的思想与优点,集成JRuby动态语言与Spring框架而开发的开源项目。基于MIT license发布。

    更多Ruby on Spring信息

     Open-jACOB 

    Open-jACOB是一个Web框架用于开发基于AJAX,数据库驱动,跨浏览器的Web应用程序。该框架设计成一个基于Eclipse的插件,可以利用该插件设计数据库,设计UI,部署/测试应用程序等。具体用法可查看其提供的一个Flash Demo

    更多Open-jACOB信息

     SpringXT 

    SpringXT是Spring框架的一个扩展用于开发richer domain models与richer user interfaces的应用程序。采用Domain Driven Design设计原则。为此SpringXT提供两个框架SpringXT Modeling Framework:提供一些组件来开发rich domain model(它集中了所有业务逻辑,规则和约束,完全独立于应用程序的其它部分)并能够让它们与其它应用软件分层"优雅"结合。SpringXT Ajax Framework:一个完全与Spring MVC集成在一起,基于事件的Ajax框架。

    更多SpringXT信息

     Frails  

    Frails是基于JSF上的一个开发效率和RoR可以向媲美的Java Web框架。 Frails的特性如下:
  • Frails 让开发者使用约定(习惯)和注解(annotations)来省略在 faces-config.xml 文件中 managed-bean 和 navigation-rule的配置.
  • Frails 提供一个更简单的方法来使用 Faces API.
  • Frails 重定向非 faces 请求为一个 faces 请求,这样可以避免因为URL输入的疏忽导致的异常.
  • Frails 提供一些预定义的 Managed Bean 基类让开发者扩展 .
  • Frails 可以让开发者在 Managed Bean 中使用注解(Annotation)来支持AOP功能 ,如 函数拦截(method interception).
  • Frails 提供 Managed Bean 属性的injection 和 outjection
  • Frails 中的Hibernate GenericDao 对象提供了基本的 CRUD 函数 和 其他一些有用(常用)的数据访问函数.
  • Frails 还提供了一些有用的注解(annotations)来简化JSF的开发.
  • Frails 完全支持 jsf 1.1 和 jsf 1.2 规范,并且可以自动的探测你使用的版本.
  • Frails 提供了对action Method 和 Listener 函数的增强,在这些函数中现在你可以传递参数了.
  • 更多Frails 信息

     jZeno 

    jZeno是一个用于开发web2.0应用程序的开源Java full-stack框架。类似于GWT,jZeno也能够把Java开发转换成Javascript/HTML/CSS。jZeno构建在Hibernate和Echo之上。

    更多jZeno信息

     Mantis 

    Mantis是一个基于Java的小型MVC Web框架,通过Mantis,您可以快速开发一个Web系统,它具有以下特点:
  • 封装数据库访问,事务处理,连接池集成,封装分页控制
  • 封装数据库缓存和刷新机
  • 基于URL反射的方法调用,避免复杂的XML配置;
  • 简化配置文件,只需要一个配置文件即可完成web应用的灵活配置
  • 完善的例外处理,超时处理
  • 内置Mail, JfreeChart, JspReport及丰富的工具类
  • 完善的认证授权机制和日志处理支持国际化
  • 内置自定义标签和丰富的js简话页面的开发
  • 内置丰富的js
  • 内置Ajax
  • 更多Mantis信息

     JWC 

    Java Web Components该项目当前开发了一些用于GWT应用程序的组件包括:GWT - Components(用于替换和增强GWT标准组件),GWT - TinyMCE (用于集成TinyMCE   DHTML在线编辑器),GWT - FCK Editor (用于集成FCK Editor   DHTML在线编辑器),GWT - Spring集成组件。

    更多JWC信息

     Apache MyFaces Trinidad 

    Apache MyFaces Trinidad是一个基于部分Oracle's ADF Faces构建的JSF1.2组件库。

    更多Apache MyFaces Trinidad信息

     WebGalileo Faces 

    WebGalileo Faces是一组加入Ajax技术的JSF组件。组件包括:容器(container),面板(panel),左右列表(dual list),菜单(menu),日期和时间组件,流程图组件(flow chart)。WebGalileo Faces已经内建支持多种IDE包括Sun Java Studio Creator,IBM Rational Application Developer,Oracle JDeveloper和Eclipse。

    更多WebGalileo Faces信息

     Hocate 

    Hocate web framework是一套给予java的快速高效、构建web应用程序的框架,在框架的设计过程中,框架设计构思来源于国内众多项目实践,研究了(struts、jsf、Myface等)著名成熟的框架并继承了他们的优点,但也回避了些许他们弱点,利用FreeMarker作为页面模版解析引擎,实现一个页面及代码完全分离的简化的MVC开发框架。旨在构建一个能实现高效Web应用系统快速开发的简易Web框架

    更多Hocate信息

     GWT Pleso Framework 

    GWT Pleso Framework是一个基于GWT的Web框架,主要用于开发AJAX数据库Web应用程序。它能够根据你的业务逻辑类自动生成用户界面。

    更多GWT Pleso Framework信息

     Apache Tiles 

    Apache Tiles是一个视图框架基于“Composite View”设计模式构建,它能够把页面分割成可复用的子页面。Apache Tiles原本是Apache Struts的一部分,但是现在它已脱离自成一个完整独立的框架。此外它还能够兼容JSR-168 portlet。Struts2已经有一个基于Tiles2.0.4(最新版本为2.0.5)的插件。在不久的将来Apache Tiles还将发布用于Apache Shale/MyFaces的插件。

    更多Apache Tiles信息

     krank 

    krank是一个Java CRUD和Validation框架。校验模块能够利用Java注释(annotations)、property文件、XML文件或数据库表实现服务器端校验、Ajax校验或只有JavaScript校验。当前该模块能够集成到JSF、Spring MVC和Spring Webflow框架中使用。CRUD框架(包括新增/修改/读取/删除/过滤/排序)支持基于JPA的DAO对象。虽然默认只支持JPA,但是利用该框架提供的接口能够很容易实现对其它框架的支持如:Hibernate、Batis等。

    更多krank信息

     LazyJ 

    LazyJ是一个快速Web应用程序开发框架。它包括:
    *.一个非常快的模板引擎,因为其缓存了预编译过的模板。
    *.一个响应(response)缓存引擎和数据缓存引擎。
    *.一个数据库连接池。
    *.采用基于数据库的缓存机制。
    *.易于从servlet或JSP上传文件。
    *.一个提醒框架(已经实现通过Email和Yahoo! Messenger进行提醒)。 
    *.Servlet执行时间限制。

    更多LazyJ信息

     

     Gwittir 

    Gwittir项目为开发基于GWT的应用程序提供一组代码生成器,基础框架,工具类和一个MVC框架。

    更多Gwittir信息

     jWebApp 

    jWebApp是一个基于Servlet的MVC框架。jWebApp是当前最易于学习与使用的web框架。支持URI映射,服务器端Ajax支持和服务器端REST(RESTful web services)支持。此外一个非常高效的request缓存算法能够让jWebApp具有较高的运行速度。

    更多jWebApp信息

     WaveMaker 

    WaveMaker是一个Web应用程序WYSIWYG构建工具。它能够创建基于Dojo Ajax widget,Spring与Hibernate的应用程序。

    更多WaveMaker信息

     IWebMvc 

    IWebMvc为开发基于Spring/Hibernate/dojo和DWR的Web应用程序提供一个基础框架。此外IWebMvc还支持Groovy,Spring Webflow2.0,Jasper Reports/Dynamic Jasper,多文件上传(包括一个特殊的控件)。提供Image Gallery控件,投票控件。

    更多IWebMvc信息

     SeamWebAppGen 

    SeamWebAppGen是一个Web应用程序生成器。它生成的应用程序基于JSF2.1,JBoss SEAM,RichFaces和EJB3等技术并能够部署在JBoss Application Server (4.x)上。

    更多SeamWebAppGen信息

     rapid-framework 

    一个类似ruby on rails的java web快速开发脚手架,本着不重复发明轮子的原则,框架只是将零散的struts(struts2)+spring+hibernate各个组件组装好在一起,并对struts及struts2进行改造,提供零配置编程,并内置一个强大的代码生成器及模板文件,可以生成java的hibernat model,dao,manager,struts+struts2 action类,可以生成jsp的增删改查及列表页面。 
    整个项目借鉴了ruby on rails,appfuse,springside

    框架特性:
    • 内置一个基于数据库的代码生成器rapid-generator,极易进行二次开发
    • struts1,struts2的零配置
    • spring集成及加强,自动搜索hibernate的entity annotation class
    • 集成动态构造sql的工具:rapid-xsqlbuilder
    • 集成javascript表单验证:rapid-validation
    • 集成extremeTable分页组件,并简单扩展显示pageNumber
    • 集成DBUnit及spring对数据库测试的支持
    • 内置的分页查询PageInfo接口
    • Java日期转换的特殊处理,与My97DatePicker集成
    • 内置最精简的ant构建脚本,简单修改即可使用
    • 公共类库友好的包名javacommon
    • 整个项目尽量做到最小集,无需删除任何资源,拿来即可使用.
    • 友好的MIT-Licence

    更多rapid-framework信息

     LazyJ 

    LazyJ是一个Java Web应用程序开发框架。包括:
  • 一个非常快的模板引擎,该引擎能够缓自动存编译过的模板。
  • 提供响应缓存和数据缓存引擎。
  • 封装常用的数据库操作功能,包括连接池。
  • 基于数据库的Session保存机制。
  • 提供便捷的文件上传功能。
  • 提供通知/提醒框架,已经实现利用email和Yahoo! Messenger来发送通知。
  • 提供一组与数据库绑定的HTML控件。
  • 更多LazyJ信息

     mesir 

    组合各种常用的开源框架,并尽量简化这些框架的用法。为开发Web应用程序提供基础的框架。帮助开发人员快速有效的建立Web应用项目。当前组合的开源框架包括:
  • JSF, Facelets
  • MyFaces Orchestra
  • Spring
  • Hibernate (Search, Validator)
  • Jboss Envers
  • CXF, JAX-WS
  • Joda Time (with Hibernate persistency support)
  • Selenium Tests
  • slf4j、logback
  • 更多mesir信息

     Suco 

    Suco是一个能够让GWT客户端实现代码简洁与模块化的框架。Suco主要关注两个方面:一.保持系统的模块化(使用IoC模式实现)。二.提供一个简单并且可扩展的publisher/subscriber(Event/Listener)机制。Suco IoC完全基于Google's Guice IoC框架的思想,拥有Container、Provider、Factory和Scope等概念。

    更多Suco信息

     PrimeFaces 

    PrimeFaces是一个用于提高JSF Web应用程序开发效率的开源类库。主要由三个模块组成:
  • UI Components:PrimeFaces UI模块提供了拥有Rich Web用户体验的各种JSF组件。PrimeFaces使用Yahoo UI库做为默认的客户端框架。PrimeFaces提供的JSF组件能够处理JavaScript Rendering和如何在服务器端与JSF集成。PrimeFaces UI组件包括:HtmlEditor、ImageCropper、Dialog、AutoComplete、Flash based Chart等。并支持通过Ajax更新页面。
  • Optimus模块提供简化JSF开发的解决方案。Optimus提供基于Google Guice IOC容器的注释来代替XML配置和一个XML-less Navigation Handler能够让你减少基于XML配置JSF Navigation的需要。此外Optimus还支持利用JPA实现数据持久化;将DataTable的内容导出成Excel与PDF。支持安全扩展。
  • FacesTrace模块提供跟踪JSF Web应用程序的各种工具包括:JSF LifeCycle可视化查看器;性能跟踪器; Log4J适配器;FacesMessage监听器;组件树可视化查看器。 

  • 更多PrimeFaces信息

     AribaWeb 

    AribaWeb是一个基于组件的Web应用快速开发框架,用于创建基于Ajax的web应用程序。AribaWeb集成了开发数据库应用所需的全部功能,提供丰富的Rich Widgets(forms、pivot、tables、charts、rich text editors等)并且与一个ORM数据库框相绑定。AribaWeb开发的Web应用支持部署在不同的J2EE运行环境中。
    AribaWeb

    更多AribaWeb信息

     Jspresso 

    Jspresso是一个full-stack Java RIA框架,用于开发N层分布式desktop-like应用程序。基于Jspresso开发的应用程序可以部署成Adobe's Flex、Ajax (WingS)、ULC与Swing,并且是不需要改动任何GUI代码。
    Jspresso.jpg

    更多Jspresso信息

     Joindesk 

    Joindesk是一个建立在Ext JS, Velocity and Spring基础上的J2EE Web应用框架。
    Joindesk能够加速使用Ext组件的J2EE Web应用开发。不用编写一句JavaScript就可以在Java代码中直接响应来自Ext组件的事件。你在处理AJAX请求时也不必关心JSON或XML数据格式。
    使用Joindesk框架开发Web应用UI交互,就像使用VB/VC开发桌面应用UI交互一样方便快捷。
    在Joindesk中,相关的表单定义(JS)、页面模板(HTML)和页面处理逻辑(class)可以打包在一个文件中发布,使web应用模块化开发部署更方便。 
    Joindesk.jpg

    更多Joindesk信息

     GWTruts 

    GWTruts是一个易于使用的GWT MVC和依赖注入框架。它将GWT module分割成view、controller和validation等部分类似于传统Web MVC框架如Apache Struts。GWTruts使用XML配置文件来配置视图,控制器和其它属性。此外GWTruts还提供一个依赖注入机制类似于Spring能够让你自由定制你的视图和控制器。GWTruts完全采用GWT开发,因此能够很好地与任意GWT插件/扩展结合使用。

    更多GWTruts信息

     Nutz 

    Nutz是一组轻巧的开源框架,内容涵盖了:
    1.数据持久化(Data Persistence) 
    2.反转控制(Ioc) 
    3.Web框架(MVC)
    Nutz所有的功能均不依赖第三方的jar包,上面三个部分可以独立使用。

    更多Nutz信息

     jQuery4jsf 

    JQuery4jsf是一个开源JSF组件库。这些组件基于jQuery 框架开发,当前可用的组件包括:
  • Accordion Panel
  • Datepicker
  • Dialog
  • Progressbar
  • Slider
  • Tabs
  • Draggable
  • Draggable
  • Resizable
  • Effect
  • Autocomplete
  • Carousel。
  • 更多jQuery4jsf信息

     vaadin 

    vaadin是一个用于创建胖客户端Web应用程序的Java框架。拥有基于GWT实现的各种控件,所有代码全部采用纯Java实现,不需要编写任何JavaScript代码,没有复杂的配置,快速,易于扩展和维护。
    vaadin.jpg

    更多vaadin信息

     etmvc 

    etmvc是基于Java技术,为WEB开发提供的一套简易MVC框架。简易但不简单,其设计和实现借鉴业界众多的优秀框架,如struts,spring mvc,ror,grails等,力图为Java开发人员提供一套高效的开发框架。
  • 基于java技术开发,继承其强大、稳定、安全、高效、跨平台等多方面的优点
  • 约定优于配置,免除开发过程中的配置之苦
  • 具有良好的自我扩展能力
  • 易于同spring等IOC框架进行集成
  • 从实用的角度出发,精益求精,从实际开发经验中提取有用的模型
  • 设计专门同EXTJS等框架进行整合的机制
    55_jxc.jpg  
  • 更多etmvc信息

    展开全文
  • java开源web开发框架

    千次阅读 2015-09-18 14:55:24
    Gwittir项目为开发基于GWT的应用程序提供一组代码生成器,基础框架,工具类和一个MVC框架。 更多Gwittir信息  jWebApp  jWebApp是一个基于Servlet的MVC框架。jWebApp是当前最易于学习与使用的web...

     Gwittir 
    Gwittir项目为开发基于GWT的应用程序提供一组代码生成器,基础框架,工具类和一个MVC框架。

    更多Gwittir信息

      jWebApp 
    jWebApp是一个基于Servlet的MVC框架。jWebApp是当前最易于学习与使用的web框架。支持URI映射,服务器端Ajax支持和服务器端REST(RESTful web services)支持。此外一个非常高效的request缓存算法能够让jWebApp具有较高的运行速度。

    更多jWebApp信息

      WaveMaker 
    WaveMaker是一个Web应用程序WYSIWYG构建工具。它能够创建基于Dojo Ajax widget,Spring与Hibernate的应用程序。

    更多WaveMaker信息

      IWebMvc 
    IWebMvc为开发基于Spring/Hibernate/dojo和DWR的Web应用程序提供一个基础框架。此外IWebMvc还支持Groovy,Spring Webflow2.0,Jasper Reports/Dynamic Jasper,多文件上传(包括一个特殊的控件)。提供Image Gallery控件,投票控件。

    更多IWebMvc信息

      SeamWebAppGen 
    SeamWebAppGen是一个Web应用程序生成器。它生成的应用程序基于JSF2.1,JBoss SEAM,RichFaces和EJB3等技术并能够部署在JBoss Application Server (4.x)上。

    更多SeamWebAppGen信息

      rapid-framework 
    一个类似ruby on rails的java web快速开发脚手架,本着不重复发明轮子的原则,框架只是将零散的struts(struts2)+spring+hibernate各个组件组装好在一起,并对struts及struts2进行改造,提供零配置编程,并内置一个强大的代码生成器及模板文件,可以生成java的hibernat model,dao,manager,struts+struts2 action类,可以生成jsp的增删改查及列表页面。 
    整个项目借鉴了ruby on rails,appfuse,springside

    框架特性:
    • 内置一个基于数据库的代码生成器rapid-generator,极易进行二次开发
    • struts1,struts2的零配置
    • spring集成及加强,自动搜索hibernate的entity annotation class
    • 集成动态构造sql的工具:rapid-xsqlbuilder
    • 集成javascript表单验证:rapid-validation
    • 集成extremeTable分页组件,并简单扩展显示pageNumber
    • 集成DBUnit及spring对数据库测试的支持
    • 内置的分页查询PageInfo接口
    • Java日期转换的特殊处理,与My97DatePicker集成
    • 内置最精简的ant构建脚本,简单修改即可使用
    • 公共类库友好的包名javacommon
    • 整个项目尽量做到最小集,无需删除任何资源,拿来即可使用.
    • 友好的MIT-Licence

    更多rapid-framework信息

      LazyJ 
    LazyJ是一个Java Web应用程序开发框架。包括: 一个非常快的模板引擎,该引擎能够缓自动存编译过的模板。提供响应缓存和数据缓存引擎。封装常用的数据库操作功能,包括连接池。基于数据库的Session保存机制。提供便捷的文件上传功能。提供通知/提醒框架,已经实现利用email和Yahoo! Messenger来发送通知。提供一组与数据库绑定的HTML控件。

    更多LazyJ信息

      mesir 
    组合各种常用的开源框架,并尽量简化这些框架的用法。为开发Web应用程序提供基础的框架。帮助开发人员快速有效的建立Web应用项目。当前组合的开源框架包括: JSF, FaceletsMyFaces OrchestraSpringHibernate (Search, Validator)Jboss EnversCXF, JAX-WSJoda Time (with Hibernate persistency support)Selenium Testsslf4j、logback

    更多mesir信息

      Suco 
    Suco是一个能够让GWT客户端实现代码简洁与模块化的框架。Suco主要关注两个方面:一.保持系统的模块化(使用IoC模式实现)。二.提供一个简单并且可扩展的publisher/subscriber(Event/Listener)机制。Suco IoC完全基于Google's Guice IoC框架的思想,拥有Container、Provider、Factory和Scope等概念。

    更多Suco信息

      PrimeFaces 
    PrimeFaces是一个用于提高JSF Web应用程序开发效率的开源类库。主要由三个模块组成: UI Components:PrimeFaces UI模块提供了拥有Rich Web用户体验的各种JSF组件。PrimeFaces使用Yahoo UI库做为默认的客户端框架。PrimeFaces提供的JSF组件能够处理JavaScript Rendering和如何在服务器端与JSF集成。PrimeFaces UI组件包括:HtmlEditor、ImageCropper、Dialog、AutoComplete、Flash based Chart等。并支持通过Ajax更新页面。Optimus模块提供简化JSF开发的解决方案。Optimus提供基于Google Guice IOC容器的注释来代替XML配置和一个XML-less Navigation Handler能够让你减少基于XML配置JSF Navigation的需要。此外Optimus还支持利用JPA实现数据持久化;将DataTable的内容导出成Excel与PDF。支持安全扩展。FacesTrace模块提供跟踪JSF Web应用程序的各种工具包括:JSF LifeCycle可视化查看器;性能跟踪器; Log4J适配器;FacesMessage监听器;组件树可视化查看器。 

    更多PrimeFaces信息

      AribaWeb 
    AribaWeb是一个基于组件的Web应用快速开发框架,用于创建基于Ajax的web应用程序。AribaWeb集成了开发数据库应用所需的全部功能,提供丰富的Rich Widgets(forms、pivot、tables、charts、rich text editors等)并且与一个ORM数据库框相绑定。AribaWeb开发的Web应用支持部署在不同的J2EE运行环境中。
    AribaWeb

    更多AribaWeb信息

      Jspresso 
    Jspresso是一个full-stack Java RIA框架,用于开发N层分布式desktop-like应用程序。基于Jspresso开发的应用程序可以部署成Adobe's Flex、Ajax (WingS)、ULC与Swing,并且是不需要改动任何GUI代码。
    Jspresso.jpg

    更多Jspresso信息

      Joindesk 
    Joindesk是一个建立在Ext JS, Velocity and Spring基础上的J2EE Web应用框架。
    Joindesk能够加速使用Ext组件的J2EE Web应用开发。不用编写一句JavaScript就可以在Java代码中直接响应来自Ext组件的事件。你在处理AJAX请求时也不必关心JSON或XML数据格式。
    使用Joindesk框架开发Web应用UI交互,就像使用VB/VC开发桌面应用UI交互一样方便快捷。
    在Joindesk中,相关的表单定义(JS)、页面模板(HTML)和页面处理逻辑(class)可以打包在一个文件中发布,使web应用模块化开发部署更方便。 
    Joindesk.jpg

    更多Joindesk信息

      GWTruts 
    GWTruts是一个易于使用的GWT MVC和依赖注入框架。它将GWT module分割成view、controller和validation等部分类似于传统Web MVC框架如Apache Struts。GWTruts使用XML配置文件来配置视图,控制器和其它属性。此外GWTruts还提供一个依赖注入机制类似于Spring能够让你自由定制你的视图和控制器。GWTruts完全采用GWT开发,因此能够很好地与任意GWT插件/扩展结合使用。

    更多GWTruts信息

      Nutz 
    Nutz是一组轻巧的开源框架,内容涵盖了:
    1.数据持久化(Data Persistence) 
    2.反转控制(Ioc) 
    3.Web框架(MVC)
    Nutz所有的功能均不依赖第三方的jar包,上面三个部分可以独立使用。

    更多Nutz信息

      jQuery4jsf 
    JQuery4jsf是一个开源JSF组件库。这些组件基于jQuery框架开发,当前可用的组件包括: Accordion PanelDatepickerDialogProgressbarSliderTabsDraggableDraggableResizableEffectAutocompleteCarousel。

    更多jQuery4jsf信息

      vaadin 
    vaadin是一个用于创建胖客户端Web应用程序的Java框架。拥有基于GWT实现的各种控件,所有代码全部采用纯Java实现,不需要编写任何JavaScript代码,没有复杂的配置,快速,易于扩展和维护。
    vaadin.jpg

    更多vaadin信息

      etmvc 
    etmvc是基于Java技术,为WEB开发提供的一套简易MVC框架。简易但不简单,其设计和实现借鉴业界众多的优秀框架,如struts,spring mvc,ror,grails等,力图为Java开发人员提供一套高效的开发框架。 基于java技术开发,继承其强大、稳定、安全、高效、跨平台等多方面的优点约定优于配置,免除开发过程中的配置之苦具有良好的自我扩展能力易于同spring等IOC框架进行集成从实用的角度出发,精益求精,从实际开发经验中提取有用的模型设计专门同EXTJS等框架进行整合的机制
    55_jxc.jpg 

    更多etmvc信息

      Induction 
    Induction是一个强大,高性能的Java MVC Web应用开发框架。支持动态重新加载。基于类型的依赖注入。模型、视图、控制器之间的依赖分析。Induction的目标是简化开发复杂、高性能、可维护的Web应用。

    更多Induction信息

      Play Framework 
    Play Framework是一个功能完整的Java Web开发框架。采用RESTful架构设计,简便灵活。Play Framework使用MVC模式作为Web层,集成Hibernate管理持久层,Play Framework还使用一个基于Groovy的模板引擎。 Play Framework让开发者无须重新编译打包发布应用,即可看到修改后的效果,方便开发人员调试应用。Play Framework采用了无状态模型,是一个真正意义上的“无共享”系统,能够在多个服务器上部署多个Play Framework的实例,所有实例都不会互相干扰。Play Framework采用了Groovy作为模板引擎,让表示层真正做到了开发高效简洁Play Framework拥有精确的错误定位机制,当错误发生的时候,可以精确的定位到错误代码的位置。Play Framework的速度很快,启动快,运行的速度也十分快。

    更多Play Framework信息

      ExpressWind 
    ExpressWind是一个REST风格的MVC Web开发框架,与传统MVC框架(如Struts、WebWork)完全不一样。支持直观友好的URL如'/blog/display/20090909'这样更利于搜索引擎收录。能够在Java类方法中定义HTTP请求。支持用拦截器来处理事务、日志和其它事情。支持用ExceptionHandler来集中处理和控制异常。支持文件上传。

    更多ExpressWind信息

      Rose 
    Rose是由人人网提供的、基于Servlet规范、Spring“规范”的开放源代码WEB开发框架。 
    Rose是面向使用Java开发的同仁们的。Rose 提供的各种特性和约束惯例,目的就是为了使您在能够轻松地开发web程序。如果您觉得Grails的想法很好,您不必转向它,Rose可以给您这种感觉,同时基于您对Java的熟悉,您又能更好地控制Rose。 
    我们希望Rose对各种技术的整合和规范,能使您摆脱犹豫,摆脱选择的困难,规避没有经验带来的开发风险。Rose不仅整合技术,同时还强调最佳实践,甚至包括名称规范。我们不仅仅只是提供技术,我们还会引导您应该如何使用好技术。 
    Rose规范了对Spring的使用,虽然大部分时间之内,您可能只是使用 @Autowired 即可,大多数时候的确这样也就够了。但 Rose 也允许您放置applicationContext-xxx.xml文件来扩展Rose。

    更多Rose信息

      Simpleframework 
    Simpleframework是基于 Intercepting-Filter模式和MVC2模式(我们称之为:后处理模式,After-Processing Pattern),基于“应用即组件,组件即应用(Application are components,component can be a application)”理念采用Java 技术实现的Web应用级框架。

    其核心价值在于提供了以声明方式来描述组件行为的机制,该机制有效整合了客户端的UI视图、处理逻辑、存取访问控制策略、校验规则,以及服务器端的数据持久化、分布式缓存、业务规则等的一体化应用

    提供一套完整的Web UI组件来简化和加快AJAX/富Web应用(Rich Internet Application)的构建、部署及维护进程,从而达到降低Web应用开发成本、缩短开发周期和提高应用效能的目的。
    layout.png

    更多Simpleframework信息

      jdonmvc 
    一个站在Jdon框架上面向DDD,DCI,CQRS等架构风格的表现层开发框架。框架特点:超级易用,易扩展,默认会使用Jdon作为领域模型管理框架。

    更多jdonmvc信息

      J-HI 
    J-HI是一款JAVA WEB应用软件快速开发开源平台,主要服务于软件企业和传统行业企事业单位信息中心的开发人员,为他们提供一套完整的一站式的JAVA WEB应用软件快速开发解决方案。  平台包括如下两个部分: 
        1、应用开发框架:本平台是团队成员多年企业应用开发经验的总结,提供大量通用的API与通用业务功能。 
        2、集成开发工具:采用MDD(模型驱动开发)的开发方式,快速搭建、生成可运行系统。 
        平台主要致力于解决如下问题:: 
        1.高效: 在J-HI中,有对业务对象和业务流程的图形化设计工具,能快速的生成一套完整的应用程序。 
         2.高质: 从业务层面上说,利用J-HI产品的业务对象和业务流程设计器能以图形化的方式直观描述业务需求,快速生成代码完全开放的完整应用,满足了客户的业务需求;。 
        3.变化: 利用J-HI的业务对象设计器可随时修改对象属性,快速应对客户的需求变化,并且源码可重复生成,不影响手写的代码。 

    更多J-HI信息

      Summer 
    Summer是下一代Spring MVC的表现层框架。它提供了最好的HTML5模板引擎并利用了许多Spring3的特性如内容协商(Content negotiation),REST支持,资源处理等。此外它还支持一些开箱即用的JavaEE6规范如Servlet3.0,JPA2.0,Bean Validation和EL2.2。
    收录时间:2010-10-12 23:24:26

    更多Summer信息

      dispatcher 
    一个简单的MVC框架或者不能算是MVC 作用:通过URL直接将请求转发到具体的方法上。 配置:唯一的配置文件为config.properties,暂时里面只需要配置一句url.suffix=com.wenbin.action(就是需要进行转发的类的包路径,多个路径用逗号隔开)。解决的问题:简化配置,去除配置文件,尽可能的使得软件的维护成本降低。并且降低学习成本。
    收录时间:2010-10-24 17:31:59

    更多dispatcher信息

      SoybeanMilk 
    SoybeanMilk是一个极其简易、友好、且零侵入的Java MVC实现框架:
    • 它几乎没有学习成本,你只需要熟悉jsp和servlet技术
    • 也不需要你遵从任何代码编写模式
    • 你的代码中找不到任何这个框架的踪迹

    使用它,您仅需要指定URL和参数值便可以执行任何Java对象的任何方法并控制和取得其返回结果。

    如果你是一个WEB开发者,并且已经有点厌烦现有的WEB开发框架所固有的开发方式(固定的代码编写模式、芝麻点的小功能也要写一堆接口),应该考虑了解下这个框架。

    还有,这个框架并不是仅能应用于WEB程序,你也可以在桌面程序中使用它。

    收录时间:2010-11-14 11:26:44

    更多SoybeanMilk信息

      GWT Portlets 
    GWT Portlets是一个开源Web框架用于开发GWT(Google Web Toolkit)应用程序。它定义了一种非常简单、高效、强大的编程模型来构建好看和模块化的GWT应用。编程模型有点类似于为Liferay, JBoss Portal等portal服务器编写一个JSR168 portlets。 
    gwtportlets.gif

    更多GWT Portlets信息

      Spring Mobile 
    Spring Mobile 是 Spring MVC 的扩展,用来简化手机上的Web应用开发。
    收录时间:2010-11-21 17:04:24

    更多Spring Mobile信息

    展开全文
  • 一直以来,都想要阅读某些Java开源项目的源代码,甚至想要修改某些代码,实现对开源项目进行二次开发的目的。但总是不知从何入手,直接将开源项目的源代码导入Eclipse,总是会报很多错误,而无法编译。可以直接通过...

    一直以来,都想要阅读某些Java开源项目的源代码,甚至想要修改某些代码,实现对开源项目进行二次开发的目的。但总是不知从何入手,直接将开源项目的源代码导入Eclipse,总是会报很多错误,而无法编译。可以直接通过Eclipse打开开源项目的源代码,至少能够达到可视化源码阅读、源码导航的目的,还是能在一定程度上解决源码阅读不爽的问题,因为直接打开并没有改变源文件项目的目录结果,对于修改过后的代码,可以通过命令行找到源文件项目目录,并使用mvn或者ant对项目进行编译,再查看修改后的项目是否正确。


    由于当前Java开源项目几乎都是采用maven或者ant的方式打包的,所以上述方法再一定程度上解决了阅读源码的问题,至少通过Eclipse能够实现源码之间的导航,但是想要通过Eclipse进行编译源代码,甚至调试就无法办到了。


    这么强大的Eclipse,怎么用起来这么力不从心呢,罪魁祸首还是自己太孤陋寡闻了,这么强大的maven,Eclipse怎么会没有插件支持呢,有了maven插件,Eclipse导入maven项目(也就是大多数开源项目的目录结构),在Eclipse上面就能够直接进行编辑,甚至通过Eclipse去编译、调试源项目。


    既然知道了怎样阅读开源项目的源代码,接下来就是安装Eclipse的maven插件,然后源代码、二次开发...


    前面说了这么多废话,是否真的有效呢,下面以Axis2源代码为例,做一个小实验例子,修改services/listServices请求的处理源码,使得原先仅支持WSDL方式描述的Web服务现在也支持OWL4WS的Web服务描述。


    第一步:安装maven

    安装maven实在是简单,从 http://maven.apache.org/download.html 下载最新的maven版本,然后解压,配置MAVEN_HOME和MAVEN_OPTS以及path环境变量即可。MAVEN_HOME指向maven的跟目录,MAVEN_OPTS配置maven执行时的参数,由于MAVEN默认设置的内存比较少,编译大项目时可能会出现OutofMemory的情况,如我没有设置MAVEN_OPTS而编译Axis2的源码时就出现了OutofMemory的情况,最后配置path,指向%MAVEN_OPTS%\bin即可。使得在命令行界面中能够直接使用maven命令。更多关于maven的介绍,推荐一本书给大家:《Maven实战》,也有叫《Maven in action》,是一个中国人写的,浅显易懂。


    第二步:安装Eclipse的maven插件

    Help->Install New Software->Add,添加如下内容:

    m2e - http://download.eclipse.org/technology/m2e/releases

    如 http://www.eclipse.org/m2e/download/ 所示,上述插件的路径应该为m2e的最新版本,使用之前的版本可能会出现依赖其他插件的情况,导致m2e插件安装不上,SB的Eclipse也没有提示m2e到底依赖哪些插件导致其安装不上,度娘倒是能够提供一下帮助,但是几乎不能找到一个能够使用的。

    安装完m2e插件之后,就能通过Eclipse打开maven格式的项目,并能够借助Eclipse对maven格式的源项目进行编译,当然也可以直接通过Eclipse创建一个Maven项目,从而使用maven的方式管理你的项目。maven实在是强大,如果你使用Java语言写程序,了解maven真心是有必要。安装完后再创建项目或者导入项目时,就可以选择Maven进行了。安装完插件后会看到如下效果:



    第三步:在Eclipse中修改源代码

    通过Eclipse导入maven项目,就能使用Eclipse的可视化导航功能对源码进行阅读及修改,还能直接执行相关的mvn命令,导入后的程序如下图所示:



    第四步:通过mvn package编译并打包源码,得到发行版本,进行测试

    有了maven,源代码的编译及打包就变得容易多了,可以直接通过Eclipse进行,选择项目右键Run As或者右键单击项目的pom.xml文件Run As即可。如下图所示:



    当然,也可以直接通过命令行进行打包编译,我选择采用命令行进行,由于我只修改了Axis2源码中的两个模块,这两个模块分别是axis2-transport-http和axis2-webapp。对这两个模块的命令行编辑命令如下:

    1. C:\OpenSource\axis2-1.6.0-src\axis2-1.6.0\modules\transport\http>mvn clean install  
    2. [INFO] BUILD SUCCESS  
    3.   
    4. C:\OpenSource\axis2-1.6.0-src\axis2-1.6.0\modules\webapp>mvn clean package  
    5. [INFO] Building war: C:\OpenSource\axis2-1.6.0-src\axis2-1.6.0\modules\webapp\target\axis2.war  
    6. [INFO] BUILD SUCCESS  

    mvn install是将axis2-transport-http模块安装到maven本地仓库中,而mvn package是将源程序按指定的格式打包,由于webapp模块的pom.xml文件中指定了很多依赖模块,包括其他项目的或者axis2本身的模块,如transport-http模块,打包时会从本地仓库中自动获取其依赖的模块,并打包。如果本地仓库中没有相应的模块,会去网上自动下载,这也是为什么第一次编译开源项目时会花费很长时间的原因。


    将axis2.war包拷贝到tomcat的webapp目录下,启动tomcat,在浏览器中输入http://localhost:8080/axis2/services/listServices,即可看到修改后的页面已经对OWL4WS进行了支持。如下图所示:



    回过头来,发现本篇文章尽是废话,不过就是想表达一下,maven真心是灰常强大,对于想要阅读Java开源项目源代码,或者有在这些源代码的基础上进行二次开发冲动的童鞋,一定不要错过maven的学习,不过感觉这种方式在修改源代码,然后进行测试这种方式还是非常不方便,命令行编译,还得copy到tomcat下测试运行,哪位有更好的阅读源代码并进行二次开发的方式,请你一定要告诉我啊。

    展开全文
  • Java开发开源框架面试总结

    千次阅读 2017-11-04 15:03:29
    此篇文章是应届生临时总结的Java开发面试开源框架部分:主要总结了主要的几个点,便于回答,用于有一定Java基础的同学面试所用,由于是面试问题,所以内容多有不详尽之处。  学习一个技术要明白几个点:这个技术是...

          此篇文章是应届生临时总结的Java开发面试开源框架部分:主要总结了主要的几个点,便于回答,用于有一定Java基础的同学面试所用,由于是面试问题,所以内容多有不详尽之处。

          学习一个技术要明白几个点:这个技术是什么?有什么特点?怎么使用?什么时候使用?这是学一个技术的态度问题。

          另外,大公司的面试官往往也很喜欢问这样的笼统问题:可以谈谈你对Spring的理解么!面对这种问题,初出茅庐的应届生往往都哑口无言,如果想要回答的体面,可以从这四个点来回答,你回答的过程中,面试官可能一直在听直到你讲完,也可能让你不用继续说了,因为他已经明白了你懂这些内容,并且善于组织这些东西,也有所准备。无论是哪一种,都能给面试官留下一个好印象。

    1 Tomcat

    1.1 Tomcat介绍

    Tomcat是什么?

    (是什么)Tomcat是一个免费的开源代码的轻量级Web应用服务器;

    (应用场合)一般在中小型系统和并发用户不多的场合下使用于开发和调试Jsp程序;

    (使用目的)用来运行Jsp页面和Servlet来响应HTML页面请求。

    1.2 组件等级划分

                

    Tomcat按功能划分为许多不同的组件,并可通过/conf/server.xml文件对其定义和配置,包括Server, Service, Connector,Engine,  Host,  Context……一般可分4个等级:

         1、顶级组件:位于配置层次的顶级,并且彼此间有着严格的对应关系,有Server和Service组件;

         2、连接器:连接客户端(浏览器或Web服务器)请求至Servlet容器,如Connector组件,

         3、容器:功能是处理传入请求的组件,并创建相应的响应。如Engine处理对一个Service的所有请求,Host处理对特定虚拟主机的所有请求,Context处理对特定web应用的所有请求;

         4、被嵌套的组件:位于一个容器当中,但不能包含其它组件;一些组件可以嵌套在任何Container中,而另一些只能嵌套在Context中。

    1.3 组件间互联关系

          如果把Tomcat比较一个框架类,那么一个Server服务器表示一个Tomcat实例,通常一个JVM也只包含一个Tomcat实例,一个Server中可以有多个Service服务,Service可以包含一个或多个Connector用于连接Container容器中的一个Engine,连接器Connector通过特定端口接收客户端请求,并将其转发到关联的Engine;

          而Engine作为Servlet容器引擎,包含多个Host组件和其他组件,引擎接收并处理来自一个或多个连接器的请求,并辨别请求的HTTP首部信息以便确定发往哪个Context或Host(客户端通常使用主机名来标识他们希望连接的服务器),并将完成的响应返回到连接器,以便最终传输回客户端。

          一个Context上下文对应一个Web应用程序,即一个Web project,而一个Web工程包含多一个Wrapper(Servlet应用程序的包装类)。也就是说,在tomcat容器等级中,Context容器直接管理Servlet在容器中的包装类Wrapper,所以Context容器如何运行将直接影响servlet的工作方式。

    【可省略不看……

    1 Server

          Server(服务器)表示Tomcat的一个实例,因此,它必须是/conf / server.xml配置文件中的单个最外层元素,它的属性表示servlet容器的整体特性。通常一个JVM只能包含一个Tomcat实例。默认配置表示监听在8005端口以接收shutdown命令,默认仅允许通过本机访问。

    2 Service

          Service(服务)主要用于关联一个Engine和与此Engine相关的Connector,每个Connector通过一个特定的端口和协议接收请求,并将其转发至关联的Engine进行处理。

           因此,Service可以包含一个Engine、以有一个或多个Connector;而一个Server可以包含多个Service组件,但通常情下只为一个Server指派一个Service。通常需要给Service命名,可以方便管理员在日志文件中识别不同Service产生的日志。

           如默认配置中server只包含一个名为"Catalina"的service,而service里包含两个Connector,其中一个监听8080端口接收HTTP请求,另一个监听8009端口接收AJP协议的请求。

    3 Connector

           Connector(连接器)通过一个特定的端口接收特定协议的客户端请求,并将其转发至关联的Engine进行处理。一个Engine可以配置多个连接器,但这些连接器必须使用不同的端口。

          定义连接器可以使用多种属性,有些属性也只适用于某特定的连接器类型。一般说来,连接器类型可以分为两种:Http连接器和AJP连接器。

    4 Engine 

         Engine(引擎)表示与特定Service相关联的整个请求处理机制,即Servlet容器引擎。它接收和处理来自一个或多个连接器的所有请求,并检查每一个请求的HTTP首部信息以辨别此请求应该发往哪个Host或Context,并将完成的响应返回到连接器,以便最终传输回客户端。

         一个Engine元素必须嵌套在Service元素内,它可以包含多个host组件,还可以包含Realm、Listener和Valve等子容器。

    5 Host

          Host(虚拟主机)类似于Apache中的虚拟主机,但在Tomcat中只支持基于FQDN的"虚拟主机"。Host位于Engine容器中用于接收请求并进行相应处理,它是服务器(例如"www.mycompany.com")的网络名称与运行Tomcat的特定服务器的关联。

          客户端通常使用主机名来标识他们希望连接的服务器,但要使客户端能够使用其网络名称连接到Tomcat服务器,此名称必须在管理所属的Internet域的域名服务(DNS)服务器中注册。

    6 Context组件

          Context(上下文)表示在特定虚拟主机中运行的Web应用程序,一个Context对应一个Web应用程序(Web工程),而里面的Wrapper可以理解为一个Servlet程序

          Context需要根据其定义的上下文路径(path)匹配请求URI的最长前缀(除主机名外)来选择。一旦选择,可以由docBase来找到该上下文将对应的web应用程序部署目录,由目录中web.xml定义的servlet映射选择一个合适的servlet来处理传入的请求。            】

    1.4 Tomcat与Jetty的比较

         Tomcat和Jetty都是一种应用的比较广泛的Servlet引擎,但是相比较于Jetty,Tomcat更加稳定成熟,其市场霸主地位仍然难以撼动。但是两者各有优劣,现对其进行综合比较:

    1)架构方面

          Jetty所有组件都是基于Handler来实现的,是一种面向Handler的架构。(Spring是一种面向Bean的架构,IBatis是一种面向Statement的架构)         

    从设计模式角度来看:一、Handler采用责任链设计模式:HandlerCollection可以帮助开发者构建一个链,接口类ScopeHandler可以帮助开发者控制这个链的访问顺序;二、采用了观察者设计模式,对象只要继承了LifeCycle接口就可以被Jetty管理控制整个生命周期。

         Tomcat则是一种多级容器的构建模式,所有组件依附于其构建骨架;其核心就是容器设计,设计臃肿复杂,是为了更好扩展,但是将内部结构暴露给了外部使用者,学习难度变大,增加学习成本,其难度。

         Jetty讲的是做某件事的规范,即告诉你应该怎么做,如果做由开发者自己实现;

         Tomcat则是已经做了很多的工作,你要先理解这些工作,然后在此基础上做额外的工作。 

    (2)性能方面

         Tomcat和Jetty的使用场景不尽相同,即对相同的使用场景,两者性能各有优劣。

         Jetty可以同时处理并保持大量的连接,适合生命周期长的;按需加载组件,使用NIO技术,处理I/O请求上更具优势。例如,淘宝Web旺旺使用的就是Jetty作为Servlet引擎。

         Tomcat适合处理少数频繁并且生命周期短的连接;使用BIO技术,处理静态资源时性能较差。

    (3)特性方面

          Jetty和Tomcat都支持标准的Servlet规范、JavaEE规范。

          只不过Tomcat更加成熟,支持的更加全面而已,集成了很多这些规范的特性;整体结构复杂,修改功能缓慢,不易扩展。

          而Jetty轻便灵敏(因为其开发社区更加灵活,修改更加简单),整体结构简单易用,组件可替换,功能修改较快,容易扩展。

    2 Servlet

    2.1 Servlet介绍

    根据自己的理解,Servlet是什么?作用?

         (是什么?)Servlet是实现了Servlet接口,并通过“请求-响应”模式来访问的服务端Java程序;

         (干什么的)主要用于开发动态Web资源;交互式的浏览和修改数据,动态的扩展Server的能力。

    (1)接受请求,并与服务器资源进行通信;

    (2)创建并返回一个基于客户端请求性质的动态内容HTML页面给客户端。

    下面是一段Servlet的具体定义:

         Servlet是sun公司提供的一种用于开发动态web资源的技术,其API提供了servlet接口,若用户想要开发一个动态web资源,需要:
      1、编写一个实现servlet接口的Java类。
      2、把开发好的Java类部署到web服务器中。
      通常,按照习惯把实现了Servlet接口的java程序,称为Servlet。

        Servlet依赖于Servlet容器(如常用的Tomcat和Jetty),两者类似于枪和子弹,相互依存、相互增强,但又相互独立,通过标准化接口进行协调工作

        Servlet容器独立发展,种类很多,各有定位,各有特点,比较流行的有Jetty、Tomcat等,其中以Tomcat占据市场主流。

    2.2 Servlet生命周期

          servlet始于装入web服务器内存,并在web服务器终止或重装servlet时结束。servlet一旦被装入web服务器,一般不会从web服务器内存中删除,直至web服务器关闭或重装才会结束。
          (1)初始化:web服务器启动时或web服务器接收到请求时加载Servlet。执行init();

          (2)调用:运行service()方法,service()自动派遣运行与请求相对应的doGet()或doPost()方法;

          (3)销毁:停止服务器时调用destroy()方法,销毁实例。  

    2.3 Servlet调用流程

         结合着生命周期说,Servlet程序是由WEB服务器调用,web服务器收到客户端的Servlet访问请求后:
       (1)Web服务器接收到浏览器发送的请求之后,首先检查是否已经装载并创建了该Servlet的实例对象。

       (2)如果没有Servlet实对象,装载并创建该Servlet的一个实例对象,调用Servlet实例对象的init()方法初始化。

       (3)创建一个用于封装HTTP请求消息的HttpServletRequest对象和一个代表HTTP响应消息的HttpServletResponse对象,然后调用Servlet的service()方法并将请求和响应对象作为参数传递进去。
       (4)WEB应用程序被停止或重新启动之前,Servlet引擎将卸载Servlet,并在卸载之前调用Servlet的destroy()方法。

     

    IE浏览器:http://localhost:8080/Demo/function.do 这个过程都经历了什么?

         (1)连接上web服务器

         (2)发送http请求

               GET/FirstServlet/first.do HTTP/1.1
               Accept: image/gif,image/jpeg, image/pjpeg, image/pjpeg, application/xaml+xml,application/x-ms-xbap, application/x- ms-application,application/vnd.ms-xpsdocument, */*
               Accept-Language:zh-cn,en-US;q=0.7,ar-OM;q=0.3
               User-Agent:Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; .NET4.0C;.NET4.0E; .NET CLR 2.0.50727; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)
               Accept-Encoding:gzip, deflate
               Host:localhost:8080
               Connection:Keep-Alive

    web服务器(Tomcat)

         (3)解析出想访问的主机名

         (4)解析出想访问的web应用

         (5)解析出想访问的web资源

    FirstServlet.java

          (6)第一次则创建servlet实例对象

          (7)第一次的话,则调用servlet的init方法完成对象初始化

          (8)创建代表请求request和代表响应的response对象,然后调用servlet的service方法响应客户端的请求

          (9)service方法执行,向代表客户端响应的response对象写入了要输出的数据

          (10)服务器从response中取出数据,构建出一个http响应,回写给客户机

           HTTP/1.1 200 OK

            Server: Apache-Coyote/1.1

            Content-Length: 14

            Date: Sat, 24 Dec 2011 04:00:55 GMT

            hello servlet!

         (11)浏览器解析http响应,提取数据显示

         (12)WEB应用程序被停止或重新启动之前,Servlet引擎将卸载Servlet,并在卸载之前调用Servlet的destroy()方法。

    2.4 Servlet线程安全问题

    1)实现 SingleThreadModel接口;(不一定安全)

            针对Service()方法

    2)使用Syncronized关键字实现数据共享;

    3)避免使用实例变量;

    2.5 Servlet 通信

            Web容器在启动的时候为每个应用创建一个ServletContext对象,ServletConfig对象中维护了ServletContext的引用,开发人员在编写servlet时,可以通过ServletConfig.getServletContext方法获取到ServletContext对象。由于一个web应用中的所有servlet共享一个ServletContext对象,因此servlet对象之间可以通过ServletContext对象来实现通讯。ServletContext对象也通常被称为Context域对象。

    1.多个servlet通过ServletContext对象实现数据共享。Initservlet的Service方法中利用ServletContext对象存入需要共享的数据

    ServletContext context=this.getServletContext();

    Context.setAttribute(“name”,“Lucy”);

        在其他的servlet中利用ServletContext对象获取共享数据

    ServletContext context =this.getServletContext();

    String name =context.getAttribute(“name”);

    2.获取web应用的初始化参数。在DemoServlet的doPost方法中获取初始化参数的步骤如下:

    ServletContextcontext=this.getServlenContext();

    String url=context.getInitParmeter(“url”); 

    2.6 Servlet 工作原理、如何实现

    1:用户通过浏览器向服务器发送一个请求url:  http://hostname:port/contextpath/servletpath; 其中,hostname和port用来与服务器简历TCP连接,contextpaht和servletpath路径用于选择服务器中对应子容器服务请求

    2:如何选择子容器?使用org.apache.tomcat.util.http.mapper这个映射类保存Container容器中所有子容器信息,  org.apache.tomcat.catalina.connector.Request请求类进入Container容器之前,Mapper类就根据hostname和contextpath在mappingData属性中保存了host和Container容器之间的关系,可以根据这个映射关系选择子容器。

    3:Mapper类又如何保存这个映射关系呢?使用类似于观察者模式的方法,将MapperListener作为一个监听者加入Container容器的每个子容器,一旦容器发生变化,保存容器关系的MapperListener类的mapper属性也会修改更新

    2.7 写一个Servlet例子和配置Servlet

    public class SecondServlet extends HttpServlet { 
    @Override 
    public void init() throws ServletException {
     System.out.println("这是init()方法..."); } 
    @Override
     Public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
     System.out.println("这是doGet()方法..."); // 设置内容类型 
    resp.setContentType("text/html"); 
    PrintWriter out = resp.getWriter(); 
     out.println("<html><head><title>Hello World Sample</title></head>");
    out.println("<body><h1>Hello World Title<h1><h2>" +new Date().toLocaleString() + "</h2></body></html>"); 
    out.flush();     
     }
     @Override 
    public void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
    System.out.println("这是doPost()方法...");
     } 
    Public void service(){};
     @Override 
    public void destroy() {
     System.out.println("这是destroy()方法..."); 
    } 
    }

        除了Servlet的书写,还有Servlet配置:

             

    2.8 Filter 和其工作原理

         对于一个web应用程序来说,过滤器是处于web容器内的一个组件,它会过滤特定请求资源请求信息和响应信息。一个请求来到时,web容器会判断是否有过滤器与该信息资源相关联,如果有则交给过滤器处理,然后再交给目标资源,响应的时候则以相反的顺序交给过滤器处理,最后再返回给用户浏览器。

     过滤器类需要实现javax.servlet.Filter,该接口的doFilter()方法是业务处理的核心代码区,类似于servlet的service()方法。doFilter()方法的参数列表有一个FilterChain接口的实现对象,它只有一个方法doFilter(),在调用该方法之前的代码会在达到目标资源前执行,之后的代码会在目标资源已经响应后执行。

    工作原理:

            当客户端发出Web资源的请求时,Web服务器根据应用程序配置文件设置的过滤规则进行检查,若客户请求满足过滤规则,则对客户请求/响应进行拦截,对请求头和请求数据进行检查或改动,并依次通过过滤器链,最后把请求/响应交给请求的Web资源处理。请求信息在过滤器链中可以被修改,也可以根据条件让请求不发往资源处理器,并直接向客户机发回一个响应。当资源处理器完成了对资源的处理后,响应信息将逐级逆向返回。同样在这个过程中,用户可以修改响应信息,从而完成一定的任务。

      两个过滤器同时过滤一个请求时,就要用到过滤链FilterChain.Filter的FilterChain中,服务器会按照web.xml中过滤器定义的先后循序组装成一条链,然后一次执行其中的doFilter()方法。执行的顺序就如下图所示,执行第一个过滤器的chain.doFilter()之前的代码,第二个过滤器的chain.doFilter()之前的代码,请求的资源,第二个过滤器的chain.doFilter()之后的代码,第一个过滤器的chain.doFilter()之后的代码,最后返回响应。

    2.9 写一个Filter和配置Filter      

    public class EncodingFilterTest implementsFilter {
    public void destroy(){      // TODO Auto-generated method stub  }
    public void doFilter(ServletRequestrequest,ServletResponse response,FilterChain chain) throws IOException,  //三个参数比较重要
    ServletException  {
             System.out.println("encodingFilterdoFilter-----");
             request.setCharacterEncoding("utf-8");
             response.setCharacterEncoding("utf-8");
             chain.doFilter(request,response);
    }
    public void init(FilterConfigarg0) throws ServletException {  System.out.println("过滤器初始化");  }
    }
     

    配置:

                 

    3 Spring

    3.0框架基础概念

    1、应用程序:是能完成我们所需要功能的成品,比如购物网站、OA系统。

    2、框架:是能完成一定功能的半成品,比如我们可以使用框架进行购物网站开发;框架做一部分功能,我们自己做一部分功能,这样应用程序就创建出来了。而且框架规定了你在开发应用程序时的整体架构,提供了一些基础功能,还规定了类和对象的如何创建、如何协作等,从而简化我们开发,让我们专注于业务逻辑开发。

    3、非侵入式设计:从框架角度可以这样理解,无需继承框架提供的类,这种设计就可以看作是非侵入式设计,如果继承了这些框架类,就是侵入设计,如果以后想更换框架之前写过的代码几乎无法重用,如果非侵入式设计则之前写过的代码仍然可以继续使用。

    4、轻量级及重量级:轻量级是相对于重量级而言的,轻量级一般就是非入侵性的、所依赖的东西非常少、资源占用非常少、部署简单等等,其实就是比较容易使用,而重量级正好相反。

    5、POJO:POJO(Plain Old Java Objects)简单的Java对象,它可以包含业务逻辑或持久化逻辑,但不担当任何特殊角色且不继承或不实现任何其它Java框架的类或接口。

    6、容器:在日常生活中容器就是一种盛放东西的器具,从程序设计角度看就是装对象的的对象,因为存在放入、拿出等操作,所以容器还要管理对象的生命周期。

    7、控制反转:即Inversion of Control,缩写为IoC,控制反转还有一个名字叫做依赖注入(DependencyInjection),就是由容器控制程序之间的关系,而非传统实现中,由程序代码直接操控。

    8、Bean:一般指容器管理对象,在Spring中指Spring IoC容器管理对象。

    3.1 Spring简介

    Spring是什么?

          Spring是一个开源的轻量级Java SE(Java 标准版本)/Java EE(Java 企业版本)开发应用框架,其目的是用于简化企业级应用程序开发。

    干什么的,优点?

    (1)通过配置方式来创建对象,并自动管理对象之间依赖关系(IOC控制反转); 【轻量级容器】

    (比起传统方式避免了源码修改,重新编译和部署,减少工作,加速开发,节省时间)

    (2)除此之外,还提供像通用日志记录、性能统计、安全控制、异常处理等面向切面的能力;将这些常用功能从业务逻辑中分离出来,通过面向切面编程,在需要这些功能的地方动态添加这些功能,无需渗透到各个需要的方法或对象中;【AOP面向切面】

    (相比较于传统代码使用对象调用或代理等,这种面向切面的能力避免了代码重复,实现了零耦合

    (3)还能繁琐的数据库事务;Spring本身提供了一套简单的JDBC访问实现;【简单的数据库事务管理】

    (相比于传统代码管理事务的“获取连接,执行SQL,提交或回滚事务,关闭连接”一系列繁琐操作,使用Spring,我们只需获取连接并执行SQL,其他的一切都交给Spring管理)

    (4)Spring还提供与第三方数据访问框架(如Hibernate、JPA)无缝集成的能力;提供JDBC访问模板。【JDBC抽象及ORM框架支持】

    5)与各种Java EE技术整合(如JavaMail、任务调度等等),提供一套自己的web层框架SpringMVC、而且还能非常简单的与第三方web框架集成;

    3.2 Spring设计思想

                        

           从图中可以看出,Spring的核心组件为:Core、Context、Beans,他们三个构成Spring的基础骨架,其他功能组件的使用都依赖于这三个核心组件,其实Spring可以看做是一个面向Bean的编程

    参考链接:

    http://blog.csdn.net/lp1052843207/article/details/51253071

    https://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/      

         Spring在IOC容器中根据配置文件来管理对象之间的依赖关系,即依赖注入机制。

          把Bean比作演员,Context就是演出的舞台背景,Core相当于演出的道具;Bean包装了Object,Context则给这些Bean提供生存环境,并利用Core工具(类似于Utils)发现每个Bean之间的关系,并建立和维护这种关系;所以,可以说Context是一个Bean关系的集合,又叫IOC容器 

    Bean组件:

            在org.springframework.beans包下,主要用来解决:Bean的定义、Bean的创建、Bean的解析。

            Bean的创建使用了工厂模式,顶级接口是BeanFactory,BeanFactory有三个子类:ListableBeanFactory(可列表)、  HierarchicalBeanFactory(有继承关系)、AutowirecapableBeanFactory(自动装配),三者各有自己的使用场合,在Spring内部对象传递和转化过程中,对对象数据访问进行限制。

           Bean的定义主要由BeanDefinition描述,完整的描述了在Spring的配置文件中定义的<bean/>节点中所有的信息,包括里面的子节点。当Spring成功的解析一个节点后,在Spring的内部转化成BeanDefinition对象。

          Bean的解析主要是对Spring配置文件的解析,依赖于LoadBeanDefinition。 

    Context组件:

          在org.springframework.context包下,给Spring提供一个运行时环境,用以保存各对象状态。

          ApplicationContext是Context的顶级父类,它继承了BeanFactory和ResourceLoader(使得Spring可以 访问外部资源),前者用于运行主体对象Bean,后者用于访问任何外部资源。

          ApplicationContext派发的两个子类:ConfigurableApplicationContext和WebApplicationContext前者用于用户动态的修改或添加配置信息,后者用于为Web准备的Context,可直接访问ServletContext;

         总体来讲ApplicationContext主要完成了:

         标识一个应用环境;利用BeanFactory创建Bean对象;保存对象关系表;捕捉各种事件 

    Core组件:

         包含了很多关键类,比较重要的是定义了资源的访问方式。把所有资源都抽象成一个接口用于访问。

         Resource接口封装了资源类型,屏蔽了文件类型的不同。

        Resource接口的父接口InputStreamSource接口,可利用getInputInstream()直接得到资源InputStream类,屏蔽了资源提供者。

        Resource派发的子接口ResourceSourceLoader接口,可屏蔽所有资源加载者的差异。

    3.3 Spring IOC

    1 何为控制反转?

         控制反转:即Inversionof Control,缩写为IOC;依赖注入(DependencyInjection)可以认为是IOC的实现。

         将控制权交给IOC容器来掌管,通过控制对象之间的关系来管理程序,而非像传统实现中,由程序代码直接操控。

    2 为什么把这种方式叫做控制反转?

        如果对象存在组合关系,传统的代码程序中,对象之间相互依赖,需要用的时候,自己必须主动创建对象或者使用已经创建好的对象;控制权都在我们自己手上;

        但是,如果软件系统引入了Ioc容器之后,对象之间失去了直接联系,一个对象实例化或运行时,如果需要用到另外的对象,IoC容器会主动创建这个对象并注入到使用的对象中,这种控制权的主动行为变成被动行为,控制转发生转移,我们把它叫做控制反转。控制反转带来的一个直观的好处就是低耦合,组件之间相互独立。

    3 IOC如何实现控制反转或控制反转原理?

    【主要利用 工厂模式+反射技术

         IOC中最基本的技术就是“反射(Reflection)”编程:Spring在配置文件中给出了要生成对象的定义,利用反射技术根据配置文件给出的类名(字符串方式)来动态地生成对象,这种编程方式可以让对象在生成时才决定到底是哪一种对象;目的就是提高灵活性和可维护性。

        IOC容器的工作模式可以看做是一个工厂模式,IOC容器就像一个工厂,这个工厂要生成的对象都在配置文件中已经给出定义,然后利用编程语言的的反射技术 ,根据配置文件中给出的类名生成相应的对象;在实现上,IOC是把以前在工厂方法里写死的对象生成代码,改变为由配置文件来定义,实现了工厂和对象生成的分离,目的就是提高灵活性和可维护性。

       【具体请看设计模式之工厂模式反射技术

    4 IOC容器如何工作:

        IOC实际是Context利用Core构建的一个Bean关系网。构建的入口在AbstractApplicationContext类的refresh方法中,功能有:1.构建BeanFactory,便于生产bean;2.注册可能感兴趣的事件;3.创建Bean实例对象;4.触发被监听的事件。

        LoadBeanDefinition(beanFactory)完成加载、解析Bean的定义,把用户的数据转换成 Ioc中的BeanDefinition结构。

    Bean的生命周期:

        1.Bean的建立:由BeanFactory读取Bean定义文件配置文件,并生成各个实例

        2.Setter注入:执行Bean的属性依赖注入

        3.BeanNameAwaer的SetBeanName:如果Bean实现了该接口,就执行该方法

         BeanFactoryAware的setBeanFactory:如果Bean实现了该接口,则执行方法。

        4.Bean定义文件中定义的init-method属性用于设置方法名称,初始化时会执行init-method方法,无参。

               

    DisposableBean的destroy() 在容器关闭时,执行实现类Bean的destroy()方法。

        5.Bean文件中定义的destory-method,在容器关闭的时候使用dstory-method方法,不带参数。

              

    总结:

    Bean的完整生命周期从 spring 容器开始实例化bean 开始,到销毁。可以从三点来理解

           1、 bean自身的方法:包括构造方法、set 方法、 init-method 指定的方法、destroy-method 指定的方法

            2、 Bean级生命周期接口方法:如 BeanNameAware 、 BeanFactoryAware 等这些接口方法由 bean类实现。

            3、 容器级生命周期接口方法:上图中带星的。有InstantiationAwareBeanPostProcessor 、 BeanPostProcessor 等。一般称为后处理 器。他们一般不由bean 本身实现,独立存在,注册到spring 容器中。Spring 通过接口反射预先知道,当spring 容器创建任何bean 时,这些后处理器都会发生作用。所以他们是全局的,用户可以通过编码对只感兴趣的bean 进行处理。

    5 使用IOC的好处、优势?

            (1)【测试调试】可维护性比较好,非常便于进行单元测试,便于调试程序和诊断故障。代码中的每一个Class都可以单独测试,彼此之间互不影响,只要保证自身的功能无误即可,这就是组件之间低耦合或者无耦合带来的好处。

            (2)【分工明确】IOC可使任务独立,各自进行单元测试,每个团队只需要关注自己的业务逻辑即可,分工明确,责任明晰,提高效率。

            (3)【组件复用】IoC独立了组件单元,使得组件可复用性好,可把具有普遍性的常用组件独立出来,反复应用;

            (4)【修改维护】IoC把对象的生成放在配置文件里进行定义,更换实现子类时更加简单,只要修改配置文件即可,完全具有热插拨特性。

    6 使用IOC容器应该注意的地方?

            (1)软件系统中由于引入了第三方IOC容器,生成对象的步骤变得有些复杂。不太直观。

            (2)由于IOC容器生成对象是通过反射方式,在运行效率上有一定的损耗。

            (3)需要进行大量的配制工作,比较繁琐,对小项目而言可能加大一些工作成本。

            (4)IOC框架产品本身的成熟度需要进行评估,存在隐性风险。

    3.4 Spring AOP

    3.4.1 Spring AOP是什么,用来干什么的?

            AOP是一种面向切面的编程技术,主要用来通过预编译方式和运行期动态代理实现程序功能的统一维护的技术。

            AOP是对OOP的补充和完善。OOP引入了封装、继承、多态等概念来建立一种对象层次结构,用于开发者定义一种纵向关系,但并不适合定义横向的关系。例如日志功能,日志代码往往横向地散布在各个层次中,但是却对该层对应的对象没有什么关系。在OOP中,这种散布在各处的无关代码横切(cross cutting)了对应层次对象,但是却导致了代码重复,不利于模块复用。

            AOP则是利用"横切"技术,剖解开封装的对象,抽取出那些散落在各个层次中但和纵向业务无关的重复调用的功能,并将其封装为一个可重用模块,并将其命名为"Aspect",即切面。降低了模块之间的耦合度,并有利于未来的可操作性和可维护性。

            AOP把软件系统分为两个部分:核心关注点横切关注点。业务处理的主要流程是核心关注点,与之关系不大的部分是横切关注点。横切关注点的一个特点是,他们经常发生在核心关注点的多处,而各处基本相似,比如权限认证、日志、事物。

            AOP的作用就在于分离系统中的各种关注点,将核心关注点和横切关注点分离开来。

    3.4.2 AOP核心概念

    1、横切关注点

            对哪些方法进行拦截,拦截后怎么处理,这些关注点称之为横切关注点

    2、切面(aspect)

            类是对物体特征的抽象,切面就是对横切关注点的抽象

    3、连接点(joinpoint)

            被拦截到的点,因为Spring只支持方法类型的连接点,所以在Spring中连接点指的就是被拦截到的方法,实际上连接点还可以是字段或者构造器

    4、切入点(pointcut)

            对连接点进行拦截的定义

    5、通知(advice)

            所谓通知指的就是指拦截到连接点之后要执行的代码,通知分为前置、后置、异常、最终、环绕通知五类

    6、目标对象

            代理的目标对象

    7、织入(weave)

            将切面应用到目标对象并导致代理对象创建的过程

    8、引入(introduction)

            在不修改代码的前提下,引入可以在运行期为类动态地添加一些方法或字段 

    3.4.3 Spring AOP如何实现?

            Spring中AOP代理由Spring的IOC容器负责生成、管理,其依赖关系也由IOC容器负责管理。因此,AOP代理可以直接使用容器中的其它bean实例作为目标,这种关系可由IOC容器的依赖注入提供;

    第一、SPring AOP默认使用Java动态代理,加载一个动态代理类来代理接口并实现一些自定义操作。

            1、SPringAOP 利用JDK环境下java.lang.reflect包下的Proxy类来构造代理类。

            2、具体创建:调用Proxy类下的static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)方法创建代理对象;

    参数1 ClassLoader --用于加载代理类的Loader类;

    参数2 Interfaces--被代理接口;

    参数3 InvocationHandler --用于执行除了代理接口中定义的方法外的其他的自定义操作,这些操作都定义在该类的invoke()方法

            3、newProxyInstance(ClassLoaderloader,Class<?>[] interfaces,InvocationHandler h)主要业务代码:    

    Class c1=getProxyClass(loader,interfaces);           //1:构造代理类名
    Constructorcons=c1.getConstructor(constructorParams);// 2创建构造函数类
    return(Object)cons.newInstance(new Object[] {h});  //创建代理对象(参数传入)

    意思就是:

            1:调用getProxyClass方法把加载类和被代理接口作为参数传入来构建代理类名;

             2:调用代理类名的getConstructor创建构造函数类。

             3:利用构造函数类的newInstance()方法,并传入实现了自定义操作的类对象h,创建Spring AOP的代理类。(会自动将方法对应属性参数传给invoke()方法的Method参数并执行)

    第二、当需要代理的类不是代理接口的时候,Spring会切换为使用CGLIB代理,也可强制使用CGLIB

             AOP编程其实是很简单的事情,纵观AOP编程,程序员只需要参与三个部分:         

    1:定义普通业务组件

    2:定义切入点,一个切入点可能横切多个业务组件

    3:定义增强处理,增强处理就是在AOP框架为普通业务组件织入的处理动作

           所以进行AOP编程的关键就是定义切入点和定义增强处理,一旦定义了合适的切入点和增强处理,AOP框架将自动生成AOP代理,即:代理对象的方法=增强处理+被代理对象的方法。      

    <html>
     <head></head>
     <body>  ​​​​​​​
      <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" /> 普通业务实现类 
      <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" /> 普通业务实现类 
      <bean id="timeHandler" class="com.xrq.aop.TimeHandler" /> 增强处理 
      <aop:config> 
       <aop:aspect id="time" ref="timeHandler">
         定义切入点 
        <aop:pointcut id="addAllMethod" expression="execution(* com.xrq.aop.HelloWorld.*(..))" /> 
        <aop:before method="printTime" pointcut-ref="addAllMethod" /> 
        <aop:after method="printTime" pointcut-ref="addAllMethod" /> 
       </aop:aspect> 
      </aop:config>
     </body>
    </html>

      如果一个切入点要执行多个方法,可以通过order属性定义横切关注点的顺序。

    3.4.4 动态代理

          在程序运行时,运用反射机制动态创建而成。

    动态代理的作用:

           主要用来做方法的增强,让你可以在不修改源码的情况下,增强一些方法,在方法执行前后做任何你想做的事情(甚至根本不去执行这个方法),因为在InvocationHandler的invoke这个方法中,你可以直接获取正在调用方法对应的Method对象,具体应用,比如,添加日志,做事物控制等。 

    4 Spring MVC                                    

    4.1 SpringMVC介绍

    是什么?

    提供了一个经典架构MVC(Model-View-Controller),使程序分层,既相互独立,又协同工作。

    View视图层:为用户提供UI,重点关注数据的呈现,负责布局问题;

    Model模型层:业务数据的信息标识,关注支撑业务的信息构成,通常是多个业务实体的组合;负责需要将什么信息展示给用户。

    Controller控制层:通过调用业务逻辑产生合适的数据Model,传递数据给视图层用于呈现,负责调用哪些业务逻辑。

    干什么的?

    MVC的本质,及其核心思想就是业务数据抽取业务数据呈现相分离。

    4.2 原理过程

                          

    Spring MVC框架,主要利用中央控制器DispatcherServlet完成客户端发送的请求。

    SpringMVC的工作原理:

            1、客户端发出一个http请求给web服务器,web服务器对http请求进行解析,如果匹配DispatcherServlet的请求映射路径(在web.xml中指定),web容器将请求转交给DispatcherServlet.

            2、DipatcherServlet接收到这个请求之后将根据请求的信息(包括URL、Http方法、请求报文头和请求参数Cookie等)以及HandlerMapping的配置找到处理请求的处理器(Handler)。

           3-4、DispatcherServlet根据HandlerMapping找到对应的Handler,将处理权交给Handler(Handler将具体的处理进行封装),再由具体的HandlerAdapter对Handler进行具体的调用。

            5、Handler对数据处理完成以后将返回一个ModelAndView()对象给DispatcherServlet,为页面呈现做准备。

            6、Handler返回的ModelAndView()只是一个逻辑视图并不是一个正式的视图,DispatcherSevlet通过ViewResolver将逻辑视图转化为真正的视图View。

            7、Dispatcher通过model解析出ModelAndView()中的参数进行解析最终展现出完整的view并返回给客户端。

    4.3 写 MVC类

    写一个Spring MVC框架的Controller类:

    @Controller
    @RequestMapping ( "/test" )
    public class MyController {
        @Autowaired
        private DAO dao; 
        @RequestMapping ( "/showView" )
        public ModelAndView showView() {
           ModelAndView modelAndView = new ModelAndView();
           modelAndView.setViewName( "viewName" );
           modelAndView.addObject( " 需要放到 model 中的属性名称 " , " 对应的属性值,它是一个对象 " );
           return modelAndView;
        }
       @RequestMapping ( "/func" )
       public void func(@RequestParam(value="id")  int id) {
           //operation……
        }
    
    }

        有几个地方需要注意:@Controller   @Autowaired    @RequestMapping ( "/showView" )    @RequestParam  等这些注解、路径格式、路参绑定等都需要写出来。

       有的面试官会让写现场撸代码,不过他们会让你写经典常用的代码,比如写一个Servlet,写一个Controller,写一个Singleton单例,笔者就曾经遇到了类似的题目。

    4.4 Struts2框架

             Struts2框架是一个轻量级的MVC流程框架,轻量级是指程序的代码不是很多,运行的时候占用的资源不是很多,MVC流程框架就是说它支持分层开发,控制数据的流程。

    升级的改善:

    Struts1的缺点:

    1.struts框架基于servlet进行开发的,所以servlet的问题在这个框中都能体现出来

    2.struts框架的流程是固定的,想要扩展业务流程非常的不方便。

    3.只支持动态视图JSP展现数据,对于现在的SEO(搜索引擎优化)支持不好

    Struts2框架改善的地方:

    1.核心基于Filter

    2.流程可以动态扩展

    3.多例创建对象

    4.支持多种视图展现技术(JSP,Freemarker,Volicity)

    4.6 Struts2和SpringMVC的区别

    1. 机制:spring mvc的入口是servlet,而struts2是filter,这样就导致了二者的机制不同。

    2. 性能

          spring会稍微比struts快。spring mvc是基于方法的设计,而sturts是基于类,每次发一次请求都会实例一个action,每个action都会被注入属性,而spring基于方法,粒度更细,但要小心把握像在servlet控制数据一样。spring3mvc是方法级别的拦截,拦截到方法后根据参数上的注解,把request数据注入进去,在spring3 mvc中,一个方法对应一个request上下文。而struts2框架是类级别的拦截,每次来了请求就创建一个Action,然后调用setter getter方法把request中的数据注入;struts2实际上是通 setter getter方法与request打交道的;struts2中,一个Action对象对应一个request上下文。 

    3. 参数传递:struts是在接受参数的时候,可以用属性来接受参数,这就说明参数是让多个方法共享的。

    4. 设计思想上:struts更加符合oop(面向对象编程)的编程思想, spring就比较谨慎,在servlet上扩展。  

    5. intercepter的实现机制

            struts有自己的interceptor机制,spring mvc用的是独立的AOP方式。这样导致struts的配置文件量还是比spring mvc大,虽然struts的配置能继承,所以我觉得论使用上来讲,spring mvc使用更加简洁,开发效率SpringMVC确实比struts2高。spring mvc是方法级别的拦截,一个方法对应一个request上下文,而方法同时又跟一个url对应,所以说从架构本身上spring3 mvc就容易实现restful url。struts2是类级别的拦截,一个类对应一个request上下文;实现restful url要费劲,因为struts2action的一个方法可以对应一个url;而其类属性却被所有方法共享,这也就无法用注解或其他方式标识其所属方法了。spring3 mvc的方法之间基本上独立的,独享requestresponse数据,请求数据通过参数获取,处理结果通过ModelMap交回给框架方法之间不共享变量,而struts2搞的就比较乱,虽然方法之间也是独立的,但其所有Action变量是共享的,这不会影响程序运行,却给我们编码,读程序时带来麻烦。 

            另外,spring3 mvc的验证也是一个亮点,支持JSR303,处理ajax的请求更是方便,只需一个注解@ResponseBody,然后直接返回响应文本即可。

    5 Mybatis

    5.1 Mybatis简介

    是什么,干什么用的?

             mybatis是一个优秀的基于java的持久层框架,它内部封装了jdbc,使开发者只需关注sql本身,而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。

            mybatis通过xml注解的方式将要执行的各种statement配置起来,并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句,最后由mybatis框架执行sql并将结果映射为java对象并返回,消除了几乎所有的JDBC代码参数的手工设置结果集的检索

            主要用来通过XML配置或注解提供一种Java Bean和数据库记录的ORM映射。

    什么是hibernate?

           hibernate是数据访问层的框架,对jdbc进行了封装,可以直接访问对象,hibernate自动将此访问转换为sql执行,从而达到间接访问数据库的目的,简化了数据访问层的代码开发。

    hibernate和mybatis对比:

          共性:采用ORM思想解决了实体和数据库映射的问题,对jdbc进行了封装,屏蔽了jdbc api底层访问细节,使我们不用与jdbc api打交道,就可以完成对数据库的持久化操作。

        Hibernate是全自动化ORM的映射工具,Mybatis实现业务代码和SQL的分离采用了面向接口编程的技术,是一种半自动化的映射工具,接口中定义的方法(方法返回类型,方法名,方法参数)对应了配置文件dao.xml中对应的SQL执行返回类型、SQL配置名称、传输参数。

    5.2 设计思想、实现原理?

    5.3优缺点?

    1.sql语句与代码分离,存放于Dao.xml配置文件中;

    优点:便于维护管理,不用在java代码中找这些语句;

    缺点: JDBC方式可以用用打断点的方式调试,但是Mybatis不能,需要通过log4j日志输出日志信息帮助调试,然后在配置文件中修改。

    2.用逻辑标签控制动态SQL的拼接

    优点:用标签代替编写逻辑代码;

    缺点:拼接复杂SQL语句时没有代码灵活,拼写比较复杂。不要使用变通手段来应对这种复杂的语句。

    3.查询的结果集与java对象自动映射

    优点:保证名称相同,配置好映射关系即可自动映射或者,不配置映射关系,通过配置列名=字段名也可完成自动映射。

    缺点:对开发人员所写的SQL依赖很强。 

    4.编写原声SQL

    优点:接近JDBC,比较灵活。

    缺点:对SQL语句依赖程度很高;并且属于半自动,数据库移植比较麻烦,比如mysql数据库编程Oracle数据库,部分的sql语句需要调整。

    5.4 Mybatis和Hibernate比较

    两者相同点

           Hibernate与MyBatis都可以是通过SessionFactoryBuider由XML配置文件生成SessionFactory,然后由SessionFactory 生成Session,最后由Session来开启执行事务和SQL语句。其中SessionFactoryBuider,SessionFactory,Session的生命周期都是差不多的。

           Hibernate和MyBatis都支持JDBC和JTA事务处理。

    Mybatis优势

          MyBatis可以进行更为细致的SQL优化,可以减少查询字段。

          MyBatis容易掌握,而Hibernate门槛较高。

    Hibernate优势

          Hibernate的DAO层开发比MyBatis简单,Mybatis需要维护SQL和结果映射。

          Hibernate对对象的维护和缓存要比MyBatis好,对增删改查的对象的维护要方便。

          Hibernate数据库移植性很好,MyBatis的数据库移植性不好,不同的数据库需要写不同SQL。

          Hibernate有更好的二级缓存机制,可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。

    他人总结

           Hibernate功能强大,数据库无关性好,O/R映射能力强,如果你对Hibernate相当精通,而且对Hibernate进行了适当的封装,那么你的项目整个持久层代码会相当简单,需要写的代码很少,开发速度很快,非常爽。 

           Hibernate的缺点就是学习门槛不低,要精通门槛更高,而且怎么设计O/R映射,在性能和对象模型之间如何权衡取得平衡,以及怎样用好Hibernate方面需要你的经验和能力都很强才行。 

          iBATIS入门简单,即学即用,提供了数据库查询的自动对象绑定功能,而且延续了很好的SQL使用经验,对于没有那么高的对象模型要求的项目来说,相当完美。 

          iBATIS的缺点就是框架还是比较简陋,功能尚有缺失,虽然简化了数据绑定代码,但是整个底层数据库查询实际还是要自己写的,工作量也比较大,而且不太容易适应快速数据库修改。

    展开全文
  • SAAS云应用近几年来越来越火,这得益于国内云计算的基础设施的发展,如以前我们开发应用所需要的硬件计算资源、平台的操作系统、互联网IP、带宽及域名等,均可以非常有效解决了,企业建设应用或平台,不再需要考虑...
  • 系统架构图   目标:  1:提升开发效率,规范开发... 易上手的框架 兼容性:  1:设备:兼容IPAD,手机,电脑,笔记本等等  2:界面:兼容IE8+,firefox,google等等  3:数据库:兼容MySQL,oracel,sqlserv...
  • java开源持久层框架

    千次阅读 2018-07-25 10:38:17
    Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端...
  • infoglue是一个高级的、可扩展的、健壮的内容管理系统,完全用Java开发。重要的功能包括完全支持多语言,站点之间良好的重用,以及广泛的集成能力。 该项目主页: http://www.infoglue.org 2.Magnolia Magnolia是一...
  • Android开发常用开源框架

    万次阅读 多人点赞 2016-10-23 12:41:20
    Android开发常用开源框架2 Android开发常用开源框架3 2017年伊始,你需要尝试的25个Android第三方库 Android开发常用第三方平台 免费的计算机编程类中文书籍 free-programming-books Mark!Android最佳的开源库集锦 ...
  • Java开源框架学习初体验

    千次阅读 2005-12-07 16:26:00
    Java开源框架学习初体验 ---献给那些不知道struts为何物的朋友们 email:gmxsmail@yahoo.com.cn 在当今企业平台开发中JAVA是领先技术。由于管理需要越来越多的技术,复杂的结构似乎爆炸式的增长,留下了大师们没有...
  • java topo: 开源jtopo框架

    千次阅读 2016-07-20 10:46:01
    java web 非本人研究方向,只是作为拓展知识涉猎范围 原文链接:http://www.jtopo.com/index.html jTopo是什么?...jTopo(Javascript ...jTopo关注于数据的图形展示,它是面向开发人员的,需要进行二次开发
  • Java源码 JavaWeb开发框架 代码 SSH SSM OA ERP CRM Java项目 功能简介:  A、代码生成器(开发利器)  生成Java各层次的类和JSP等文件,提高开发效率  B、阿里巴巴数据库连接池Druid  ...
  • Java开源框架学习初体验 (转)

    千次阅读 2008-05-21 01:17:00
    Java开源框架学习初体验---献给那些不知道struts为何物的朋友们作者:弓明弦 (hotcoffee12)email:gmxsmail@yahoo.com.cn在当今企业平台开发中JAVA是领先技术.由于管理需要越来越多的技术,复杂的结构似乎爆炸式的增长,...
  • 学习Java开源框架前你应该了解的

    千次阅读 2016-04-21 15:50:56
     一是Java的反射机制和自省机制。大部分框架都用到这两种机制,因为它们都要实现通过配置文件自动完成类的识别和加载,所以必须要使用反射和自省。尤其是自省机制,对于大家了解JSP中的一些知识也是很有帮助的。...
  • 5款Java微服务开源框架

    万次阅读 2019-01-18 20:58:08
    开源地址: https://gitee.com/log4j/pig 基于Spring Cloud、OAuth2.0、Vue的前后端分离的系统。 通用RBAC权限设计及其数据权限和分库分表 支持服务限流、动态路由、灰度发布、 支持常见登录方式, 多系统SSO登录, ...
  • java开源

    千次阅读 2014-11-29 23:29:45
    一、JavaWeb开源 快速开发框架(包括前端UI和后端) 1、g4studio  G4Studio是一套基于JavaEE、面向小微型软件企业的免费开源产品套件... G4Studio行业应用二次快速开发平台基于JavaEE技术体系,面向中小软件企业。以
  • WebGIS二次开发控件制作实例(OpenLayers+Jquery EasyUI),Openlayers是一个开源、纯JS、面向对象、轻量级的Web地理信息框架;具有可读性强:赠送全套源代码,源代码所有变量名遵循Java命名规范,全局变量、函数和...
  • java 工作流开发框架比较

    千次阅读 2014-08-07 15:58:03
    它是另一款遵循WfMC的XPDL标准开源工作流引擎,并且同时遵循OMG组织的Workflow Management Facility规范。在所有开源工作流引擎中,Shark的体系最为完备和复杂。其一直秉承着“模块化”的思想,所以比较容易扩展。...
  • JAVA后端主流开发框架

    千次阅读 2020-07-18 21:12:10
    JavaWeb专业版,企业级开发框架SpringBoot+Layui+Thymeleaf+MybatisPlus开发权限(RBAC)及内容管理框架框架中集成了权限管理、模块管理,数据库管理、富文本编辑器(已集成ueditor,kindeditor),后台支持多主题切换、...
  • 1.安装git服务: ...   2.打开github官网: https://github.com/ ...3.输入自己需要检索的关键字 ...注:adminlte、easyui等是前端的框架 ...java开发的同学搜索:spring 微信开发的同学搜索:vxss、wxml、js ...
  • 最近需要做一个类似于网贷之家http://www.wangdaizhijia.com/ 这样的信息资讯门户网站,最好是基于ssh框架的,找一个这样开源的资讯门户系统进行二次开发,请问有推荐的吗,重谢!
  • java基础设计 开源框架

    千次阅读 2007-09-12 22:30:00
    有关java各种框架的基础设计,笔者经验之谈,算是小结吧!:)一,Hibernate部分1,简述hibernate映射继承关系和映射组成关系有何异同?映射继承关系:类和类之间除了关联和聚集关系外,还可以有继承关系。什么时候需要映射...
  • Java开源模板引擎

    万次阅读 2017-12-29 11:59:02
    Velocity  Velocity是一个基于java的... 当Velocity应用于web开发时,界面设计人员可以和java程序开发人员同步开发一个遵循MVC架构的web站点,也就是说,页面设计人员可以只关注页面的显示效果,而由java程序
  • 深度学习的开源Java ML框架

    千次阅读 2017-11-01 09:18:10
    作为开发人员,我们习惯从用命令或函数的角度来思考问题。程序由任务组成,每个任务都包含一些编程结构。神经网络不同于这种编程方法,因为它加入了自动任务改进的概念,或者类似于大脑的学习和改进的能力。换句话说...
  • IoT开源平台Thingsboard二次开发研究

    万次阅读 2019-10-25 14:27:35
    ThingsBoard 二次开发指南 参考资料 [TB官方文档(英文)](https://thingsboard.io/docs/) [Protobuf的讲解](https://www.ibm.com/developerworks/cn/linux/l-cn-gpb/index.html) 概述 1 整个ThingsBoard的代码中...
  • springboot快速开发框架,适合二次开发(一)

    万次阅读 多人点赞 2018-12-24 15:34:04
    1、项目名称:分布式敏捷开发系统架构   项目简介:基于 Spring + SpringMVC + Mybatis 分布式敏捷开发系统架构,提供整套公共微服务服务模块:集中权限管理(单点登录)、内容管理、支付中心、用户管理(支持...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 112,459
精华内容 44,983
关键字:

java开源二次开发框架

java 订阅