Использование Spring @Autowired

https://stackoverflow.com/questions/633158

08-07-2019
|

Вопрос

Каковы плюсы и минусы использования @Автоматическое подключение в классе, который будет подключен к весне?

Просто чтобы уточнить, я говорю конкретно о @Автоматическое подключение аннотация, а не автоматическое подключение в XML.

Возможно, я просто этого не понимаю, но для меня это почти похоже на антишаблон - ваши классы начинают осознавать, что они привязаны к фреймворку DI, а не просто являются POJOS.Может быть, я жажду наказаний, но мне нравится иметь внешнюю XML-конфигурацию для beans, и мне нравится иметь явные проводки, поэтому я точно знаю, что и куда подключено.

Решение

В течение долгого времени я считал, что наличие «!» централизованной, декларативной конфигурации " как XML-файлы, которые мы все использовали. Затем я понял, что большинство файлов в файлах не было конфигурацией - это никогда не менялось нигде после разработки, никогда. Тогда я понял, что & Quot; централизованный & Quot; имеет значение только в довольно маленьких системах - только в маленьких системах вы сможете получить конфигурационный файл в целом . И какова на самом деле ценность понимания проводки в целом, когда тот же & Quot; wirings & Quot; в основном дублируются зависимостями в коде? Поэтому единственное, что я сохранил, - это метаданные (аннотации), которые все еще являются декларативными. Эти никогда не изменяются во время выполнения, и они никогда & Quot; конфигурация & Quot; данные, которые кто-то изменит на лету - поэтому я думаю, что хранить их в коде - это хорошо.

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

Прямо сейчас я думаю, что наиболее важной причиной использования автопроводки является то, что в вашей системе есть одна абстракция, которую нужно отслеживать. & Quot; имя бина & Quot; фактически ушел Оказывается, имя компонента существует только из-за xml. Таким образом, полный слой абстрактных косвенных указаний (где вы бы подключили bean-name & Quot; foo & Quot; в bean & Quot; bar & Quot;) пропал. Теперь я подключаю & Quot; Foo & Quot; интерфейс в мой бин, и реализация выбирается по профилю времени выполнения. Это позволяет мне работать с кодом при отслеживании зависимостей и реализаций. Когда я вижу в своем коде автосвязанную зависимость, я могу просто нажать & Quot; перейти к реализации & Quot; ключ в моей IDE и вверх приходит список известных реализаций. В большинстве случаев есть только одна реализация, и я прямо в классе. Не может быть намного проще, и я всегда точно знаю, какая реализация используется (я утверждаю, что обратная сторона ближе к истине с проводкой xml - забавно, как меняется ваша перспектива!)

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

Большинство систем, с которыми я когда-либо работал, имеют только одну конфигурацию рабочей среды выполнения. Там могут быть другие конфигурации для тестирования и т. Д.

Я бы сказал, что полная автоматическая разводка - это пружина на рельсах: она охватывает идею о том, что существует нормальная и распространенная схема использования, которой придерживаются большинство вариантов использования. С конфигурацией XML вы разрешаете много последовательного / противоречивого использования конфигурации, которое может / не может быть предназначено. Я видел, как много xml-конфигураций выходят за рамки несогласованностей - реорганизуются ли они вместе с кодом? Мысль нет. Есть ли эти вариации по какой-то причине? Обычно нет.

Мы почти не используем квалификаторы в нашей конфигурации и нашли другие способы решения этих ситуаций. Это явный & Недостаток & Quot; мы сталкиваемся: мы немного изменили способ кодирования, чтобы он стал более плавным при взаимодействии с автопроводкой: хранилище клиентов больше не реализует универсальный интерфейс Repository<Customer>, но мы создаем интерфейс CustomerRepository, который расширяет @Component. Иногда также есть хитрость или два, когда дело доходит до подклассов. Но это, как правило, просто указывает нам направление более строгой типизации, которое, как я считаю, почти всегда является лучшим решением.

Но да, вы привязаны к определенному стилю DI, который в основном связан с весной. Мы даже больше не публикуем сеттеры для зависимостей (так что вы можете утверждать, что мы +1 в отделе инкапсуляции / скрытия информации) У нас все еще есть некоторый xml в нашей системе, но xml в основном only содержит аноmalies. Полное автоматическое подключение прекрасно интегрируется с XML.

Теперь нам нужно только, чтобы java.util.concurrent, <=> и остальные были включены в JSR (например, JSR-250 ), поэтому нам не нужно связываться с пружиной. Так происходило в прошлом (на ум приходит <=> материал), поэтому я не удивлюсь, если это снова произойдет.

Другие советы

Для меня вот что мне нравится / не нравится в пружинах и автоматической проводке.

Плюсы:

Автоматическое подключение избавляет от неприятной конфигурации XML.
Гораздо проще в использовании аннотации, которые позволяют вводить непосредственно с помощью полей, методов настройки или конструкторов.Также позволяет вам комментировать и "квалифицировать" введенные вами компоненты.

Минусы:

Использование автоматической проводки и аннотаций делает вас зависимым от библиотек Spring, где, как и в случае с конфигурацией XML, вы могли бы работать с Spring или без него.Как вы сказали, вы становитесь привязаны к фреймворку DI.
В то же время мне нравится иметь возможность "квалифицировать" beans, на мой взгляд, это делает код действительно запутанным.Если вам нужно ввести один и тот же компонент в нескольких местах, я видел, что одно и то же имя строки повторяется повсюду.Мне кажется, что это чревато ошибками.

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

Я думаю, что автоматическое подключение - это приобретенный вкус, как только вы привыкнете к нему, вы поймете, насколько мощно, легко и с гораздо меньшей головной болью работать, чем с конфигурацией XML.

В нашем большом проекте мы переключаемся с @Autowire на конфигурацию XML. Проблема заключается в очень низкой производительности начальной загрузки. Сканер автопроводки загружает все классы из пути поиска по автопроводке, поэтому во время инициализации Spring многие классы загружаются с нетерпением.

Было очень мало дискуссий о переключении сред. Большинство проектов, над которыми я работал, было реальной проблемой для внедрения зависимостей в зависимости от среды, над которой мы работаем. С xml config это довольно просто с Spring EL, и я не знаю ни одного хорошего решения с аннотациями. Я только что понял один:

    @Value("#{${env} == "production" ? realService : dummyService}")
    private SomeService service;

Это должно работать, но не очень хорошее решение imho.

Я перешел на @Autowire. Поддержка конфигурации XML для чего-либо, кроме небольшого проекта, стала самостоятельной задачей, и понимание быстро ухудшилось.

IntelliJ обеспечивает хорошую (не идеальную) поддержку аннотаций Spring.

Мое мнение на эту тему заключается в том, что конфигурация xml снижает ясность кода, особенно в больших системах.

Аннотации типа @Component делают вещи еще хуже. Это заставляет разработчиков делать объекты изменяемыми, поскольку зависимости больше не могут быть окончательными, учитывая необходимость предоставления конструкторов по умолчанию. Зависимости должны быть либо введены через общедоступный сеттер, либо неуправляемы через @Autowired. [еще худшее внедрение зависимостей скомпрометировано с классами, которые создают их зависимости, я все еще вижу это во вновь написанном коде!]. Под неконтролируемым я подразумеваю, что в больших системах, когда доступно несколько реализаций (или дочерних элементов) этого типа, гораздо сложнее понять, какая из реализаций была @Autowired, - сложность, которая значительно усложняет исследование ошибок. Это также означает, что, предположительно, у вас есть профиль для тестовой среды, а другой - для производства, ваши производственные ошибки будут возникать только тогда, когда это наносит наибольший вред - на производстве, вместо того, чтобы обнаруживать ошибки в тестовой среде или, что еще лучше, в время компиляции!

Я придерживаюсь середины, где я объявляю свой класс (ы) конфигурации (конфигурация Spring на основе Java с использованием @Configuration)

Я объявляю все мои компоненты явно в классе (ах) конфигурации. Я использую только @Autowired в классе (ах) конфигурации, целью является ограничение зависимости от Spring для класса (ов) конфигурации

@Configuration находится в определенном пакете, это единственное место, где выполняется весеннее сканирование. (Это существенно ускоряет время запуска в крупных проектах)

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

Сокращение возможностей изменения объектов после их создания существенно уменьшает количество ошибок в большой системе, а также сокращает время на обнаружение ошибки, когда она существует.

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

Вот некоторые из накопленного опыта
Плюсы

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

Минусы

Плотно привязан к XML-файлу, даже если мы используем DI
Трудно найти реализацию (но если вы используете хорошие ide, такие как intellij, уверен, вы сможете избавиться от этого)

Исходя из моего личного опыта, я не так часто использовал аннотацию @AutoWire, но в тестовых случаях.

Я действительно люблю писать с помощью аннотаций, а не XML.Согласно руководству Spring и последним версиям, XML и Annotation достигли того же результата.

Это мой список

Профессиональный:

Удалить бесполезную строку из xml
Упростите отладку кода:когда вы открываете класс, вы можете прочитать, что у вас есть в этом классе
Более быстрая разработка, проект с 400 или более строками XML доступен для чтения?

Минусы:

Это не стандартная реализация Java, но вы можете переключиться на использование @Inject, который является стандартным Java Api, поэтому компонент остается Pojo
Вы не можете просто использовать везде, подключение к базе данных и так далее, но это всего лишь мнение, я предпочитаю иметь место, где можно прочитать всю конфигурацию.

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

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow