Что в мире Spring beans?

Ответ 1

  Объекты, которые образуют основу вашего приложения и которые Управляемые Spring IoC * контейнеры называются bean-компонентами. Боб объект, который создается, собирается и иным образом управляется Контейнер Spring IoC. Эти бины создаются с помощью конфигурации метаданные, которые вы предоставляете контейнеру, например, в форме Определения XML <bean/>.

SpringSource:

Когда вы создаете определение компонента, то вы на самом деле создаете рецепт для создания реальных экземпляров класса, определенного этим бином определение. Идея, что определение бина является рецептом, важна, потому что это означает, что, как и класс, вы можете иметь множество экземпляров объектов, созданных по одному рецепту.

Вы можете контролировать не только различные зависимости и конфигурации значения, которые должны быть подключены к объекту, который создается из конкретное определение бина, а также область действия создаваемых объектов из конкретного определения бина. Этот подход очень мощный и дает вам гибкость, чтобы выбрать объем объектов, которые вы создать через конфигурацию вместо того, чтобы "запечь" область объекта на уровне класса Java. Бобы могут быть определены как развернуты в одной из нескольких областей

* IoC: инверсия контроля

Ответ 2

Spring beans - это просто экземпляры объектов, которые управляются контейнером Spring, а именно: они создаются и подключаются каркасом и помещаются в "сумку объектов" (контейнер), откуда вы можете получить их позже.

В разделе "Проводка" есть какая инъекция зависимостей, что означает, что вы можете просто сказать "мне понадобится эта вещь", и структура будет следовать некоторым правилам, чтобы получить подходящий экземпляр.

Для тех, кто не привык к Spring, я думаю, Статья в Wikipedia Spring имеет приятное описание:

Центральным элементом Spring Framework является его инверсия контейнера управления, который обеспечивает последовательное средство настройки и управления Java объекты с использованием отражения. Контейнер отвечает за управление объектные жизненные циклы конкретных объектов: создание этих объектов, вызов их методы инициализации и конфигурирование этих объектов путем проводки их вместе.

Объекты, созданные контейнером, также называются управляемыми объектами или beans. Контейнер можно настроить, загружая файлы XML или определение конкретных аннотаций Java в классах конфигурации. Эти источники данных содержат определения bean, которые обеспечивают информация, необходимая для создания beans.

Объекты могут быть получены с помощью либо поиска зависимостей, либо внедрение зависимости. Поиск зависимостей - это шаблон, в котором вызывающий запрашивает объект-контейнер для объекта с определенным именем или определенного типа. Инъекционная инъекция представляет собой шаблон, в котором контейнер передает объекты по имени другим объектам, через конструкторы, свойств или методов factory.

Ответ 3

Сначала давайте поймем весну:

Пружина представляет собой легкий и гибкий каркас.

Аналогия:

Bean: объект, который создается, управляется и уничтожается в Spring Container. Мы можем внедрить объект в контейнер Spring с помощью метаданных (xml или аннотации), которые называются инверсией управления.

Аналогия. Предположим, что у фермера есть сельскохозяйственные угодья, обрабатываемые семенами (или бобами). Здесь Фермер - это Spring Framework, Сельскохозяйственные угодья - это Spring Container, Beans - это Spring Beans, Cultivating - это Spring Processors.

Как и жизненный цикл бобов, у бобов spring тоже есть свой жизненный цикл.

img source

Ниже приведена последовательность жизненного цикла бина в Spring:

• Создание экземпляра: сначала контейнер весны находит определение bean-компонента из файла XML и создает экземпляр bean-компонента.

• Заполнение свойств: используя внедрение зависимостей, Spring заполняет все свойства, как указано в определении компонента.

• Задать имя компонента: если компонент реализует интерфейс BeanNameAware, BeanNameAware передает идентификатор setBeanName() метод setBeanName().

• Set Bean factory: если Bean реализует интерфейс BeanFactoryAware, Spring передает beanfactory setBeanFactory().

• Предварительная инициализация: также называется постобработкой бина. Если с bean-компонентом связаны какие-либо BeanPostProcessors, Spring вызывает postProcesserBeforeInitialization().

• Инициализация bean-компонентов: если bean-компонент реализует IntializingBean, afterPropertySet() его afterPropertySet(). Если бин имеет объявление метода init, вызывается указанный метод инициализации.

• Постинициализация: - если есть какие-либо BeanPostProcessors связанные с postProcessAfterInitialization() будут вызваны их postProcessAfterInitialization().

• Готов к использованию: теперь компонент готов к использованию приложением

• Destroy: если компонент реализует DisposableBean, он вызовет метод destroy()

Ответ 4

Хорошо, вы это поняли частично. Вам необходимо адаптировать beans в соответствии с вашими потребностями и сообщить Spring контейнер, чтобы управлять им, когда это необходимо, с использованием методологии, популярно известной как IoC (Инверсия Control), придуманным Мартин Фаулер, также известный как Инъекция зависимостей (DI).

Вы подключаете beans таким образом, чтобы вам не приходилось следить за созданием или оценивать любую зависимость от bean. Это общеизвестно как Голливудский принцип.

Google - лучший инструмент, чтобы больше узнать об этом в дополнение к ссылкам, которые вы могли бы заполнить здесь в этом вопросе.:)

Ответ 5

Spring имеют контейнер IoC, несущий сумку Bean; создание и удаление создания - это ответственность Spring Контейнера. Мы можем поместить Bean в Spring с помощью проводки и автоматической проводки. Проводка означает, что мы вручную настраиваем ее в XML файл, а "Автоматическое подключение" означает, что мы помещаем аннотации в файл Java, а затем Spring автоматически просматриваем корневой контекст, где находится файл конфигурации java, делаем его и помещаем в сумку Spring.

Вот подробный URI, где вы получили больше информации о Beans

Ответ 6

JAVA bean

Java Bean - это класс Java, который должен следовать следующим соглашениям:

• Он должен иметь конструктор no-arg.
• Он должен быть Serializable.
• Он должен предоставлять методы для установки и получения значений свойства, известные как методы getter и setter.

дайте понять Spring bean

Spring bean

Spring Bean ничего особенного, любой объект в структуре Spring, который мы инициализируем через контейнер Spring, называется Spring Bean. Любой нормальный Java POJO-класс может быть Spring Bean, если он настроен для инициализации через контейнер, предоставив информацию о метаданных конфигурации.

Простой bean

public class Triangle {
    private String name;  //private member variable

    public Triangle() {   // It should have a no-arg constructor

    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void sayHello(){
        System.err.println(getName() + " hello");
    }
   }

Контейнер IOC управляет жизненным циклом Bean через метаданные (spring.xml)

my spring.xml

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id ="t" class= "com.ved.spring.springmaven.Triangle">
 <property name="name" value="ved prakash"></property>
</bean>
</beans>

Я пытаюсь продемонстрировать простейшим способом

Ответ 7

Beans лежат в основе Spring. Это стандартные объекты Java, созданные и управляемые Spring.

Beans в основном используются для:

• Настроить Spring каким-либо образом (параметры подключения базы данных, безопасность и т.д.)
• Избегайте зависимости жесткого кодирования с помощью инъекции зависимостей, чтобы наши классы оставались автономными и проверялись единицами

Ответ 8

• Spring beans - это только экземпляры объектов, которые управляются контейнером IOC Spring.

• Spring Контейнер IOC несут сумку Bean. Создание, сохранение и удаление Bean являются обязанностью Spring Container.

• Мы можем поместить bean в Spring с помощью проводки и автоматической проводки.

• Подключение означает, что мы вручную настраиваем его в XML файл.

• Auto Wiring означает, что мы помещаем аннотации в файл Java, а затем Spring автоматически просматриваем корневой контекст, где файл конфигурации java, делаем его и помещаем в сумку Spring.

Ответ 9

Весенние бобы - это классы. Вместо того, чтобы создавать экземпляр класса (используя new), вы получаете экземпляр в виде bean приведенного к типу вашего класса, из контекста приложения, где компонент - это то, что вы настроили в конфигурации контекста приложения. Таким образом, все приложение поддерживает экземпляр singleton-scope во всем приложении. Все компоненты инициализируются в соответствии с порядком их настройки сразу после создания контекста приложения. Даже если вы не получаете никаких bean-компонентов в своем приложении, все экземпляры bean-компонентов уже созданы через мгновение после создания контекста приложения.

Ответ 10

В Spring те объекты, которые составляют основу вашего приложения и управляются с помощью Spring IoC контейнер обозначаются как beans. A bean - это просто объект, который создается, собирается и иным образом управляемый контейнером IoC Spring;

Ответ 11

Для весны все объекты являются бобами! Фундаментальный шаг в Spring Framework - определить ваши объекты как бины. Бины - это не что иное, как экземпляры объектов, которые будут созданы средой Spring при рассмотрении определений их классов. Эти определения в основном формируют метаданные конфигурации. Затем инфраструктура создает план, для которого должны быть созданы экземпляры объектов, какие зависимости должны быть установлены и внедрены, область действия вновь созданного экземпляра и т.д. На основе этих метаданных конфигурации.

Метаданные могут быть предоставлены в простом XML файле, как в первой главе. В качестве альтернативы, можно предоставить метаданные в виде аннотации или конфигурации Java.

Книга: Просто spring

Ответ 12

XML-конфигурация Spring состоит из Beans, а Beans в основном являются классами. Это просто POJO, которые мы используем внутри нашего ApplicationContext. Определение Beans можно рассматривать как замену ключевого слова new. Поэтому везде, где вы используете ключевое слово new в вашем приложении, что-то вроде:

MyRepository myRepository =new MyRepository ();

Где вы используете это ключевое слово, новое, где вы можете посмотреть, как удалить эту конфигурацию и поместить ее в файл XML. Итак, мы будем кодировать так:

<bean name="myRepository " 
      class="com.demo.repository.MyRepository " />

Теперь мы можем просто использовать Setter Injection/Constructor Injection. Я использую Setter Injection.

public class MyServiceImpl implements MyService {
    private MyRepository myRepository;
    public void setMyRepository(MyRepository myRepository)
        {
    this.myRepository = myRepository ;
        }
public List<Customer> findAll() {
        return myRepository.findAll();
    }
}