Четвертое, java-интервью: Весна

опрос

Что такое Spring Framework

Официальный сайт весны:весна.IO/.

Это набор многих модулей, и использование этих модулей может легко помочь нам в разработке. Этими модулями являются: основные контейнеры, доступ к данным/интеграция, веб, АОП (аспектно-ориентированное программирование), модули инструментов, обмена сообщениями и тестирования. Например, компонент Core в контейнере Core является ядром всех компонентов Spring, компонент Beans и компонент Context являются основой для реализации IOC и внедрения зависимостей, а компонент AOP используется для реализации аспектно-ориентированного программирования.

  • Основная технология: Внедрение зависимостей (DI), АОП, события, ресурсы, i18n, проверка, привязка данных, преобразование типов, SpEL.
  • контрольная работа: Mock Objects, TestContext Framework, тесты Spring MVC, WebTestClient.
  • доступ к данным: Транзакции, поддержка DAO, JDBC, ORM, упорядоченный XML.
  • Веб-поддержка: Веб-фреймворк Spring MVC и Spring WebFlux.
  • интегрированный: удаленное взаимодействие, JMS, JCA, JMX, электронная почта, задачи, планирование, кэширование.
  • язык: Kotlin, Groovy, динамические языки

Преимущества весны?

  • Spring — это малонавязчивый дизайн, а загрязнение кода крайне мало;
  • Механизм Spring DI передает зависимости между объектами в фреймворк, чтобы уменьшить связанность компонентов;
  • Spring предоставляет технологию АОП для поддержки централизованного управления некоторыми общими задачами, такими как безопасность, транзакции, журналы, разрешения и т. д., для обеспечения лучшего повторного использования.
  • Spring обеспечивает интегрированную поддержку основных платформ приложений.

Перечислите некоторые важные модули Spring?

  • Весеннее ядро:По сути, можно сказать, что все остальные функции Spring должны зависеть от этой библиотеки классов. В основном он обеспечивает функцию внедрения зависимостей IoC.
  • Spring Aspects: этот модуль обеспечивает поддержку интеграции с AspectJ.
  • Spring AOP: Обеспечивает реализацию аспектно-ориентированного программирования.
  • Spring JDBC: подключение к базе данных Java.
  • Spring JMS: Служба сообщений Java.
  • Spring ORM: Используется для поддержки инструментов ORM, таких как Hibernate.
  • Spring Web: Обеспечивает поддержку создания веб-приложений.
  • Spring Test: Обеспечивает поддержку тестов JUnit и TestNG.

@RestController vs @Controller

Использовать в одиночку@Controllerне добавлять@ResponseBodyОбычно он используется в случае возврата представления, принадлежащего более традиционному приложению Spring MVC, что соответствует ситуации, когда передняя и задняя части не разделены.

@RestController =@Controller +@ResponseBody

Расскажите о своем понимании Spring IoC и АОП

  • IOC

    IoC (инверсия управления: инверсия управления) представляет собойдизайн-мышление,то естьУправление ручным созданием объектов в программе передано в управление фреймворку Spring.IoC имеет приложения и на других языках и не является специфичным для Spring.Контейнер IoC — это носитель, используемый Spring для реализации IoC Контейнер IoC на самом деле представляет собой карту (ключ, значение), в которой хранятся различные объекты.

    Взаимозависимость между объектами передается контейнеру IoC для управления, и контейнер IoC завершает внедрение объекта. Это значительно упрощает разработку приложений и освобождает приложения от сложных зависимостей.Контейнер IoC похож на фабрику: когда нам нужно создать объект, нам нужно только настроить файл конфигурации/аннотацию, не учитывая, как создается объект.В реальном проекте класс службы может иметь сотни или даже тысячи классов в качестве нижнего уровня.Если нам нужно создать экземпляр этой службы, вам, возможно, придется каждый раз выяснять конструкторы всех базовых классов этой службы, что может результат сводит людей с ума. Если вы используете IoC, вам нужно только настроить его, а затем ссылаться на него там, где это необходимо, что значительно повышает удобство сопровождения проекта и снижает сложность разработки.

  • AOP

    АОП (Аспектно-ориентированное программирование: Аспектно-ориентированное программирование) может преобразовать тех, кто не имеет никакого отношения к бизнесу,Однако он инкапсулируется логикой или ответственностью (например, обработка транзакций, управление журналами, контроль разрешений и т. д.), обычно вызываемой бизнес-модулями.,легкоУменьшить дублирование кода в системе,Уменьшите связь между модулями,а такжеХорошо для будущей масштабируемости и ремонтопригодности.

    ​Spring AOP основан на динамическом прокси, если проксируемый объект реализует интерфейс, то Spring AOP будет использоватьJDK Proxy, для создания прокси-объектов и для объектов, которые не реализуют интерфейсы, JDK Proxy нельзя использовать для проксирования.В настоящее время Spring AOP будет использоватьCglib, то Spring AOP будет использоватьCglibСоздайте подкласс прокси-объекта, чтобы действовать как прокси

В чем разница между Spring AOP и AspectJ AOP?

Spring AOP — это усовершенствование времени выполнения, а AspectJ — усовершенствование времени компиляции. Spring AOP основан на проксировании, а AspectJ основан на манипулировании байт-кодом.

Spring AOP интегрировал AspectJ, который следует считать наиболее полной структурой AOP в экосистеме Java. AspectJ более мощный, чем Spring AOP, но Spring AOP относительно проще.

Если у нас меньше граней, то между ними нет большой разницы в производительности. Однако, когда аспектов слишком много, лучше выбрать AspectJ, который намного быстрее, чем Spring AOP.

Каковы масштабы бобов весной?

  • singleton : единственный экземпляр bean-компонента, bean-компоненты в Spring по умолчанию являются одноэлементными.
  • прототип: новый экземпляр компонента создается при каждом запросе.
  • request : каждый HTTP-запрос будет генерировать новый bean-компонент, который действителен только в рамках текущего HTTP-запроса.
  • session : каждый HTTP-запрос будет генерировать новый bean-компонент, который действителен только в рамках текущего HTTP-сеанса.
  • global-session: глобальная область сеанса, которая имеет смысл только в веб-приложениях на основе портлетов, больше не доступна в Spring 5. Портлеты — это небольшие веб-плагины Java, которые генерируют фрагменты семантического кода (например, HTML). Они основаны на контейнерах портлетов и могут обрабатывать HTTP-запросы, как сервлеты. Однако, в отличие от сервлетов, каждый портлет имеет отдельный сеанс.

Являются ли bean-компоненты в Spring потокобезопасными?

Для одноэлементных компонентов все потоки совместно используют одноэлементный экземпляр компонента, поэтому существует конкуренция за ресурсы.

Если singleton bean является bean-компонентом без сохранения состояния, то есть операции в потоке не выполняют операций, отличных от запросов к членам bean-компонента, то singleton bean является потокобезопасным. Например, Spring mvc Controller, Service, Dao и т. д. Большинство этих bean-компонентов не имеют состояния и сосредоточены только на самом методе.

Для bean-компонентов с отслеживанием состояния bean-компоненты, официально предоставляемые Spring, обычно предоставляют методы для решения проблемы безопасности потоков через ThreadLocal, такие как RequestContextHolder, TransactionSynchronizationManager, LocaleContextHolder и т. д.

Сам контейнер не обеспечивает политику безопасности потоков для bean-компонентов, поэтому можно сказать, чтоКомпоненты в контейнере Spring сами по себе не являются потокобезопасными..Таким образом, безопасность потоков полностью зависит от характеристик самого Бина.

В чем разница между @Component и @Bean?

  1. Различные объекты:@ComponentАннотации работают с классами, а@BeanАннотации применяются к методам.
  2. @ComponentОбычно автоматически определяется и автоматически подключается к контейнеру Spring с помощью сканирования пути к классам (мы можем использовать@ComponentScanАннотация определяет путь для сканирования, из которого можно определить классы, которые должны быть автоматически подключены к контейнеру bean-компонентов Spring).@BeanАннотация обычно определяется в методе, отмеченном аннотацией для создания этого компонента.@BeanСкажите Spring, что это пример определенного класса, и верните его мне, когда мне нужно будет его использовать.
  3. @BeanКоэффициент аннотацииComponentАннотации более настраиваемы, и во многих местах мы можем передать только@BeanАннотация для регистрации бинов. Например, когда мы ссылаемся на классы в сторонних библиотеках, которые необходимо собрать дляSpringконтейнер, вы можете только пройти@Beanреализовать.

Каковы аннотации для объявления класса как компонента Spring?

Обычно мы используем@AutowiredAnnotation autowires bean-компоненты, чтобы пометить класс как доступный для@AutowiredАннотируйте класс автосвязанного компонента, чего можно добиться с помощью следующих аннотаций:

  • @Component: Общая аннотация, которая может помечать любой класс какSpringкомпоненты. Если бин не знает, к какому слою он принадлежит, вы можете использовать@ComponentАннотация аннотация.
  • @Repository: соответствующий уровень сохраняемости — это уровень Dao, который в основном используется для операций, связанных с базой данных.
  • @Service: Что касается сервисного уровня, он в основном включает в себя некоторую сложную логику и должен использовать уровень Dao.
  • @Controller: в соответствии с уровнем управления Spring MVC основной пользователь принимает запросы пользователей и вызывает уровень службы для возврата данных на интерфейсную страницу.

жизненный цикл бобов весной?

  • Контейнер компонентов находит определение Spring Bean в файле конфигурации.
  • Контейнер компонента использует Java Reflection API для создания экземпляра компонента.
  • Если задействованы некоторые значения атрибутов, используйтеset()метод для установки некоторого значения свойства.
  • Если компонент реализуетBeanNameAwareинтерфейс, вызовsetBeanName()метод, передавая имя компонента.
  • Если компонент реализуетBeanClassLoaderAwareинтерфейс, вызовsetBeanClassLoader()метод, пройтиClassLoaderэкземпляр объекта.
  • Аналогично предыдущему, если другое*.Awareинтерфейс, вызовите соответствующий метод.
  • Если есть что-то, связанное с контейнером Spring, который загружает этот bean-компонентBeanPostProcessorобъект, выполнитьpostProcessBeforeInitialization()метод
  • Если Бин реализуетInitializingBeanинтерфейс, выполнитьafterPropertiesSet()метод.
  • Если определение bean-компонента в файле конфигурации содержит атрибут init-method, выполнить указанный метод.
  • Если есть что-то, связанное с контейнером Spring, который загружает этот bean-компонентBeanPostProcessorобъект, выполнитьpostProcessAfterInitialization()метод
  • Когда Бин должен быть уничтожен, если Бин реализуетDisposableBeanинтерфейс, выполнитьdestroy()метод.
  • Когда bean-компонент должен быть уничтожен, если определение bean-компонента в файле конфигурации содержит атрибут destroy-method, выполняется указанный метод.

Как работает SpringMVC

  1. Клиент (браузер) отправляет запрос, напрямую запрашиваяDispatcherServlet.
  2. DispatcherServletЗвонил по запросу информацииHandlerMapping, который анализирует запрос, соответствующийHandler.
  3. принять соответствующиеHandler(Это то, что мы обычно говоримControllerконтроллер), начните сHandlerAdapterРабота с адаптером.
  4. HandlerAdapterбудет основываться наHandlerВызов реального процессора для обработки запроса и обработки соответствующей бизнес-логики.
  5. После того, как процессор обработает бизнес, он вернетModelAndViewобъект,Modelэто возвращаемый объект данных,Viewявляется логическимView.
  6. ViewResolverпо логикеViewнайти фактическоеView.
  7. DispaterServletположить обратноModelперейти кView(просмотреть визуализацию).
  8. ПучокViewВернуть запрашивающему (браузеру)

Сколько способов Spring управляет транзакциями?

  1. Программные транзакции, жестко запрограммированные в коде. (устарело)
  2. Декларативные транзакции, настроенные в файле конфигурации (рекомендуется)

Существует два типа декларативных транзакций:

  1. Декларативные транзакции на основе XML
  2. Декларативные транзакции на основе аннотаций

Каковы уровни изоляции в транзакциях Spring?

  • TransactionDefinition.ISOLATION_DEFAULT:Используйте уровень изоляции по умолчанию для серверной базы данных, уровень изоляции REPEATABLE_READ, принятый Mysql по умолчанию, и уровень изоляции READ_COMMITTED, принятый Oracle по умолчанию.
  • TransactionDefinition.ISOLATION_READ_UNCOMMITTED:Самый низкий уровень изоляции, позволяющий читать изменения данных, которые еще не были зафиксированы,Может вызвать грязное чтение, фантомное чтение или неповторяющееся чтение.
  • TransactionDefinition.ISOLATION_READ_COMMITTED:Позволяет читать данные, которые были зафиксированы параллельными транзакциями,Грязные чтения можно предотвратить, но фантомные или неповторяющиеся чтения все же могут происходить.
  • TransactionDefinition.ISOLATION_REPEATABLE_READ:Результаты многократного чтения одного и того же поля согласуются, если только данные не изменены самой транзакцией.Грязные чтения и неповторяющиеся чтения можно предотвратить, но фантомные чтения все еще могут возникать.
  • TransactionDefinition.ISOLATION_SERIALIZABLE:Самый высокий уровень изоляции, полностью соответствующий уровню изоляции ACID. Все транзакции выполняются одна за другой, так что абсолютно исключена возможность вмешательства между транзакциями, т.е.Этот уровень предотвращает грязные чтения, неповторяемые чтения и фантомные чтения.. Но это серьезно повлияет на производительность программы. Обычно этот уровень также не используется.

Каково поведение распространения транзакций в транзакциях Spring?

Ситуации, поддерживающие текущую транзакцию:

  • TransactionDefinition.PROPAGATION_REQUIRED:Если транзакция уже существует, присоединиться к ней, если текущей транзакции нет, создать новую транзакцию.
  • TransactionDefinition.PROPAGATION_SUPPORTS:Если в данный момент есть транзакция, присоединиться к транзакции; если текущей транзакции нет, продолжить работу в нетранзакционном режиме.
  • TransactionDefinition.PROPAGATION_MANDATORY:Если в данный момент есть транзакция, присоединиться к транзакции; если текущей транзакции нет, сгенерировать исключение. (обязательно: обязательно)

Когда текущая транзакция не поддерживается:

  • TransactionDefinition.PROPAGATION_REQUIRES_NEW:Создайте новую транзакцию и приостановите текущую транзакцию, если есть текущая транзакция.
  • TransactionDefinition.PROPAGATION_NOT_SUPPORTED:Запустить в нетранзакционном режиме, приостановить текущую транзакцию, если текущая транзакция есть.
  • TransactionDefinition.PROPAGATION_NEVER:Работает без транзакций и выдает исключение, если транзакция уже существует.

Другие случаи:

  • TransactionDefinition.PROPAGATION_NESTED:Если в данный момент транзакция существует, транзакция создается для выполнения как вложенная транзакция текущей транзакции; если текущей транзакции нет, значение эквивалентно TransactionDefinition.PROPAGATION_REQUIRED.

В чем разница между BeanFactory и ApplicationContext?

BeanFactory и ApplicationContext являются двумя основными интерфейсами Spring, и оба могут использоваться как контейнеры Spring. Где ApplicationContext является подинтерфейсом BeanFactory.

  1. BeanFactory: это интерфейс нижнего уровня в Spring.Он содержит определения различных бинов, читает документы конфигурации бинов, управляет загрузкой и созданием бинов, контролирует жизненный цикл бинов и поддерживает зависимости между бинами. Будучи производным от BeanFactory, интерфейс ApplicationContext предоставляет более полные функции инфраструктуры в дополнение к функциям BeanFactory:

​ ① Наследовать MessageSource, чтобы он поддерживал интернационализацию.

​ ②Единый метод доступа к файлам ресурсов.

​ ③ Обеспечьте события для регистрации bean-компонентов в прослушивателе.

​ ④ Загрузите несколько файлов конфигурации одновременно.

​ ⑤ Загружайте несколько (унаследованных) контекстов, чтобы каждый контекст фокусировался на определенном уровне, например веб-слое приложения.

  1. ①BeanFactroy использует форму отложенной загрузки для внедрения bean-компонентов, то есть только когда bean-компонент используется (вызывается getBean()), bean-компонент загружается и создается экземпляр. Таким образом, мы не можем найти некоторые существующие проблемы с конфигурацией Spring. Если свойство Bean не введено, после загрузки BeanFacotry будет выдано исключение до тех пор, пока метод getBean не будет вызван в первый раз.

    ②ApplicationContext, который создает все bean-компоненты одновременно при запуске контейнера. Таким образом, когда контейнер запускается, мы можем найти ошибки конфигурации в Spring, что полезно для проверки того, внедрены ли зависимые свойства. Предварительно загружая все компоненты bean-компонентов с одним экземпляром при запуске ApplicationContext, предварительно загружая bean-компоненты с одним экземпляром, вы гарантируете, что когда они вам понадобятся, вам не придется ждать, потому что они уже созданы.

    ③По сравнению с базовой BeanFactory единственным недостатком ApplicationContext является то, что он занимает место в памяти. При наличии большого количества bean-компонентов конфигурации приложения программа запускается медленно.

  2. BeanFactory обычно создается программно, ApplicationContext также может быть создан декларативно, например, с использованием ContextLoader.

  3. И BeanFactory, и ApplicationContext поддерживают использование BeanPostProcessor и BeanFactoryPostProcessor, но разница между ними заключается в следующем: BeanFactory необходимо зарегистрировать вручную, тогда как ApplicationContext регистрируется автоматически.

<!-- 将CellPhone部署成prototype的范围 -->
<bean id="cellPhone" class="com.abc.CellPhone" scope="prototype" />
<bean id="developer" class="com.abc.Developer">
    <!-- getPhone方法返回CellPhone，每次调用将获取新的CellPhone -->
    <lookup-method name="getPhone" bean="cellPhone" />
</bean>
  
  public class CellPhone implements Phone {
    public CellPhone() {
        System.out.println("Spring实例化依赖的Bean...CellPhone实例");
    }
    public return call() {
        return "正在打电话...";
    }
}

  public abstract class Developer implements Person {
    public Developer() {
        System.out.println("Spring实例化主调的Bean...Developer实例");
    }
    //定义一个抽象方法，该方法将由Spring实现
    public abstract Phone getPhone();
    @Override
    public void call() {
        System.out.println("正在使用 " + getPhone() + " 打电话");
        System.out.println(getPhone().call());
    }
}

  public class Test {
    public static void main(String args[]) {
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Developer d = context.getBean("developer", Developer.class);
        d.call();
        d.call();
    }
}

Бин определяется в файле applicationgContext.xml, идентификатором является authService, и бин получается через метод getBean экземпляра объекта ApplicationContext.Какой принцип реализации стоит за этим?

Когда контейнер Spring запускается, он анализирует applicationgContext.xml, анализирует bean-компонент, определенный в xml (например, authService), в BeanDefinition внутри Spring и использует beanName (например, authService) в качестве ключа и BeanDefinition (например, BeanDefinition, соответствующий authService). ) в качестве значения.В свойстве beanDefinitionMap в DefaultListableBeanFactory (на самом деле это свойство типа ConcurrentHashMap), в то же время сохраните beanName в beanDefinitionNames (тип List), затем пройдите beanName в beanDefinitionNames, создайте экземпляр bean-компонента и заполните в свойствах, в процессе создания экземпляра Если есть зависимость, которая не была создана, она сначала создаст свои зависимости, а затем сама себя.После завершения создания экземпляр будет сохранен в кеше singleton bean , Когда вызывается метод getBean, он будет искаться в кеше одноэлементного компонента. , Если он найден и преобразован для возврата этого экземпляра (например, экземпляра AuthService), его можно использовать сразу после этого.

Расскажите о процессе парсинга xml файла?

После указания файла xml для загрузки в коде, во время инициализации контейнера Spring класс реализуется через интерфейс ResourceLoader, такой как ClassPathXmlApplicationContext, путь к файлу xml преобразуется в соответствующий файл ресурсов, такой как ClassPathResource, и затем файл ресурсов преобразуется и преобразуется с помощью DocumentLoader в файл документа, затем анализируется документ с помощью DefaultBeanDefinitionDocumentReader и используется BeanDefinitionParserDelegate для анализа элементов, анализа каждого элемента определения компонента в xml и сохранения его в BeanDefinition.

Тогда не могли бы вы уточнить, что это за BeanDefinition?

Если жизненный цикл объекта должен управляться контейнером Spring, информация о его классе должна быть сначала преобразована во внутреннюю структуру данных Spring.BeanDefinition — это структура данных, используемая для описания информации о классе объекта в среде Spring. Например, имя класса, область действия, атрибуты, список параметров конструктора, зависимые компоненты, является ли это одноэлементным классом, является ли он отложенной загрузкой и т. д. Фактически, информация об определении компонента хранится в соответствующих атрибутах BeanDefinition. , а информация об определении Bean сохраняется позже.Операция выполняется непосредственно над BeanDefinition.Например, после получения BeanDefinition можно использовать отражение для создания объектов в соответствии с именем класса, конструктором и параметрами конструктора в нем. BeanDefinition — это интерфейс, который является абстрактным определением, и фактически используются его классы реализации, такие как ChildBeanDefinition, RootBeanDefinition, GenericBeanDefinition и т. д. BeanDefinition наследует AttributeAccessor, указывая, что он может обрабатывать атрибуты; BeanDefinition наследует BeanMetadataElement, указывая, что он может содержать элементы метаданных Bean, и его функция состоит в том, чтобы хранить Object, соответствующий тегу bean-компонента в файле XML.

Вы только что упомянули DefaultListableBeanFactory, какова его роль в среде Spring?

DefaultListableBeanFactory — это основная часть загрузки всего bean-компонента и стандартная реализация регистрации и загрузки bean-компонентов в Spring. DefaultListableBeanFactory косвенно реализует интерфейс BeanFactory, и многие методы, связанные с операциями bean, определены в интерфейсе BeanFactory, такие как getBean, containsBean, isSingleton и т. д., поэтому DefaultListableBeanFactory также соответственно поддерживает эти операции.

Тогда что такое BeanFactory?

BeanFactory - это корневой интерфейс, используемый для доступа к контейнеру Spring Bean. Это простая фабрика Bean, которую часто называют определением верхнего уровня контейнера ioc. На его основе расширяются различные контейнеры ioc для удовлетворения различных потребностей, в том числе часто используемый ApplicationContext.

Как понять BeanFactory и FactoryBean?

BeanFactory определяет самую базовую форму контейнера ioc и предоставляет самый простой интерфейс, которому должен соответствовать контейнер ioc, то есть самую низкую и самую базовую спецификацию программирования, которой придерживается Spring ioc.Это просто интерфейс, а не ioc. контейнер. В его обязанности входит: создание экземпляров, поиск, настройка объектов в приложении и установление зависимостей между этими объектами. Давайте поговорим о FactoryBean. В общем, Spring использует атрибут класса bean-компонента для создания экземпляра bean-компонента через механизм отражения. Однако в некоторых случаях процесс создания экземпляра bean-компонента более сложен. Если используется традиционный метод, его необходимо предоставляется в определении bean-компонента. Существует много информации о конфигурации, а гибкость конфигурации ограничена. В этом случае метод кодирования может быть более подходящим решением. Spring предоставляет для этой цели интерфейс фабричного класса FactoryBean. Пользователи могут реализовать этот интерфейс, настроив логику создания экземпляров bean-компонентов.

Если вы хотите изменить свойства бина перед инициализацией, как это сделать?

Настройте BeanFactoryPostProcessor, пусть он реализует интерфейс BeanFactoryPostProcessor и реализует метод postProcessBeanFactory, в котором вы можете изменять свойства bean-компонента перед инициализацией.

Как этот пользовательский BeanFactoryPostProcessor вызывается автоматически?

Он будет автоматически запущен во время инициализации контейнера Spring. Конкретный код вызовет метод invokeBeanFactoryPostProcessors в классе AbstractApplicationContext. В этом методе будут отфильтрованы все имена классов, которые реализуют интерфейс BeanFactoryPostProcessor, а затем метод postProcessBeanFactory из эти классы реализации будут пройдены и вызваны.

Если вы хотите перехватывать и выполнять дополнительные операции инициализации при инициализации компонента, как это реализовать?

Настройте BeanPostProcessor и позвольте ему реализовать интерфейс BeanPostProcessor, в котором определены два метода: postProcessBeforeInitialization и postProcessAfterInitialization. Метод postProcessBeforeInitialization будет выполняться до afterPropertiesSet и пользовательского метода инициализации, благодаря реализации которого внутри метода выполняются дополнительные операции перед инициализацией. Метод postProcessAfterInitialization будет выполняться после afterPropertiesSet и пользовательского метода инициализации, при реализации этого метода внутри метода выполняются дополнительные операции после инициализации.

Все ли определенные bean-компоненты инициализируются во время инициализации контейнера Spring?

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

Вы видели исходный код инициализации бина в Spring?

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

Как Spring разрешает циклические зависимости во время создания экземпляра компонента?

Spring решает только циклическую зависимость singleton bean-компонента, в то же время, если циклическая зависимость вызвана внедрением конструктора, Spring не может решить ее, а генерирует исключение BeanCurrentlyInCreationException. Если это циклическая зависимость, вызванная внедрением сеттера, когда Spring создает объект компонента, он заранее предоставляет ObjectFactory для возврата создаваемого объекта компонента, чтобы другие компоненты могли ссылаться на этот компонент.

Категории