Для чего конкретно Spring Framework? [закрыто]

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

В основном весна является основой для внедрение зависимости это образец, который позволяет строить очень несвязанные системы.

Проблема

Например, предположим, что вам нужно перечислить пользователей системы и, таким образом, объявить интерфейс с именем UserLister:

public interface UserLister {
    List<User> getUsers();
}

И, возможно, реализация доступа к базе данных, чтобы получить всех пользователей:

public class UserListerDB implements UserLister {
    public List<User> getUsers() {
        // DB access code here
    }
}

По вашему мнению, вам нужно получить доступ к экземпляру (просто пример, помните):

public class SomeView {
    private UserLister userLister;

    public void render() {
        List<User> users = userLister.getUsers();
        view.render(users);
    }
}

Обратите внимание, что приведенный выше код не инициализировал переменную userLister . Что нам делать? Если я явно создаю экземпляр объекта следующим образом:

UserLister userLister = new UserListerDB();

... Я бы связал представление с моей реализацией класса, который обращается к БД. Что если я захочу перейти от реализации БД к другой, которая получает список пользователей из файла, разделенного запятыми (помните, это пример)? В этом случае я бы снова пошел к своему коду и изменил строку выше:

UserLister userLister = new UserListerCommaSeparatedFile();

Это не проблема для такой маленькой программы, как эта, но ... Что происходит в программе, которая имеет сотни представлений и такое же количество бизнес-классов? Техническое обслуживание становится кошмаром!

Подход Spring (Dependency Injection)

Что делает Spring, так это связывает классы с помощью XML-файла или аннотаций, таким образом все объекты создаются и инициализируются Spring и внедряются в нужных местах (сервлеты, веб-фреймворки, бизнес-классы, DAO и т. Д. И т. Д. И т. Д. И т. Д. И т. Д., И т. Д.) ...).

Возвращаясь к примеру в Spring, нам просто нужно иметь установщик для userListerполя и иметь XML-файл, подобный этому:

<bean id="userLister" class="UserListerDB" />

<bean class="SomeView">
    <property name="userLister" ref="userLister" />
</bean>

или, более просто, аннотируйте поле в нашем классе представления с помощью @Inject:

@Inject
private UserLister userLister;

Таким образом, когда представление будет создано, оно волшебным образом будет UserListerготово к работе.

List<User> users = userLister.getUsers();  // This will actually work
                                           // without adding any line of code

Это просто супер! Не так ли?

• Что если вы хотите использовать другую реализацию вашего UserListerинтерфейса? Просто измените XML.
• Что, если у вас нет UserListerготовой реализации? Запрограммируйте временную реализацию UserListerи упростите разработку представления.
• Что если я больше не хочу использовать Spring? Только не используйте это! Ваше приложение не связано с ним. Инверсия управления гласит: «Приложение контролирует структуру, а не среда контролирует приложение».

Есть несколько других вариантов внедрения зависимостей, что, на мой взгляд, сделало Spring настолько известным, кроме своей простоты, элегантности и стабильности, что ребята из SpringSource запрограммировали множество POJO, которые помогают интегрировать Spring со многими другими общими фреймворками без навязчиво в вашем приложении. Кроме того, у Spring есть несколько хороших подпроектов, таких как Spring MVC, Spring WebFlow, Spring Security и, опять же, огромный список и так далее.

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

Spring содержит ( как правильно заметил Скаффман ) инфраструктуру MVC. Чтобы объяснить вкратце, вот мои входные данные. Spring поддерживает разделение сервисного уровня, веб-уровня и бизнес-уровня, но на самом деле он лучше всего «внедряет» объекты. Чтобы объяснить это на примере, рассмотрим пример ниже:

public interface FourWheel
{
   public void drive();
}

public class Sedan implements FourWheel
{
   public void drive()
   {
      //drive gracefully
   }
}

public class SUV implements FourWheel
{
   public void drive()
   {
      //Rule the rough terrain
   }
}

Теперь в вашем коде у вас есть класс RoadTrip следующим образом

public class RoadTrip
{
    private FourWheel myCarForTrip;
}

Теперь, когда вы хотите экземпляр Trip; иногда вам может понадобиться внедорожник для инициализации FourWheel, а иногда - седан. Это действительно зависит от того, что вы хотите, в зависимости от конкретной ситуации.

Чтобы решить эту проблему, вы должны иметь фабричный шаблон в качестве шаблона для создания. Где фабрика возвращает правильный экземпляр. Таким образом, в конечном итоге вы получите много связующего кода только для правильной реализации объектов. Spring лучше всего справляется с клеевым кодом без этого клеевого кода. Вы объявляете отображения в XML, и он автоматически инициализирует объекты. Он также много использует одноэлементную архитектуру для экземпляров, и это помогает оптимизировать использование памяти.

Это также называется инверсией контроля. Другие рамки для этого - Google Guice, Pico-контейнер и т. Д.

Помимо этого, Spring имеет платформу проверки, расширенную поддержку уровня DAO в сотрудничестве с JDBC, iBatis и Hibernate (и многими другими). Обеспечивает превосходный транзакционный контроль над транзакциями базы данных.

В Spring есть что-то еще, что можно прочитать в таких хороших книгах, как «Pro Spring».

Следующие URL также могут быть полезны.
http://static.springframework.org/docs/Spring-MVC-step-by-step/
http://en.wikipedia.org/wiki/Spring_Framework
http://www.theserverside.com/tt/articles/article .tss? л = SpringFramework

В прежние времена Spring был фреймом зависимостей, работающим только как ( Guice , PicoContainer , ...), но в настоящее время это комплексное решение для создания вашего корпоративного приложения .

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

В Spring сейчас есть много проектов, каждый из которых имеет несколько подпроектов ( http://spring.io/projects ). Когда кто-то говорит о весне, вы должны выяснить, о каком весеннем проекте он говорит, это только пружинное ядро, известное как пружинный каркас , или это другие весенние проекты.

Некоторые весенние проекты, о которых стоит упомянуть:

• Spring Security - http://projects.spring.io/spring-security/
• Spring Webservices - http://projects.spring.io/spring-ws/
• Spring Integration - http://projects.spring.io/spring-integration/

Если вам нужна еще какая-то конкретная функция для вашего приложения, вы также можете найти ее там:

• Пакетная среда Spring Batch предназначена для разработки
  пакетных приложений.
• Весенний HATEOAS простое создание REST API на основе принципала HATEOAS
• Спринг Мобайл и Спринг Андриод для разработки мобильных приложений
• Spring Shell создает полнофункциональное приложение оболочки (или командную строку)
• Spring Cloud и Spring Cloud Data Flow для облачных приложений

Там также есть несколько крошечных проектов, например, spring-social-facebook ( http://projects.spring.io/spring-social-facebook/ )

Вы можете использовать Spring для веб-разработки, так как он имеет Spring MVCмодуль, который является частью проекта Spring Framework . Или вы можете использовать Spring с другим веб-фреймворком, например struts2 .

Для чего нужна весна? Я отвечу на этот вопрос в ближайшее время, но сначала давайте еще раз посмотрим на пример Виктора Гюго. Это не хороший пример, потому что он не оправдывает необходимость в новой структуре.

public class BaseView {
  protected UserLister userLister;

  public BaseView() {
    userLister = new UserListerDB(); // only line of code that needs changing
  }
}

public class SomeView extends BaseView {
  public SomeView() {
    super();
  }

  public void render() {
    List<User> users = userLister.getUsers();
    view.render(users);
  }
}

Выполнено! Так что теперь, даже если у вас есть сотни или тысячи представлений, вам все равно нужно просто изменить одну строку кода, как в подходе Spring XML. Но изменение строки кода по-прежнему требует перекомпиляции, в отличие от редактирования XML, говорите вы? Ну, мой суетливый друг, используйте муравья и сценарий прочь!

Так для чего весна? Это для:

1. Слепые разработчики, которые следуют за стадом
2. Работодатели, которые никогда не хотят нанимать дипломированных программистов, потому что они не преподают такие основы в Uni
3. Проекты, которые начинались с плохого дизайна и нуждаются в пэчворке (как показано на примере Виктора Гюго)

Дополнительное чтение: http://discuss.joelonsoftware.com/?joel.3.219431.12

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

Весна это три вещи.

1. Spring обрабатывает Dependency Injection, и я рекомендую вам прочитать отличное введение Martin Fowler по внедрению зависимостей.
2. Второе, что делает Spring, - это оборачивает превосходные библиотеки Java очень элегантным способом для использования в ваших приложениях. Для хорошего примера посмотрите, как Spring оборачивает Task Executors и Quartz Scheduler.
3. В-третьих, Spring предоставляет множество реализаций веб-контента, таких как REST, веб-фреймворк MVC и многое другое. Они рассчитывают, так как вы используете Spring для первых двух, возможно, вы можете просто использовать его для всего, что нужно вашему веб-приложению.

Проблема в том, что Spring DI действительно хорошо продуман, обертки вокруг других вещей действительно хорошо продуманы в том, что другие вещи продумали все, и Spring просто оборачивает это. Реализация Spring в MVC и REST и все остальное не так хорошо сделано (YMMV, IMHO), но есть исключения (Spring Security - это бомба). Поэтому я склонен использовать Spring для DI и его классные обертки, но предпочитаю другие вещи для Web (мне очень нравится Tapestry), REST (Джерси действительно крепкий) и т. Д.

Что вы, вероятно, хотели бы в веб-приложении с Spring -

• Spring MVC, который с 2.5+ позволяет вам использовать POJO в качестве классов контроллеров, то есть вам не нужно расширяться от какой-либо конкретной среды (как в Struts или Spring pre-2.5). Классы контроллеров также очень просты в тестировании, отчасти благодаря внедрению зависимостей
• Интеграция Spring с Hibernate, которая хорошо упрощает работу с этим решением ORM (в большинстве случаев)
• Использование Spring для веб-приложения позволяет использовать ваши доменные объекты на всех уровнях приложения - те же классы, которые отображаются с помощью Hibernate, - это классы, которые вы используете в качестве «форм-компонентов». По своей природе это приведет к созданию более надежной модели предметной области, отчасти потому, что она сократит количество классов.
• Весенние теги форм позволяют создавать формы без особых хлопот.

Кроме того, Spring - ОГРОМНЫЙ - поэтому есть много других вещей, которые вы могли бы заинтересовать в веб-приложении, таких как Spring AOP или Spring Security. Но четыре вещи, перечисленные выше, описывают общие компоненты Spring, которые используются в веб-приложении.

Я вижу две части к этому:

1. «Для чего именно весна» -> см. Принятый ответ Виктора Гюго.
2. «[...] Spring - [[]] хорошая основа для веб-разработки» -> люди, говорящие это, говорят о Spring MVC. Spring MVC является одной из многих частей Spring и представляет собой веб-фреймворк, использующий общие функции Spring, такие как внедрение зависимостей. Это довольно универсальный фреймворк в том смысле, что он очень настраиваем: вы можете использовать разные слои БД (Hibernate, iBatis, обычный JDBC), разные слои представления (JSP, Velocity, Freemarker ...)

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

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

Ваши объекты доступа к данным всегда будут нуждаться в доступе Hibernate, Spring связывает классы Hibernate с вашими DAO для вас.

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

Весна действительно отличный инструмент. (Я не говорил о Spring MVC, просто о базовых рамках).

Принятый ответ не включает использование аннотаций, так как Spring представил поддержку различных аннотаций для конфигурации.

Подход Spring (Dependency Injection)

Есть еще один способ связать классы вместе с использованием файла XML: аннотации. Давайте использовать пример из принятого ответа и зарегистрировать компонент непосредственно на классе , используя один из аннотаций @Component, @Service, @Repositoryили @Configuration:

@Component
public class UserListerDB implements UserLister {
    public List<User> getUsers() {
        // DB access code here
    }
}

Таким образом, когда представление создается, оно волшебным образом будет иметь готовый к работе пользовательский список.

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

@Autowired
private UserLister userLister;

Используйте @Beanаннотацию к методу, который используется для внедрения реализации bean-компонента.

Преимущество - Dependency Injection (DI) . Это означает аутсорсинг задачи создания объекта. Позвольте мне объяснить на примере.

public interface Lunch
{
   public void eat();
}

public class Buffet implements Lunch
{
   public void eat()
   {
      // Eat as much as you can 
   }
}

public class Plated implements Lunch
{
   public void eat()
   {
      // Eat a limited portion
   }
}

Теперь в моем коде у меня есть класс LunchDecide следующим образом:

public class LunchDecide {
    private Lunch todaysLunch;
    public LunchDecide(){
        this.todaysLunch = new Buffet(); // choose Buffet -> eat as much as you want
        //this.todaysLunch = new Plated(); // choose Plated -> eat a limited portion 
    }
}

В приведенном выше классе, в зависимости от нашего настроения, мы выбираем Buffet () или Plated (). Однако эта система тесно связана. Каждый раз, когда нам нужен другой тип объекта, нам нужно изменить код. В этом случае закомментируйте строку! Представьте, что 50 разных классов используют 50 разных людей. Это был бы адский беспорядок. В этом случае нам нужно отделить систему. Давайте перепишем класс LunchDecide.

public class LunchDecide {
    private Lunch todaysLunch;
    public LunchDecide(Lunch todaysLunch){
        this.todaysLunch = todaysLunch
        }
    }

Обратите внимание, что вместо создания объекта с использованием нового ключевого слова мы передали ссылку на объект типа обеда в качестве параметра нашему конструктору. Здесь создание объекта передается на аутсорсинг. Этот код может быть связан либо с использованием файла конфигурации Xml (устаревший), либо с помощью аннотаций Java (современный). В любом случае решение о том, какой тип объекта будет создан, будет приниматься там во время выполнения. Xml может внедрить объект в наш код - наш код зависит от Xml для этой работы. Следовательно, Dependency Injection (DI). DI не только помогает сделать нашу систему слабо связанной, но и упрощает написание модульных тестов, поскольку позволяет имитировать зависимости. И последнее, но не менее важное: DI оптимизирует аспектно-ориентированное программирование (AOP), что приводит к дальнейшему разделению и повышению модульности. Также обратите внимание, что над DI находится Constructor Injection.

• Spring - это легкий и гибкий каркас по сравнению с J2EE.
• Пружинный контейнер действует как инверсия управления.
• Spring использует AOP, т.е. прокси и шаблоны Singleton, Factory и Template Method Design.
• Многоуровневая архитектура: разделение задач и многоразовых слоев и простота обслуживания.

Spring - хорошая альтернатива технологии Enterprise JavaBeans (EJB) . Он также имеет веб-фреймворк и компонент веб-сервисов.

Spring начинался как довольно простая система внедрения зависимостей. Теперь он огромен и в нем есть все (кроме общеизвестной раковины).

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

Чтобы увидеть, с чего все началось, попробуйте:

http://www.amazon.com/Expert-One-Design-Development-Programmer/dp/0764543857/ref=sr_1_1?ie=UTF8&s=books&qid=1246374863&sr=1-1

Это может быть старый, но это отличная книга.

Еще одна хорошая книга, посвященная весне, на этот раз:

http://www.amazon.com/Professional-Java-Development-Spring-Framework/dp/0764574833/ref=sr_1_2?ie=UTF8&s=books&qid=1246374863&sr=1-2

Он также ссылается на более старые версии Spring, но определенно стоит посмотреть.

Spring был внедрением зависимостей в начале, затем добавил короля оберток для почти всего (обертки над реализациями JPA и т. Д.).

Длинная история ... большинство компонентов Spring преферрируют XML-решения (механизм сценариев XML ... brrrr), поэтому для DI я использую Guice

Хорошая библиотека, но с растущим depnedenciec, например Spring JDBC (может быть, одно решение Java jdbc с параметрами реальных имен), взятое из maven 4-5 далее.

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

В прошлом я думал о Spring Framework с чисто технической точки зрения.

Учитывая некоторый опыт командной работы и разработки корпоративных веб-приложений, я бы сказал, что Spring предназначен для более быстрой разработки приложений (веб-приложений) путем отделения его отдельных элементов (компонентов). Более быстрое развитие делает его таким популярным. Spring позволяет переложить ответственность за сборку (подключение) приложения на среду Spring. Инъекция зависимостей в среду Spring отвечает за соединение / подключение отдельных bean-компонентов в работающее приложение.

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

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

Платформа Spring определяет несколько специализированных bean-компонентов, таких как @Controller ( @Restcontroller ), @Repository , @Component, для обслуживания веб-целей. Spring вместе с Maven обеспечивают интуитивно понятную для разработчиков структуру. Командная работа проста и быстра, так как отдельные элементы хранятся отдельно и могут быть использованы повторно.

Spring Framework, безусловно, хорош для веб-разработки и, более конкретно, для остальных API-сервисов.

Это хорошо для вышеупомянутого из-за его внедрения зависимости и интеграции с другими модулями, такими как Spring Security , Spring AOP , MVC Framework , микросервисы

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

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

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

Spring Data - это один проект, который обеспечивает интеграцию с вашим проектом.

Так что весна может вписаться практически в любое требование.