https://school.programmers.co.kr/learn/courses/30/lessons/131128
— 문제 설명
두 정수 X
, Y
의 임의의 자리에서 공통으로 나타나는 정수 k(0 ≤ k ≤ 9)들을 이용하여 만들 수 있는 가장 큰 정수를 두 수의 짝꿍이라 합니다(단, 공통으로 나타나는 정수 중 서로 짝지을 수 있는 숫자만 사용합니다). X
, Y
의 짝꿍이 존재하지 않으면, 짝꿍은 -1입니다. X
, Y
의 짝꿍이 0으로만 구성되어 있다면, 짝꿍은 0입니다.
예를 들어, X
= 3403이고 Y
= 13203이라면, X
와 Y
의 짝꿍은 X
와 Y
에서 공통으로 나타나는 3, 0, 3으로 만들 수 있는 가장 큰 정수인 330입니다. 다른 예시로 X
= 5525이고 Y
= 1255이면 X
와 Y
의 짝꿍은 X
와 Y
에서 공통으로 나타나는 2, 5, 5로 만들 수 있는 가장 큰 정수인 552입니다(X
에는 5가 3개, Y
에는 5가 2개 나타나므로 남는 5 한 개는 짝 지을 수 없습니다.)
두 정수 X
, Y
가 주어졌을 때, X
, Y
의 짝꿍을 return하는 solution 함수를 완성해주세요.
— 제한 조건
X
, Y
의 길이(자릿수) ≤ 3,000,000입니다.X
, Y
는 0으로 시작하지 않습니다.X
, Y
의 짝꿍은 상당히 큰 정수일 수 있으므로, 문자열로 반환합니다.— 입출력 예
X | Y | result |
---|---|---|
"100" | "2345" | "-1" |
"100" | "203045" | "0" |
"100" | "123450" | "10" |
"12321" | "42531" | "321" |
"5525" | "1255" | "552" |
입출력 예 #1
X
, Y
의 짝꿍은 존재하지 않습니다. 따라서 "-1"을 return합니다.입출력 예 #2
X
, Y
의 공통된 숫자는 0으로만 구성되어 있기 때문에, 두 수의 짝꿍은 정수 0입니다. 따라서 "0"을 return합니다.입출력 예 #3
X
, Y
의 짝꿍은 10이므로, "10"을 return합니다.입출력 예 #4
X
, Y
의 짝꿍은 321입니다. 따라서 "321"을 return합니다.입출력 예 #5
— 문제 풀이
class Solution {
public String solution(String X, String Y) {
int[] numX = new int[10];
int[] numY = new int[10];
for(int i=0;i<X.length();i++){
numX[Integer.parseInt(X.charAt(i)+"")]++;
}
for(int i=0;i<Y.length();i++){
numY[Integer.parseInt(Y.charAt(i)+"")]++;
}
StringBuilder sb = new StringBuilder();
boolean flag = false; // 0이 아닌 공통된 수가 있는지 체크
for(int i=9;i>=0;i--){
if(numX[i]==0||numY[i]==0)continue;
if(i>0&&!flag) flag = true;
while(numX[i]>0&&numY[i]>0){
sb.append(i);
numX[i]--;
numY[i]--;
}
}
if(sb.toString().equals("")) return "-1";
else if(!flag) return "0";
return sb.toString();
}
}
https://school.programmers.co.kr/learn/courses/30/lessons/42862
— 문제 설명
점심시간에 도둑이 들어, 일부 학생이 체육복을 도난당했습니다. 다행히 여벌 체육복이 있는 학생이 이들에게 체육복을 빌려주려 합니다. 학생들의 번호는 체격 순으로 매겨져 있어, 바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있습니다. 예를 들어, 4번 학생은 3번 학생이나 5번 학생에게만 체육복을 빌려줄 수 있습니다. 체육복이 없으면 수업을 들을 수 없기 때문에 체육복을 적절히 빌려 최대한 많은 학생이 체육수업을 들어야 합니다.
전체 학생의 수 n, 체육복을 도난당한 학생들의 번호가 담긴 배열 lost, 여벌의 체육복을 가져온 학생들의 번호가 담긴 배열 reserve가 매개변수로 주어질 때, 체육수업을 들을 수 있는 학생의 최댓값을 return 하도록 solution 함수를 작성해주세요.
— 제한 조건
— 입출력 예
n | lost | reserve | return |
---|---|---|---|
5 | [2, 4] | [1, 3, 5] | 5 |
5 | [2, 4] | [3] | 4 |
3 | [3] | [1] | 2 |
예제 #1
1번 학생이 2번 학생에게 체육복을 빌려주고, 3번 학생이나 5번 학생이 4번 학생에게 체육복을 빌려주면 학생 5명이 체육수업을 들을 수 있습니다.
예제 #2
3번 학생이 2번 학생이나 4번 학생에게 체육복을 빌려주면 학생 4명이 체육수업을 들을 수 있습니다.
— 문제 풀이
class Solution {
public int solution(int n, int[] lost, int[] reserve) {
int[] students = new int[n];
for(int i=0;i<n;i++){
students[i] = 1;
}
for(int i=0;i<lost.length;i++){
students[lost[i]-1]--;
}
for(int i=0;i<reserve.length;i++){
students[reserve[i]-1]++;
}
for(int i=0;i<n;i++){
if(students[i]==0){
if(i>0&&students[i-1]==2){
students[i-1]--;
students[i]++;
}
else if(i<n-1&&students[i+1]==2){
students[i+1]--;
students[i]++;
}
}
}
int answer = 0;
for(int i=0;i<n;i++){
if(students[i]>0) answer++;
}
return answer;
}
}
Kafka 설치
version: '3.8'
services:
zookeeper:
image: wurstmeister/zookeeper:3.4.6
platform: linux/amd64
ports:
- "2181:2181"
environment:
ZOOKEEPER_CLIENT_PORT: 2181
ZOOKEEPER_TICK_TIME: 2000
kafka:
image: wurstmeister/kafka:latest
platform: linux/amd64
ports:
- "9092:9092"
environment:
KAFKA_ADVERTISED_LISTENERS: INSIDE://kafka:29092,OUTSIDE://localhost:9092
KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: INSIDE:PLAINTEXT,OUTSIDE:PLAINTEXT
KAFKA_LISTENERS: INSIDE://0.0.0.0:29092,OUTSIDE://0.0.0.0:9092
KAFKA_INTER_BROKER_LISTENER_NAME: INSIDE
KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
volumes:
- /var/run/docker.sock:/var/run/docker.sock
kafka-ui:
image: provectuslabs/kafka-ui:latest
platform: linux/amd64
ports:
- "8080:8080"
environment:
KAFKA_CLUSTERS_0_NAME: local
KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS: kafka:29092
KAFKA_CLUSTERS_0_ZOOKEEPER: zookeeper:2181
KAFKA_CLUSTERS_0_READONLY: "false"
Producer Project
spring:
application:
name: producer
kafka:
bootstrap-servers: localhost:9092
producer:
key-serializer: org.apache.kafka.common.serialization.StringSerializer
value-serializer: org.apache.kafka.common.serialization.StringSerializer
server:
port: 8090
@Configuration
public class ProducerApplicationKafkaConfig {
@Bean
public ProducerFactory<String, String> producerFactory() {
Map<String, Object> configProps = new HashMap<>();
configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
return new DefaultKafkaProducerFactory<>(configProps);
}
@Bean
public KafkaTemplate<String, String> kafkaTemplate() {
return new KafkaTemplate<>(producerFactory());
}
}
@RestController
@RequiredArgsConstructor
public class ProducerController {
private final ProducerService producerService;
@GetMapping("/send")
public String sendMessage(@RequestParam("topic") String topic,
@RequestParam("key") String key,
@RequestParam("message") String message) {
producerService.sendMessage(topic, key, message);
return "Message sent to Kafka topic";
}
}
@Service
@RequiredArgsConstructor
public class ProducerService {
private final KafkaTemplate<String, String> kafkaTemplate;
public void sendMessage(String topic , String key, String message) {
for (int i = 0; i < 10; i++) {
kafkaTemplate.send(topic, key, message + " " + i);
}
}
}
Consumer Project
spring:
application:
name: consumer
kafka:
bootstrap-servers: localhost:9092
producer:
key-serializer: org.apache.kafka.common.serialization.StringSerializer
value-serializer: org.apache.kafka.common.serialization.StringSerializer
server:
port: 8091
// 이 클래스는 Kafka 컨슈머 설정을 위한 Spring 설정 클래스입니다.
@EnableKafka // Kafka 리스너를 활성화하는 어노테이션입니다.
@Configuration // Spring 설정 클래스로 선언하는 어노테이션입니다.
public class ConsumerApplicationKafkaConfig {
// Kafka 컨슈머 팩토리를 생성하는 빈을 정의합니다.
// ConsumerFactory는 Kafka 컨슈머 인스턴스를 생성하는 데 사용됩니다.
// 각 컨슈머는 이 팩토리를 통해 생성된 설정을 기반으로 작동합니다.
@Bean
public ConsumerFactory<String, String> consumerFactory() {
// 컨슈머 팩토리 설정을 위한 맵을 생성합니다.
Map<String, Object> configProps = new HashMap<>();
// Kafka 브로커의 주소를 설정합니다.
configProps.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
// 메시지 키의 디시리얼라이저 클래스를 설정합니다.
configProps.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
// 메시지 값의 디시리얼라이저 클래스를 설정합니다.
configProps.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
// 설정된 프로퍼티로 DefaultKafkaConsumerFactory를 생성하여 반환합니다.
return new DefaultKafkaConsumerFactory<>(configProps);
}
// Kafka 리스너 컨테이너 팩토리를 생성하는 빈을 정의합니다.
// ConcurrentKafkaListenerContainerFactory는 Kafka 메시지를 비동기적으로 수신하는 리스너 컨테이너를 생성하는 데 사용됩니다.
// 이 팩토리는 @KafkaListener 어노테이션이 붙은 메서드들을 실행할 컨테이너를 제공합니다.
@Bean
public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() {
// ConcurrentKafkaListenerContainerFactory를 생성합니다.
ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
// 컨슈머 팩토리를 리스너 컨테이너 팩토리에 설정합니다.
factory.setConsumerFactory(consumerFactory());
// 설정된 리스너 컨테이너 팩토리를 반환합니다.
return factory;
}
}
@Slf4j
@Service
public class ConsumerEndpoint {
// 이 메서드는 Kafka에서 메시지를 소비하는 리스너 메서드입니다.
// @KafkaListener 어노테이션은 이 메서드를 Kafka 리스너로 설정합니다.
@KafkaListener(groupId = "group_a", topics = "topic1")
// Kafka 토픽 "test-topic"에서 메시지를 수신하면 이 메서드가 호출됩니다.
// groupId는 컨슈머 그룹을 지정하여 동일한 그룹에 속한 다른 컨슈머와 메시지를 분배받습니다.
public void consumeFromGroupA(String message) {
log.info("Group A consumed message from topic1: " + message);
}
// 동일한 토픽을 다른 그룹 ID로 소비하는 또 다른 리스너 메서드입니다.
@KafkaListener(groupId = "group_b", topics = "topic1")
public void consumeFromGroupB(String message) {
log.info("Group B consumed message from topic1: " + message);
}
// 다른 토픽을 다른 그룹 ID로 소비하는 리스너 메서드입니다.
@KafkaListener(groupId = "group_c", topics = "topic2")
public void consumeFromTopicC(String message) {
log.info("Group C consumed message from topic2: " + message);
}
// 다른 토픽을 다른 그룹 ID로 소비하는 리스너 메서드입니다.
@KafkaListener(groupId = "group_c", topics = "topic3")
public void consumeFromTopicD(String message) {
log.info("Group C consumed message from topic3: " + message);
}
@KafkaListener(groupId = "group_d", topics = "topic4")
public void consumeFromPartition0(String message) {
log.info("Group D consumed message from topic4: " + message);
}
}
실행 후 확인
RabbitMQ를 활용해 보상 트랜잭션이 구현된 상품 주문 시스템 구현
Project : Order, Product, Payment
Queue : market.product, market.payment, market.err.product, market.err.order
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-amqp'
implementation 'org.springframework.boot:spring-boot-starter-web'
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
testImplementation 'org.springframework.amqp:spring-rabbit-test'
testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
spring:
application:
name: order
rabbitmq:
host: localhost
port: 5672
username: guest
password: guest
message:
exchange: market
err:
exchange : market.err
queue:
product: market.product
payment: market.payment
err:
order : market.err.order
product : market.err.product
@Configuration
public class OrderApplicationQueueConfig {
@Bean
public Jackson2JsonMessageConverter producerJackson2MessageConverter() {
return new Jackson2JsonMessageConverter();
}
@Value("${message.exchange}")
private String exchange;
@Value("${message.queue.product}")
private String queueProduct;
@Value("${message.queue.payment}")
private String queuePayment;
@Value("${message.err.exchange}")
private String exchangeErr;
@Value("${message.queue.err.order}")
private String queueErrOrder;
@Value("${message.queue.err.product}")
private String queueErrProduct;
@Bean public TopicExchange exchange() { return new TopicExchange(exchange); }
@Bean public Queue queueProduct() { return new Queue(queueProduct); }
@Bean public Queue queuePayment() { return new Queue(queuePayment); }
@Bean public Binding bindingProduct() { return BindingBuilder.bind(queueProduct()).to(exchange()).with(queueProduct); }
@Bean public Binding bindingPayment() { return BindingBuilder.bind(queuePayment()).to(exchange()).with(queuePayment); }
@Bean public TopicExchange exchangeErr() { return new TopicExchange(exchangeErr); }
@Bean public Queue queueErrOrder() { return new Queue(queueErrOrder); }
@Bean public Queue queueErrProduct() { return new Queue(queueErrProduct); }
@Bean public Binding bindingErrOrder() { return BindingBuilder.bind(queueErrOrder()).to(exchangeErr()).with(queueErrOrder); }
@Bean public Binding bindingErrProduct() { return BindingBuilder.bind(queueErrProduct()).to(exchangeErr()).with(queueErrProduct); }
}
@Builder
@Data
@ToString
public class Order {
private UUID orderId;
private String userId;
private String orderStatus;
private String errorType;
public void cancelOrder(String receiveErrorType) {
orderStatus = "CANCEL";
errorType = receiveErrorType;
}
}
@Data
@Builder
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class DeliveryMessage {
private UUID orderId;
private UUID paymentId;
private String userId;
private Integer productId;
private Integer productQuantity;
private Integer payAmount;
private String errorType;
}
@Slf4j
@RestController
@RequiredArgsConstructor
public class OrderEndpoint {
private final OrderService orderService;
private final RabbitTemplate rabbitTemplate;
@GetMapping("order/{orderId}")
public ResponseEntity<Order> getOrder(@PathVariable UUID orderId) {
Order order = orderService.getOrder(orderId);
return ResponseEntity.ok(order);
}
@PostMapping("/order")
public ResponseEntity<Order> order(@RequestBody OrderRequestDto orderRequestDto) {
Order order = orderService.createOrder(orderRequestDto);
return ResponseEntity.ok(order);
}
@RabbitListener(queues = "${message.queue.err.order}")
public void errOrder(DeliveryMessage message) {
log.info("ERROR RECEIVE !!!");
orderService.rollbackOrder(message);
}
@Data
public static class OrderRequestDto {
private String userId;
private Integer productId;
private Integer productQuantity;
private Integer payAmount;
public Order toOrder (){
return Order.builder()
.orderId(UUID.randomUUID())
.userId(userId)
.orderStatus("RECEIPT")
.build();
}
public DeliveryMessage toDeliveryMessage(UUID orderId){
return DeliveryMessage.builder()
.orderId(orderId)
.userId(userId)
.productId(productId)
.productQuantity(productQuantity)
.payAmount(payAmount)
.build();
}
}
}
@Slf4j
@Service
@RequiredArgsConstructor
public class OrderService {
@Value("${message.queue.product}")
private String productQueue;
private final RabbitTemplate rabbitTemplate;
private Map<UUID, Order> orderStore = new HashMap<>();
public Order createOrder(OrderEndpoint.OrderRequestDto orderRequestDto) {
Order order = orderRequestDto.toOrder();
DeliveryMessage deliveryMessage = orderRequestDto.toDeliveryMessage(order.getOrderId());
orderStore.put(order.getOrderId(), order);
log.info("send Message : {}",deliveryMessage.toString());
rabbitTemplate.convertAndSend(productQueue, deliveryMessage);
return order;
}
public void rollbackOrder(DeliveryMessage message) {
Order order = orderStore.get(message.getOrderId());
order.cancelOrder(message.getErrorType());
log.info(order.toString());
}
public Order getOrder(UUID orderId) {
return orderStore.get(orderId);
}
}
dependencies {
// Jackson 의존성
implementation 'com.fasterxml.jackson.core:jackson-databind'
implementation 'com.fasterxml.jackson.core:jackson-core'
implementation 'com.fasterxml.jackson.core:jackson-annotations'
implementation 'org.springframework.boot:spring-boot-starter-amqp'
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
testImplementation 'org.springframework.amqp:spring-rabbit-test'
testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
spring:
application:
name: product
rabbitmq:
host: localhost
port: 5672
username: guest
password: guest
message:
exchange: market
err:
exchange : market.err
queue:
product: market.product
payment: market.payment
err:
order : market.err.order
product : market.err.product
@Configuration
public class ProductApplicationQueueConfig {
@Bean
public Jackson2JsonMessageConverter producerJackson2MessageConverter() {
return new Jackson2JsonMessageConverter();
}
}
@Data
@Builder
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class DeliveryMessage {
private UUID orderId;
private UUID paymentId;
private String userId;
private Integer productId;
private Integer productQuantity;
private Integer payAmount;
private String errorType;
}
@Slf4j
@Component
@RequiredArgsConstructor
public class ProductEndpoint {
private final ProductService productService;
@RabbitListener(queues = "${message.queue.product}")
public void receiveMessage(DeliveryMessage deliveryMessage) {
productService.reduceProductAmount(deliveryMessage);
log.info("PRODUCT RECEIVE:{}", deliveryMessage.toString());
}
@RabbitListener(queues="${message.queue.err.product}")
public void receiveErrorMessage(DeliveryMessage deliveryMessage) {
log.info("ERROR RECEIVE !!!");
productService.rollbackProduct(deliveryMessage);
}
}
@Slf4j
@Service
@RequiredArgsConstructor
public class ProductService {
private final RabbitTemplate rabbitTemplate;
@Value("${message.queue.payment}")
private String paymentQueue;
@Value("${message.queue.err.order}")
private String orderErrorQueue;
public void reduceProductAmount(DeliveryMessage deliveryMessage) {
Integer productId = deliveryMessage.getProductId();
Integer productQuantity = deliveryMessage.getProductQuantity();
if (productId != 1 || productQuantity > 1) {
this.rollbackProduct(deliveryMessage);
return;
}
rabbitTemplate.convertAndSend(paymentQueue,deliveryMessage);
}
public void rollbackProduct(DeliveryMessage deliveryMessage){
log.info("PRODUCT ROLLBACK!!!");
if(!StringUtils.hasText(deliveryMessage.getErrorType())){
deliveryMessage.setErrorType("PRODUCT ERROR");
}
rabbitTemplate.convertAndSend(orderErrorQueue, deliveryMessage);
}
}
dependencies {
// Jackson 의존성
implementation 'com.fasterxml.jackson.core:jackson-databind'
implementation 'com.fasterxml.jackson.core:jackson-core'
implementation 'com.fasterxml.jackson.core:jackson-annotations'
implementation 'org.springframework.boot:spring-boot-starter-amqp'
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
testImplementation 'org.springframework.amqp:spring-rabbit-test'
testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
spring:
application:
name: payment
rabbitmq:
host: localhost
port: 5672
username: guest
password: guest
message:
exchange: market
err:
exchange : market.err
queue:
product: market.product
payment: market.payment
err:
order : market.err.order
product : market.err.product
@Data
@Builder
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class DeliveryMessage {
private UUID orderId;
private UUID paymentId;
private String userId;
private Integer productId;
private Integer productQuantity;
private Integer payAmount;
private String errorType;
}
@Data
@Builder
public class Payment {
private UUID paymentId;
private String userId;
private String payAmount;
private String payStatus;
}
@Configuration
public class PaymentApplicationQueueConfig {
@Bean
public Jackson2JsonMessageConverter producerJackson2MessageConverter() {
return new Jackson2JsonMessageConverter();
}
}
@Slf4j
@Component
@RequiredArgsConstructor
public class PaymentEndpoint {
private final PaymentService paymentService;
@RabbitListener(queues = "${message.queue.payment}")
public void receiveMessage(DeliveryMessage deliveryMessage) {
log.info("PAYMENT RECEIVE : {}", deliveryMessage.toString());
paymentService.createPayment(deliveryMessage);
}
}
@Slf4j
@Service
@RequiredArgsConstructor
public class PaymentService {
private final RabbitTemplate rabbitTemplate;
@Value("${message.queue.err.product}")
private String productErrorQueue;
public void createPayment(DeliveryMessage deliveryMessage) {
Payment payment = Payment.builder()
.paymentId(UUID.randomUUID())
.userId(deliveryMessage.getUserId())
.payStatus("SUCCESS").build();
Integer payAmount = deliveryMessage.getPayAmount();
if (payAmount >= 10000) {
log.error("Payment amount exceeds limit: {}", payAmount);
payment.setPayStatus("CANCEL");
deliveryMessage.setErrorType("PAYMENT_LIMIT_EXCEEDED");
this.rollbackPayment(deliveryMessage);
}
}
public void rollbackPayment(DeliveryMessage deliveryMessage) {
log.info("PAYMENT ROLLBACK !!!");
rabbitTemplate.convertAndSend(productErrorQueue, deliveryMessage);
}
}
{
"userId" : "user1",
"productId" : 1,
"productQuantity" : 1,
"payAmount" : 1000
}
{
"userId" : "user1",
"productId" : 1,
"productQuantity" : 1,
"payAmount" : 10000
}
Apache에서 만든 Java Application Open Source 부하 테스트 도구
- JMeter 설치 URL : https://jmeter.apache.org/download_jmeter.cgi
위에서 만든 주문 서비스를 활용한 부하 테스트
Thread Group 생성 ( Test Plan - Add - Threads ( Users ) - Thread Group
HTTP Request 추가 ( Thread Group - Add - Sampler - HTTP Request )
HTTP Request 정보 입력 - Protocol, Host, Port, HTTP Method, Path
{
"userId" : "user1",
"productId" : 1,
"productQuantity" : 1,
"payAmount" : 1000
}
HTTP Header Manager 추가 ( HTTP Request - Add - Config Element - HTTP Header Manager )
Header에 Content-Type 추가
Report 추가 ( Thread Group - Add - Listener - View Results Tree, Summary Report )
실행 후 Report 확인