Что в мире Весенние бобы?

Мне еще предстоит найти высокоуровневое определение бобов Spring, которое я могу понять. Я часто на них ссылаюсь в документации и книгах Grails, но думаю, что понимание того, чем они являются, было бы полезно. Так, каковы Весенние бобы? Как их можно использовать? Они имеют какое-то отношение к инъекции зависимости?

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

Чтобы узнать больше о bean-компонентах и ​​области применения SpringSource :

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

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

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

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

Часть «разводка» - это то, что представляет собой внедрение зависимостей, это означает, что вы можете просто сказать «мне понадобится эта вещь», и фреймворк будет следовать некоторым правилам, чтобы получить правильный экземпляр.

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

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

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

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

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

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

Аналогия:

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

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

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

img source

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

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

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

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

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

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

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

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

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

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

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

Вы связываете bean-компоненты таким образом, что вам не нужно заботиться о создании экземпляров или оценивать какую-либо зависимость от bean-компонента. Это широко известно как принцип Голливуда .

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

У весны есть контейнер IoC, который несет Мешок Боба; Создание, поддержка и удаление являются обязанностью Spring Container. Мы можем поставить боб в Spring с помощью Wiring и Auto Wiring. Соединение означает, что мы вручную настраиваем его в файл XML, а «Автосоединение» означает, что мы помещаем аннотации в файл Java, а затем Spring автоматически сканирует корневой контекст, где находится файл конфигурации Java, создает его и помещает в пакет Spring.

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

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

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

• Контейнер Spring IOC несет Bag of Bean. Ответственность за создание, поддержание и удаление Bean лежит на Spring Container.

• Мы можем поставить боб в Spring с помощью Wiring и Auto Wiring.

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

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

Бин - это POJO (Простой старый Java-объект), которым управляет контейнер Spring.

Контейнеры Spring по умолчанию создают только один экземпляр компонента. Этот bean-компонент кэшируется в памяти, поэтому все запросы для bean-компонента будут возвращать общую ссылку на один и тот же bean-компонент.

Аннотация @Bean возвращает объект, который Spring регистрирует как bean-компонент в контексте приложения. Логика внутри метода отвечает за создание экземпляра.

Когда мы используем аннотацию @Bean?

Когда автоматическая настройка не вариант. Например, когда мы хотим связать компоненты из сторонней библиотеки, потому что исходный код недоступен, поэтому мы не можем аннотировать классы с помощью @Component.

Сценарий реального времени может заключаться в том, что кто-то хочет подключиться к корзине Amazon S3. Поскольку источник недоступен, ему придется создать @bean.

@Bean
public AmazonS3 awsS3Client() {
    BasicAWSCredentials awsCreds = new BasicAWSCredentials(awsKeyId, accessKey);
    return AmazonS3ClientBuilder.standard().withRegion(Regions.fromName(region))
            .withCredentials(new AWSStaticCredentialsProvider(awsCreds)).build();
}

Источник для кода выше -> https://www.devglan.com/spring-mvc/aws-s3-java

Потому что я упомянул аннотацию @Component выше.

@Component Указывает, что аннотированный класс является «компонентом». Такие классы рассматриваются как кандидаты для автоматического обнаружения при использовании конфигурации на основе аннотаций и сканирования пути классов.

Компонентная аннотация регистрирует класс как один компонент.

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

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

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

Книга: Просто весна

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

MyRepository myRepository =new MyRepository ();

Где вы используете это ключевое слово new , вы можете посмотреть, как удалить эту конфигурацию и поместить ее в файл 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();
    }
}