Мои уроки по программированию

Всем привет! Друзья, некоторое время назад я начал серию статей с уроками по программированию. В основном это уроки по Angular и Java. Сегодня хочу собрать то, что удалось сделать за это время в небольшую обзорную статью. Итак, поехали!


Анонос статей

В ближайшее время на сайте (и, естественно на моем канале) выйдут следующие статьи:

  • Какие проекты делать начинающему разработчику?
  • Короткая текстовая версия моего нашумевшего видео «Как стать Java-разработчиком в 40 лет».
  • Java SpringBoot HelloWorld
  • Java jdbc HelloWorld
  • Java Spring jdbcTemplate HelloWorld
  • Java JPA HelloWorld
  • Java Spring REST Helloworld
  • Java SpringBoot REST Helloworld
  • Java SpringBoot + jdbcTemplate REST Helloworld
  • Java SpringBoot + JPA + Postgres REST Helloworld
  • Как пользоваться Postman’ом чтобы отправлять запросы.
  • Java Helloworld из консоли.

Мои видео

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

Во-первых, это видео о том, как стать Java-разработчиком в 40 лет и напомню, что скоро выйдет более короткая версия этого видео:

И так же, у меня есть видео о том, как проходить Java-собеседования на позицию Java Junior (точнее как я их проходил) со списком часто-задаваемых вопросов:

Пишем первый Maven HelloWorld

Всем привет! Сегодня напишем простейшее приложение со сборщиком Maven. Более подробно по этой теме я рассказывал здесь. По ссылке в статье Вы сможете узнать о том, как установить Maven, я так же подробно и с примерами разъясняю суть всех ключей команды mvn. Поэтому сегодня будет сокращенная версия этой статьи.

Итак, открываем консоль. Напомню, я пользуюсь вместо стандартной виндусовой, сторонней ConEmu. Создаем папку для нашего будущего проекта, переходим туда с помощью cd и там выполняем следующую команду:

Далее система Вам будет задавать следующие вопросы:

Define value for property ‘groupId’: отвечаем — «com.antonromanov»

Следующие вопросы просто подтверждаем клавишей Enter. Вот наглядный скриншот иллюстрирущий это:

Теперь открываем нашу IDE. У меня это все так же JetBrains IntelijIdea. В стартовом диалоговом окне выбираем Open:

Переходим в дереве директорий до только что созданной, у меня это MavenHW, раскрываем ее и в ней выделяем мышью файл pom.xml. Жмем Ок. На следующий вопрос отвечаем обязательно Open as Project

Ну и теперь давайте подключим какую-нибудь зависимость и используем ее в нашем проекте.

Сразу приведу код Pom.xml. Вы можете скопировать его и вставить в свой, только если Вы меняли группу и архетип относительно моих, поменяйте их и моей версии pom.xml тогда:

Мы добавили вот такую зависимость:

<dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.0</version>
</dependency>

Эта dependency добавляет в проект функционал от компании Apache и в частности их строковые утилиты. Например, у нас появляется метод isBlank, позволяющий проверить пустая ли строка, причем пустой строкой будет и считаться строка, содеражащая пробелы, но не содаржащая символов. Переходим в класс App.java и вставляем следующий код:

Что мы тут делаем? Мы задаем три строки foo1, foo2, foo3: с текстом, полностью пустую и с пробелом. После чего печатаем в консоль результат исполнения метода StringUtils.isBlank, который на вход принимает строку и в случае, если она не содержит символов возвращает true. Если мы запустим программу, то в консоли соответственно получим:

Строка №1 - false
Строка №2 - true
Строка №3 - true

… что соответствует правде.

Пара замечаний:

  • Если при добавлении этого кода, строчка StringUtils.isBlank подсвечивается красным, выставьте на нее курсор мыши, нажмите Alt+Enter и выберете Import:
  • Как запустить программу? Выделите файл App.java в дереве проекта, вызовете контекстное меню, щелкнув на нем правой кнопкой мыши и там найдите Run ‘App.main()’, либо нажмите Ctrl + Shift + F10.

Spring Framework. HelloWorld Example с Maven и без XML

Всем, привет! Продолжаю серию своих уроков, посвященных программированию на языке Java и в частности Spring Framework. В предыдущих статьях мы научились добавлять jar-файлы (библиотеки) в пустой Java-проект, создавать простое Spring приложение сконфигурированное на XML как с ручным добавлением библиотек, так и с помощью сборщика Maven.

И сегодня мы создадим с Вами Spring приложение со сборщиком Maven и без XML. Такой тип конфигурирования приложения еще называют java-based или конфигурирование с помощью аннотаций.

Хочу отметить, что текущий стандарт де-факто в современном «взрослом» java-производстве (в современной enterprise-разработке) это SpringBoot + Maven. И все сконфигурировано аннотациями. Так что мы изучаем с Вами в этой статье почти что «взрослый» вариант. Поехали!

На этот раз уже не будем тратить время на создание Maven-проекта из консоли и создадим его прямо из IDE. Как и всегда, я использую JetBrains IntelijIdea.

Итак, открываем нашу IDE. Если у Вас открылся прежний проект, то выбираем File / New / Project. Если вы открываете среду разработки в первый раз, то видим следующее окно:

Жмем «Create New Project». В следующем окне, в списке справа выбираем Maven. В нижний список через какое-то время подгрузятся все возможные варианты арчетайпов (о них мы говорили в предыдущей статье). Не выбирайте ничего и жмите Next.

В следующем окне задаем местоположение и имя проекта. В раскрывающимся списке внизу — вводим группу нашего будущего проекта и название артефакта. Группа появится в Pom-файле в теге <groupId>, а артефакт — именно под его именем будет генерироваться будущий jar-ник и под его именем проект попадет в локальный репозиторий Maven (что позволит его потом переиспользовать):

Жмем Finish.

Если внизу у Вас всплыло вот такое вот окошко, обязательно нажмите Enable Auto-Import:

Это позволит Maven’у автоматически импортировать зависимости при добавлении новых.

Находим в дереве проекта файл pom.xml, это как раз и есть конфигурационный файл сборщика и вставляем туда следующее:

На что стоит обратить внимание? Смотрите, мы вынесли версию Spring’а как отдельное свойство наверх в тег «properties«:

<properties>
        <org.springframework.version>5.2.3.RELEASE</org.springframework.version>

</properties>

Это дает нам возможность просто потом использовать ее как ссылку вида ${org.springframework.version}. И при необходимости поменять версию — мы поменяем ее 1 раз, а не несколько, как если бы вставляли бы ее в каждый тег dependency.

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

Теперь нам осталось добавить основной код нашего проекта и наслаждаться! Поехали!

Переходим на дерево проекта справа (вкладка так и называется — Project), разворачиваем ее до уровня java (иконка папки выделена синим), вызываем на ней контекстное меню, там выбираем пункт New / Package и вводим название пакета. У меня это:

Как видно, пакет с одной стороны совпадает с Мвановским groupId, с другой стороны отражает суть проекта.

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

В комментариях я специально пометил что значит та или иная строчка. Кстати, я бы еще добавил, там где в комментарии написано «поле», что это «приватное поле». То есть оно видно только в рамках класса. Обратится к нему извне можно только через геттер или сеттер. Ну или через конструктор, как в моем примере.

А теперь мы сделаем с Вами святая святых современного Spring-проекта — класс конфигурации или просто конфиг. Собственно это и есть аналог-заменитель xml-конфигурации. И сообщаем мы Спрингу о том, что это конфигурация специальной аннотацией @Configuration.

Вот его код:

У нас есть 2 метода, первый из них закомментирован.

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

Ну и нам осталось написать наш главный класс с методом Main:

Разница с предыдущими моими статьями (то есть, с конфигурацией через xml, что теперь мы используем класс AnnotationConfigApplicationContext для конфигурирования Спрингового контейнера. У него в аргумент передается класс конфигуратора, а не путь до файла beans.xml. Вот и все.

Запускаем приложение и вуаля…. (я надеюсь, как запускать приложение Вы уже знаете??? )

Java. Spring Framework HelloWorld Example с XML и Maven

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

Если говорить своими словами, Maven — это система сборки и управления зависимостями для Java-проектов.

Одно из Важных преимуществ Maven — это как раз управление dependency (зависимостями). Помните, как в предыдущих статьях мы добавляли необходимые библиотеки фреймворка Spring в ручную? Maven позволяет в специальном конфигурационном xml-файле просто указать в специальном формате блоки так называемых dependency и IDE сама подтянет в проект все необходимые библиотеки.

Кроме того, Maven позволяет управлять репозиториями. Что это значит? Например, вы создаете какой-то функционал, хорошая иллюстрация — так называемый коннектор, то есть набор методов, которые, предположим, ходят в некое покупное API и позволяют массово отправлять SMS или email, делать рассылки. Внутри коннектора у вас куча кода: проверки разные, антифрод, куча бойлерплейта (то есть куча обслуживающего служебного кода). А наружу у вас торчит только один метод:

Вы создаете в своей организации (или на локальной машине, если вы единственный разработчик) Maven-репозиторий, где будут лежать подобные коннекторы. После его написания вы выполняете команду mvn install для «отправки» его в репозиторий, а потом в коде ваших приложений вы указываете, где лежит ваш дополнительный репозиторий (например, если он внешний, лежит не в стандартной папке, а на отдельном сервере), указываете dependency в pom-файле и вуаля — в нужном классе, вы просто делаете import и используете метод коннектора и в хвост и в гриву.

pom-файл, он же «помник» — собственно и есть тот самый конфигурационный файл Maven’а.

У Maven есть и масса других возможностей, но о них мы поговорим позже, в других статьях. Давайте, перейдем, наконец, к написанию кода нашего приложения!


Я исхожу из того, что у Вас уже установлена JetBrains Intelij Idea. Если это не так, если вы пишете код в другой IDE или планируете использовать простой текстовой редактор типа Sublime или Vim и ставить Maven вручную, то гуглите — статей о том, как установить Maven в интернете очень много, как в англоязычном, так и в русскоязычном. Если же Вы хотите, чтобы об этом написал я, то пишите — если пост или видео наберет должное количество комментариев — то материал будет.

Итак, запускаем Вашу Intelij Idea (я использую самую последнюю версию), далее идем в File — Settings… или жмем Ctrl + Alt + S. В меню поиска вверху вбиваем «Maven» и видим примерно следующее:

У меня, как видно установлен Maven версии 3.6.1 (JetBrains сама устанавливает свой Maven, при отсутствии внешнего). И ниже в поле Local repository как раз можно увидеть ссылку, куда установлен у вас Maven. Ее нужно прописать в переменные среды Windows (если у Вас Linux — опять же, гуглите, там все чуть-чуть по другому).

Запускаем Explorer и спускаемся по этому пути. Нам нужно удостовериться в местоположении папки bin:

Как видно, у меня она есть. У Вас путь должен быть плюс-минус такой же.

Далее — правой кнопкой мыши на «Мой компьютер» или «Этот компьютер«, выбираем свойства:

… там выбираем пункт «Дополнительные параметры системы«, в появившемся диалоговом окне жмем кнопку в самом низу — «Переменные среды«. Теперь нам надо добавить пути до Maven. Жмем «Создать» под верхним списком. Добавляем переменную M2. В нее добавляем путь до папки bin:

Так же добавляем переменную M2_HOME. В нее добавляем путь до папки родительской для папки bin. Ну и в переменную Path должно быть добавлено следующее:

… то есть %M2%.

Теперь запускаем консоль и вводим:

mvn -version

… мы должны увидеть что-то подобное:

Кстати, я пользуюсь сторонней консолью ConEmu, вместо стандартной Виндусовой — рекомендую всячески! Как видно на картинке выше mvn -version подтвердил, что у меня установлена версия 3.6.1. Если система будет ругаться на то, что не опознает mvn как команду или что-то там не найдено — значит Вы как-то не так прописали пути.

Теперь попробуем создать наше приложение с консоли. Консольная команда mvn позволяет генерировать пустые джава-проекты, снабженные всеми необходимыми dependency в зависимости от «ключей», которые вы указываете при генерации. Собственно за конфигурацию приложения (то есть за набор dependency в «помнике» (см.выше — что это)) и отвечает так называемый арчетайп (archetype). Там же в cmd или любом Вашем консольном приложении (в Linux это хозяйство называется «терминал») переходим в папку, где будет расположено ваше приложение с помощью cd и вводим следующее:

Давайте сразу разберем, что это и с чем это едят. Потому что, я прекрасно помню себя, когда я только начинал изучать Яву и хватался за все подряд — все эти арчетайпы, группы, айди — все это была какая-то каша просто.

mvn archetype:generate — это собственно сама команда mvn с ключом, говорящим «сгенери мне готовый проект».

-Dgroup=com.antonromanov и -DartifactId=JavaHelloWorld — это так называемая группа и артефакт. Зачем это нужно и для чего (простыми словами)? Открою Вам сейчас боевой проект нашей компании и покажу как это используется:

Справа как раз открыт тот самый «помник» и видна его классическая структура. Неотъемлимой частью Pom-файла как раз является указание groupId и artifactId. Обратите внимание, группа частично совпадает с paсkage-name на панели слева: «club.apibank.connectors.kontur». Если перейти по url самого внешнего репозитория (как правило в больших компаниях они лежат на отдельном сервере), мы увидим:

Это web-представление удаленного репозитория. На жестком диске его структура попапочно будет плюс минус такая. Обратите внимание, сверху указана коллекция из Dgroup: club/apibank/connectors и далее представлены артифакты (artifactId), по которым можно «вытянуть» соответствующий коннектор.

Теперь собственно, вишенка на торте или зачем все это нужно. Спустя некоторое время вы создаете какой-то другой проект и хотите переиспользовать код ранее написанного из вашего репозитория. Внутри pom-файла вы в группе <dependencies> вы указываете:

<dependency>
            <groupId>club.apibank.connectors</groupId>
            <artifactId>apibank-connectors-kontur</artifactId>
</dependency>

… потом в нужном классе просто вставляете import…. и используете public-методы из своего репозитория. Собственно, при генерации проекта в консоли с помощью -DartifactId=JavaHelloWorld вы как раз и указываете по каким группам и артефактам его потом можно будет найти в репозитории.

-DarchetypeArtifactId=maven-archetype-quickstart — собственно это базовый архитип, на основе которого и создается ваш проект. Я раньше парился, типа там столько этих базвых архитипов, как же мне их все упомнить. Теперь, разобравшись уже с вопросом могу сказать — не надо их запоминать! Достаточно запомнить только этот, который создает пустой HelloWorld Maven-проект и все. Все равно в каждом случае наполнение проекта разными депенденси сугубо индивидуально.

Итак, с «Мавеном» («Мейвеном«) разобрались, идем дальше:

Кстати, можно так же в список параметров командной строки еще добавить —DinteractiveMode = false. Если вы запустите первый вариант, то он по ходу выполнения будет вам задавать уточняющие вопросы — «точно ли такая группа?». Ключ DinteractiveMode = false позволяет избавить Вас от этих вопросов и сделать все это в автоматическом режиме.

По итогу в консоли Вы увидите что-то подобное:

То есть, Ваш проект создан и можно открывать его в Вашей любимой IDE (это, конечно же, JetBrains). Открываем JetBrains, выбираем File / Open… и в дереве директорий находим папку только что созданного проекта. Но не спешите жать «Open». Раскройте свиток папки и выбирете файл pom.xml. Нажмите «Open». Появится следующее диалоговое окно:

Выбираем «Open as Project». Типичная структура вновь созданного пустого Java-Maven проекта выглядит примерно так:

Мы видим наш «помник» pom.xml, в папке test лежат как правило Unit-тесты — это нам еще долго не понадобится. Далее вы видите папки исходников: src -> maim -> java -> com.antonromanov — именно ее мы указывали в Dgroups и она же указана в открытом справа помнике в теге <groupId> </groupId>.

Давайте сразу изучим основные команды работы с Maven, которых Вам хватит на ближайшее будущее:

  • mvn clean — в процессе «упаковки» либо «инсталляции» артефактов (то есть файлов jar или war) Maven создает папку target, куда он кладет сами артефакты. clean очищает полностью эту папку и все артефакты внутри нее. Есть плагины, позволяющие на стадии clean очищать какие-либо другие папки в Вашем проекте.
  • mvn package — собственно выполнение компиляции, сборки проекта и упаковки его в war или jar. Если есть тесты или какие-то стайл-чекеры — выполняются и они.
  • mvn install — не только создается артефакт, но он так же добавляется в локальный репозиторий на Вашей машине.

Если Вы откроете вкладку справа в IntelijIdea, во вкладке Lifecycle вы увидите среди других как раз эти команды:

Их действие аналогично вводу в терминале в папке проекта вышеописанных команд.

Если в процессе запуска mvn clean вы увидите сообщение:

Source option X is no longer supported. Use 6 or later.

То нужно сделать следующее. В конец вашего pom-файла вставьте секцию build:

… после этого еще раз выполните mvn package. Вы должны увидеть нечто походее на:

Обратите внимание на то, что я выделил желтым:

  • Создалась папка target c артефактами;
  • В консоли мы видим строчку «Building… «, где Мавен показал нам где и какой он создал артефакт.
  • Ну и мы так же видим так важный для нас «BUILD SUCCESS».

Собственно, теперь нам надо добавить эти самые пресловутые dependency в наш проект. Ниже я укажу полный код pom.xml, чтобы Вы видели что за чем идет и в будущем у Вас не было путаницы:

Теперь, нам осталось лишь наполнить наши классы кодом (это мы делали в предыдущей статье, поэтому нового особо ничего тут не будет) и проверить, что все работает.

Создаем класс HelloWorld как и в прошлый раз (в пакете com.antonromanov). Его код такой же, как и в прошлый раз:

Главный класс, отвечающий за запуск и конфигурацию Spring-контейнера тоже не поменялся:

Но обратите внимание, где теперь лежит Beans.xml. Именно это немного меняется с приходом в проект Maven. Собственно, на картинке можно увидеть всю структуру проекта:

Да, верно, у нас появилась папка resources и Beans.xml лежит в ней. Его код тот же:

Ну а теперь, запускаем приложение и наслаждаемся! Поздравляю: Вы только что создали свое первое Spring-приложение с XML-конфигурацией со сборщиком Maven!!!!

Что такое Spring Framework

Когда я только начал свое погружение в мир Java, я обнаружил, что во многих вакансиях на HH помимо Java Core значатся как правило еще 2 строчки:

  • Hibernate
  • Spring

И я решил узнать, что же такое Spring и с чем его едят. Однако попытки зайти на сайты типа spring.io и его русские зеркала запутали еще больше. Дело в том, что информация на подобных сайтах рассчитана на то, что программист уже знаком с понятиями DI и IoC, являющимися фундаментом Spring, а так как я не знал что это, то все, что было написано в основных мануалах мне было абсолютно не понятно.

Понятно, что на Спринге выросла целая эко-система, дающая программисту огромный функционал работы с различными аспектами программирования — и с БД, и с авторизацией и с WEB-функционалом. Однако начнем с простого. Итак, Spring реализует для программиста функционал IoC. DI же является одной из реализаций IoC так же как Factory method или Service Locator.

Ну а теперь пришло время сделать 3 вещи:

  • Рассказать что это, собственно, за понятия;
  • Объяснить, зачем это нужно и какие преимущества это дает программисту;
  • Объяснить, почему начинающему программисту так сложно это понять.

И начнем мы, пожалуй, с последнего.

Почему так сложно понять Spring начинающему программисту?

Не знаю, слышали ли Вы или нет, но часто можно услышать мнение о том, как важно начинающему разработчику изучать так называемые «Паттерны прогроммирования«. Однако, если Вы достанете, к примеру вот эту легендарную книгу:

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

В видео чуть ниже я привожу конкретный пример, в каком случае мы можем упереться в проблему жесткой связанности кода. Кстати, еще одна проблема, о которой я не рассказываю ниже — это проблема тестирования отдельного «компонента», поведение которого жестко завязано на другой компонент. Оно (тестирование), как правило, затруднено в рамках большого проекта. Ну, а прежде чем Вы доберетесь до видео, давайте раскроем базовые понятия, столпы, на которых, собственно и строится Spring Framework:

Теория

IoC (Inversion of Control) — это некий обощенный принцип, аккумулирующий набор правил и рекомендаций для написания так называемого слабосвязанного кода.
Слабосвязанный код — это код, каждый компонент (класс) которого максимально изолирован от другиз и внутренняя реализация этого компонента минимально зависит от реализаций других.
Dependency Injection (внедрение зависимостей) — одна из реализаций Ioc (к примеру, есть еще Service Locator, Factory Method).

Ну а теперь собственно видео, иллюстрирующее всю проблематику жесткосвязанного кода и потребность в Ioc и DI:

Spring Framework. Создаем первое HelloWorld приложение без Maven на XML

Этой статьей я продолжаю свои уроки по Java. Я немного прыгнул через голову и пропустил серию материалов по Java Core, оставив за бортом базовые ключевые слова, операторы и прочее. Думаю, что если подобный материал окажется востребованным, я обязательно освещу в своих статьях и эти темы. Ну а сегодня мы создадим простое HelloWorld java-приложение с использованием Spring Framework на xml-конфигурации без сборщиков (типа Maven).

Первое, что Вам нужно, это склонировать себе этот проект — https://github.com/Latinist/libs4Spring.git. Так как я намеренно привожу этот пример именно без использования каких-либо сборщиков типа Maven (с Maven мы попробуем этот же пример в другой раз), то все необходимые для работы с фреймворком Spring библиотеки мне пришлось выложить отдельно.

Если Вы еще не знаете, как работать с Git, то сделаем так. Заходим в браузере по ссылке https://github.com/Latinist/libs4Spring.git, видим следующее:

… щелкаем на зеленую кнопку «Clone or download«, в выпадающем меню выбираем Download ZIP, качаем себе архив, распаковываем, запоминаем путь к папке. В архиве коллекция *.jar-файлов. Это бибилиотеки, необходимые для использования в проекте фреймворка Spring.

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

Итак, создаем проект (я использую IDE от JetBrains Intelij IDEA, что и Вам рекомендую), добавляем скаченные библиотеки и видим следующую картинку:

Я специально раскрыл ветку с библиотеками в панели справа. Кстати, сейчас IDE сама назвала ее по имени первой библиотеки в списке — common-logging. Вы можете зайти и переименовать группу бибилиотек. Например, Spring.

Добавим наш первый Бин.

Что такое Бин? Бин (от английского — «кофейное зерно») — это по сути обычный java-объект. Его отличие от всех остальных объектов в том, что он управляется DI-контейнером. Про Dependency Injection и DI-контейнер, по сути, главный механизм Spring’а, мы поговорим позже, в отдельном видео и статье. А пока просто возьмите себе на заметку, если вы ничего не знаете об этом, что это такая фича, которая выросла из потребности программистов при рефакторинге большинх интерпрайз-проектов иметь слабосвязнный код.

Щелкаем правой кнопкой мыши на названии пакета com.antonromanov.firstspring.application и видим контекстное меню:

Выбираем New. В следущем окне вводим название нашего бина HelloWorld и двоыс щелчком по элементу Class подтверждаем выбор. У нас появляется вкладка HelloWorld с пустой «рыбой» нового класса. Пишем там следующий код:

public class HelloWorld {
	private String message;

	public void setMessage(String message){
		this.message  = message;
	}
	public void getMessage(){
		System.out.println("Your Message : " + message);
	}
}

Теперь нам нужно вызвать добавить немного строк в класс Main, чтобы обратиться к этому Бины. Щелкаем на него и вставляем следующий код (добавляем метод):

public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
        obj.getMessage();
    }

Если Intelij IDEA подчеркивает некоторые фрагменты кода красным вот так:

… Установите указатель мыши на них и нажмите Alt + Enter. Если появится контекстное меню, выберете «Import Class«. В верхней части класс должны появится две строчки импорта:

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

Осталось добавить конфигурационный файл настройки бинов. Переходим в каталог src, добавляем новый файл:

Называем его Beans.xml и вставляем туда следующий код:

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
       xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean id = "helloWorld" class = "com.antonromanov.firstspring.application.HelloWorld">
        <property name = "message" value = "Hello World!"/>
    </bean>

</beans>

Осталось запустить программу и получить в консоли:

Теперь, в кратце что мы сделали простыми словами:

  1. Main — это класс нашего консольного приложения, содержащий метод public static void main(String[] args). Именно этот метод Java-машина воспринимает как «точка входа в программу». Именно через него JVM реализует «выполнение» вышего приложения.
  2. В этом методе мы используем ClassPathXmlApplicationContext (и это не единственный способ) как способ сообщить DI-контейнеру Спринга как будет происходить конфигурирование бинов. В данном случае мы указываем ему, что конфигурирование будет происходить с помощью файла Beans.xml, лежащего в application path. ApplicationContext — это интерфейс, определяющий контекст нашего приложения. В свою очеред контекст приложения — это его главный интерфейс, определяющий всю онфигурацию Spring-приложения.
  3. Вот этой строчкой «HelloWorld obj = (HelloWorld) context.getBean(«helloWorld»);» мы «достаем» из контекста наш Бин HelloWorld. Но достаем именно средствами Dependency Injection, а не прямым наследованием или созданием инстанса. Зачем это нужно, мы поговорим в других статьях.
  4. Весь Beans.xml по сути xml-конфигурационный файл для конфигурирования, простите за тавталогию, DI-контейнера приложения. Мы описываем здесь наши бины, можем заранее инициализировать какие-то параметры бинов и так далее. Собственно вот тут:
<bean id = "helloWorld" class = "com.antonromanov.firstspring.application.HelloWorld">
        <property name = "message" value = "Hello World!"/>

… мы сообщаем «Спрингу», вот, дескать, у нас есть бин, с id «helloWorld» (именно по нему мы потом достаем его в методе Main), находящемся в пакете com.antonromanov.firstspring.application.HelloWorld и так как у бина есть сеттер, мы прям в xml инициализируем ему переменную message значением Hello World строчкой <property name = "message" value = "Hello World!"/>

Вот, собственно и все. Мы написали наше первое Spring-приложение.

В следущий раз мы обязательно сделаем это со сборщиком Maven и перейдем от xml-конфигурации к конфигурированию аннотациями.

Видео-версия этой статьи:

Toyota Fortuner VS Toyota LandCruiser Prado


Как я понял, 90% людей, выбирающих в этой нише мучаются этим вопросом: форч или lcp. Имхо, в кратце о минусах LCP:⠀

🚗 Это самая угоняемая тачка в России во все рейтингах из года в год.⠀
🚗 Как следствие сразу получаем огромное по стоимости КАСКО и заморочки с сигналками.
🚗 Более или менее симпатичный салон и интересные фишки начинаются от 4к. В остальных комплектациях из преимуществ имеем только фултайм.
🚗 Тяжелее.
🚗 Он просто стоит на Лям дороже. И это не топовая версия относительно топовой у форча, а просто адекватная. ⠀
🚗 Просто жалко убивать тачку в таком ценнике.

Имхо, минусы форча:⠀

🚗 Местами довольно убогий салон. Но, с другой стороны, перешить весь салон Алькантарой — 150 — 200к.
🚗 Не так понтово. Форчунер это уже больше инструмент, а не пафос. С другой стороны это отличный повод отказаться от попыток самоутверждаться машиной.
🚗 За разницу в цене можно сделать афигенный внедорожный тюнинг.

Ну а в конце небольшой ролик о сравнении Toyota Fortuner и Toyota LandCruiser Prado на бездорожье: