Как вы справляетесь с дополнительной сложностью, добавляемой бобами весны?

Question

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

При использовании Spring для создания бэков поддержки веб-приложений объекты более четко не организованы в модули и не имеют наименьшей возможной видимости. Вместо этого теперь существует единое глобальное пространство имен бинов. Из-за этого объекты, как правило, получают ужасные имена, такие как 'pendingOrderCustomerName', и, что еще хуже, такие имена даже не четко идентифицируют четко определенную сущность, поскольку определения бинов могут поступать из различных источников определений, собранных из открыто указанных местоположений: Вместо того, чтобы определяться просто как класс в пакете, бины Spring собираются из файлов xml со свободными возможностями переопределения и свободно определенными отношениями.

Например, когда у меня есть тип "Учетная запись" на обычном Java, в пакете "my.webstore" я обычно могу узнать о свойствах, отношениях и способностях этого типа в одном месте, "my/webstore/Account". Ява "файл. Экземпляры "Account" существуют как ссылки в объектах, работающих с учетными записями, состояние любого экземпляра точно определяется классом. Однако с бобами Spring все усложняется: теперь экземпляр "Account" существует под глобальным именем в области, управляемой контейнером, с состоянием, собираемым из файлов xml, найденных по пути поиска файлов на основе шаблонов именования....

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

Может быть, это просто вопрос вкуса, но мне также интересно, почему люди предпочитают многословный, неуклюжий синтаксис xml, например:

  <bean id="p1" class="Point" scope="prototype">
    <property name="x">
      <value>20</value>
    </property>
    <property name="y">
      <value>80</value>
    </property>
  </bean>

через это:

  p1 = new Point(20,80);

Этот пример может показаться преувеличенным, но я говорю вам, что видел хуже!

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

Answer 1

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

• определить модель компонента (например, контроллеры, сервисы, репозитории и их зависимости)
• централизованный поиск зависимостей компонентов (например, замените ваши сервисные локаторы, JNDI-поиск или другие стратегии поиска компонентов без сохранения состояния)
• украшать компоненты техническими аспектами (например, управление транзакциями, кэширование, контроль доступа и т. д.)

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

Конечно, вы ничего не получите (и на самом деле много потеряете), если начнете определять Accountс и Pointкак компоненты Spring. Они все еще должны быть спроектированы как объекты или объекты стоимости. Они все еще должны быть частью надлежащего пакета, и должны применяться соответствующие модификаторы видимости. Их по-прежнему следует создавать, манипулировать ими и управлять ими с помощью стратегий, которые вы бы использовали, если бы ваше приложение не использовало контейнер IoC.

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

Я также призываю вас исследовать, как использовать @Component а также <context:component-scan> декларации для сокращения площади XML.

Удачи.

Answer 2

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

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

Для меня мотивация Guice побудила меня понять больше о внедрении зависимости, это в равной степени относится и к Spring.

Тем не менее, вы можете проверить аннотации Spring, чтобы увидеть, как ваша конфигурация и код могут храниться в одном месте.