blocks|key|64594|text|在最简单的形式中，它是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|64595|Java|64596|模型:用于持久化(Hibernate、JPA等)和数据建模(|unordered-list-item|64597|
Beans)的任何内容。Java视图:+xhtml、jsp、管理Beans。|64598|JSF使您能够控制您的请求/响应。创建模型/视图的方式与框架MVC概念没有直接联系。这只是一个选择问题。MVC概念与代码组织相关。|64599|类似地，Struts是一个MVC框架，但它主要作为一个控制器工作。|64600|我想我可以帮助你更好地阐明你的想法。|64601|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|T|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|U|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|V|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|W|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|P|$]]

In a minimalist form, it's:

<ul>
<li>Model: Anything you use for persistence (Hibernate, JPA, etc) and data modeling (Java Beans).</li>
<li>View: xhtml, jsp, etc.</li>
<li>Controller: Mananaged Beans.</li>
</ul>

JSF gives you the power to control your requests/responses. The way you create model/view it's not directly connected to the framework MVC concept. It's just a matter of choice.
The MVC concept is related to code organization.

Analogously Struts is a MVC framework, but it works mainly as a controller.

I think I help you to better clarify your idea.

blocks|key|1708124|text|在JSF和许多其他web框架中，它的哪些部分对应于MVC的哪些部分通常并不完全清楚，部分原因是MVC模式最初是为桌面应用程序设计的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1708125|在桌面应用程序中，节点M、V和C是最大连接图，这意味着每个部分都可以与其他部分进行通信。例如，如果模型更改，它可以将此更改推送到视图。在桌面应用程序中存在多个视图表示的情况下，这一点尤其明显。更改其中一个，并实时查看另一个更新。|1708126|由于web应用程序的客户端/服务器和请求/响应的性质，传统的MVC不会1:1映射到大多数web框架。|1708127|具体地说，在JSF中，映射如下：|1708128|1708129|Model+-服务/DAO加上它们生产和使用的实体。这方面的入口点是托管bean，但在Java+(+JSF是其中的一部分)中，这些构件通常是由EJB和JPA+respectively.|unordered-list-item|offset|length|style|BOLD|1708130|View实现的-+UI组件及其组合成一个完整的页面。这完全在JSF域中，并由JSF+respectively.|1708131|Controller和UIComponent实现-交通警察处理来自用户的命令和输入数据，将其路由到正确的部分，并选择要显示的视图。在JSF中，不需要编写这个控制器，但是框架已经提供了这个控制器(它是FacesServlet).|CODE|1708132|1708133|特别是最后一部分通常不能很好地理解:在JSF中，您没有实现控制器。因此，支持bean或任何其他类型的受管bean是而不是控制器。|1708134|第一部分(模型)也并不总是被清楚地理解。业务逻辑可以由EJB和JPA实现，但从JSF的角度来看，值绑定引用的一切都是模型。这也是JSF生命周期阶段之一的名称来源：Update+Model。在此阶段，JSF将数据从UI组件推送到模型中。从这个意义上说，(JSF)托管bean就是模型。|1708135|尽管JSF本身并没有显式地定义这个概念，但是托管bean有一种经常重复出现的特定用法，称为支持bean。|1708136|对于JSF，支持bean仍然是模型，但实际上它是位于模型、视图和控制器中间的管道元素。因为它执行一些可能被视为控制器任务的任务，所以它经常被误认为是控制器。但是，正如前面所解释的，这是不正确的。它还可以执行一些模型任务，偶尔也可以执行一些视图逻辑。|1708137|另请参阅：|1708138|1708139|What+are+the+main+advantages+of+MVC+pattern+over+the+old+fashioned+3-layer+pattern|1708140|MVC-Architecture+of+JavaServer+Faces+(Chapter+4.3)|1708141|1708142|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/4573554/472792|1|http://www.sts.tu-harburg.de/pw-and-m-theses/2007/maab07.pdf^0|0|0|0|0|0|0|5|0|0|4|0|0|A|B|B|2R|C|0|0|1L|3|0|29|C|0|19|6|0|0|0|0|0|2A|0|0|0|1E|1|0|0^^$0|@$1|2|3|4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1O|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|1Q|8|@$L|1R|M|1S|N|O]]|9|@]|A|$]]|$1|P|3|Q|5|K|7|1T|8|@$L|1U|M|1V|N|O]]|9|@]|A|$]]|$1|R|3|S|5|K|7|1W|8|@$L|1X|M|1Y|N|O]|$L|1Z|M|20|N|T]|$L|21|M|22|N|T]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|23|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|24|8|@$L|25|M|26|N|O]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|27|8|@$L|28|M|29|N|T]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2A|8|@$L|2B|M|2C|N|O]]|9|@]|A|$]]|$1|11|3|12|5|6|7|2D|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|2E|8|@]|9|@]|A|$]]|$1|15|3|-4|5|6|7|2F|8|@]|9|@]|A|$]]|$1|16|3|17|5|K|7|2G|8|@]|9|@$L|2H|M|2I|1|2J]]|A|$]]|$1|18|3|19|5|K|7|2K|8|@]|9|@$L|2L|M|2M|1|2N]]|A|$]]|$1|1A|3|-4|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1B|3|-4|5|6|7|2P|8|@]|9|@]|A|$]]]|1C|$1D|$5|1E|1F|1G|A|$1H|1I]]|1J|$5|1E|1F|1G|A|$1H|1K]]]]

Part of the reason why it's often not entirely clear in JSF and many other web frameworks which parts of it correspond to which part of MVC, is that the MVC pattern was originally devised for desktop applications.

In a desktop application, the nodes M, V and C are a maximum connected graph, meaning each part can communicate with every other part. E.g. if the model changes, it can push this change to the view. This is particularly visible in case there are multiple representations of the view in a desktop application. Change one, and see the other update in real-time.

Due to the client/server and request/response nature of web applications, classic MVC doesn't map 1:1 to most web frameworks.

Specifically, in JSF the mapping is as follows:

<ul>
<li>Model - The Services/DAOs plus the entities they produce and consume. The entry point to this is the managed bean, but in Java EE (of which JSF is a part) these artifacts are typically implemented by EJB and JPA respectively.</li>
<li>View - The UI components and their composition into a full page. This is fully in the domain of JSF and implemented by JSF <code>UIComponent</code>s and Facelets respectively.</li>
<li>Controller - The traffic cop that handles commands and incoming data from the user, routes this to the right parts and selects a view for display. In JSF one doesn't write this controller, but it's already provided by the framework (it's the <code>FacesServlet</code>).</li>
</ul>

Especially the last part is frequently not well understood: In JSF you don't implement a controller. Consequently, a backing bean or any other kind of managed bean is NOT the controller.

The first part (the model) is also not always clearly understood. Business logic may be implemented by EJB and JPA, but from the point of view of JSF everything that is referenced by a value binding is the model. This is also where the name of one of the JSF life-cycle phases comes from: <code>Update Model</code>. In this phase JSF pushes data from the UI components into the model. In that sense, (JSF) managed beans are thus the model.

Although JSF itself doesn't explicitly define the concept, there is an often recurring and specific usage of managed beans called the backing bean.

For JSF a backing bean is still the model, but practically it's a plumbing element that sits in the middle of the Model, View and Controller. Because it performs some tasks that may be seen as some controller tasks, this is often mistaken to be the controller. But, as explained before this is not correct. It can also perform some model tasks and occasionally do some view logic as well.

See also:

<ul>
<li><a href="https://stackoverflow.com/a/4573554/472792">What are the main advantages of MVC pattern over the old fashioned 3-layer pattern</a></li>
<li><a href="http://www.sts.tu-harburg.de/pw-and-m-theses/2007/maab07.pdf" rel="noreferrer">MVC-Architecture of JavaServer Faces (Chapter 4.3)</a></li>
</ul>

blocks|key|1086525|text|关于托管bean思想的有趣之处在于，它既可以用作模型(MVC模式)，也可以用作控制器(mediating-controller+MVC+pattern，也称为模型-视图-适配器)，其中模型和视图不直接交互。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1086526|在后一种情况下，路由机制不是控制器，因为业务逻辑包含在托管bean中，而model严格是一个域模型。然后我们就有了：|1086527|1086528|Model+-包含域模型，在大多数情况下表示数据库中的表，通过DAOs.|unordered-list-item|style|BOLD|1086529|View持久化-+ui组件，连接到bean;|1086530|Controller+-包含业务逻辑并处理视图和模型之间的通信的托管bean。|1086531|1086532|我认为有些人将中介控制器MVC与普通MVC混淆，这导致了遇到的不同解释。|1086533|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Model%25E2%2580%2593view%25E2%2580%2593adapter^0|17|W|0|0|0|0|0|5|0|0|4|0|0|A|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|15|8|@]|9|@]|C|$]]|$1|G|3|H|5|I|7|16|8|@$A|17|B|18|J|K]]|9|@]|C|$]]|$1|L|3|M|5|I|7|19|8|@$A|1A|B|1B|J|K]]|9|@]|C|$]]|$1|N|3|O|5|I|7|1C|8|@$A|1D|B|1E|J|K]]|9|@]|C|$]]|$1|P|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1G|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

The interesting thing about the managed bean idea is that it can both be used as a model (MVC pattern) or as a controller (<a href="http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93adapter" rel="noreferrer">mediating-controller MVC pattern</a>, also called model-view-adapter), where the model and view do not interact directly.

In that latter case, the routing mechanism is not the controller, as the business logic is contained in the managed bean and the Model is strictly a domain model. We then have:

<ul>
<li>Model - contains the domain model, in most cases represents the tables in the database, persisted through DAOs.</li>
<li>View - the ui components, connected to the bean;</li>
<li>Controller - the managed bean that contains the business logic and handles communication between the view and the model.</li>
</ul>

I think some people confuse mediating-controller MVC as plain MVC, which leads to the different explanations encountered.

blocks|key|1086545|text|我想，这里的所有人都是正确的。但对我来说，混淆的主要原因是将mvc组件的定义与您在应用程序设计中定义的模型和控制器组件混合在一起：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1086546|假设您在业务应用程序中从JSF更改为任何其他Web+UI框架:您仍将拥有一个“业务模型”和一个“业务控制器”。(在我们的项目中，我们只将这些组件称为“模型”和“流程”。)|1086547|​|1086548|这意味着:要么你不能使用mvc来描述整个应用程序架构，而只能用于UI，要么你必须在你的整个应用程序堆栈中接受许多控制器、模型等组件。|1086549|1086550|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|M|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|N|8|@]|9|@]|A|$]]|$1|H|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|J|$]]

I think, all anwsers here are correct.
But the main point for confusion arises for me from mixing the mvc components' definitions coming from the framework, here JSF, with those model and controller components you define in your application design:
Assume you change from JSF to any other Web UI framework in your business application: 
You will still have a "business model" and a "business controller". (In our projects we just call these components "the model" and "the process".)
What does this mean: Either you can't use mvc for the description of the overall application architecture, but solely for the UI, or you may have to accept many controller, model like components in your full application stack.

I am reading on JSF and I feel rather confused why JSF is a MVC framework (or atleast which parts belongs to which "letter").

I looked at this question: <a href="https://stackoverflow.com/questions/5104094/what-components-are-mvc-in-jsf-mvc-framework">What components are MVC in JSF MVC framework?</a>

I read there if you don't look at it in an aggregated view the model is your entity, view is your XHTML code and controller is the managed bean. Hmm...Ok, but doesn't the view very often depend on carrying out further business logic calls which returns a set of entities for example, does the description still fit?

One book I read described it as managed beans is the some kind of "message" bringer that the Faces Servlet (Controller) use to invoke the business layer (Model) and then the XHTML code is the view.

There are so many explanations and differences so I don't know which or how to understand it.

Understanding JSF as a MVC framework

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在阅读关于JSF的文章，我感到相当困惑，为什么JSF是一个MVC框架(或者至少哪些部分属于哪个“字母”)。我看过这个问题：我在那里读到，如果您不从聚合视图中查看它，那么模型就是您的实体，视图就是您的XHTML代码，控制器就是托管bean。Hmm...Ok，但是视图不是经常依赖于执行进一步的业务逻辑调用，例如返回一组...

问将JSF理解为MVC框架
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将JSF理解为MVC框架EN