Пошаговое руководство для начинаю

Пошаговое руководство для начинающих

Введение

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

Составление пошагового руководства

Чтобы составить эффективное пошаговое руководство, следует учесть ряд важных аспектов:

1. Определите цель: перечислите основные навыки и знания, которые участник должен овладеть в конце процесса обучения.

2. Структурируйте материал: разделите процесс на логические этапы и определите, какой шаг следует после другого. Старайтесь быть последовательным и логичным.

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

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

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

Примеры пошаговых руководств

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

• Руководство по созданию веб-сайта с использованием HTML и CSS.
• Руководство по готовке простого блюда.
• Руководство по основам игры на музыкальном инструменте.
• Руководство по освоению базовых принципов фотографии.

Заключение

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

Понятие Ардуино для начинающих

Ардуино представляет из себя плату, в которую вводится скетч с помощью программы и компьютера. Ардуино является как бы головой собранного устройства и отвечает за многие процессы, в том числе это приём информации и передачи этой информации пользователю. Разберём пример для начинающих. Если мы возьмём ультразвуковой датчик, то он будет излучать ультразвук, который поможет прибору определить расстояние до какого-либо предмета. Информация будет передаваться на плату Ардуино, тем временем сама плата выведет нужное значение на дисплей. Её можно скачать с официального сайта: www.arduino.cc

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

Начало обучения

Обучение работе с Ардуино следует начать с основных команд. Самое основное в системе Ардуино – это программирование платы. И соответственно, нужно научиться писать команды, чтобы далее уже загружать целый скетч на плату. Можно посмотреть множество видео, много статей из открытых источников и ознакомится с полезной информацией об этом процессе. В Интернете есть много информации по этому поводу. Начать обучение и знакомство с такой программой можно использовав различные симуляторы и системы, позволяющие использовать плату, не покупая её. 

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

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

Стартовый набор Ардуино

Допустим я новичок, что мне купить для самостоятельного изучения системы Ардуино? Такой вопрос актуален и очень интересен. Давай те же рассмотри, что купить новичку для ознакомления с этой темой. Составим список, который желательно купить себе для изучения:

• Плата Ардуино – как вы все поняли, платы от этой компании бывают разные, но чаще всего берут UNO или Nano. Плата Arduino Nano по своим размер маленькая, а соответственно не требует много место и дешевле, для базового ознакомления как раз таки она подойдёт. UNO как раз таки стандартная плата, которая имеет много разъёмов и она универсальна. Для вашего удобства, Ардуино создали макетную плату. Она полностью универсально и в ней не нужно ничего паять. Все элементы провода просто вставляются в отверстия. Для начинающих пользователей данной системы подойдёт отлично. В такую макетную плату вставляется и сама плата Arduino.
• Различные модули и датчики – конечно же без них сложно представить Ардуино, ведь для этих приборов она и предназначена. Существует огромный выбор датчиков и модулей. Всё зависит от ваших потребностей и бюджета. Из полезных, можно выделить датчик измеряющий давление, температуру и влажность, датчик измеряющий дальность до предмета и другое множество полезных модулей.
• Компоненты – сюда относят резисторы, конденсаторы, диоды, кнопки, светодиоды, транзисторы, фотодиоды и остальные мелкие составляющие приборов.

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

Отличаем подделку Ардуино от оригинала

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

Иногда, продавцы специально продают поддельные платы вместо оригинальных, а как отличить? Существует специальный список, где содержатся официальный магазины, которые перепродают платы Ардуино, стоит для начала найти плату в нём. Если же данного магазина в списке нет, то следует насторожиться и лучше не покупать у этого продавца. Следует обратить внимание и на цену устройства. Оригинальные платы Ардуино поставляются в коробочках, вместе с инструкцией и наклейками.

Поддельные, в частности случаев поставляются просто в запечатанных пакетиках. Если посмотреть на колодки, куда припаиваются провода, то у них дублируются надписи на корпусе колодок сбоку. Шрифт у оригинальной платы чётки и без размытий, в отличии от подделок. Можно заметить и по самому качеству платы и по надписям, что это сделано руками поддельщиков, так как их оборудование не такое точно как у оригинального производителя Ардуино. 

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

Написание скетча

Для начинающих стоит начать с основных программ в языке Arduino. Здесь рассмотрим написание скетча Ардуино с нуля. Простой скетч написать не так уж сложно. Важно понять данную тему и разобраться с основными функциями и командами в данном языке. Основные функции в изучении системы программирования Ардуино:

• pinMode(PIN, type) – задаём нужный пин подключения проводами к модулю, компоненту или датчику.
• digitalWrite(PIN, state) – с помощью этой командой устанавливаем состояние на каком-либо пине, может быть значение либо один либо ноль.
• digitalRead(PIN) – возвращение в прежние состояние входа, может быть значение либо один либо ноль.
• delay(ms) – остановка процесса, на определенное время, к примеру со светодиодом, мигание, то есть светодиод горит, а вводя эту функцию, он на несколько миллисекунд приостановит свою работу, тем самым осуществит мигание.
• analogWrite(PIN, state) – установка нужного напряжение на выходе пина, выставляется до значения 255, а минимальное значение – ноль.
• analogRead(PIN) – возвращает прежнее значение напряжение на пине, значение составляет от нуля до 1023.

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

// переменные с пинами подключенных устройств

 int switchPin = 8;

 int ledPin = 11;

// переменные для хранения состояния кнопки и светодиода 

boolean lastButton = LOW;

boolean currentButton = LOW;

boolean ledOn = false;

  void setup()

{ pinMode(switchPin, INPUT);

pinMode(ledPin, OUTPUT);

}

// функция для подавления дребезга

 boolean debounse(boolean last) {

 boolean current = digitalRead(switchPin);

if(last != current) {

delay(5);

current = digitalRead(switchPin);

}

return current;

}

 void loop() {

 currentButton = debounse(lastButton);

if(lastButton == LOW && currentButton == HIGH) {

ledOn = !ledOn;

}

lastButton = currentButton;

digitalWrite(ledPin, ledOn);

}

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

Заключение

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

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

В этой статье вы пройдёте через 10 шагов, которые помогут вам прийти к понимаю вашей цели, ваших возможностей и тому как их использовать. Приступим:

Шаг 0. Закладываем знания

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

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

Шаг 1. Создаем подушку безопасности

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

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

Шаг 2. Устанавливаем цель

На этом этапе мы должны поставить цель вашего инвестирования, так как от неё будут отталкиваться все следующие действия. Чаще всего
инвесторы стремятся к:

Чётко поставленная цель помогает достичь лучшего результата. Это
связано с тем, что вы сможете подобрать более эффективные средства для ее достижения и с более высоким уровнем мотивации.

Шаг 3. Определяем риск профиль

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

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

Шаг 4. Визуализируем ваши цели

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

Шаг 5. Обдумываем стратегию

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

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

Выделяют несколько базовых стратегий инвестирования:

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

Шаг 6. Выбираем активы

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

Ваш портфель может состоять из:

Существует два основополагающих принципа составления портфеля:

Шаг 7. Ищем лучшего брокера

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

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

Шаг 8. Открываем счет

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

Здесь я бы хотел сказать, что если вы собираетесь инвестировать в акции российских компаний, то рекомендую открыть ИИС, так вы сможете получить налоговый вычет (только обязательно ознакомьтесь с условиями).

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

Шаг 9. Реализовываем задуманное

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

Шаг 10. Продолжаем инвестировать

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

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

Советы новоиспеченным инвесторам

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

Чем больше ваш доход, тем больше вы сможете инвестировать, не
пренебрегайте возможностями подзаработать.

Не относитесь к инвестированию как к казино, здесь есть свои
закономерности. Акции -это доля в бизнесе (пусть и небольшая) и относиться к этому нужно соответствующе.

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

Очень важна дисциплина. Сделайте инвестиции одной из ваших статей
расхода и регулярно вкладывайтесь.

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

Постоянно узнавайте новое. Если вы уже составили свой портфель, то
это ещё не конец, заработать капитал не так трудно, как его сохранить.

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

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

Я хотел бы предложить вам принципиально новый подход к изучению Спринга. Он заключается в том, что человек проходит через серию специально подготовленных туториалов и самостоятельно реализует функционал спринга. Особенность этого подхода в том, что он, помимо 100%-го понимания изучаемых аспектов Spring даёт ещё большой прирост в Java Core (Annotations, Reflection, Files, Generics).

Статья подарит вам незабываемые ощущения и позволит почувствовать себя разработчиком Pivotal. Шаг за шагом, вы сделаете ваши классы бинами и организуете их жизненный цикл (такой же, как и в реальном спринге). Классы, которые вы будете реализовывать — BeanFactory, Component, Service, BeanPostProcessor, BeanNameAware, BeanFactoryAware, InitializingBean, PostConstruct, PreDestroy, DisposableBean, ApplicationContext, ApplicationListener, ContextClosedEvent.

Немного о себе

Меня зовут Ярослав, и я Java Developer с 4-х летним опытом работы. На данный момент я работаю в компании EPAM Systems (СПБ), и с интересом углубляюсь в те технологии, которые мы используем. Довольно часто приходится иметь дело со спрингом, и я вижу в нём некоторую золотую середину, в которой можно разиваться (Java все итак нормально знают, а слишком специфические инструменты и технологии могут приходить и уходить).

Пару месяцев назад я прошёл сертификацию Spring Professional v5.0 (без прохождения курсов). После этого я задумался над тем, как можно обучать спрингу других людей. К сожалению, на данный момент нет эффективной методики обучения. У большинства разработчиков складывается весьма поверхностное представление о фреймворке и его особенностях. Дебажить исходники спринга слишком тяжело и абсолютно не эффективно с точки зрения обучения (я как-то увлекался этим). Сделать 10 проектов? Да, вы где-то сможете углубить свои знания и получите много практического опыта, но многое из того, что «под капотом», так и не откроется перед вами. Читать книгу Spring in Action? Круто, но затратно по усилиям. Я вот проработал её 40% (во время подготовки к сертификации), но это было не просто.

Единственный способ понять что-то до конца — самостоятельно разработать это. Недавно у меня появилась идея о том, что можно провести человека через интересный туториал, который будет курировать разработку своего DI-фреймворка. Главная его особенность будет заключаться в том, что API будет совпадать с изучаемым API. Офигенность данного подхода в том, что помимо глубокого (без пробелов) понимания спринга, человек получит ОГРОМНОЕ количество опыта по Java Core. Признаюсь честно, я сам много всего нового узнал во время подготовки статьи, как по Spring, так и по Java Core. Давайте приступим к разработке!

Проект с нуля

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

В чистом проекте создайте 2 главных пакета. Первый пакет — ваше приложение (com.kciray), и класс Main.java внутри него. Второй пакет — org.springframework. Да, мы будем дублировать структуру пакетов оригинального спринга, название его классов и их методов. Есть такой интересный эффект — когда вы создаете что-то свое, это свое начинает казаться простым и понятным. Потом, когда вы будете работать в больших проектах, вам будет казаться, что там все создано на основе вашей заготовки. Такой подход может очень положительно сказаться на понимании работы системы в целом, её улучшении, исправлении багов, решении проблем и так далее.

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

Создаём контейнер

Для начала, поставим задачу. Представим, что у нас есть 2 класса — ProductFacade и PromotionService. Теперь представим, что вы хотите связать эти классы между собой, но так, чтобы сами классы не знали друг о друге (Паттерн DI). Нужен какой-то отдельный класс, который будет управлять всеми этими классами и определять зависимости между ними. Назовём его контейнер. Создадим класс Container… Хотя нет, подождите! В Spring нету единого класса-контейнера. У нас есть много реализаций контейнеров, и все эти реализации можно разделить на 2 типа — фабрики бинов и контексты. Фабрика бинов создаёт бины и связывает их между собой (инъекция зависимостей, DI), а контекст делает примерно то же самое, плюс ещё добавляет некоторые дополнительные функции (например, интернационализация сообщений). Но эти дополнительные функции нам не нужны сейчас, поэтому будем работать с фабрикой бинов.

Создайте новый класс BeanFactory и поместите его в пакет org.springframework.beans.factory. Пускай внутри этого класса хранится Map<String, Object> singletons, в которой id бина замапено на сам бин. Добавьте к нему метод Object getBean(String beanName), который вытаскивает бины по идентификатору.

public class BeanFactory {
    private Map<String, Object> singletons = new HashMap();

    public Object getBean(String beanName){
        return singletons.get(beanName);
    }
}

Обратите внимание на то, что BeanFactory и FactoryBean — это разные вещи. Первое — это фабрика бинов (контейнер), а второе — это бин-фабрика, который сидит внутри контейнера и тоже производит бины. Фабрика внутри фабрики. Если вы путаетесь между этими определениями, можете запомнить, что в английском языке второе существительное является ведущим, а первое — служит чем-то типа прилагательного. В слове BeanFactory Главным словом является фабрика, а в FactoryBean — бин.

Теперь, создадим классы ProductService и PromotionsService. ProductService будет возвращать продукт из БД, но перед этим нужно проверить, применимы ли к этому продукту какие-либо скидки (Promotions). В электронной коммерции работу со скидками часто выделяют в отдельный класс-сервис (а иногда и в сторонний веб-сервис).

public class PromotionsService {

}

public class ProductService {
    private PromotionsService promotionsService;

    public PromotionsService getPromotionsService() {
        return promotionsService;
    }

    public void setPromotionsService(PromotionsService promotionsService) {
        this.promotionsService = promotionsService;
    }
}

Теперь нам надо сделать так, чтобы наш контейнер (BeanFactory) обнаружил наши классы, создал их за нас и инжектировал один в другой. Операции типа new ProductService() должны находится внутри контейнера и делаться за разработчика. Давайте используем самый современный подход (сканирование классов и аннотации). Для этого нам нужно ручками создать аннотацию @Component (пакет org.springframework.beans.factory.stereotype).

@Retention(RetentionPolicy.RUNTIME)
public @interface Component {

}

По умолчанию аннотации не загружаются в память во время работы программы (RetentionPolicy.CLASS). Мы изменили данное поведение через новую политику удержания (RetentionPolicy.RUNTIME).

Теперь добавьте @Component перед классами ProductService и перед PromotionService.

@Component
public class ProductService {
    //...
}
@Component
public class PromotionService {
    //...
}

Нам нужно, чтобы BeanFactory сканировал наш пакет (com.kciray) и находил в нем классы, которые аннотированы @Component. Эта задача совсем не тривиальная. В Java Core нет готового решения, и нам придётся делать костыль самому. Тысячи приложений на спринге используют сканирование компонентов через этот костыль. Вы узнали страшную правду. Вам придется извлекать из ClassLoader названия файлов и проверять, заканчиваются они на «.class» или нет, а потом строить их полное имя и вытаскивать по нему объекты классов!

Сразу хочу предупредить, что будет много проверяемых исключений, поэтому будьте готовы их оборачивать. Но для начала, давайте определимся, чего мы хотим. Мы хотим добавить специальный метод в BeanFactory и вызывать его в Main:

//BeanFactory.java
public class BeanFactory{
    public void instantiate(String basePackage) {

    }
}

//Main.java
BeanFactory beanFactory = new BeanFactory();
beanFactory.instantiate("com.kciray");

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

ClassLoader classLoader = ClassLoader.getSystemClassLoader();

Наверно вы уже заметили, что пакеты разделяются точкой, а файлы — прямым слешем. Нам надо преобразовать пакетный путь в путь к папке, и получить что-то типа List<URL> (пути в вашей файловой системе, по которым можно искать class-файлы).

String path = basePackage.replace('.', '/'); //"com.kciray" -> "com/kciray"
Enumeration<URL> resources = classLoader.getResources(path);

Так, подождите! Enumeration<URL> это не List<URL>. Что это вообще такое? О ужас, это же старый прародитель Iterator, доступный ещё с времен Java 1.0. Это легаси, с которым нам приходится иметь дело. Если по Iterable можно пройтись с помощью for (все коллекции его реализуют), то в случае Enumeration вам придётся делать обход ручками, через while(resources.hasMoreElements()) и nextElement(). И ещё там нет возможности удалять элементы из коллекции. Только 1996 год, только хардкор. Ах да, в Java 9 добавили метод Enumeration.asIterator(), так что можете работать через него.

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

while (resources.hasMoreElements()) {
    URL resource = resources.nextElement();

    File file = new File(resource.toURI());
    for(File classFile : file.listFiles()){
        String fileName = classFile.getName();//ProductService.class

    }
}

Дальше, нам нужно получить название файла без расширения. На дворе 2018 год, Java много лет развивала File I/O (NIO 2), но до сих пор не может отделить расширение от имени файла. Приходится свой велосипед создавать, т.к. мы решили не использовать сторонние библиотеки вроде Apache Commons. Давайте используем старый дедовский способ lastIndexOf("."):

if(fileName.endsWith(".class")){
    String className = fileName.substring(0, fileName.lastIndexOf("."));
}

Далее, мы можем по полному имени класса получить объект класса (для этого вызываем класс класса Class):

Class classObject = Class.forName(basePackage + "." + className);

Окей, теперь наши классы в наших руках. Далее, осталось только выделить среди них те, что имеют аннотацию @Component:

if(classObject.isAnnotationPresent(Component.class)){
    System.out.println("Component: " + classObject);
}

Запустите и проверьте. В консоли должно быть что-то вроде этого:

Component: class com.kciray.ProductService
Component: class com.kciray.PromotionsService

Теперь нам нужно создать наш бин. Надо сделать что-то вроде new ProductService(), но для каждого бина у нас свой класс. Рефлексия в Java предоставляет нам универсальное решение (вызывается конструктор по-умолчанию):

Object instance = classObject.newInstance();//=new CustomClass()

Далее, нам нужно поместить этот бин в Map<String, Object> singletons. Для этого нужно выбрать имя бина (его id). В Java мы называем переменные подобно классам (только первая буква в нижнем регистре). Данный подход может быть применим к бинам тоже, ведь Spring — это Java-фреймворк! Преобразуйте имя бина так, чтобы первая буква была маленькая, и добавьте его в мапу:

String beanName = className.substring(0, 1).toLowerCase() + className.substring(1);
singletons.put(beanName, instance);

Теперь убедитесь в том, что всё работает. Контейнер должен создавать бины, и они должны извлекаться по имени. Обратите внимание на то, что название вашего метода instantiate() и название метода classObject.newInstance(); имеют общий корень. Более того, instantiate() — это часть жизненного цикла бина. В джаве всё взаимосвязано!

//Main.java
BeanFactory beanFactory = new BeanFactory();
beanFactory.instantiate("com.kciray");
ProductService productService = (ProductService) beanFactory.getBean("productService");
System.out.println(productService);//ProductService@612

Попробуйте также реализовать аннотацию org.springframework.beans.factory.stereotype.Service. Она выполняет абсолютно ту же функцию, что и @Component, но называется по-другому. Весь смысл заключён в названии — вы демонстриуете, что класс является сервисом, а не просто компонентом. Это что-то типа концептуальной типизации. В сертификации по спрингу был вопрос «Какие аннотации являются стереотипными? (из перечисленных)». Так вот, стереотипные аннотации — это те, которые находятся в пакете stereotype.

Наполняем свойства

Посмотрите на схему ниже, на ней представлено начало жизненного цикла бина. То, что мы делали до этого, это Instantiate (создание бинов через newInstance()). Следующий этап — это перекрестное инжектирование бинов (инъекция зависимостей, она же инверсия контроля (IoC)). Нужно пройтись по свойствам бинов и понять, какие именно свойства нужно заинжектить. Если вы сейчас вызовете productService.getPromotionsService(), то получите null, т.к. зависимость ещё не добавлена.

Для начала, создадим пакет org.springframework.beans.factory.annotation и добавим в него аннотацию @Autowired. Идея в том, чтобы помечать этой аннотацией те поля, которые являются зависимостями.

@Retention(RetentionPolicy.RUNTIME)
public @interface Autowired {
}

Далее, добавим её к свойству:

@Component
public class ProductService {
    @Autowired
    PromotionsService promotionsService;

    //...
}

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

public class BeanFactory {
    //...
    public void populateProperties(){
        System.out.println("==populateProperties==");

    }
}

Далее, нам нужно всего-лишь пройтись по всем нашим бинам в мапе singletons, и для каждого бина пройтись по всем его полям (метод object.getClass().getDeclaredFields() возвращает все поля, включая приватные). И проверить, есть ли у поля аннотация @Autowired:

for (Object object : singletons.values()) {
    for (Field field : object.getClass().getDeclaredFields()) {
        if (field.isAnnotationPresent(Autowired.class)) {

        }
    }
}

Далее, нам надо ещё разок пройтись по всем бинам и посмотреть их тип — вдруг это тот тип, который хочет себе взять наш бин. Да, у нас получается трехмерный цикл!

for (Object dependency : singletons.values()) {
    if (dependency.getClass().equals(field.getType())) {

    }
}

Далее, когда мы нашли зависимость, надо её заинжектить. Первое что вам может прийти в голову — это записать поле promotionsService с помощью рефлексии напрямую. Но спринг так не работает. Ведь если поле имеет модификатор private, то нам придется сначала установить его как public, потом записать наше значение, потом снова установить в private (чтобы сохранить целостность). Звучит как большой костыль. Давайте вместо большого костыля сделаем маленький костыль (сформируем название сеттера и вызовем его):

String setterName = "set" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);//setPromotionsService
System.out.println("Setter name = " + setterName);
Method setter = object.getClass().getMethod(setterName, dependency.getClass());
setter.invoke(object, dependency);

Теперь запустите ваш проект и убедитесь, что при вызове productService.getPromotionsService() вместо null возвращается наш бин.

То, что мы реализовали — это инъекция по типу. Есть ещё инъекция по имени (аннотация javax.annotation.Resource). Отличается она тем, что вместо типа поля будет извлекаться его имя, и по нему — зависимость из мапы. Тут всё аналогично, даже в чем-то проще. Я рекомендую вам поэкспериментировать и создать какой-нибудь свой бин, а потом заинжектить его с помощью @Resource и расширить метод populateProperties().

Поддерживаем бины, знающие о своем имени

Бывают случаи, когда внутри бина нужно получить его имя. Такая потребность возникает не часто, т.к. бины, по своей сути, не должны знать друг о друге и о том, что они бины. В первых версиях спринга предполагалось, что бин — это POJO (Plain Old Java Objec, старый добрый Джава-объект), а вся конфигурация вынесена в XML-файлы и отделена от реализации. Но мы реализуем данный функционал, так как инъекция имени — это часть жизненного цикла бина.

Как нам узнать, какой бин хочет узнать, как его зовут, а какой не хочет? Первое, что приходит в голову — это сделать новую аннотацию типа @InjectName и лепить её на поля типа String. Но это решение будет слишком общим и позволяет выстрелить себе в ногу много раз (разместить эту аннотацию на полях неподходящих типов (не String), или же пытаться инжектировать имя в несколько полей в одном классе). Есть другое решение, более аккуратное — создать специальный интерфейс с одним методом-сеттером. Все бины, что его реализуют — получает своё имя. Создайте класс BeanNameAware в пакете org.springframework.beans.factory:

public interface BeanNameAware {
    void setBeanName(String name);
}

Далее, пускай наш PromotionsService его реализует:

@Component
public class PromotionsService implements BeanNameAware {
    private String beanName;

    @Override
    public void setBeanName(String name) {
        beanName = name;
    }

    public String getBeanName() {
        return beanName;
    }
}

И, наконец, добавим новый метод в фабрику бинов. Тут всё просто — мы проходимся по нашим бинам-синглтонам, проверяем, реализует ли бин наш интерфейс, и вызываем сеттер:

public void injectBeanNames(){
    for (String name : singletons.keySet()) {
        Object bean = singletons.get(name);
        if(bean instanceof BeanNameAware){
            ((BeanNameAware) bean).setBeanName(name);
        }
    }
}

Запустите и убедиесь, что всё работает:

BeanFactory beanFactory = new BeanFactory();
beanFactory.instantiate("com.kciray");
beanFactory.populateProperties();
beanFactory.injectBeanNames();

//...

System.out.println("Bean name = " + promotionsService.getBeanName());

Надо отметить, что в спринге есть и другие подобные интерфейсы. Я рекомендую вам самостоятельно реализовать интерфейс BeanFactoryAware, который позволит бинам получать ссылку на фабрику бинов. Реализуется он аналогично.

Инициализируем бины

Представим, что у вас возникла ситуация, когда нужно выполнить некоторый код после того, как зависимости были проинжектированы (свойства бина установлены). Говоря простым языком, нам нужно предоставить бину возможность инициализировать самого себя. Как вариант, мы можем создать интерфейс InitializingBean, и в него поместить сигнатуру метода void afterPropertiesSet(). Реализация данного механизма абсолютно аналогична той, что была представлена для интерфейса BeanNameAware, поэтому решение под спойлером. Потренируйтесь и сделайте его самостоятельно за минуту:

//InitializingBean.java
package org.springframework.beans.factory;

public interface InitializingBean {
    void afterPropertiesSet();
}

//BeanFactory.java
public void initializeBeans(){
    for (Object bean : singletons.values()) {
        if(bean instanceof InitializingBean){
            ((InitializingBean) bean).afterPropertiesSet();
        }
    }
}

//Main.java
beanFactory.initializeBeans();

Добавляем пост-процессоры

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

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

Мы можем позволить оба варианта сразу. Пускай один пост-процессор несёт две логики, два метода. Один выполняется до инициализации (до метода afterPropertiesSet()), а другой — после. Теперь давайте задумаемся над самими методами — какие параметры у них должны быть? Очевидно, что там должен быть сам бин (Object bean). Для удобства, кроме бина можно передавать имя этого бина. Вы же помните, что бин сам по себе не знает о своём имени. И мы не хотим заставлять все бины реализовывать интерфейс BeanNameAware. Но, на уровне пост-процессора, имя бина может очень даже пригодиться. Поэтом удобавляем его как второй параметр.

А что должен возвращать метод при пост-обработке бина? Сделаем так, чтобы он возвращал сам бин. Это даёт нам супер-гибкость, ведь вместо бина можно подсунуть прокси-объект, который оборачивает его вызовы (и добавляет секьюрити). А можно и вовсе вернуть другой объект, пересоздав бин заново. Разработчикам даётся очень большая свобода действия. Ниже представлена окончательная версия спроектированного интерфейса:

package org.springframework.beans.factory.config;

public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object bean, String beanName);
    Object postProcessAfterInitialization(Object bean, String beanName);
}

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

//BeanFactory.java
private List<BeanPostProcessor> postProcessors = new ArrayList<>();
public void addPostProcessor(BeanPostProcessor postProcessor){
    postProcessors.add(postProcessor);
}

Теперь поменяем метод initializeBeans так, чтобы он учитывал пост-процессоры:

public void initializeBeans() {
    for (String name : singletons.keySet()) {
        Object bean = singletons.get(name);
        for (BeanPostProcessor postProcessor : postProcessors) {
            postProcessor.postProcessBeforeInitialization(bean, name);
        }
        if (bean instanceof InitializingBean) {
            ((InitializingBean) bean).afterPropertiesSet();
        }
        for (BeanPostProcessor postProcessor : postProcessors) {
            postProcessor.postProcessAfterInitialization(bean, name);
        }
    }
}

Давайте создадим небольшой пост-процессор, который просто трассирует вызовы в консоль, и добавим его в нашу фабрику бинов:

public class CustomPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("---CustomPostProcessor Before " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("---CustomPostProcessor After " + beanName);
        return bean;
    }
}

//Main.java
BeanFactory beanFactory = new BeanFactory();
beanFactory.addPostProcessor(new CustomPostProcessor());

Теперь запустите и убедитесь, что всё работает. В качестве тренировочного задания создайте пост-процессор, который будет обеспечивать работу аннотации @PostConstruct (javax.annotation.PostConstruct). Она предоставляет альтернативный способ инициализации (имеющий корни в Java, а не в спринге). Суть его в том, что вы размещаете аннотацию на некотором методе, и этот метод будет вызван ПЕРЕД стандартной спринговой инициализацией (InitializingBean).

Обязательно создавайте все аннотации и пакеты (даже javax.annotation) вручную, не подключайте зависимости! Это поможет вам увидеть разницу между ядром спринга и его расширениями (поддержка javax), и запомнить её. Это позволит придерживаться одного стиля в будущем.

Вам будет интересен тот факт, что в реальном спринге аннотация @PostConstruct именно так и реализована, через пост-процессор CommonAnnotationBeanPostProcessor. Но не подглядывайте туда, напишите свою реализацию.

На последок, я вам рекомендую добавить метод void close() в класс BeanFactory и отработать ещё два механизма. Первый — аннотация @PreDestroy (javax.annotation.PreDestroy), предназначена для методов, которые должны быть вызваны при закрытии контейнера. Второй — интерфейс org.springframework.beans.factory.DisposableBean, который содержит метод void destroy(). Все бины, исполняющие данный интерфейс, будут иметь возможность сами себя уничтожить (освободить ресурсы, например).

//DisposableBean.java
package org.springframework.beans.factory;

public interface DisposableBean {
    void destroy();
}

//PreDestroy.java
package javax.annotation;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface PreDestroy {
}

//DisposableBean.java
public void close() {
    for (Object bean : singletons.values()) {
        for (Method method : bean.getClass().getMethods()) {
            if (method.isAnnotationPresent(PreDestroy.class)) {
                try {
                    method.invoke(bean);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
        if (bean instanceof DisposableBean) {
            ((DisposableBean) bean).destroy();
        }
    }
}

Полный жизненный цикл бина

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

Наш любимый контекст

Программисты очень часто используют термин контекст, но не все понимают, что же он на самом деле значит. Сейчас мы расставим всё по-полочкам. Как я уже отметил в начале статьи, контекст — это реализация контейнера, как и BeanFactory. Но, кроме базовых функций (DI), она ещё добавляет некоторые крутые фичи. Одна из таких фич — это отправка и обработка событий между бинами.

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

public class ApplicationContext {
    private BeanFactory beanFactory = new BeanFactory();

    public ApplicationContext(String basePackage) throws ReflectiveOperationException{
        System.out.println("******Context is under construction******");

        beanFactory.instantiate(basePackage);
        beanFactory.populateProperties();
        beanFactory.injectBeanNames();
        beanFactory.initializeBeans();
    }

    public void close(){
        beanFactory.close();
    }
}

ApplicationContext applicationContext = new ApplicationContext("com.kciray");
applicationContext.close();

package org.springframework.context.event;

public class ContextClosedEvent {
} 

package org.springframework.context;

public interface ApplicationListener<E>{
    void onApplicationEvent(E event);
}

public void close(){
    beanFactory.close();
    for(Object bean : beanFactory.getSingletons().values()) {
        if (bean instanceof ApplicationListener) {

        }
    }
}

for (Type type: bean.getClass().getGenericInterfaces()){
    if(type instanceof ParameterizedType){
        ParameterizedType parameterizedType = (ParameterizedType) type;

    }
}

Type firstParameter = parameterizedType.getActualTypeArguments()[0];
if(firstParameter.equals(ContextClosedEvent.class)){
    Method method = bean.getClass().getMethod("onApplicationEvent", ContextClosedEvent.class);
    method.invoke(bean, new ContextClosedEvent());
}

@Service
public class PromotionsService implements BeanNameAware, ApplicationListener<ContextClosedEvent> {
    //...

    @Override
    public void onApplicationEvent(ContextClosedEvent event) {
        System.out.println(">> ContextClosed EVENT");
    }
}

//Main.java
void testContext() throws ReflectiveOperationException{
    ApplicationContext applicationContext = new ApplicationContext("com.kciray");
    applicationContext.close();
}

Заключение

Изначально я планировал данную статью для Baeldung на английском, но потом подумал, что аудитория хабры может положительно оценить данный подход к обучению. Если вам понравились мои идеи, обязательно поддержите статью. Если она наберёт рейтинг более 30, то обещаю продолжение. При написании статьи, я старался показать именно те знания Spring Core, которе используются наиболее часто, а также с опорой на Core Spring 5.0 Certification Study Guide. В будущем, с помощью таких туториалов можно покрыть всю сертификацию и сделать спринг более доступным для Java-разработчиков.

Update 10/05/2018

Мне постоянно приходят письма с вопросами «а когда продолжение, мы его ждём». Но вот времени совсем нету, и другие личные проекты в приоритете. Однако, если кому-то из вас действительно понравилась идея, вы можете изучить узкий раздел спринга и написать статью-продолжение. Если у вас нету аккаунта хабры, то я могу опубликовать статью от моего акка или помочь вам получить инвайт.

Распределение тем:
Spring Container — [имя пользователя]
Spring AOP — [имя пользователя]
Spring Web — [имя пользователя]
Spring Cloud — [имя пользователя]

Тема для следующей статьи

Проголосовали 219 пользователей.

Воздержались 28 пользователей.