반응형

얀센 백신 후기

2021년 6월 1일

어제 뉴스에서 얀센 백신 사전 예약이 가능하다는 소식을 접하고 어제 밤 11시 57분에 예약사이트에 접속했습니다.

예방 접종 예약 시스템, 누리집(https://ncvr.kdca.go.kr) 에 접속하여 내가 다니던 병원을 선택하여 6월 10일 16시로 예약을 하였습니다.

카톡으로 알림 설정을 하니 예약된 내역을 '국민비서 구삐'로 부터 받았습니다.

2021년 6월 10일

16시 조금 전에 맞추어 예약된 병원으로 갔습니다.

도착하자마자 접수를 했고 검진표를 받아 작성했습니다. 그리고 제출하면서 체온도 쟀고 36.9도가 나왔습니다. 아스트라제네카 약 10명, 얀센백신 접종자 약 3명이 대기를 했습니다. 의사와 면담을 했고 백신 접종 후 2~30분 대기해야 된다고 하였고 저의 핸드폰으로 전화가 올 수도 있다고 하였습니다.

16시 반쯤 되니 주사실로 저를 불렀습니다. Janssen 백신 통을 보여 주셨고 왼쪽 어깨에 접종을 하였습니다. 예약된 사람이 적게 왔는지 간호사 분께서 다음과 같은 얘기도 하셨습니다.

"이거 남는 거 버려야 되는데 어떻게 하나 내가 맞을 수도 없고..."

20분 정도 대기하였고 주사 맞은 부분이 약간 빨갛게 부었습니다. 보여주며 여쭤보니 한 시간 정도 계속 지속되면 건드리지 말고 병원으로 연락하라고 하셨습니다. 다행히 주사 맞은 부분은 정상으로 돌아왔습니다. 프린트 된 접종 확인서도 요청하여 받았고 카톡으로도 다음처럼 확인 받았습니다.

집에 돌아와서 웹서핑하여 예방 접종 확인 앱도 다운로드 받았습니다.

*질병관리청 COOV(https://play.google.com/store/apps/details?id=kr.go.kdca.coov&hl=ko&gl=US)

2021년 6월 11일

새벽 3시쯤에 깨었고 몸살 기운이 있는 거 같기도 하였습니다. 한 시간 쯤 뒹굴거리다 다시 잤습니다.

오전 9시 조금 전에 깨었고 몸살 기운이 조금 있었습니다.

오전 10시 쯤(17시간 반 경과) 되니 열이 나기 시작했고 체온이 37.8도 정도 나왔습니다.
미리 사 두었던 타이네롤 서방정 한 알을 먹고 30분 후에 또 한 알을 먹었습니다.

11시가 조금 지나서 체온은 조금씩 내려갔고 12시 즈음에 점심 식사를 하였습니다.

뉴스를 보니 얀센 노쇼(예약 불이행)할 경우 60세 이상이 우선 맞을 수 있다고 하였습니다.

컨디션이 안 좋아 낮잠을 잤습니다.

저녁을 먹고 난 후 다시 열이 좀 오르기 시작했습니다. 오후 10시 정도에 다시 체온이 37.8도 정도 나와서
타이네롤 서방정 두 알을 먹고 잤습니다.

  • 타이네롤 서방정은 하루에 최대 6알 먹을 수 있고 8시간 간격으로 2알씩 먹을 수 있습니다.

2021년 6월 12일

아침에 일어나니 체온은 정상이었습니다.

컨디션이 점점 괜찮아져서 14시 부터 얀센백신 후기를 작성중입니다.

추가 자료

투자 자료

반응형
반응형

출처 : https://stackoverflow.com/questions/1060279/iterating-through-a-range-of-dates-in-python

Python에서 날짜 범위를 반복하기

이를 하기 위해 다음 코드가 있지만, 어떻게 하면 더 좋게 할 수 있을까요? 지금은 중첩 루프보다 낫다고 생각하지만 list comprehension에 generator로 한 줄씩 날짜를 얻기 시작합니다.

day_count = (end_date - start_date).days + 1
for single_date in [d for d in (start_date + timedelta(n) for n in range(day_count)) if d <= end_date]:
    print strftime("%Y-%m-%d", single_date.timetuple())

Notes

  • 나는 실제로 이것을 출력하는 데 사용하지 않습니다. 그냥 이는 데모 용입니다.
  • start_dateend_date 변수는 타임 스탬프가 필요하지 않기 때문에 datetime.date 개체입니다. (보고서를 생성하는 데 사용됩니다).

샘플 출력

시작날짜 2009-05-30에서 끝날짜 2009-06-09 동안 출력합니다.

2009-05-30
2009-05-31
2009-06-01
2009-06-02
2009-06-03
2009-06-04
2009-06-05
2009-06-06
2009-06-07
2009-06-08
2009-06-09

24 개의 답변 중 1 개의 답변만 추려냄.

왜 이중 for문을 반복하시나요? 저는 하나의 반복문으로 데이터의 같은 list를 생산합니다.

for single_date in (start_date + timedelta(n) for n in range(day_count)):
    print ...

그리고 list가 저장되지 않고 하나의 generator에서만 반복됩니다. 또한 generator의 "if"는 불필요한 것 같습니다.

결국 선형 시퀀스에는 두 개가 아닌 하나의 반복자만 필요합니다.

John Machin과 토론 후 갱신

아마도 가장 우아한 해결책은 generator 함수를 사용하여 날짜 범위에 대한 반복을 완전히 숨기거나 줄이는 것입니다.

from datetime import date, timedelta

def daterange(start_date, end_date):
    for n in range(int((end_date - start_date).days)):
        yield start_date + timedelta(n)

start_date = date(2013, 1, 1)
end_date = date(2015, 6, 2)
for single_date in daterange(start_date, end_date):
    print(single_date.strftime("%Y-%m-%d"))

주의: 내장 range() 함수와의 일관성을 위해 이 반복은 end_date에 도달하기 전에 중지됩니다. 따라서 포괄적인 반복을 위해서는 range()에서와 같이 다음 날을 사용하십시오.

    for n in range(int ((end_date - start_date).days+1)):
반응형
반응형

출처 : https://stackoverflow.com/questions/19231871/convert-unix-time-to-readable-date-in-pandas-dataframe

Unix 시간을 pandas dataframe에서 읽을 수 있는 날짜로 변환하기

저는 Unix 시간으로 가격이 포함된 dataframe이 있습니다. 사람이 읽을 수 있는 날짜로 표시되도록 index 열을 변환하고 싶습니다.

예를 들어 index 열에서 date1349633705가 있지만 그것이 10/07/2012(또는 적어도 10/07/2012 18:15)로 보여지길 원합니다.

다음 구문에서 내가 작업 중인 코드와 이미 시도한 코드는 다음과 같습니다.

import json
import urllib2
from datetime import datetime
response = urllib2.urlopen('http://blockchain.info/charts/market-price?&format=json')
data = json.load(response)   
df = DataFrame(data['values'])
df.columns = ["date","price"]
#convert dates 
df.date = df.date.apply(lambda d: datetime.strptime(d, "%Y-%m-%d"))
df.index = df.date

보시다시피 df.date = df.date.apply(lambda d: datetime.strptime (d, "%Y-%m-%d")) 여기에서 문자열이 아닌 정수로 작동하지 않습니다. 나는 datetime.date.fromtimestamp를 사용해야 한다고 생각하지만 이것을 df.date 전체에 적용하는 방법을 잘 모르겠습니다.

감사합니다.


4 개의 답변 중 1 개의 답변만 추려냄.

다음은 epoch 이후 초단위로 보일 것입니다.

In [20]: df = DataFrame(data['values'])

In [21]: df.columns = ["date","price"]

In [22]: df
Out[22]: 
<class 'pandas.core.frame.DataFrame'>
Int64Index: 358 entries, 0 to 357
Data columns (total 2 columns):
date     358  non-null values
price    358  non-null values
dtypes: float64(1), int64(1)

In [23]: df.head()
Out[23]: 
         date  price
0  1349720105  12.08
1  1349806505  12.35
2  1349892905  12.15
3  1349979305  12.19
4  1350065705  12.15
In [25]: df['date'] = pd.to_datetime(df['date'],unit='s')

In [26]: df.head()
Out[26]: 
                 date  price
0 2012-10-08 18:15:05  12.08
1 2012-10-09 18:15:05  12.35
2 2012-10-10 18:15:05  12.15
3 2012-10-11 18:15:05  12.19
4 2012-10-12 18:15:05  12.15

In [27]: df.dtypes
Out[27]: 
date     datetime64[ns]
price           float64
dtype: object
반응형
반응형

주식예측 퀴즈앱 꾸욱 사용후기

제작사 홈페이지

https://team-yacht.com/

 

꾸욱 by 팀요트 - 금융퀴즈게임

전국민이 즐기는 금융 예측 게임 어플리케이션 꾸욱. 매일 새롭게 제시되는 금융 주제의 결과를 예측하고 상금으루 주식도 받아가세요

team-yacht.com

다운로드

https://play.google.com/store/apps/details?id=com.team_yacht.ggook

 

꾸욱 - 주식예측 퀴즈앱 - Google Play 앱

누구나 참여 가능한 주식예측 퀴즈앱! 꾸욱 눌러서 예측하고 주식받자!

play.google.com

소개

주제에 맞추어 정답을 정확이 예측하면 상점을 얻게 됩니다.

시즌마다 상점을 제일 높이 받은 분이 우승 상금으로 실제 주식을 받게 됩니다.

특별상까지 규모는 적지만 주식을 약간 받게 됩니다.

사용방법

[집(Home) 아이콘 - 왼쪽 첫번째 메뉴]

풀고자 하는 주제를 체크합니다.

체크를 하기 위해서는 꾸욱 포인트가 있어야 하고 '꾸욱 얻으러 가기'를 클릭하여

광고를 하나씩 볼 때마다 1개의 꾸욱 포인트를 얻게 되고 이 포인트로 체크 표시가 가능하게 됩니다.

KOSPI는 상승할지 하락할 지를 예측하게 됩니다. (2021년 5월 13일 현재)

종목1 vs 종목2는 어떤 종목이 등락율이 높을 지를 예측하게 됩니다. (2021년 5월 13일 현재)

[기록 아이콘 - 제일 오른쪽 다섯번째 메뉴]

실제 주식 결과와 제가 예측한 종목이 맞는지 결과를 장 끝나면(오후 3시 40분~3시 50분 정도)

확인하실 수 있습니다.

[트로피 아이콘 - 가운데 세번째 메뉴]

현재 참여하고 있는 분들의 순위와 승점을 확인할 수 있습니다.

후기

주식 예측을 해서 리워드로 실제 주식을 받을 수 있는 것이 인상적이었습니다.

매일 간단하게 시황 정보도 push 메세지로 받을 수 있는 것도 좋은 점이라 생각합니다.

우승이나 특별상을 받아야 실제 주식으로 리워드를 받을 수 있습니다.

우승 한 번 해보고 싶네요.

반응형
반응형

출처

https://data-flair.training/blogs/rdd-lineage/

Spark에서 RDD 계보 정보(리니지): ToDebugString 메소드

1. 목적

기본적으로 Spark에서는 실제 데이터에도 RDD 간의 모든 종속성이 그래프에 기록됩니다. 이것이 우리가 Spark에서 계보 그래프라고 부르는 것입니다. 이 문서는 Spark 논리적 실행 계획의 RDD 계보 개념을 담고 있습니다. 또한 toDebugString 메서드로 RDD 계보 정보 그래프를 얻는 방법을 자세히 알게 될 것입니다. 먼저 Spark RDD에 대해서도 알아 보겠습니다.

2. Spark RDD 소개

Spark RDD는 "Resilient Distributed Dataset"의 약어 입니다. RDD를 Apache Spark의 기본 데이터 구조로 간주할 수 있습니다. 구체적으로 말하면 RDD는 Apache Spark의 변경 불가능한 개체 모음입니다. 이는 클러스터의 다른 노드에서 계산하는 데 도움이 됩니다.
Spark RDD의 이름을 분해 할 때 :

  • 탄력성

이것은 내결함성을 의미합니다. RDD 계보 정보 그래프(DAG)를 사용하여 노드 장애로 인해 누락되거나 손상된 파티션을 다시 계산할 수 있습니다.

  • 분산

데이터가 여러 노드에 있음을 의미합니다.

  • 데이터 세트

작업하는 데이터의 기록일 뿐 입니다. 또한 사용자는 데이터 세트를 외부에서 불러올 수 있습니다. 예를 들어, 특정 데이터 구조가 없는 JDBC를 통한 JSON 파일, CSV 파일, 텍스트 파일 또는 데이터베이스일 수 있습니다.

당신은 Spark dataSet 튜토리얼을 읽어야 합니다.

3. RDD 계보정보(리니지) 소개

기본적으로, RDD의 평가는 자연적으로 게으릅니다. 이는 변환의 시리즈가 RDD에서 수행되지만, 바로 평가되지는 않습니다.
Spark RDD로부터 새로운 RDD를 만드는 동안, 새로운 RDD는 Spark에서 부모 RDD의 포인터를 가져옵니다. 이는 실제 데이터가 아니라 그래프에 기록된 RDD 간의 모든 종속성과 동일합니다. 우리가 계보 그래프라고 부르는 것입니다. RDD 계보는 RDD의 모든 부모 RDD의 그래프일 뿐 입니다. RDD 연산자 그래프 또는 RDD 종속성 그래프라고도 합니다. 구체적으로 말하자면 스파크에 Transformation을 적용한 결과입니다. 그런 다음 논리적 실행 계획을 생성합니다.
또한 실제 실행 계획 또는 실행 DAG를 단계의 DAG라고 합니다.
잘 이해하기 위해 Cartesian 또는 zip을 사용하여 Spark RDD 계보의 한 예부터 시작하겠습니다. 그러나 다른 연산자를 사용하여 Spark에서 RDD 그래프를 작성할 수도 있습니다.

예시

위 그림은 다음과 같은 일련의 Transformation의 결과인 RDD 그래프를 보여줍니다.

Spark의 게으른 평가

val r00 = sc.parallelize(0 to 9)
val r01 = sc.parallelize(0 to 90 by 10)
val r10 = r00 cartesian df01
val r11 = r00.map(n => (n, n))
val r12 = r00 zip df01
val r13 = r01.keyBy(_ / 20)
val r20 = Seq(r11, r12, r13).foldLeft(r10)(_ union _)

다른 예시

다음과 같은 RDD val b=a.map()이 있다고 합시다.

RDD b는 부모 RDD a에 대한 참조를 유지해야 합니다. 이것이 RDD 계보 정보(리니지)의 종류입니다.

4. RDD 계보정보(리니지)의 논리적 실행 계획

기본적으로, 논리적 실행 계획은 초기 RDD들과 함께 초기화 됩니다. 초기 RDD는 다른 RDD에 의존하지 않는 RDD 일뿐입니다. 매우 구체적으로 말하자면 이들은 참조 캐시 데이터와 독립적입니다. 또한 실행을 위해 호출된 작업의 결과를 생성하는 RDD로 끝납니다.

Spark 작업을 실행하기 위해 SparkContext가 요청될 때 실행되는 DAG라고도 말할 수 있습니다.

5. Spark에서 RDD 계보정보(리니지) 그래프를 얻기 위한 ToDebugString 메소드

Spark에서 RDD 계보정보(리니지) 그래프를 얻기 위한 몇가지 방법이 있지만, 메소드 중 하나는 toDebugString 메소드 입니다.

toDebugString: String

Spark DStream 살펴보기

기본적으로 이 방법을 사용하여 Spark RDD 계보정보(리니지) 그래프에 대해 배울 수 있습니다.

scala> val wordCount1 = sc.textFile(“README.md”).flatMap(_.split(“\\s+”)).map((_, 1)).reduceByKey(_ + _)
wordCount1: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[21] at reduceByKey at <console>:24
scala> wordCount1.toDebugString
res13: String =
(2) ShuffledRDD[21] at reduceByKey at <console>:24 []
+-(2) MapPartitionsRDD[20] at map at <console>:24 []
|  MapPartitionsRDD[19] at flatMap at <console>:24 []
|  README.md MapPartitionsRDD[18] at textFile at <console>:24 []
|  README.md HadoopRDD[17] at textFile at <console>:24 []

기본적으로 여기에서 괄호() 안의 H는 각 단계에서 병렬 처리 수준을 나타내는 숫자를 나타냅니다.
예를 들어, 위 출력에서 (2) 입니다.

scala> wordCount1.getNumPartitions
res14: Int = 2

toDebugString 메서드는 action을 실행할 때 포함되며 spark.logLineage 속성이 활성화됩니다.

$ ./bin/spark-shell –conf spark.logLineage=true
scala> sc.textFile(“README.md”, 4).count
…
15/10/17 14:46:42 INFO SparkContext: Starting job: count at <console>:25
15/10/17 14:46:42 INFO SparkContext: RDD’s recursive dependencies:
(4) MapPartitionsRDD[1] at textFile at <console>:25 []
|  README.md HadoopRDD[0] at textFile at <console>:25 []

Spark 성능 조정에 대해 읽어 보세요.

그래서 이것은 Spark RDD Lineage Tutorial에 관한 것입니다. 우리의 설명이 마음에 드셨으면 좋겠습니다.

6. 결론

따라서 이 블로그를 통해 Apache Spark RDD 계보정보(리니지) 그래프의 실제 의미를 배웠습니다. 또한 Apache Spark에서 논리적 실행 계획의 풍미를 맛 보았습니다. 그러나 toDebugString 메서드도 자세히 살펴 보았습니다. 또한 Apache Spark RDD에서 모든 계보정보(리니지) 그래프 개념을 다루었습니다.

또한 궁금한 점이 있으시면 댓글란에 문의 해주세요.

Spark를 배우려면 인기 도서를 참조하십시오.

반응형
반응형

출처

https://unix.stackexchange.com/questions/295274/grep-to-find-the-correct-line-sed-to-change-the-contents-then-putting-it-back

수정할 라인을 grep으로 찾고, 내용을 sed로 바꾼 뒤 원래 파일에 적용하는 방법?

저는 파일에서 특정 라인에 한 단어를 바꾸려고 합니다만 이 모두를 연결하는데 몇가지 문제가 있습니다.

기본적으로 제 파일의 한 라인은 키워드 'firmware_revision'이며 이 라인에서만 'test' 단어를 'production'으로 변경하고 싶습니다.

저는 이렇게 해 보았습니다.

grep 'firmware_revision' myfile.py | sed 's/test/production'

이 방법으로 제가 원하는 라인을 선택하여 대체를 실행할 수 있겠지만, 이전 줄을 대체하기 위해 새 줄을 원본 파일로 적용하는 방법은 알 수 없습니다. 분명히 파일로 다시 redirection할 수는 없습니다. 어떻게 해야 할까요?

임시 파일을 사용하더라도 grep을 사용하여 필요한 줄만 가져 오면 파일의 다른 모든 데이터가 손실되므로 더 이상 모든 데이터를 임시 파일로 리디렉션 한 다음 원본을 임시 파일로 바꿀 수 없습니다.

편집-누군가가 추가 정보를 요청했습니다.

다음과 같은 줄로 가득 찬 파일이 있다고 가정해 봅시다.

[
  ('key_name1', str, 'value1', 'Description'),
  ('key_name2', str, 'value2', 'Description'),
  ('key_name3', str, 'value3', 'Description'),
  ('firmware_revision', str, 'my-firmware-name-test', 'Firmware revision name')
]

이제 'firmware_revision'이 포함된 줄을 찾고 해당 줄에서 'test'라는 단어의 모든 인스턴스를 'production'으로 변경하는 스크립트 (이상적으로는 한 줄짜리)를 작성하고 싶습니다. '테스트'라는 단어는 해당 파일의 다른 위치에 있을 수 있으며 변경하지 않기를 바랍니다. 명확하게 하기 위해 위의 줄을 다음과 같이 변경하고 싶습니다.

('firmware_revision', str, 'my-firmware-name-production', 'Firmware revision name')

어떻게 해야 합니까?


2개 답변 중 1개

다음을 시도해 보세요.

sed -i.bak '/firmware_revision/ s/test/production/' myfile.py

여기 /firmware_revision/은 조건처럼 작동합니다. 정규식 firmware_revision과 매칭되는 라인이면 true(참) 이고 다른 라인에 대해서는 false(거짓)입니다. 조건이 true이면 다음 명령이 실행됩니다. 이 경우, 저 명령은 testproduction으로 처음 나왔을 때 대체하는 명령입니다.

다른 말로, 명령어 s/test/production/firmware_revision의 정규식과 매칭되는 라인에서만 실행됩니다. 모든 다른 라인은 변경되지 않고 지나갑니다.

기본적으로 sed는 표준출력으로 그것을 보냅니다. 하지만, 당신이 파일에 변경사항을 적용하고 싶다면, -i 옵션을 추가할 수 있습니다. 특별히, -i.bakbak 확장자로 지정된 백업 복사본으로 파일이 변경 되도록 합니다.

명령이 작동한다고 결정하고 위험하게 백업을 생성하지 않으려면 GNU sed (Linux)를 사용하여 다음을 사용하십시오.

sed -i '/firmware_revision/ s/test/production/' myfile.py

반면, BSD (OSX)에서는 -i 옵션은 argument를 가져야 합니다. 만약 백업을 남겨놓지 않길 바라면, 비어있는 argument를 제공해야 합니다. 다음처럼 사용하십시오.

편집

질문에 대한 편집에서 OP는 라인의 모든 test 발생이 production으로 대체 되도록 요청합니다. 이 경우 전역 (해당 행) 대체를 위해 대체 명령에 g 옵션을 추가합니다.

sed -i.bak '/firmware_revision/ s/test/production/g' myfile.py
반응형
반응형

출처

https://dzone.com/articles/java-8-how-to-create-executable-fatjar-without-ide

명령줄로 실행 가능한 Fat JAR 생성하기

명령줄 만으로 실행 가능한 fat JAR 파일을 만들고 실행하고 싶으십니까? 필요한 기초 작업과 수행 방법을 확인하십시오.

이 글은 추가 플러그인, IDE 또는 다른 도구를 사용하지 않고 순수한 명령 줄과 Java에서 Fat JAR (Java 아카이브 파일)을 만들 수 있는 가능성을 검토하는 내 블로그 게시물을 통합한 내용입니다.

빌드 도구 (Ant, Maven 또는 Gradle)의 세계에서는 명령줄에 대해 생각하는 것이 유용하지 않을 수도 있습니다. 가장 유명한 IDE (IntelliJ, Eclipse 또는 NetBeans)는 빌드 도구와 구현을 즉시 제공합니다. 그러나 명령줄 만 있고 인터넷에 액세스 할 수 없다고 가정해 보겠습니다.

그러면 어떻게 하시겠습니까?

파트 1: ExecutableOne.jar 컴파일 (GitHub)

이 첫 번째 부분의 목표는 실행 가능한 JAR 파일을 만드는 것입니다. ExecutableOne.jar 이라고 부르겠습니다. 명령줄을 열어서 간단한 프로젝트 폴더를 생성해 보겠습니다. 예제 프로젝트 구조는 Maven 표준 디렉토리 레이아웃 구조를 따릅니다.

./libs
./out
./README.md
./src
./src/main
./src/main/java
./src/main/java/com
./src/main/java/com/exec
./src/main/java/com/exec/one
./src/main/resources

우리의 의도는 실행 가능한 JAR 파일을 만드는 것이므로 기본 클래스를 만들어야 합니다. com.exec.one 패키지에서 해봅시다. 패키지는 샘플 프로젝트 구조의 SRC/MAIN/JAVA 폴더에서 찾을 수 있습니다.

package com.exec.one;

public class Main {
    public static void main(String[] args){                                                                                 
        System.out.println("Main Class Start");                     
    }                                                      
}

SRC/MAIN/RESOURCES 폴더 안에 META-INF 폴더를 만든 다음 그 안에 MANIFEST.MF 파일을 배치합니다. 새로 생성된 MANIFEST.MF 파일을 열고 기본 설명을 입력해 보겠습니다.

Manifest-Version: 1.0   
Class-Path: .                                                                                                                                                                          
Main-Class: com.exec.one.Main

참고 : JAR 파일 당 하나의 MANIFEST.MF 파일만 있습니다.

MANIFEST.FM 파일에는 JAR 파일이 사용되는 방법에 대한 세부 사항이 포함되어 있습니다. 자세한 내용은 다루지 않습니다. 정의한 옵션에 집중하겠습니다.

  1. Manifest-Version : manifest 파일 버전입니다.
  2. 클래스 경로 : 애플리케이션 또는 확장 클래스 로더는 이 속성 값을 사용하여 내부 검색 경로를 구성합니다. 원래 클래스 로더는 검색 경로에서 각 요소를 다운로드하고 엽니다. 이러한 목적을 위해 간단한 선형 검색 알고리즘이 사용되었습니다.
  3. Main-Class : 시작시에 런처가 로드할 클래스의 이름이 있습니다.

이제 *.jar 라이브러리없이 JAR 파일을 생성합니다. 프로젝트 구조의 LIBS 폴더는 여전히 비어 있습니다. 이렇게 하려면 먼저 javac를 사용하여 프로젝트를 컴파일해야합니다. 한편 출력은 OUT 폴더에 저장합니다. 명령 줄로 돌아가서 프로젝트 루트 안에 다음을 입력해 보겠습니다.

$javac -cp ./src/main/java ./src/main/java/com/exec/one/*.java -d ./out/

프로젝트가 OUT 디렉터리로 컴파일되었습니다. ls 명령을 사용하여 확인할 수 있습니다.

두 번째 단계는 OUT 디렉터리에 있는 리소스에서 실행 가능한 JAR 파일을 만드는 것입니다. 명령줄로 돌아가서 다음 명령을 실행합니다.

$jar cvfm ExecutableOne.jar ./src/main/resources/META-INF/MANIFEST.MF -C ./out/ .

우리가 사용한 JAR 도구 옵션을 간단히 검토 및 설명해 보겠습니다.

  • c : 새 JAR 파일을 만들려고 함을 나타냅니다.
  • v : 표준 출력에 대한 자세한 출력을 생성합니다.
  • f : 생성 할 jar 파일을 지정합니다.
  • m : 우리가 사용하는 매니페스트 파일을 나타냅니다. 매니페스트 파일에는 이름-값 쌍이 포함됩니다.
  • -C : 디렉토리에 대한 임시 변경을 나타냅니다. 이 디렉토리에서 JAR 파일로 클래스가 추가됩니다. 점은 모든 클래스 (파일)를 나타냅니다.

최종 출력을 위해 명령줄을 열고 다음을 입력합니다.

$java -jar ./ExecutableOne.jar

standard output: 
Main Class Start

잘 했습니다! 파트 2로 이동하겠습니다.

파트 2: 추가적인 패키지와 함께 ExecutableOne.jar 컴파일

이 섹션의 주요 목표는 추가적인 패키지를 포함하여 실행 가능한 JAR 파일을 컴파일 아는 방법을 보여드리겠습니다. 이러한 목적을 위해, 우리는 MagicService를 만들 것입니다. 이 서비스는 우리에게 getMessage() 메소드를 우리에게 제공하며 표준 출력으로 메세지를 출력합니다.

명령줄을 열어 새로운 폴더 _SERVICE_와 파일 MagicService.java를 만듭니다.

$mkdir src/main/java/com/exec/one/service
$vi src/main/java/com/exec/one/service/MagicService.java

새롭게 만들어진 MagicService는 다음 예제에서 사용될 수 있습니다.

package com.exec.one.service;                                                                                                                                                          
public class MagicService {                                                                                                                                                            
  private final String message;                                       
    public MagicService(){ 
        this.message = "Magic Message";
    }                    

    public String getMessage(){                                                      
         return message;                              
    }
}

MagicService는 Main 클래스보다 패키싲 구조에서 다른 위치에 있습니다. 이제 우리는 Main 클래스로 돌아가서 새롭게 만든 MagicService를 import 합니다. import하고 서비스 인스턴스를 만든 뒤에 Main 클래스는 getMessage() 메소드로 접근을 할 것입니다. Main 클래스는 다음 방법으로 변경될 것입니다.

package com.exec.one;                                                                                                                                                                  
import com.exec.one.service.MagicService;                                                                                                                                              
public class Main {                                                                                                         
    public static void main(String[] args){
        System.out.println("Main Class Start");            
        MagicService service = new MagicService();          
        System.out.println("MESSAGE : " + service.getMessage());
     }
} 

이제 코드를 컴파일 할 준비가 된 지점에 도달했습니다. 명령줄로 돌아가 Executable-One 프로젝트의 루트 폴더로 이동하겠습니다. 첫 번째 단계는 Executable-One 프로젝트를 OUT 폴더로 컴파일 / 재컴파일하는 것입니다. 이를 위해 새로 생성된 MagicService.java 클래스의 위치를 추가해야 합니다.

javac -cp ./src/main/java ./src/main/java/com/exec/one/*.java ./src/main/java/com/exec/one/**/*.java -d ./out/

두 번째 단계는 컴파일된 클래스에서 실행 가능한 JAR 파일을 만드는 것입니다. JAR 파일 논리를 변경하지 않았으므로 명령을 변경할 필요가 없습니다. 이는 MANIFEST.FM 파일이 변경없이 그대로 유지됨을 의미합니다.

Manifest-Version: 1.0
Class-Path: .                                                           
Main-Class: com.exec.one.Main

이제 샘플 프로젝트의 루트 디렉토리에서 Part 1과 유사한 명령을 다시 실행할 수 있습니다.

jar cvfm ExecutableOne.jar ./src/main/resources/META-INF/MANIFEST.MF -C ./out/ .

생성된 JAR 파일을 실행하여 표준 출력에 인쇄된 메시지를 얻습니다.

$java -jar ExecutableOne.jar 
output: 
Main Class Start
MESSAGE : Magic Message

축하합니다. 다시 잘 하셨습니다!

파트 3: 실행 가능한 Fat JAR 생성하기 (GitHub)

이 파트의 목표는 개발된 프로그램에서 모든 필요한 의존성을 포함하는 fat JAR(Java Archive)를 생성하는 것입니다. 외부 라이브러리로 우리는 파트 2에서 생성된 JAR 파일을 사용할 필요가 있습니다. 파트 3에서 우리는 (위의 링크에서 다운로드 받을 수 있는) "Executable-Two"라고 불리는 샘플 프로젝트를 생성합니다.

executable-two 프로젝트는 다음과 같은 폴더 구조를 가집니다.

./libs
./libs/ExecutableOne.jar
./out
./README.md
./src
./src/main
./src/main/java
./src/main/java/com
./src/main/java/com/exec
./src/main/java/com/exec/two
./src/main/java/com/exec/two/Main.java
./src/main/resources
./src/main/resources/META-INF
./src/main/resources/META-INF/MANIFEST.MF

LIBS 폴더는 전에 생성된 "ExecutableOne.jar"를 포함합니다. "ExecutableOne.jar"는 우리가 ExecutableTwo 안에서 사용될 MagicService 클래스를 포함합니다. 우리는 클래스 MagicService를 인스턴스화 하여 public 메소드 getMessage()를 실행할 것입니다. 프로젝트 "ExecutableTwo"의 메인 클래스 안에서 이 모든 것이 발생할 것입니다.

프로젝트 패키지 com.exec.two 에서 다음 메인 클래스를 생성합시다.

package com.exec.two;                                                                                                                                                                  
import com.exec.one.service.MagicService;                                                                                                                                              
public class Main {
    public static void main(String[] args){
        System.out.println("Executable-Two Main");
        MagicService service = new MagicService();                                                                                 System.out.println("MagicService from Executable-ONE");                                                                     System.out.println("MESSAGE: " + service.getMessage());
     }
}

이제 우리는 JAR 파일 생성의 모든 것이 준비 되었습니다. 이전에 생성한 getMessage() 메소드를 실행한 JAR 라이브러리에서 MagicService를 가져 왔습니다. 다음 몇 단계에서는 Java JDK에서 제공하는 javac 및 JAR 도구를 사용합니다. 명령 줄로 돌아가서 프로젝트를 컴파일해 보겠습니다. 명령에서 클래스 경로를 사용된 라이브러리로 확장해야 함을 컴파일러에 알려야합니다.

$javac -cp ./src/main/java 
./src/main/java/com/exec/two/*.java -d ./out/ 
-classpath ./libs/ExecutableOne.jar

"Executable-Two" 프로젝트가 OUT 디렉토리로 성공적으로 컴파일 되었습니다.

이제 fat JAR 생성을 위해 OUT 디렉토리를 적절하게 준비할 때입니다. OUT 디렉토리 안에는 "Executable-Two"를 위해 만든 컴파일 된 클래스가 있습니다. 한편, JAR 도구는 파일 시스템에 물리적으로 위치한 파일만 읽습니다. 압축된 JAR 파일은 읽지 않습니다. 물론 이는 JAR 도구가 OUT 디렉토리에있는 * .jar 파일의 압축을 풀거나 읽지 않음을 의미합니다.

그 결과 ExecutableOne.jar을 OUT 디렉토리에 복사하더라도 JAR 도구는 ExecutableOne.jar 파일의 압축을 풀지 않고 라이브러리가 결과에 추가됩니다 (압축된 형태로). 물론 압축 되었기 때문에 무시됩니다.

문제는 $java -jar 도구가 내부 패키지 *.jar 아카이브 파일을 읽지 않는다는 것입니다!

이는 이전에 생성된 Java 아카이브 (JAR) "Executable-One.jar"을 "Executable-Two" 프로젝트의 OUT 디렉토리에 압축 해제해야 함을 의미합니다. 명령 줄을 열고 다음을 입력합니다.

$cp libs/ExecutableOne.jar ./out/
$cd ./out
$jar xf ExecutableOne.jar
$rm ExecutableOne.jar

이제 "Executable-Two" 프로젝트 출력 디렉토리를 새 JAR 파일의 소스 폴더로 사용할 준비가 되었습니다.

참고: 모든 실행 가능한 JAR 파일에는 하나의 MANIFEST.FM 파일만 사용할 수 있습니다.

"Executable-Two"프로젝트를 JAR 아카이브 파일에 묶기 위해 ./src/main/resources/META-INF/ 폴더에 새로 생성된 매니페스트 파일을 사용합니다.

Manifest-Version: 1.0                              
Class-Path: .                                      
Main-Class: com.exec.two.Main

다음처럼 타이핑하여 이 모두를 묶을 수 있습니다..

$jar cvfm ExecutableTwo.jar ./src/main/resources/META-INF/MANIFEST.FM -C./out/ .

새로 생성된 fat JAR 파일인 "ExecutableTwo.jar"을 실행하면 다음과 같은 출력이 나타납니다.

$java -jar ./ExecutableTwo.jar
output:
Executable-Two Main
MagicService from Executable-ONE
MESSAGE: Magic Message

축하합니다! 당신은 fat JAR 파일을 실행했습니다!

반응형
반응형

출처

https://stackoverflow.com/questions/19382593/how-to-compile-java-package-structures-using-javac

javac를 사용하여 자바 패키지 구조를 컴파일 하는 방법

다른 패키지를 가져 오는 Java 패키지를 (명령 줄에서) 컴파일 하려고 합니다. 튜토리얼 온라인을 따르고 있었지만 최종 자바 파일 (CallPackage.java)을 컴파일 하려고 하면 오류가 발생하는 것 같습니다.

다음은 파일 구조입니다.

+ test_directory (contains CallPackage.java)
   -> importpackage
       -> subpackage (contains HelloWorld.java)

다음은 CallPackage.java 입니다.

/// CallPackage.java
import importpackage.subpackage.*;
class CallPackage{
  public static void main(String[] args){
  HelloWorld h2=new HelloWorld();
  h2.show();
  }
}

그리도 다음은 HelloWorld.java 입니다.

///HelloWorld.java

package importpackage.subpackage;

public class HelloWorld {
  public void show(){
  System.out.println("This is the function of the class HelloWorld!!");
  }
}

시도했던 단계

  1. subpackage로 가서 HelloWorld.java를 $javac HelloWorld.java로 컴파일 하였습니다.
  2. test_directory로 가서 CallPackage.java를 $javac CallPackage.java로 컴파일 하였습니다.

이는 마지막 명령에서 다음과 같은 오류를 저에게 제공하였습니다.

CallPackage.java:1: package importpackage.subpackage does not exist
import importpackage.subpackage.*;
^
CallPackage.java:4: cannot find symbol
symbol  : class HelloWorld
location: class CallPackage
  HelloWorld h2=new HelloWorld();
  ^
CallPackage.java:4: cannot find symbol
symbol  : class HelloWorld
location: class CallPackage
  HelloWorld h2=new HelloWorld();
                    ^
3 errors

두 패키지 모두 컴파일을 어떻게 할 수 있을까요? 어떠한 도움이든 감사드립니다!


6개 답변 중 1개만 추림

문제는 각 명령 (javac 및 java)에 대해 클래스 경로를 설정해야 한다는 것입니다.

시도한 단계

  1. 하위 패키지로 이동하는 대신 최상위 수준에서 HelloWorld.java를 컴파일합니다.
$ javac -cp . importpackage/subpackage/HelloWorld.java
  1. 같은 방법으로 CallPackage.java를 컴파일합니다.
$ javac -cp . CallPackage.java
  1. 클래스 경로를 사용하여 파일을 실행하십시오.
$ java -cp . CallPackage

참고 : "$ java CallPackage"를 실행하면 "오류 : 주 클래스 CallPackage를 찾거나 로드 할 수 없습니다" 오류가 발생합니다.

요약하면 각 단계에서 클래스 경로를 지정해야 합니다. 그렇게 실행한 후에 작동했습니다.

반응형
반응형

출처

https://stackoverflow.com/questions/18431857/compile-source-file-to-a-different-directory

소스 파일을 다른 디렉터리로 컴파일?

다른 디렉터리로 자바 소스 파일 (*.java)를 컴파일 하는 방법이 있을까요?

만약 제 패키지 파일 구조가 다음과 같습니다.

Mathematics ->
  Formulas ->
    src ->
      // 수학 공식을 포함하는 소스 파일...
    bin ->
      // 수학 공식을 포함하는 class 파일...
  Problems ->
    src ->
      // 수학 문제를 포함하는 소스 파일...
    bin ->
      // 수학 문제를 포함하는 class 파일...

저는 소스와 class 파일을 폴더 구조를 유지한 채로 분리하고 싶고, 컴파일 할 때마다 src 폴더를 bin 폴더로 모든 class 파일을 복사해야 합니다.

javac 명령어로 다른 폴더로 클래스 파일을 컴파일함으로써 이 과정을 간단하게 하는 방법이 있을까요?


1개의 답변

옙, 절대적으로 출력 디렉터리를 지정하기 위해 -d 옵션을 사용합니다.

javac -d bin src/foo/bar/*.java

당신이 지정한 디렉터리는 출력 구조의 루트 입니다. 관련 하위 디렉토리는 코드의 패키지 구조에 따라 자동으로 생성됩니다.

자세한 내용은 javac 문서를 참조하십시오.

이 경우 하나의 javac 명령을 실행하여 공식 디렉터리를 컴파일하고 다른 하나는 문제 디렉터리를 컴파일 해야 합니다. 잠재적으로 문제 디렉터리를 컴파일 할 때 클래스 경로의 일부로 공식 bin 디렉토리를 사용합니다.

(단일 소스 구조를 사용하지만 다른 패키지를 사용하는 것을 고려할 수도 있습니다. IDE를 사용하여 이러한 복잡성 중 일부를 숨기는 것도 고려해야 합니다. 실제로는 어렵지 않더라도 이 모든 작업을 수작업으로 수행하는 데 지치게 됩니다.)

반응형
반응형

출처

https://sparkbyexamples.com/spark/spark-how-to-create-an-empty-dataset/

Spark - 비어있는 Dataset을 만드는 방법

이 글에서, 저는 몇가지 Scala 예시를 사용하여 비어있는 Spark Dataset(emptyDataset())을 스키마가 있고 없고에 따라 만드는 방법을 설명하겠습니다. 우리는 시작하기 전에, 비어있는 Dataset을 만들 필요가 있는 많은 시나리오 중에 하나를 설명하겠습니다.

Spark에서 파일로 작업하는 동안 처리할 파일을 받지 못하는 경우도 있지만, 파일을 받을 때 생성한 데이터 세트와 유사한 (동일한 스키마) 빈 데이터 세트를 생성해야 합니다. 동일한 스키마로 생성하지 않으면 표시되지 않을 수 있는 열을 참조하므로 데이터 세트에 대한 작업 / 변환이 실패합니다.

관련글: Spark 비어있는 DataFrame 생성하기

이와 유사한 상황을 처리하려면 항상 동일한 스키마로 Dataset을 생성해야 합니다. 즉, 파일이 존재하거나 빈 파일 처리에 관계없이 동일한 열 이름과 데이터 유형을 의미합니다.

먼저 예제 전체에서 사용할 SparkSessionSpark StructType 스키마와 case class를 생성해 보겠습니다.

val spark:SparkSession = SparkSession.builder()
   .master("local[1]")
   .appName("SparkByExamples.com")
   .getOrCreate()

import spark.implicits._

val schema = StructType(
    StructField("firstName", StringType, true) ::
      StructField("lastName", IntegerType, false) ::
      StructField("middleName", IntegerType, false) :: Nil)

val colSeq = Seq("firstName","lastName","middleName")
case class Name(firstName: String, lastName: String, middleName:String)

emptyDataset() – 컬럼이 없는 비어있는 Dataset 생성

SparkSession은 스키마 없이 빈 Dataset을 반환하는 emptyDataset() 메서드를 제공하지만 이것은 우리가 원하는 것이 아닙니다. 다음 예제는 스키마로 생성하는 방법을 보여줍니다.

case class Empty()
val ds0 = spark.emptyDataset[Empty]
ds0.printSchema()
// Outputs following
root

emptyDataset() – 스키마로 비어있는 Dataset 생성

아래 예에서는 스키마 (열 이름 및 데이터 type)가 있는 Spark 빈 데이터 세트를 만듭니다.

val ds1=spark.emptyDataset[Name]
ds1.printSchema()
// Outputs following
root
 |-- firstName: string (nullable = true)
 |-- lastName: string (nullable = true)
 |-- middleName: string (nullable = true)

createDataset() – 스키마로 비어있는 Dataset 생성

SparkSession의 createDataset() 메서드를 사용하여 스키마가 있는 빈 Spark Dataset을 만들 수 있습니다. 아래의 두 번째 예는 먼저 빈 RDD를 생성하고 RDD를 데이터 셋으로 변환하는 방법을 설명합니다.

val ds2=spark.createDataset(Seq.empty[Name])
ds2.printSchema()
val ds3=spark.createDataset(spark.sparkContext.emptyRDD[Name])
ds3.printSchema()
//These both Outputs following
root
 |-- firstName: string (nullable = true)
 |-- lastName: string (nullable = true)
 |-- middleName: string (nullable = true)

createDataset () – 기본 열 이름으로 빈 Dataset 만들기

val ds4=spark.createDataset(Seq.empty[(String,String,String)])
ds4.printSchema()
// Outputs following
root
 |-- _1: string (nullable = true)
 |-- _2: string (nullable = true)
 |-- _3: string (nullable = true)

암시적인 인코더 사용

암시적인 인코더를 사용하는 다른 방법을 살펴 보겠습니다.

val ds5 = Seq.empty[(String,String,String)].toDS()
ds5.printSchema()
// Outputs following
root
 |-- _1: string (nullable = true)
 |-- _2: string (nullable = true)
 |-- _3: string (nullable = true)

case class 사용

Scala case class에서 원하는 스키마로 빈 데이터 세트를 만들 수도 있습니다.

val ds6 = Seq.empty[Name].toDS()
ds6.printSchema()
// Outputs following
root
 |-- firstName: string (nullable = true)
 |-- lastName: string (nullable = true)
 |-- middleName: string (nullable = true)
반응형

+ Recent posts