Spring с чего начать

Учебное пособие по Spring Framework: начало работы со Spring

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

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

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

Что такое Spring Framework?

Spring — это легкая среда разработки приложений с открытым исходным кодом, использующая Java Enterprise Edition (Java EE) и модель Enterprise JavaBeans (EJB).

Spring часто называют «фреймворком», потому что он поддерживает другие интегрированные фреймворки в экосистеме Java, такие как Struts, Hibernate и Tapestry. Spring поставляется во многих вариантах, которые адаптированы для конкретных целей, таких как Spring MVC, Spring Boot или Spring Security.

Spring известен своими системами внедрения зависимостей и инверсии управления (IoC), которые позволяют с легкостью создавать крупномасштабные слабосвязанные приложения. Spring особенно подходит для финансовых и корпоративных приложений благодаря своей скорости, безопасности и простоте построения транзакционных систем. Ведущими работодателями разработчиков Spring являются Citibank, eBay, Visa и JP Morgan.

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

Преимущества Spring

Недостатки Spring

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

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

Особенности Spring

Архитектура и компоненты Spring

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

Beans

Spring Beans — это экземпляры классов, которыми управляет Spring. Они являются наиболее фундаментальным компонентом программы Spring.

Традиционно объекты создают личные экземпляры своих зависимостей. Spring управляет всеми зависимостями объекта и создает экземпляр объекта в bean-компоненте после внедрения необходимых зависимостей. @ComponentАннотаций является наиболее распространенным методом определения бобов.

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

Область видимости bean-компонента по умолчанию — singleton, в которой только один экземпляр bean-компонента создается и кэшируется в памяти. Несколько запросов к компоненту возвращают общую ссылку на один и тот же компонент. Напротив, область видимости прототипа приводит к созданию новых bean-компонентов всякий раз, когда запрос на bean-компонент выполняется в контексте приложения.

Autowiring

Метод Spring по внедрению бобов в одно и другое. Spring идентифицирует зависимость выбранного bean-компонента, ищет совпадение, а затем заполняет зависимость. @AutowiredАннотаций сообщает Spring, чтобы найти и внедрить сотрудничающий боб в другой. Если доступно более одного bean-компонента одного типа, Spring выдает ошибку.

В следующем сценарии Spring обнаруживает два bean-компонента типа Operator:

IoC Container

Контейнер IoC — это платформа, которая обеспечивает функциональность инверсии управления. Контейнер IoC управляет bean-компонентами и создает все необходимые экземпляры.

Например, у нас есть класс, Vehicleкоторый зависит от другого класса, Engine.

С IoC программисту нужно только упомянуть зависимость, а Spring сделает все остальное. Контейнер IoC будет создавать экземпляры обоих классов и внедрять Engineих Vehicleв качестве зависимости.

Модули Spring и проекты Spring

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

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

Модули базовой архитектуры Spring Project показаны ниже, сгруппированные по их слоям:

Контейнер Spring Core включает 4 модуля, необходимых для использования Spring: Beans, Core, Context и Spring Expression Language (SpEL). Эти модули отвечают за основные функции среды Spring, такие как инверсия управления (IoC), внедрение зависимостей, интернационализация, а также за поддержку запросов к объекту во время выполнения.

Уровень доступа / интеграции Spring Data обеспечивает поддержку взаимодействия с базами данных и управления данными. Он состоит из 4 основных частей:

Веб-уровень содержит модули Веб, Сервлеты, Портлеты и Сокеты, используемые для создания веб-приложений.

Модуль Test обращается к сквозной проблеме модульного тестирования. Платформа Spring Test поддерживает тестирование с помощью JUnit, TestNG, а также создание фиктивных объектов для изолированного тестирования кода.

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

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

Например, Spring Cloud позволяет разрабатывать собственные облачные приложения, которые можно динамически настраивать и развертывать. Он предоставляет функциональные возможности для обработки общих шаблонов в распределенных системах. Другие проекты включают Spring Boot, Spring Security, Spring DAO, Spring Context и многие другие.

Начать работу с Spring

Теперь мы познакомим вас с вашим первым приложением Spring: простая система рекомендаций по фильмам. Настроить новый проект с помощью Spring Framework сложно, потому что вам нужно настроить полную архитектуру вручную, включая то, какие зависимости Apache Maven использовать, использовать ли XML или Java, и вы должны установить веб-сервер, такой как Tomcat.

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

Как начать свой проект

Мы будем использовать Spring Initializr, чтобы быстро создать проект Spring Boot, используя его простое меню выбора. Сначала перейдите в start.spring.io. Вы найдете интерфейс меню, подобный приведенному ниже, с выбором настроек и полями метаданных.

Для этого проекта мы выберем «Maven Project», выберем Java в качестве нашего языка и выберем последнюю версию Spring Boot. На данный момент избегайте версий «SNAPSHOT», потому что они проходят альфа- или бета-тестирование. В разделе «Метаданные проекта» введите io.datajek.springbasics»GroupID» и movie-recommmender-system»ArtifactID«. Идентификатор группы и идентификатор артефакта — это в основном имя пакета и имя класса. Обычно вы добавляете зависимости модулей в разделе «Зависимости», но для этого проекта требуется только Spring по умолчанию. инструменты.

После того, как вы все ввели, нажмите «Создать», чтобы создать zip-файл с архитектурой настройки. Разархивируйте папку в желаемое место на жестком диске. Эта папка будет содержать pom.xmlфайл для импорта в Eclipse IDE. Через короткое время вы увидите следующую иерархию:

Поздравляем, вы создали свое первое приложение Spring с помощью Spring Boot!

Добавление зависимостей

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

Сначала создайте новый класс в src/main/javanamed RecommenderImplementation.

Затем мы добавим recommendMoviesметод в RecommenderImplementation. recommendMoviesМетод будет принимать строку заголовка фильма в качестве входных данных и возвращает три рекомендации в массиве String.

Используйте жестко запрограммированную реализацию ниже:

Теперь создайте экземпляр RecommenderImplementationкласса в MovieRecommenderSystemApplicationфайле, а затем вызовите recommendMoviesметод через RecommenderImplementationкласс.

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

А пока мы жестко запрограммируем getRecommendations возврат тех же трех фильмов.

Теперь мы можем использовать методы ContentBasedFilterкласса в RecommenderImplementationклассе. Замените предыдущую жестко запрограммированную реализацию recommendMoviesследующей реализацией на основе зависимостей.

Наконец, мы добавим toStringметод к mainметоду, чтобы сделать массив String доступным для чтения в качестве вывода.

Источник

Spring для начинающих: наиболее полный видеокурс

Ситуации, когда нужен джавист, но не требуется знание Spring – редкость. Представляем полный видеокурс на тему «Spring для начинающих».

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

Введение

Курс начинается с определения фреймворка как универсального инструмента с открытым исходным кодом. Основная цель Spring – разгрузка кода и упрощение разработки на Java.

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

Начало работы и Maven

Вступительная лирика позади, и второй урок готовит нас к:

Возможно, поклонникам более современных IDE Eclipse покажется дикостью, но в работе будет использоваться именно эта среда.

Чтобы ознакомиться с Maven, нужно немного отвлечься от основного курса и посмотреть данное видео:

Spring для начинающих: первый пример

Первый пример подробно разбирается уже в пятом видеоуроке. План состоит в переводе проектов на Spring, настройке контейнера, связывании объектов и конфигурации XML.

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

Область видимости и домашнее задание

Начало традиционно вобрало в себя необходимую терминологию и принципы работы каждого элемента. Рассмотрены области действия компонентов Singleton и Prototype, ряд методов, интерфейсов, а также ленивая инициализация (параметр lazy-init).

В конце первой части десятого урока дается домашнее задание, а во второй производится его разбор.

Далее ряд видеоуроков посвящается внедрению методов, коллекциям, SpEL, автоматическому связыванию и аннотациям.

Примеры кода на Spring

А вот и более практическая часть, которая призвана закрепить всю теорию, которая была изложена ранее. Это разбор учебного проекта от IBM + анализ связки Swing и Spring IoC. Вы увидите, насколько более удобно писать «формы» с использованием Spring, а не только на чистом Swing. Любителям создавать качественные UI будет особенно интересно.

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

Второй показывает на практике, как работают аспекты, и для чего они нужны:

Третий урок, основываясь на предыдущих двух, дополняет теоретическую часть по AOP:

Spring и базы данных

Раскрытие вопросов, как умеет Spring работать с базами данных, и почему его так часто выбирают для работы с БД. Этот универсальный фреймворк может работать с разными типами подключения к данным. Из наиболее часто используемых это:

Подробно объясняются преимущества и недостатки каждого инструмента, что особенно удобно, если вы новичок в работе с БД и понятия не имеете, с чем «сотрудничает» Spring.

Доработка приложения

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

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

Добавление транзакций

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

Настройка Eclipse и Tomcat

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

Создание проекта Spring MVC

План урока включает сравнение контекста веб-приложения и контекста Spring, создание Spring MVC приложения, в котором используется плагин Eclipse, структуру проекта и рассмотрение библиотеки Log4J.

Подключение CSS

После разбора MVC, его структуры и тестового проекта есть смысл проанализировать подключение таблицы стилей в проект, так как данный вопрос нередко вызывает затруднения у новичков.

Передача параметров формы

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

В оставшейся части курса разбираются дополнительные инструменты, объекты, параметры, локализация, AJAX-запросы, JSF, etc. 66-ой урок – последний в первой части курса. Остальные посвящены Spring с использованием IntelliJ IDEA, GlassFish, MySQL, Hibernate и многого другого. Полный видеокурс вы найдете здесь:

Вас также могут заинтересовать другие статьи по теме:

Источник

Изучение Spring Framework 100% через практику. Активные туториалы и язык разметки KML. Проект KciTasks (beta)

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

В результате, мы получаем целенаправленное обучение, но БЕЗ ступоров, проблем непонимания вида «а где это использовать», а также без скучного и пассивного чтения теории. Совсем.

В рамках статьи представлено 5 учебных задачек, которые покрывают Spring Jdbc/Transactions на 50% от необходимых для сертификации знаний. Главная задача статьи — массово протестировать саму идею, а также вместе с вами разработать большое количество уникальных задачек по всем темам.

Для начала немного о себе. Меня зовут Ярослав, и я работаю на позиции Middle Java Developer в компании EPAM Systems. Одним из моих хобби является создание обучающих систем (диплом бакалавра, диплом магистра). За последние 4 года я перепробовал более сотни самых разнообразных подходов к обучению различных областей знаний (включая Java/Spring), и создал более двадцати программ-прототипов для проверки этих подходов. Большинство из них не принесло какой-либо супер-пользы, и поэтому я продолжаю работу в этом направлении.

Эта статья посвящена одной из моих идей, которая, теоретически, может взлететь. Надо её массово протестировать, в этом и заключается задача данной статьи. Забегая вперёд, рекомендую вам зайти и посмотреть веб-страницу с задачками, чтобы понимать, о чём идёт речь (https://kciray8.github.io/KciTasks/App/src/).

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

Как обычно изучают Spring

В изучении фреймворков есть 2 крайности. Первая — когда человек работает в компании и просто делает те задачи, которые даёт заказчик. Это медленный, очень медленный способ развития, но по нему идут большинство разработчиков. Логично делать только то, что просят, особенно когда за это платят, не так ли? Однако, обучение «на работе» лишь кажется эффективным. Большинство задач, которые решают современные программисты, заключается в сопровождении систем. Всё уже написано до нас, нужно лишь фиксить баги\править конфиги, и дорабатывать систему напильником. В этом нет ничего плохого, но вот обучение самим технологиям происходит крайне медленно. Конечно, рано или поздно вам придётся раскопать документацию спринга и вы запомните всё необходимое, но на это уйдут годы. Может быть, стоит попробовать сначала «накрутить» знания и опыт, а потом уже брать практические задачки посложнее (и за существенно больший оклад, разумеется)? (С Java это точно работает, можно за 2-3 месяца целенаправленно изучить Java SE и это могут засчитывать за год-другой опыта. Много знакомых с универа, кто так делал).

Вторая крайность — это целенаправленное обучение. Это быстрый, но ОЧЕНЬ тяжёлый способ. Он заключается в том, что человек продвигается по книге (или курсу), а потом пытается применить это на практике и как-то запомнить. И если с Java SE такой подход ещё кое-как работает, то со спрингом всё глухо и туго. Даже в самых лучших книгах зачастую не объясняется, где конкретно применять те или иные особенности, приходится догонять это самому. Но самое обидное тут — это забывание информации, добытой таким тяжёлым трудом. Одна из проблем обучения — это отсутствие эффективного повторения. Если вы изучали спринг классическим способом (например, читали книгу и пробовали код на практике), то на это были потрачены огромные усилия, но БЕЗ возможности восстановления. Простое перечитывание книги через 1-2 года не вернёт вам забытой информации (которую вы получили через практику, параллельную с прочтением). Возникает некая дилемма — как же сделать так, чтобы было много практики, но при этом программист «направлялся» в нужные области?

Проблемы обучения

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

Для начала, выберем материалы, по которым стоит обучаться. Главное требование к ним — ограниченный набор информации (только то, что нужно для сертификации/собеседования/практики), а также последовательная и логически взаимосвязанная подача этой информации. По данным критериям, наилучшим образом подходят книги (Спринг в действии, Учебное пособие по сертификации от Юлианы и т.д.) Они очень хорошо продуманы и оформлены (на мой взгляд, куда приятнее и подробнее, чем видеокурсы по спрингу на udemy). Казалось бы, читай себе, вникай, пробуй, экспериментируй — и будут знания! Но не тут-то было.

Дело в том, что сам процесс чтения книги и разбора теории в ней очень плохо состыкован с процессом апробации этой теории на практике. Он не естественный. Какой бы ни была книга идеальной, она остаётся книгой. Она по своей природе не предназначена для обучения программированию. Программист, в конечном итоге, должен набивать хорошие привычки по сознательному использованию тех или иных технологий фреймворка. Между «Я прочитал и понял» и «Я умею это применять и знаю где» образуется огромная пропасть. Чтобы преодолеть её, приходится вложить немалые усилия. Скажу честно — я написал довольно много веб-приложений на Spring, однако всё равно испытывал множество трудностей при прочтении глав книги «Спринг в действии». На данный момент я детально разобрал около 30% из обеих книг, и готов к сертификации Spring 5 примерно на 60%.

Аналогичные проблемы я наблюдал при изучении Android SDK в 2014 году. Разгадка тут довольно простая — каждый фреймворк вводит какие-то свои новые концепции, которые довольно трудно понять и начать думать через них (если использовать традиционные способы обучения).

Процесс связывания представленной в книге информации с привычками — очень тяжёлый и не эффективный. Он часто вызывает множество негативных эмоций (когда что-то не работает или не запускается), заставляет много гуглить и решать проблемы. Неужели нельзя сделать некоторые «пути (trails)», по которым можно будет провести разработчика, показать ему правильные решения, да так, чтобы он сам их делал? Ведь опытные разработчики прекрасно знают о таких путях. Для них это что-то очевидное. Но тут возникает проблема в форме передачи знаний. Как мы уже выяснили, книги не подходят для этой цели.

Ещё одна проблема, на которую хотелось бы обратить внимание — это проблема повторения. Даже если мы преодолеем все трудности и широко прокачаем знания спринга, со временем они будут угасать (не считая того небольшого процента, который получилось связать с текущими задачами). Человеку свойственно забывать, и с этим ничего не поделать. Единственное, что мы можем сделать — это попробовать оптимизировать повторения. Когда я учился в бакалавриате, я возлагал большие надежды на теорию интервального повторения и хранение знаний в виде флеш-карт (Хабростатья про диплом бакалавра). Однако, флеш-карты слишком независимы друг от друга (не подходят для хранения связанных знаний о спринге). Даже для изучения Java их эффективность средняя. Да и они тоже не естественны, ведь программист должен повторять через практику.

Я многие годы ломал голову над тем, как сделать обучение 100% завязанным на практику (как следствие — не скучное и с высоким КПД). Сейчас я коротко расскажу о вариантах, которые были перепробованы. Для начала, я пытался найти набор подробных и учебных ТЗ, которые бы, кроме задач давали бы технические наводки (разработать такой-то REST Api используя такие-то классы). Ничего дельного я не нашёл, и потратил кучу времени. Да, я видел отдельные авторские курсы по некоторым частям спринга, но полного покрытия сертификации нигде не собрать. Да и «книжная» проблема этих туториалов остаётся (хоть и некоторые авторы пытались сделать пошаговые руководства, они всё равно имеют недостатки). P.S.: Если у вас есть что-то вроде «Учебных ТЗ» по спрингу, обязательно отправьте их мне на kciray8@gmail.com.

Одна из проблем книг и туториалов — их очень скучно и нудно читать. Это ещё больнее, чем гуглить баги. Я не хочу читать, я хочу кодить! Что, если использовать книгу только для наводки на темы и названия классов, а потом уже самостоятельно (через эксперименты и гугл) догонять всё остальное? А уже потом и главу перечитывать, пересиливая себя и собирая оставшиеся крупицы знаний. Собственно, я так и изучал спринг. Не с начала главы (унылое введение), а с середины, пытаясь за что-то ухватиться и экспериментировать вокруг этого. IDE очень помогает в этом с помощью автозаполнения, просмотра JavaDoc и исходников, удобной отладки. Я бы назвал это «изучение с помощью экспериментов с API». Я даже развил ряд особых методик вокруг этого метода, но там всё равно остаются некоторые фундаментальные проблемы.

А именно, проблема «ступоров» никуда не девается. Она вызывает по-прежнему много боли, хоть это уже более естественно и приближенно к практике (в реальных проектах придётся много таких ступоров решать, прокачать навык будет полезно). На самом деле, на этой методике можно вполне себе дойти до конечной цели (сертификация). Но это будет требовать очень много усилий, в 3-4 раза больших, чем если бы идти по накатанной дорожке. Да и проблема повторения информации всё равно остаётся. И хочется сделать что-то более приближенное к идеальному. Вдруг моя новая методика окажется полезным большому количеству людей и изменит мир? И в конце 2017 года мне пришла в голову такая идея, да так, что захотелось её сразу реализовать и изначально я делал очень большие ставки на успех.

Давайте подумаем, как происходит обучение по классическому (большей частью пассивному) туториалу. Большинство туториалов по Spring просто отвратительны по своей структуре (включая гайды на spring.io). Самый большой их недостаток, который я просто терпеть не могу — это линейность. Многие авторы «вываливают» большие куски кода, которые нужно копипастить к себе. Было бы правильнее начинать с простого примера (минимально возможной демонстрации, которую можно запустить и поэкспериментировать), и потом накручивать на него разные навороты. Принцип «от простого к сложному» — золотой закон обучения! Но нет ведь. Каждый автор считает нужным накрутить информации в 2-4 раза больше чем нужно, по кускам это разбирать и только потом запускать.

К примеру, откроем руководство по поднятию SOAP-сервиса на спринге (https://spring.io/guides/gs/producing-web-service, недавно на работе понадобилось). Они тут и spring-boot прикрутили, и wsdl4j с процессом генерации Java-классов с использованием gradle, и целый in-memory репозиторий CountryRepository (хотя простой строки «Hello world» мне хватило бы). И только в самом конце объяснили, как с помощью curl запустить всю эту систему. Нет, я конечно всё понимаю — авторы хотели дать наглядный пример «всё в одном» и разобрать его. Но, с точки зрения понимания информации, такой подход не годится.

Вы любите «читать» скучный разбор и копипастить куски кода (каждый по пол страницы)? Я это терпеть не могу. Хочу вот получать опыт экспериментальным путём, и всё тут.

Идея активных туториалов (KciTasks)

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

Концепция проекта с чистого листа

Перед тем, как продолжить разбор активных туториалов, хотелось бы рассказать об одной важной концепции, на которой они базируются. Эту концепцию вы можете использовать совместно с любой методикой обучения, но почему-то о ней редко пишут или упоминают где-то. Так вот, суть её в том, что тренировочные проекты нужно делать с нуля. Никаких start.spring.io, каждый день заходите в File->new Project->Hello world и на нём базируете ВСЕ ваши проекты, включая веб. И все maven-зависимости тоже забиваете по-новому. Благодаря этому вы запомните зависимости между спринг-модулями, зачем нужен каждый из них и т.д. На практике это очень сильно пригождается, когда есть какие-то проблемы с зависимостями.

Практическая направленность

Любите ли вы XML? Авторы обеих книг по Spring соглашаются, что рано или поздно XML станет пережитком прошлого. Однако, они сами приводят большинство решений в двух вариантах (XML+Аннотации). Я не любил XML до тех пор, пока не устроился в большую компанию. Сейчас это просто часть работы. Слишком много готовых решений сделано, которые просто пронизаны XML и переписать их без него — потратить огромные деньги и получить несравнимо мало. Никто не будет этого делать. Поэтому, я старался чередовать XML/Аннотации в моих задачках, что и вам рекомендую. Если правильно обучаться (по описанной в статье методике), то XML не вызывает проблем, а, напротив, помогает взглянуть с другой стороны на некоторые решения и лучше их запомнить. Написание XML кода (с автозаполнениями и подсказками, с помощью IDE) также приятно, как и написание Java кода.

Приближаемся к идеалу (0.5% копипасты, 5% чтения)

Каждая инструкция в активном туториале должна быть выполнимой БЕЗ копипасты. Современные IDE позволяют умножить её на ноль. Да, даже beans.xml со всеми его приблудами, даже dependencies — всё можно сделать внутри IDE. Это намного приятнее, чем бездумно копировать код. Как я уже сказал, я хочу сделать обучение приятным и это одно из проявлений.

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

Специальный язык для активных туториалов (KML)

Одна из причин, по которым активные туториалы до сих пор никто не распространил — отсутствие формата для их хранения. Существующие языки разметки совершенно не подходят для перемешивания кода и текста. Первую версию KciTasks я сделал как надстройку на HTML, и это было просто ужас как неудобно! Потом я сделал свой небольшой язык разметки, который отличным образом подходит для тасок и компилируется в HTML. И происходит это прямо во время загрузки веб-страницы. Вот примеры:

Пример 1 — Создание бина JdbcTemplate

Пример 2 — Создание файла schema.sql

План полного покрытия Core Spring 5.0 Certification

В интернете существует холивар о том, нужны ли сертификаты. Об этом можно написать отдельную статью, но в рамках этой статьи я просто напишу «нужны и как можно больше». Месяц назад вышел Study Guide по Spring 5 (и сам экзамен от pivotal), поэтому имеет смысл ориентироваться на него. Для нас это может служить в качестве плана, или некоторого стандартного набора, который спрашивают на собеседованиях и который может быть полезен для ваших проектов.

По каждой теме нужно сделать 6-8 уникальных задачек, которые затрагивают требуемый объём знаний и подают информацию с разных точек зрения (например, DataSource создаётся разными способами — с помощью билдеров, вручную, с использованием пропертей, через аннотации или XML, автоматически через Boot и т.д.). Потренировавшись, программист надёжно запомнит, что же такое DataSource и как он применяется (вместо того, чтобы «выучить, сдать и забыть», как делают многие). Кроме того, темы часто взаимно пересекаются (Container и AOP используются в Spring Data). Это позволяет очень хорошо углубить основы основ.

Не смотря на максимальную автоматизацию процесса через язык разметки, разработка тасок остаётся весьма трудоёмкой задачей. Особенно, если их делать качественно (демонстрируя всё в простой форме и с правильной перспективы). Например, мне потребовалось около 10 часов, чтобы разработать задачку по уровням изоляции в транзакциях. Казалось бы, нужно всего лишь продемонстрировать разницу между 4-мя уровнями, запустив транзакции параллельно. Но не тут-то было! Для H2 и MySQL не видна разница между некоторыми уровнями, и они по-разному обрабатывают конфликтные ситуации (одни БД возвращают старые копии данных, другие — вводят транзацию в режим ожидания). И только в DerbyDB наглядно можно увидеть разницу между всеми уровнями. Все авторы книг такие умные — копируют теорию, а вот показать её на практике — полноценный пример так и не получилось найти, пришлось самому выводить.

Суть моего плана в том, чтобы объединить мои усилия с вашими и вместе разработать большое количество уникальных задачек по Spring 5. Все, что требуется от вас, это отправить мне на почту *.kml-файлик с задачкой, и zip-архив проекта. Задачки будут доступны бесплатно и без регистрации, для всех, через GitHub-вебсайт. Или вы можете сделать пулл-реквест (если нужно что-то доработать в самом движке). Я верю, что вместе мы сможем создать новый принцип обучения и нести его в массы.

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

Рекомендации

По каждой теме спринга можно придумать множество уникальных тасок. Например, вы можете давать указания по разработке некоторого REST API через спринг MVC, а потом получать данные с него через RestTemplate и выводить их в консоль. Получается 2 в 1, некоторое замкнутое кольцо. Вообще, простор для творчества тут очень большой, нужно лишь время и желание. И чем больше уникальных задачек, тем лучше! Если вы хотите добавить что-то своё (необычное) — вперёд. Многогранность обучения очень важна. Нужно показать одни и те же знания с большого количества разных ракурсов, тогда они хорошо запомнятся. Главное — соблюдайте баланс, о котором говорилось выше (каждая инструкция требует что-то сделать, но не слишком много). Вместе мы сможем конвертировать знания из книг в форму тасок и сделать большое дело!

P.S.: Если кто-то из читателей проходил экзамен и/или официальный курс от pivotal, напишите мне на kciray8@gmail.com.

Система обучения или система повторения?

Я вижу два пути, по которым вы можете использовать KciTasks. Первый — использовать её для углублённого изучения спринга. На мой взгляд, это должно быть эффективно. Вы просто выполняете инструкцию за инструкцией, сверяясь с решением и корректируя себя. По началу вы будете много «подглядывать» туда, но это нормально. На следующий день попробуйте подглядывать как можно меньше и всё делать самому. Все таски рассчитаны на то, чтобы быть сделанными без разворачивания спойлеров, СОВСЕМ. Вам надо к этому прийти. Обратите внимание, что вы не гуглите (. ), не читаете доки или книжку. Таски самодостаточны, просто вчитвайтесь в инструкцию и решение к ней, и выводите знания из экспериментов.

Второй путь — использовать KciTasks для повторения. Когда вы изучаете какой-либо фрейм или язык программирования по книге/курсу, вы вкладываете много усилий. И пусть они не пропадут даром — вложите весь полученный опыт в таски, чтобы потом через полгода можно было пройти по проторенной дорожке и всё вспомнить.

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

Источник