Разница между управляемым бобом и поддерживающим бобом
Я встречал термины "управляемый бин" и "поддерживающий боб" на нескольких форумах. Многие люди думают, что оба одинаковы. Но, похоже, есть небольшая разница. Может ли кто-нибудь помочь мне понять точную разницу между этими двумя терминами?
11 ответов
Меняя мой первоначальный ответ - между ними нет существенной разницы. В учебнике говорится, что резервные компоненты позже объявляются как управляемые компоненты. Итак, подведем итог:
- бэк - класс вне контекста
- Управляемый компонент является вспомогательным компонентом всякий раз, когда он объявляется для использования со средством управляемого компонента JSF.
Я никогда не использовал термин "поддерживающий боб", потому что не нашел в этом смысла. Так что вам лучше использовать только "управляемый бин". Обратите внимание, что в JSF 2.0 (и в CDI) у вас есть @ManagedBean- так что ваш боб - управляемый боб.
BalusC предположил, что "поддерживающий компонент" - это определение, а "управляемый компонент" - это пример. Хотя это могло быть оригинальной идеей создателей JSF, я не думаю, что это стоит поддерживать. CDI и весна, например, не имеют разных терминов для "определения бина" и "экземпляра бина".
В спецификации JSF 2.0 термин "поддерживающий компонент" упоминается всего несколько раз, без какого-либо определения. В дополнение к этому в нем упоминается "класс поддерживающего бина", что может означать "вспомогательный класс"!= "Класс поддерживающего бина", что приводит к еще большей путанице.
Итак, в заключение - для меня оба являются взаимозаменяемыми, и я бы придерживался только использования "управляемого компонента"
Что такое управляемый боб?
Объекты JavaBean, управляемые реализацией JSF, называются управляемыми компонентами. Управляемый компонент описывает, как создается и управляется компонент. Это не имеет ничего общего с функциональностью бина.
Что такое бэк?
Поддерживающие bean-компоненты - это компоненты JavaBeans, связанные с компонентами пользовательского интерфейса, используемыми на странице. Управление бэк-бином отделяет определение объектов компонента пользовательского интерфейса от объектов, которые выполняют обработку для конкретного приложения и хранят данные. Базовый компонент определяет свойства и логику обработки, связанные с компонентами пользовательского интерфейса, используемыми на странице. Каждое свойство бэк-компонента связано либо с экземпляром компонента, либо с его значением. Поддерживающий компонент также определяет набор методов, которые выполняют функции для компонента, такие как проверка данных компонента, обработка событий, которые запускает компонент, и выполнение обработки, связанной с навигацией, когда компонент активируется.
Каковы различия между базовым компонентом и управляемым компонентом?
Поддерживающие Бины - это просто соглашение, подтип JSF-Управляемых Бинов, которые имеют очень конкретную цель. В базовом компоненте нет ничего особенного, что отличает его от любого другого управляемого компонента, кроме его использования.
MB: управляемый боб; BB: бэк
1) BB: поддерживающий компонент - это любой компонент, на который ссылается форма.
МБ: Управляемый компонент - это резервный компонент, который был зарегистрирован в JSF (в face-config.xml) и автоматически создается (и при желании инициализируется) JSF, когда это необходимо.
Преимущество управляемых bean-компонентов заключается в том, что среда JSF автоматически создает эти bean-компоненты, при желании инициализируя их параметрами, указанными в файле Face-config.xml.
2) BB: базовые компоненты должны быть определены только в области запроса
МБ: управляемые bean-компоненты, созданные JSF, могут храниться в пределах области запросов, сеансов или приложений.
Поддерживающие Бины должны быть определены в области запроса, существовать в виде взаимно-однозначного отношения с конкретной страницей и содержать весь код обработки событий, характерный для данной страницы. В реальном сценарии, возможно, нескольким страницам придется использовать один и тот же компонент поддержки за кулисами. Поддерживающий компонент содержит не только данные представления, но и поведение, связанное с этими данными.
Поддерживающий компонент - это любой компонент, связанный с пользовательским интерфейсом JSF. в то время как управляемый боб - это любой боб
Проще говоря,
Вы, как разработчик, делаете:
@ManagedBean(name="managedBean")
@RequestScoped
public class BackingBean {
// ...
}
JSF как структура управления bean-компонентами делает под прикрытием:
BackingBean managedBean = new BackingBean();
externalContext.getRequestMap().put("managedBean", managedBean);
Таким образом, поддерживающий компонент - это конкретный класс, который разрабатывается вами и обычно привязывается к представлению, а управляемый компонент - это конкретный экземпляр, который находится под защитными оболочками, созданными и помещенными в желаемую область действия структурой управления компонентами по требованию, и доступны #{managedBean} в EL. Вам никогда не нужно создавать и помещать его в объем самостоятельно. Если вы это сделали, значит, нет никакого компонента, управляемого фреймворком.
КДИ @Named и весна @Component делать то же самое, что и JSF @ManagedBean,
Чтобы узнать больше о том, как структуры управления bean-компонентами, такими как JSF, CDI и Spring, находят и создают свои управляемые bean-компоненты, следует подробно изучить следующее средство устранения неполадок: Идентификация и решение javax.el.PropertyNotFoundException: Target Unreachable.
Смотрите также:
http://docs.oracle.com/javaee/5/tutorial/doc/bnaqm.html говорит
Типичное приложение JavaServer Faces включает в себя один или несколько базовых компонентов, каждый из которых является управляемым компонентом JavaServer Faces, связанным с компонентами пользовательского интерфейса, используемыми на конкретной странице. Управляемые компоненты - это компоненты JavaBeans (см. Компоненты JavaBeans), которые можно настроить с помощью средства управляемого компонента, которое описано в разделе Настройка компонентов. В этом разделе представлены основные концепции создания, настройки и использования компонентов поддержки в приложении.
http://docs.oracle.com/javaee/6/tutorial/doc/bnaqm.html не упоминает "поддерживающий компонент".
Управляемые Бины управляются (создаются и уничтожаются) контейнером.
Backing Beans - это управляемые bean-компоненты, которые поддерживают представления как модели данных.
Я бы сказал, что базовый компонент является компонентом, используемым исключительно для целей пользовательского интерфейса, то есть ссылается на файлы jsp. В конце концов, все bean-компоненты, управляемые JSF-контейнером, являются управляемыми bean-компонентами, однако существуют разные контексты, в которых они могут использоваться. Для получения дополнительной информации см. Принятый ответ здесь: JSF: ManagedBean, Хорошее место для работы с Business Logic?
Backing Bean - это разновидность управляемого боба. Управляемый компонент - это объект (то есть экземпляр класса), созданный контейнером (поэтому он называется управляемым), и, конечно, у этого объекта есть класс, и, если вам так хочется, вы можете создать столько экземпляров этого класса, Неважно, какую аннотацию они имеют с m = new MyManagedBean(), просто это будет не управляемый компонент или, по крайней мере, не управляемый контейнером, но управляемый вами:)
А резервный компонент - это своего рода управляемый компонент (как выразился Сантош: соглашение), в котором обычно используется JSF requestScope (но в некоторых средах, таких как ADF, есть даже назначенная область действия только для вспомогательных компонентов, называемая backingBeanScope - вы бы никогда не догадались),
И да... Аромат управляемых bean-компонентов jsf, который можно было бы назвать BackingBeans, используется для связывания UIComponents и написания ActionListeners, в то время как, скажем, аромат "model beans" будет, например, входить в область сеанса и содержать ваши данные.
По этой ссылке JSF - Managed Beans
Управляемый Боб:
Managed Bean - это обычный класс Java Bean, зарегистрированный в JSF. Другими словами, Managed Beans - это Java-бин, управляемый средой JSF.
По этой ссылке Создание и использование базового компонента для веб-страницы:
Бэк бин:
В JSF вспомогательные компоненты - это JavaBean-компоненты, используемые в основном для обеспечения логики пользовательского интерфейса и управления данными между веб-уровнем и бизнес-уровнем приложения (аналогично объекту передачи данных). Как правило, у вас есть один компонент поддержки на странице JSF. Базовый компонент содержит логику и свойства для компонентов пользовательского интерфейса, используемых на странице.
NB:
Чтобы базовый компонент был доступен при запуске приложения, вы регистрируете его как управляемый компонент с именем и областью действия.
Я взял очень хороший (дорогой) курс по JSF. То, что я узнал там, есть только то, что объясняется в http://www.avromroyfaderman.com/2008/07/from-backing-bean-to-managed-bean/.
Возможно, это различие не является теоретическим различием или этимологией терминов, но это, безусловно, очень практичный способ настройки вашей архитектуры, особенно если вы являетесь частью большого проекта с несколькими разработчиками и / или вам нужно поддерживать много код давно. По сути, идея заключается в том, что вы помещаете свою бизнес-логику пользовательского интерфейса в управляемые компоненты. Вспомогательные бобы редки и поддерживают только саму страницу.
Управляемый Боб:
Управляемый компонент - это базовый компонент, который был зарегистрирован в JSF (в face-config.xml) или использует аннотации. Управляемый компонент автоматически создается (и при желании инициализируется) JSF, когда это необходимо.
Если вы используете Managed Bean в своем приложении, вы должны использовать следующий синтаксис на странице JSF, чтобы установить или получить значения из bean-компонента
<h:inputText value="#{user.name}"/>
Бэк бин:
Бин, который содержит некоторые или все составляющие объекты веб-формы. Такой компонент называется компонентом поддержки для веб-формы.
Когда вы используете поддерживающий компонент, вам нужно соединить компоненты формы с компонентами компонента. Вы используете атрибут привязки для этой цели
Пример:
<h:inputText binding="#{myForm.myComponent}" .../>
Посмотрите, как мы получаем или устанавливаем значения для бэк-компонента.
Поддерживающие Бины должны быть определены в области запроса, должны существовать в виде взаимно-однозначного отношения с конкретной страницей и содержать весь код обработки событий, относящийся к конкретной странице.
Надеюсь, это кому-нибудь пригодится.