Для чего именно нужен Spring Framework?

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

Проблема

Например, предположим, что вам нужно перечислить пользователей системы и таким образом объявить интерфейс с именем 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 (внедрение зависимостей)

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 Documentation, на мой взгляд, это раньше было лучшей весенней книгой.

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 container и т. Д.

Помимо этого, 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?l=SpringFramework

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

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

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

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

• Spring Security - http://projects.spring.io/spring-security/
• Веб-службы Spring - http://projects.spring.io/spring-ws/
• Интеграция Spring - http://projects.spring.io/spring-integration/

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

• Пакетная среда Spring Batch, предназначенная для разработки
  пакетных приложений.
• Spring HATEOAS простое создание REST API на основе принципала HATEOAS
• Spring Mobile и Spring Andriod для разработки мобильных приложений.
• 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, как вы говорите? Что ж, мой суетливый друг, используйте Ant и скрипт прочь!

Так для чего нужна Spring? Это для:

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

Дополнительная литература: http://discuss.joelonsoftware.com/?joel.3.219431.12

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

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

1. Spring обрабатывает внедрение зависимостей, и я рекомендую вам прочитать отличное введение Мартина Фаулера по внедрению зависимостей.
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 и его классные оболочки, но предпочитаю другие вещи для Интернета (мне очень нравится Tapestry), REST (Джерси действительно надежен) и т. д.

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

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

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

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

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

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

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

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

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

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

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

Подход с использованием аннотаций Spring (внедрение зависимостей)

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

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

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

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

@Autowired
private UserLister userLister;

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

Преимущество заключается в внедрении зависимостей (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 
    }
}

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

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

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

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

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

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

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

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

https://rads.stackoverflow.com/amzn/click/com/0764543857

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

Еще одну хорошую книгу, на этот раз посвященную исключительно весне, см .:

https://rads.stackoverflow.com/amzn/click/com/0764574833

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

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

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

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

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

Раньше я думал о фреймворке Spring с чисто технической точки зрения.

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

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

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

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

Фреймворк Spring определенно хорош для веб-разработки, а точнее - для спокойных сервисов api.

Это хорошо для вышеуказанного из-за его зависимости внедрение и интеграция с другими модулями, такими как Spring security, пружинный наконечник, mvc framework, микросервисы

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

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

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

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

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