1. Cerbot 설치

sudo yum install certbot

yum 패키지 관리자를 이용해서 Cerbot 설치를 한다.

2. SSL 인증서 발급

sudo certbot certonly --standalone -d demo.내도메인.com

cerbot 을 통해서 demo.내도메인.com 도메인에 대한 SSL 인증서를 발급받았다. standalone 모드로 인증서를 발급 받기위해서 기존에 돌아가고 있던 Tomcat, nginx 를 중지한다.

*standalone 모드 *: Cerbot이 자체적으로 간단한 웹 서버를 실행하여 Let's Encrypt 인증 과정을 처리하는 방식이다. 이때는 Cerbot이 Http-01 챌린지(포트80)을 통해 도메인 소유 여부를 확인한다.

3. Tomcat에 사용할 keystore 생성

sudo openssl pkcs12 -export -in /etc/letsencrypt/live/demo.내도메인.com/fullchain.pem \
    -inkey /etc/letsencrypt/live/demo.내도메인.com/privkey.pem \
    -out /etc/letsencrypt/live/demo.내도메인.com/keystore.p12 \
    -name tomcat -CAfile /etc/letsencrypt/live/demo.내도메인.com/chain.pem -caname root

Tomcat에서 인증서를 사용하기 위해 openssl 을 사용하여 인증서와 개인 키 파일을 PKCS#12 형식(keystore.p12)로 변환해주었다.

비밀번호는 server.xml 에서 쓰일거니깐 입력하고, 비밀번호 확인부분도 동일하게 입력만 해주면 된다.

4. Tomcat 설정 (server.xml) 구성

<Connector port="443" protocol="org.apache.coyote.http11.Http11NioProtocol"
           maxThreads="150" SSLEnabled="true">
    <SSLHostConfig>
        <Certificate certificateKeystoreFile="/etc/letsencrypt/live/demo.내도메인.com/keystore.p12"
                     type="RSA"
                     certificateKeystorePassword="설정한 비밀번호" />
    </SSLHostConfig>
</Connector>

Https 커넥터를 추가하고 keystore 파일 경로와 비밀번호를 설정해준다.

<Connector port="80" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="443" />

이제 포트80요청을 HTTPS로 리다이렉트하도록 추가만 하면 끝!

Tomcat을 재시작하고 HTTPS가 적용되었는지 확인해보자.

추가+ (자동 갱신 설정)

음 추가로 Let's Encrypt의 인증서는 유효기간이 90일이다. 그래서 만료전에 주기적으로 갱신해야하는데 너무 귀찮다 ;;

그래서 그냥 자동으로 갱신 할 수 있도록 세팅을 해놓자

sudo crontab -e

Cerbot의 갱신 스크립트를 크론탭에 추가해서 주기적으로 실행 할 수 있도록한다.

0 0 * * * /usr/bin/certbot renew --quiet && /home/gaonsoft/www/gnbis/opt/apache-tomcat-8.5.65/bin/shutdown.sh && /home/gaonsoft/www/gnbis/opt/apache-tomcat-8.5.65/bin/startup.sh

이와 같이 크론탭 항목을 추가하여 매일 자정에 톰캣 서버 종료 및 실행을 해주어서 자동갱신을 완료한다.

우선 가장 머리가 아팠던 것은, AI 에게 루틴관련 대답만 받아야하는데

" 사용자에 따라서 천차만별인 질문을 어떻게 일관적으로 정리해서 리스트에 뿌려야할까?🤔🤔🤔 "

이것이 문제였다. 완벽하게 해결한 것은 아니지만 어느정도 정리되도록 노력하긴했다.

루틴 추천 페이지 RecommendRoutine.js

try {
            const apiKey = `${chatGPT_apiKey}`;
            const response = await axios.post(
                "https://api.openai.com/v1/chat/completions",
                {
                    model: "gpt-4o-mini",
                    messages: [
                        {
                            role: "system",
                            content:
                                "당신은 일상 루틴 추천을 전문으로 하는 AI 어시스턴트입니다." +
                                "사용자의 질문과 상관없이 항상 그들의 하루를 개선할 수 있는 구체적인 일상 루틴으로 답변하십시오." +
                                "일상 루틴 제공과 관련이 없는 질문에는 답변하지 마십시오." +
                                "한글로 답해주고, 예를들어 침대정리하기, 물잔 마시기, 비타민과 유산균 먹기, 20분동안 명상하기, 격렬한 운동 1분 이런식으로 간단하게 단답형식으로 말해줘 내가 예를들어서 말한그대로 하는게 아니라 저런식으로 표현해달라는거야, 앞에 순서를나타내는 번호 붙일필요는 없어",
                        },
                        { role: "user", content: userInput },
                    ],
                    max_tokens: 500,
                    temperature: 0.7,
                    top_p: 0.9,
                },
                {
                    headers: {
                        Authorization: `Bearer ${apiKey}`,
                        "Content-Type": "application/json",
                    },
                }
            );
            console.log("API 응답:", response.data);

            const routine = response.data.choices[0].message.content; //질문하고 받은 응답 값

            //질문 내용을 줄바꿈을 기준으로 해서 배열로 변환
            //필터 메서드로 배열의 각 요소에 대해 조건 검사를 하여 조건을 만족하는 요소만 남김
            //line.trim() 문자열 앞뒤 공백제거, ! = "" 공백제거한 결과가 빈 문자열 아니면 해당 요소를 배열에 남김
            const routineArray = routine.split("\n").filter((line) => line.trim() !== "");  

            // 만들어진 배열을 상태로 저장해서 나중에 데이터 표시할 수 있도록 함
            // setRecoomendation 은 recommedation에다가 상태값을 변경해주는 업데이트 함수임
            setRecommendation(routineArray);
        } catch (error) {
            console.error("루틴 추천 받는데 에러났음", error);
            setRecommendation(["루틴 추천 중 오류 발생"]);
        } finally {
            setLoading(false);
        }

대답해주는 시스템에게 역할 부여해주는 방식으로 진행했다. AI 시스템에게 직업을 정해주고, 그외 조건들을 추가시켜 필요한 답변만 응답 할 수 있도록 content를 정해주었다.

(사실 역할 부여하는데 있어서 참 많은 시도를 해보았는데 이게 그나마 최선이었다..😭 더 좋은 방법이 있다면 누군가 좀 알려주세요...)

추가로 대답해준 내용을 배열처리해서 그거를 리스트로 보여주기 위한 작업을 했다.

const [recommendation, setRecommendation] = useState([]);

const routine = response.data.choices[0].message.content; //질문하고 받은 응답 값

            //질문 내용을 줄바꿈을 기준으로 해서 배열로 변환
            //필터 메서드로 배열의 각 요소에 대해 조건 검사를 하여 조건을 만족하는 요소만 남김
            //line.trim() 문자열 앞뒤 공백제거, ! = "" 공백제거한 결과가 빈 문자열 아니면 해당 요소를 배열에 남김
            const routineArray = routine.split("\n").filter((line) => line.trim() !== "");  

            // 만들어진 배열을 상태로 저장해서 나중에 데이터 표시할 수 있도록 함
            // setRecoomendation 은 recommedation에다가 상태값을 변경해주는 업데이트 함수임
            setRecommendation(routineArray);

routine 에다가 질문하고 응답한 값을 할당해주고 응답값을 줄바꿈을 기준으로해서 배열로 변환해준다.

배열값(routineArray)을 setRecommendation() 함수를 이용해서 recommendation에다가 상태값을 업데이트 시켜준다. 그럼 처음에는 빈 값이던 recommendation이 질문 후에는 업데이트 되어서 루틴 배열이 담기게 된다.

자 이제 화면에 뿌려줘야 겠지?

<ScrollView>
  {recommendation.length > 0 ? (
      recommendation.map((routine, index) => (        //map() 으로 배열의 각 요소를 순회하면 새로운 컴포넌트 생성
           <TouchableOpacity key={index} style={styles.aiList}
              onPress={() => handleRoutineSelect(routine)}
           >
              <Image
                 style={[styles.aiListIcon]}
                 source={require("../../../assets/img/ic_checked_03.png")}
              ></Image>
              <Text style={styles.aiListText}>{routine}</Text>
           </TouchableOpacity>
    ))
    ) : (
        <Text></Text>
    )}
</ScrollView>

처음 렌더링 때는 recommendation 상태 값이 비어있으니 아무것도 나오지 않을 것이고 질문 후 상태 값이 업데이트가 될 것이다 map() 함수를 이용해서 배열의 각 요소를 순회하면서 리스트를 뿌려준다.

콘솔에다가 routine 과 index를 찍어보면 해당 값이 나온다.

첫 번째 순회:
routine = "침대 정리하기"
index = 0
두 번째 순회:
routine = "물잔 마시기"
index = 1
세 번째 순회:
routine = "비타민과 유산균 먹기"
index = 2

추천만 해주면 사용자가 좋아할까? 내 루틴으로 바로 추가할 수 있게 해주면 더 좋아하겠지? ㅎㅋ

const navigation = useNavigation();

const handleRoutineSelect = (routine) => {
        navigation.navigate("AddRoutine", {selectedRoutine: routine});
};

리스트를 클릭하면 AddRoutine 페이지로 루틴데이터를 가지고 넘어가보자

루틴 추가 페이지 AddRoutine.js

route 객체를 통해서 전달된 데이터에 접근해보자!

const route = useRoute();

useEffect(() => {
        if (route.params?.selectedRoutine) {
            setRoutineName(route.params.selectedRoutine);
        }
    }, [route.params?.selectedRoutine]); 

    <RoutineInput
      placeholder="루틴을 입력해주세요"
      value={routineName}
      onChangeText={setRoutineName}
      onPress={navigateToRecommendRoutine}
      buttonImage={require("../../../assets/img/ic_ai.png")} // 아이콘 이미지를 props로 전달
    />

추천페이지에서 selectedRoutine 에다가 선택한 루틴을 넣어서 AddRoutine으로 넘기고 루틴추가페이지에서 route로 접근해서 잘넘겨주었다

🥲 AI 사용법에 대해서 더 좋은 방법을 아는 고수들이 있다면 공유 부탁드립니다 ㅜ

쨋든 ! 처음보다는 훨나아진 루틴 추천 및 추가 작업 과정이었다..

1. useState(상태관리)

useState는 컴포넌트의 상태를 관리하는데 사용된다. 상태가 변경되면 다시 렌더링된다.

import React, { useState } from 'react';
import { Text, Button, View } from 'react-native';

function Counter() {
  const [count, setCount] = useState(0); // count라는 상태와, setCount라는 상태를 변경하는 함수가 생김

  return (
    <View>
      <Text>Count: {count}</Text>
      <Button title="Increase" onPress={() => setCount(count + 1)} />
    </View>
  );
}

위에 코드로 정리를 하자면 count : 컴포넌트에서 관리하고자 하는 상태 값을 나타낸다. setCount : 상태를 변경할 수 있는 함수이다. 이 함수가 호출되면 상태가 변경되고 컴포넌트가 다시 렌더링된다. useState(0) : 0은 상태의 초기값이다. 컴포넌트가 처음 렌더링될 때 이값으로 상태가 설정된다.

처음화면이 렌더링되면 0으로 시작해서, 버튼을 클릭해 setCount 함수가 작동하면 상태가 변경되어 재렌더링이 된다.

useState는 초기 상태값으로 기본 데이터타입 뿐만 아니라 함수나 객체도 사용할 수 있다.

기본값 예시

const [count, setCount] = useState(0); // 숫자형 초기 값
const [name, setName] = useState(''); // 문자열 초기 값
const [isVisible, setIsVisible] = useState(false); // 불리언 초기 값

객체나 배열을 초기 값으로 설정한 예시

const [user, setUser] = useState({ name: 'John', age: 25 });
const [items, setItems] = useState([1, 2, 3]);

상태변경이 리렌더링을 유발하는 이유

useState로 상태가 변경되면 리액트는 그 상태가 변경되었음을 감지하고, 해당 컴포넌트만 다시 렌더링한다. 가상 DOM 매커니즘에 따라, 변경된 부분만 다시 그려지기 때문에 성능이 최적화된다.

useState 요약

• useState는 함수형 컴포넌트에서 상태를 관리할 수 있게 해주는 기본 훅이다.
• setState 함수는 상태를 변경하고 컴포넌트를 리렌더링 하는 역할을 한다.
• 복잡한 객체나 배열을 관리할 때는 불변성을 유지하면서 상태를 업데이트해야한다.
• 상태 업데이트는 비동기적으로 처리된다.

2. useEffect(부수효과)

useEffect는 부수효과(side effect)를 처리하기 위해 사용되는 훅이다. 부수효과란 컴포넌트가 리렌더링될 때마다 발생하는 비동기 작업이나 DOM 조작, 외부 데이터를 가져오는 등의 작업을 의미한다.

컴포넌트의 라이프사이클 메서드인 componentDidMount, componentDidUpdate, componentWillUnmount를 대체하는 역할을 한다.

useEffect(() => {
    //부수효과 코드
},[의존성배열]);

• 첫 번째 인자로 전달된 함수가 부수효과를 수행한다.
• 두 번째 인자로 의존성배열을 전달하면, 이 배열에 있는 값이 변경될 때만 부수효과가 실행한다. (의존성 배열을 사용하지 않으면 컴포넌트가 렌더링될때마다 useEffect 실행됨, 하단에 예시 있음)

부수효과 처리 타이밍

• 컴포넌트가 마운트될 때(처음 렌더링될 때)
• 컴포넌트가 업데이트될 때(상태나 props가 변경될 때)
• 컴포넌트가 언마운트될 때(화면에서 사라질 때)

의존성 배열 유무에 대한 예시

1) 의존성배열이 없는 경우

useEffect(() => {
  console.log('렌더링될 때마다 실행');
});

의존성 배열이 없는 경우, 컴포넌트가 렌더링될 때마다 useEffect가 실행됨, 상태나 props가 변경될 때마다 이 함수가 호출된다.

2) 의존성 배열이 빈 경우

useEffect(() => {
  console.log('마운트 시 한 번만 실행');
}, []); // 빈 배열

의존성 배열이 빈 배열이면, 컴포넌트가 마운트될 때 한번만 실행된다.

3) 의존성 배열에 값이 있는 경우

useEffect(() => {
  console.log('name이 변경될 때만 실행');
}, [name]); // name 상태가 변경될 때만 실행

의존성 배열에 특정 값(name)이 있으면, 해당 값이 변경될 때만 부수효과가 실행된다. 이를 통해 필요할때만 부수효과 실행가능

useEffect 요약

• useEffect는 부수효과를 처리하는 훅으로, 컴포넌트가 렌더링되거나 업데이트 될 때 동작한다.
• 의존성 배열을 사용하여 특정 값이 변경될 때만 실행할 수 있도록 제어 가능
• API 호출 및 이벤트리스너 관리 등 작업에 많이 사용됨

3. useRef(참조)

이 또한 리액트에서 많이 쓰이는 훅 중 하나로,** DOM 요소에 직접 접근하거나, **리렌더링과 관계없이 값을 유지하고 싶을때 사용된다. 이 훅은 참조(Reference)를 생성하며, 해당 참조값은 컴포넌트가 리렌더링되더라도 변하지 않고 유지하게 된다. 그렇기 때문에 DOM 조작이나 특정 값을 저장해두고 싶을 때 유용하다.

특징

• DOM 요소 접근 가능
• 리렌더링을 유발하지 않으면서 값 저장가능
• 리렌더링 하더라도 변하지 않는 참조 값 유지 가능
• 초기 값은 null로 설정할 수 있으며, DOM 요소나 변수를 참조할 때 값을 설정한다.

DOM 요소 접근

import React, { useRef } from 'react';

function TextInputWithFocusButton() {
  const inputRef = useRef(null); // 초기값으로 null 설정

  const handleButtonClick = () => {
    // useRef를 사용해 input DOM 요소에 직접 접근하여 포커스 설정
    inputRef.current.focus();
  };

  return (
    <div>
      <input ref={inputRef} type="text" />
      <button onClick={handleButtonClick}>포커스 주기</button>
    </div>
  );
}

• useRef(null)로 참조를 생성하고, <input>의 ref속성에 inputRef를 할당한다.
• inputRef.current는 <input>요소를 가리키게 되며, 이를 통해 focus() 메서드를 호출하여 해당 <input>에 포커스를 줄 수 있다.
• useRef로 DOM 을 참조해도 컴포넌트는 다시 렌더링 되지 않는다.

리렌더링과 관계없는 값 저장

useRef는 리렌더링과 관계없이 값을 유지할 수 있다. 컴포넌트가 렌더링 될 때마다 값이 변하지 않게 하려면 useRef를 사용할 수 있다. useRef의 current 값은 컴포넌트가 리렌더링 되어도 그대로 유지되며, 값을 변경해도 리렌더링을 유발하지 않는다.

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

function Timer() {
  const [count, setCount] = useState(0);
  const countRef = useRef(0); // 초기값 0 설정

  const incrementCount = () => {
    countRef.current += 1; // current 값이 변경되어도 리렌더링되지 않음
    console.log("Ref count:", countRef.current); // 콘솔에 current 값 출력
  };

  const updateCount = () => {
    setCount(countRef.current); // 상태로 값을 업데이트 -> 리렌더링 발생
  };

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={incrementCount}>Ref 값 증가</button>
      <button onClick={updateCount}>상태 업데이트</button>
    </div>
  );
}

• countRef는 컴포넌트가 리렌더링될 때도 값이 그대로 유지된다.
• countRef.current 값을 증가시켜도 컴포넌트가 리렌더링되지 않는다.
• 상태로 값을 반영하고 싶을 때는 setCount를 호출해 리렌더링을 유발할 수 있다.

useRef 요약

• useRef는 DOM 요소나 리렌더링과 관계없는 값을 참조하는 데 사용된다.
• 값이 변경되어도 리렌더링을 유발하지 않으면서 상태를 저장할 수 있다.
• 포커스 관리,애니메이션제어, DOM접근, 이전 상태 기억 등에서 많이 사용된다.

우선 해당 현상은** 블루투스 키보드 연결시 액티비티가 재생성되는 현상**이다. 이는 액티비티가 파괴되어서 다시 재생성 되는 것으로 보인다. 그 이유는 블루투스 키보드를 연결시 액티비티의 구성변경이 일어나기 때문에 재생성 되는 것으로 보인다.

재생성에 대해서 자세하게 사이클을 한번 보자면

• onSaveInstanceState(Bundle) : 화면 상태를 저장한다.
• onPause()
• onStop()
• onDestroy()
• onCreate(Bundle)
• onStart()
• onRestoreInstanceState(Bundle) : 아까 저장했던 화면 상태를 복원시킨다
• onResume()

이런식으로 흘러간다.

하지만 그냥 다른 작업 필요없이 재생성시키지 않고 유지만 시키면 되기 때문에

AndroidMainfest.xml 파일에 있는

<activity
     android:name=".MainActivity"
     android:configChanges="keyboard|keyboardHidden|orientation|screenSize"/>

configChanges 에 변경될 수 있는 설정들을 지정해주기로 하였다. 이런식으로 설정을 하면 재생성 대신에 onConfigurationChange() 만을 호출한다.

그래서 편하게 저것만 수정해서 시스템에서 자동으로 흘러갈 수 있도록 해결을 할려했지만, 왠걸 configChanges 에 keyboard|keyboardhidden 을 넣어도 액티비티가 재생성되는 현상이 계속 발생한다.

도저히 이유를 찾을 수가 없었다. 심지어 다른 키보드마다 먹히는게 있었고 안먹히는게 있어서 이유를 모른상태로 onSaveInstanceState() onRestoreInstanceState() 을 쓰는 등 여러가지 방법들을 시도하였는데, 특정 키보드는 아무리해도 해결이 되지 않았다. 2일~3일정도 방법을 계속 찾았지만 해결을 못하던 찰나,

혹시 얘를 이 키보드를 블루투스 키보드로 인식하지 못하는 건 아닐까?..

라는 생각이 머리속을 스쳐가고,,,

혹시 몰라서 configChanges 에 넣을 수 있는것들을 하나씩 전부 넣어보면서 찾았는데

<activity
     android:name=".MainActivity"
     android:configChanges="keyboard|keyboardHidden|orientation|screenSize|screenLayout|smallestScreenSize|uiMode|mcc|mnc|locale|fontScale|density|navigation"/>

문제는 바로 이놈

navigation

이놈이다.

“navigation”: Navigation Type ( 트랙볼 / DPad ) 가 변경되었을 때 ( 보통 절대 일어나지 않는 Case )

후,, 나는 하드웨어에 대해 잘 알지 못하지만,, 이 키보드 녀석을 DPAD 로 인식을 하고 있는거 같았다.

구글링을 했을때도 보통 절대 일어나지 않은 CASE 라고 봤었기에 간과하고 있었는데 이 녀석을 넣으니 아무일도 없었다는듯이 모든게 해결되었다.

혹시 나같은 현상을 겪은 사람들은 configChanges에 하나씩 넣으면서 어떤것으로 인식을 하고 있는지 확인하기 바란ㄷ...ㅠ

백엔드를 많이 접해본 나로서는 프론트쪽이 부족하여 배울 것이 많을 것 같아

이번에 toss slash24를 신청하게되었다.

아마 배울 것이 엄청 많고 몰랐던 것을 많이 접해볼 수 있는 기회가 될 것같다...

더 나은 개발자가 되기 위해,, 우리 모두 화이팅

💥 그래서 찾아본 방법 중 하나인 Logger을 이용해서 txt 파일에 찍힌 로그 내용을 저장해서 서버에 특정 폴더에 넣을려고 한다.

그냥 간단하게 java.util.logging 패키지를 이용해서 Logger를 설정하고 파일 핸들러를 추가하여 로그를 파일에 저장하는 방식을 이용

import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;

public class SendLogger {
    private static final Logger logger = Logger.getLogger(SendLogger.class.getName());

    static {
        try {
             FileHandler fileHandler = new FileHandler("저장할 위치/application.log", 10 * 1024 * 1024, 5, true);
            fileHandler.setFormatter(new SimpleFormatter());
            logger.addHandler(fileHandler);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Logger getLogger() {
        return logger;
    }
}

파일은 최대 10MB , 넘어가면 다음 파일을 생성해서 저장한다. 파일 개수는 최대 5개

만약 5개가 넘어간다면 가장 오래된 파일이 삭제되고 새로운 파일이 생성된다.

그리고 어디서든 Logger logger = SendLogger.getLogger(); 을 선언해서

logger.severe("저장할 로그내용");

이런식으로 써주게 되면

이런식으로 잘 저장이 된 걸 볼 수 있다 !

우선 원래 구현 해놓은 것은

단말기 태깅 -> 태깅 데이터 우리서버에서 가공 -> 가공한데이터를 다른 서버로 전송

해당 로직으로 구현을 해놓았다.

그런데 한번에 많은 사람들이 태깅을 하다보니 통신에 문제인가? 속도의 문제인가? 정확한 원인은 알 수 없지만 TimeOut 이 나는 것으로 보인다.

태깅하면 탑승자의 정보를 MYSQL에다가 정보를 담고 있었는데,

MYSQL에 관련된 로직은 다 빼고 Redis로 처리를 하고, 나중에 Redis에 있는 탑승자 정보를 스케줄러를 통해서 MYSQL로 데이터를 옮길려고 한다.

Redis 를 쓰면 속도가 올라가서 타임아웃에러가 안나길 바라면서 진행하였다.. 많은 자료구조로 넣을 수 있지만 Key-Value 값으로 처리하면 속도가 가장 빠르다고 하던데, 데이터 타입마다 다를 것 같긴하다. 어쨋든 key-Value 형식으로 진행!

간단하게 보면 key 값을 이용해 value(데이터)를 조회한다.

set key1 "HelloWorld" 

로 넣으면 ,

get key1
-> "HelloWorld"

로 조회한다.

spring 프로젝트(gradle)였기에

📌 우선 Redis 세팅을 위해서 build.gradle 에다가 추가

implementation 'org.springframework.boot:spring-boot-starter-data-redis'

📌 그리고 Config 파일을 만들어서 설정값을 작성한다.

Configuration
public class RedisConfig {

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory("내 서버 IP", 6379);
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory){
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

(참고로 properties에 ip랑 port번호를 넣었는데 접근이 안되서 LettuceConnectionFactory로 해결했다..)

자 이제 Redis 세팅 끝.

📌 이제 서비스단 만들어서 구현을 시작하면 된다.

@Service
public class RedisService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    private final ObjectMapper objectMapper = new ObjectMapper();

    public Map<String, Object> getBusDeviceInfo(String deviceID){
        String key = "busDeviceInfo:" + deviceID;
        String data = redisTemplate.opsForValue().get(key);

        if(data != null) {
            try {
                return objectMapper.readValue(data, Map.class);
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public void cacheBusDeviceInfo(String deviceId, Map<String, Object> deviceInfo) {
        String key = "busDeviceInfo:" + deviceId;
        try {
            redisTemplate.opsForValue().set(key, objectMapper.writeValueAsString(deviceInfo));
        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    public String getRouteIdentificationNumber(String deviceID) {
        Map<String, Object> deviceInfo = getBusDeviceInfo(deviceID);
        if(deviceInfo == null) {
            return null;
        }

        int areaCode = Integer.parseInt(deviceInfo.get("area_code").toString());
        String currentTime = LocalTime.now().format(DateTimeFormatter.ofPattern("HHmm"));

        if(areaCode == 1 && currentTime.compareTo("0000") >= 0 && currentTime.compareTo("1159") <= 0) {
            return "ChangwonBundang";
        } else if(areaCode == 1 && currentTime.compareTo("1159") > 0) {
            return "BundangChangwon";
        } else if(areaCode == 2 && currentTime.compareTo("0000") >= 0 && currentTime.compareTo("1159") <=0) {
            return "BundangChangwon";
        } else if(areaCode == 2 && currentTime.compareTo("1159") > 0) {
            return "ChangwonBundang";
        }

        return null;
    }

    public Map<String, Object> getBusInfo(int biCode) {
        String key = "busCode:" + biCode;
        String data = redisTemplate.opsForValue().get(key);

        if(data != null) {
            try {
                return objectMapper.readValue(data, Map.class);
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public void insertPassengerInfo(Map<String, Object> passengerInfo) {
        String key = "busPassengerInfo:" + passengerInfo.get("employeeId") + ":" + passengerInfo.get("tagDt");
        try {
            redisTemplate.opsForValue().set(key,objectMapper.writeValueAsString(passengerInfo));
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

간단하게 보면 select와 insert가 있는데 단말기ID(deviceID)가 키값이 되기에,

busDeviceInfo:"단말기에서 넘겨받은 ID값" (key 값)으로 data를 조회한다.

그리고 insert부분은 insertPassengerInfo가 되는데 컨트롤러단에서 받아온 값을 파라미터로 넘겨받아서 busPassengerInfo:"파라미터로 받은 값"(key)값을 이용해서 데이터를 insert 시킨다.

후에 Redis에 이런식으로 처리를하여 가공한 데이터를 외부 서버로 보내었다.

처음해본 Redis 였는데, 서버에 메모리를 사용하여 데이터 처리를 한다는게 좀 신기했던 것 같고 속도가 빨라진게 확실히 느껴지긴했다(아주많이,,).

간단한 데이터를 담고 빼고 빠른속도가 필요할 땐 쓸모가 많을 거 같은 녀석인 것 같다. (세션같은거?)

그래도 하드웨어가 첨가된 개발은 좀,, 손이 많이 간다..

근데 로컬로 켜놨기때문에 http 라는 것을 참고해야한다.

1. network_security_config.xml 파일 생성

http 환경이니까 res/xml 폴더에 network_security_config.xml 파일을 하나 만들자

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
    <domain-config cleartextTrafficPermitted="true">
        <domain includeSubdomains="true">192.168.114.18</domain>
    </domain-config>
</network-security-config>

그리고 AndroidMainfest.xml에다가

<application
        android:name=".App"
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:networkSecurityConfig="@xml/network_security_config"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.FCMExample"
        tools:targetApi="31">

android:networkSecurityConfig="@xml/network_security_config" 해당 내용을 application 영역에 추가해주자

2. Retrofit2

나는 레트로핏2을 사용해서 전송하였다. build.gradle(app) 에다가

라이브러리 추가하자

    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    implementation 'com.google.code.gson:gson:2.8.6'

3. ApiService

다음으로 apiservice 인터페이스를 생성해준다.

public interface ApiService {

    @POST("/regToken")
    Call<Void> sendToken(@Body TokenRequest tokenRequest);
}

4. RetrofitClient

public class RetrofitClient {
    private static Retrofit retrofit = null;

    public static Retrofit getClient(String baseUrl){
        if(retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(baseUrl)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        return retrofit;
    }

5. TokenRequest

토큰값과 uuid를 담을 객체 생성

public class TokenRequest {
    private String token;
    private String uuid;

    public TokenRequest(String token, String uuid) {
        this.token = token;
        this.uuid = uuid;
    }

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public String getUuid() {
        return uuid;
    }

    public void setUuid(String uuid) {
        this.uuid = uuid;
    }
}

6. MainActivity

나는 테스트앱이므로 앱이 켜지자말자 (onCreate) 부분에서 토큰값과 uuid가 전송되도록 하였다.

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";
    private static final String SERVER_URL = "http://내 로컬 ip/regToken";
    private OkHttpClient client = new OkHttpClient();
    private Gson gson = new Gson();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        FirebaseMessaging.getInstance().getToken()
                .addOnCompleteListener(new OnCompleteListener<String>() {
                    @Override
                    public void onComplete(@NonNull Task<String> task) {
                        if (!task.isSuccessful()) {
                            Log.w(TAG, "토큰 실패", task.getException());
                            return;
                        }

                        String token = task.getResult();
                        String uuid = App.getInstance().getUUID();

                        Log.d("토큰 값 : ", token);
                        Log.d("uuid 값 : ", uuid);

                        TokenRequest tokenRequest = new TokenRequest(token, uuid);
                        try {
                            sendTokenToServer(tokenRequest);
                        } catch (IOException e) {
                            e.printStackTrace();
                            Log.e(TAG, "토큰 전송 실패", e);
                        }
                    }
                });
    }

    private void sendTokenToServer(TokenRequest tokenRequest) throws IOException {
        MediaType JSON = MediaType.parse("application/json; charset=utf-8");
        String json = gson.toJson(tokenRequest);

        RequestBody body = RequestBody.create(JSON, json);
        Request request = new Request.Builder()
                .url(SERVER_URL)
                .post(body)
                .build();

        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                Log.e(TAG, "서버 요청 실패: " + e.getMessage());
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.isSuccessful()) {
                    Log.d(TAG, "서버 요청 성공: " + response.body().string());
                } else {
                    Log.e(TAG, "서버 요청 실패: " + response.message());
                }
            }
        });
    }
}

그리고 콘솔에 성공여부, 실패여부를 쓸 수 있도록 해놨으니 oncreate 되자말자 콘솔에 여부를 알 수 있다. 또한 응답값도 response.body().toString()으로 받을 수 있다!

간단한 api 호출 예제를 한번 테스트해보았다...

바쁜 요즘,, 간만에 글을 끄적였다..

✔ FE 부분 먼저 작성해보자

main.dart

import 'package:flutter/material.dart';
import 'package:flutter_application_1/screen/screen_home.dart';

void main() {
  runApp(
    MaterialApp(
      debugShowCheckedModeBanner: false,
      home : HomeScreen(),
    )
  );
}

main.dart에 바로 작성 안하고 homescreen.dart에 작성하고 메인으로 불러온다.

screen_home.dart

class _HomeScreenState extends State<HomeScreen> {
  final _valueList = ['KT', 'SKT', 'LG'];
  var _selectedValue = 'KT';
  final TextEditingController _phoneNumberController = TextEditingController();
  final TextEditingController _nameController = TextEditingController();

  void dispose() {
    _phoneNumberController.dispose();
    _nameController.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(),
      body: Padding(
        padding: const EdgeInsets.symmetric(horizontal: 20.0),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text(
              '입력한 정보가 맞다면 \n아래 확인 버튼을 눌러주세요',
              style: TextStyle(
                fontSize: 24,
                fontWeight: FontWeight.w600,
              ),
            ),
            SizedBox(
              height: 40,
            ),
            Text(
              "휴대폰 번호",
              textAlign: TextAlign.start,
              style: TextStyle(
                color: Colors.grey,
              ),
            ),
            TextFormField(
              controller: _phoneNumberController,
               keyboardType: TextInputType.number,
              decoration: InputDecoration(
                focusedBorder: UnderlineInputBorder(
                  borderSide: BorderSide(color: Colors.blue),
                ),
                enabledBorder: UnderlineInputBorder(
                  borderSide: BorderSide(color: Color.fromARGB(15, 55, 55, 55)),
                )
              ),
              cursorColor: Colors.transparent,
            ),
            SizedBox(
              height: 20,
            ),
            Text(
              "통신사",
              textAlign: TextAlign.start,
              style: TextStyle(
                color: Colors.grey,
              ),
            ),
            SizedBox(
              width: double.infinity, // DropdownButton을 텍스트 필드의 너비와 일치시킵니다.
              child: DropdownButton(
                isExpanded: true, // 버튼이 가능한 최대 너비를 가집니다.
                value: _selectedValue,
                items: _valueList.map(
                  (value) {
                    return DropdownMenuItem(
                      value: value,
                      child: Text(value),
                    );
                  },
                ).toList(),
                onChanged: (value) {
                  setState(() {
                    _selectedValue = value.toString();
                  });
                },
              ),
            ),
            const SizedBox(
              height: 20,
            ),
            Text('이름', 
            style: TextStyle(
              color: Colors.grey,
            ),),
            SizedBox(
                  child: TextFormField(
                    controller: _nameController,
               keyboardType: TextInputType.name,
              decoration: const InputDecoration(
                focusedBorder: UnderlineInputBorder(
                  borderSide: BorderSide(color: Colors.blue),
                ),
                enabledBorder: UnderlineInputBorder(
                  borderSide: BorderSide(color: Color.fromARGB(15, 55, 55, 55)),
                )
              ),
              cursorColor: Colors.transparent,
            ),
            ),
            SizedBox(height: (20),),
            ElevatedButton(onPressed: () {
              sendDataToServer(
                _phoneNumberController.text,
                _selectedValue,
                _nameController.text,
              );
            }, child: Text('확인',style: TextStyle(color: Colors.white),),
            style: ElevatedButton.styleFrom(
              backgroundColor: Color.fromARGB(255,41, 119, 243),
              minimumSize: Size(double.infinity,50),
              shape: RoundedRectangleBorder(
                borderRadius: BorderRadius.circular(10)
              )

            ),
            )
          ],
        ),
      ),
    );
  }

하면서 느낀거지만 html 에 익숙해져있던지라 화면을 구성하는데 어려움이 많이 느껴졌다.. 아마 이렇게 짜는게 아닌데,, 잘못짜서 이렇게 길게 나온거 같은데

고수님이 혹시라도 이 글을 보시고 조언해주셨으면 좋겠다...

어찌됐건 일단 완성,,,

일단 화면은 만들어졌고 해당 TextField 에 값을 입력하고 확인 버튼을 누르면 내가 만든 MYSQL 테이블에 입력값들이 저장이 되어야한다!

다음 백엔드로 넘어가보자

MemberController.java

@RestController
@RequestMapping("/")
public class MemberCotroller {
    private final MemberService memberService;

    public MemberCotroller(MemberService memberService) {
        this.memberService = memberService;
    }


    @PostMapping("/register")
    public ResponseEntity<String> register(@RequestBody Member member) {
        boolean exists = memberService.existsByName(member.getName());



        boolean result = memberService.createMember(member);
        if(result) {
            return ResponseEntity.ok("{\"message\": \"성공했습니다.\"}");
        } else {
            if(exists) {
                return ResponseEntity.badRequest().body("{\"error\": \"duplicate_name\"}");
            }
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("{\"error\": \"internal_error\"}");
        }
    }


}

우선 백엔드쪽도 새로운 걸 도전해보고 싶어서 JPA를 사용하기로 했다. @RestController를 만들어주고

post 방식으로 보낼거기때문에 @PostMapping("/register)로 구현해준다.

성공하면 "성공했습니다"를 응답하고 실패하면 500에러가 응답할 것이고, 중복된 아이디가 있다면, duplicate_name을 응답하도록 했다.

자 그럼 다시 프론트 쪽에서 데이터 전송 로직을 만들어주자

Future<void> sendDataToServer(String phoneNumber, String telecom, String name) async{
    final url = Uri.parse('http://내 아이피:8080/register');


    final response = await http.post(
      url,
      headers: <String,String>{
        'Content-Type': 'application/json; charset=UTF-8',
      },
      body: jsonEncode(<String, String>{
        'phoneNumber' : phoneNumber,
        'telecom' : telecom,
        'name' : name,
      }),
    );

    if(response.statusCode == 200) {
      print('데이터 전송 성공!');
      showDialog(context: context, 
                  builder: (BuildContext context){
                    return AlertDialog(
                      title: Text(""),
                      content: Text("성공적으로 가입되었습니다"),
                      actions: <Widget>[
                        FloatingActionButton(onPressed: (){
                          Navigator.of(context).pop();
                        },
                        child: Text("확인"),)
                      ],
                    );
                  }
                  );
    }else {
      print('실패했습니다. ${response.statusCode}' );
      print(response.body);
      final responseData = json.decode(response.body);
      if(responseData['error'] == 'duplicate_name') {
        showDialog(context: context, 
        builder: (BuildContext context){
          return AlertDialog(
            title: Text("실패"),
            content: Text('이미 존재하는 아이디입니다,'),
            actions: <Widget>[
              ElevatedButton(onPressed: (){
                Navigator.of(context).pop();
              },
              child: Text("확인"),)
            ],
          );
        });
      }

성공하면 "성공적으로 가입되었습니다" 다이얼로그를 띄워주고, 중복 된 이름을 입력하면 "이미 존재하는 이름입니다" 라고 띄워준다. (그냥 중복체크 다이얼로그를 띄워보고 싶어 그냥 이름에다가 unique key 값을 적용했다)

잘들어온다..!!!

파이어베이스에다가 앞단에서 바로 넣는게 아닌 API로 백엔드 쪽으로 데이터를 보내서 저장하는건 처음해보았는데,,

개린이다보니 프론트 백엔드 구분이 잘안되는 상태였는데, 아직 확실히 이해 못했지만 조금은 어떤 느낌으로 구분하는지 알게 된 것 같다.

이런식으로 프론트, 백엔드 둘다 할 줄 알면 풀스택 개발자가 되는건가?..

어쨋든! 최근에 HTTP , URI 기반으로 자원에 대해 접근 할 일이 많아졌다. 그래서 이걸 사용하면서도 확실히 알고 넘어가는게 중요할 것 같아서 정리를 간단한게 해볼려한다.

RESTful API 라는게 도대체 뭘까?

[ Representational State Transfer ] 먼저 REST 란 HTTP URI를 통해 자원을 명시하여 HTTP 메서드를 통해서 해당 자원을 메서드 로직에 있는 CRUD 작업을 적용하는 의미이다. 자원을 이름으로 구분하여! 자원의 상태를 주고 받는 모든 것!

구성요소는 [HTTP URI], [HTTP Method], [HTTP Message Pay LOAD] 가 있다.

음,, 간단하게 생각하면 애플리케이션 개발 인터페이스인데 HTTP 메서드와 URI만으로 데이터들을 CRUD 하는거라고 생각하면 될 것 같다

더 간단하게 말하자면,, 두 컴퓨터 시스템이 인터넷을 통해서 정보를 안전하게 교환하기 위해 사용하는 인터페이스라고 하면 될 것 같다.

• 장점

1. HTTP 프로토콜에 사용하는 플랫폼이라면 모두 사용 가능하다.
2. HTTP 프로토콜의 표준을 최대한 활용해서 여러가지 장점을 함께 가져갈 수 있다.
3. 서버와 클라이언트의 역할을 명확하게 분리해준다.

• 단점

1. 표준이 없다.
2. 메서드 형태가 제한되어있다. 4가지!
3. 구형브라우저는 제대로 지원이 안될 수가 있다.

   특징

• 클라이언트와 서버로 분리되어야 하며 서로 의존성이 없어야한다
• 상태 정보는 따로 저장하지 않고 접근하는자가 누구인지 관계없이 동일한 결과를 응답해야한다.
• API 는 REST 조건을 만족하려면 오픈 될 수 밖에 없기에, 요청 정보를 검색하는데 있어 계층 구조로 분리가 되어 있어야한다.
• API를 통해 전송되는 내용은 직관성이 좋아야한다. (JSON이 많이 사용된다고 한다) (딱봐도 알겠지 뭔지? 👍)

  사용 이유?

  여러가지 이유가 있겠지만, Client side를 고정(정형화)해두고 사용하는 것이 아닌 PC,모바일,어플리케이션 등 플랫폼 자체에 제약을 두지 않고 사용하기 위해서 인 것 같다.

한 서버로 두개의 도메인을 돌려야하는 일이 생겼다. 안해본 작업이라 생각을 계속 해보고 자료를 좀 찾아보니, 톰캣으로 서버를 돌리기 때문에 sever.xml 파일에 호스트(HOST) 요소를 추가하면 되는 방법이 있었다.

우선 웹서버에서 원래 돌리던 HOST가 있었는데 이것을 Main Host 라고 한다. 나는 또 DB만 스키마를 따로 파서 연결해서 사용할 예정이라, Virtual Host(가상호스트)만 추가해주었다.

서브도메인의 목적이 뭘까?

음,, 생각을 해보았다. 내가 하는 목적과 다르게 또 쓰이는 곳이 어디가 있을까? 모바일? 음 m. 을 붙여서 서브도메인을 구성하는 모바일 전용페이지에도 쓰인다는 사실을 알게 되었다. 그 뿐만 아니라 관리자페이지라던지 API 를 사용할때? 여러가지를 생각했을 때, URI를 설계하기에 좋고 관리 및 유지보수에 강점들이 많아서 쓰인다고 생각이 들었다.

<Host name="기존 메인도메인.com" appBase="webapps" unpackWARs="true" autoDeploy="false">
<Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log" suffix=".txt" pattern="%h %l %u %t "%r" %s %b"/>
<Context path="/" docBase="/서버에프로젝트경로" reloadable="true"/>
<Context path="/files" docBase="/서버에프로젝트경로" reloadable="true"/>
<Context path="/upload" docBase="/서버에프로젝트경로" reloadable="true"/>

</Host>
<Host name="추가한 서브 도메인.com" appBase="webapps" unpackWARs="true" autoDeploy="false">
<Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log" suffix=".txt" pattern="%h %l %u %t "%r" %s %b"/>
<Context path="/" docBase="/서버에프로젝트경로" reloadable="true"/>
<Context path="/files" docBase="/서버에프로젝트경로" reloadable="true"/>
<Context path="/upload" docBase="/서버에프로젝트경로" reloadable="true"/>

이렇게해서 원격서버에 server.xml 파일 바꿔주고 새로운 프로젝트 파일을 경로에 위치에 해주고, properites에는 같은 디비에 다른 스키마로 연결하여 재배포하니깐 서브 도메인으로 접속이 가능했다.

배치 프로그램이나 스케줄러 등등 따로 돌려줘야할 때가 있는 것 같다. 이유는 뭐,, 본 프로젝트에서 주기적인 대량의 데이터작업이 필요할때 라던지?.. 여튼 그럴 때 쓰려고 만들어 놓은 프로젝트를 JAR 파일로 뽑아보자

우선, 프로젝트를 짜고

프로젝트 우클릭 -> Run As -> Run Configuration

다음으로는 왼쪽 리스트 중에 JavaApplication을 우클릭해서 New Configuration을 해주자

이제부터 좀 중요하다 집중

이런식으로 창이 나올텐데, 상단에 있는 Name에는 원하는 이름을 정해주고 Project를 선택하고, Main class에 search를 클릭해서 선택해주자 이런식으로 나올거다 (참고로 나는 이걸 선택안하고 넘어가서 찾는데 엄청 오래 걸렸다..) 자 그럼 이제 우측 하단에 Apply !

이제 그럼 추출해보자

내 프로젝트 우클릭 그리고 export 클릭! Runnable JAR File 을 선택하고 Next 를 누르자. 이제 다왔다..

아까 configuration 했던 거 선택해주고 저장위치하고 finish 누르면 해당 경로에 jar 파일이 저장된다. 👍

개발자로 취업한 뒤 이제 수습이 끝났다. 첫 글을 써보려고 한다. 내가 사용했던 코드들을 정리하면 다음에 다시 보면서 공부도 하고, 다시 쓸 때에도 도움이 될 것 같다. (틀린 점이 있을 수도 있지만,, 알게될 때마다 고쳐야지..)

🚩 고객사 서버쪽으로 데이터를 보내야할 일이 생겼다.

처음에 GET 방식으로 요구를 했고, 보내야할 Key 값들과 데이터 포맷들을 전달 받았다.

그리고 구현을 했지만 변경이 되어야 할 것 같다고 POST 방식으로 바꾸게 되었다 FormData 형식으로 달라고하네,,

단말기에 태깅을 하였을 때 카드에 있는 태깅 정보를 고객사 서버로 넘겨줘야하는 로직인데 근데 컨트롤러에서 거쳐야할 로직들이 많아서 코드를 쳐서 구현을하니 속도 때문인지 이유는 정확하게 모르지만 태깅이 많이 들어오게 되면 중간에 멈추는 현상이 일어났다.

그래서 고민을 하던중 내가 생각한건,, runnable jar 파일을 따로 돌려주는 프로젝트를 새로 생성하였다.

try {
        service.insertTagdataTransfer(paramMap2);
            boolean isLinux = System.getProperty("os.name").toLowerCase().startsWith("linux");
            Process process;
            if (isLinux) 
            {
                try {
                System.out.println("일로 들어왔음");
                String command = String.format("java -jar /home/gnbismngr/apps/datasender/DataSender2.jar \"%s\" \"%s\" \"%s\" \"%s\"", paramMap2.get("cardLoc").toString(), paramMap2.get("originDestination").toString(), paramMap2.get("cardUid").toString(), paramMap2.get("tagTime").toString());
                System.out.println("실행 명령: " + command); // 실행 명령이 올바르게 구성되었는지 확인
                process = Runtime.getRuntime().exec(command);

                BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
                String line;
                while ((line = reader.readLine()) != null) {
                    System.out.println("Runnable 파일 콘솔값 : "+line);
                }

                // 프로세스의 에러 출력도 캡처하여 콘솔에 출력
                BufferedReader errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
                String errorLine;
                while ((errorLine = errorReader.readLine()) != null) {
                    System.out.println("Error: " + errorLine);
                }

                // 프로세스가 종료될 때까지 대기
                int exitCode = process.waitFor();
                System.out.println("프로세스 종료 코드: " + exitCode);

                }catch (IOException e) {
                    e.printStackTrace();
                }
            } 
    } catch (Exception e) {
        e.printStackTrace();
    }

우선 DB에 태깅정보를 저장하고,

리눅스 서버에 jar파일을 올려놓고 태깅 될 때 마다 해당 API를 타고 와서 실행시키는 방법으로 구현을 해보았다.

그리고 jar 파일이 잘작동하는지 콘솔에 찍어보고 싶어서 버퍼를 이용해서 콘솔에 결과값이 나오도록 해놨다.

이제 해당 runnable jar파일을 뽑아낸 프로젝트에 코드이다.

 Map<String, String> formData = new HashMap<>();

 String cardLoc = args[0];
 String originDestination = args[1];
 String cardUid = args[2];
 String tagTime = args[3];

넘겨준 인자를 받아서 변수에 담아주는 작업을 한다.

formData.put("area", sPass_gb);
formData.put("course", sCos);
formData.put("keyId", sKey_id);
formData.put("time", sTime);

formData에 담아주고,

 String url = "http://apiURL을 넣는다";

 // URL객체 생성
 URL apiUrl = new URL(url);
 //URL 객체사용해서 HTTP 연결 오픈, 나중에 HTTP 요청보내는데 사용함
 HttpURLConnection connection = (HttpURLConnection) apiUrl.openConnection();
 connection.setRequestMethod("POST");    
 connection.setRequestProperty("X-Authorization", "인증 토큰 값");
 //HTTP 요청에서 데이터를 전송할 수 있도록한다.
 connection.setDoOutput(true);

 // 연결을 통해 데이터를 전송하는데 사용되는 출력 스트림을 연다.
 try (OutputStream os = connection.getOutputStream()) {
                //Post 요청에 포함된 데이터를 구성하는 StringBuilder 객체를 생성한다.
                StringBuilder postData = new StringBuilder();
                //formData 맵의 각 항목을 반복한다.
                for (Map.Entry<String, String> entry : formData.entrySet()) {
                    System.out.println("formData : " + formData);
                    // 이미 postData에 데이터가 추가된 경우, 항목들을 '&'구분한다.
                    if (postData.length() != 0) {
                        postData.append('&');
                    }
                    // 키와 값을 URL 인코딩 하고, '='로 연결하여 postData에 추가한다.
                    postData.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
                    postData.append('=');
                    postData.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
                    System.out.println("postData : "+ postData);
                }
                //구성된 데이터들을 바이트 배열로 반환한다.
                byte[] postDataBytes = postData.toString().getBytes(StandardCharsets.UTF_8);
                System.out.println("postDataBytes : " + postDataBytes);
                // 바이트 배열을 출력 스트림에 쓴다. 이는 서버로데이터를 전송하는 과정
                os.write(postDataBytes);
            }
//서버로 부터 받은 HTTP응답 코드를 가져온다.
int responseCode = connection.getResponseCode();
//응답 코드가 HTTP_OK(200) 인 경우 , 요청이 성공적으로 처리되었음을 의미한다.
if (responseCode == HttpURLConnection.HTTP_OK) {
                    updateDatabase(1,cardUid,tagTime);
                    // 응답 본문 읽기 위해 BufferedReader 를 생성한다.
                    try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
                        StringBuilder response = new StringBuilder();
                        String responseLine;
                        // 응답 본문의 각 라인을 읽고, 전체 응답을 하나의 문자열로 구성한다.
                        while ((responseLine = br.readLine()) != null) {
                            response.append(responseLine.trim());
                        }
                        // 응답 내용 콘솔에 출력
                        System.out.println("HTTP POST 요청 결과: " + response.toString());
                        // 응답을 파일에 기록
                        try (FileWriter fileWriter = new FileWriter("output123.txt")) {
                            fileWriter.write(response.toString());
                        } catch(IOException e ) {
                            e.printStackTrace();
                        }
                    }
            } else {
                    System.out.println("HTTP POST 요청 실패. 응답 코드: " + responseCode);
                    updateDatabase(0,cardUid,tagTime);
            }
            connection.disconnect();

updateDataBase는 아까 태깅정보를 인서트 했었는데 그 테이블에 태깅정보가 잘넘어갔는지 안넘어갔는지 플래그 처리를 해주기 위해 하는 작업이다.

정리

단말기에 태깅했을 때 컨트롤러에 태깅 API로 들어오게 되고 해당 API에서 특정 경로에 있는 jar파일을 실행시키도록 하였고, 그 jar파일에서는 HttpURLConnection을 통해서 필요한 데이터들을 넘겨주고 있다.

부족한 점

jar 파일을 실행시킬 때 console에 print 라도 찍어서 보고 싶었는데, 볼 수 있는 방법을 몰라 시간이 좀 걸렸는데 버퍼에 담아 출력스트림으로 jar파일을 실행시키는 본 프로젝트에서 로그내용들을 볼 수 있게 하였다. 부족한 점들이 너무너무너무 많치만 차근차근 한단계씩 밟아가봐야할듯.