精华内容
下载资源
问答
  • 本文仅介绍golang web开发框架httprouter在开发简单的REST API f服务器上的使用,golang开发工具等。 本文要点: 1. golang http包的介绍 2. curl http协议分析工具的介绍和使用 3. ab开发压力测试工具的介绍...

    本文仅介绍golang web开发框架httprouter在开发简单的REST API f服务器上的使用,golang开发工具等。

    本文要点:
    1. golang http包的介绍
    2. curl http协议分析工具的介绍和使用
    3. web开发框架 httprouter的介绍和使用
    4. ab开发压力测试工具的介绍和使用

    学习前提
    1.了解http的基础知识
    2.了解“C/S架构”知识
    3.了解golang中接口的用法

    1. golang http包的介绍

    HTTP是互联网上应用最为广泛的一种网络协议,定义了客户端和服务端之间请求与响应的传输标准。
    Go lang标准库內建提供了net/http包,涵盖了HTTP客户端和服务端的具体实现,使用net/http包,我们可以很方便地编写HTTP客户端和服务端程序。

    1.1、HTTP客户端

    说起请求数据, 你最先想到的是拿东西,我们来看看golang的net/http包中GET方法的原型和使用

    func (c *Client)Get(url string) (r *response, err error) 

    要求请求一个资源只需要调用http.Get()方法

    res, err := http.Get("http://example.com/")
    
    if err != nil {
        //handle error
        return
    }
    
    defer res.Body.close()
    //output to standard output stream
    io.Copy(os.Stdout, res.Body)
    ...

    当然拿了别人的东西,我们也不会忘记还回去,golang以POST方式发送数据也很简单。

    func (c *Client) Post(url string, bodyType string ,body io.Reader) (r *Response, err error)

    第一个参数是目标URL,第二个参数是POST数据的资源类型(MIMETYPE),第三个是数据的比特流(以[]byte形式)。比如我们要上传一张图片,就可以像下面这样写。

    res, err := http.Post("http://example.com/upload", "image/jpeg", &imageDataBuf)
    
    if err != nil {
        // handle error
        return
    }
    
    if res.StatusCode != http.StatusOK {
        // handle error
        return
    }
    ...

    在web开发中,经常离不开表单提交,golang的net/http包则很好地封装了表单提交的方法,http.PostForm()就很好地实现了标准编码格式为application/x-www-form-urlencoded的表单提交,比如我们要提交一篇新文章。

    res, err := http.PostForm("http://example.com", url.Values{"title":{"article title"}, "content":{"article body"}})
    
    if err != nil {
        //handle error
        return
    }
    ...

    此外,还有请求的头部信息,( *http.Client)http.Head(),更优雅地定制你的请求,( *http.Client)http.Do(),好了,少年,自己去探索吧。

    然而如果你觉得上面的这些方法能满足你的需求,那么你就太容易满足了,而golang就是这么不想让你满足,一个自称“简单,简单,简单”的语言,怎么能轻易放弃?

    除了上述介绍的基本的HTTP操作外,golang标准库也暴露了比较底层的HTTP相关库,让开发者可以基于这些库灵活地定制HTTP服务器和使用HTTP服务。

    所以有没有更高级的高级封装?

    前面使用的基本方法实际上都是基于http.DefaultClient进行调用的,比如http.Get()等价于http.DefaultClient.Get(),所以呢?既然存在默认的Client,是不是就存在不默认的Client?那是必须的!

    client := &http.Client{
            Transport: &http.Transport{
                Dial: func(netw, addr string) (net.Conn, error) {
                    deadline := time.Now().Add(25 * time.Second)
                    c, err := net.DialTimeout(netw, addr, time.Second*20)
                    if err != nil {
                        return nil, err
                    }
                    c.SetDeadline(deadline)
                    return c, nil
                },
            },
        }

    但是您需要一点尝试的勇气,如果没有,请找梁静茹。

    给你个眼(链)神(接),自己去体会:https://studygolang.com/articles/253

    1.2 服务端

    也讲讲HTTP服务端技术吧。

    net/http包提供的http.ListenAndServe()方法,可以在指定的地址进行监听,开启一个HTTP服务,服务端该方法的原型如下:

    func ListenAndServe(addr string, handler Handler) error

    该方法用于在指定的TCP网络地址addr进行监听,然后调用服务端处理程序传处理传入的请求。第一个参数是监听地址,第二个参数是服务端的处理程序,一般为nil,这意味这服务端调用http.DefaultServeMux(既然存在默认,是不是也就存在不默认呢?哈哈),而服务端编写的业务逻辑处理程序http。Handle()或者http.HandleFunc()默认注入http.DefaultServeMux中,具体的代码如下:

    func handIt(w http.ResponseWriter, r *http.Request) {
        fmt.Printf(w, "hello %q", html.EscapeString(r,URL.Path))
    }
    
    http.Handle("/path",pathHandler)
    
    http.HandleFunc("/path1", handIt)
    
    log.Fatal(http.ListenAndServe(":8080",nil))
    ...

    说了既然有默然就会有自定义。
    可以通过自定义更多地控制服务端的行为。

    s := http,Serve {
        Addr: ":8080"
        Handler: myHandler,
        ReadTimeout: 10*time.Second
        WriteTimeout: 10*time.Second
        MaxHeaderByte: 1 << 10
    }
    log.Fatal(s.ListenAndServe())
    ...

    OK,优雅使用!对于golang的net/http包,您还有什么不满意?


    2. curl http协议分析工具的介绍和使用

    curl是个什么东西?以前似乎没听过?╮(╯▽╰)╭,没关系,百度一下不就好,百度又没被墙,您说是不是啊。

    curl是利用URL语法在命令行方式下工作的开源文件传输工具。它被广泛应用在Unix、多种Linux发行版
    中,并且有DOS和Win32、Win64下的移植版本。

    百度了也看不懂。没关系,先找个教程照着做,用了再说也不迟。

    墙裂推荐潘大神的这篇博客:http://blog.csdn.net/pmlpml/article/details/78404838

    我们写个小东西测试一下:

    package main
    
    import (
        "fmt"
        "log"
        "net/http"
        "github.com/julienschmidt/httprouter"
    )
    
    func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
        fmt.Fprint(w, "welcome!\n")
    }
    
    func main() {
        router := httprouter.New()
        router.GET("/", Index)
        log.Fatal(http.ListenAndServe(":8080", router))
    }

    看一下输出了些什么?

    -v 是什么东西?

    不如逛逛小花园?http://www.cnblogs.com/sunada2005/p/3829772.html

    sysuygm@localhost:~$ curl -v http://localhost:8080/
    *   Trying 127.0.0.1...
    * Connected to localhost (127.0.0.1) port 8080 (#0)
    > GET / HTTP/1.1
    > Host: localhost:8080
    > User-Agent: curl/7.47.0
    > Accept: */*
    > 
    < HTTP/1.1 200 OK
    < Date: Wed, 08 Nov 2017 02:57:33 GMT
    < Content-Length: 9
    < Content-Type: text/plain; charset=utf-8
    < 
    welcome!
    * Connection #0 to host localhost left intact
    sysuygm@localhost:~$ ^C
    

    3. web开发框架 httprouter的介绍和使用

    正如潘大神所说,每个人都有一颗做框架的心呐,您说是不是啊?除了net/http提供强大工具以外,您可能会在web服务器开发上陷入选择困难症,反正我是这样的。至于httprouter有什么独特的风骚,这个我也说不出来。这个也许能给您答案:http://blog.csdn.net/real_myth/article/details/76161540

    不管怎么样,先用了再说。二不多说,上码为敬。

    一个简单的RESTful API:

    package main
    
    import (
        "encoding/json"
        "fmt"
        "log"
        "net/http"
    
        "github.com/julienschmidt/httprouter"
    )
    // path为 ‘/’的handler 
    func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
        fmt.Fprint(w, "welcome!\n")
    }
    // 请求获取的实体
    type Book struct {
        ISDN   string "'json':'isdn'"
        Title  string "'json':'title'"
        Author string "'json':'author'"
        Pages  int    "'json':''pages"
    }
    //响应时返回的数据 Data
    type JsonResponse struct {
        Meta interface{} "json:'status'"
        Data interface{} "json:'data'"
    }
    //请求错误的响应处理
    type JsonErrorResponse struct {
        Error *ApiError "json:'error'"
    }
    
    type ApiError struct {
        Status int16  "json:'status'"
        Title  string "json:'title'"
    }
    
    var bookstore = make(map[string]*Book)
    
    // path为 ‘/books’的handler 
    
    func BookIndex(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
        books := []*Book{}
        for _, book := range bookstore {
            books = append(books, book)
        }
        response := &JsonResponse{Data: &books}
        w.Header().Set("Content-Type", "application/json;charset=UTF-8")
        w.WriteHeader(http.StatusOK)
        if err := json.NewEncoder(w).Encode(response); err != nil {
            panic(err)
        }
    }
    // path为 ‘/books/:json’的handler 
    func BookShow(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
        isdn := params.ByName("isbn")
        book, ok := bookstore[isdn]
        w.Header().Set("Content-Type", "application/json;charset=UTF-8")
        if !ok {
            w.WriteHeader(http.StatusNotFound)
            response := JsonErrorResponse{Error: &ApiError{Status: 404, Title: "Record Not Found"}}
            if err := json.NewEncoder(w).Encode(response); err != nil {
                panic(err)
            }
        }
        response := JsonResponse{Data: book}
        if err := json.NewEncoder(w).Encode(response); err != nil {
            panic(err)
        }
    }
    
    
    func main() {
        router := httprouter.New()
        router.GET("/", Index)
        router.GET("/books/", BookIndex)
        router.GET("/books/:json", BookShow)
        //测试数据
        bookstore["123"] = &Book{
            ISDN:   "123",
            Title:  "Silence of the Lambs",
            Author: "Thomas Harris",
            Pages:  367,
        }
        //测试数据
        bookstore["124"] = &Book{
            ISDN:   "124",
            Title:  "tO KILL a mocking bird",
            Author: "Thomas Harris",
            Pages:  320,
        }
        log.Fatal(http.ListenAndServe(":8080", router))
    }
    

    有本事自己看英文去:https://medium.com/@gauravsingharoy/build-your-first-api-server-with-httprouter-in-golang-732b7b01f6ab


    4 . ab开发压力测试工具的介绍和使用

    Apache的ab命令模拟多线程并发请求,测试服务器负载压力,也可以测试nginx、lighthttp、IIS等其它
    Web服务器的压力。

    对上面写的简单服务器进行压力测试,看看输出些什么?

    特别注意页面响应所消耗的时间和流量!

    sysuygm@localhost:~$ ab -n 1000 -c 100 http://localhost:8080/books
    This is ApacheBench, Version 2.3 <$Revision: 1706008 $>
    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
    Licensed to The Apache Software Foundation, http://www.apache.org/
    
    Benchmarking localhost (be patient)
    Completed 100 requests
    Completed 200 requests
    Completed 300 requests
    Completed 400 requests
    Completed 500 requests
    Completed 600 requests
    Completed 700 requests
    Completed 800 requests
    Completed 900 requests
    Completed 1000 requests
    Finished 1000 requests
    
    
    Server Software:        
    Server Hostname:        localhost
    Server Port:            8080
    
    Document Path:          /books
    Document Length:        42 bytes
    
    Concurrency Level:      100
    Time taken for tests:   0.055 seconds
    Complete requests:      1000
    Failed requests:        0
    Non-2xx responses:      1000
    Total transferred:      192000 bytes
    HTML transferred:       42000 bytes
    Requests per second:    18234.20 [#/sec] (mean)
    Time per request:       5.484 [ms] (mean)
    Time per request:       0.055 [ms] (mean, across all concurrent requests)
    Transfer rate:          3418.91 [Kbytes/sec] received
    
    Connection Times (ms)
                  min  mean[+/-sd] median   max
    Connect:        0    1   0.7      1       4
    Processing:     0    4   5.5      2      25
    Waiting:        0    3   5.3      1      23
    Total:          2    5   5.4      3      27
    
    Percentage of the requests served within a certain time (ms)
      50%      3
      66%      3
      75%      4
      80%      5
      90%     19
      95%     21
      98%     23
      99%     23
     100%     27 (longest request)
    
    sysuygm@localhost:~$ ab -n 1000 -c 100 http://localhost:8080/books/:json
    This is ApacheBench, Version 2.3 <$Revision: 1706008 $>
    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
    Licensed to The Apache Software Foundation, http://www.apache.org/
    
    Benchmarking localhost (be patient)
    Completed 100 requests
    Completed 200 requests
    Completed 300 requests
    Completed 400 requests
    Completed 500 requests
    Completed 600 requests
    Completed 700 requests
    Completed 800 requests
    Completed 900 requests
    Completed 1000 requests
    Finished 1000 requests
    
    
    Server Software:        
    Server Hostname:        localhost
    Server Port:            8080
    
    Document Path:          /books/:json
    Document Length:        78 bytes
    
    Concurrency Level:      100
    Time taken for tests:   0.035 seconds
    Complete requests:      1000
    Failed requests:        0
    Non-2xx responses:      1000
    Total transferred:      207000 bytes
    HTML transferred:       78000 bytes
    Requests per second:    28743.89 [#/sec] (mean)
    Time per request:       3.479 [ms] (mean)
    Time per request:       0.035 [ms] (mean, across all concurrent requests)
    Transfer rate:          5810.53 [Kbytes/sec] received
    
    Connection Times (ms)
                  min  mean[+/-sd] median   max
    Connect:        1    1   0.4      1       3
    Processing:     0    2   0.6      2       4
    Waiting:        0    1   0.5      1       4
    Total:          2    3   0.8      3       7
    
    Percentage of the requests served within a certain time (ms)
      50%      3
      66%      3
      75%      3
      80%      3
      90%      4
      95%      5
      98%      6
      99%      6
     100%      7 (longest request)
    sysuygm@localhost:~$ 
    

    觉得好用,就赶紧入手吧。

    5. 拓展阅读

    golang的http client源码简析 :https://studygolang.com/articles/5774
    HTTP 协议 与 golang web 应用服务:http://blog.csdn.net/pmlpml/article/details/78404838
    面向对象设计思想与 golang 编程:http://blog.csdn.net/pmlpml/article/details/78326769

    展开全文
  • 如何选择Web开发框架

    千次阅读 热门讨论 2006-06-09 18:01:00
    如何选择Web开发框架 开发框架的选择,始终是个仁者见仁、智者见智的事情。尤其是Web层的开发框架,数量非常多,而且各有特色,如:Struts、WebWork、Spring MVC、Tapestry、JSF、WebPage3.0……等等。 下面先来看看...
    如何选择Web开发框架 
    开发框架的选择,始终是个仁者见仁、智者见智的事情。尤其是Web层的开发框架,数量非常多,而且各有特色,如:Struts、WebWork、Spring MVC、Tapestry、JSF、WebPage3.0……等等。
    下面先来看看为什么要使用Web开发框架

    一:使用框架的必然性
    框架,即framework。其实就是某种应用的半成品,把不同应用程序中有共性的一些东西抽取出来,做成一个半成品程序,这样的半成品就是所谓的程序框架。
    软件系统发展到今天已经很复杂了,特别是服务器端软件,涉及到的知识,内容,问题太多。在某些方面使用别人成熟的框架,就相当于让别人帮你完成一些基础工作,你只需要集中精力完成系统的业务逻辑设计。这样每次开发就不用白手起家,而是可以在这个基础上开始搭建。
    使用框架的最大好处:减少重复开发工作量、缩短开发时间、降低开发成本。同时还有其它的好处,如:使程序设计更合理、程序运行更稳定等。基于这些原因,基本上现在在开发中,都会选用某些合适的开发框架,来帮助快速高效的开发应用系统。
    了解了使用框架的必然性,下面来看看如何选择,当然我们的话题集中在Web层的开发框架。在谈这个问题之前,先来看看我们在Web开发中究竟需要做些什么工作:

    二:Web层开发的工作
    在J2EE开发中,分层是基本的思想,3层架构或者多层架构早已深入人心,在这里我们就把目光集中到Web层,看看到底Web层开发做了那些工作:
    1:数据展示
    Web层需要从逻辑层获取需要展示的数据,然后以合理的方式在页面进行展示
    2:人机交互
    用户需要从界面上输入数据,在界面上进行按钮点击,进而触发事件,标准的事件驱动模型,然后跟后台进行数据交换,出现新的界面。
    3:收集数据,调用逻辑层接口
    Web层收到用户的事件请求,需要调用相应的逻辑层接口来进行处理,Web层是不会有任何逻辑处理的。调用逻辑层接口,需要传递参数,这时需要收集用户在界面上输入的数据,然后进行组织,组织成为逻辑层接口需要的数据封装形式(通常都是ValueObject)。
    4:根据逻辑层的数据来重新展示页面
    逻辑层处理完了,需要返回数据或信息到界面上。这个时候Web层需要根据返回的值选择合适的页面,然后展示这些数据或者信息。

    从上面可以看出,Web层开发的主要工作集中在展示上,也就是图形用户界面。这一部分是用户直观感受应用程序的窗口,也是用户要求最多的地方,其表现形式也是最丰富的。

    三:Web层开发的步骤

    写得手好累啊:) 给点支持,板砖也行啊,如果没人顶就不往下写了,呵呵

    开个玩笑,主要是昨天还没有写完,后续的

    三:Web层开发的步骤
    下面再来总结一下Web层开发的大致步骤(也就是需要开发人员做的工作):
    注意:这里讨论的Web层开发,是不使用任何开发框架时候的开发。

    1:写页面Html,到底有哪些数据需要在界面上表现
    2:每个数据的具体表现形式,如:有的需要表现成为下拉列表,有的需要表现成为单选按钮等。
    3:界面表现形式的逻辑布局,所谓逻辑布局是指某些数据的表现形式应该放在前面,某些应该放在后面;某些放在上面,某些放在下面。如:某个请假申请的业务,有请假开始时间和结束时间,很明显开始时间的表现就应该排在结束时间的前面。而美工是负责最后页面的美观,一般美工不能动界面的逻辑布局。
    4:完成前面3步,页面的表现形式的大致模样就有了,下面需要来做功能性的开发。第一个就是这些表现形式的值的来源,如:下拉列表显示的值从什么地方来。值的来源方式很多,有数据库中来、固定值、某断程序运行的中间结果、前面页面传递过来等等,当然典型的还是来自数据库。
    好了,确定了值的来源,开发人员就要写代码来获取这些值,然后把这些值赋值到对应的表现形式里面。
    5:还有一些比较特殊,也就是真实操作的是一类值,但是在界面上显示的是另一类值,比如:数据库中有用户编号,到了界面上就得显示用户姓名,但是所有的操作都是要操作用户编号的。我们把这种情况分做:真实值和表现值,他们有一定的内在联系。这些都是要开发人员去转化和维护的。
    6:接下来就应该开发功能性的事件响应了。用户点击了某个按钮或者触发了某个事件,首先是客户端:数据检测、客户端事件处理;然后提交到服务端,服务端要获取到客户端提交的数据,然后调用相应的逻辑层接口来响应。当然如何写逻辑层的实现这里就不去谈论了。
    7:逻辑层执行完过后,返回数据和信息到Web层,开发人员还需要写代码去处理,选择哪个页面来显示,如何显示这些数据和信息等。
    8:在整个交互的过程中,还必须考虑到如何控制权限,如:某些数据不能显示,某些数据不能编辑等等;同样还需要考虑到消息的配置和国际化等等。这些功能起源于逻辑层,但是实际的控制要到Web层,这些都需要开发人员来控制。
    9:完成了上面的开发步骤,页面基本的功能开发就告一段落,接下来开发人员需要考虑页面美观的问题了。大家可能会说:“不是有美工吗,还需要开发人员干什么?”。事实上美工多半只能出一个静态页面的美化模版,美工对于一推Java代码和Html的混杂物,多半是没有办法的,更不要说还有一些内容是动态生成的,美工就更不可能搞定了。还是得开发人员上阵,按照美工给的模版,开始添加Css:class、id、style……
    10:完成上面的开发,基本页面的开发工作就完成了,最后的一个步骤就是把各个页面有机的组织起来,开发应用程序的整体应用导航框架,通常就是菜单,然后把各个功能页面跟菜单结合起来,形成一个完整的应用。

    在这里我们省略了开发期反复的调试过程,仅总结开发的步骤。

    四:选择Web开发框架的目的
    了解了如果没有框架,我们需要做的工作,这对选择框架有非常大的帮助。
    框架,直白点说,就是一个半成品,能够帮我们做一些事情的半成品。
    框架的选择,就是看哪个框架最合适,从而减少开发的工作量,提高开发的效率和质量,并有效减少维护的工作量,最终达到节约综合开发成本,获取更多的收益。

    五:选择Web开发框架的标准
    声明:这里所谈的选择Web开发框架的标准,只是我们的总结和一家之言,并不是放之四海而皆准的真理,请根据您的体会客观的看待我们的总结。
    另外:我们这里更多的讨论业务功能性应用程序的Web开发框架。
    1:选择能够对我们的开发过程提供更多、更好帮助的Web开发框架
    2:Web开发框架的学习一定要简单,上手一定要快,没有什么比使用能得到更深的体会。那些动不动就需要半个月或者一个月学习周期的框架,实在是有些恐怖。
    3:一定要能得到很好的技术支持,在应用的过程中,或多或少都会出现这样或者那样的问题,如果不能很快很好的解决,会对整个项目开发带来影响。一定要考虑综合成本,其实这是目前应用开源软件最大的问题,碰到问题除了死肯文档就是查阅源代码,或者是网上搜寻解决的办法,通常一个问题就会导致1-2天的开发停顿,严重的甚至需要一个星期或者更长,一个项目有上这么几次,项目整体的开发成本嗖嗖的就上去了。
    4:Web开发框架结合其他技术的能力一定要强,比如:在逻辑层要使用Spring或者Ejb3,那么Web开发框架一定要能很容易,很方便的与它们进行结合。
    5:Web开发框架的扩展能力一定要强。在好的框架都有力所不及的地方,这就要求能很容易的扩展Web开发框架的功能,以满足新的业务需要。同时要注意扩展的简单性,如果扩展框架的功能代价非常大,还不如不用呢。
    6:Web开发框架最好能提供可视化的开发和配置,可视化开发对开发效率的提高,已经得到业界公认。
    7:Web开发框架的设计结构一定要合理,应用程序会基于这个框架,框架设计的不合理会大大影响到整个应用的可扩展性。
    8:Web开发框架一定要是运行稳定的,运行效率高的。框架的稳定性和运行效率直接影响到整个系统的稳定性和效率。
    9:Web开发框架一定要能很好的结合目前公司的积累。在多年的开发中已有了很多积累,不能因为使用Web开发框架就不能再使用了,那未免有些得不偿失。
    10:选择开发框架另外要注意的一点就是:任何开发框架都不可能是十全十美的,也不可能是适应所有的应用场景的,也就是说任何开发框架都有它适用的范围。所以选择的时候要注意判断应用的场景和开发框架的适用性。


    展开全文
  • web开发框架详解

    千次阅读 2017-05-29 12:15:36
    随着这个问题的深入,再加以现在公司很多web项目的控制层的技术框架由struts2迁移到springMVC,我突然有了一个新的疑问无法得到正确的解释,为什么我们现在做java的web开发,会选择struts2或者springMVC这样的框架,...

    今年我一直在思考web开发里的前后端分离的问题,到了现在也颇有点心得了,随着这个问题的深入,再加以现在公司很多web项目的控制层的技术框架由struts2迁移到springMVC,我突然有了一个新的疑问无法得到正确的解释,为什么我们现在做java的web开发,会选择struts2或者springMVC这样的框架,而不是使用servlet加jsp这样的技术呢?特别是现在我们web的前端页面都是使用velocity这样的模板语言进行开发,抛弃了jsp,这样的选择又会给我们java的web开发带来什么样的好处,延着这个问题的思路,我又发现新的疑问,为什么现在很多java企业级开发都会去选择spring框架,spring框架给我们开发的应用带来了什么?这么一想还真是问倒我了,我似乎很难找到一串能让人完全信服的答案,最终我发现,这些我认为我很熟悉很常用的技术,其实还有很多让我陌生不解的地方,这些陌生和不解的地方也正是我是否能更高层次使用它们的关键,今天这篇文章我就来讲讲这些问题,不过struts2,spring这样的技术经过这么多年的积累已经是相当庞大和复杂,它们的面很广,本人虽然已经用了它们多年,还是有很多技术不熟悉和不清楚,所以本文不是全面对我题目做出解答的文章,而是根据我现有知识结构来理解这个问题。

    软件里有很多优秀的框架,有一种类型的框架,它的特点是建立在一个现有技术的基础上,提供和现有技术一样业务功能的技术框架,这个新的技术框架比原技术更加易用,更加健壮同时功能更加强大,例如:jQuery,以及本文所要谈到的struts2和springMVC,深究这些框架都是相当之复杂,但是它们的优点其实只有一个:就是让使用者只关心核心业务的开发,框架帮你屏蔽原有技术跟业务开发无关的各类技术问题。像jQuery,struts2或springMVC这类框架之所以优秀,就是它们在这点上做的太好了,以至于很多使用它的程序员都已经不清楚原有技术的真实面目,因此我们要将struts2理解的更好,使用的更加熟练和深入,这里我们就要跳出struts2的技术,到struts2技术的源头servlet,仔细研究下servlet的特点,只有这样我们才能把struts2框架学的更好。

    Servlet的作用是接收浏览器传给服务端的请求(request),并将服务端处理完的响应(response)返回给用户的浏览器,浏览器和服务端之间通过http协议进行沟通,其过程是浏览器根据用户的选择将相关信息按http协议报文的规范组装请求的http报文,报文通过网络传输到指定的服务器,服务器通过特定的web容器接收这个报文信息,例如:tomcat,jetty,jboss这样的web容器,web容器会将http报文解析出来,如果是用户请求,最终解析出来的报文信息会用一个request对象存储起来,服务端使用这个request做完相应的处理后,服务端程序将结果信息封装到response对象里,然后将response对象交给web容器,web容器则把这个response对象转变为http协议的报文,并将报文回传给浏览器,浏览器最后解析这个响应报文,将最终结果展示给用户。

    Web容器创造了servlet接口,servlet接口就是开发人员自己实现业务逻辑的地方,程序员开发servlet就好比做填空题,而填空题的语境或者说上下文提示就是由request和response对象,但是javaEE规范里的servlet接口很简单,就三个方法init,service和destory,但是这个接口太笼统,所以规范里还提供了一个HttpServlet类,这个类根据http请求类型提供了doGet,doPost等方法,servlet接口最大的特点就是根据http协议的特点进行定义,因此做servlet开发时候如果使用者对http协议特点不是特别熟悉,都会碰到或多或少令人迷惑的问题,特别是碰到一些复杂特殊的请求时候:例如文件上传,返回特殊的文件格式到浏览器,这时候使用servlet开发就不是很方便了,servlet开发还有个问题可能大家常常被忽视,就是请求的数据的类型转化,http协议传输都是文本形式,到了web容器解析后也是文本类型,如果碰到货币,数字,日期这样的类型需要我们根据实际情况进行转化,如果页面传送的信息非常多,我们就不得不做大量类型转化,这种工作没有什么技术含量,是个体力活而且很容易导致程序错误。同时java的企业开发都是围绕javabean进行,类型转化好的数据还要封装到对应的javabean里,这种转来转去的事情对于项目开发绝对不是什么好事情,所以古老的struts1为这种问题找到了一种解决方案,就是定义了一个DTO对象(数据传输对象),专门负责做这样的事情,不过到了struts2,整个替代servlet的action本身就是一个javabean。

    Java的企业开发一个技术特点就是使用javabean进行的,struts2的特点之一就是它替代servlet的操作类就是一个典型的javabean,首先struts2框架将页面传输的数据进行类型转化和封装后将请求信息封装到了这个javabean的属性里,这样我们开发web程序时候就省去了烦心的类型转化和封装的问题,前面我讲到传统的servlet是根据http协议进行定义的,它会按你请求方式(post还是get方式)来处理用户的请求,但是对于一名程序开发人员而言,一个请求,具体到一个url,其实对于服务端而言就是服务端对外提供的一个功能,或者说是服务端对外的一个动作,如果我们使用servlet开发程序我们就得把http的动作转化为具体的业务动作,这就让程序开发变得繁琐,增强了开发的难度,所以struts2替代servlet的javabean就屏蔽了servlet里http的请求方式和具体业务动作转化的问题,javabean里的每一个方法都可以和每一个url请求一一对应,这必然减轻了开发的难度问题。

    Servlet另一个作用就是构造response对象,让页面获得正确的响应,其实现代的浏览器是一个多媒体工具,文字,图片,视屏等等东西都可以在浏览器里显示,资源的不同就会导致http响应报文的差别,如果我们使用servlet开发就要根据资源的不同在java程序里用硬编码的形式处理,这样的程序很难复用,而且如果程序员对某种资源的处理理解不到位,就会导致问题的出现,struts2通过配置文件的形式将这样的逻辑从java程序里剥离出来,使用配置的方式进行统一管理,这个做法和spring的AOP方式类似,这样就让结果处理方式更加统一,更加利于管理,同时也提升了程序的健壮性以及降低了开发的难度。

    Servlet在MVC开发模式里就是其中C层即控制层,控制层就像俄罗斯的双头鹰(一个头向东看一个头向西看)一样,一个头向M层模型层看,一个头向V层视图层看,模型层也是用java编写的,控制层也属于服务端语言开发,所以M层和C层的沟通没有天然的障碍,但是和V层视图层就不一样了,这是一个跨语言的沟通,对于浏览器,它只懂得html,javascript和css,浏览器是理解不了java这种语言的东西,但是要让服务端的东西能被浏览器理解接受,我们就必须得把服务端的响应信息放到页面里,因此就需要一个技术把java的信息转化到html页面里,这就是javaEE规范里提供了jsp技术,jsp其实是一种服务端技术而非客户端技术,不过它看起来似乎更像html技术,最早的jsp开发里都是直接将java代码写到页面里,这种坏处谁都知道,之后javaEE规范提供了自定义标签技术,使用一种类似html标签的方式来解析java代码,struts2框架提供了一整套完整的自定义标签技术,这似乎听起来不算啥,但是它的作用非凡,因为自定义标签之所以叫自定义就是每个人都可以自己来定义,如果没有一个规范必然产生混乱,而且一套完善的自定义标签是个系统工程,一套完整的自定义标签相当于我们在自己定义一套新的开发语言,做程序的人听到这个一定就会明白开发一套完整的自定义标签的工作量和开发难度都是难以想象的,而且自定义标签都是和控制层紧密相连,其难度又会增加一个维度,所以struts2提供的自定义标签对于业务开发带来的将是质的飞越。

    Servlet里还有两个重要的技术:监听器和过滤器,对于监听器在web开发里使用的场景比较少,都是一些十分特别的情况才会使用,大部分web开发里可以忽略它的使用,我们用的最多的监听器可能就是对ServletContext创建和销毁的监听器,ServletContext是整个web应用的全局对象,它和Web应用的生命周期绑定在一起,因此使用这个监听器对Web应用的全局信息进行初始化和销毁操作,例如spring容器的初始化操作。比较有意思的是过滤器,在struts2里有个拦截器,它们的作用相同都是用来拦截请求的,因为拦截器是struts2的特有功能,在struts2里使用拦截器自然比使用过滤器更顺手,其实拦截器所用的技术比过滤器更加先进,因为拦截器使用了反射技术,因此拦截器拦截的面更大,控制请求的能力更强,它能完成的任务也会更加的丰富多彩。

    在我第一次接触struts2时候,有人告诉我struts设计的一个目的就是想屏蔽在控制层里操作request和response对象,因为这两个http协议的儿子会造成web开发里思路的混乱,但是我在实际开发里却经常不自觉的使用这两个对象。而且本人做前端开发非常喜欢使用ajax,使用ajax技术时候我就很讨厌struts2的自定义标签,我更加喜欢在页面里用javascript技术处理各种信息,最终struts2在我眼里就是一个servlet的变体,因此曾经有段时间我常常在想是不是可以抛弃struts2,直接用servlet,因为struts2里用到了太多反射机制,特别是使用注解做配置(注解是用反射实现的),在java里反射的执行效率是非常低的,直接使用servlet一定能提升web应用的执行效率。其实这个倒很难做到,因为当时我没法在servlet里灵活的运用spring技术。

    下面我要谈谈spring了。

    spring技术可以说是java企业开发里最重要的技术,不过真的理解spring的作用和意义还真是一件麻烦的事情,很多人对spring理解其实都是停留在使用阶段(例如:声明式事务很好用等等),当今的spring技术生态环境里可谓是蔚为壮观,spring已经包罗万象,它的内容之多完全不亚于它的本源java语言了,而spring这么大的框都是建立在ioc和aop技术之上,只有深入理解了这两个技术我们才能明白为什么spring这个框能装的下那么多东西了。

    首先是ioc,ioc技术第一个解释叫做控制反转,它还有个解释就是依赖注入,这两个名字很难从字面理解,但是当你理解它的原理后就会发现它们的描述是何等准确。Ioc技术的本质就是构建对象的技术换句话说就是将一个类实例化成对象的技术,在java里实例化类通过new关键字进行的,每次new一个类都会产生一个新的实例对象,这么做视乎很浪费,有时这种浪费还挺危险,因为在程序开发时候我们常常只需要某个类永远只能产生一个的实例对象这个时候就得使用单例模式,此外在设计模式里还可以通过工厂方式产生对象,使用过spring的人看到上面的文字就知道了,spring里bean的定义就和上面的内容一一对应,scope属性single产生单例对象,prototype产生新对象,bean还可以通过工厂方式产生对象,可以说spring的bean就是制造对象的工具。面向对象编程里对象相当于显示生活中的一个实体,例如我们有个对象作用是完成打猎的操作,那么打猎这个对象内部包含两个辅助对象:人和枪,只有人和枪赋予了打猎这个对象,那么打猎对象才能完成打猎的操作,但是构建一个人和枪的对象并不是看起来那么简单,这里以枪为例,要创造一把枪我们需要金属,需要机床,需要子弹,而机床和子弹又是两个新对象,这些对象一个个相互嵌套相互关联,大伙试想下如果我们在java代码里构建一个枪的对象那是何其的复杂,假如我们要构造的不是简单的枪对象而是更加复杂的航空母舰,那么构造这个对象的成本之高是让人难以想象的,怎么来消除这种对象相互嵌套相互依赖的关系了?spring提供了一种方式,这种方式就是spring提供一个容器,我们在xml文件里定义各个对象的依赖关系,由容器完成对象的构建,当我们java代码里需要使用某个实例的时候就可以从容器里获取,那么对象的构建操作就被spring容器接管,所以它被称为控制反转,控制反转的意思就是本来属于java程序里构建对象的功能交由容器接管,依赖注入就是当程序要使用某个对象时候,容器会把它注入到程序里,这就叫做依赖注入。在java开发里我们想使用某个类提供的功能,有两种方式,一种就是构造一个新的类,新的类继承该类,另一种方式则是将某个类定义在新类里,那么两个类之间就建立一种关联关系,spring的ioc容器就是实现了这种关联关系(记住不是继承关系哦),那么某个类要被赋予到新类有哪些办法了?一般只有两种:一种就是通过构造函数,一种就是通过setXXX方式,这也是spring容器使用到了两种标准的注入方式。

    不管是上面说的继承方式,还是关联方式其实都是增强目标对象能力的开发手段,在设计模式里有一种代理模式,代理模式将继承模式和关联模式结合在一起使用,代理模式就是继承模式和关联模式的综合体,不过这个综合体的作用倒不是解决对象注入的问题,而是为具体操作对象找到一个保姆或者是秘书,这就和小说里的二号首长一样,这个二号首长对外代表了具体的实例对象,实例对象的入口和出口都是通过这个二号首长,因为具体的实例对象是一号首长,一号首长是要干大事的,所以一些事务性,重复性的工作例如泡茶,安排车子,这样的工作是不用劳烦一号首长的大驾,而是二号首长帮忙解决的,这就是aop的思想,aop解决程序开发里事务性,和核心业务无关的问题,但这些问题对于业务场景的实现是很有必要的,在实际开发里aop也是节省代码的一种方式。

    Spring的核心技术的作用本质就是一个 沟通机制,spring总是尽全力的让沟通的双方信息畅通,同时降低双方的沟通成本,在现实机构里一个善于沟通的人肯定是该公司的领导,很会沟通的领导能调动起各种资源的积极性,善于沟通的领导就会做到海纳百川,让各种不同人追随他,所以当今的spring就是一个大框,什么都可以往里装。

    Spring很像银行,它不能直接创造物质财富,但是一切资源都要通过它进行流通,它能控制经济发展的走向,回到程序的世界,spring的作用是被标榜为程序之间的解耦,spring能降低不同模块之间的耦合度,原因就是在程序开发里不同模块之间信息的沟通是通过对象传递完成的,而对象能否顺利传递就是要合理的构建好对象,而管理好对象的构建方式就能管理好对象传递,这就是spring给系统架构设计带来的好处。

    前端大牛能对后端理解如此,实在是太牛啦。
    ioc和aop是编程思想,放到前端,后端都是一样的。随着前端承担越来越多的业务,必然对ioc和aop有需要,但是究竟这个需要会到哪种程度这很难说。也许会有前端的ioc,Aop框架发展起来。
    我补充一些:

    tomcat容器帮我们解决了从http字符流到HttpServletRequest对象的创建,随后交给servlet处理。随着servlet承载越来越多,越来越复杂的业务,一个doGet,doPost方法,两个request,response对象已远远不能满足需求了。

    struts2,springMVC这些框架为此提供了解决方案:把HttpServletRequest 与JavaBean的一个method建立关系。根据HttpServletRequest 创建对应的JavaBean,生成方法参数对象,同时调用对应的method方法,接收method返回值,最后根据返回值创建HttpServletresponse对象交给容器。

    框架做了这么多,只有一个目的:程序员只需要关心method方法怎么写(后端的mvc还要处理业务逻辑,数据持久化这些问题)。

    以上这些是OOP,IOC,AOP协作一致来降低业务复杂度(解耦)。

    话说回来。如果没有这么高的复杂度,如果不是servlet要承担越来越多的业务,鬼才会搞一个这么复杂的框架呢。

    我觉得这是值得前端借鉴的,如果不是ajax流行,不是js性能的大幅提升,不是前端业务越来越复杂。我想也用不到backbone, avalon这些框架,简单的jsp页面或者velocity模版就能搞定了。
    avalon可能也要融入一些aop的思想。


    我觉得前后端分离最大的问题在于,前后开端开发人员的知识结构差异大,思维方式也有很大差别。
    体现在代码上,前后端的接口就是前端设计的api后端不好实现,后端给的api前端不好用。另外就是前后端的数据结构差异。“定接口”,“改接口”是前后分离后最常遇见的问题。 现在node大行其道,淘宝不是用node搞一个前后分离的框架,让前端人员来编写部分后端代码来解决 “接口”的问题。以前是后端人员兼写前端代码,淘宝这个框架是让前端人中兼写后端代码。是否存在一个中间状态呢?
    如何让前后端的开发人中用同一种思维来设计api,如何解决前后端数据结构对应是值得讨论的。

    参考:https://github.com/RubyLouvre/agate/issues/8

    展开全文
  • 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信息

    展开全文
  • 如何选择Web开发框架(转)

    千次阅读 2007-02-10 21:27:00
    如何选择Web开发框架
  • 基于python的web开发框架-CherryPy

    千次阅读 2008-10-20 22:57:00
    基于python的web开发框架-CherryPy Python满足了我对编程语言的所有渴望,而且更重要的是python一直在发展,而且发展迅速。在web2.0的时候,对web站点的开发也提出了新的需求。现在许多动态语言都提供了相关的开发...
  • 分享超实用的web网页开发框架

    千次阅读 2017-09-14 17:16:57
    使用Web开发框架,可以帮助开发者提高Web应用程序、Web服务和网站等Web开发工作的质量和效率。如果没有这些框架,Web开发工作可能变得复杂和困难,开发者需要去做全部的工作,比如编写业务逻辑、设计用户界面、构建...
  • Java开源 Web开发框架 (三)

    千次阅读 2008-02-03 09:51:00
    Aranea Aranea是一个开源,面向组件,事件驱动的Java MVC Web框架。它提供一种通用简单的方式来构建Web应用程序组件,复用自义定或一般的GUI逻辑,扩展该框架。Aranea强调必须使用POJOs面向对象的技术,并且提供一...
  • Web开发需要服务器端和客户端的配合,在服务器端Java无疑是一个不错的选择,每个服务器的功能都可以写成一个Servlet。客户端除了内容展现的html标记语言之外,还需要实现相关逻辑的脚本语言Javascript无疑是个不错的...
  • Java开源 Web开发框架 (二)

    千次阅读 2008-02-03 09:49:00
    Aurora Aurora是一个开源的...更多Aurora信息 Pustefix Pustefix是一个web应用程序框架.它包含一个基于XML/XSLT的视图生成系统与一个清晰MVC模式的后端系统.前台UI可以利用XSLT模板构建并可包含部分的HTML或XML代码.
  • JFinal是一个基于Java的极速Web开发框架,其核心设计目标是开发迅速、代码量少、学习简单、功能强大、轻量级、易扩展、Restful。 JFinal主要特点: MVC架构,设计精巧,使用简单遵循COC原则,零配置,无...
  • Web开发分层思想

    千次阅读 2017-12-02 15:45:45
    MVC开发模式: M:Model模型 JavaBean&四种作用域...不使用框架,使用JSP+JavaBean+Servlet进行开发 但是在实际开发中,我们进行更为细致的划分: 分层思想:强内聚,弱耦合 整个业务流程是这样的: 浏览器即
  • Web前端开发框架对比

    千次阅读 2018-03-31 00:00:00
    近几年随着 jQuery、Ext 以及 CSS3 的发展,以 Bootstrap 为代表的前端开发框架如雨后春笋般挤入视野,可谓应接不暇。不论是桌面浏览器端还是移动端都涌现出很多优秀的框架,极大丰富了开发素材,也方便了大家的开发...
  • Web前端框架开发入坑指南

    千次阅读 多人点赞 2020-06-18 16:07:17
    都2020年了,尽管 Web 开发的典型应用场景除了将服务器用作平台、浏览器用作客户端之外,几乎很少活跃于其他业务领域,但不可否认 JavaScript 语言和框架的使用已经成为了主流。Angular、React 和 Vue,作为 ...
  • 垂直方向架构 多层架构 分层架构通过程序包或者程序的隔离构建松耦合的应用。我们以最近流行的洋葱架构模型进行分析,如图 领域模型 包括领域实体/存储接口/服务接口,是整个程序的核心。 贫血模型 如果把...
  • SSH Web开发架构分析和实现

    千次阅读 2013-04-03 10:44:38
    摘要:对当前Web应用程序开发面临的问题,结合目前比较流行的开源框架SSH(Spring、Struts、Hibernate),具体讨论其基本相似性及有关基本概念,提出了一种开发J2EE Web应用的轻量级解决方案,以帮助开发人员在短期内...
  • 基于webdriver的web UI自动化测试框架(系统架构+测试脚本应用架构) 自动化测试系统及应用架构
  • Java Web开发构想(4) -- 6. Web框架

    千次阅读 2005-05-31 08:35:00
    6.Web框架Web框架层是一个清洁的楼层。很多优秀的程序员在这一层大展身手,做出了很多好作品。我感觉不错的有Spring MVC, Web Work。对于Web应用来说,Web框架层是最重要的一层。SOA、Semantic Web等效果都要在这一...
  • 即使用了MVC架构模式的思想,将web层进行职责解耦,基于请求驱动指的就是使用请求-响应模型,框架的目的就是帮助我们简化开发,Spring Web MVC也是要简化我们日常Web开发的。   另外还有一种基于组件的、事件...
  • 基于django框架web开发环境搭建

    千次阅读 多人点赞 2020-07-23 21:48:47
    是当前python语言最流行的web框架,django本身是基于MVC的设计模式(有的培训机构介也称MTV模式M-model、V-view、T-templates),这只是名称上的区别,总体设计思想相同的,都实现了低耦合、开发快捷、部署方便、可...
  • Delphi web应用开发框架 - 第一部

    千次阅读 2018-04-05 22:31:48
    框架基于Delphi 10.2.2 +UniGuiv1.0 1397开发,整个脉络采用面向服务的思想,层级为client +appserver + dbserver,今天时间晚了,先放几张截图供朋友参考: ...
  • java web开发为什么要使用框架

    千次阅读 2017-08-11 16:46:43
    转自:... 现在做项目都会使用框架,现在很常见的框架就是SSH(Struts+SpringMVC+hibernate),SSM(Struts/springMVC+Spring+Hibernate), 做项目分层是为了更好的解耦,分层可以完全不用你框架就能够解
  • Java后端开发框架

    万次阅读 多人点赞 2019-09-09 15:31:22
    Java web开发框架了解 web开发 前端–页面的设计、路由、展示—静态资源(HTML、CSS、JS)–web服务器(nginx)-- Vue 技术栈开发 后端–对外提供(类)RESTful风格的API—数据库交互-- web应用服务器(tomcat)...
  • Web框架》 试读感想   作为一个已经在java领域摸爬滚打多年的IT人,在每次需要从头搭建一个小项目框架、技术选型的时候,面对越来越庞大臃肿的spinrg, 脑海里每次都想过自己写一个轻量级的框架,来满足当前业务...
  • WEB 开发与Java框架及设计模式

    千次阅读 2010-08-01 15:56:00
    大家好,本节课堂讨论的是 WEB和Java应用开发 这节课分三个小节,分别是WEB原理,JAVAEE框架,设计模式 首先我们要明白Web的概念,以及原理是什么。 大家,对于web并不陌生,我们平时上网...
  • 全新Web开发风格-REST架构介绍

    千次阅读 2007-12-15 12:07:00
    REST架构风格是全新的针对Web应用的开发风格,是当今世界最成功的互联网超媒体分布式系统架构,它使得人们真正理解了Http协议本来面貌。随着REST架构成为主流技术,一种全新的互联网网络应用开发的思维方式开始流行...
  • 企业开发框架包括垂直方向架构和水平方向架构。垂直方向架构是指一个应用程序的由下到上叠加多层的架构,同时这样的程序又叫整体式程序。水平方向架构是指将大应用分成若干小的应用实现系统功能的架构,同时这样的...
  • 开发 ——建立开发框架 •建立数据库 •实施编码  测试——功能测试 •性能测试  一、架构设计 二、对接约定 1、接口约定  前端请求四要素,文档中体现,程序中实现:约定请求方式(普通HTTP请求,...
  • J2EE开发常用架构及其性能

    千次阅读 2014-11-02 23:17:28
    web开发中,因应用所属行业领域不同,对系统架构的选择也不同,系统架构决定了整个系统性能 和其他各种技术指标。    J2EE开发中,通常选用以下三种架构: 1,SSH 即spring+struts+hibernate ...
  • 几款常用的高质量web前端框架

    万次阅读 多人点赞 2017-09-20 17:06:18
    Web前端框架就是为了节约开发成本和时间,一般开发一个项目都会用到前端框架(除非自己有前端开发团队),根据我经验找的几款web前端框架做出了分析。都是个人意见,仁者见仁智者见智。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 72,044
精华内容 28,817
关键字:

web开发框架架构思想