Перевод официального документа Spring (главы 1–6)

задняя часть Spring

Официальная документация Spring:docs.spring.IO/весна/документы…

1. Обзор Spring Framework

Spring Framework — это легкое решение для создания приложений корпоративного уровня за одну остановку. Spring является модульным, поэтому вы можете использовать только те части, которые вам нужны. Вы можете использовать Inversion of Control (IoC) в любой веб-инфраструктуре или просто использоватьКод интеграции со спящим режимомилиУровень абстракции JDBC. Он поддерживает декларативное управление транзакциями, удаленный доступ через RMI или веб-службы и может сохранять данные различными способами. Он обеспечивает полноценныйФреймворк MVC, можно прозрачно интегрироватьAOPв программное обеспечение.

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

Этот документ является справочным руководством по Spring Framework, если у вас есть пожелания, комментарии или вопросы,пожалуйста, напишите нам, вопросы по самому фреймворку будут обсуждаться на StackOverflow (см.spring.io.questions).

1. Начало работы с Spring

Это справочное руководство содержит подробную информацию о Spring Framework, включая полное понимание всех функций, а также справочную информацию о некоторых важных концепциях (например, внедрение зависимостей).

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

можно использоватьstart.spring.ioили следуйтеРуководство по началу работы(Например,Приступаем к созданию веб-приложений RESTful) для создания базового проекта. Помимо того, что эти руководства просты для понимания, они сгруппированы по задачам, большинство из которых основаны на Spring Boot, но также включают другие проекты в рамках пакета Spring, чтобы вы могли подумать, когда их использовать для решения конкретных проблем. .

2. Введение в Spring Framework

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

Spring может использовать POJO (простые старые объекты Java) для создания приложений и может неинвазивно применять корпоративные сервисы к POJO. Эта функция применяется к модели программирования Java SE, а также ко всей или части Java EE.

Итак, какие преимущества вы можете получить от Spring как разработчик?

  • Транзакции базы данных можно выполнять, не заботясь об API транзакций;
  • Вы можете использовать удаленные операции, не заботясь об удаленном API;
  • Операции управления можно выполнять, не заботясь о JMX API;
  • Обработку сообщений можно выполнять, не заботясь о JMS API.

Примечание переводчика: ① JMX, Java Management eXtension, расширение управления Java, представляет собой структуру для внедрения функций управления для приложений, устройств, систем и т. д. JMX может гибко разрабатывать плавно интегрированные приложения для управления системами, сетями и службами для ряда гетерогенных платформ операционных систем, системных архитектур и сетевых протоколов передачи. ②JMS, служба сообщений Java, служба сообщений Java — это техническая спецификация промежуточного программного обеспечения, ориентированного на сообщения (MOM), на платформе Java, которое облегчает обмен сообщениями между приложениями Java в системе сообщений и обеспечивает стандартное генерирование, отправку и получение. сообщений.Интерфейс упрощает разработку корпоративных приложений.

2.1 Внедрение зависимостей (DI) и инверсия управления (IoC)

Приложение Java, от ограниченного встроенного приложения до n-уровневого серверного приложения, обычно состоит из взаимодействующих друг с другом объектов, поэтому объекты в приложении взаимозависимы.

Хотя платформа Java обеспечивает широкие возможности разработки приложений, она не организует эти основные строительные блоки в непрерывное целое, а оставляет эту задачу архитекторам и разработчикам. Вы можете использовать шаблоны проектирования, такие как Factory, Abstract Factory, Creator, Decorator и Service Locator, для создания различных классов и экземпляров объектов, составляющих целое приложение. Эти шаблоны проектирования очень просты, ключ в том, что они хорошо названы в соответствии с лучшими практиками, и их имена хорошо описывают то, что они делают, где они используются, какие проблемы они решают и т. д. Эти шаблоны проектирования являются результатом лучших практик, поэтому вы должны использовать их в своем приложении.

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

задний план

Мартин Фаулер в 2004 годуего сайтОн поднял вопрос об инверсии управления (IoC): «Вопрос в том, какой аспект управления [они] инвертируют?», а позже предложил переименовать принцип, чтобы сделать его самоочевидным, тем самым предложив концепцию внедрения зависимостей (Dependency Injection). DI, внедрение зависимостей).

2.2 Модули

Spring содержит около 20 модулей, которые составляют основной контейнер (Core Container), доступ/интеграцию данных (Data Access/Integration), Web, AOP (Aspect Oriented Programming), инструментарий, обработку сообщений (Messaging) и тестирование (Test), а также показано ниже:

Рисунок 2.1 Обзор Spring Framework
spring框架概述

Модули и их темы, соответствующие каждой функции, перечислены ниже, и все они имеют имена артефактов, соответствующиеИнструмент управления зависимостямисерединаartifact idсоответствуют друг другу.

2.2.1 Основной контейнер

Основной контейнер включает в себяspring-core,spring-beans,spring-context,spring-context-supportиspring-expression(SpEL, Spring Expression Language, Spring Expression Language) и другие модули.

spring-coreиspring-beansмодульОсновы Spring Framework, включая такие функции, как инверсия управления и внедрение зависимостей. BeanFactory — это тонкая реализация фабричного шаблона, которая устраняет необходимость в закодированных синглтонах и отделяет конфигурацию и зависимости от фактической логики кодирования.

Context(spring-context) модуль находится вЯдро и БинПостроенный на основе модулей, он обращается к объектам аналогично реестру JNDI. Модуль Context наследуется от модуля Bean и добавляет такие функции, как интернационализация (например, с использованием пакетов ресурсов), распространение событий, загрузка ресурсов и создание прозрачного контекста (например, с помощью контейнера Servlet). Модуль Context также поддерживает Java. Функции EE, такие как EJB, JMX и удаленные вызовы.ApplicationContextИнтерфейс является фокусом модуля Context.spring-context-supportОбеспечивает поддержку интеграции сторонних библиотек в контекст Spring, таких как кэширование (EhCache, Guava, JCache), почта (JavaMail), планирование (CommonJ, Quartz), механизмы шаблонов (FreeMarker, JasperReports, Velocity) и т. д.

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

2.2.2 АОП и инструментарий

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

spring-aspectsМодули обеспечивают интеграцию с AspectJ.

spring-instrumentМодули обеспечивают поддержку инструментированных классов и реализации загрузчиков классов для конкретных серверов приложений.spring-instrument-tomcatМодуль содержит прокси-сервер обнаружения Spring для tomcat.

2.2.3 Обработка сообщений (обмен сообщениями)

В комплекте с Весной 4spring-messagingМодули взяты из ключевых абстракций из проектов интеграции Spring, которые включаютMessage,MessageChannel,MessageHandlerи другие элементы, которые служат для обработки сообщений. Этот модуль также содержит набор аннотаций для сопоставления сообщений с методами, аналогично аннотациям Spring MVC, основанным на модели кодирования.

2.2.4 Доступ к данным и интеграция

Уровень доступа к данным и интеграции содержит JDBC, ORM, OXM, JMS и модули транзакций. (Примечание переводчика: JDBC = подключение к базе данных Java, ORM = реляционное сопоставление объектов, OXM = сопоставление объектов XML, JMS = служба сообщений Java)

spring-jdbcмодуль обеспечиваетJDBCУровень абстракции, который устраняет многословное кодирование JDBC и синтаксический анализ кодов ошибок, зависящих от поставщика базы данных.

spring-txПоддержка модуляПрограммные и декларативные транзакции, доступный для классов и всех объектов POJO, реализующих определенный интерфейс.
(Примечание переводчика: для программных транзакций необходимо написать свои собственные методы управления транзакциями, такие как beginTransaction(), commit(), rollback(), декларативные транзакции автоматически обрабатываются Spring с помощью аннотаций или конфигурации, а программные транзакции более детализированы)

spring-ormмодуль предоставляет доступ к популярнымРеляционное сопоставление объектовИнтеграция с API, в том числеJPA,JDOиHibernateЖдать. С помощью этого модуля эти структуры ORM могут быть интегрированы с другими функциями Spring, такими как упомянутое выше управление транзакциями.

spring-oxmмодуль обеспечиваетOXMРеализована поддержка JAXB, Castor, XML Beans, JiBX, XStream и др.

spring-jmsМодули содержат функции для создания и потребления сообщений. Начиная с Spring 4.1, интегрированоspring-messagingмодуль.

2.2.5 Web

Веб-уровень включаетspring-web,spring-webmvc,spring-websocket,spring-webmvc-portletи другие модули.

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

spring-webmvcМодули (т. е. модули веб-сервлетов) обеспечивают управление представлением модели для веб-приложений (MVC) и реализация веб-сервисов REST. Фреймворк MVC Spring может полностью разделить код модели предметной области и веб-формы и может быть интегрирован со всеми другими функциями фреймворка Spring.

spring-webmvc-portletМодули (т. е. модули веб-портлета) обеспечивают реализацию MVC для среды портлета и отражаютspring-webmvcфункция модуля.

2.2.6 Test

spring-testМодули поддерживаются компонентами JUnit и TestNG.модульный тестиИнтеграционное тестирование. Он обеспечивает последовательноенагрузкаитайникКонтекст Spring, который также обеспечивает изолированное тестирование кода.фиктивный объект(ложный предмет).

2.3 Сценарии использования

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

Рисунок 2.2 Типичное зрелое веб-приложение Spring
典型的成熟的Spring web应用程序

ВеснаДекларативное управление транзакциямиВеб-приложения можно сделать транзакционными, как и при использовании транзакций, управляемых контейнером EJB. Вся пользовательская бизнес-логика может быть реализована с использованием простых POJO и управляться контейнером IoC Spring. Также включает функции отправки по электронной почте и проверки, где функции проверки отделены от веб-уровня, и вы сами решаете, где выполнять проверку. ORM Spring может интегрировать JPA, Hibernate и JDO и т. д. Например, при использовании Hibernate вы можете продолжать использовать существующий файл сопоставления и стандартную конфигурацию SessionFactory Hibernate. Контроллер форм легко интегрирует веб-уровень с моделью предметной области, удаляя ActionForms и другие классы, которые переводят параметры HTTP в модель предметной области.

Рисунок 2.3 Промежуточное ПО Spring с использованием сторонних веб-фреймворков
使用第三方web框架的Spring中间件

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

Рисунок 2.4 Сценарий использования удаленного вызова
远程调用使用场景

Когда вам нужно получить доступ к существующему коду через веб-сервисы, вы можете использовать SpringHessian-,Burlap-,Rmi-илиJaxRpcProxyFactoryКласс, удаленный доступ к существующим приложениям не представляет сложности.

Рисунок 2.5: EJB — упаковка существующего POJO
EJB-包装现有的POJO

Spring framework также предоставляет EJBДоступ к уровню абстракции, вы можете повторно использовать существующие POJO и обернуть их в сеансовые компоненты без сохранения состояния для использования в масштабируемых и безопасных веб-приложениях.

2.3.1 Управление зависимостями и соглашения об именах

Управление зависимостями и внедрение зависимостей — это две разные вещи. Чтобы приложение имело эти удивительные возможности Spring (такие как внедрение зависимостей), все необходимые jar-файлы необходимо импортировать и поместить в путь к классам во время выполнения и, если возможно, во время компиляции. Эти зависимости не являются внедренными виртуальными компонентами, а обычно являются физическими ресурсами в файловой системе. Процесс управления зависимостями включает в себя поиск этих ресурсов, их сохранение и добавление в путь к классам. Зависимости могут быть прямыми (например, зависимость времени выполнения от Spring) или косвенными (например, зависимость от Spring).commons-dbcp,commons-dbcpзависит отcommons-pool). Косвенные зависимости, также известные как «транзитивные», сложнее всего идентифицировать и управлять ими.

Если вы планируете использовать Spring, вам необходимо скопировать пакет Spring jar необходимых модулей. Для простоты использования Spring упакован в серию модулей, чтобы максимально уменьшить зависимости.Например, если вы не пишете веб-приложение, нет необходимости импортировать модуль spring-web. Модули Spring, задействованные в этом документе, мы используемspring-*илиspring-*.jarсоглашение об именах, где,*Краткое имя, представляющее модуль (например,spring-core,spring-webmvc,spring-jmsи т.д). Фактически используемый пакет jar обычно имеет номер версии (например,spring-core-4.3.0.RELEASE.jar).

Каждая версия Spring публикует артефакты в следующих местах:

  • Центральный репозиторий Maven, репозиторий запросов Maven по умолчанию, который можно использовать без специальной настройки. Многие общедоступные библиотеки, от которых зависит Spring, также доступны в центральном репозитории Maven, и большая часть сообщества Spring также использует Maven в качестве инструмента управления зависимостями, так что это удобно. Формат именования пакетов jar в Maven:spring-*-<version>.jar, идентификатор группы которого равен org.springframework.
  • Специально для размещения общедоступного репозитория Spring Maven. В дополнение к финальному общедоступному выпуску в этом репозитории также размещаются моментальные снимки разработки и промежуточные выпуски. JAR-файлы называются так же, как и в центральном репозитории Maven, поэтому это также полезное место для получения версии Spring для разработки, которую можно использовать с другими библиотеками, развернутыми в центральном репозитории Maven. Этот репозиторий также содержит zip-файлы дистрибутива, связанные со всеми jar-файлами Spring для легкой загрузки.

Поэтому первое, что нужно сделать, это решить, как управлять зависимостями.Обычно мы рекомендуем использовать автоматическую систему управления, такую ​​как Maven, Gradle или Ivy.Конечно, вы также можете загрузить все jar-файлы вручную.

Артефакты Spring перечислены ниже, а более полное описание каждого модуля см.2.2 Модулиглава.

Таблица 2.1 Артефакты Spring Framework

groupId artifactId описывать
org.springframework spring-aop АОП на основе прокси
org.springframework spring-aspects AspectJ на основе аспектов
org.springframework spring-beans поддержка компонентов, включая Groovy
org.springframework spring-context Контекст времени выполнения, включая планирование и абстракции удаленных вызовов
org.springframework spring-context-support Содержит классы для интеграции сторонних библиотек в контекст Spring.
org.springframework spring-core Основная библиотека, используемая многими другими модулями
org.springframework spring-expression Язык выражений Spring
org.springframework spring-instrument Агент обнаружения под управлением JVM
org.springframework spring-instrument-tomcat прокси-сервер обнаружения tomcat
org.springframework spring-jdbc Пакет поддержки JDBC, включая поддержку настройки источника данных и доступа JDBC
org.springframework spring-jms Пакет поддержки JMS, включая вспомогательные классы для отправки и получения сообщений JMS.
org.springframework spring-messaging Архитектура и протоколы для обработки сообщений
org.springframework spring-orm Объектно-реляционное сопоставление, включая поддержку JPA и Hibernate.
org.springframework spring-oxm XML-отображение объекта
org.springframework spring-test Компоненты модульного и интеграционного тестирования
org.springframework spring-tx Основы транзакций, включая поддержку DAO и интеграцию JCA.
org.springframework spring-web пакет веб-поддержки, включая клиентские и веб-удаленные вызовы
org.springframework spring-webmvc Реализация MVC веб-сервисов и веб-приложений REST
org.springframework spring-webmvc-portlet Реализация MVC для среды портлетов
org.springframework spring-websocket Реализация WebSocket и SockJS, включая поддержку STOMP
Spring зависимости и зависимости

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

Ниже перечислены основные этапы настройки приложения, зависящего от Spring, сначала с использованием Maven, затем Gradle и, наконец, Ivy. Во всех случаях, если что-то неясно, обратитесь к документации используемой системы управления зависимостями или посмотрите на какой-нибудь пример кода — Spring строит себя с помощью Gradle для управления зависимостями, поэтому в большинстве наших примеров используется Gradle или Maven.

Управление зависимостями Maven

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

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.0.RELEASE</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

Вот и все, обратите внимание, что если вам не нужно компилировать Spring API, вы можете объявить область действия как среду выполнения, что является типичным случаем внедрения зависимостей.

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

версия выпуска:

<repositories>
    <repository>
        <id>io.spring.repo.maven.release</id>
        <url>http://repo.spring.io/release/</url>
        <snapshots><enabled>false</enabled></snapshots>
    </repository>
</repositories>

Веха версии:

<repositories>
    <repository>
        <id>io.spring.repo.maven.milestone</id>
        <url>http://repo.spring.io/milestone/</url>
        <snapshots><enabled>false</enabled></snapshots>
    </repository>
</repositories>

Версия снапшота:

<repositories>
    <repository>
        <id>io.spring.repo.maven.snapshot</id>
        <url>http://repo.spring.io/snapshot/</url>
        <snapshots><enabled>true</enabled></snapshots>
    </repository>
</repositories>
Зависимости Maven "Bill of Materials"

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

Чтобы решить эту проблему, Maven предлагает концепцию зависимостей «Список материалов» (BOM). допустимыйdependencyManagementЧастичный импортspring-framework-bomЧтобы убедиться, что все зависимости Spring (будь то прямые или транзитивные) используют одну и ту же версию.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-framework-bom</artifactId>
            <version>4.3.0.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Еще одним преимуществом использования спецификации является то, что ее больше не нужно указывать.<version>атрибут:

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
    </dependency>
<dependencies>
Управление зависимостями Gradle

чтобыGradleЧтобы использовать репозиторий Spring в системе сборки, вам необходимоrepositoriesраздел содержит подходящие URL-адреса:

repositories {
    mavenCentral()
    // and optionally...
    maven { url "http://repo.spring.io/release" }
}

может в случае необходимостиrepositoriesв URL/releaseпревратиться в/milestoneили/snapshot. Как только репозиторий настроен, зависимости могут быть объявлены так же, как это делает Gradle.

dependencies {
    compile("org.springframework:spring-context:4.3.0.RELEASE")
    testCompile("org.springframework:spring-test:4.3.0.RELEASE")
}
Управление зависимостями плюща

использоватьIvyСуществуют аналогичные параметры конфигурации для управления зависимостями.

существуетivysettings.xmlДобавьте конфигурацию преобразователя, чтобы Ivy указывал на репозиторий Spring:

<resolvers>
    <ibiblio name="io.spring.repo.maven.release"
            m2compatible="true"
            root="http://repo.spring.io/release/"/>
</resolvers>

может в случае необходимостиrootв URL/releaseпревратиться в/milestoneили/snapshot. После настройки зависимости могут быть добавлены как обычно (в ivy.xml):

<dependency org="org.springframework"
    name="spring-core" rev="4.3.0.RELEASE" conf="compile->runtime"/>
Zip-файл раздачи

Хотя использование системы сборки, поддерживающей управление зависимостями, является рекомендуемым способом получения среды Spring, также поддерживается загрузка zip-файла дистрибутива Spring.

ZIP-файлы выпуска публикуются в репозитории Sprng Maven (это просто для удобства, для их загрузки не требуется дополнительная Maven или другая система сборки).

открыть в браузереrepo.spring.IO/release/org…, и выберите подкаталог соответствующей версии, вы сможете скачать zip-файл дистрибутива. релизный файл с-dist.zipконец, например,spring-framework-{spring-version}-RELEASE-dist.zip. Файл релиза также содержитвехаверсия иснимокВерсия.

2.3.2 Управление журналом

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

Обязательной зависимостью управления журналами в Spring является Jakarta Commons Logging API (JCL). Мы скомпилировали JCL и сделали JCLLogОбъекты видны классам, наследующим платформу Spring. Для пользователей важно, чтобы все версии Spring использовали одну и ту же библиотеку управления журналами: миграция проста, поскольку Spring сохраняет обратную совместимость даже для приложений, расширяющих Spring. Как мы это делаем? Мы делаем один из модулей Spring явно зависимым отcommons-logging(типичная реализация JCL), а затем сделать все остальные модули зависимыми от этого модуля во время компиляции. Например, с Maven вы хотите знать, где находятся зависимости.commons-logging, на самом деле Spring как раз и является его основным модулемspring-coreзависел от.

commons-loggingПреимущество в том, что для работы приложения больше ничего не нужно. Он имеет алгоритм обнаружения во время выполнения для поиска других сред управления журналами в пути к классам и выбора одной из них для использования (или указания, какую из них использовать) в зависимости от ситуации. Если никакие другие функции не нужны, вы можете получить красивый журнал из JDK (java.util.logging или JUL). Вы обнаружите, что большую часть времени ваше приложение Spring работает нормально и хорошо регистрируется в консоли, что очень важно.

Не использовать ведение журнала Commons

К несчастью,commons-loggingАлгоритм обнаружения во время выполнения хотя и удобен для конечных пользователей, имеет определенные проблемы. Если бы мы могли вернуться в прошлое и снова запустить проект Spring, мы бы использовали другую зависимость управления ведением журнала. Первым выбором, вероятно, является Simple Logging Facade для Java (SLF4J), который также используется в некоторых других инструментах, использующих Spring.

Есть два способа отключитьcommons-logging:

  1. отspring-coreудалить пару из модуляcommons-loggingзависимости (поскольку это единственная явная зависимостьcommons-loggingМесто)
  2. зависит от конкретногоcommons-loggingИ замените его пакет jar пустым пакетом jar (см.SLF4J FAQ)

следующим образом, вdependencyManagementДобавьте код, чтобы исключить егоcommons-loggingв настоящее время:

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.3.0.RELEASE</version>
        <exclusions>
            <exclusion>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

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

Использование SLF4J

SLF4J является более чистой зависимостью и имеет более высокое время выполнения, чемcommons-loggingБолее эффективен, поскольку использует время компиляции, а не время выполнения привязки к другим платформам управления журналами. Это также означает, что вы должны явно указать, что должна делать среда выполнения, а также определить и настроить ее. SLF4J может быть связан со многими распространенными средами управления журналами, поэтому обычно вы можете выбрать ту, которую уже используете, связать ее, настроить и управлять ею.

SLF4J может связываться со многими общедоступными платформами управления журналами, включая JCL, а также является мостом между другими платформами управления журналами и самой собой. Поэтому, чтобы использовать SLF4J с Spring, вместо этого нужно использовать мост SLF4J-JCL.commons-loggingполагаться. Как только это будет сделано, журналирование изменений с внутренних вызовов Spring на вызовы SLF4J API, поэтому, если другие библиотеки в приложении используют этот API, тогда будет единое место для настройки и управления ведением журнала.

Обычный выбор состоит в том, чтобы связать Spring с SLF4J, а затем предоставить явные привязки от SLF4J к Log4J. 4 зависимости должны быть предоставлены (и исключеныcommons-logging): мост, SLF4J API, привязки к Log4J и сама реализация Log4J. В Maven это выглядит следующим образом:

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.3.0.RELEASE</version>
        <exclusions>
            <exclusion>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>jcl-over-slf4j</artifactId>
        <version>1.5.8</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.5.8</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.5.8</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.14</version>
    </dependency>
</dependencies>

Похоже, что так много зависимостей только для получения журналов. При проблемах с загрузчиком классов он должен вести себя лучше, чемcommons-loggingЛучше, особенно в строгих контейнерах, таких как OSGi. Кроме того, у него есть преимущества в производительности, поскольку связывание происходит во время компиляции, а не во время выполнения.

Более распространенный вариант для пользователей SLF4J — прямая привязкаLogback, что требует меньше шагов и создает меньше зависимостей. Это устраняет дополнительную привязку, поскольку Logback напрямую реализует SLF4J, поэтому нужны только две библиотеки вместо четырех (jcl-over-slf4jиlogback). Для этого также необходимо исключить зависимость slf4j-api от других внешних зависимостей (не Spring), поскольку в пути к классам требуется только одна версия API.

Использование Log4J

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

Чтобы заставить Log4J заменить зависимость JCL по умолчанию (commons-logging), предоставляет только файл конфигурации (log4j.propertiesилиlog4j.xml) в корневом каталоге пути к классам. Конфигурация в Maven следующая:

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.3.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.14</version>
    </dependency>
</dependencies>

Вот пример log4j.properties для вывода логов на консоль:

log4j.rootCategory=INFO, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %t %c{2}:%L - %m%n

log4j.category.org.springframework.beans.factory=DEBUG
Контейнер среды выполнения с собственным JCL

Многие люди запускают приложения Spring в контейнере, который сам обеспечивает реализацию JCL. IBM Websphere Application Server (WAS) является прототипом. Это часто вызывает проблемы, и, к сожалению, хорошего решения нет, просто исключите его из приложения.commons-loggingНедостаточно в большинстве случаев.

Чтобы описать это более ясно: проблема обычно не связана с самим JCL или дажеcommons-logging, но связываютcommons-loggingна другой фреймворк (обычно Log4J). Это не удается, потому чтоcommons-loggingИзменен способ выполнения алгоритма обнаружения во время выполнения в старой версии (1.0) и новой версии (1.1), где старая версия по-прежнему используется в некоторых контейнерах, а новая версия теперь используется большинством людей. Spring не использует остальную часть JCL API, так что это не должно быть проблемой, но как только Spring или ваше приложение попытаются войти в журнал, вы обнаружите, что Log4J не работает. (Примечание переводчика: смысл здесь в том, что даже в случае возникновения вышеуказанного конфликта Spring не будет проверять, и ошибка возникнет только тогда, когда журнал необходимо распечатать при прямом запуске)

В случае WAS самый простой способ сделать это — инвертировать наследование загрузчика классов (IBM называет его «последний родительский» или поставить родительский класс последним), чтобы приложение, а не контейнер, контролировало зависимости JCL. Этот выбор не всегда работает, в открытом доступе есть много других предлагаемых альтернатив, и ваш пробег может варьироваться в зависимости от точной версии и характеристик контейнера. (Примечание переводчика: Смысл здесь в том, что описанные выше способы не уникальны, и соответствующие решения нужно делать по разным версиям и контейнерам)

Во-вторых, новые возможности Spring 4.x.

3. Новые функции и улучшения в Spring 4.0

Первоначально Spring был выпущен в 2004 году и с тех пор претерпел несколько серьезных изменений: Spring 2.0 предоставляет пространства имен XML и AspectJ, Spring 2.5 включает конфигурацию, управляемую аннотациями, Spring 3.0 использует Java 5+ в качестве основы кода платформы и использует свои новые функции, такие как в виде@ConfigurationАннотированные модели и т.д.

Версия 4.0 является последней основной версией и впервые полностью поддерживает новые функции Java 8. Вы по-прежнему можете продолжать использовать более старые версии Java, но минимальные требования были повышены до Java SE 6. Мы также воспользовались этим важным изменением, чтобы удалить многие устаревшие классы и методы.

Как перейти на Spring 4.0видетьSpring Framework GigHub Wiki.

3.1 Улучшенный процесс адаптации

новыйspring.ioURL предоставляет полныйРуководство по началу работыПомочь вам узнать весну. Дополнительные рекомендации см. в этом документе.1. Начало работы с Spring. Новый URL-адрес также дает представление о многих проектах, выпущенных в рамках Spring.

Если вы являетесь пользователем Maven, вас, вероятно, заинтересует то, что теперь выпускается в каждом выпуске Spring.Спецификация материаловИнтересуют файлы POM.

3.2 Удалены устаревшие пакеты и методы

Версия 4.0 удаляет все устаревшие пакеты и многие устаревшие классы и методы. Если вы обновляете предыдущую версию, вам необходимо убедиться, что все обращения к устаревшим API исправлены.

Полные изменения см.API Differences Report.

Обратите внимание, что необязательные сторонние зависимости были обновлены до версий 2010/2011 (то есть Spring 4 поддерживает только версии, выпущенные после 2010 года), в частности, Hibernate 3.6+, EhCache 2.1+, Quartz 1.8+, Groovy 1.8+, Joda- Время 2.0+. За одним исключением, для Spring 4 требуется Hibernate Validator 4.3+ и Jackson 2.0+ (Spring 3.2 сохраняет поддержку Jackson 1.8/1.9, но теперь он устарел).

3.3 Java 8 (и 6, и 7)

Spring 4.0 обеспечивает поддержку нескольких новых функций Java 8, позволяя использовать лямбда-выражения и использовать ссылки на методы в интерфейсах обратного вызова Spring. правильноjava.time(JSR-310) хорошо поддерживается, превращая несколько существующих аннотаций в@Repeatable, вы также можете использовать обнаружение имени параметра java 8 в качестве альтернативы компиляции кода с включенной отладочной информацией (на основе-parametersФлаги компилятора, Примечание переводчика: Обнаружение имени параметра достигается путем отражения, чтобы получить имя параметра, а не тип).

Spring сохраняет совместимость со старыми версиями Java и JDK, в частности полностью поддерживается Java SE 6 и более поздних версий (минимум JDK 6.18, выпущенный в январе 2010 г.). Тем не менее, мы по-прежнему рекомендуем Java 7 или 8 для новых проектов на основе Spring 4.

3.4 Java EE 6 и 7

Java EE 6+ и связанные с ним JPA 2.0 и Servlet 3.0 считаются базовыми для Spring 4. Для совместимости с Google App Engine и старыми серверами приложений Spring 4 может быть развернут в среде Servlet 2.5. Тем не менее, Servlet 3.0+ настоятельно рекомендуется, и это также необходимое условие для тестирования Spring, а также необходимое условие для имитации настройки среды разработки для тестирования пакетов.

如果你是WebSphere 7用户，请一定要安装JPA 2.0包，如果是WebLogic 10.3.4或更高版本，还要安装JPA 2.0补丁，这样Spring 4才能兼容这两个服务器。

Более дальновидная идея: Spring 4.0 теперь поддерживает применимые спецификации Java EE 7, в частности JMS 2.0, JTA 1.2, JPA 2.1, Bean Validation 1.1 и JSR-236 Concurrency Utilities. Как обычно, эта поддержка предназначена только для личного использования, например, в Tomcat или автономной среде. Тем не менее, приложения Spring нормально работают при развертывании на сервере Java EE 7.

Обратите внимание, что Hibernate 4.3 является поставщиком JPA 2.1 и поэтому поддерживается только в Spring 4.0. Точно так же Hibernate Validator 5.0 является поставщиком Bean Validation 1.1. Поэтому эти два элемента официально не поддерживаются Spring 3.2.

3.5 Groovy Bean Definition DSL

Начиная с Spring 4.0 можно определять внешние компоненты с помощью Groovy DSL. Концептуально это похоже на настройку bean-компонентов с использованием XML, но можно использовать более краткий синтаксис. С помощью Groovy также легко встраивать определения bean-компонентов непосредственно в код начальной загрузки. Например:

def reader = new GroovyBeanDefinitionReader(myApplicationContext)
reader.beans {
    dataSource(BasicDataSource) {
        driverClassName = "org.hsqldb.jdbcDriver"
        url = "jdbc:hsqldb:mem:grailsDB"
        username = "sa"
        password = ""
        settings = [mynew:"setting"]
    }
    sessionFactory(SessionFactory) {
        dataSource = dataSource
    }
    myService(MyService) {
        nestedBean = { AnotherBean bean ->
            dataSource = dataSource
        }
    }
}

Для получения дополнительной информации см.GroovyBeanDefinitionReaderизjavadocs.

3.6 Усовершенствования основного контейнера

Основной контейнер имеет следующие улучшения:

3.7 Веб-улучшения

Развертывание сервера Servlet 2.5 сохранено, но Spring 4.0 теперь сосредоточен в основном на развертывании среды Servlet 3.0+. При использованииФреймворк для тестирования Spring MVC, необходимо убедиться, что JAR-пакет, совместимый с Servlet 3.0, включен в тестовый путь к классам.

В дополнение к описанной ниже поддержке WebSocket, веб-модуль Spring также включает следующие улучшения:

3.8 Обмен сообщениями WebSocket, SockJS и STOMP

новыйspring-websocketМодуль полностью поддерживает двустороннюю связь между клиентом и сервером на основе WebSocket в веб-приложениях. это совместимоJSR-356, Java WebSocket API и дополнительно предоставляет резервные варианты на основе SockJS (например, эмуляцию WebSocket) для браузеров, не поддерживающих протокол WebSocket (например, IE

новыйspring-messagingМодуль поддерживает STOMP в качестве подпротокола WebSocket вместе с аннотированной программной моделью для маршрутизации и обработки сообщений STOMP от клиентов WebSocket. Следовательно,@Controllerможет содержать оба@RequestMappingи@MessageMappingМетоды используются для обработки HTTP-запросов и сообщений от клиентов WebSocket. новыйspring-messagingМодуль также содержит ключевые абстракции из предыдущих проектов интеграции Spring в качестве основы для приложений на основе сообщений, таких какMessage,MessageChannel,MesaageHandlerЖдать.

Для получения более подробной информации см.25 поддержка веб-сокетовглава.

3.9 Улучшения тестирования

кроме удаленныхspring-testУстаревший код модуля, Spring 4.0 также представляет несколько новых функций для модульного и интеграционного тестирования:

  • почтиspring-testВсе аннотации для модуля (например,@ContextConfiguration,@WebAppConfiguration,@ContextHierarchy,@ActiveProfilesи др.) можно использовать какметааннотацияИспользуется для создания пользовательских аннотаций и уменьшения дублирования конфигурации в наборах тестов.
  • Действительный файл конфигурации определения bean-компонента можно проанализировать программным путем, просто реализовав пользовательскийActiveProfilesResolverи зарегистрируйтесь@ActiveProfilesизresolverхарактеристики.
  • spring-coreмодуль представляет новыеSocketUtilsКласс для сканирования локальных свободных служебных портов TCP и UDP. Эта функция не предназначена для тестирования, но полезна при написании интеграционных тестов, требующих сокетов, например тестов, запускающих SMTP-сервер в памяти, FTP-сервер, контейнер сервлетов и т. д.
  • Начиная с весны 4.0,org.springframework.mock.webКоллекция макетов в пакете основана на Servlet 3.0. Кроме того, некоторые имитаторы Servlet API (например,MockHttpServletRequest,MockServletContextи т. д.) имеют незначительные улучшения и могут быть улучшены путем настройки.

4. Новые функции и улучшения в Spring 4.1

4.1 Усовершенствования JMS

Spring 4.1 представил более простой способЗарегистрируйте прослушиватель JMS, то есть использовать@JmsListenerМетод аннотирования bean-компонента. Пространства имен XML также были расширены для поддержки этой новой функции (jms:annotation-driven), эту новую функцию также можно полностью использовать с помощью конфигурации Java (@EnableJms,JmsListenerContainerFactory), вы также можете использоватьJmsListenerConfigurerдля программной регистрации слушателей.

Spring 4.1 также можно использовать сspring-messagingСовместное использование:

  • Слушатели сообщений могут иметь более устойчивые подписи и могут извлечь выгоду из стандартных аннотаций обработки сообщений, таких как:@Payload, @Header, @Headers, @SendToи т. д., вы также можете использовать стандартныйMessageзаменятьjavax.jms.Messageв качестве параметра метода.
  • новыйJmsMessageOperationинтерфейс можно использовать и позволяетJmsTemplateнравится использоватьMessageПовторяй.

Наконец, Spring 4.1 также предоставляет следующие различные улучшения:

  • JmsTemplateПоддерживаются синхронные операции запрос-ответ.
  • каждый<jms:listener>Элементы могут указывать приоритет слушателя.
  • пройти черезBackOffРеализации могут настраивать параметры восстановления для контейнеров прослушивания сообщений.
  • JMS 2.0 поддерживает общих потребителей.

4.2 Улучшения кэша

Поддержка весны 4.1Аннотации JCache (JSR-107), вы можете напрямую использовать существующую конфигурацию и инфраструктуру кэша Spring без каких-либо других изменений.

Spring 4.1 также значительно улучшил свою стратегию кэширования:

  • можно использовать во время выполненияCacheResolverРазобрать кеш. Таким образом, больше не является обязательным использованиеvalueпараметр для определения имени кэша.
  • Дополнительные пользовательские операции: разбор кеша, управление кешем, генераторы ключей.
  • новый@CacheConfigАннотации позволяют совместно использовать общие настройки на уровне класса без включения каких-либо операций кэширования.
  • использоватьCacheErrorHandlerЛучшая обработка кэшированных исключений.

Spring 4.1 также добавлен для того, чтобыputIfAbsentпара методовCacheInterfaceВнесены серьезные изменения.

4.3 Улучшения в Интернете

  • новая абстракцияResourceResolver, ResourceTransformerиResourceUrlProviderрасширяет существующиеResourceHttpRequestHandlerобработчик ресурсов. Некоторые встроенные реализации обеспечивают поддержку URL-адресов ресурсов с версиями (для эффективного кэширования HTTP), поиск ресурсов, сжатых с помощью gzip, создание манифестов HTML 5 AppCache и многое другое. Ссылаться на21.16.9 Службы ресурсов.
  • JDK 1.8java.util.Optionalтеперь поддерживается@RequestParam, @RequestHeaderи@MatrixVariableПараметры метода контроллера.
  • ListenableFutureзаменено как возвращаемое значениеDeferredResult, базовая услуга в этом отношении (илиAsyncRestTemplateзвонок) вернулсяListenableFuture.
  • @ModelAttributeМетоды теперь вызываются последовательно в порядке между зависимостями.
  • Джексона@JsonViewдействовать непосредственно на@ResponseBodyиResponseEntityМетоды контроллера для сериализации различных форм одного и того же POJO (например, сводки и подробности). Это визуализирует представление, добавляя сериализованный тип представления с указанным ключом к свойству модели. Ссылаться наПоддержка сериализованного представления Джексона.
  • Джексон теперь поддерживает JSONP. Ссылаться наПоддержка Джексона JSONP.
  • Новые параметры жизненного цикла можно использовать для перехвата после возврата метода контроллера, но до того, как ответ будет записан.@ResponseBodyиResponseEntityметод, объявляет@ControllerAdviceреализация бинаResponseBodyAdviceДа, встроенный@JsonViewИ JSONP использует именно это. Ссылаться на21.4.1 Использование HandlerInterceptor для перехвата запросов.
  • Существует три параметра HttpMessageConverter:
    • Gson — более легкий след, чем Jackson, используемый в Spring Android.
    • Буфер протокола Google — протокол данных для обмена данными между службами, который эффективен в рамках предприятия, но также может быть представлен в браузере в виде JSON и XML.
    • Джексон на основе XML поддерживается через расширение jackson-dataformat-xml. когда используешь@EnableWebMvcили<mvc:annotation-driven>, если он существует в пути к классамjackson-dataformat-xmlПо умолчанию он заменит JAXB2.
  • Представления, подобные JSP, теперь можно связать с контроллерами, обратившись к имени карты контроллера. Имя по умолчанию будет присвоено каждому@RequestMapping. Например,FooControllerсобственный методhandleFoo, который называется "FC#handleFoo". Стратегия именования является подключаемой, а также может быть указана с помощью атрибута имени.@RequestMappingНазовите это явно. Новое в библиотеке тегов Spring JSPmvcUrlФункции могут сделать работу со страницами JSP более удобной. Ссылаться на21.7.2 Создание URI для контроллера и его методов из представления.
  • ResponseEntityПредоставляет API в стиле создателя для управления методами контроллера для подготовки к ответам на стороне сервера. Например,ResponseEntity.ok().
  • RequestEntity— это новый тип, который предоставляет API в стиле создателя для направления кода REST на стороне клиента для подготовки к HTTP-запросам.
  • Конфигурация Java MVC с пространством имен XML:
    • Преобразователи представлений можно настроить для включения поддержки согласования содержимого. Ссылаться на21.16.8 Просмотр преобразователей.
    • Контроллеры представления имеют встроенную поддержку перенаправления и установки состояния ответа. Приложения могут использовать его для настройки перенаправленных URL-адресов, рендеринга ответов 404 с представлениями, отправки ответов «нет контента» и многого другого. некоторые варианты использования, пожалуйстакликните сюда.
    • Встроенное настраиваемое сопоставление путей. Ссылаться на21.16.11 Сопоставление путей.
  • Поддержка шаблонов разметки Groovy (на основе Groovy 2.3). Ссылаться наGroovyMarkupConfigurerи их соответствующиеViewResolverи посмотреть реализацию.

4.4 Улучшения в обработке сообщений WebSocket

  • Поддерживается клиент SockJS (Java). Ссылаться наSockJsClientи классы в одном пакете.
  • Новые события контекста приложения, когда клиенты STOMP подписываются и отписываютсяSessionSubscribeEventиSessionUnsubscribeEventбудет запущен.
  • Новая область "веб-сокет". Ссылаться на25.4.14 Область действия веб-сокета.
  • @SendToUserЦелевым может быть только один сеанс, и аутентификация пользователя не требуется.
  • @MessageMappingМетоды могут использовать точку «.» вместо косой черты «/» в качестве разделителя. Ссылаться наSPR-11660.
  • Сбор информации мониторинга STOMP/WebSocket и управление журналами. Ссылаться на25.4.16 Мониторинг выполнения.
  • Значительно оптимизированное и улучшенное управление журналами сохраняет удобочитаемость и простоту даже на уровне DEBUG.
  • Оптимизировано создание сообщений, чтобы включить поддержку эфемерной изменчивости сообщений и избежать автоматического создания идентификатора сообщения и временной метки. Обратитесь к Javadoc вMessageHeaderAccessor.
  • Соединение STOMP/WebSocket будет закрыто, если в течение 60 секунд после создания сеанса WebSocket не будет активности. Ссылаться наSPR-11884.

4.5 Улучшения тестирования

  • Groovy-скрипты теперь доступны для настройкиApplicationContext,вApplicationContextЗагружается для интеграционного тестирования в среде тестового контекста. Ссылаться наКонфигурация контекста с помощью сценариев Groovy.
  • В методе проверки транзакции можно пройтиTestTransactionAPI программно запускает и завершает тестовые транзакции. Ссылаться наПрограммное управление транзакциями.
  • Выполнение сценария SQL можно выполнить, добавив новый@Sqlи@SqlConfigАннотации настраиваются декларативно. Ссылаться на14.5.7 Выполнение сценария SQL.
  • через новый@TestPropertySourceАннотация настраивает исходные файлы свойств для тестирования, что может автоматически перезаписывать исходные файлы свойств системы и приложения. Ссылаться наКонфигурация контекста с исходными файлами тестовых свойств.
  • Слушатели TestExecutionListener по умолчанию могут быть обнаружены автоматически. Ссылаться наАвтоматическое обнаружение TestExecutionListeners по умолчанию.
  • Пользовательские TestExecutionListeners могут быть автоматически объединены с прослушивателями по умолчанию. Ссылаться наОбъединенные TestExecutionListeners.
  • Документация по тестированию транзакций в среде тестового контекста содержит более подробные объяснения и дополнительные примеры. Ссылаться на14.5.6 Управление транзакциями.
  • правильноMockServletContext, MockHttpServletRequestи различные улучшения для других эмуляций Servlet API.
  • AssertThrowsрефакторинг для поддержкиThrowableвместоException.
  • В тестах Spring MVC JSON Assert в качестве дополнительной опции с использованием JSONPath может утверждать для ответов JSON, точно так же, как утверждение для XML с помощью XMLUnit.
  • в состоянии пройтиMockMvcConfigurerСоздайтеMockMvcBuilder. Это упрощает применение настроек безопасности Spring, а также может использоваться для добавления общих настроек в любой сторонний фреймворк или проект.
  • MockRestServiceServerтеперь поддерживаетсяAsyncRestTemplateДля тестирования на стороне клиента.

5. Новые функции и улучшения в Spring 4.2

5.1 Усовершенствования основного контейнера

  • похожий@BeanЭта аннотация была обнаружена и использована для обработки методов по умолчанию в Java 8, позволяя классам конфигурации реализовывать интерфейс с параметрами по умолчанию.@Beanметод. (Примечание переводчика:@BeanАннотацию можно использовать в методе по умолчанию интерфейса Java 8, а затем можно получить bean-компонент, настроив класс для реализации этого интерфейса)
  • Классы конфигурации теперь могут объявлять@ImportВведены общие классы компонентов, что позволяет смешанное введение классов конфигурации и классов компонентов. (Примечание переводчика:@ImportРаньше можно было вводить только классы конфигурации, но теперь можно вводить и классы компонентов без каких-либо аннотаций)
  • Класс конфигурации может объявить@OrderЗначения, обрабатываемые в определенном порядке (например, переопределение bean-компонентов по имени), даже во время сканирования пути к классам. (Примечание переводчика:@OrderБольшие значения перезапишут меньшие)
  • @ResourceПоддержка инъекционных элементов@Lazyзаявление, как@AutowiredНапример, BEAN цели запроса принимает агент инициализации задержки.
  • События приложений теперь предоставляют модель на основе аннотаций, а также могут публиковать любые события.
    • Доступ к любому общедоступному методу в bean-компоненте можно получить через@EventListenerАннотация для использования событий.
    • @TransactionalEventListenerОбеспечивает поддержку событий для привязки транзакций.

  • Spring 4.2 обеспечивает первоклассную поддержку объявления и поиска псевдонимов для свойств аннотаций. новый@AliasForАннотации можно использовать для объявления пары свойств с псевдонимами в одной аннотации или для объявления псевдонима из пользовательского свойства аннотации в свойство мета-аннотации.

    • Передаются следующие аннотации@AliasForОбновлено, чтобы предоставить более содержательный псевдоним для свойства value:@Cacheable, @CacheEvict, @CachePut, @ComponentScan, @ComponentScan.Filter, @ImportResource, @Scope, @ManagedResource, @Header, @Payload, @SendToUser, @ActiveProfiles, @ContextConfiguration, @Sql, @TestExecutionListeners, @TestPropertySource, @Transactional, @ControllerAdvice, @CookieValue, @CrossOrigin, @MatrixVariable, @RequestHeader, @RequestMapping, @RequestParam, @RequestPart, @ResponseStatus, @SessionAttributes, @ActionMapping, @RenderMapping, @EventListener, @TransactionalEventListener.

    • Например, изspring-testмодульный@ContextConfigurationТеперь он определяется следующим образом:

      public @interface ContextConfiguration {

@AliasFor("locations")
String[] value() default {};

@AliasFor("value")
String[] locations() default {};

// ...
}

    • Точно так же аннотации, которые переопределяют атрибуты мета-аннотаций, теперь также могут использовать@AliasForДетальный контроль над теми свойствами, которые переопределяются в иерархии аннотаций. На самом деле теперь можноvalueСвойство объявляет псевдоним.

    • Например, теперь можно разработать составную аннотацию, которая переопределяет пользовательское свойство следующим образом.

      @ContextConfiguration
public @interface MyTestConfig {

@AliasFor(annotation = ContextConfiguration.class, attribute = "value")
String[] xmlFiles();

// ...
}

    • Ссылаться наМодель программирования аннотаций Spring.

  • Spring внес множество улучшений в алгоритм поиска для обнаружения мета-аннотаций. Например, аннотации локальной композиции могут быть объявлены в иерархии наследования аннотаций.
  • Композиционные аннотации, которые переопределяют свойства метааннотаций, теперь можно использовать в интерфейсах, абстрактных классах, мостах и ​​методах интерфейса, а также в классах, стандартных методах, конструкторах и полях.
  • Карта, представляющая свойства аннотаций (иAnnotationsAttributesэкземпляр) может быть синтезирован (или преобразован) в аннотацию.
  • Привязка данных на основе полей (DirectFieldAccessor) можно привязать к текущим данным на основе свойств (BeanWrapper) использовать вместе. В частности, привязки на основе полей теперь поддерживают навигацию по коллекциям, данным и картам.
  • DefaultConversionServiceзаSteam,Charset,CurrencyиTimeZoneПредоставляются преобразователи, которые можно использовать напрямую. Эти преобразователи также могут быть добавлены к любомуConversionServiceсередина.
  • DefaultFormattingConversionServiceОбеспечивает поддержку денег в JSR-354 (если javax.money существует в пути к классам), т.е.MonetaryAmountиCurrencyUnit. Это также включает@NumberFormatслужба поддержки.
  • @NumberFormatТеперь доступно в виде мета-аннотации.
  • JavaMailSenderImplесть новый методtestConnection()Используется для проверки соединения с сервером.
  • ScheduledTaskRegistrarВыставляйте запланированные задачи.
  • Апачиcommons-pool2Пулы AOP теперь поддерживаютсяCommonsPool2TargetSource.
  • Представлено для сценариев bean-компонентовStandardScriptFactoryКак механизм на основе JSR-223, представленный в XMLlang:stdэлемент. Поддержка JavaScript и JRuby. (Примечание: JRubyScriptFactory иlang:jrubyСейчас устарело, используйте JSR-223)

5.2 Улучшения доступа к данным

  • AspectJ теперь поддерживаетjavax.transactional.Transactional.
  • SimpleJdbcCallOperationsТеперь поддерживаются именованные привязки.
  • Полная поддержка Hibernate ORM 5.0, как поставщика JPA (автоадаптированная), а также его нативного API (полученного новымorg.springframework.orm.hibernate5охват пакета).
  • Встроенным базам данных теперь можно автоматически присваивать уникальные имена.<jdbc:embedded-database>Поддержка новых свойствdatabase-name. См. раздел «Улучшения тестирования» ниже.

5.3 Усовершенствования JMS

  • autoStartupсвойства могут быть переданыJmsListenerContainerFactoryконтроль.
  • Ответы могут быть настроены для каждого контейнера прослушивателяDestinationтип.
  • @SendToАннотированные значения теперь могут использовать выражения SpEL.
  • Цель ответа может использоватьJmsResponseРассчитывается во время выполнения.
  • @JmsListenerявляется воспроизводимой аннотацией для объявления нескольких контейнеров JMS в одном и том же методе (если вы еще не используете Java 8, используйте недавно представленный@JmsListeners).

5.4 Веб-улучшения

  • Поддерживает потоковую передачу HTTP и события, отправленные сервером. Ссылаться наHTTP-потоковая передача.
  • Поддержка как глобальной (конфигурация MVC Java и пространства имен XML), так и локальной (например, @CrossOrign) конфигурации со встроенным CORS. Ссылаться на26 CORS-поддержка.
  • Обновление кэша HTTP:
    • новый создательCacheControl, встроенный вResponseEntity, WebContentGenerator, ResourceHttpRequestHandlerсередина.
    • существуетWebRequestУлучшена поддержка ETag/Last-Modified в .
  • Аннотации пользовательского сопоставления, использование@RequestMappingв качестве мета-аннотации.
  • AbstractHandlerMethodMappingПубличные методы используются для регистрации и отмены регистрации карт запросов во время выполнения.
  • AbstractDispatcherServletInitializerметоды защиты вcreateDispatcherServletдальнейшая настройкаDispatcherServletпример.
  • HandlerMethodв виде@ExceptionHandlerпараметры метода, в частности@ControllerAdviceОчень удобен в компонентах.
  • java.util.concurrent.CompletableFutureв виде@ControllerТип возвращаемого значения метода.
  • HttpHeadersПоддерживаются запросы диапазона байтов и обслуживаются статические ресурсы.
  • @ResponseStatusОбнаружение вложенных исключений.
  • RestTemplateсерединаUriTemplateHandlerточка расширения.
    • DefaultUriTemplateHandlerнезащищенныйbaseUrlПараметры кодирования атрибутов и сегментов пути.
    • Эту точку расширения можно встроить в библиотеку шаблонов URI.
  • OkHTTPиRestTemplateинтегрированный.
  • Вместо этого можно использовать собственный baseUrlMvcUriComponentsBuilderметод в .
  • Информация об исключении сериализации/десериализации регистрируется на уровне WARN.
  • Префикс JSON по умолчанию был изменен с "{}&&" на один из более безопасных ")]}'," (Примечание переводчика: здесь может быть ошибка в официальной документации).
  • новая точка расширенияRequestBodyAdviceи встроенная поддержка внедрения@RequestBodyДжексон на параметрах метода@JsonView.
  • При использовании GSON или Jackson 2.6+ возвращаемый тип метода обработчика используется для улучшения сериализации параметризованных типов, таких какList<Foo>.
  • представилScriptTemplateViewВ качестве механизма JSR-223 для обработки веб-представлений со сценариями основное внимание уделяется шаблонам представлений JavaScript в Nashorn (JDK 8).

5.5 Улучшения в обработке сообщений WebSocket

  • Предоставляет информацию о наличии подключенных пользователей и подписок.
    • новыйSimpUserRegistryПредставлен как bean-компонент с именем «userRegistry».
    • Совместное использование существующей информации между кластерами серверов (см. Параметры конфигурации Agent Relay).
  • Определите место назначения пользователя в кластере серверов (см. Параметры конфигурации прокси-ретранслятора).
  • StompSubProtocolErrorHandlerТочка расширения используется для настройки и управления кадрами ошибок STOMP для клиента.
  • пройти через@ControllerAdviceГлобальные методы, объявленные компонентами@MessageExceptionHandler.
  • Заголовок "селектор" выражения SpEL используется дляSimpleBrokerMessageHandlerподписка.
  • Используйте клиент STOMP через TCP и WebSocket. Ссылаться на25.4.13 Клиент STOMP.
  • @SendToи@SendToUserМожет содержать несколько заполнителей.
  • Джексона@JsonViewподдержка в@MessageMappingи@SubscribeMappingвозвращаемое значение метода.
  • ListenableFutureиCompletableFutureможно использовать как@MessageMappingи@SubscribeMappingТип возвращаемого значения метода.
  • MarshallingMessageConverterдля полезной нагрузки XML.

5.6 Улучшения тестирования

  • Интеграционные тесты на основе JUnit теперь можно выполнять с использованием правил JUnit вместоSpringJUnit4ClassRunner. Это позволяет запускать интеграционные тесты на основе Spring с использованием альтернативных средств выполнения, таких как JUnit.Parameterizedили сторонние бегуны, такие какMockitoJUnitRunner. Ссылаться наВесенние правила JUnit.
  • Инфраструктура тестирования Spring MVC теперь обеспечивает первоклассную поддержку HtmlUnit, включая интеграцию WebDriver с Selenium, что позволяет тестированию веб-приложений на основе страниц больше не требовать развертывания в контейнере сервлетов. Ссылаться на14.6.2, интеграция HtmlUnit.
  • AopTestUtils— это новый класс инструментов тестирования, который позволяет разработчикам получать базовые целевые объекты, скрытые в одном или нескольких прокси-классах Spring. Ссылаться на13.2.1 Общий класс инструментов тестирования.
  • ReflectionTestUtilsтеперь поддерживает какstaticНастройки и значения полей, включая константы.
  • пройти через@ActiveProfilesПервоначальный порядок объявленных файлов конфигурации определения bean-компонента теперь сохраняется, это для таких случаев использования, как Spring BootConfigFileApplicationListener, который загружает файл конфигурации с допустимым именем.
  • @DirtiesContextНовые режимы теперь поддерживаютсяBEFORE_METHOD, BEFORE_CLASSиBEFORE_EACH_TEST_METHODдля закрытия перед тестированиемApplicationContext- Например, некоторые тесты низкого качества в большом наборе тестовApplicationContextисходная конфигурация.
  • @CommitЭта новая аннотация может напрямую заменить@Rollback(false).
  • @RollbackТеперь можно использовать для настройки семантики отката по умолчанию на уровне класса.
    • следовательно,@TransactionConfigurationВ настоящее время он устарел и будет удален в следующем выпуске.
  • пройти черезstatementsэто новое свойство@SqlТеперь поддерживается выполнение встроенных операторов SQL.
  • Используется для кэширования контекста приложения во время тестирования.ContextCacheТеперь это общедоступный API, он имеет реализации по умолчанию, которые могут переопределять пользовательские потребности в кэшировании.
  • DefaultTestContext, DefaultBootstrapContextиDefaultCacheAwareContextLoaderDelegateэтоsupportПубличные классы в подпакетах, которые разрешают пользовательские расширения.
  • TestContextBootstrappersтеперь отвечает за созданиеTestContext.
  • В среде тестирования Spring MVC,MvcResultПодробный журнал теперь доступен по адресуDEBUGуровни распечатываются или записываются на заказOutputStreamилиWriterсередина. Ссылаться наMockMvcResultHanlderновый метод вlog(), print(OutputStream)иprint(Writer).
  • Пространство имен JDBC XML поддерживает новый атрибутdatabase-name,роды<jdbc:embedded-database>, позволяет разработчику задать другое имя для встроенной базы данных — например, с помощью выражений SpEl или заполнителей файла свойств, на которые влияет текущий действительный файл конфигурации определения компонента.
  • Встроенным базам данных теперь можно автоматически назначать разные имена, что позволяет повторно использовать общие конфигурации тестовых баз данных в различных контекстах приложений в одном наборе тестов. Ссылаться на18.8.6 Создание разных имен для встроенных баз данных.
  • MockHttpServletRequestиMockHttpServletResponseтеперь черезgetDateHeaderиsetDateHeaderобеспечивает лучшую поддержку форматирования заголовков даты.

6. Новые функции и улучшения в Spring 4.3

6.1 Усовершенствования основного контейнера

  • Основной контейнер предоставляет более подробные метаданные для программной оценки.
  • Методы по умолчанию в Java 8 могут быть инструментированы как методы получения/установки для свойств компонента.
  • Если целевой компонент определяет только один конструктор, нет необходимости указывать@AutowiredАннотированный.
  • @ConfigurationКлассы поддерживают внедрение конструктора.
  • любой указанный@EventLIstenerУсловные выражения SpEL теперь могут ссылаться на bean-компоненты (например,@beanName.method()).
  • Составные аннотации теперь могут переопределять свойства массива метааннотаций. Например,@RequestMappingизString[] pathМожно использовать комбинированные аннотации.String pathпереписать.
  • @Scheduledи@SchedulesМожет использоваться в качестве мета-аннотации для создания составных аннотаций и переопределения их свойств.
  • @ScheduledПоддерживаются любые bean-компоненты с ограниченной областью действия.

6.2 Улучшения доступа к данным

  • jdbc:initialize-databaseиjdbc:embedded-databaseПоддерживает настраиваемый разделитель, применяемый к любому сценарию.

6.3 Улучшения кэша

Spring 4.3 допускает одновременные вызовы данного ключа, так что значение вычисляется только один раз. Это дополнительная функция, через@Cacheableновое свойствоsyncвключить. Эта функция также позволяетCacheИнтерфейс претерпел серьезные изменения, добавивget(Object key, Callable<T> valueLoader)метод.

Spring 4.3 также улучшает следующие аспекты кэширования:

  • Выражения SpEL в аннотациях, связанных с кэшем, теперь могут ссылаться на bean-компоненты (например,@beanName.method()).
  • ConcurrentMapCacheManagerиConcurrentMapCacheТеперь можно передать новое свойствоstoreByValueСериализировать кэшированную запись.
  • @Cacheable, @CacheEvict, @CachePutи@CachingТеперь можно использовать в качестве мета-аннотации для создания составных аннотаций и переопределения их свойств.

6.4 Усовершенствования JMS

  • @SendToТеперь можно применять на уровне класса для достижения общей цели.
  • @JmsListenerи@JmsListenersТеперь доступно как мета-аннотация для создания составных аннотаций и переопределения их свойств.

6.5 Веб-улучшения

  • Встроенная поддержка заголовков Http и опций Http.
  • Новая комбинированная аннотация@GetMapping, @PostMapping, @PutMapping, @DeleteMappingи@PatchMapping, которые происходят от@RequestMapping.
  • Новая комбинированная аннотация@RequestScope, @SessionScopeи@ApplicationScopeдля веб-сферы.
  • новая аннотация@RestControllerAdvice,это@ControllerAdviceи@ResponseBodyкомбинация.
  • @ResponseStatusТеперь доступно на уровне класса и наследуется всеми методами.
  • новый@SessionAttributeАннотация используется для доступа к свойствам сеанса.
  • новый@RequestAttributeАннотация используется для доступа к свойствам запроса.
  • @ModelAttributeможно установить его свойстваbinding=falseЗапретить привязку данных.
  • Ошибки и пользовательские исключения постоянно подвергаются обработчикам исключений MVC.
  • Наборы символов обрабатываются конвертерами HTTP-сообщений последовательно, а кодировка UTF-8 используется по умолчанию для составного текстового содержимого.
  • использовать настроенныйContentNegotiationManagerОбрабатывайте статические ресурсы, такие как типы мультимедиа.
  • RestTemplateиAsyncRestTemplateдоступныйDefaultUriTemplateHandlerПоддерживается строгое кодирование URI.
  • AsyncRestTemplateПерехват запросов в службу поддержки.

6.6 Усовершенствования обработки сообщений WebSocket

  • @SendToи@SendToUserТеперь можно применять на уровне класса для достижения общей цели.

6.7 Улучшения тестирования

  • JUnit в контексте весеннего теста теперь требует версии 4.12 и выше.
  • SpringJUnit4ClassRunnerновый псевдоним дляSpringRunner.
  • Аннотации, связанные с тестами, теперь доступны в интерфейсах, что позволяет использовать методы интерфейсов по умолчанию в Java 8.
  • пусто объявлено@ContextConfigurationтеперь можно полностью исключить, если XML-файл по умолчанию, сценарий Groovy или@Configurationкласс был обнаружен.
  • @TransactionalМетоды испытаний больше не должны бытьpublic(например, в TestNG и JUnit 5).
  • @BeforeTransactionиAfterTransactionметод больше не должен бытьpublic, и теперь также может использоваться в методах по умолчанию интерфейсов Java 8.
  • в контексте весеннего тестаApplicationContextКэш теперь ограничен, с максимальным значением по умолчанию 32, и восстанавливается на основе наименьшего недавнего времени. Его максимальное значение может быть передано через системные свойства JVM или свойства Spring.spring.test.context.cache.maxSizeСделайте настройки.
  • для индивидуального тестированияApplicationContextновый APIContextCustomizerЗагружается в контекст после определения компонента и до обновления контекста. Настройщик может быть зарегистрирован третьей стороной, но должен реализовать пользовательскийContextLoader.
  • @Sqlи@SqlGroupТеперь доступно как мета-аннотация для создания составных аннотаций и переопределения их свойств.
  • ReflectionTestUtilsДелегат теперь автоматически депроксируется при установке или получении поля.
  • Серверные тесты springmvc поддерживают заголовки ответа с несколькими значениями.
  • Тест springmvc на стороне сервера анализирует содержимое запроса данных формы и заполняет параметры запроса.
  • Серверные тесты springmvc поддерживают фиктивные утверждения для вызываемых методов обработчика.
  • Тесты REST на стороне клиента позволяют вам указать, сколько запросов вы хотите отправить, и решить, можно ли игнорировать порядок запросов.
  • Тестирование REST на стороне клиента поддерживает добавление данных формы в тело запроса.

6.8 Поддержка новых библиотек и серверов

  • Hibernate ORM 5.2 (4.2/4.3 и 5.0/5.1 по-прежнему хорошо поддерживаются, но 3.6 устарела)
  • Jackson 2.8 (требуется как минимум версия 2.6)
  • OkHttp 3.x (с поддержкой OkHttp 2.x)
  • Netty 4.1
  • Undertow 1.4
  • Томкэт 8.5.2 и 9.0 М6

Также весна 4.3spring-core.jarИнтегрированы обновленные ASM 5.1 и Objenesis 2.4.

Категории