|
| 1 | +package ru.otus.main_patterns.hw05.commands; |
| 2 | + |
| 3 | +import java.util.HashMap; |
| 4 | +import java.util.Map; |
| 5 | +import java.util.concurrent.ConcurrentHashMap; |
| 6 | +import java.util.concurrent.atomic.AtomicBoolean; |
| 7 | +import java.util.function.BiFunction; |
| 8 | +import java.util.function.Function; |
| 9 | +import org.slf4j.Logger; |
| 10 | +import org.slf4j.LoggerFactory; |
| 11 | +import ru.otus.main_patterns.hw05.core.IoC; |
| 12 | +import ru.otus.main_patterns.hw05.interfaces.Command; |
| 13 | +import ru.otus.main_patterns.hw05.interfaces.DependencyResolver; |
| 14 | +import ru.otus.main_patterns.hw05.scopes.DependencyResolverImpl; |
| 15 | + |
| 16 | +/** |
| 17 | + * <a |
| 18 | + * href="https://github.com/etyumentcev/appserver/blob/main/appserver/scopes/InitCommand.cs">Example</a> |
| 19 | + * |
| 20 | + * <p>Scope(context) - это разные области видимости. |
| 21 | + * |
| 22 | + * <p>ThreadLocal — это специальный класс в Java, который позволяет создавать переменные, доступные |
| 23 | + * только для одного конкретного потока. Если обычная статическая переменная видна всем потокам |
| 24 | + * одинаково, то в случае с ThreadLocal у каждого потока будет своя собственная, изолированная копия |
| 25 | + * этой переменной. Изменение значения в одном потоке никак не повлияет на значение в другом. |
| 26 | + * |
| 27 | + * <p>ThreadLocal - это карта, где в качестве ключа выступает идентификатор текущего потока(Thread). |
| 28 | + * Можно по текущему потоку хранить какой-то тип данных. |
| 29 | + * |
| 30 | + * <p>В результате в каждый поток можно положить собственный scope(context). В итоге, когда мы будем |
| 31 | + * обращаться к этой стратегии(через метод IoC.resolve()), то мы сначала идем в ThreadLocal, смотрим |
| 32 | + * в текущем потоке какой текущий контекст(scope) и уже работаем с ним. В итоге получается, что в |
| 33 | + * каждом потоке могут быть как одинаковые, так и разные контексты. Т.е. Получаем, что благодаря |
| 34 | + * ThreadLocal, в одном потоке один контекст, а в другом потоке другой контекст. Т.е. Когда мы |
| 35 | + * выполняем метод IoC.resolve(), первое, что происходит - это мы пойдем в ThreadLocal и получим |
| 36 | + * текущий контекст. В каком бы потоке мы не вызывали мы всегда получим ссылку на тот контекст, |
| 37 | + * который актуален для этого потока. Таким образом мы получаем потокобезопасные реализации. |
| 38 | + * Стратегию проще всего представлять в виде лямбды функции - Function <Object[], Object>. |
| 39 | + * |
| 40 | + * <p>Инициализация многопоточного контейнера. Выполняется только один раз. Эта команда |
| 41 | + * инициализирует IoC контейнер для работы с несколькими потоками. Scope = Map<String, |
| 42 | + * Function<Object[], Object>> |
| 43 | + * |
| 44 | + * <p>При переопределении стратегии (через {@code "update.ioc.resolve.dependency.strategy"}) |
| 45 | + * ожидается лямбда-функция типа: |
| 46 | + * |
| 47 | + * <pre>{@code |
| 48 | + * Function<BiFunction<String, Object[], Object>, BiFunction<String, Object[], Object>> |
| 49 | + * }</pre> |
| 50 | + */ |
| 51 | +public class InitCommand implements Command { |
| 52 | + public static final ThreadLocal<Object> currentScopeThreadLocal = |
| 53 | + ThreadLocal.withInitial(() -> null); |
| 54 | + // key = dependency name, value = strategy as lambda Function<Object[], Object> |
| 55 | + private static final ConcurrentHashMap<String, Function<Object[], Object>> scopesMap = |
| 56 | + new ConcurrentHashMap<>(); |
| 57 | + private static final AtomicBoolean isAlreadyExecutesSuccessfully = new AtomicBoolean(false); |
| 58 | + |
| 59 | + private static final Logger logger = LoggerFactory.getLogger(InitCommand.class); |
| 60 | + |
| 61 | + /** - Выполняется один раз. */ |
| 62 | + @Override |
| 63 | + public void execute() { |
| 64 | + logger.info("execute, isAlreadyExecutesSuccessfully: {}", isAlreadyExecutesSuccessfully); |
| 65 | + if (isAlreadyExecutesSuccessfully.get()) { |
| 66 | + return; |
| 67 | + } |
| 68 | + |
| 69 | + // Root scope - главный контекст, в который мы складываем разные зависимости |
| 70 | + synchronized (scopesMap) { |
| 71 | + /*- |
| 72 | + SetCurrentScopeCommand - команда установит, в этом потоке, текущий контекст(смена контекста), |
| 73 | + который будет передан в качестве аргумента(args[0]). |
| 74 | + E.g. change scope: |
| 75 | + IoC.resolve<Command>("ioc.scope.current.set", otherScope).execute() |
| 76 | + */ |
| 77 | + scopesMap.putIfAbsent( |
| 78 | + "ioc.scope.current.set", (Object[] args) -> new SetCurrentScopeCommand(args[0])); |
| 79 | + scopesMap.putIfAbsent( |
| 80 | + "ioc.scope.current.clear", (Object[] args) -> new ClearCurrentScopeCommand()); |
| 81 | + |
| 82 | + /*- |
| 83 | + "ioc.scope.current" - возвращает текущий scope, который есть в текущем потоке. |
| 84 | + currentScopeThreadLocal.get() - возвращает значение из текущего потока. |
| 85 | + */ |
| 86 | + scopesMap.putIfAbsent( |
| 87 | + "ioc.scope.current", |
| 88 | + (Object[] args) -> |
| 89 | + currentScopeThreadLocal.get() != null ? currentScopeThreadLocal.get() : scopesMap); |
| 90 | + /*- |
| 91 | + У контекста можно прочитать родительский контекст. Все контексты упорядочены иерархически. |
| 92 | + "ioc.scope.parent" - возвращает ссылку на родительский контекст. |
| 93 | + */ |
| 94 | + scopesMap.putIfAbsent( |
| 95 | + "ioc.scope.parent", |
| 96 | + (Object[] args) -> { |
| 97 | + throw new RuntimeException("The root scope has no a parent scope."); |
| 98 | + }); |
| 99 | + scopesMap.putIfAbsent( |
| 100 | + "ioc.scope.create.empty", |
| 101 | + (Object[] args) -> new HashMap<String, Function<Object[], Object>>()); |
| 102 | + scopesMap.putIfAbsent( |
| 103 | + "ioc.scope.create", |
| 104 | + (Object[] args) -> { |
| 105 | + Map<String, Function<Object[], Object>> scopeMap = |
| 106 | + IoC.resolve("ioc.scope.create.empty"); |
| 107 | + if (args.length > 0) { |
| 108 | + scopeMap.put("ioc.scope.parent", (Object[] innerArgs) -> args[0]); |
| 109 | + } else { |
| 110 | + scopeMap.put( |
| 111 | + "ioc.scope.parent", (Object[] innerArgs) -> IoC.resolve("ioc.scope.current")); |
| 112 | + } |
| 113 | + return scopeMap; |
| 114 | + }); |
| 115 | + |
| 116 | + /*- |
| 117 | + При регистрации зависимости мы создаем команду RegisterDependencyCommand и передаем ей |
| 118 | + нужные параметры. |
| 119 | + Регистрация новой стратегии разрешения(resolve) зависимости в нашем контейнере. |
| 120 | + Когда мы регистрируем зависимость, то мы создаем команду RegisterDependencyCommand. |
| 121 | + RegisterDependencyCommand - команда, которая будет регистрировать зависимость. |
| 122 | + Param#1 - имя зависимости |
| 123 | + Param#2 - лямбда функция(Function <Object[], Object>), которая будет вызываться |
| 124 | + Usage: |
| 125 | + IoC.<Command>resolve("ioc.register", "A", (Object[] args -> new A()}).execute() |
| 126 | + , где |
| 127 | + - "ioc.register" - имя разрешаемой зависимости |
| 128 | + На вход подается два параметра: |
| 129 | + - "A" - имя зависимости |
| 130 | + - (Object[] args) -> { return new A();} - стратегия(лямбда функция - Function <Object[], Object>) |
| 131 | + с помощью которой будет разрешена эта зависимость. |
| 132 | + Стратегия принимает на вход параметры args(Object[]) и возвращает что-то(Object). |
| 133 | + В примере стратегия возвращает экземпляр класса A. |
| 134 | + Т.е. Когда просят вернуть экземпляр класса A, то будет вызвана стратегия(лямбда функция) и |
| 135 | + результат работы этой лямбда функции вернется на выходе. В примере это Command, которую мы |
| 136 | + выполняем(execute) для регистрации стратегии внутри фабрики. |
| 137 | +
|
| 138 | + В случае Spring-а, "A" - это имя bean-а в Spring контейнере. |
| 139 | +
|
| 140 | + Т.е. Вместо |
| 141 | + SomeInterface user = new User(); |
| 142 | + Function<Object[], Object> dependencyResolveStrategy = args -> new User(); |
| 143 | + IoC.register("A", dependencyResolveStrategy) |
| 144 | +
|
| 145 | + мы пишем |
| 146 | + IoC.<Command>resolve("ioc.register", "A", dependencyResolveStrategy).execute() |
| 147 | +
|
| 148 | + Второй подход более универсальный, т.к. При появлении новой команды (например IoC.freeze) мы не будем менять существующий клиентский код. |
| 149 | + Usage: |
| 150 | + SomeInterface a = IoC.<SomeInterface>resolve("A"); |
| 151 | + */ |
| 152 | + scopesMap.putIfAbsent( |
| 153 | + "ioc.register", |
| 154 | + (Object[] args) -> { // регистрация стратегии(strategy) внутри фабрики |
| 155 | + String dependencyName = (String) args[0]; |
| 156 | + Function<Object[], Object> strategy = (Function<Object[], Object>) args[1]; |
| 157 | + /*- |
| 158 | + Таким образом, метод IoC.resolve() полностью заменяет создание объекта через "new", решая главную задачу: |
| 159 | + клиентский код не меняется при изменении правил создания объектов. |
| 160 | + Ключевое слово "new" будет использоваться только при регистрации зависимости, что |
| 161 | + позволяет соблюдать принцип открытости/замкнутости (Open-Closed Principle). |
| 162 | + */ |
| 163 | + return new RegisterDependencyCommand(dependencyName, strategy); |
| 164 | + }); |
| 165 | + |
| 166 | + /*- |
| 167 | + Основная стратегия. |
| 168 | + Стратегия, которая разрешает(resolve) зависимость в виде лямбды функции - |
| 169 | + BiFunction<String, Object[], Object>. |
| 170 | + Когда нас просят разрешить зависимость, то мы в текущем потоке "currentScopeThreadLocal" |
| 171 | + получаем установленный scope - currentScopeThreadLocal.get(). |
| 172 | + Если scope есть, то возвращаем его. Если не установлен, то возвращаем rootScope. |
| 173 | + DependencyResolverImpl - специальная конструкция с помощью которой мы находим нужную |
| 174 | + зависимость и вызываем ее(strategyResolver). |
| 175 | + */ |
| 176 | + BiFunction<String, Object[], DependencyResolver> strategyResolver = |
| 177 | + new BiFunction<String, Object[], DependencyResolver>() { |
| 178 | + @Override |
| 179 | + public DependencyResolver apply(String dependency, Object[] args) { |
| 180 | + // 1. Находим scope |
| 181 | + Object findScope = |
| 182 | + currentScopeThreadLocal.get() != null ? currentScopeThreadLocal.get() : scopesMap; |
| 183 | + // 2. Находим нужную зависимость и вызываем ее. |
| 184 | + DependencyResolver dependencyResolver = new DependencyResolverImpl(findScope); |
| 185 | + return (DependencyResolver) dependencyResolver.resolve(dependency, args); |
| 186 | + } |
| 187 | + }; |
| 188 | + |
| 189 | + /*- |
| 190 | + Вызываем зависимость "update.ioc.resolve.dependency.strategy" для того, чтобы заменить на стратегию. |
| 191 | + param1 = имя зависимости "update.ioc.resolve.dependency.strategy" (same as Spring Bean name) |
| 192 | + param2 = стратегия с помощью которой будет разрешена(resolve) эта зависимость. |
| 193 | + Вызываем данную зависимость для того, чтобы заменить ее на стратегию. |
| 194 | + */ |
| 195 | + Command command = IoC.resolve("update.ioc.resolve.dependency.strategy", strategyResolver); |
| 196 | + command.execute(); |
| 197 | + |
| 198 | + isAlreadyExecutesSuccessfully.set(true); |
| 199 | + } |
| 200 | + } |
| 201 | +} |
0 commit comments