2023. 4. 27. 09:08ใ์ธํ๋ฐ/์คํ๋ง ๋ถํธ - ํต์ฌ ์๋ฆฌ์ ํ์ฉ
0๏ธโฃ ์์ ํ๋ก์ ํธ ๋ง๋ค๊ธฐ
์คํ๋ง ๋ถํธ๊ฐ ์ ๊ณตํ๋ ์๋ ๊ตฌ์ฑ์ ๋ํด์ ์์๋ณด๊ธฐ ์ ์
๊ฐ๋จํ ์์ ํ๋ก์ ํธ๋ฅผ ๋ง๋ค ๊ฒ์ธ๋ฐ ์ด ์์ ํ๋ก์ ํธ๋ ์ค์๊ฐ์ผ๋ก ์๋ฐ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ์น์ผ๋ก ํ์ธํ๋ ์์ ์ด๋ค.
Memory
public class Memory
{
private long used;
private long max;
public Memory(long used, long max)
{
this.used = used;
this.max = max;
}
public long getUsed()
{
return used;
}
public long getMax()
{
return max;
}
@Override
public String toString()
{
return "Memory{" +
"used=" + used +
", max=" + max +
'}';
}
}
uesd๋ ํ์ฌ ์ฌ์ฉ์ค์ธ ๋ฉ๋ชจ๋ฆฌ์ด๊ณ , max๋ ์ต๋ ๋ฉ๋ชจ๋ฆฌ๋ก used๊ฐ max๋ฅผ ๋์ด๊ฐ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ ๊ฒ์ด๋ค.
MemoryFinder
@Slf4j
public class MemoryFinder
{
public Memory get()
{
long max = Runtime.getRuntime().maxMemory(); // JVM์ด ์ฌ์ฉํ ์ ์๋ ์ต๋ ๋ฉ๋ชจ๋ฆฌ
long total = Runtime.getRuntime().totalMemory(); // JVM์ด ํ๋ณดํ ์ ์ฒด ๋ฉ๋ชจ๋ฆฌ
long free = Runtime.getRuntime().freeMemory(); /// JVM์ด ํ๋ณดํ ์ ์ฒด ๋ฉ๋ชจ๋ฆฌ ์ค ์ฌ์ฉํ์ง ์์ ๊ฒ
long used = total - free;
return new Memory(used, max);
}
@PostConstruct
public void init()
{
log.info("init MemoryFinder");
}
}
MemoryFinder์์ ์ด์ ๋ฉ๋ชจ๋ฆฌ ์ ๋ณด๋ฅผ ์ค์๊ฐ์ผ๋ก ์กฐํํ๋ ๊ธฐ๋ฅ์ด๋ค.
max : JVM์ด ์ฌ์ฉํ ์ ์๋ ์ต๋ ๋ฉ๋ชจ๋ฆฌ
total : JVM์ด ํ๋ณดํ ์ ์ฒด ๋ฉ๋ชจ๋ฆฌ (JVM์ด ์ฒ์๋ถํฐ max๊น์ง ๋ค ํ๋ณดํ๋ ๊ฒ์ด ์๋๊ณ ํ์ํ ๋ ๋ง๋ค ์กฐ๊ธ์ฉ ํ๋ณดํ๋ค.)
free : total ์ค์์ ์ฌ์ฉํ์ง ์์ ๋ฉ๋ชจ๋ฆฌ (JVM์ด ํ๋ณดํ ์ ์ฒด ๋ฉ๋ชจ๋ฆฌ ์ค์์ ์ฌ์ฉํ์ง ์์ ๊ฒ)
used : total - free ๋ก JVM์ด ์ฌ์ฉ์ค์ธ ๋ฉ๋ชจ๋ฆฌ์ด๋ค.
MemoryController
@Slf4j
@RestController
@RequiredArgsConstructor
public class MemoryController
{
private final MemoryFinder memoryFinder;
@GetMapping("/memory")
public Memory system()
{
Memory memory = memoryFinder.get();
log.info("memory = {}" , memory);
return memory;
}
}
MemoryController์์๋ ์ด์ ๋ฉ๋ชจ๋ฆฌ ์ ๋ณด๋ฅผ ์กฐํํ๋ ์ปจํธ๋กค๋ฌ๋ก memoryFinder๋ฅผ ์ฃผ์ ๋ฐ์์ ์ฌ์ฉํ๋ค.
MemoryConfig
@Configuration
public class MemoryConfig
{
@Bean
public MemoryController memoryController()
{
return new MemoryController(memoryFinder());
}
@Bean
public MemoryFinder memoryFinder()
{
return new MemoryFinder();
}
}
๊ทธ๋ฆฌ๊ณ ์ด์ MemoryConfig์ MemoryController์ MemoryFinder๋ฅผ ๋น์ผ๋ก ๋ฑ๋กํด์คฌ๋ค.
๋น์ผ๋ก ๋ฑ๋กํ localhost:8080/memory๋ฅผ ์คํํ๋ฉด ๊ฐ๋จํ๊ฒ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ์ค์๊ฐ์ผ๋ก ํ์ธํ ์ ์๋ค.
1๏ธโฃ Conditional
์ด์ ์์์ ๋ง๋ ํ๋ก์ ํธ๋ฅผ ์ฌ์ฉํ๋๋ฐ ํญ์ ๋ฉ๋ชจ๋ฆฌ ์กฐํ ๊ธฐ๋ฅ์ ์ฌ์ฉํ๋ ๊ฒ์ด ์๋๋ผ ํน์ ์กฐ๊ฑด์ผ ๋๋ง ํด๋น ๊ธฐ๋ฅ์ด ํ์ฑํ๋๋๋ก ํ๊ณ ์ถ๋ค๋ฉด??
์คํ๋ง์ด ์ ๊ณตํ๋ @Conditional ์ด๋ ธํ ์ด์ ์ด ์๋ค.
-> ์ด ์ด๋ ธํ ์ด์ ์ ๊ฐ์ ์์ค ์ฝ๋์ธ๋ฐ ํน์ ์ํฉ์ผ ๋๋ง ํน์ ๋น๋ค์ ๋ฑ๋กํด์ ์ฌ์ฉํ๋๋ก ๋์์ฃผ๋ ๊ธฐ๋ฅ์ด๋ค.
(if๋ฌธ์ ๋ฃ๋๊ฒ๊ณผ ๋น์ทํ๋ค.)
Condition
@FunctionalInterface
public interface Condition {
/**
* Determine if the condition matches.
* @param context the condition context
* @param metadata the metadata of the {@link org.springframework.core.type.AnnotationMetadata class}
* or {@link org.springframework.core.type.MethodMetadata method} being checked
* @return {@code true} if the condition matches and the component can be registered,
* or {@code false} to veto the annotated component's registration
*/
boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}
matches ๋ฉ์๋๊ฐ true๋ฅผ ๋ฐํํ๋ฉด ์กฐ๊ฑด์ด ๋ง์กฑํ๋ ๊ฒ์ผ๋ก ํน์ ๊ธฐ๋ฅ์ ๋์ํ๊ณ , false๋ฅผ ๋ฐํํ๋ฉด ๋์ํ์ง ์๋๋ก ํ๋ค.
MemoryCondition
@Slf4j
public class MemoryCondition implements Condition
{
@Override
public boolean matches(ConditionContext context,
AnnotatedTypeMetadata metadata)
{
// -Dmemory=on
String memory = context.getEnvironment().getProperty("memory");
log.info("memory = {} ", memory);
return "on".equals(memory);
}
}
MemoryConditon์ Condition ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํด์ ์๋ฐ ์์คํ ์์ฑ์ด memory = on์ผ๋ก ์ค์ ๋ ๊ฒฝ์ฐ์๋ง true๋ฅผ ๋ฐํํด์ ๋ฉ๋ชจ๋ฆฌ ์กฐํํ ์์๋ค.
VM ์ต์ ์ค์ ์ -Dmemory=on ์ค์ ํด์ฃผ๋ฉด ๋๋ค.
๊ทธ ๋ค์ MemoryConfig ์์ @Conditional ์ด๋ ธํ ์ด์ ์ ์ถ๊ฐํด์ค๋ค.
@Configuration
@Conditional(MemoryCondition.class)
public class MemoryConfig
{
@Bean
public MemoryController memoryController()
{
return new MemoryController(memoryFinder());
}
@Bean
public MemoryFinder memoryFinder()
{
return new MemoryFinder();
}
}
@Conditional(MemoryCondition.class)
-> ์ด ์ด๋ ธํ ์ด์ ์ ์ถ๊ฐํ๊ณ ๋๋ฉด ์ด์ ๋ฉ๋ชจ๋ฆฌ ์กฐํ ๊ธฐ๋ฅ์ ํญ์ ์คํํ ์ ์๋ ๊ฒ์ด ์๋๋ผ ํน์ ์กฐ๊ฑด์ ๋ง๋ ๊ฒฝ์ฐ์๋ง ์คํํ ์ ์๋ค.
์ฆ, @Conditional์ ์ง์ ํ MemoryConfig์ ์กฐ๊ฑด์ ๋ฐ๋ผ true ์ธ ๊ฒฝ์ฐ์๋ง MemoryConfig๊ฐ ์ ์ฉ ๋ ์ ์๋ค.
MemoryCondition์ matches()๋ฅผ ์คํํด๋ณด๊ณ , ๊ทธ ๋ค์ ๊ฒฐ๊ณผ๊ฐ true ์ด๋ฉด MemoryConfig๊ฐ ์ ์ ๋์๋๊ณ , MemoryController, MemoryFinder๊ฐ ๋น์ผ๋ก ๋ฑ๋ก๋๋ค.
๋ฐ๋๋ก ๊ฒฐ๊ณผ๊ฐ false ์ธ ๊ฒฝ์ฐ์๋ MemoryConfig๋ ๋ฌดํจํ ๋์ด์ ๋น์ผ๋ก ๋ฑ๋ก๋์ง ์๋๋ค.
2๏ธโฃ @Conditional์ ๋ค์ํ ๊ธฐ๋ฅ
์์์ ๋ณด๋ฉด MemoryCondition์ด Condition์ ์ง์ ๊ตฌํํด์ ๊ตฌํ์ฒด๋ฅผ ๋ง๋ค์๋๋ฐ ์ฌ์ค ์คํ๋ง์ ์ด๋ฏธ ํ์ํ ๊ฒ์ ์ ๊ณตํ๊ณ ์๋ค.
MemoryConfig
@Configuration
//@Conditional(MemoryCondition.class)
@ConditionalOnProperty(name = "memory", havingValue = "on")
public class MemoryConfig
{
@Bean
public MemoryController memoryController()
{
return new MemoryController(memoryFinder());
}
@Bean
public MemoryFinder memoryFinder()
{
return new MemoryFinder();
}
}
@Conditional ์ด๋ ธํ ์ด์ ๋์ @ConditionalOnProperty(name = "memory", havingValue = "on") ์ด๋ ธํ ์ด์ ์ผ๋ก ๋ฐ๊ฟ์ฃผ๋ฉด ์์์ ํ๋ ๊ฒ๊ณผ ๋๊ฐ์ด ๋์ํ๋ค!
@ConditionalOnProperty ์ด๋ ธํ ์ด์ ์ ๋ณด๋ฉด ๊ทธ ์์ @Conditional ์ด๋ ธํ ์ด์ ์ ๊ฐ์ง๊ณ ์๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
๊ทธ๋ฆฌ๊ณ OnPropertyCondition ํด๋์ค๋ฅผ ๋ณด๋ฉด Condition์ ๊ตฌํํ๊ณ ์๋ ๊ฒ๋ ํ์ธํ ์ ์๋ค.
๐ ์คํ๋ง์ด ์ ๊ณตํ๋ @ConditionalOnXxx
- @ConditionalOnClass, @ConditionalOnMissingClass
: ํด๋์ค๊ฐ ์๋ ๊ฒฝ์ฐ์ ๋์ํ๋ค, ์๋ ๊ฒฝ์ฐ์ ๋์ํ๋ค.
- @ConditionalOnBean, @ConditionalOnMissingBean
: ๋น์ด ๋ฑ๋ก๋์ด ์๋ ๊ฒฝ์ฐ์ ๋์ํ๋ค, ์๋ ๊ฒฝ์ฐ์ ๋์ํ๋ค.
- @ConditionalOnProperty
: ํ๊ฒฝ ์ ๋ณด๊ฐ ์๋ ๊ฒฝ์ฐ์ ๋์ํ๋ค.
- @ConditionalOnResource
: ๋ฆฌ์์ค๊ฐ ์๋ ๊ฒฝ์ฐ์ ๋์ํ๋ค.
- @ConditionalOnWebApplication, @ConditionalOnNotWebApplication
: ์น ์ ํ๋ฆฌ์ผ์ด์ ์ธ ๊ฒฝ์ฐ์ ๋์ํ๋ค, ์๋ ๊ฒฝ์ฐ์ ๋์ํ๋ค.
'์ธํ๋ฐ > ์คํ๋ง ๋ถํธ - ํต์ฌ ์๋ฆฌ์ ํ์ฉ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์๋ ๊ตฌ์ฑ Auto Configuration ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ง๋ค๊ณ ์ฌ์ฉํด๋ณด๊ธฐ (0) | 2023.04.28 |
---|---|
์๋ ๊ตฌ์ฑ ์ฌ์ฉ ์ ์คํ๋ง ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ง๋ค๊ณ ์ฌ์ฉํด๋ณด๊ธฐ (0) | 2023.04.28 |
์คํ๋ง ๋ถํธ Auto Configuration (0) | 2023.04.25 |
์คํ๋ง ๋ถํธ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ด๋ฆฌ์ ์คํ๋ง ๋ถํธ ์คํํฐ (0) | 2023.04.24 |
์คํ๋ง ๋ถํธ์ ์น ์๋ฒ ์คํ ๋ฐ ๋น๋ ๋ฐฐํฌ (0) | 2023.04.21 |