defaultK

[Node.js] RabbitMQ,Socket.io 실시간 웹소켓 서버 구축기 (2)

kwoss2341 — Wed, 26 Apr 2023 23:05:15 +0900

본격적인 구조 설계

설계1

처음 구상한 RabbitMQ를 이용한 실시간 서버의 모습니다.

처음에는 웹소켓 서버가 아닌 REST-API서버였고, 클라이언트 프로그램은 외부 RabbitMQ의 큐를 소비하는 시스템이었습니다.

서버의 역할은 그저 요청이 오면 메시지를 큐에 발행하는 일이었습니다.

클라이언트 측도 받은 메시지에 따라 실시간으로 동작을 수행하는 간단한 시스템이었습니다.

하지만 몇 가지 문제점이 있었습니다.

1. 연결 여부 및 접속 시간 확인

POS시스템을 운영하면서 가장 중요한 부분은 연결 여부와 접속 시간이었습니다.

해당 클라이언트가 연결되어 있는지, 연결한 시간과 연결이 끊긴 시간은 POS시스템 운영에 가장 중요하다 판단했습니다. RabbitMQ에서도 연결 여부를 알 수 있겠지만 서비스에 활용하기 어렵다고 판단했습니다.

2. RabbitMQ Connection 관리

RabbitMQ는 AWS의 RabbitMQ용 AmazonMQ를 이용했습니다.

인스턴스 유형은 m5.large를 선택했습니다.

AmazonMQ 브로커 기본값

m5.large 인스턴스 유형의 max-connections 값은 4000개 이고, 이는 수동으로 변경이 가능했습니다.

하지만 많은 커넥션은 RabbitMQ서버에도 비효율적이라고 판단했습니다.

3. React-natve RabbitMQ 라이브러리

클라이언트 프로그램은 안드로이드 OS기반의 프로그램들로 react-native로 개발 중이었습니다.

react-native 앱에서 rabbitMQ를 사용하기 위해 react-native-rabbitmq 라이브러리를 이용하려 했지만 최신 버전 안드로이드에서 제대로 빌드가 되지 않았습니다. 해당 라이브러리는 최근 커밋이 2019년이 마지막이었고 react-native-rabbitmq를 제외한 쓸만한 라이브러리를 찾지 못했습니다.

이러한 다양한 이유 때문에 RabbitMQ를 이용한 실시간 웹소켓 서버 설계를 시작했습니다.

1차 실시간 웹소켓 서버 설계입니다.

실시간 웹소켓 서버

실시간 웹소켓 서버와 RabbitMQ

실시간 웹소켓 서버와 RabbitMQ 사이 Connection입니다.

분산 서버 2대에서 각각 하나의 Connection을 맺습니다. (실제로는 pm2를 이용하여 각각의 서버에서 4개의 인스턴스를 생성해서 한 서버에 프로세스 4개 , 즉 커넥션 4개씩 2개의 서버 총 8개의 커넥션만을 이용했습니다.)

그 후 서버와 클라이언트 프로그램사이 WebSocket Connection이 맺어지면 RabbitMQ Connection에서 Channel을 하나 생성해서 클라이언트 프로그램 1개 당 메시지 큐 하나를 생성하고 클라이언트 프로그램에 맞게 큐에 바인딩한 후 채널을 통해 해당 큐를 소비합니다. 큐의 Message Consume 이벤트는 socket을 통해 클라이언트 프로그램에 전달됩니다.

그 후 웹소켓이 끊어지면 해당 채널을 통해 큐 소비를 취소하고 채널을 닫습니다.

요약하자면.

1. RabbitMQ Connection 생성

2. 실시간 웹소켓서버 포트 listening

3. 클라이언트 프로그램 웹소켓 connect

4. Channel 생성

5. Channel => 큐 생성, 바인딩, 큐 소비

6. 웹소켓 연결 끊어질 시 큐 소비 취소, Channel close

간단한 동작이지만 구현하면서 많은 난관이 있었습니다.

자체적으로 10000개의 웹소켓 커넥션을 맺어가며 부하테스트를 진행하면서 겪었던

어려웠던 점에 대해 소개하겠습니다.

부하테스트 난관 1. DB Connection

가장 기본적인 부분이었습니다. Knex.js를 이용해서 DB를 이용 중, 웹소켓 접속 시 헤더의 토큰을 보고 유효한 토큰에 한해 DB 조회를 해서 간단한 기기 정보를 불러오는 로직에서 DB에서 'Too many connection' 에러가 발생했습니다.

원인은 DB의 Connection이었습니다. 하지만 knex.js의 connection pool을 이용하고 있어 의아했습니다.

원인은 connection pool 옵션이었습니다. connection pool의 max connection을 너무 높게 잡아 서버 2대의 8개의 프로세스에서 DB Connection보다 많은 connection이 문제였습니다. 오히려 connection 수를 줄여 db connection 문제를 해결했습니다.

부하테스트 난관 2. RABBITMQ_MEMORY_ALARM

10000개의 클라이언트 웹소켓이 한 번에 서버에 붙으면 RabbitMQ 서버에 10000개의 채널이 생성됩니다.

( 하나의 채널에 하나의 웹소켓만 해당 큐를 소비하는 건 비효율적입니다.)

RabbitMQ 서버에 한 번에 10000개의 채널을 동시에 요청하니 서버에 메모리 알람이 발생했습니다.

부득이하게 실시간 웹소켓 서버를 수정하고 다시 배포하면 한번에 많은 웹소켓이 연결될 것이고, RabbitMQ서버에 많은 채널을 요청할 것입니다. 이는 RabbitMQ 서버의 큰 부하를 일으켜 문제 해결이 필요했습니다.

channel 동시 생성

문제 해결을 위해 async queue를 이용했습니다.

해당 큐에 RabbitMQ 요청을 push 하고 큐에서 순서대로 채널을 생성해 공급하는 방식이었습니다.

async queue의 옵션을 통해 최대 10개까지 동시 처리 가능하게 설정을 해서 10000개의 웹소켓이 한 번에 접속해도 큐에 최대 동시 10개씩 순차적으로 채널을 공급해 서버의 부하를 줄였습니다.

Queue를 이용한 Channel 생성

하지만 가장 좋은 방법은 가급적이면 채널을 적절히 생성하는 것입니다.

크리티컬 하지 않는 경우 채널을 재사용해서 서버의 부하를 줄여야 합니다.

부하테스트 난관 3. "No channels left to allocate"

amqplib라이브러리를 이용해서 부하테스트 중 해당 에러가 발생했습니다.

해당에러는 할당할 채널이 남아 있지 않았을 때 발생합니다.

가장 먼저 RabbitMQ Management 웹 콘솔에서 설정을 확인합니다.

max-channels의 설정값을 확인해서 부족하면 늘려줍니다.

두 번째는 amqplib/lib/connection.js를 확인합니다.

실제로 에러발생하는 코드에서 channelMax의 값은 2047입니다.

connection을 통한 channel의 최대 개수는 2047개였습니다.

각 서버의 실시간 웹소켓 서버의 프로세스 수를 늘려 최대한 분산하는 방식으로 각 커넥션당 2047개를 넘지 않게 조절했습니다.

부하테스트 난관 4. Exchages

10000개의 클라이언트 프로그램의 실시간 웹소켓 서버에 연결되고, 채널과 큐가 생성되면 큐에 각각의 클라이언트의 성격에 맞게 routing key에 맞게 바인딩해줘야 합니다.

앞서 언급했듯이 Topic Exchage를 이용해서 라우팅키를 바인딩합니다.

하지만 하나의 Exchange에 10000개의 클라이언트 프로그램의 라우팅키를 여러 개 바인딩하는 것은 비효율적입니다.

각각의 매장단위로 Exchange를 생성해서 해당매장의 속한 클라이언트 프로그램은 해당 매장 Exchage로만 바인딩을 해서 각각의 Exchage에 대한 부하를 최대한 분산했습니다.

최종 실시간 웹소켓 서버와 RabbitMQ

RabbitMQ와 Socket.io를 이용한 실시간 웹소켓 서버를 구축한 최종 모습입니다.

API 서버에서 필요한 메시지를 Exchange를 통해 발행하면 클라이언트 프로그램까지 도달되는 과정을 그린 그림입니다.

봐주셔서 감사합니다.

[Node.js] RabbitMQ,Socket.io 실시간 웹소켓 서버 구축기 (1)

kwoss2341 — Wed, 19 Apr 2023 23:30:46 +0900

들어가기 앞서...

회사에서 새로운 프로젝트를 시작하기로 했습니다.

외식업의 포스시스템 구축 프로젝트로 안드로이드 클라이언트 프로그램(POS, KIOSK, 태블릿 오더) 간의 실시간 웹소켓 통신 서버 구축이 과제였습니다. 해당 글은 Node.js로 실시간 웹소켓 통신 서버 구축하는 경험기를 소개하고자 합니다.

(정답은 아니고 미흡한 부분이 많습니다...)

개발배경

외식업의 포스시스템 프로젝트를 시작하면서 가장 걱정한 부분은 네트워크 상태에따른 주문 누락에 대한 부분이었습니다.

몇몇 포스시스템은 불안정한 네트워크상황과 여러 변수들을 고려해 같은 로컬 네트워크를 클라이언트 프로그램에서 사용한다고 하지만..

이러한 시스템은 초기 설정도 힘들고 전문가가 아니면 네트워크 구축하기도 힘듭니다.

저희는 인터넷만 되면 연결이 가능한 중앙 웹소켓 통신 서버 구축을 하기로 결정했습니다.

개발하기 앞서 기존 서비스 중인 웹소켓 서버

현재 드라이브 스루 앱 서비스를 제공하는 회사에 재직 중입니다.

드라이브 스루 앱은 다른 배달앱과 같이 고객이 직접 앱을 통해 주문할 메뉴를 고르고 결제한뒤

차를 타고 가면 가맹점에서 주문한 메뉴를 전달해 주는 서비스를 제공해 주는 위치기반 주문 앱입니다.

실시간 웹소켓 서버를 이용한 주문 알림

사진과 같이 드라이브 스루 앱은 실시간 웹소켓 서버와 커넥션을 맺고 있습니다.

가맹점에서 마찬가지로 가맹점 전용 주문 접수 앱을 실시간 웹소켓 서버와 커넥션을 맺고 있습니다.

고객이 앱을 통해 결제와 주문을 하면 가맹점에서 실시간으로 주문 알림 발생해야 합니다.

실시간 웹소켓 서버를 이용한 주문 취소 알림

마찬가지로 가맹점 앱(STORE5)에서 해당 주문을 취소하면 APP5에서 취소 알림을 받을 수 있어야 합니다.

하지만 그림의 시스템은 웹소켓 서버가 하나일 경우에만 유효합니다...

대부분의 서비스는 안정성을 위해 분산 서버 시스템으로 구축합니다.

분산 서버 시스템에서는 그림처럼 실시간 웹소켓 서버를 구축할 수 없습니다.

다음 사진은 분산 서버 시스템에서의 실시간 웹소켓 서버입니다.

분산 서버 시스템에서의 실시간 웹소켓 서버

대부분의 서비스는 로드 밸런싱을 이용해서 분산 서버 시스템을 구축해 서버의 부하를 줄입니다.

분산 서버 시스템에서는 각기 다른 서버에서 커넥션을 맺어서 알림을 보낼 수 없습니다.

Redis는 캐시 메모리를 이용하는 서버로 다양한 자료구조와 서비스를 제공해 줍니다.

그중에서도 Redis Queue를 이용해 일종의 실시간 메시지 큐를 구현했습니다.

기존의 Redis큐를 이용한 실시간 웹소켓 서버

실시간 웹소켓 서버의 역할이 커졌습니다....

실시간 웹소켓 서버는 가맹점앱(THROO STORE)과 웹소켓 커넥션을 맺으면 해당 가맹점의 Redis 큐를 바라봐야 합니다. 실시간 웹소켓 서버 내에서 구현한 일종의 Worker는 가맹점의 Redis 큐를 바라보고 있다가 메시지가 큐에 들어오면 즉시 소비 해서 해당 소켓으로 메시지를 전송하는 역할을 합니다.

고객앱(THROO APP)에서 메시지를 생성할 때 역시 일종의 Producer가 실시간 웹소켓 서버 내에서 Redis 큐에 메시지를 넣어주는 역할을 합니다.

이로써 기존의 실시간 웹소켓 서버는 Redis를 통해 분산 서버 시스템에서의 웹소켓 커넥션 유지와 메시지 유실방지 기능을 수행하고 있었습니다.

기존의 Redis 가 아닌 RabbitMQ를 사용하기로 결정한 이유

기존의 Redis 실시간 웹소켓 서버 역시 큰 문제없이 안정적인 서비스를 제공 중이었습니다.

하지만 새로운 프로젝트에서 기존의 웹소켓 서버를 이용하기에는 부족함이 있었습니다.

다음은 RabbitMQ를 사용하기로 결정한 이유를 소개해드리겠습니다.

1, 복잡한 라우팅 기능 지원

Redis와 달리 RabbitMQ는 복잡한 라우팅 기능을 지원합니다.

외식업 포스시스템 구축 프로젝트에는 다양한 클라이언트 프로그램 ( POS, KIOSK, 태블릿오더, 기존 자사 드라이브스루앱 등..) 이 있습니다.

복잡한 라우팅

Job의 성격에 따라 메시지는 POS 그룹에, 특정 태블릿에게만, 가맹점 전체 클라이언트 프로그램에게 전달될 수 있어야 합니다. 메시지의 성격에 따라 라우팅방식이 복잡해집니다.

Redis에서 pub/sub 기능을 제공하지만 해당 기능은 클라이언트가 sub 하지 않으면 메시지 유실이 발생합니다. 메시지 유실은 시스템 전체의 신뢰성을 하락시켜 치명적입니다.

또한 실시간 웹소켓 서버에서 자체적으로 메시지 성격에 따라 Redis 큐에 메시지를 넣는 방법도 있지만 이는 기능 구현하기 번거롭고 유지보수 측면에서도 굉장히 힘들어질 것 같았습니다.

RabbitMQ에서는 메시지가 생성되면 Exchange에서 바인딩 정보에 따라 해당 메시지를 큐에 넣어 줍니다.

Exchange의 다양한 타입 중에서 저희에게 필요한 Topic을 이용했습니다.

https://www.rabbitmq.com/tutorials/tutorial-five-javascript.html

RabbitMQ tutorial - Topics — RabbitMQ

Topics (using the amqp.node client) Prerequisites This tutorial assumes RabbitMQ is installed and running on localhost on the standard port (5672). In case you use a different host, port or credentials, connections settings would require adjusting. Where t

www.rabbitmq.com

TOPIC

다음은 Topic을 이용해서 메시지를 라우팅 하는 과정입니다.

*, # 으로 큐는 자기가 원하는 메시지만 받을 수 있습니다.

TOPIC을 이용한 메시지 라우팅 예시

TOPIC의 라우팅 키에 따라 메시지를 라우팅하는 예시입니다.

각각의 큐에 라우팅 규칙을 적용해서 1번 가맹점 전체 (STORE_1) , 1번 가맹점의 POS 전체(STORE_1.POS), 1번 가맹점의 POS 1번만 (STORE_1.POS_1) 메시지를 보낼 수 있습니다.

2. 실시간 모니터링

래빗엠큐에서는 기본적으로 15672 포트에서 웹브라우저를 통해 management UI를 제공해 줍니다.

큐 생성뿐만 아니라 커넥션, 커넥션을 통해 생성된 채널, Exchange의 바인딩 정보, Queue 옵션, Queue 메시지 수 등등 한눈에 파악할 수 있습니다.

기존의 Redis 큐 역시 모니터링할 수 있는 툴이 존재했지만 RabbitMQ의 management UI 수준의 모니터링은 할 수 없었습니다.

뿐만 아니라 서버 측에서 활용할 수 있는 api 도 제공해주고 있어 유지 보수 측면에서 유리하다고 판단했습니다.

3. 다양한 옵션

메시지 큐를 이용하면 다양한 문제를 만날 수 있습니다.

예를 들어 메시지 유실 방지를 위해 생성한 메시지 큐에 메시지를 언제까지 유지시킬 것인가?

만약 한번 생성된 큐에 Consumer 가 없어 계속해서 메시지가 쌓이면 이는 RabbitMQ 성능에 큰 문제를 야기시킬 수 있습니다. 또한 장기간 사용하지 않아 메시지가 잔뜩 쌓인 큐를 클라이언트 측이 한 번에 다 소비하려면 클라이언트 프로그램 역시 많은 무리가 갑니다. 이를 메시지 옵션을 통해 타임아웃을 걸어 자동 삭제가 가능하고, 큐 옵션을 통해 일정 시간 동안 Consumer가 없으면 큐를 자동 삭제해 줄 수 있었습니다.

4. 검증된 시스템, 방대한 자료, 쉬운 구현

RabbitMQ는 오랜 기간 사용되어 왔습니다.

많은 사용자가 사용한 만큼 검증된 오픈소스이고자료 역시 방대하고 구현도 쉬웠습니다. 이해하기 쉽게 정리된 공식문서 역시 마음에 들었습니다.

여기까지 '실시간 웹소켓 서버 구축기 (1)' 입니다.

'실시간 웹소켓 서버 구축기 (2)' 에서는 구현하면서 겪었던 어려움에 대해서 적어보겠습니다...

[React] Hook 훅

kwoss2341 — Sun, 17 Jul 2022 23:40:57 +0900

https://ko.reactjs.org/docs/hooks-intro.html

Hook의 개요 – React

A JavaScript library for building user interfaces

ko.reactjs.org

Hook

✔ Funtion component에서 리액트의 state와 생명주기 기능을 지원

State Hook

✔ state를 사용하기 위한 훅

import React, { useState } from 'react';

function Example() {

  const [count, setCount] = useState(0);

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
    </div>
  );
}

Effect Hook

✔ 생명주기 함수 기능을 제공

import React, { useState, useEffect } from 'react';

function FriendStatus(props) {
  const [isOnline, setIsOnline] = useState(null);

  useEffect(() => {
    function handleStatusChange(status) {
      setIsOnline(status.isOnline);
    }
    ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange);
    // effect 이후에 어떻게 정리(clean-up)할 것인지 표시합니다.
    return function cleanup() {
      ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange);
    };
  });

  if (isOnline === null) {
    return 'Loading...';
  }
  return isOnline ? 'Online' : 'Offline';
}

[React] State 와 LifeCycle

kwoss2341 — Sun, 17 Jul 2022 14:19:45 +0900

https://ko.reactjs.org/docs/state-and-lifecycle.html

State and Lifecycle – React

A JavaScript library for building user interfaces

ko.reactjs.org

State

✔ 리액트 컴포넌트의 변경 가능 데이터

✔ state가 변경될 경우 재랜더링.

✔ 변경시 재랜더링이 일어나므로 성능을 고려하여 state 값 설정

✔ state값을 변경시

-Class component : setState()

-Function component : useState() 훅에서 정의한 set함수

LifeCycle

✔ componentDidMount()

- 컴포넌트가 생성될 때

✔ componentDidUpdate()

- component props가 변경될 때

- state값 변경시(setState())

- forceUpdate() 강제 업데이트 함수 호출 시

✔ componentWillUnmount()

- 컴포넌트가 언마운트될때 호출

class Clock extends React.Component {
  constructor(props) {
    super(props);
    this.state = {date: new Date()};
  }

  componentDidMount() {
    this.timerID = setInterval(
      () => this.tick(),
      1000
    );
  }

  componentWillUnmount() {
    clearInterval(this.timerID);
  }

  tick() {
    this.setState({
      date: new Date()
    });
  }

  render() {
    return (
      <div>
        <h1>Hello, world!</h1>
        <h2>It is {this.state.date.toLocaleTimeString()}.</h2>
      </div>
    );
  }
}

ReactDOM.render(
  <Clock />,
  document.getElementById('root')
);

[JAVA] Selenium 네이버 블로그 서로이웃추가 자동화 프로그램

kwoss2341 — Sun, 19 Jun 2022 11:53:41 +0900

네이버 블로그 서로이웃추가 자동화 프로그램을 만들어보자.

먼저 개발환경을 세팅하는 방법은 여기서...

https://kwonik2304.tistory.com/52

[JAVA] Selenium - 개발 환경 세팅

1. pom.xml 추가 (최신버전: 4.1.4 추가. 해당 링크에서 원하는 버전 조회하여 추가) org.seleniumhq.selenium selenium-java 4.1.4 2. 크롬 드라이버 다운로드 https://chromedriver.chromium.org/downloads Chro..

kwonik2304.tistory.com

우선 Selenium 을 이용하기에 앞서 웹 분석이 필요하다.

분석은 크게 프로그램 동작과 동작에 필요한 각각의 요소에 대한 분석이 필요하다.

동작은 사용자의 event ( click, input, wait, get 등)

웹 요소분석은 event가 이루어질 웹 요소를 분석한다.

해당 코드는 네이버 로딩 후

로그인 클릭 후

일정시간동안 사용자가 로그인하기를 대기한 후 블로그 페이지 까지 이동하는 코드이다.

String url = "https://www.naver.com/";

//1. 네이버 페이지 로딩
driver.get(url);
Thread.sleep(delay);

//2. 로그인 클릭
element = driver.findElement(By.cssSelector("#account > a"));
element.click();
Thread.sleep(delay*4);

//3. 블로그 페이지 이동
driver.get("https://section.blog.naver.com/BlogHome.naver?directoryNo=0&currentPage=1&groupId=0");
Thread.sleep(delay);

여기서 click 이벤트를 수행하는 요소를 찾기 위해서 css 선택자를 이용한 모습을 볼 수 있다.

요소를 찾기위한 방법은 xpath, css selector, id, class name 등 많은 방법이 있다.

해당 요소를 개발자 모드를 이용하여 분석한 후 가장 적합한 방법을 이용하면 된다.

블로그 페이지로 이동했다면 이웃추가 버튼을 클릭하여 서로이웃추가 하는 작업을 수행한다.

하지만 여기서 반복 수행에 대한 문제가 생긴다...

1. 해당 페이지 내의 모든글에 대해 이웃추가 버튼을 클릭 반복 수행.

2. 1번 반복 완료 후 하단 1~10페이지 클릭 반복수행

3. 2번 반복 완료 후 다음버튼 클릭

반복을 위해서는 해당 요소를 찾아 그 요소만큼 반복적으로 수행해야 한다.

그러기 위해서는 ChromeDriver 의 findElements 메소드를 이용하여 공통된 특징을 가진 요소드를 찾은 후 반복한다.


List<WebElement> pageButtons = driver.findElements(By.cssSelector("#content > section > div:nth-child(3) > div > span > a")) ;
for(int i=1; i<10; i++)
{
	getList(driver);
	element=pageButtons.get(i);
	element.click();
	Thread.sleep(delay);
}
	
element = driver.findElement(By.cssSelector("#content > section > div:nth-child(3) > div > a"));
element.click();
Thread.sleep(delay);

이러한 방식으로 반복적으로 서로이웃신청이 가능하다.

하지만 실제 이웃추가 버튼을 클릭하게 되면....

이러한 팝업창이 나온다..

해당 팝업창에서 driver 동작이 이루어 져야한다.

그러기 위해서 driver의 switchTo 메소드를 이용하여 해당 팝업으로 전환 후

동작들이 이루어 져야한다.

static void clickAddNeighbor(ChromeDriver driver) throws InterruptedException
	{
		String MainWindow = driver.getWindowHandle();
		Set<String> s1= driver.getWindowHandles();
		Iterator<String> i1= s1.iterator();
		
		while(i1.hasNext()){
			String ChildWindow = i1.next();
			
			if(!MainWindow.equalsIgnoreCase(ChildWindow)){
				driver.switchTo().window(ChildWindow);
				//팝업창에서의 동작 구현...
			}
		}
		
		
		driver.switchTo().window(MainWindow);

		
	}

코드와 같이 MainWindow 를 저장 후 하위 window로 이동하여 동작을 수행하면 된다.

동작이 끝나면 다시 MainWindow 로 돌아와서 이웃추가를 반복 수행하여야 한다.

해당 작업을 수행하는 전체 코드이다.

public class SeleniumMain {

	public static String WEB_DRIVER_ID = "webdriver.chrome.driver";
	public static String WEB_DRIVER_PATH = "chromedriver.exe";
	public static int delay = 3;
	public static WebElement element;
	

	public static void main(String[] args) throws InterruptedException, IOException {
		
		
		// TODO Auto-generated method stub
		System.setProperty(WEB_DRIVER_ID, WEB_DRIVER_PATH);
		
		
		ChromeOptions options = new ChromeOptions();
		options.addArguments("--disable-popup-blocking");
		options.addArguments("--start-maximized");
		options.addArguments("--window-size=1920,1080");
		
		ChromeDriver driver = new ChromeDriver(options);
		
		try {
			start(driver);
			
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally{
			driver.quit();
		}
		
		
		
		
		
		
		
		

	}
	
	
	
	static void start(ChromeDriver driver) throws InterruptedException
	{
		String url = "https://www.naver.com/";
		
		
		driver.get(url);
		Thread.sleep(delay);
	
		element = driver.findElement(By.cssSelector("#account > a"));
		element.click();
		Thread.sleep(delay*4);

		
		driver.get("https://section.blog.naver.com/BlogHome.naver?directoryNo=0&currentPage=1&groupId=0");
		Thread.sleep(delay);
		
		
		
		
		while(true)
		{
			List<WebElement> pageButtons = driver.findElements(By.cssSelector("#content > section > div:nth-child(3) > div > span > a")) ;
			for(int i=1; i<10; i++)
			{
				getList(driver);
				element=pageButtons.get(i);
				element.click();
				Thread.sleep(delay);
			}
			
			element = driver.findElement(By.cssSelector("#content > section > div:nth-child(3) > div > a"));
			element.click();
			Thread.sleep(delay);
		}
		
		
		

		
		
	}
	
	static void getList(ChromeDriver driver) throws InterruptedException
	{
		WebElement element;
		
		//목록찾기
		List<WebElement> elements = driver.findElements(By.cssSelector("a.button_buddy.button_buddy_add"));
		Thread.sleep(delay);
		
		for(WebElement el : elements)
		{
			el.click();
			Thread.sleep(delay);
			
			clickAddNeighbor(driver);
			Thread.sleep(delay);
		}

	}

	
	
	static void clickAddNeighbor(ChromeDriver driver) throws InterruptedException
	{
		String MainWindow = driver.getWindowHandle();
		Set<String> s1= driver.getWindowHandles();
		Iterator<String> i1= s1.iterator();
		
		while(i1.hasNext()){
			String ChildWindow = i1.next();
			
			if(!MainWindow.equalsIgnoreCase(ChildWindow)){
				driver.switchTo().window(ChildWindow);
				String name=null;
				try {
					element = driver.findElement(By.cssSelector("#content > div > form > fieldset > div.popup_text > div.buddy_state > p.text_buddy_add > strong"));
					name=element.getAttribute("innerHTML");
					
					element = driver.findElement(By.cssSelector("#content > div > form > fieldset > div.popup_text > div.buddy_state > p > span.wrap_radio.radio_bothbuddy > label"));
					element.click();
					Thread.sleep(delay);
					
					element = driver.findElement(By.cssSelector("#content > div > form > fieldset > div.area_button > a.button_next._buddyAddNext"));
					element.click();
					Thread.sleep(delay);
					
					element = driver.findElement(By.cssSelector("#message"));
					if(name!=null)
					{
						element.sendKeys(name+"님! 글 재밌게봤습니다^^ 서로이웃 추가 해요 ㅎㅎ");
					}
					else
					{
						element.sendKeys("글 재밌게봤습니다^^ 서로이웃 추가 해요 ㅎㅎ");
					}
					Thread.sleep(delay);
					
					
					element = driver.findElement(By.cssSelector("body > form > div > div > fieldset > div.area_button > a.button_next._addBothBuddy"));
					element.click();
					Thread.sleep(delay);
					
					System.out.println("["+name+"] 서로이웃추가 신청완료");
					driver.close();
				}
				catch(UnhandledAlertException e)
				{
					System.out.println("["+name+"] 이미 서로이웃추가신청된 계정.");
				}
				catch(Exception e)
				{
					System.out.println("["+name+"] 서로이웃추가 비활성 계정");	
					driver.close();
				}
				finally
				{
					
				}

				
				
			}
		}
		
		
		driver.switchTo().window(MainWindow);

		
	}
}

[JAVA] Selenium - 개발 환경 세팅

kwoss2341 — Sun, 1 May 2022 14:49:36 +0900

1. pom.xml 추가

(최신버전: 4.1.4 추가. 해당 링크에서 원하는 버전 조회하여 추가)

	<!-- https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-java -->
	<dependency>
	    <groupId>org.seleniumhq.selenium</groupId>
	    <artifactId>selenium-java</artifactId>
	    <version>4.1.4</version>
	</dependency>

2. 크롬 드라이버 다운로드

https://chromedriver.chromium.org/downloads

ChromeDriver - WebDriver for Chrome - Downloads

Current Releases If you are using Chrome version 101, please download ChromeDriver 101.0.4951.41 If you are using Chrome version 100, please download ChromeDriver 100.0.4896.60 If you are using Chrome version 99, please download ChromeDriver 99.0.4844.51 F

chromedriver.chromium.org

크롬 브라우저 버전과 맞는 드라이버를 다운로드.

(크롬 브라우저:101.0.4951.41, 크롬 드라이버:101.0.4951.41)

3. TEST

public class SeleniumMain {
	
	public static String WEB_DRIVER_ID = "webdriver.chrome.driver";
	public static String WEB_DRIVER_PATH = "chromedriver.exe";
	
	public static String url = "https://www.hometax.go.kr/";
	
	
	public static void main(String[] args) throws InterruptedException {
		
		
		System.setProperty(WEB_DRIVER_ID, WEB_DRIVER_PATH);
		ChromeDriver driver = new ChromeDriver();
		driver.get(url);

		Thread.sleep(10000);
		driver.quit();

	}

}

다운로드 받은 드라이버는 WEB_DRIVER_PATH에서 경로를 설정.

국세청 홈텍스 접속 확인

[프로그래머스][BFS/DFS] 단어 변환 c++

kwoss2341 — Tue, 7 Sep 2021 22:37:38 +0900

https://programmers.co.kr/learn/courses/30/lessons/43163#

코딩테스트 연습 - 단어 변환

두 개의 단어 begin, target과 단어의 집합 words가 있습니다. 아래와 같은 규칙을 이용하여 begin에서 target으로 변환하는 가장 짧은 변환 과정을 찾으려고 합니다. 1. 한 번에 한 개의 알파벳만 바꿀 수

programmers.co.kr

기본적인 아이디어.

1. 단어에 한 문자만 틀리면 엣지를 연결하는 그래프를 생성한다.

2. 해당 그래프를 BFS(DFS역시 가능)를 이용하여 begin 과 target 사이 최단 거리(엣지 개수)를 구한다.

#include <string>
#include <vector>
#include <iostream>
#include <queue>
using namespace std;

bool onecheck(string a, string b)
{
    int x=0;
    for(int i=0; i<a.size(); i++)
    {
        if(a[i]!=b[i])
        {
            x++;
        }
        
        if(x>1) break;
    }
    
    if(x>1) return 0;
    else if(x==1) return 1;
}

int solution(string begin, string target, vector<string> words) {
    int answer = 0;
    int n=begin.size();
    
    int zz=0;

    
    
    words.insert(words.begin(), target);
    words.insert(words.begin(), begin);
    int size=words.size();
    
    queue <int> q;
    vector <int> w[size];
    int visit[size];
    int d[size];
    
    
    
    
    for(int i=0; i<size; i++)
    {
        for(int j=0; j<size; j++)
        {
            if(i==j) continue;
            
            if(onecheck(words[i] , words[j]))
            {
                w[i].push_back(j);
            }
        }
    }
    
    for(int i=0; i<size; i++)
    { 
        visit[i]=0;
        d[i]=0;
    }

        int start;
        int i=0;

        start=i;
        while(1) 
        {
            
            visit[start]=1;
            for(int j=0; j<w[start].size(); j++)
            {
                if(visit[w[start][j]]==1) continue;
                
                
                                
                q.push(w[start][j]);
                d[w[start][j]]=d[start]+1;
                
                if(w[start][j]==1) return d[start]+1;
            }
            
            if(q.empty())
            {
                answer = 0;
                break;    
            }
            
            
            
            start=q.front();
            q.pop();
        }
        
        
        
    
    
    
    return answer;
}

프로그래머스 단어 변환 실행시간

[프로그래머스] 카카오 순위 검색 c++

kwoss2341 — Sun, 5 Sep 2021 23:49:21 +0900

https://programmers.co.kr/learn/courses/30/lessons/72412

코딩테스트 연습 - 순위 검색

["java backend junior pizza 150","python frontend senior chicken 210","python frontend senior chicken 150","cpp backend senior pizza 260","java backend junior chicken 80","python backend senior chicken 50"] ["java and backend and junior and pizza 100","pyt

programmers.co.kr

기본적인 아이디어.

1. 나올수 있는 모든경우의수 4(java,cpp,python,-) *3(back,front,-) *3(chicken, pizza, -) 벡터 배열을 만들어 점수를

push_back하여 해당 조건을 검색한다.

2. 점수를 push_back한 배열을 정렬한다.

3. 정렬한 배열을 이분탐색으로 조건의 점수 이상인 사람을 탐색하여 시간을 줄인다.

(하지만 정렬하지않고 이분탐색을 하지 않아도 500ms시간안으로 통과 된다.. )

#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int as;
vector<int> solution(vector<string> info, vector<string> query) {
    vector<int> answer;
    
    vector<int> countn[5][4][4][4];
    
    
    
    for(int i=0; i<info.size(); i++)
    {
        int j;
        int a=0;
        int b,c,d;
        int an,bn,cn,dn;
        for(j=0; j<info[i].size(); j++)
        {
            if(info[i][j]==' ')
            {
                break;
            }
        }
        
        
        if(info[i][a]=='c')
        {
            an=1;
        }
        else if(info [i][a]=='j')
        {
            an=2;
        }
        else
        {
            an=3;
        }
        
        
        b=j+1;
        for(j=b; j<info[i].size(); j++)
        {
            if(info[i][j]==' ')
            {
                break;
            }
        }
        
        if(info[i][b]=='b')
        {
            bn=1;
        }
        else
        {
            bn=2;
        }
        
        
        c=j+1;
        for(j=c; j<info[i].size(); j++)
        {
            if(info[i][j]==' ')
            {
                break;
            }
        }
        
        if(info[i][c]=='j')
        {
            cn=1;
        }
        else
        {
            cn=2;
        }
        
        
        d=j+1;
        for(j=d; j<info[i].size(); j++)
        {
            if(info[i][j]==' ')
            {
                break;
            }
        }
        
        if(info[i][d]=='c')
        {
            dn=1;
        }
        else
        {
            dn=2;
        }
        
        int score = stoi(info[i].substr(j+1));
        
        
        //무지성구간
        //몸이 나쁘면 머리가 고생한다 <안개특유>
        countn[an][bn][cn][dn].push_back(score);
        countn[0][bn][cn][dn].push_back(score);
        countn[an][0][cn][dn].push_back(score);
        countn[an][bn][0][dn].push_back(score);
        countn[an][bn][cn][0].push_back(score);
        countn[0][0][cn][dn].push_back(score);
        countn[0][bn][0][dn].push_back(score);
        countn[0][bn][cn][0].push_back(score);
        countn[an][0][0][dn].push_back(score);
        countn[an][0][cn][0].push_back(score);
        countn[an][bn][0][0].push_back(score);
        countn[0][0][0][dn].push_back(score);
        countn[0][bn][0][0].push_back(score);
        countn[0][0][cn][0].push_back(score);
        countn[an][0][0][0].push_back(score);
        countn[0][0][0][0].push_back(score);
        
      
    }
    
    
 
    for(int a=0; a<4; a++)
    {
        for(int b=0; b<3; b++)
        {
            for(int c=0; c<3; c++)
            {
                for(int d=0; d<3; d++)
                {
                    sort(countn[a][b][c][d].begin(),countn[a][b][c][d].end());
                }
            }
        }
    }
    
    
    
    
    for(int i=0; i<query.size(); i++)
    {
        int j;
        int a=0;
        int b,c,d;
        int an,bn,cn,dn;
        for(j=0; j<query[i].size(); j++)
        {
            if(query[i][j]==' ')
            {
                break;
            }
        }
        
        
        if(query[i][a]=='c')
        {
            an=1;
        }
        else if(query[i][a]=='j')
        {
            an=2;
        }
        else if(query[i][a]=='p')
        {
            an=3;
        }
        else
        {
            an=0;
        }
        
        
        b=j+5;
        for(j=b; j<query[i].size(); j++)
        {
            if(query[i][j]==' ')
            {
                break;
            }
        }
        
        if(query[i][b]=='b')
        {
            bn=1;
        }
        else if(query[i][b]=='f')
        {
            bn=2;
        }
        else
        {
            bn=0;
        }
        
        c=j+5;
        for(j=c; j<query[i].size(); j++)
        {
            if(query[i][j]==' ')
            {
                break;
            }
        }
        
        if(query[i][c]=='j')
        {
            cn=1;
        }
        else if(query[i][c]=='s')
        {
            cn=2;
        }
        else
        {
            cn=0;
        }
        
        
        d=j+5;
        for(j=d; j<query[i].size(); j++)
        {
            if(query[i][j]==' ')
            {
                break;
            }
        }
        
        if(query[i][d]=='c')
        {
            dn=1;
        }
        else if(query[i][d]=='p')
        {
            dn=2;
        }
        else
        {
            dn=0;
        }
        
        int score = stoi(query[i].substr(j+1));
        
        int start = 0;
        int end = countn[an][bn][cn][dn].size()-1;
        int mid = 0;
        while (start <= end || start<0 )
        {
            mid = (start+end) / 2;
            if (countn[an][bn][cn][dn][mid] == score)
                break;
            else {
                if (countn[an][bn][cn][dn][mid] < score)
                    start = mid+1;
                else if (countn[an][bn][cn][dn][mid] > score)
                    end = mid-1;
            }
        }
        
        
        
        if(countn[an][bn][cn][dn].size()==0)
        {
            answer.push_back(0);
            continue;
        }
        
        
        if(countn[an][bn][cn][dn][mid]>=score)
        {
           
            
            for(mid; mid>=0; mid--)
            {
                if(countn[an][bn][cn][dn][mid]<score)
                {                    
                    break;
                }
            }
            
            
            if(mid<0)
            {
                 answer.push_back(countn[an][bn][cn][dn].size());
            }
            else
            {
                answer.push_back(countn[an][bn][cn][dn].size()-(mid+1));
            }
            
        }
        else
        {
            int sw=0;
            for(mid; mid<countn[an][bn][cn][dn].size(); mid++)
            {
                if(countn[an][bn][cn][dn][mid]>=score)
                {    
                    sw=1;
                    break;
                }
            }
            
            if(sw==1)
            {
                answer.push_back(countn[an][bn][cn][dn].size()-mid);
            }
            else
            {
                answer.push_back(0);
            }
            
        }
        
        
    }
    

    
    return answer;
}

카카오 순위 검색 실행시간

[디자인 패턴 C++] 추상 팩토리 패턴

kwoss2341 — Mon, 9 Aug 2021 23:57:02 +0900

의도

상세화된 서브클래스를 정의하지 않고도 서로 관련성이 있거나 독립적인 여러 객체의 군을 생성하기 위한 인터페이스를 제공합니다.

구조

참여자

-AbstractFactory : 객체(제품)을 생성하는 연산을 추상화 시킨다.

-ConcreteFactory : virtual로 추상화 되어있는 CreateProductA(),CreateProductB() 메소드를 구체화하여 객체를 생성하는 연산을 수행한다.

-AbstractProduct : 제품을 추상화 시킨다.

( Client 코드에서 const AbstractProductA *product_a =factory.CreateProductA(); )

- ConcreteProduct : AbstractProduct가 정의하는 인터페이스 구현. 구체으로 팩토리가 생성할 객체.

- Client : AbstractFactory, AbstractProduct 클래스에 선언된 인터페이스를 사용.

( ConcreteFactory 클래스를 생성해서

AbstractFactory의 인터페이스 CreatProductA() 메소드 사용,

AbstractProduct를 이용 일관성 유지 )

코드

(추상 팩토리 패턴 이해가 어려워 많은 코드를 찾아보던 중 가장 정리가 잘된 코드를 찾았다)

출처 https://refactoring.guru/design-patterns/abstract-factory/cpp/example

Design Patterns: Abstract Factory in C++

/ Design Patterns / Abstract Factory / C++ Abstract Factory in C++ Abstract Factory is a creational design pattern, which solves the problem of creating entire product families without specifying their concrete classes. Abstract Factory defines an interfac

refactoring.guru

/**
 * Each distinct product of a product family should have a base interface. All
 * variants of the product must implement this interface.
 */
class AbstractProductA {
 public:
  virtual ~AbstractProductA(){};
  virtual std::string UsefulFunctionA() const = 0;
};

/**
 * Concrete Products are created by corresponding Concrete Factories.
 */
class ConcreteProductA1 : public AbstractProductA {
 public:
  std::string UsefulFunctionA() const override {
    return "The result of the product A1.";
  }
};

class ConcreteProductA2 : public AbstractProductA {
  std::string UsefulFunctionA() const override {
    return "The result of the product A2.";
  }
};

/**
 * Here's the the base interface of another product. All products can interact
 * with each other, but proper interaction is possible only between products of
 * the same concrete variant.
 */
class AbstractProductB {
  /**
   * Product B is able to do its own thing...
   */
 public:
  virtual ~AbstractProductB(){};
  virtual std::string UsefulFunctionB() const = 0;
  /**
   * ...but it also can collaborate with the ProductA.
   *
   * The Abstract Factory makes sure that all products it creates are of the
   * same variant and thus, compatible.
   */
  virtual std::string AnotherUsefulFunctionB(const AbstractProductA &collaborator) const = 0;
};

/**
 * Concrete Products are created by corresponding Concrete Factories.
 */
class ConcreteProductB1 : public AbstractProductB {
 public:
  std::string UsefulFunctionB() const override {
    return "The result of the product B1.";
  }
  /**
   * The variant, Product B1, is only able to work correctly with the variant,
   * Product A1. Nevertheless, it accepts any instance of AbstractProductA as an
   * argument.
   */
  std::string AnotherUsefulFunctionB(const AbstractProductA &collaborator) const override {
    const std::string result = collaborator.UsefulFunctionA();
    return "The result of the B1 collaborating with ( " + result + " )";
  }
};

class ConcreteProductB2 : public AbstractProductB {
 public:
  std::string UsefulFunctionB() const override {
    return "The result of the product B2.";
  }
  /**
   * The variant, Product B2, is only able to work correctly with the variant,
   * Product A2. Nevertheless, it accepts any instance of AbstractProductA as an
   * argument.
   */
  std::string AnotherUsefulFunctionB(const AbstractProductA &collaborator) const override {
    const std::string result = collaborator.UsefulFunctionA();
    return "The result of the B2 collaborating with ( " + result + " )";
  }
};

/**
 * The Abstract Factory interface declares a set of methods that return
 * different abstract products. These products are called a family and are
 * related by a high-level theme or concept. Products of one family are usually
 * able to collaborate among themselves. A family of products may have several
 * variants, but the products of one variant are incompatible with products of
 * another.
 */
class AbstractFactory {
 public:
  virtual AbstractProductA *CreateProductA() const = 0;
  virtual AbstractProductB *CreateProductB() const = 0;
};

/**
 * Concrete Factories produce a family of products that belong to a single
 * variant. The factory guarantees that resulting products are compatible. Note
 * that signatures of the Concrete Factory's methods return an abstract product,
 * while inside the method a concrete product is instantiated.
 */
class ConcreteFactory1 : public AbstractFactory {
 public:
  AbstractProductA *CreateProductA() const override {
    return new ConcreteProductA1();
  }
  AbstractProductB *CreateProductB() const override {
    return new ConcreteProductB1();
  }
};

/**
 * Each Concrete Factory has a corresponding product variant.
 */
class ConcreteFactory2 : public AbstractFactory {
 public:
  AbstractProductA *CreateProductA() const override {
    return new ConcreteProductA2();
  }
  AbstractProductB *CreateProductB() const override {
    return new ConcreteProductB2();
  }
};

/**
 * The client code works with factories and products only through abstract
 * types: AbstractFactory and AbstractProduct. This lets you pass any factory or
 * product subclass to the client code without breaking it.
 */

void ClientCode(const AbstractFactory &factory) {
  const AbstractProductA *product_a = factory.CreateProductA();
  const AbstractProductB *product_b = factory.CreateProductB();
  std::cout << product_b->UsefulFunctionB() << "\n";
  std::cout << product_b->AnotherUsefulFunctionB(*product_a) << "\n";
  delete product_a;
  delete product_b;
}

int main() {
  std::cout << "Client: Testing client code with the first factory type:\n";
  ConcreteFactory1 *f1 = new ConcreteFactory1();
  ClientCode(*f1);
  delete f1;
  std::cout << std::endl;
  std::cout << "Client: Testing the same client code with the second factory type:\n";
  ConcreteFactory2 *f2 = new ConcreteFactory2();
  ClientCode(*f2);
  delete f2;
  return 0;
}

정리

- 말그대로 팩토리는 공장이다. 객체를 생성하는 공장이다.

- AbstractFactory가 제시한 인터페이스를 ConcreteFactory가 구체화 하여 어떤 A제품을 createProductA()할건지 정의한다.

- AbstractProduct가 정의한 인터페이스는 제품의 특성에따라 ConcreteProduct에서 구체화 될 수 있다.

- Client는 ClientCode() 함수를 통해 실제 팩토리에서 어떤 제품이 생성되는지 관여하지 않아도 된다.

[Qt 프로그래밍] [크로스컴파일] Linux Sqlite db 조회

kwoss2341 — Sat, 5 Jun 2021 17:05:30 +0900

pro 파일에 sql 추가해준다

QT +=

sql

QtSql inlcude 한다

#include <QtSql>



    QSqlDatabase db;
    db = QSqlDatabase::addDatabase("QSQLITE");
    db.setDatabaseName("/usr/local/app/my.db"); //db 경로

    QString strQry = "PRAGMA synchronous = OFF;"; // 디스크 동기화 사용여부

    if(!db.open()) {
            qDebug() << QString("<FAILED> Connect to DB: %1") .arg("/usr/local/app/my.db");
            abort();
        }


    QSqlQuery qry(db);
    qry.clear();
    qry.prepare(strQry);
    if(!qry.exec()) {
        qDebug() << QString("<SQL FAILED> %1") .arg(strQry);
        qDebug() << QString("<SQL FAILED> %1") .arg(qry.lastError().text());
    }
    else {
        qDebug() << QString("<SQL SUCCEED> %1") .arg(strQry);
    }

	
    
    
   
    QString szQry;
    QString szVal, szType, szTgtIP, szVarNm, szValOld, szDec;
    
    szQry = QString("select * from tb_evm_mst where set_target_ip='%1';") .arg(""); //조회쿼리


    qry.prepare(szQry);


    if(!qry.exec()) {
            qDebug() << QString("<SQL FAILED> %1") .arg(szQry);
            qWarning() << QString("<SQL FAILED> %1") .arg(qry.lastError().text());
            return false;
        }

    
    
    
    while(qry.next()) {
            szVal = qry.record().value("set_val").toString();
            szValOld = qry.record().value("set_val_old").toString();
            szVarNm = qry.record().value("set_var_nm").toString();

            szType = qry.record().value("set_type").toString();
            szDec = qry.record().value("set_dec").toString();
            szTgtIP = qry.record().value("set_target_ip").toString();

          
            qDebug()<<szVal<<" "<<szValOld<<" "<<szVarNm<<" "<<szType<<" "<<szDec<<" "<<szTgtIP;
        }