โ๏ธ ์ค๋ฌด์์ ์์ ์ด๋ CSV ํ์ผ์ ๋ค์ด๋ก๋ํ๊ฑฐ๋ ์ ๋ก๋ํ๋ ๊ธฐ๋ฅ์ ๊ตฌํํ๋ ๊ฒฝํ์ด ์๋๋ฐ, ์์ ์ ๊ฒฝ์ฐ Apache ์ฌ๋จ์์ ์ ๊ณตํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ด์ฉํด์ ๊ตฌํํ๊ณ , CSV์ ๊ฒฝ์ฐ ByteArrayInputStream ์ผ๋ก ๊ตฌํํ์๋ค.
ํ์ง๋ง ๋น์์๋ ๊ทธ๋ฅ ์ด ํด๋์ค๋ฅผ ์ฐ๋ฉด ํ์ผ์ ๋ค์ด๋ก๋/์ ๋ก๋ ํ ์ ์๋ค๋ ๊ฒ๋ง ์๊ณ ์ด๋ป๊ฒ ๋ค์ด๋ก๋/์ ๋ก๋๋ฅผ ํ ์ ์๋์ง ์์ง ๋ชปํ๋ค. ์ด๋ฒ ์๊ฐ์ ํตํด I/O, File, I/O Stream ์ ๋ํด ๊ณต๋ถํด๋ณด์!
File
java.io ํจํค์ง์ ์ํ๋ ํด๋์ค๋ก ํ์ผ๋ฟ๋ง ์๋๋ผ ํ์ผ์ ๊ฒฝ๋ก๊น์ง ํฌํจํ๋ ํฌ๊ด์ ์ธ ํด๋์ค์ด๋ค. ๋๋ฌธ์ ๋ชฉ์ ์ ๋ชจํธ์ฑ ๋๋ฌธ์ Java 7 ๋ถํฐ NIO2 ํจํค์ง๋ฅผ ์ ๊ณตํ๋ฉด์ Files ํด๋์ค๊ฐ ์ถ๊ฐ๋๋๋ฐ, ์ด๋ File ํด๋์ค ๋๋ถ๋ถ์ ๋ฉ์๋๋ฅผ ๋์ฒดํ์ฌ ์ ๊ณตํ๊ณ ์๋ค.
๊ทธ๋ฆฌ๊ณ File ํด๋์ค๋ ์ง์ ๊ฐ์ฒด๋ฅผ ์์ฑํด์ผ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌ ํ ์ ์๋ ๊ฒ์ ๋ฐํด, Files ํด๋์ค๋ ๋ชจ๋ ๋ฉ์๋๋ฅผ static ์ผ๋ก ์ ์ธ ํ๊ธฐ ๋๋ฌธ์ ๋ณ๋๋ก ๊ฐ์ฒด๋ฅผ ์์ฑํด์ผ ํ๋ ๋ฒ๊ฑฐ๋ก์์ด ์ค์ด ๋ค์๋ค.
I/O
Input๊ณผ Output์ ์๋ฏธํ๋ฉฐ, Input์ ๋ง์ฐ์ค์ ํด๋ฆญ์ด๋ ํค๋ณด๋์ ์ ๋ ฅ ๋ฑ์ด ์ํ๊ณ , Output์ ์คํผ์ปค๋ ๋ชจ๋ํฐ ํ๋ฉด์ ์ถ๋ ฅ ๋ฑ์ด ์ํ๋ค. ์ฆ, java.io ํจํค์ง์ ์ํ ํด๋์ค๋ค์ Stream์ ํตํด ๋จ๋ฐฉํฅ์ผ๋ก JVM ์ธ๋ถ์ ์๋ ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ฑฐ๋ ์ธ ์ ์๋ค.
ํด๋น ๋ถ๋ถ์ ๊ณต๋ถํ๋ฉด์ Java๊ฐ ํ์ผ์ ์ฝ๊ณ ์ฐ๋ ๋ฐฉ๋ฒ์ด ๊ถ๊ธํด์ก๋ค.
Java๋ FileSystem ์ด๋ผ๋ ์ถ์ ํด๋์ค๋ฅผ ํตํด OS์ ํ์ผ ์์คํ
์ ์ ๊ทผ ํ ์ ์์ผ๋ฉฐ ๋ฉค๋ฒ ํ๋์ ๋ช ๋ถ๋ถ์ @Native ์ด๋
ธํ
์ด์
์ด ์ ์ธ๋์ด JNI๋ก ๊ตฌํ๋์ด ์๋ ๊ฒ์ ์ ์ ์๋๋ฐ, ์ด๋ฅผ ํตํด Java๋ JVM๊ณผ JNI๋ฅผ ํตํด ํ์ผ ์ ๊ทผ ๋ฐฉ์์ ๋ฉํํด์ ์๋ํ๋ ๊ฒ์ ์ ์ ์๋ค.
์ฆ, ํ์ผ์ ์ ๊ทผํ๊ธฐ ์ํด์๋ OS์ ์ปค๋์ ํตํด ์ ๊ทผํด์ผ ํ๋ฉฐ, ์ปค๋์ ํ์ผ ์ ๊ทผ ๋ช
๋ น์ ๋ด๋ฆฌ๊ธฐ ์ํด์๋ System Call์ ์ด์ฉํด ๋ช
๋ น์ ๋ด๋ ค์ผ ํ๋๋ฐ, ์ด๋ฅผ JVM์ ํตํด ์ถ์ํํ์ฌ ์ ๊ทผ ํ ์ ์๋ค.
1. JVM์ด OS์ ํ์ผ ์์คํ
์ ์ ๊ทผํ๋ ๋ฐฉ๋ฒ?
How JVM access the file system
I have an argument with my boss who is convinced that the JVM uses JNI to access native things like the file system. I think he is wrong because the JVM itself is a native code and it communicates
stackoverflow.com
2. JVM์ ์ด๋ป๊ฒ ํ์ผ ์ฝ๊ธฐ/์ฐ๊ธฐ๋ฅผ ๊ตฌํํ๋๊ฐ?
How do the JVM and Java implement reading from and writing to files?
In Java, you can read from and write to files. But the JVM can run on many systems that may have different ways of storing files and related data. How does one write JVM code that works on every sy...
stackoverflow.com
3. JVM์ด ํ์ผ์ ์ฝ์ ๋ System Call ์ง์ ์ํํ๋๊ฐ?
Does a file read from a Java application invoke a system call?
My understanding is that a user application requesting a file system path (eg. /aFile) will invoke the File System and get back the virtual address of the requested file. Then the application will
stackoverflow.com
JDK 1.4 ์ด์ ์๋ Stream์ด๋ผ๋ ๋จ๋ฐฉํฅ ํต๋ก๋ฅผ ํตํด ๋ฆฌ์์ค๋ฅผ ์ฐ๊ณ ์ฝ์๋๋ฐ, Stream์ ๋ฆฌ์์ค๋ฅผ ์ฝ๊ณ ์ฐ๊ธฐ ์ํด์ ์ด 2๊ฐ์ Stream์ ์์ฑํด์ผ ํ๋ ๋ฒ๊ฑฐ๋ก์์ด ์๊ณ , ํด๋น ์์ ์ ์ํํ๋ ๋์ ๋ค๋ฅธ ์์ ์ ์ํ ํ ์ ์๋ค๋ ๋จ์ (Blocking, Sync)์ด ์กด์ฌํ๋ค.
์ด๋ฅผ ๊ฐ์ ํ NIO ๋ผ๋ ํจํค์ง๋ฅผ JDK 1.4์ ์ง์ํ๋ฏ๋ก์จ ๋ฆฌ์์ค ์ ๊ทผ ๋ฐฉ์์ด Stream ๋ง๊ณ ๋ Buffer์ Channel ์ด ์ถ๊ฐ๋๋ฉด์ ๋น๋๊ธฐ์, Non-Blocking ๋ฐฉ์์ผ๋ก ๋ ๋น ๋ฅด๊ณ ์ ์ฐํ๊ฒ ์ ๊ทผ ํ ์ ์๊ฒ ๋์๋ค.
ํด๋น ๋ถ๋ถ์ Buffer์ Channel, Sync/Async, Blocking/Non-Blocking์ ๊ณต๋ถํ๋ฉด์ ์์ธํ ์์๋ณด์.
Stream
Stream์ด๋ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ์ ์ ์๋ ๋จ๋ฐฉํฅ ํต๋ก๋ก ํค๋ณด๋๋ ๋ง์ฐ์ค ๋ฑ์ ์ฅ์น๋ก ์ ๋ ฅํ์ฌ ์ ๋ฌํ๋ ๊ฒ์ InputStream, ์ธ๋ถ์ ์๋ฒ๋ก์ ๋ฐ์ดํฐ ์ ์ก์ด๋ ๋ชจ๋ํฐ, ์คํผ์ปค ๋ฑ์ ์ฅ์น๋ก ์ถ๋ ฅ๋๋ ๊ฒ์ OutputStream ์ด๋ผ๊ณ ํ๋ค.
InputStream๊ณผ OutputStream ํด๋์ค ๋ด๋ถ์๋ Closeable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๊ณ ์๋๋ฐ, ์ด๋ Stream์ด ๋ฆฌ์์ค์ ์ ๊ทผ ํ ๋ Blocking, Synchronous(๋๊ธฐ) ๋ฐฉ์์ผ๋ก ์๋ํ๊ธฐ ๋๋ฌธ์ ํ๋ฒ Stream์ ํตํด ๋ฐ์ดํฐ์ ์ ๊ทผํ๊ณ ํด๋น Stream์ close() ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ Stream์ ๋ซ์ง ์์ผ๋ฉด ํ๋ก์ธ์ค๊ฐ ์ข ๋ฃ๋ ๋๊น์ง Stream์ด ์ด๋ ค ์๋ ์ํ๊ฐ ๋๋ฉฐ, ์ด ๋๋ฌธ์ ๋ค๋ฅธ ์์ ์ ๋ชปํ๊ธฐ์ ์์ฒญ๋ ๋ฉ๋ชจ๋ฆฌ ๋์๊ฐ ๋ฐ์ ํ ์ ์๋ค.
๋ํ, Stream์ ๋จ๋ฐฉํฅ ํต๋ก๋ผ๋ ๋จ์ ์ด ์๋๋ฐ, ์ด๋ ๋ฆฌ์์ค์ ๋ํด ์ฝ๊ธฐ๋ก ์ ๊ทผํ๊ธฐ ์ํด์๋ InputStream์ผ๋ก Stream์ ์์ฑํ์ฌ ์ ๊ทผํด์ผ ํ๊ณ , ์ฐ๊ธฐ๋ก ์ ๊ทผํ๊ธฐ ์ํด์๋ OutputStream์ผ๋ก Stream์ ์์ฑํ์ฌ ์ ๊ทผํด์ผ ํ๋ค.
OutputStream์ ๊ฒฝ์ฐ Flushable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๊ณ ์์ผ๋ฉฐ, ์ด๋ OutputStream์ ํ์ฅํ๋ ํ์ ํด๋์ค๋ค ์์ฒด์ ์ผ๋ก Buffer ๋ฅผ ์ด์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ๋ชจ์๋ค๊ฐ ํ๋ฒ์ ์ ์ฅํ๋๋ฐ, ์ด๋ฅผ Flushable ์ธํฐํ์ด์ค์ flush() ๋ฉ์๋๋ฅผ ์ด์ฉํด Buffer์ ๊ด๊ณ์์ด ๋ฐ๋ก ์ง์ ๋ ๋๋ ํ ๋ฆฌ์ ์ ์ฅ ํ ์ ์๋๋ก ํ๋ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ค.
Reader, Writer
Stream์ byte์ byte[]์ ์ฝ๊ณ ์ฐ๊ธฐ ์ํด ์ฌ์ฉ๋๋ค๋ฉด, Reader์ Writer๋ char ํ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ณ ์ฐ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ํด๋์ค์ด๋ค.
์ฐธ๊ณ ์ฌ์ดํธ
[ 13์ฃผ์ฐจ ] Java์ I/O (feat. Stream, Buffer, Channel)
๋ชฉ์ฐจ ์คํธ๋ฆผ(Stream), ๋ฒํผ(Buffer), ์ฑ๋(Channel) ๊ธฐ๋ฐ์ I/O InputStream, OutputStream Byte์ Character ์คํธ๋ฆผ ํ์ค์คํธ๋ฆผ(System.in, System.out, System.err) ํ์ผ ์ฝ๊ณ ์ฐ๊ธฐ ๊ฐ์ I/O๋ Input/Output์ผ๋ก..
javanitto.tistory.com
'Programming > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
F018 - Serializable (์ง๋ ฌํ, ์ญ์ง๋ ฌํ) (0) | 2021.06.16 |
---|---|
F017 - Blocking, Non-Blocking / Synchronous, Asynchronous (2) | 2021.06.15 |
F015 - Set (์์ฑ ์ค) (0) | 2021.05.31 |
F014 - List (ArrayList, LinkedList, Vector, Stack) (0) | 2021.05.30 |
F013 - Generic (0) | 2021.05.26 |