개발연습블로그

실시간 화면 공유 플랫폼 만들기 With kurento media server

스핑큐스 — Fri, 19 Jul 2024 14:08:06 +0900

이 블로그는 https://terianp.tistory.com/184 를 참고하여 만들었습니다.

media server란?

peer 간의 연결에서 각 peer들의 연결 상태를 확인 해 주는 Signaling server와 실제 media 데이터를 전달하는 STUN server 또는 TURN server가 필요하다.

위 그림은 media server를 구성하기 위한 3가지 방법을 표현한 것이다.
나는 그 중에서 1대 다 화상 채팅 및 화면 공유를 원하기 때문에 SFU 방식을 선택하였다.

핵심 코드 리뷰

KurentoRoomDto

import com.example.steam.steam.enums.ChatType;  
import com.example.steam.steam.handler.KurentoUserSession;  
import com.google.gson.JsonArray;  
import com.google.gson.JsonObject;  
import lombok.Getter;  
import lombok.NoArgsConstructor;  
import lombok.Setter;  
import lombok.extern.slf4j.Slf4j;  
import org.kurento.client.KurentoClient;  
import org.kurento.client.MediaPipeline;  
import org.springframework.web.socket.WebSocketSession;  

import java.io.IOException;  
import java.util.ArrayList;  
import java.util.Collection;  
import java.util.List;  
import java.util.concurrent.ConcurrentHashMap;  
import java.util.concurrent.ConcurrentMap;  

@Getter  
@Setter  
@NoArgsConstructor  
@Slf4j  
public class KurentoRoomDto{  
    private KurentoClient kurento;  
    private MediaPipeline pipeline;  
    private String userId;  
    private String roomId;  
    private String roomName;  
    private int userCount = 0;  
    private int maxUserCnt;  
    private ChatType chatType;  
    private boolean isHost = false;  

    private ConcurrentMap<String, KurentoUserSession> participants;  
    public void setRoomInfo(String roomId, String roomName, ChatType chatType, KurentoClient kurento, String userId){  
        this.userId = userId;  
        this.kurento = kurento;  
        this.roomId = roomId;  
        this.chatType = chatType;  
        this.roomName = roomName;  
        this.participants = new ConcurrentHashMap<>();  
    }  

    public void createPipeline(){  
        this.pipeline = this.kurento.createMediaPipeline();  
        log.info("pipline : {} ",this.pipeline);  
    }  

    public KurentoUserSession join(String name, WebSocketSession session, String roomName) throws IOException {  
        final KurentoUserSession participant = new KurentoUserSession(name, roomName, session, this.pipeline);  

        joinRoom(participant);  

        participants.put(participant.getName(), participant);  

        sendParticipantNames(participant);  
        userCount++;  

        return participant;  
    }  

    public void leave(KurentoUserSession user) throws IOException {  
        log.info("PARTICIPANT {}: Leaving room {}", user.getName(), this.roomId);  
        this.removeParticipant(user.getName());  

        user.close();  
    }  

    public void close(){  
        for (final KurentoUserSession user : participants.values()) {  
            // 유저 close            user.close();  
        } // for 문 끝  

        // 유저 정보를 담은 map - participants - 초기화  
        participants.clear();  

        pipeline.release();  
    }  

    public Collection<String> joinRoom(KurentoUserSession newParticipant){  

        final JsonObject newParticipantMsg = new JsonObject();  
        newParticipantMsg.addProperty("id", "newParticipantArrived");  
        JsonObject joNewParticipant = new JsonObject();  
        joNewParticipant.addProperty("name", newParticipant.getName());  
        newParticipantMsg.add("data", joNewParticipant);  

        final List<String> participantsList = new ArrayList<>(participants.values().size());  
        log.debug("ROOM {}: 다른 참여자들에게 새로운 참여자가 들어왔음을 알림 {} :: {}", roomId,  
                newParticipant.getName(), newParticipant.getRoomName());  

        for (final KurentoUserSession participant: participants.values()) {  
            try{  
                participant.sendMessage(newParticipantMsg);  
            }  
            catch (IOException e){  
                log.error("ROOM {}: participant {} could not be notified", roomId, participant.getName(), e);  
            }  

            participantsList.add(participant.getName());  
        }  
        return participantsList;  


    }  

    private void removeParticipant(String name) throws IOException {  

        // participants map 에서 제거된 유저 - 방에서 나간 유저 - 를 제거함  
        participants.remove(name);  

        log.debug("ROOM {}: notifying all users that {} is leaving the room", this.roomId, name);  

        // String list 생성  
        final List<String> unNotifiedParticipants = new ArrayList<>();  

        // json 객체 생성  
        final JsonObject participantLeftJson = new JsonObject();  

        // json 객체에 유저가 떠났음을 알리는 jsonObject        // newParticipantMsg : { "id" : "participantLeft", "name" : "참여자 유저명"}  
        participantLeftJson.addProperty("id", "participantLeft");  
        participantLeftJson.addProperty("name", name);  

        // participants 의 value 로 for 문 돌림  
        for (final KurentoUserSession participant : participants.values()) {  
            try {  
                // 나간 유저의 video 를 cancel 하기 위한 메서드  
                participant.cancelVideoFrom(name);  

                // 다른 유저들에게 현재 유저가 나갔음을 알리는 jsonMsg 를 전달  
                participant.sendMessage(participantLeftJson);  

            } catch (final IOException e) {  
                unNotifiedParticipants.add(participant.getName());  
            }  
        }  

        // 만약 unNotifiedParticipants 가 비어있지 않다면  
        if (!unNotifiedParticipants.isEmpty()) {  
            log.debug("ROOM {}: The users {} could not be notified that {} left the room", this.roomId,  
                    unNotifiedParticipants, name);  
        }  

    }  

    public void sendParticipantNames(KurentoUserSession user) throws IOException {  
        final JsonObject existingParticipantsMsg = new JsonObject();  

        final JsonArray participantsArray = new JsonArray();  

        for (final KurentoUserSession participant: this.getParticipants().values()) {  
            if(!participant.getName().equals(user.getName())){  
                JsonObject exisingUser  = new JsonObject();  
                exisingUser.addProperty("name", participant.getName());  

                participantsArray.add(exisingUser);  
            }  
        }  

        existingParticipantsMsg.addProperty("id", "existingParticipants");  
        existingParticipantsMsg.add("data", participantsArray);  
        log.debug("PARTICIPANT {}: sending a list of {} participants", user.getName(), participantsArray.size());  

        // user 에게 existingParticipantsMsg 전달  
        user.sendMessage(existingParticipantsMsg);  
    }  

    public void sendHostIsOut(){  
        final JsonObject msg = new JsonObject();  
        msg.addProperty("id", "hostExit");  
        msg.addProperty("name", "name");  
        for (final KurentoUserSession participant : participants.values()) {  
            try {  
                // 다른 유저들에게 현재 유저가 나갔음을 알리는 jsonMsg 를 전달  
                participant.sendMessage(msg);  

            } catch (final IOException e) {  
                log.info("host exit error");  
            }  
        }  
    }  




}

진짜 저 위의 블로그가 없었다면 구현할 수 없었을 것 같았다.
Websocket 기반으로 Signaling server로 구현하였다.
위 코드에서는 방에 사람이 들어오고 나갔을 때에 처리 방법과, 방을 만든 Host가 방을 떠났을 시에 대해 어떻게 처리해야 되는지 대한 로직이 담겨있다.

KurentoHandler

import com.example.steam.steam.dto.ChatRoomMap;  
import com.example.steam.steam.dto.KurentoRoomDto;  
import com.example.steam.steam.service.KurentoManager;  
import com.example.steam.steam.service.KurentoRegistryService;  
import com.google.gson.Gson;  
import com.google.gson.GsonBuilder;  
import com.google.gson.JsonObject;  
import lombok.RequiredArgsConstructor;  
import lombok.extern.slf4j.Slf4j;  
import org.kurento.client.IceCandidate;  
import org.springframework.web.socket.CloseStatus;  
import org.springframework.web.socket.TextMessage;  
import org.springframework.web.socket.WebSocketSession;  
import org.springframework.web.socket.handler.TextWebSocketHandler;  

import java.io.IOException;  
import java.util.Objects;  

@Slf4j  
@RequiredArgsConstructor  
public class KurentoHandler extends TextWebSocketHandler {  
    private static final Gson gson = new GsonBuilder().create();  


    private final KurentoRegistryService registry;  

    private final KurentoManager roomManger;  


    @Override  
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {  
        final JsonObject jsonMessage = gson.fromJson(message.getPayload(), JsonObject.class);  
        KurentoUserSession user = null;  
        try{  
            user = registry.getBySession(session);  
        }  
        catch (Exception e){  
            if(user != null){  
                log.info("Incoming message from user '{}': {}", user.getName(), jsonMessage);  
            }  
            else{  
                log.info("Incoming message from new user '{}'", jsonMessage);  
            }  
        }  

        switch (jsonMessage.get("id").getAsString()){  
            case "joinRoom": // value : joinRoom 인 경우  
                joinRoom(jsonMessage, session); // joinRoom 메서드를 실행  
                break;  

            case "receiveVideoFrom": // receiveVideoFrom 인 경우  
                try {  
                    // sender 명 - 사용자명 - 과  
                    final String senderName = jsonMessage.get("sender").getAsString();  
                    // 유저명을 통해 session 값을 가져온다  
                    final KurentoUserSession sender = registry.getByName(senderName);  
                    // jsonMessage 에서 sdpOffer 값을 가져온다  
                    final String sdpOffer = jsonMessage.get("sdpOffer").getAsString();  

                    user.receiveVideoFrom(sender, sdpOffer);  
                } catch (Exception e){  
                    connectException(user, e);  
                }  
                break;  

            case "leaveRoom": // 유저가 나간 경우  
                leaveRoom(user);  
                break;  
            case "onIceCandidate": // 유저에 대해 IceCandidate 프로토콜을 실행할 때  
                JsonObject candidate = jsonMessage.get("candidate").getAsJsonObject();  

                if (user != null) {  
                    IceCandidate cand = new IceCandidate(candidate.get("candidate").getAsString(),  
                            candidate.get("sdpMid").getAsString(), candidate.get("sdpMLineIndex").getAsInt());  
                    user.addCandidate(cand, jsonMessage.get("name").getAsString());  
                }  
                break;  

            default:  
                break;  
        }  
    }  

    @Override  
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {  
        KurentoUserSession user = registry.removeBySession(session);  
        this.leaveRoom(user);  
    }  



    private void joinRoom(JsonObject params, WebSocketSession session) throws IOException {  
        final String roomName = params.get("room").getAsString();  
        final String name = params.get("name").getAsString();  
        log.info("participant '{}': trying to join room {}", name, roomName);  

        KurentoRoomDto room = roomManger.getRoom(roomName);  

        final KurentoUserSession user = room.join(name, session, roomName);  

        registry.register(user);  
    }  

    private void leaveRoom(KurentoUserSession user) throws IOException {  

        if(Objects.isNull(user)) return;  

        final KurentoRoomDto room = roomManger.getRoom(user.getRoomName());  

        if(room.getParticipants() == null) return;  
        if(!room.getParticipants().containsKey(user.getName())) return;  


        if(isHost(room.getRoomName(), user.getName())){  
            room.sendHostIsOut();  
        }  
        room.leave(user);  
        room.setUserCount(room.getUserCount() - 1);  
        if(room.getUserCount() == 0){  
            roomManger.removeRoom(room);  
        }  
    }  


    private boolean isHost(String roomName, String name){  
        if(ChatRoomMap.getInstance().getChatRooms().get(roomName).getUserId().equals(name)){  
            return true;  
        }  
        return false;  
    }  

    private void connectException(KurentoUserSession user, Exception e) throws IOException {  
        JsonObject message = new JsonObject();  
        message.addProperty("id", "ConnectionFail");  
        message.addProperty("data", e.getMessage());  

        user.sendMessage(message);  

    }  
}

Websocket 연결로 첫 Kurento와 연결될 때, 종료 등 다른 이벤트가 발생할 때 메세지 타입에 따라 로직을 구현하였다.
실제 peer간에 미디어 데이터 통신은 소켓 연결 수 pipeline을 통해 kurento media server에서 통신하므로 Spring server의 부담이 줄어들게 된다.

이 글을 쓰면서 다시 한번 Media server에 대해 블로그를 작성해준 분께 감사합니다.
너무 어렵다.

Unity + Spring + React로 이루어진 Stomp 소켓 통신

스핑큐스 — Wed, 10 Apr 2024 15:04:52 +0900

졸작을 하는 중 spring을 기점으로 다중 웹 소켓 통신을 하던 과정을 나타낸 것이다.

Spring

Spring에서는 두 프레임워크의 웹 소켓 연결을 받아주고, 메세지를 보낼 때 받는 url을 설정해주어야 된다.

WebSocketConfig

import org.springframework.context.annotation.Configuration  
import org.springframework.messaging.simp.config.MessageBrokerRegistry  
import org.springframework.web.socket.config.annotation.*  


@Configuration  
@EnableWebSocket  
@EnableWebSocketMessageBroker  
class WebSocketConfig : WebSocketMessageBrokerConfigurer {  

    // 엔드포인트 지정 
    override fun registerStompEndpoints(registry: StompEndpointRegistry) {  
        registry.addEndpoint("/ws")  
            .setAllowedOriginPatterns("*")  

    }  
    // 메세지 주거나 받는 브로커 시작 url 설정 
    override fun configureMessageBroker(registry: MessageBrokerRegistry) {  
        registry.enableSimpleBroker("/sub")  
        registry.setApplicationDestinationPrefixes("/pub")  
    }  


}

ChatMessageDTO

data class ChatMessage(  
        val type: MessageType,  
        val roomId: String,  
        val sender: String,  
        val message: Map<String, Any>,  
        val people : PeopleType,  
) {  
    // 메시지 타입 : 입장, 채팅  
    enum class MessageType {  
        ENTER,  
        TALK,  
        EXIT,  
    }  

    // 권한 구분  
    enum class PeopleType {  
        PARENT,  
        KID  
    }  
}

Service


fun messageHandler(chatMessage: ChatMessage): MutableList<MessageResponseDTO> {  
    var result: MutableList<MessageResponseDTO> = mutableListOf()  
    when (chatMessage.type) {  
        ChatMessage.MessageType.ENTER -> {  
            userList.add(chatMessage.sender)  

            if (!messageBuffer.containsKey(chatMessage.roomId)) {  
                messageBuffer[chatMessage.roomId] = mutableListOf()  
                return mutableListOf()  

            } else {  

                val senderMap = mutableMapOf<String, Any>()  
                if (chatMessage.people == ChatMessage.PeopleType.PARENT) {  
                    userList.remove(chatMessage.sender)  
                }  
                senderMap["list"] = userList  
                result.add(  
                    MessageResponseDTO(  
                        sender = chatMessage.sender,  
                        message = senderMap  
                    )  
                )  
                return result  
            }  
        }  

        ChatMessage.MessageType.TALK -> {  
                //실시간 데이터를 받을 때 데이터의 양을 조절하기 위함함
            if (messageBuffer[chatMessage.roomId]?.size!! > 5000) {  
                messageBuffer[chatMessage.roomId]?.clear()  
            }  
            if (chatMessage.people == ChatMessage.PeopleType.PARENT) {  
                return agencyEnterUser(chatMessage)  
            }  
        }  

        ChatMessage.MessageType.EXIT -> {  
              // 종료 시 버퍼 제거 및 목록에서 제외
            val iterator = messageBuffer[chatMessage.roomId]?.iterator()  
            while (iterator?.hasNext() == true) {  
                val message = iterator.next()  
                if (message.sender == chatMessage.sender) {  
                    iterator.remove()  
                }  
            }  


            userList.remove(chatMessage.sender)  
            val senderMap = mutableMapOf<String, Any>()  
            senderMap["list"] = userList  
            result.add(  
                MessageResponseDTO(  
                    sender = chatMessage.sender,  
                    message = senderMap  
                )  
            )  

            return result  
        }  
    }  
    val message = MessageResponseDTO(sender = chatMessage.sender, message = chatMessage.message)  
    result.add(message)  
    messageBuffer[chatMessage.roomId]?.add(message)  
    return result  
}

Unity

유니티에서는 StompHelper 플러그인을 제공하여 연결을 지원하고있다.
우리 작품에서는 Unity에서 데이터를 보내는 역할만 한다.

React

React는 실시간으로 받은 데이터를 웹에 표현하는 역할을 한다.
여기서 일대 다 기능으로 해당 유저의 데이터만 받기 위해 많은 고민을 했다.

Socket.js

import React, { useEffect, useState, useRef } from 'react';  
import { Client } from "@stomp/stompjs";  
import UserRealDetail from "./UserRealDetail";  

const Socket = () => {  

    const client = useRef(null);  
    const [user, setUser] = useState([])  
    const [selectedUser, setSelectedUser] = useState(null);  
    const [showButtons, setShowButtons] = useState(true);  

    useEffect(() => {  
        client.current = new Client({  
            brokerURL: "ws://localhost:8080/ws", // 서버 WebSocket URL            reconnectDelay: 5000,  
            onConnect: () => {  
                console.log("connect")  
                client.current.subscribe(`/sub/enter/chat/room/` + localStorage.getItem("roomId"), (message) => {  
                    const msg = JSON.parse(message.body);  
                    console.log(msg[0].message.list)  
                    setUser(msg[0].message.list)  
                });  
                handleConnectionChange();  
            },  
        });  

        client.current.activate();  

    }, []);  
    const handleConnectionChange = () => {  
        publishMessage();  
    };  
    const publishMessage = () => {  
        if (client.current.connected) {  
            console.log("publish");  
            client.current.publish({  
                destination: "/pub/chat/message",  
                body: JSON.stringify({  
                    type: "ENTER",  
                    roomId: localStorage.getItem("roomId"),  
                    sender: localStorage.getItem("agencyId"),  
                    message: {  
                        x: 1,  
                        y: 1,  
                    },  
                    people: "PARENT",  
                }),  
            });  
        }  
    };  

    useEffect(() => {  
        if(showButtons){  
            publishMessage()  
        }  
    }, [showButtons])  

    const handleUserClick = (userName) => {  
        setSelectedUser(userName);  
        setUser(prevUsers => prevUsers.filter(user => user !== userName));  
        setShowButtons(false)  
    };  

    return (  
        <div>  
            {showButtons && user.map((userName, index) => (  
                <button key={index} onClick={() => handleUserClick(userName)}>{userName}</button>  
            ))}  
            {selectedUser && !showButtons && <UserRealDetail client={client} userName={selectedUser} showButton={setShowButtons}/>}  
        </div>  

    );  
}  

export default Socket;

먼저 입장 시 소켓 연결을 한 후 내가 들어왔다는 사실을 알리고, 그에 따라 Unity측에서 들어온 유저들의 리스트를 확인하여 표현한다.

그 후 들어온 유저의 버튼을 클릭 시 해당 유저의 데이터만 받아올 수 있도록 subscirbe를 세팅하도록 설정하였다.

UserRealDetail.js

import React, {useEffect, useRef, useState} from "react";  
import logo from "../../assets/image/login/logo.png";  
import {CartesianGrid, Legend, Line, LineChart, Tooltip, XAxis, YAxis} from "recharts";  

const UserRealDetail = ({client, userName, showButton}) => {  

    const [message, setMessage] = useState([  
        {  
            x : 0,  
            y : 0  
        }  
    ])  

    const canvasRef = useRef(null);  
    const [count, setCount] = useState(0);  
    const [showChart, setShowChart] = useState(false);  
    useEffect(() => {  
        const canvas = canvasRef.current;  
        if (!canvas) return;  
        const ctx = canvas.getContext('2d');  

        // 이미지 불러오기  
        const img = new Image();  
        img.onload = () => {  
            // 캔버스 크기 설정  
            canvas.width = 1920;  
            canvas.height = 3240;  

            // 이미지 그리기  
            ctx.drawImage(img, 0, 0);  
            const rect = canvas.getBoundingClientRect();  
            const canvasX = rect.left;  
            const canvasY = rect.top;  
            // 마커 그리기  
            ctx.fillStyle = 'red';  
            ctx.beginPath();  
            //const imageX = message[count].x - canvasX;  
            //const imageY = message[count].y - canvasY;            message.forEach((point) => {  
                ctx.beginPath();  
                ctx.arc(point.x, point.y, 5, 0, Math.PI * 2);  
                ctx.fill();  
            });  
            setCount(count + 1)  
        };  
        img.src = logo;  
    }, [message, canvasRef]);  
    useEffect(() => {  
        if(!client.current.connected){  
            client.current.activate()  
        }  

        client.current.subscribe(`/sub/chat/room/` + localStorage.getItem("roomId") + "/" + userName, (message) => {  

            const msg = JSON.parse(message.body);  
            if(msg.length > 2){  
                setMessage(prevMessage => {  
                    const updatedMessage = msg.map(item => ({ x: item.message.x, y: item.message.y }));  
                    console.log(updatedMessage)  
                    return updatedMessage;  
                });  
                return            }  
            const x = msg[0].message.x;  
            const y = msg[0].message.y;  
            const canvas = canvasRef.current;  
            const rect = canvas.getBoundingClientRect();  
            //const newX = x - rect.left;  
            //const newY = y - rect.top;            setMessage(prevMessage => {  
                const updatedMessage = [...prevMessage, { x: x, y: y }];  
                return updatedMessage;  
            });  
        });  

        client.current.publish({  
            destination: "/pub/chat/message",  
            body: JSON.stringify({  
                type: "TALK",  
                roomId: localStorage.getItem("roomId"),  
                sender: userName,  
                message: {  
                    x: 1,  
                    y: 1,  
                },  
                people: "PARENT",  
            }),  
        });  

    }, [])  
    const handleButtonClick = () => {  
        setShowChart(!showChart);  
    };  
    const handleBackButtonClick = () => {  
        showButton(true)  
    }  

return(  
    <div>  
        <button onClick={handleBackButtonClick}>돌아가기</button>  
        <canvas ref={canvasRef} />  
        <button onClick={handleButtonClick}>Show Chart</button>  
        {showChart && (  
            <LineChart width={800} height={400} data={message}>  
                <CartesianGrid strokeDasharray="3 3" />  
                <XAxis dataKey="timestamp" />  
                <YAxis />                <Tooltip />                <Legend />                <Line type="monotone" dataKey="x" stroke="#8884d8" />  
                <Line type="monotone" dataKey="y" stroke="#8884d8" />  
            </LineChart>        )}  
    </div>)  

}  

export default UserRealDetail

이 부분에서 혹시 Unity에서 컨텐츠를 하고 있는 유저의 데이터를 Spring에서 저장하고 있다가, React에서 뒤늦게 해당 유저의 실시간 정보를 확인할 때 버퍼에 해당 유저의 정보를 따로 요청하여 가져올 수 있도록 하였다.

원래는 버퍼를 Radis를 사용하고 싶었지만..... 기회가 된다면 시도해보겠다..

Docker 4회차 실습

스핑큐스 — Thu, 1 Feb 2024 14:51:47 +0900

gradle 기반의 Spring 웹 서버를 Dockerfile로 만들자.

gradle 기반 Spring 웹 서버는 예전에 Spring을 공부하면서 만든 Product 시스템으로 구성하였다.

멀티 스테이지를 이용

#이미지를 gradle로 설정
FROM gradle:7.6.3-jdk17 as builder  
#작업 디렉토리를 build로 설정
WORKDIR /build  
# 작업 디렉토리로 현재 디렉토리에 있는 2개의 파일을 복사함
COPY build.gradle settings.gradle /build/  
RUN gradle build -x test --parallel --continue > /dev/null 2>&1 || true  
  
COPY . /build  
RUN gradle build -x test --parallel  

#Stage 2
FROM openjdk:17.0-slim  
WORKDIR /app  
# builder에서 만들어 두었던 Jar 파일 복사
COPY --from=builder /build/build/libs/Product-0.0.1-SNAPSHOT.jar .  
EXPOSE 80  
  
USER nobody  
ENTRYPOINT [                                                \  
    "java",                                                 \  
    "-jar",                                                 \  
    "-Djava.security.egd=file:/dev/./urandom",              \  
    "-Dsun.net.inetaddr.ttl=0",                             \  
    "Product-0.0.1-SNAPSHOT.jar"              \  
]

docker image build -t product .

위 과정을 통해 이미지를 만들 수 있다.

postman, 웹 클라이언트 등등 통신을 진행해보자.

Post 요청을 보내보니 잘 받는 모습이다.
실제로 웹으로 Swagger를 접속해보니 잘 접속이 되었고 API 호출 또한 정상적으로 진행되는 것을 확인할 수 있다.

Docker 4회차

스핑큐스 — Thu, 1 Feb 2024 14:51:30 +0900

조작 관련 커맨드

볼륨을 영구적으로 사용할 수 있는 방법은 3가지가 존재한다.

호스트 볼륨 사용
- 호스트 운영체제의 디렉토리를 컨테이너 내에 마운트 시키는 작업
볼륨 컨테이너를 이용하는 방법
- 빈 컨테이너를 만들어 다른 컨테이너들이 빈 컨테이너를 참조하는 방식으로 구성
도커 볼륨을 이용하는 방법
- 도커가 제공하는 볼륨 관리 기능을 통해 생성과 삭제를 관리

볼륨 조작

옵션	설명
docker volume create [볼륨 이름]	볼륨 생성
docker volume ls	볼륨 목록 확인
docker volume inspect [볼륨 이름]	볼륨 상세 정보 확인
docker volume rm [볼륨 이름]	볼륨 삭제
docker volume prune	마운트가 없는 볼륨 삭제

바인드 마운트

docker volume create testvol

docker run --name apache -d -p 8080:80 -v C:\Users\82104\Desktop\volume:/usr/local/apache2/htdocs httpd

마운트를 할 때 바로 내 홈 디렉토리와 연결하는 명령어이다.
실제 연결이 되었음을 확인할 수 있다.

도커 컴포즈

도커 컴포즈란?

여러 개의 컨테이너를 하나의 서버로 만들어 컨테이너의 묶음으로 관리하는 도구이다.
docker-compose.yml로 작성해야된다.

도커 컴포즈를 사용하는 이유?

하나의 어플리케이션에 여러 개의 컨테이너가 존재하는 경우 이 애플리케이션을 실행하기 위해 여러 개의 컨테이너들을 각각 실행해야 되는 번거로움이 존재한다.
이러한 불편함을 해결하기 위해 도커 컴포즈가 여러 개의 컨테이너의 옵션과 환경을 정의한 파일을 읽어 컨테이너를 순차적으로 생성하는 방식으로 동작하게 된다.

도커 컴포즈 사용법

옵션	설명
docker-compose up	docker-compose.yml에 있는 프로그램을 실행한다.
docker-compose down	실행되고 있는 컨테이너를 종료한다.
docker-compose scale	각 서비스에 여러개의 컨테이너를 생성한다.

docker-compose.yml 작성법

옵션	설명
version	yml의 파일 포맷의 버전을 나타낸다.
service	생성될 컨테이너를 묶어놓은 단위이다.
image	컨테이너를 생성할 때 쓰일 이미지의 이름을 설정한다.
links	다른 서비스에 서비스명으로만 접근할 수 있도록 설정한다.
environment	–env 옵션과 동일하다. 컨테이너 내부에서 사용할 환경변수를 지정한다.
command	컨테이너가 실행될 때 수행할 명령어를 설정한다
depends_on	이 항목에 명시된 컨테이너가 먼저 생성되고 실행된다.
ports	컨테이너를 개방할 포트를 설정한다.
build	정의된 도커파일에서 이미지를 빌드해 서비스의 컨테이너를 생성한다.
extends	다른 yaml이나 현재 yaml 파일에서 서비스 속성을 상속 받도록 설정한다.
driver	브리지 네트워크가 아닌 다른 네트워크를 사용하고 싶을 때 설정한다.
ipam	subnet, ip범위 등을 설정할 수 있다.
external	기존의 네트워크를 사용하도록 설정한다.

Docker 3회차

스핑큐스 — Mon, 29 Jan 2024 17:15:47 +0900

Dockerfile이 있는데 빌드 서버가 필요할까?

빌드 서버를 만들지 않는다면 각각의 개인 컴퓨터에 작업 환경을 전부 같이 세팅을 해야되므로 신규 개발자가 들어 왔을 때 환경 세팅에서만으로도 많은 시간을 쏟게 된다.
Docerfile 스크립트를 작성한 후 이 이미지를 사용하여 애플리케이션을 패키징 할 수 있으므로 굳이 세팅할 필요가 없어진다.

애플리케이션 빌드 실전 예제 - 자바

본 예제는 https://github.com/sixeyed/diamol/tree/master 의 코드를 참조하여 만들었습니다.

FROM maven:3.8.4-openjdk-17-slim AS builder  
  
WORKDIR /usr/src/iotd  
COPY pom.xml .  
RUN mvn -B dependency:go-offline  
  
COPY . .  
RUN mvn package  
  
# app  
FROM openjdk:17  
  
WORKDIR /app  
COPY --from=builder /usr/src/iotd/target/iotd-service-0.1.0.jar .  
  
EXPOSE 80  
ENTRYPOINT ["java", "-jar", "/app/iotd-service-0.1.0.jar"]

docker image build -t image-testing .

빌드를 마치면 이미지가 생성되는 것을 확인할 수 있다.

멀티 스테이지 Dockerfile 스크립트 이해하기

앞에서 봤던 Dockerfile 스크립트를 살펴보자

FROM maven:3.8.4-openjdk-17-slim AS builder : maven 3.8.4버전과 openjdk 17 버전의 이미지를 가져온 후 그 이름을 builder로 설정하였다.
WORKDIR /usr/src/iotd : 작업 디렉토리를 /usr/src/iotd로 설정한다.
COPY pom.xml . : pom.xml 파일을 복사한다.
RUN mvn -B dependency:go-offline : pom.xml에 있는 의존성을 오프라인으로 모두 복사한다.
COPY . . : 현재 디렉토리를 복사한다.
RUN mvn package : 현재 디렉토리를 기준으로 iotd-service-0.1.0.jar 파일을 생성한다.
FROM openjdk:17 : openjdk 17버전의 이미지를 기준으로 한다.
WORKDIR /app : 작업 디렉토리를 /app으로 설정한다
COPY --from=builder /usr/src/iotd/target/iotd-service-0.1.0.jar . : builder 에서 생성한 iotd-service-0.1.0.jar 를 복사해 가져온다.
EXPOSE 80 : 오픈 포트를 80번으로 지정한다.
ENTRYPOINT [“java”, “-jar”, “/app/iotd-service-0.1.0.jar”] : 컨테이너에 올라갔을 때 위 명령어를 실행하여 iotd-service-0.1.0.jar 파일을 실행한다.

멀티 스테이지 빌드란?

도커 이미지의 용량을 최소화하기 위해 빌드를 여러 번 거치는 과정이다.
이미지가 매우 많을 시 사소한 용량 차이가 큰 용량이 될 수 있기 때문에 위 과정은 중요하다고 볼 수 있다.
위 Dockerfile을 하나로 합친 경우

FROM maven:3.8.4-openjdk-17-slim AS builder  
  
WORKDIR /usr/src/iotd  
COPY pom.xml .  
RUN mvn -B dependency:go-offline  
  
COPY . .  
RUN mvn package  
EXPOSE 80  
ENTRYPOINT ["java", "-jar", "/usr/src/iotd/target/iotd-service-0.1.0.jar"]

용량이 늘어난 것을 확인할 수 있다.

레지스트리에 이미지 공유하기

레지스트리, 리포지토리, 이미지 태그 다루기

레지스트리는 이미지를 다른 사람들이 이미지를 사용할 수 있도록 제공되는 장소이다. 기본값을 도커 허브로 지정되어 있다.
리포지토리는 일반적으로 애플리케이션의 이름에 해당되고, 하나의 리포지토리는 여러 버전의 이미지를 담을 수 있다.
이미지 태그는 애플리케이션의 버전 혹은 변종을 나타낸다. 기본값은 가장 최근 버전을 표시한다.

도커 허브에 직접 빌드한 이미지 push하기

도커 허브에 로그인 하기

docker login --username (유저 아이디)

기존 이미지에 새로운 이미지를 부여

docker image tag image-test bnh4924/image-test:v1

이미지 업로드 된 것을 확인할 수 있다.

로컬 네트워크에 전용 레지스트리가 있으면 편리한 점은 무엇인가?

버전 관리가 쉽다.
개인 컴퓨터에서 사용하므로 보안성이 좋다.

이미지 태그를 효율적으로 사용하기

새로운 이미지를 계속 제작하면서 이미지 태그를 버전처럼 사용하여 관리를 유용하게 할 수 있다.

실용 도커 기술

컨테이너와 호스트 사이에 파일 복사

컨테이너의 파일 시스템은 일시적인 것이므로 컨테이너가 삭제된다면 기존 컨테이너에 있는 데이터는 모두 손실된다.
도커는 이러한 상황을 방지하기 위해 도커 볼륨과 마운트 요소를 만들었다.

볼륨 마운트

바인드 마운트

원본이 될 폴더나 파일을 먼저 만들고 연결한다.

docker volume create (볼륨이름)

볼륨 마운트

볼륨 상위 커멘드를 사용해 먼저 볼륨을 생성한다.

docker run -v (실제 스토리지 경로):(컨테이너 마운트 경로)

docker run -v (볼륨 이름:(컨테이너 마운트 경로))

Game-server 1회차

스핑큐스 — Fri, 26 Jan 2024 12:21:19 +0900

블로킹 함수란?

이 함수로 인해서 다른 코드들이 실행하지 못하게 만드는 함수를 지칭한다.

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title></title>
</head>
<body>
    <div id="result"></div>
    <button onclick="func();">start</button>
    <script type="text/javascript">
        function func() {
            document.getElementById('result').innerText = test1();
            document.body.style.backgroundColor = '#008299';
        }
        function test1() {
            var num = 0;
            for (var i = 0; i < 1000000000; i++) {
                num++;
            }
            return num;
        }
    </script>
</body>
</html>

위 코드에서 test1 메소드 때문에 배경화면의 색이 변하지 않는 것을 확인할 수 있다.

비동기적이란?

요청한 작업에 대하여 완료 여부를 신경쓰지 않고 자신의 그 다음 작업을 수행할 수 있도록 하는 방법이다.
대규모 트래픽에서 안정적으로 동작할 수 있는 웹 애플리케이션을 만들 수 있다.

동기 vs 비동기

동기 처리에서는 응답이 다 올 때까지 기다린 후 다음 작업을 실행하지만 비동기 서버는 멀티 스레드나 멀티 프로세싱과 같은 방식으로 구현될 수 있다.
단 비동기 처리에서는 앞의 작업이 뒤에 영향을 주는 경우에는 문제가 될 가능성이 있다.
동기는 작업 순서가 잘 지켜지고, 비동기는 작업 순서가 지켜지지 않을 수도 있다.
비동기 방식은 작업을 하면서도 다른 작업을 하기 때문에 다른 작업이 먼저 완료가 될 수가 있다.

IOCP 서버란?

IOCP(IO Completion Port)란

Overlapped IO에서 입출력 결과를 통지하는 하나의 방법론이다.

비동기 I/O 시작
- 동기 함수와 같은 역할을 하는 비동기 함수를 실행하여 윈도우 I/O에 넘긴다. 이 동작을 거친 뒤에는 프로그램의 흐름이 다시 호출한 쓰레드로 바로 돌아온다.(비동기)
비동기 입출력 완료
- 비동기 입출력이 윈도우 I/O에서 종료되면 IOCP라는 항구에 쌓이게 되는데 이 자료구조는 Queue 이다.
GetQueuedCompletionStatus
- 할 일이 없는 쓰레드에서 GetQueuedCompletionStatus를 호출하면 IOCP에서 완료된 내용을 꺼내서 받을 수 있다.

논블로킹이란?

다른 요청의 작업을 처리하기 위해 현재 작업을 차단하지 않는 프로세스의 실행 방식이다.
논블로킹 방식으로 파일을 읽는 작업이 있다면 파일을 다 읽지 않아도 다른 작업을 수행할 수 있다.

논블로킹 vs 블로킹

한 작업을 하는 도중에 다른 작업이 들어왔을 시 기존에 하던 작업을 기다리면 블로킹, 기존에 하던 작업을 다른 작업과 동시에 진행하면 논 블로킹이다.

작업자 스레드란?

한번 기동하면 영원히 일을 실행하는 스레드이다.
기존의 클라이언트의 요청이 들어오면 일을 실행할 때마다 새로운 스레드를 만들어 사용하지만, 작업자 스레드는 요청을 반복해서 실행하고 있어 새로운 스레드를 만들 필요가 없다.
작업자 스레드는 용량을 제어할 수 있어 실제 프로그램이 동작하는 환경에 따라서 작업자 스레드를 조절해야 된다.

Overlapped 란?

NonBlocking과 비동기 I/O 처리가 합쳐진 개념이다.
Overlapped I/O는 I/O 처리를 Device Driver에 맡김으로써 해당 쓰레드가 다른일을 할 수 있도록 한다.
Send 100 Byte를 하면 100Byte를 Send 할 때까지 완료 결과가 오지 않는다.
유저 영역의 버퍼를 이용하므로 소켓 버퍼에 복사하지 않으므로 한번의 복사 비용이 줄어든다.

Docker 2회차

스핑큐스 — Wed, 24 Jan 2024 13:50:50 +0900

컨테이너의 기본적인 사용법

도커 명령어

기본적으로 커멘트에 docker를 입력하면 명령어들의 모음이 나온다.

자주 사용하는 명령어 모음

옵션	설명
docker version	Docker 버전 및 상세정보 확인
docker system info	Docker의 시스템 전체 정보 확인
docker system df	도커 디스크의 사용양 확인
docker images	docker 이미지 목록 확인
docker search [옵션] <검색어>	docker hub image 검
docker build -t [dockerHub ID]/[이미지명] .	dockerfile로 image 생성
docker rmi [이미지 ID]	image 삭제
docker ps	현재 실행중인 컨테이너 확인
docker ps -a	실행, 중지중 컨테이너 확인
docker rm [컨테이너 ID]	컨테이너 ID 1개 삭제
docker rm ‘docker ps -a -q’	컨테이너 전체 삭제
docker attach [컨테이너명, ID]	컨테이너의 접속
docker start[컨테이너명, ID]	컨테이너 시작
docker stop[컨테이너명, ID]	컨테이너 중지
docker restart[컨테이너명, ID]	컨테이너 재시작
docker rename[현재 컨테이너명] <변경할 컨테이너 이름>	컨테이너 이름 변경

version 명령어 사용 시 화면

조작 관련 커맨드

볼륨을 영구적으로 사용할 수 있는 방법은 3가지가 존재한다.

호스트 볼륨 사용
- 호스트 운영체제의 디렉토리를 컨테이너 내에 마운트 시키는 작업
볼륨 컨테이너를 이용하는 방법
- 빈 컨테이너를 만들어 다른 컨테이너들이 빈 컨테이너를 참조하는 방식으로 구성
도커 볼륨을 이용하는 방법
- 도커가 제공하는 볼륨 관리 기능을 통해 생성과 삭제를 관리

볼륨 조작

옵션	설명
docker volume create [볼륨 이름]	볼륨 생성
docker volume ls	볼륨 목록 확인
docker volume inspect [볼륨 이름]	볼륨 상세 정보 확인
docker volume rm [볼륨 이름]	볼륨 삭제
docker volume prune	마운트가 없는 볼륨 삭제

네트워크 조작

Docker 네트워크는 목적에 따라 다양한 종류의 네트워크 드라이버를 지원한다.

bridge : 하나의 호스트 컴퓨터 내에서 컨테이너들간 소통할 수 있도록 한다.
host : 컨테이너를 호스트 컴퓨터와 동일한 네트워크 상에 올린다.
overlay : 여러 호스트에 분산되어 있는 컨테이너들 간에 연결을 위해 사용한다.

옵션	설명
docker network ls	Docker 네트워크 조회
docker network create [네트워크 이름]	새로운 네트워크 생성
docker network inspect [네트워크 이름]	네트워크 상세 정보 확인
docker network connect [컨테이너 이름] [네트워크 이름]	네트워크 연결
docker network disconnect [컨테이너 이름] [네트워크 이름]	네트워크 연결 해제
docker network rm [네트워크 이름]	네트워크 삭제
docker network prune	불필요한 네트워크 전부 삭제

컨테이너의 통신

아파치란?

WAS(Web Application Server) 라고 부르며 웹 브라우저와 같은 클라이언트들로부터 HTTP 요청을 받아들이고, 웹페이지를 반환하는 프로그램이다.
장점

오래 사용된 만큼 거의 모든 OS환경에서 실행을 지원하고, 다양한 모듈을 가지고 있다.
클라이언트 요청을 처리하기 위해 멀티 스레드 방식을 따른다.
자체적으로 동적 컨텐츠를 처리한다.
단점
CPU, 메모리 자원 낭비가 심하다.
대규모 요청이 들어왔을 때 스레드 생성 비용이 들어 한계가 정해져 있다.

컨테이너와 통신하기 위한 방법

컨테이너와 컨테이너간의 통신

docker network connect 명령어를 통해 해당 브릿지에 연결
다른 컨테이너 또한 같은 브릿지에 연결
Ping 명령어를 통해 통신이 되는 지 확인인

컨테이너 생성에 익숙해지기

다양한 유형의 컨테이너

컨테이너에는 OS, 웹서버, DB 등 다양한 유형의 컨테이너들을 올릴 수 있다.
컨테이너 실행 방법은 도커 허브에 공식 이미지를 확인하면 사용 방법을 알 수 있다.

아파치 컨테이너를 여러 개 실행하기

docker run --name apache1 -d -p 8080:80 httpd
docker run --name apache2 -d -p 8079:80 httpd

포트 바인딩을 다른 포트로 안주면 바인딩 에러가 나므로 같은 컨테이너를 생성하더라도 포트를 다르게 설정해 주어야 된다.

Nginx 컨테이너 실행하기

docker run --name nginx --name nginx -d -p 8078:80 nginx

MySQL 컨테이너 실행하기

docker run --name mysql -e MYSQL_ROOT_PASSWORD=secret -d mysql

Docker 1회차 실습

스핑큐스 — Sun, 21 Jan 2024 16:20:36 +0900

실습환경 구축

도커 데스크톱 첫 실행 화면

도커 컨테이너 명령어

컨테이너로 Hello World 실행하기

Apache 서버로 웹페이지 출력하기

docker pull httpd:latest
docker run -d --name apach -p 8080:80 httpd

Ngnix 서버로 웹페이지 출력하기

docker pull nginx:latest
docker run -d --name nginx -p 8080:80 nginx

Docker 1회차

스핑큐스 — Sun, 21 Jan 2024 16:20:09 +0900

도커(Docker)란?

Docker는 애플리케이션을 신속하게 구축, 테스트 및 배포할 수 있는 소프트웨어 플렛폼이다.
소프트웨어를 컨테이너라는 표준화된 유닛으로 패키징하고, 이 컨테이너 안에는 라이브러리, 시스템 도구, 코드, 런타임 등 소프트웨어를 실행하는 데 필요한 모든 것이 포함되어 있다.

데이터나 프로그램을 독립된 환경에 격리해야하는 이유?

대부분의 프로그램은 단독으로 동작하는 것이 아닌 실행환경이나 라이브러리, 다른 프로그램과 함께 동작한다.
소프트웨어 또한 여러 개의 프로그램으로 구성되어 있으므로 다른 프로그램과 공유하는 폴더 또는 설정 정보를 저장하는 경우가 있다.
만약 프로그램 하나를 업데이트하면 다른 프로그램에도 영향을 미치게 될 수 밖에 없다.
ex) 멀쩡히 돌아가는 파이썬 프로그램이 관련 라이브러리 1개의 업데이트 만으로도 해당 파이썬 프로그램이 돌아가지 않을 수도 있다!

프로그램의 격리

여러 프로그램이 한 서버에서 실행되면서 발생하게 되는 문제들을 해결할 수 있다.
도커는 완전히 독립된 환경이므로 여러 컨테이너에서 같은 프로그램을 실행할 수 있다.

서버의 2가지 의미

기능적 의미의 서버

흔히 표현하는 웹 서버, 메일 서버 와 같은 의미의 서버

물리적 컴퓨터로서의 서버

컴퓨터 자체를 의미

컨테이너를 이용해 여러가지 서버 기능을 안전하게 함께 실행하기

도커 환경에서 컨테이너를 사용하면 프로그램을 완전히 격리시킬 수 있으므로 한 대의 서버에서 여러 개의 기능 서버를 실행했을 때 나오는 문제점들을 도커를 사용함으로서 각각 독립적인 환경에서 안전하게 운용할 수 있도록 만들어준다.

도커의 동작 원리

물리 서버가 있고, 서버에서 동작하는 운영체제가 있는데 원래 일반적인 서버라면 운영체제 위에 프로그램이나 데이터가 직접 올라가지만, 도커는 운영체제 위에 도커 엔진이 동작하고 그 위에서 컨테이너가 동작한다.

Docker Container

컨테이너 안에 포함되는 OS 이미지에는 커널이 없고, Host 커널을 공유하여 사용한다.
따라서 컨테이너는 각 application마다 OS를 필요로 하지 않아 서버를 더 효율적으로 만들 수 있다.

도커 허브와 이미지, 그리고 컨테이너

이미지와 컨테이너

이미지는 컨테이너를 만들 수 있는 틀 과 같은 것이다.
이미지는 하나만 있으면 여러 개 복제할 수 있어서 배치하기가 편하다.
컨테이너로 이미지를 다시 만들 수 있다. 이 뜻은 컨테이너 상태에서 수정을 할 수 있다는 말이다.
이미지만 있으면 도커 엔진이 설치된 공간에서는 어디서든지 이미지를 이용하여 컨테이너를 생성할 수 있다.

도커 허브

다양한 공개 컨테이너가 이미지가 있는 곳이다.
설정이 완료된 원하는 이미지를 가져다가 사용하면 된다.
안전하지 못한 이미지가 있을 수 있으므로 공식 이미지를 사용하는 것을 권장한다.

도커 컨테이너 생애주기와 데이터 저장

도커 컨테이너 생애주기

한 컨테이너는 오래 사용하기보다 새 버전이 나올 때마다 갈아타는 것이 좋다.

1. 생성

이미지를 통해 컨테이너를 생성한다.

2. 시작

컨테이너를 실행시킨다.

3. 중지

현재 동작하고 잇는 작업을 종료하고 컨테이너를 중지시킨다.

4. 삭제

컨테이너를 종료한다.

데이터 저장

컨테이너를 삭제했을 때 안에 남아있는 데이터는 도커에 설치된 물리적 서버의 디스크를 마운트하여 이 디스크에 데이터를 저장하게 된다.
따라서 컨테이너가 삭제되면 실제 데이터는 컨테이너 외부에 있으므로 안전하게 저장되게 될 뿐만 아니라 다른 컨테이너가 데이터를 공유할 수 있게 되어 편리하다.

도커의 장단점

도커의 장점

한 대의 물리 서버에 여러 대의 서버를 띄울 수 있다.
- 격리된 환경에서 실행되어 각각 안전한 상태로 실행이 가능하다.
- 같은 소프트웨어를 여러 개 실행이 가능하다.
- 가상화 기술에 비해 가볍다.
서버 관리가 용이하다.
- 컨테이너 교체와 수정이 쉽다.

도커의 단점

리눅스용 소프트웨어만 지원이 가능하다.
호스트 서버에 문제가 생기면 모든 컨테이너에 영향을 미친다.
장기간에 걸쳐 하나의 컨테이너를 사용한다면 장점이 희석된다.

도커의 주 용도

모두에게 동일한 개발환경을 제공
새로운 버전 테스트 용이
- 컨테이너에서 테스트 할 경우 격리되어 있으므로 다른 컨테이너들이 영향을 받지 않음
동일한 서버가 여러 대 필요할 경우
- 한 대 물리 서버에 동일한 서버를 여러 개 만들 수 있으므로 관리가 간편하고 비용이 절약됨.

Java Study 7-3주차

스핑큐스 — Sat, 18 Nov 2023 16:30:31 +0900

Lambda

Java8 이후로 람다 표현식이 생겼고, 그 표현식을 구성하는데 사용되는 화살표 연산자가 생겨났다.
람다 이전의 자바는 Interface를 사용하거나 abstract 클래스를 사용하여 구현해야 되기 때문에 가독성 부분에서 문제가 발생한다.

// 두 수를 더하는 람다식
(a, b) -> System.out.println(a+b)

위와 같은 식에서 일회용이기 때문에 재사용이 불가능하다.
하지만 한번만 쓰고 말 것이라면 굳이 함수를 만들지 않고 사용할 수 있으므로 편리하다.
위 식을 볼때 a,b는 int형인지 어떻게 알수 있을까?
다른 언어에서 내세운 특징인 컴파일러가 스스로 매개 타입 변수가 무엇인지를 알 수 있도록 하는 타입 추론 기능을 사용하였다.

함수형 인터페이스

추상 메소드를 딱 하나만 가지고 있어야 된다.
람다 표현식에서는 함수형 인터페이스의 인스턴스를 만드는 방법으로 사용될 수 있다.

public static void main(String[] args) {
	Foo foo = (x) -> System.out.println(x);
}

@FunctionalInterface
public interface Foo{
	void printInt(int x);
}

위 방식으로 함수형 인터페이스를 작성할 수 있다.

Lambda Capturing

public supply<Integer> a() {  
    int seperator = 1;  
    //seperator = 2  ;//final 키워드가 없더라도 final처럼 사용하지 않으면 문제가 된다.  
    return () -> seperator;  
}  

@FunctionalInterface
public interface supply<I extends Number> {  
    int a();  
}

위 코드처럼 단순 지역 변수를 그대로 사용할 수 있다.
하지만, 이렇게 사용할 때에 지역 변수는 effectivly final variable 이여야 한다.

이러한 제약이 있는 이유는 인스턴스 변수는 heap에 저장하고, 지역 변수는 Stack에 저장하는데 람다가 스레드에서 실행된다면 스레드는 지역 변수를 공유할 수 없는 형태이므로 람다가 자유 변수를 참조할 때 자신의 Stack에 복사하여 참조하고 있기 떄문에 수정이 불가능해야 한다.

Lambda 메소드, 생성자, 레퍼런스 참조

메소드 참조

메소드를 참조하여 매개 변수의 정보와 리턴 타입을 알아내어 불필요한 매개 변수를 제거할 수 있다.

(x,y) -> Math.min(x,y);
IntBinaryOperator operator = Math::min; // IntBinaryOperator 인터페이스에 applyAsInt 메소드를 활용하여 연산 값을 리턴 가능하게 만들 수 있다.

정적 메소드와 인스턴스 메소드

정적 메소드는 클래스::메소드 처럼 사용이 가능하고, 인스턴스 메소드는 객체를 생성한 수에 참조변수::메소드 형식으로 사용한다.

public static void main(String[] args) {  
    ToIntBiFunction<Integer, Integer> function1;  
    ToIntBiFunction<Integer, Integer> function2;  
  
    function1 = cal::staticSum;  
    System.out.println(function1.applyAsInt(1,2)); // 3 출력 
     
    cal c = new cal(); // 인스턴스 메소드는 객체 생성이 우선  
    function2 = c::instanceSum;  
    System.out.println(function2.applyAsInt(3,4)); // 7 출력  

	int result = allSum(function1.applyAsInt(1,2), function2.applyAsInt(3,4)); //매개변수에 메소드 참조 가능
	System.out.println(result); // 10 출력
    
}

public static int allSum(int sum1, int sum2){
	return sum1 + sum2;
}

class cal{  
    public int instanceSum(int n1, int n2){  
        return n1+n2;  
    }  
  
    public static int staticSum(int n1, int n2){  
        return n1+n2;  
    }  
}

생성자 참조

단순히 객체를 생성하고 리턴하는 것 뿐이라면 생성자 참조로 변환이 가능하다.

(a, b) -> new cal(a,b);
cal::new; // 변환 가능

단, 생성자가 여러 개 일 경우 매개 변수로 들어오는 개수에 따라 다른 생성자를 접근한다.

public static void main(String[] args) {  
    Function<Integer, cal> function1 = cal::new;  
    cal student = function1.apply(1); // 매개변수 1개의 생성자 접근  
  
    BiFunction<Integer, Integer, cal> function2 = cal::new;  
    cal student2 = function2.apply(1,2); // 매개변수 2개의 생성자 접근  
}

class cal{  
    int n1;  
    int n2;  
    public cal(int n1, int n2) {  
        this.n1 = n1;  
        this.n2 = n2;  
    }  
  
    public cal(int n1){  
        this(n1, 100);  
    }
}

아래는 Java.Util.Functinon의 인터페이스를 표시 한 것이다.


인터페이스명	추상메소드	설명
Consumer<\T>	void accept(T t)	객체 T를 받아 소비
BiConsumer<\T>	void accept(T t, U u)	객체 T와 U를 받아 소비
DoubleConsumer<\T>	void accept(double value)	double 값을 받아 소비
IntConsumer<\T>	void accept(int value)	int 값을 받아 소비
LongConsumer<\T>	void accept(long value)	long 값을 받아 소비
ObjDoubleConsumer<\T>	void accept(T t, double value)	객체 T와 double 값을 받아 소비
ObjIntConsumer<\T>	void accept(T t, int value)	객체 T와 int 값을 받아 소비
ObjLongConsumer<\T>	void accept(T t, long value)	객체 T와 long 값을 받아 소비