New Score :0
High Score :0
Run Best
NICE BUSINESS TYPE INDICATOR
3. ๊ธ์ ์ ์น๊ตฌ์๊ฒ ๋น๋ ธ๋๋ฐ ์ค๋์ด ๋์ ์ฃผ๊ธฐ๋ก ํ๋ .. ๊ทธ๋ฐ๋ฐ ์นด๋๊ฐ์ ๋ด์ผํ๋ ๋ ๋ ์ค๋์ธ๋ฐ... ์ด๊ฑธ ์ด์ฉ๋...
4. ์ฐ๋ฆฌ ํ์ฌ๋ ์ค์ํ ์์ฌ ๊ฒฐ์ ์ ํ ๋?
5. ์ด์ฌํ ์ผํ ๋๋ฅผ ์ํ ์ ๋ฌผ์ ์ฃผ๊ณ ์ถ๋ค. ์ด๋ค๊ฒ ์ข์๊น?
6. ์ํ์์ ํฌ์์ํ์ ์ถ์ฒ๋ฐ์๋ค. ์ด๋ค๊ฑธ ๊ฐ์ ํ์ง?
7. ํ์ฌ์์์ ๋๋?
8. ๊ฟ์์ ๊นจ์ด๋๋ 20๋ ์ ์ผ๋ก ๋์๊ฐ๋ค. ๋น์ ์ด ์ ์ผ ๋จผ์ ํ๋์ผ์?
9. ๋ด๊ฐ ์ธ์ฌ ๋ด๋น์๋ผ๋ฉด ์ ๊ท ์ ์ฌ์ ์ฑ์ฉ ์ ์ ์ผ ์ค์ํ๊ฒ ๋ณด๋๊ฒ์?
10. ํ์ฌ์ ์ ๋ง ์ซ์ดํ๋ ๋๋ฃ๊ฐ ์๋ค๋ฉด?
11. ๊ฐ๋ํ ์ง์ ๊ฐ์ฅ์ด ๋์๋ค.. ์๋ ์ ์์ผ ๋ ์ ๋ฌผ์?
12. ํ์ ํ์ฌ ์ถ๊ทผ ์คํ์ผ์?
13.ํ์ฌ ์ฒด์ก๋ํ ํ๋ ๋ ์ด๋ค. ์ค๋ ๋ญํ์ง?
14. ๋์ ์ ๋ฌด ์คํ์ผ์?
Given problem
โCommandBus ํจํด์ ๋ฌธ์ ๋ CQRS ์ํคํ ์ฒ ํจํด์ ์์ ๋ฌธ์ ์ ๋๋ค. ์๋์ ์ ์ผํ ์ง๋ฌธ์ ํญ์ ์ฐ๋ฆฌ ๋จธ๋ฆฌ ์์ ์กด์ฌํฉ๋๋ค : ์ฐ๋ฆฌ ์์คํ ์์ ๋ช ๋ น๊ณผ ์ฟผ๋ฆฌ๋ฅผ ๋ถ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ ๋๊น?โ
โ์ฐ๋ฆฌ ์์คํ ์ด ๋ ๋ณต์ก ํด์ง๋ฉด ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ ์ผ๋ฐ์ ์ผ๋ก ํด๊ฒฐํด์ผ ํ ๋ดํ๋ฅ์ด๊ธฐ ๋๋ฌธ์ ๋๋ค. ์ ๊ธ ๋ฉ์ปค๋์ฆ์ ๋์์ฑ ์ก์ธ์ค์ ์ผ๋ถ ๋ฌธ์ ๋ฅผ ๋ฐฉ์งํ๋ ๋ฐ ๋์์ด๋๊ธฐ ๋๋ฌธ์ ๋๋ค. ๊ทธ๋ฌ๋ ๊ทธ๊ฒ์ ๋ํ ์ฑ๋ฅ์ ๊ดํ ๋ ๋ค๋ฅธ ๋ฌธ์ ๋ฅผ ๋ง๋ญ๋๋ค.โ
โ๊ทธ๋ฐ ๋ค์ ๋ช ๋ น ๋ฐ ์ฟผ๋ฆฌ ๊ฐ๋ ์ CQRS ์ํคํ ์ฒ ํจํด์ ๋ ๊ฐ์ง๋ก ๋ถ๋ฆฌํ์ฌ ์ฑ๋ฅ์ ํฌ๊ฒ ํฅ์์ํต๋๋ค.โ
โ๊ทธ๋ ๋ค๋ฉด ๋ช ๋ น ๋ฒ์ค ํจํด์ ์ด๋ป๊ฒ ๊ตฌํํฉ๋๊น?โ
Solution with Command Bus pattern
โ๋ค์์ ๋ช ๋ น ๋ฒ์ค ํจํด์ ๋ํ ๋ค์ด์ด๊ทธ๋จ์ ๋๋ค.โ

โ์ด ํจํด์๋ ์ธ ๊ฐ์ง ํด๋์ค๊ฐ ์ฌ์ฉ๋ฉ๋๋ค.โ
Command class
โ๋ช ๋ น ํด๋์ค๋ ์์ ์ ์คํํ๋ ๋ฐ ํ์ํ ๋ฐ์ดํฐ๊ฐ ํฌํจ ๋ ํด๋์ค ์ผ๋ฟ์ ๋๋ค. ๋ฐ์ดํฐ ์ ์ก ๊ฐ์ฒด ํจํด๊ณผ ๊ฐ์ต๋๋ค.โ
โ๋ช ๋ น๊ณผ ๋ช ๋ น ์ฒ๋ฆฌ๊ธฐ ๊ฐ์ ๊ด๊ณ๋ ์ผ๋์ผ์ ๋๋ค. ์ฆ, ํ๋์ ๋ช ๋ น์ ํ๋์ CommandHandler์ ์ํด์๋ง ์ฒ๋ฆฌ๋ฉ๋๋ค.โ
โCommand ํด๋์ค์์ ๋ฐ์ดํฐ์ ๋ํ ๊ฐ๋จํ ์ ํจ์ฑ ๊ฒ์ฌ๋ฅผ ์ํ ํ ์ ์์ผ๋ฉฐ Command ๊ฐ์ฒด๋ ๋ณ๊ฒฝํ ์์๋ ๊ฐ์ฒด์ ๋๋ค.โ
CommandHandler class
โCommandHandler์ ์ฑ ์์ ํน์ Command ๊ฐ์ฒด๋ฅผ ์ ๋ ฅ์ผ๋ก ์ฌ์ฉํ ๋ ์ ์ ํ ๋๋ฉ์ธ ๋์์ ์คํํ๋ ๊ฒ์ ๋๋ค. CommandHandler๋ ๋๋ฉ์ธ ๋ ผ๋ฆฌ ์์ฒด๋ฅผ ์ํํด์๋ ์๋ฉ๋๋ค. ์ด ์ด์์ ์์ ์ ์ํํด์ผ ํ๋ ๊ฒฝ์ฐ ํด๋น ๋ ผ๋ฆฌ๋ฅผ ๋ํํ๋ ์๋น์ค๋ฅผ ์ ์ํด์ผ ํฉ๋๋ค.โ
โ๋๋ฉ์ธ ๋์์ AggregateRoot์์ ์คํ๋์ด์ผ ํฉ๋๋ค. ๋ฐ๋ผ์ CommandHandler ํด๋์ค๋ ์ ์ฅ์๋ฅผ ์ฌ์ฉํ์ฌ AggregateRoot๋ฅผ๋ก๋ํ๊ณ ํด๋น ๋ฐ์ดํฐ๋ฅผ AggregateRoot์ ์ ๋ฌํฉ๋๋ค.โ
CommandBus class
โCommand ๊ฐ์ฒด๋ฅผ ๋ฐ์ ํ CommandBus๋ ์ ์ ํ CommandHandler๋ก ๋ผ์ฐํ ํฉ๋๋ค.โ
โCommandBus ํด๋์ค์ ๊ธฐ๋ฅ์ ํ์ฅํ๋ ค๋ฉด ๋ฐ์ฝ๋ ์ดํฐ ํจํด ๋๋ ํ๋ก์ ํจํด์ ํจ๊ป ์ฌ์ฉํ ์ ์์ต๋๋ค. ๋ฐ์ฝ๋ ์ดํฐ ํจํด์ ๊ฒฝ์ฐ CommandBus์ ํ์ฅ์ ๋ํ ๋ช ๊ฐ์ง ์ํ์ด ์์ต๋๋ค.โ
- โ๋ฐ์ดํฐ๋ฒ ์ด์ค ํธ๋์ญ์ ์์ CommandBus๋ฅผ ๋ํํฉ๋๋ค.โ
- โ๋ก๊น ์ผ๋ก CommandBus๋ฅผ ๋ํํ์ฌ CommandHandler์ ์๊ฐ์ ์ธก์ ํฉ๋๋ค.โ
โํ๋ก์ ํจํด์ ์ฌ์ฉํ๋ฉด ๋ช ๋ น์ ์ฒ๋ฆฌํ๊ธฐ ์ ์ ๊ถํ์ ํ์ธํ๊ธฐ ์ํด CommandBus๋ฅผ ๋ํํฉ๋๋ค.โ
Source code
โ์ผ๋ฐ์ ์ผ๋ก CommandBus์์ HashMap์ ์ฌ์ฉํ์ฌ Command ์ CommandHandler ๊ฐ์ ์ฐ๊ฒฐ์ ์ฒ๋ฆฌ ํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ฐ๋ฆฌ์ ๊ฒฝ์ฐ Guice์ DI ์์น ๋๋ IoC ์ปจํ ์ด๋๋ฅผ ํ์ฉํ์ฌ Command ๋ฐ CommandHandler๋ฅผ ๋งคํํฉ๋๋ค.โ
โ๋ค์์ ๋ช ๋ น ๋ฒ์ค ํจํด์์ ๊ตฌํํด์ผํ๋ ๋จ๊ณ์ ๋๋ค.โ
โ์ผ๋ฐ ์ธํฐํ์ด์ค โโICommand์โโ ํด๋น ๊ตฌํ์ ๋ง๋ญ๋๋ค.โ
public interface ICommand<R> {
// nothing to do
}
@Getter
@AllArgsConstructor
@NoArgsConstructor
public class WithdrawMoneyCommand implements ICommand<Void> {
private String username;
private String amount;
private String account;
}
โ์ผ๋ฐ ์ธํฐํ์ด์ค โโICommandHandlerโโ ๋ฐ ํด๋น ๊ตฌํ์ ๋ง๋ญ๋๋ค.โ
public interface ICommandHandler<C, R> {
R handle(C command);
}
public class WithdrawCommandHandler implements ICommandHandler<WithdrawCommand, Void> {
@Override
public Void handle(WithdrawCommand command) {
System.out.println(WithdrawCommandHandler.class.getName() + " handled.");
return null;
}
}
โGuiceโโ์์ ๊ตฌ์ฒด์ ์ธ ๋ชจ๋์ ์ ์ํ์ฌ Command ๋ฐ โโCommandHandlerโโ ํด๋์ค๋ฅผ ๊ฒฐํฉ โโ ํ์ญ์์ค.โ
โICommandHandlerโ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ๋ช ๋ น ์ฒ๋ฆฌ๊ธฐ๊ฐ ์ฌ๋ฌ ๊ฐ ์๊ธฐ ๋๋ฌธ์ โโMultibinderโ โ๋ฅผ ์ฌ์ฉํ์ฌ ๋์ผํ โโICommandHandlerโ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ํด๋์ค๋ฅผ ์๋ฝํฉ๋๋ค.โ
public class CommandHandlerModule extends AbstractModule {
@Override
protected void configure() {
Multibinder<ICommandHandler> commandHandlerBinder = Multibinder.newSetBinder(binder(), ICommandHandler.class);
commandHandlerBinder.addBinding().to(RegisterCommandHandler.class);
// define the other derived class of ICommandHandler interface
}
}
public class MainModule extends AbstractModule {
@Override
protected void configure() {
this.install(new CommandHandlerModule());
this.bind(ICommandBus.class).to(CommandBusImpl.class);
}
}
โICommandBusโโ ์ธํฐํ์ด์ค ๋ฐ ๊ตฌํ ๋ง๋ค๊ธฐโ.โ
public class CommandBusImpl implements ICommandBus {
private Set<ICommandHandler> commandHandlers;
@Inject
public CommandBusImpl(Set<ICommandHandler> commandHandlers) {
this.commandHandlers = commandHandlers;
}
@Override
public <C> void execute(C command) {
return (ICommandHandler<C, Void>) findCommandHandler(command);
}
@Override
public <C extends ICommand<R>, R> R execute(C command) {
return (ICommandHandler<C, R>) findCommandHandler(command);
}
private <C> ICommandHandler<C, ?> findCommandHandler(C command) {
Class<?> commandClazz = command.getClass();
return this.commandHandlers.stream()
.filter(handler -> this.canHandleCommand(handler.getClass(), commandClazz))
.findFirst()
.orElseThrow(() -> new RuntimeException("Do not handle " + commandClazz.getName()));
}
/**
* check the parameters's type that is corresponding to the type of Command class
*
*/
private boolean canHandleCommand(Class<?> handlerClazz, Class<?> commandClazz) {
Type[] genericInterfaces = handlerClazz.getGenericInterfaces();
ParameterizedType handlerIntefaceType = null;
for (Type type : genericInterfaces) {
if (type instanceof ParameterizedType) {
handlerIntefaceType = (ParameterizedType) type;
break;
}
}
Class<?> acceptableParameterClass = (Class<?>) handlerIntefaceType.getActualTypeArguments()[0];
return acceptableParameterClass.equals(commandClazz);
}
}
โCommandBusImplโโ ํด๋์ค์ ์ ์ :โ
public interface ICommandBus {
<C> void execute(C command);
<C extends ICommand<R>, R> R execute(C command);
}
โ๊ทธ๋์, ์ฐ๋ฆฌ๋ ๊ฐ์ง๊ณ ์์ต๋๋ค :โ
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.manhpd.bus.ICommandBus;
import com.manhpd.command.WithdrawCommand;
public class Application {
public static void main(String[] args) {
Injector injectorHandler = Guice.createInjector(new MainModule());
ICommandBus commandBus = injectorHandler.getInstance(ICommandBus.class);
WithdrawCommand command = new WithdrawCommand("John", "100000", "john");
commandBus.execute(command);
}
}
Benefits and Drawbacks
- โํํโ
- โ์ด ํจํด์ ๋๋ฉ์ธ ๊ธฐ๋ฐ ๋์์ธ ํจํด์ ์ ํฉํฉ๋๋ค. ํด๋ผ์ด์ธํธ๊ฐ ๋ช
๋ น์ ์ ์ํ์ฌ ์ํํ ์ ์๋ ์์
์๋ง ์ด์ ์ ๋ง์ถฅ๋๋ค. ๋ฐ๋ผ์ ์ฐ๋ฆฌ์ ๋น์ฆ๋์ค ๋
ผ๋ฆฌ๋ ๋ค๋ฅธ ๊ณ์ธต์์ ๋์ถ๋์ง ์์ต๋๋ค.โ
์ฌ์ฉ์์ ๊ฐ๋ฐ์ ๊ฐ์ ์์ฌ ์ํต์ ์ ๋ง ์ํํฉ๋๋ค. ์๋ํ๋ฉด ๊ทธ๋ค์ ๋ค๋ฅธ ์ฌ๋๋ค์ด ๋งํ๋ ๊ฒ์ ์ฝ๊ฒ ์ดํดํ ์ ์๊ธฐ ๋๋ฌธ์ ๋๋ค.โ - โ๋ค๋ฅธ ํจํด์ ํ์ฉํ๋ฉด CommandBus์ ๋์์ ํ์ฅ ํ ์ ์์ต๋๋ค.โ
- โCommandBus ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ฉด ๋น๋๊ธฐ ๋ฐฉ์์ผ๋ก Command ๊ฐ์ฒด๋ฅผ ์ฒ๋ฆฌ ํ ์ ์์ต๋๋ค.
๋น๋๊ธฐ ๋ฐฉ์์ ์ฌ์ฉํ๋ฉด ๋ค์์ ํฅ์์ํฌ ์ ์์ต๋๋ค.โโ- โ๋ฉํฐ ์ค๋ ๋๋ฅผ ์ฌ์ฉํ์ฌ ์ฒ๋ฆฌ ํ ์ ์๊ธฐ ๋๋ฌธ์ ์์คํ ์ ์ฑ๋ฅ.โ
- โUX๋ ์ฌ์ฉ์์ ๋ํ ์๋ต์ด ๋น ๋ฅด๊ธฐ ๋๋ฌธ์ ๋๋ค.โ
- โ์ด ํจํด์ ๋๋ฉ์ธ ๊ธฐ๋ฐ ๋์์ธ ํจํด์ ์ ํฉํฉ๋๋ค. ํด๋ผ์ด์ธํธ๊ฐ ๋ช
๋ น์ ์ ์ํ์ฌ ์ํํ ์ ์๋ ์์
์๋ง ์ด์ ์ ๋ง์ถฅ๋๋ค. ๋ฐ๋ผ์ ์ฐ๋ฆฌ์ ๋น์ฆ๋์ค ๋
ผ๋ฆฌ๋ ๋ค๋ฅธ ๊ณ์ธต์์ ๋์ถ๋์ง ์์ต๋๋ค.โ
- โ๋จ์ โ
- โCommandHandler ์ฝ๋ฉ์ ๋ํด์ฃผ์ ๊น๊ฒ ์๊ฐํ์ง ์์ผ๋ฉด SRP๋ฅผ ์ค์ํ์ง ์๋ CommandHandlers๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค.โ
- โ์ผ๋ฐ์ ์ผ๋ก ๋ฆฌํ๋ ์ ์ ์ฌ์ฉํ์ฌ Command ์ CommandHandler ์ฌ์ด๋ฅผ ๋งคํํฉ๋๋ค. ๋ฐ๋ผ์ ๋ฐํ์์ ์์คํ ์ ์ฑ๋ฅ์๋ ์ํฅ์ ์ค ์ ์์ต๋๋ค.โ
Some problems with Command Bus pattern
- โ๋๋ก๋ CommandHandler ํด๋์ค์์ ์ฌ๋ฌ ์์
์ ์ ์ํ์ง๋ง ๊ธฐ๋ณธ ์์
์ ์ด์ ์ ๋ง์ถ์ง ์๋ ๊ฒฝ์ฐ๊ฐ ์์ต๋๋ค.
โ์๋ฅผ ๋ค์ด, ์ฐ๋ฆฌ๊ฐ ์น ์ฌ์ดํธ์ ๋ก๊ทธ์ธํ๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ์ด ๋ช ๋ น์ ๊ธฐ๋ณธ ๋์์ ์ฌ์ฉ์ ์ด๋ฆ-์ํธ๋ฅผ ํฌํจํ๋ ์ ๋ณด์ ์ ํจ์ฑ์ ๊ฒ์ฌํ๊ณ ์ด ํ์ฌ ์ฌ์ฉ์์ ์ด ์ธ์ ์ ์ ์ฅํ๋ ๊ฒ์ ๋๋ค. ๋ํ ํ์ฌ ์ฌ์ฉ์์ ๋ํด ์ด๋ฉ์ผ์ ์ฌ์ฉํ์ฌ ํ์ฌ ๊ณ์ ์ ์ฌ์ฉํ๋ ์ฌ๋์ด ์๋ค๋ ๊ฒ์ ์ ํ์๊ฐ ์์ต๋๋ค.โ
๋ฐ๋ผ์ ๋ ๋ฒ์งธ ์์ ์ ํ์ฌ ์ฌ์ฉ์์๊ฒ ์ ์ ๋ฉ์ผ์ ๋ณด๋ด๋ ๊ฒ์ ๋๋ค.โโ
โCommandHandler์์ ์ฌ๋ฌ ๋ณด์กฐ ์์ ์ ๊ตฌํํ๋ ๊ฒฝ์ฐ. ๊ทธ๊ฒ์ ์ฐ๋ฆฌ์ CommandHandler ํด๋์ค๋ฅผ ์ค์ผ์ํค๊ณ ๋จ์ผ ์ฑ ์ ์์น์ ์ถฉ์กฑ์ํค์ง ๋ชปํฉ๋๋ค.โ
์ด ๊ฒฝ์ฐ์ ๋ํ ์ฐ๋ฆฌ์ ํด๊ฒฐ์ฑ ์ ๊ฐ ๋ณด์กฐ ์์ ์ ๋ํ ๊ธ๋ก๋ฒ ์ด๋ฒคํธ๋ฅผ ์ ์ํ๋ ๊ฒ์ ๋๋ค. ์ด๋ฒคํธ ๋ฒ์ค ํจํด์ ์ฌ์ฉํ๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.โ
๋ํ ๊ธ๋ก๋ฒ ์ด๋ฒคํธ์ ๋๋ฉ์ธ ์ด๋ฒคํธ์ ์ฐจ์ด์ ์ ์ธ์ํด์ผํฉ๋๋ค.โ- ์ธ๋ถ ํ๋์ผ๋ก ์ฐ๋ฆฌ๋ ๊ธ๋ก๋ฒ ์ด๋ฒคํธ๋ฅผ ์ฌ์ฉํด์ผํฉ๋๋ค.โ
- ๋๋ฉ์ธ ๋์์ผ๋ก ๋๋ฉ์ธ ์ด๋ฒคํธ๋ฅผ ๋ฐ์์์ผ์ผํฉ๋๋ค.โ
The relationship with other patterns
- โ๋ช
๋ น ํจํด ๋ฐ ๋ช
๋ น ๋ฒ์ค ํจํดโ
- โ๋ช ๋ น ํจํด์ ๋ช ๋ น ๋ฒ์ค ํจํด๊ณผ ๊ด๋ จ์ด ์์ต๋๋ค.โ
- โ๋ช ๋ น ํจํด์ ํธ์ถ์์ ์์ ์ ๊ฐ์ ๋์ปคํ๋ง๋๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ณ , Command ๊ฐ์ฒด๋ ๋ฉ์๋๋ฅผ ์ ์ํ์ฌ ์์ ์ ์ํํ๋ ์ค์ ๊ฐ์ฒด๋ฅผ ์จ๊น๋๋ค.โ
- โ๋ช
๋ น ๋ฒ์ค ํจํด์ ์ฌ์ฉ ์ฌ๋ก์ ์ ์ธ๊ณผ ํด๋น ๊ตฌํ์ ๋ถ๋ฆฌํ๋ ๋ฐ ์ฌ์ฉ๋๋ฉฐ Command ๊ฐ์ฒด๋ ์์
์ ์คํํ๊ธฐ ์ํ ๋ฐ์ดํฐ๋ฅผ ํฌํจํ๋ ๋ฉ์์ง์ผ ๋ฟ์
๋๋ค.
๊ทธ๋ฆฌ๊ณ CommandHandler๋ ๋น์ฆ๋์ค ๋ก์ง์ ๊ตฌํํ๋ ํด๋์ค์ ๋๋ค.โ
๋ฐ๋ผ์ ์ค์ ๋ก Command ๊ฐ์ฒด๋ CommandHandler์ ์ ๋ฌ ๋ ๋ฉ์์ง ์ผ๋ฟ์ ๋๋ค.โ
- โ๋ช
๋ น ๋ฒ์ค ํจํด ๋ฐ ๋ฉ์์ง ๋ฒ์ค ํจํดโ
- โ๋ช ๋ น ๋ฒ์ค ํจํด์ ๋ฉ์์ง ๋ฒ์ค ํจํด์ ํน์ ํจํด์ ๋๋ค. ๋ฉ์์ง ๋๋ ๋ช ๋ น ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ฉด ํญ์ ์ฒ๋ฆฌ๊ธฐ ๋๋ ๋์์ ์๊ณ ์๊ธฐ ๋๋ฌธ์ ๋๋ค.โ
Wrapping up
- โ์์ฆ์๋ CommandBus ํจํด์ ๊ตฌํํ๊ธฐ ์ํด ์ผ๋ฐ์ ์ผ๋ก ๋ฆฌํ๋ ์ ๊ณผ ์ฃผ์์ ์ฌ์ฉํ์ฌ DI ํจํด์ ์ฌ์ฉํ์ฌ DI ํจํด์ ์ฌ์ฉํฉ๋๋ค.โ
- โCommandBus ํจํด์ ๋ ๋ค๋ฅธ ๊ตฌํ์ ์คํ๋ง ์ปจํ ์ด๋, Guice, CDI์ ๊ฐ์ DI ํ๋ ์ ์ํฌ๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋ชจ๋ ๋ช ๋ น์ ์ ์ํฉ๋๋ค. ๋ฐ๋ผ์ ๋ฐํ์์ ๋ชจ๋ ๊ฒ์๋ก๋ ํ ๊ฒ์ ๋๋ค.โ
https://ducmanhphan.github.io/2020-12-02-command-bus-pattern/#given-problem
Command Bus pattern
Table of contents Given problem Solution with Command Bus pattern Source code Benefits and Drawbacks Some problems with Command Bus pattern The relationship with other patterns Wrapping up Given problem The problem of CommandBus pattern is the child proble
ducmanhphan.github.io
Refer:
https://github.com/cloudogu/command-bus
GitHub - cloudogu/command-bus: Java implementation of the Command-Bus pattern for Spring and CDI
Java implementation of the Command-Bus pattern for Spring and CDI - GitHub - cloudogu/command-bus: Java implementation of the Command-Bus pattern for Spring and CDI
github.com
https://github.com/fdside/commandbus
GitHub - fdside/commandbus: Tiny, Lightweight Java Command Bus
Tiny, Lightweight Java Command Bus. Contribute to fdside/commandbus development by creating an account on GitHub.
github.com
https://www.sitepoint.com/command-buses-demystified-a-look-at-the-tactician-package/
Command Buses Demystified: A Look at the Tactician Package - SitePoint
Andrew Cairns explains Commands and Command Buses, demonstrating their use with Tactician, a popular Command Bus package for PHP
www.sitepoint.com
https://matthiasnoback.nl/2015/01/a-wave-of-command-buses/
A wave of command buses โ Matthias Noback - Blog
Recently many people in the PHP community have been discussing a thing called the "command bus". The Laravel framework nowadays contains an implementation of a command bus and people have been talking about it in several vodcasts. My interest was sparked t
matthiasnoback.nl