Изучение spring framework 100% через практику. активные туториалы и язык разметки kml. проект kcitasks (beta)

Actuator

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

После добавления Actuator к проекту, Spring Boot опубликует список доступных бинов через URL . Этот список так же доступен через JMX (Java Management Extensions), и последняя версия Intellij IDEA умеет показывать все бины приложения прямо из окна запуска.

Резюме

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

Надеюсь, что эта статья помогла понять важность и ценность Spring именно как экосистемы и убрала немного «магичности» в происходящем, особенно при использовании Spring Boot. Мой совет — не бойтесь углубляться в недра фреймворка, читайте исходники и документацию, благо они у Spring-a почти эталонные, на мой взгляд

Так же стоит отметить, что в готовящемся к выходу в сентябре Spring 5 появится несколько новых концепций, направленных на создание простых приложений, и понижение уровня «магии» (хотя, как мы выяснили, магии там особо и нет). Одна из концепций это Functional Bean Registration, которая позволяет регистрировать бины в контексте с помощью функций, или даже с помощью неплохого DSL на Kotlin (а Spring 5 добавит много хорошего для поддержки Kotlin). Следующая, но еще более важная вещь, это комбинация Functional Web Framework и WebFlux (reactive web framework), которая позволит создавать веб-приложения вообще без зависимости на Spring MVC и запускать их без сервлет контейнеров. Приложение вполне сможет работать без контекста приложений и DI, и описываться просто как набор функций . Об этом можно чуть больше почитать здесь (на английском).

The getBean() APIs

BeanFactory provides five different signatures of the getBean() method that we’re going to examine in the following subsections.

3.1. Retrieving Bean by Name

Let’s see how we can retrieve a Lion bean instance using its name:

In this variant, we provide a name, and in return, we get an instance of Object class if a bean with the given name exists in the application context. Otherwise, both this and all other implementations throw NoSuchBeanDefinitionException if the bean lookup fails.

The main disadvantage is that after retrieving the bean, we have to cast it to the desired type. This may produce another exception if the returned bean has a different type than we expected.

Suppose we try to get a Tiger using the name “lion”.  When we cast the result to Tiger, it will throw a ClassCastException:

3.2. Retrieving Bean by Name and Type

Here we need to specify both the name and type of the requested bean:

Compared to the previous method, this one is safer because we get the information about type mismatch instantly:

3.3. Retrieving Bean by Type

With the third variant of getBean(), it is enough to specify only the bean type:

In this case, we need to pay special attention to a potentially ambiguous outcome:

In the example above, because both Lion and Tiger implement the Animal interface, merely specifying type isn’t enough to unambiguously determine the result. Therefore, we get a NoUniqueBeanDefinitionException.

3.4. Retrieving Bean by Name with Constructor Parameters

In addition to the bean name, we can also pass constructor parameters:

This method is a bit different because it only applies to beans with prototype scope.

In the case of singletons, we’re going to get a BeanDefinitionStoreException.

Because a prototype bean will return a newly created instance every time it’s requested from the application container, we can provide constructor parameters on-the-fly when invoking getBean():

As we can see, each Tiger gets a different name according to what we specified as a second parameter when requesting the bean.

3.5. Retrieving Bean by Type With Constructor Parameters

This method is analogous to the last one, but we need to pass the type instead of the name as the first argument:

Similar to retrieving a bean by name with constructor parameters, this method only applies to beans with prototype scope.

Курс «Разработчик на Spring Framework» от Otus

Длительность	150 дней
Уровень	Начинающие
Для кого подходит	Разработчикам, программистам
Формат	Вебинары + домашние задания + обратная связь от преподавателя
Гарантии	Помощь в трудоустройстве
Итоги	Сертификат + портфолио
Цена	● полная – 100 000 рублей; ● УСПЕЙ НА СКИДКУ! – всего за 70 000 рублей; ●  рассрочка от 8 563 рублей в месяц; ● гарантия возврата денег в течение 5 дней.
Ссылка на курс

Учебный план состоит из следующих блоков:

• Spring Framework;
• работа с БД;
• создание веб-приложений;
• специфические проекты Spring;
• диплом.

 Преподаватели:

Виталий Куценко – опытный программист;

Дмитрий Коган – председатель совета предприятия DXC, публицист, спортивный журналист, блогер;

Артем Первушов – сертифицированный специалист Android ATC, Senior Software Developer в Luxoft;

Юрий Дворжецкий – тренер в Luxoft Training Center, ведущий разработчик, кандидат физико-математических наук.

После окончания курса вы сможете:

• использовать возможности Spring в разработке;
• создавать сервис-ориентированную архитектуру;
• создавать масштабируемые приложения;
• работать с БД и запросами через проекты Spring;
• работать с технологиями вспомогательных проектов.

Мои впечатления: Открывает мою новую подборку очень хороший и насыщенный курс от Otus. Программа подходит для опытных специалистов. Вы научитесь работать с системой безопасности приложения, упрощать процесс создания, поработаете с обновлённой версией фреймворка. Таким образом, вы углубите свои знания и сможете ускорить разработку приложений.

Получить скидку →

Подписывайтесь на наши новости

Одно письмо в неделю с самыми актуальными статьями + обзор digital-профессий!

*Нажимая «Подписаться» вы даете согласие на обработку персональных данных.

Установка Java Spring

Вот пошаговая информация по установке Java Spring на ваш компьютер:

Шаг 1) Зайдите на сайт www.eclipse.org.

Шаг 2) Загрузите установщик Eclipse Neon и установите его в своей системе Windows.

Шаг 3) Нажмите кнопку «Загрузить 64-разрядную версию».

Шаг 4) Перейдите в Eclipse IDE для разработчиков Java и нажмите на ссылку «64-bit».

Шаг 5) Нажмите на ссылку «Windows 64-bit».

Шаг 6) Нажмите на кнопку «Загрузить», чтобы загрузить ZIP-файл.

Шаг 7) Распакуйте zip-файл для загрузки в определенную папку.

Шаг 8) Нажмите кнопку «Обзор», чтобы выбрать каталог рабочей области.

Шаг 9) Нажмите «Выбрать папку», чтобы выбрать папку.

Процесс будет отображаться, как показано на следующем экране.

Шаг 10) Открытие клиента Eclipse Marketplace.

Шаг 11) Поиск и установка плагина Spring.

Шаг 12) Подтвердите выбранные функции и нажмите кнопку «Подтвердить».

Шаг 13) Принятие условий и установка программного обеспечения.

Появится экран приветствия с ходом установки программного обеспечения.

Шаг 14) Нажмите кнопку «Перезагрузить сейчас», чтобы перезапустить Eclipse IDE и применить изменения.

Будет отображен следующий экран:

Клиентский код

Оставим за рамками этой статьи, пример можно увидеть в исходном коде. Цель этого кода — исключительно продемонстрировать как получить JSON данные с сервера, интеграции с клиентскими фреймворками React, Angular etc намеренно оставлены вне рамок этой статьи.

Тестирование

Spring так же предоставляет мощные средства для Integration и Unit тестирования приложения. Пример кода, который проверяет контроллер:

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

Аналогично для API тестов есть набор хелперов для проверки JsonPath выражений.

Тестирование в Spring это все таки отдельная тема, поэтому мы не будем сильно на этом останавливаться сейчас.

Деплоймент

Чтобы собрать и запустить наше приложение в продакшене есть несколько вариантов.

1. Задеплоить полученный JAR (или даже WAR) в сервлет контейнер, например Tomcat. Это не самый простой путь, его нужно выбирать только если у вас уже есть работающий сервлет контейнер или сервер приложений.
2. Использовать магию Spring Boot. JAR файл, собранный используя плагин Spring Boot (который автоматически добавляется в проекты созданные через Spring Initializr), является полностью самодостаточным.

Таким образом сборка и запуск приложения выглядит как:

Для деплоймента этого JAR файла не нужно ничего, кроме установленной Java (JRE). Это так называемый fat JAR — он включает в себя и встроенный сервлет контейнер (Tomcat по умолчанию) и фреймворк, и все библиотеки-зависимости. По сути, он является единственным артефактом деплоймтента — его можно просто копировать на целевой сервер и запускать там.

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

На базе этого файла можно легко создать Docker образ или установить его как демон. Больше деталей доступно в официальной документации.

Заключение

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

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

Чтобы сделать этап «знать» как можно проще, Spring обладает отличной документацией, огромным сообществом, и чистыми исходниками, которые вполне можно читать. Если расположить Spring на шкале Рича Хики, он (Spring) несомненно попадет в easy, но уж точно не simple. Но для современного энтерпрайза (и не только энтерпрайза) он дает невероятные возможности чтобы получить production-ready приложение очень быстро и концентрироваться на логике приложения, а не инфраструктуры вокруг.

Ссылки

• Исходный код на github
• Главный сайт Spring с кучей разных гайдов spring.io
• Официальная документация Spring Framework

@Repository

DAO or Repository classes usually represent the database access layer in an application, and should be annotated with @Repository:

One advantage of using this annotation is that it has automatic persistence exception translation enabled. When using a persistence framework such as Hibernate, native exceptions thrown within classes annotated with @Repository will be automatically translated into subclasses of Spring’s DataAccessExeption.

To enable exception translation, we need to declare our own PersistenceExceptionTranslationPostProcessor bean:

Note, that in most cases, Spring does the step above automatically.

Or, via XML configuration:

A Brief History of the Technologies

To start with, let’s take a quick peek at the history of these two technologies and how they’ve steadily developed over the years.

2.1. Enterprise Java Beans

The EJB specification is a subset of the Java EE (or J2EE, now known as Jakarta EE) specification. Its first version came out in 1999, and it was one of the first technologies designed to make server-side enterprise application development easier in Java.

It shouldered the Java developers’ burden of concurrency, security, persistence, transaction processing, and more. The specification handed these and other common enterprise concerns over to the implementing application servers’ containers, which handled them seamlessly. However, using EJBs as they were was a bit cumbersome due to the amount of configuration required. Moreover, it was proving to be a performance bottleneck.

But now, with the invention of annotations, and stiff competition from Spring, EJBs in their latest 3.2 version are much simpler to use than their debut version. The Enterprise Java Beans of today borrow heavily from Spring’s dependency injection and use of POJOs.

2.2. Spring

While EJBs (and Java EE in general) were struggling to satisfy the Java community, Spring Framework arrived like a breath of fresh air. Its first milestone release came out in the year 2004 and offered an alternative to the EJB model and its heavyweight containers.

Thanks to Spring, Java enterprise applications could now be run on lighter-weight . Moreover, it also offered dependency inversion, AOP, and Hibernate support among myriad other useful features. With tremendous support from the Java community, Spring has now grown exponentially and can be termed as a full Java/JEE application framework.

In its latest avatar, Spring 5.0 even supports the reactive programming model. Another offshoot, Spring Boot, is a complete game-changer with it’s embedded servers and automatic configurations.

Instance Factory Method

A standard implementation of the factory method pattern is to create an instance method that returns the desired bean.

Additionally, we can configure Spring to create our desired bean with or without arguments.

2.1. Without Arguments

We can create a Foo class that represents our bean being created:

Then, we create an InstanceFooFactory class that includes a factory method, createInstance, that creates our Foo bean:

After that, we configure Spring:

1. Create a bean for our factory class (InstanceFooFactory)
2. Use the factory-bean attribute to reference our factory bean
3. Use the factory-method attribute to reference our factory method (createInstance)

Applying this to a Spring XML configuration, we end up with:

Lastly, we autowire our desired Foo bean. Spring will then create our bean using our createInstance factory method:

2.2. With Arguments

We can also provide arguments to our instance factory method using the constructor-arg element in our Spring configuration.

First, we create a class, Bar, that utilizes an argument:

Next, we create an instance factory class, InstanceBarFactory, with a factory method that accepts an argument and returns a Bar bean:

Lastly, we add a constructor-arg element to our Bar bean definition:

We can then autowire our Bar bean in the same manner as we did for our Foo bean:

Spring: начало

Если вы только решили начать знакомиться с программированием на «Джава спринг», рекомендуем начинать именно с Java ee Spring (фреймворк). Это один из простейших методов с открытым исходным кодом для данной платформы «Джава». Фреймворк создает последовательную конструкцию, которую можно без проблем применить к большинству задач, что были уже ранее описаны на основе Java. Простота и прозрачность фреймворка позволит вам самостоятельно увидеть ошибки в написании.

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

• Контроллер – inversion of control. Обеспечивают корректную работоспособность, отвечают за конфигурацию элементов приложения и регулируют функциональный цикл объектов Java.
• Доступ к данным – функционал направлен на управление реляционными базами данных (БД) в Java. Благодаря данному фреймворку обеспечивается решение огромного количества сложных задач на базе Java environments.
• Фреймворк аспектно-ориентировочной настройки. Работает с компонентами, которые не могут реализоваться без каких-либо потерь на Java.
• Управления транзакциями. Фреймворк координирует АР и инструментарий настроившими объектами управлениями транзакций для элементов Java.
• Фреймворк удаленного доступа и управления. Конфигурация происходит локально.
• Аутентификация и авторизация. Поддерживают конфигурацию на многих популярных протоколах через Spring Security.

На сегодняшний день для всех фреймворков в «Спринг» предоставляется ряд возможностей:

• Автоматическое управление ресурсами.
• Обработка исключенных компонентов при доступе к данным исключения самого «Спринга».
• Прозрачное управление транзакциями во время каких-либо операций с данными.
• Разархивирование ресурсов.
• Обработка абстракции во многих форматах.

Необходимо понимать предназначение всех фреймворков, так как это основа Java Spring. Для начинающих рекомендуется начинать изучать все компоненты по группам и пробовать их использовать на примерах.

Основной пакет

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

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

Пакет ORM обеспечивает интеграцию слоев популярных API для отображения реляционных объектов, включая JDO, Hibernate и Ibatis. Используя пакет ОРМ, вы можете применять все O/R-картографы в сочетании с другими функциями Spring-предложения.

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

Применяя метаданные на уровне исходных текстов, можно включить все виды поведенческой информации в код, например NET-атрибуты.

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

Component Scanning

Spring can automatically scan a package for beans if component scanning is enabled.

@ComponentScan configures which packages to scan for classes with annotation configuration. We can specify the base package names directly with one of the basePackages or value arguments (value is an alias for basePackages):

Also, we can point to classes in the base packages with the basePackageClasses argument:

Both arguments are arrays so that we can provide multiple packages for each.

If no argument is specified, the scanning happens from the same package where the @ComponentScan annotated class is present.

@ComponentScan leverages the Java 8 repeating annotations feature, which means we can mark a class with it multiple times:

Alternatively, we can use @ComponentScans to specify multiple @ComponentScan configurations:

When using XML configuration, the configuring component scanning is just as easy:

Singleton Scope

Defining a bean with singleton scope means the container creates a single instance of that bean, and all requests for that bean name will return the same object, which is cached. Any modifications to the object will be reflected in all references to the bean. This scope is the default value if no other scope is specified.

Let’s create a Person entity to exemplify the concept of scopes:

Afterwards, we define the bean with singleton scope by using the @Scope annotation:

We can also use a constant instead of the String value in the following manner:

Now we proceed to write a test that shows that two objects referring to the same bean will have the same values, even if only one of them changes their state, as they are both referencing the same bean instance:

The scopes.xml file in this example should contain the xml definitions of the beans used:

Как сделать простое приложение на Java Spring (фреймворк)

Конфигурацию приложения в Spring можно осуществлять несколькими способами. Одним из наиболее распространенных и достаточно простых считается вынос конфигурации в XML-файл. Этот тип традиционно используют во многих версиях Java Spring. Для начинающих рекомендуем использовать такие инструменты как java (1.5), tomcat (6), ant (1.7), eclipse (3), junit 4x.

Для того чтобы описать простую задачку в Java Spring, необходимо придерживаться такой поочередности:

• Создать саму структуру приложения. Для этого вам понадобится на eclipse установить специальный плагин — Spring IDE. Также необходимо создать проект на Springapp и дополнительно добавить папку war.
• Создать index.jsp. В Java Spring web дополнительно прописать WEB-INF и поместить в нее web.xml.
• Деплоим программу в tomcat. Для того чтобы развернуть приложение, необходимо воспользоваться ANT-скриптом, который будет содержать цель для компиляции, переноса и строения программы.
• Прописав полностью все приложения, сделайте проверку. Запускайте tomcat и открывайте веб-страничку с адресом: localhost:8080/springapp/.
• Затем вам понадобится установить Spring Framework и разархивировать его.

На этом этапе можно сказать, что вы спешно завершили настройку сетевого окружения. Дальше следует подстроить Spring Java config:

• Для начала необходимо сделать некоторые изменения в web.xml, которые вы найдете в папке WEB-INF. Наша цель заключается в том, чтобы прописать диспетчер входных запросов приложения.
• Производим диспетчеризацию входных запросов. Мы решили все запросы с вида ‘.htm’ направлять на сервлет-диспетчер.
• Затем скопируйте библиотеки данных в WEB-INF/lib.
• Создайте контроллер в springapp.web и пропишите тест.
• Задайте вид и скомпилируйте приложения на сервере.
• Попробуйте запустить приложения.

Что же мы сделали в Spring Java? Для чайников некоторые из выше перечисленных пунктов будут непонятны, поэтому попробуем описать попроще:

1. Мы создали стартовую страницу– index.jsp, которая служит для того, чтобы проверить корректность установки окружения.
2. Прописали диспетчер с соответствующим файлом описания springapp-servlet.xml.
3. Создали контроллер и прописали для него текст.
4. Задали вид приложения.

Краткая история

Вот важные ориентиры из истории:

• Spring Framework был написан Родом Джонсоном и впервые выпущен в июне 2002 года.
• Spring La с т версия выпуск в марте 2004 года
• Версия Spring 1.2.6 выпущена в 2006 году
• Выпуск версии Spring 2.0 в октябре 2006 г.
• Выпуск версии Spring 2.5 в ноябре 2007 г.
• Выпуск версии Spring 3 в декабре 2009 г.
• Выпуск версии Spring 3.1 в декабре 2011 г.
• Выпуск версии Spring Framework 4 в декабре 2013 года с поддержкой Java 8
• Spring Framework 4.2.0 версия выпущена в июле 2015 года
• Spring Framework 4.2.1 версия выпущена в сентябре 2015
• Версия Spring Framework 4.3 выпущена 10 июня 2016 года
• Spring Framework 5.0 версия выпущена в июне 2017 года

Расшифровка основных аббревиатур в Java Spring

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

• Inversion of Control – IoC – инверсия контроля или, проще говоря, главный модуль приложения.
• АОП – аспектно-ориентировочное программирование. Благодаря этому модулю «Джава» может без проблем подключиться к любой точке доступа и прописать там необходимый код.
• MVC — Model-view-controller – это структурированный шаблон, который задает и описывает способ построения конструкции всего приложения, обеспечивает взаимодействие всех частей в одной системе. Создает объекты web.
• Класс WEB предназначит для того, чтобы облегчить разработку авторизации фреймворка, отвечает за доступ к бинам и т. д.
• ORM- Object-Relational Mapping – связывает БД (базы данных) с концепциями объекто-ориентировочных методов программирования, создавая новую виртуальную базу данных.
• DAO предназначен для работы с базами данных в структуре «Спринга».
• Service Abstraction – задает интерфейсы (внешней вид) приложения, то есть отвечает за абстрагирование задачи.

Сегодня можно найти достаточно много полезной и интересной информации по Java Spring. Уроки, учебники, веб-семинары непременно помогут вам без проблем изучить данный скриптовый язык программирования. Если у вас возникли какие-либо проблемы с написанием приложения, пересмотрите документацию по «Спрингу», в которой авторы достаточно детально описали все требования к структуре «Джава», а также ответили на вопросы, как исправить часто совершаемые ошибки.

The Spring Bean Lifecycle

When we look into the lifecycle of Spring beans, we can see numerous phases starting from the object instantiation up to their destruction.

To keep it simple, we group them into creation and destruction phases:

Let’s explain these phases in a little bit more detail.

Bean Creation Phases

• Instantiation: This is where everything starts for a bean. Spring instantiates bean objects just like we would manually create a Java object instance.
• Populating Properties: After instantiating objects, Spring scans the beans that implement interfaces and starts setting relevant properties.
• Pre-Initialization: Spring’s s get into action in this phase. The methods do their job. Also, annotated methods run right after them.
• AfterPropertiesSet: Spring executes the methods of the beans which implement .
• Custom Initialization: Spring triggers the initialization methods that we defined in the attribute of our annotations.
• Post-Initialization: Spring’s s are in action for the second time. This phase triggers the methods.

Bean Destruction Phases

• Pre-Destroy: Spring triggers annotated methods in this phase.
• Destroy: Spring executes the methods of implementations.
• Custom Destruction: We can define custom destruction hooks with the attribute in the annotation and Spring runs them in the last phase.

Why Would I Need to Hook Into the Bean Lifecycle?

When we need to extend our software with new requirements, it is critical to find the best practices to keep our codebase maintainable in the long run.

In Spring Framework, hooking into the bean lifecycle is a good way to extend our application in most cases.

Dynamically Changing Spring Bean Instances

In some cases, we need to define Spring beans programmatically. This can be a practical solution when we need to re-create and change our bean instances at runtime.

Let’s create an service which is capable of dynamically updating to the latest version on-demand:

We access the instance with the help of interface. Thus, we dynamically create our bean with the latest database file and update our bean definition by registering it to the Spring context.

Also, we call our method right after we acquire the instance in the method. Therefore, we can initially create the first instance of the bean while the Spring context boots up.

Accessing Beans From the Outside of the Spring Context

Another scenario is accessing the or instance from outside of the Spring context.

For example, we may want to inject the into a non-Spring class to be able to access Spring beans or configurations inside that class. The integration between Spring and the Quartz library is a good example to show this use case:

In this example, we’re using the interface to get access to the bean factory and use the bean factory to autowire the dependencies in a bean that is initially not managed by Spring.

Also, a common Spring — Jersey integration is another clear example of this:

By marking Jersey’s as a Spring , we inject the and lookup all the beans which are annotated by Jersey’s , to easily register them on application startup.

Stateful EJB == Spring Component with prototype Scope

At times, say when we are building a shopping cart, we need our bean to remember its state while going back and forth between method calls.

In this case, we need our container to generate a separate bean for each invocation and save the state. Let’s see how this can be achieved with our technologies in question.

5.1. Stateful EJB Example

Similar to our singleton EJB sample, we need a javax.ejb.Remote interface and its implementation. Only this time, its annotated with javax.ejb.Stateful:

Let’s write a simple test to set a name and add items to a bathingCart. We’ll check its size and verify the name:

Now, to demonstrate that the bean really maintains state across instances, let’s add another shoppingCartEJB to this test:

Here we did not set the name and hence its value was null. Recall from the singleton test, that the name set in one instance was retained in another. This demonstrates that we got separate ShoppingCartEJB instances from the bean pool with different instance states.

5.2. Stateful Spring Bean Example

To get the same effect with Spring, we need a Component with a :

That’s it, just the annotations differ – the rest of the code remains the same.

To test our Stateful bean, we can use the same test as described for EJBs. The only difference is again how we get the bean from the container: