Ubuntu에서 PostgreSQL을 설치하고 외부 접속을 허용하려면 다음과 같은 단계로 진행하면 됩니다.

1. PostgreSQL 설치

sudo apt update
sudo apt install postgresql postgresql-contrib

설치 후 PostgreSQL 서비스가 자동 시작됩니다. 상태 확인:

sudo systemctl status postgresql

2. PostgreSQL 유저 및 DB 설정

PostgreSQL 설치 시 기본적으로 postgres라는 유저가 생성됩니다.

sudo -i -u postgres
psql

원하는 유저와 DB를 만들고 비밀번호 설정:

CREATE USER myuser WITH PASSWORD 'mypassword';
CREATE DATABASE mydb OWNER myuser;

권한 부여:

커링(Currying)은 여러 개의 인자를 받는 함수를 하나의 인자만 받는 함수들의 연속으로 변환하는 기법입니다. 수학자 하스켈 커리(Haskell Curry)의 이름에서 따온 용어입니다.

기본 개념

일반적인 함수:

function add(a, b, c) {
    return a + b + c;
}

add(1, 2, 3); // 6

커링된 함수:

function curriedAdd(a) {
    return function(b) {
        return function(c) {
            return a + b + c;
        };
    };
}

curriedAdd(1)(2)(3); // 6

화살표 함수로 간단하게

const curriedAdd = a => b => c => a + b + c;

const result = curriedAdd(1)(2)(3); // 6

부분 적용 (Partial Application)

커링의 가장 큰 장점은 부분 적용이 가능하다는 것입니다:

const curriedAdd = a => b => c => a + b + c;

// 부분 적용
const add5 = curriedAdd(5);
const add5And3 = add5(3);

console.log(add5And3(2)); // 10 (5 + 3 + 2)
console.log(add5(4)(1)); // 10 (5 + 4 + 1)

실용적인 예제들

1. 문자열 검사 함수

const hasSubstring = substring => str => str.includes(substring);

const hasReact = hasSubstring('React');
const hasVue = hasSubstring('Vue');

console.log(hasReact('React 개발자')); // true
console.log(hasVue('Vue.js 프레임워크')); // true

// 배열에서 활용
const frameworks = ['React', 'Angular', 'Vue', 'Svelte'];
const reactItems = frameworks.filter(hasReact);
console.log(reactItems); // ['React']

2. 수학 연산

const multiply = a => b => a * b;
const divide = a => b => a / b;

const double = multiply(2);
const triple = multiply(3);
const half = divide(1/2); // 또는 multiply(0.5)

console.log(double(5)); // 10
console.log(triple(4)); // 12

const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(double);
console.log(doubled); // [2, 4, 6, 8, 10]

3. 이벤트 핸들러

const log = level => message => {
    console.log(`[${level}] ${message}`);
};

const logError = log('ERROR');
const logInfo = log('INFO');

logError('데이터베이스 연결 실패'); // [ERROR] 데이터베이스 연결 실패
logInfo('서버 시작됨'); // [INFO] 서버 시작됨

4. API 요청

const apiRequest = method => url => data => {
    return fetch(url, {
        method: method,
        headers: { 'Content-Type': 'application/json' },
        body: data ? JSON.stringify(data) : undefined
    });
};

const get = apiRequest('GET');
const post = apiRequest('POST');
const put = apiRequest('PUT');

// 사용
get('/api/users')();
post('/api/users')({ name: '김철수', email: 'kim@example.com' });

자동 커링 함수 만들기

function curry(fn) {
    return function curried(...args) {
        if (args.length >= fn.length) {
            return fn.apply(this, args);
        } else {
            return function(...nextArgs) {
                return curried.apply(this, args.concat(nextArgs));
            };
        }
    };
}

// 사용 예
function add(a, b, c) {
    return a + b + c;
}

const curriedAdd = curry(add);

console.log(curriedAdd(1)(2)(3)); // 6
console.log(curriedAdd(1, 2)(3)); // 6
console.log(curriedAdd(1)(2, 3)); // 6
console.log(curriedAdd(1, 2, 3)); // 6

라이브러리에서의 활용

Lodash

const _ = require('lodash');

const add = (a, b, c) => a + b + c;
const curriedAdd = _.curry(add);

console.log(curriedAdd(1)(2)(3)); // 6

Ramda

const R = require('ramda');

const users = [
    { name: '김철수', age: 25 },
    { name: '이영희', age: 30 },
    { name: '박민수', age: 35 }
];

const getProperty = R.curry((prop, obj) => obj[prop]);
const getName = getProperty('name');

const names = users.map(getName);
console.log(names); // ['김철수', '이영희', '박민수']

커링의 장점

1. 재사용성: 특정 매개변수가 고정된 새로운 함수를 쉽게 생성
2. 가독성: 함수의 의도가 더 명확해짐
3. 함수 조합: 다른 고차 함수들과 조합하기 쉬움
4. 부분 적용: 필요할 때 일부 인자만 먼저 적용 가능

주의사항

1. 성능: 함수 호출이 중첩되므로 약간의 오버헤드 발생
2. 디버깅: 스택 트레이스가 복잡해질 수 있음
3. 가독성: 과도하게 사용하면 오히려 코드를 이해하기 어려워질 수 있음

커링은 함수형 프로그래밍의 핵심 개념 중 하나로, 코드의 재사용성과 모듈성을 크게 향상시킬 수 있는 강력한 기법입니다.

1. 함수형 인터페이스 사용 (Java 8+)

기본적인 커링 구현

import java.util.function.Function;

public class CurryingExample {
    
    // 3개 인자를 받는 함수를 커링
    public static Function<Integer, Function<Integer, Function<Integer, Integer>>> 
           curriedAdd() {
        return a -> b -> c -> a + b + c;
    }
    
    public static void main(String[] args) {
        // 사용 예
        Function<Integer, Function<Integer, Function<Integer, Integer>>> add = curriedAdd();
        
        int result1 = add.apply(1).apply(2).apply(3); // 6
        System.out.println(result1);
        
        // 부분 적용
        Function<Integer, Function<Integer, Integer>> add5 = add.apply(5);
        Function<Integer, Integer> add5And3 = add5.apply(3);
        
        int result2 = add5And3.apply(2); // 10
        System.out.println(result2);
    }
}

더 복잡한 예제 - 문자열 처리

import java.util.function.Function;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StringCurrying {
    
    // 문자열 포함 검사 함수
    public static Function<String, Function<String, Boolean>> contains() {
        return substring -> str -> str.contains(substring);
    }
    
    // 문자열 변환 함수
    public static Function<String, Function<String, String>> replace() {
        return target -> replacement -> str -> str.replace(target, replacement);
    }
    
    public static void main(String[] args) {
        List<String> frameworks = Arrays.asList("React", "Angular", "Vue", "Svelte");
        
        // 부분 적용된 함수 생성
        Function<String, Boolean> hasReact = contains().apply("React");
        
        // 스트림과 함께 사용
        List<String> reactItems = frameworks.stream()
            .filter(hasReact::apply)
            .collect(Collectors.toList());
        
        System.out.println(reactItems); // [React]
        
        // 문자열 치환
        Function<String, String> replaceJavaWithKotlin = 
            replace().apply("Java").apply("Kotlin");
        
        String result = replaceJavaWithKotlin.apply("I love Java programming");
        System.out.println(result); // I love Kotlin programming
    }
}

2. 제네릭을 활용한 범용 커링 유틸리티

import java.util.function.*;

public class CurryUtil {
    
    // 2개 인자 함수 커링
    public static <A, B, R> Function<A, Function<B, R>> 
           curry(BiFunction<A, B, R> function) {
        return a -> b -> function.apply(a, b);
    }
    
    // 3개 인자 함수를 위한 함수형 인터페이스
    @FunctionalInterface
    public interface TriFunction<A, B, C, R> {
        R apply(A a, B b, C c);
    }
    
    // 3개 인자 함수 커링
    public static <A, B, C, R> Function<A, Function<B, Function<C, R>>> 
           curry(TriFunction<A, B, C, R> function) {
        return a -> b -> c -> function.apply(a, b, c);
    }
    
    public static void main(String[] args) {
        // BiFunction 커링
        BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
        Function<Integer, Function<Integer, Integer>> curriedMultiply = curry(multiply);
        
        Function<Integer, Integer> double_ = curriedMultiply.apply(2);
        System.out.println(double_.apply(5)); // 10
        
        // TriFunction 커링
        TriFunction<Integer, Integer, Integer, Integer> add3 = (a, b, c) -> a + b + c;
        Function<Integer, Function<Integer, Function<Integer, Integer>>> curriedAdd3 = curry(add3);
        
        int result = curriedAdd3.apply(1).apply(2).apply(3);
        System.out.println(result); // 6
    }
}

3. 클래스 기반 구현

public class MathOperations {
    
    public static class CurriedAdd {
        private final int first;
        
        private CurriedAdd(int first) {
            this.first = first;
        }
        
        public static CurriedAdd of(int first) {
            return new CurriedAdd(first);
        }
        
        public CurriedAddSecond with(int second) {
            return new CurriedAddSecond(first, second);
        }
        
        public class CurriedAddSecond {
            private final int second;
            
            private CurriedAddSecond(int first, int second) {
                this.second = second;
            }
            
            public int and(int third) {
                return first + second + third;
            }
        }
    }
    
    public static void main(String[] args) {
        int result = CurriedAdd.of(1).with(2).and(3); // 6
        System.out.println(result);
        
        // 부분 적용
        CurriedAdd add5 = CurriedAdd.of(5);
        CurriedAdd.CurriedAddSecond add5And3 = add5.with(3);
        
        int result2 = add5And3.and(2); // 10
        System.out.println(result2);
    }
}

4. 실용적인 예제 - HTTP 클라이언트

import java.util.function.Function;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class CurriedHttpClient {
    
    public static Function<String, Function<String, Function<String, HttpRequest>>> 
           httpRequest() {
        return method -> url -> body -> {
            HttpRequest.Builder builder = HttpRequest.newBuilder()
                .uri(URI.create(url));
            
            switch (method.toUpperCase()) {
                case "GET":
                    builder.GET();
                    break;
                case "POST":
                    builder.POST(HttpRequest.BodyPublishers.ofString(body));
                    break;
                case "PUT":
                    builder.PUT(HttpRequest.BodyPublishers.ofString(body));
                    break;
            }
            
            return builder.build();
        };
    }
    
    public static void main(String[] args) {
        // 부분 적용된 함수들 생성
        Function<String, Function<String, HttpRequest>> get = 
            httpRequest().apply("GET");
        Function<String, Function<String, HttpRequest>> post = 
            httpRequest().apply("POST");
        
        // 사용
        HttpRequest getRequest = get.apply("https://api.example.com/users").apply("");
        HttpRequest postRequest = post.apply("https://api.example.com/users")
            .apply("{\"name\":\"김철수\"}");
        
        System.out.println("GET: " + getRequest.uri());
        System.out.println("POST: " + postRequest.uri());
    }
}

5. Vavr 라이브러리 사용

Vavr(이전 Javaslang)는 자바에서 함수형 프로그래밍을 더 쉽게 할 수 있게 해주는 라이브러리입니다:

JavaScript에서 **클로저(Closure)**는 함수와 그 함수가 선언된 어휘적 환경(Lexical Environment)의 조합을 말합니다. 즉, 함수가 외부 스코프의 변수에 접근할 수 있는 기능을 의미합니다.

📌 기본 개념

클로저는 다음과 같은 조건에서 생성됩니다:

1. 함수 안에 함수가 정의되어 있고,
2. 내부 함수가 외부 함수의 변수에 접근할 수 있으며,
3. 외부 함수의 실행이 끝난 뒤에도 내부 함수가 여전히 그 변수에 접근할 수 있을 때 클로저가 됩니다.

function outer() {
  let count = 0;
  return function inner() {
    count++;
    console.log(count);
  }
}

const counter = outer();
counter(); // 1
counter(); // 2

위 예제에서 inner() 함수는 outer()의 지역 변수 count에 접근합니다. outer()의 실행이 끝났음에도 counter()가 count에 계속 접근할 수 있는 이유는 클로저 때문입니다.

MySQL을 비롯한 대부분의 관계형 데이터베이스에서 사용되는 JOIN은 여러 테이블의 데이터를 조합해 하나의 결과로 만드는 데 사용됩니다. 아래는 대표적인 JOIN 종류와 각각의 설명, 예제를 포함한 정리입니다.

🔗 1. INNER JOIN

✅ 정의

두 테이블에서 공통된 값이 존재하는 행만 반환합니다.

🧪 예시

SELECT a.id, a.name, b.order_date
FROM customers a
INNER JOIN orders b ON a.id = b.customer_id;

📌 특징

• 가장 일반적인 JOIN 방식
• 양쪽 모두 일치하는 값이 있어야 결과에 포함됨

🔗 2. LEFT JOIN (또는 LEFT OUTER JOIN)

✅ 정의

왼쪽 테이블의 모든 행을 반환하며, 오른쪽 테이블에 일치하는 값이 없으면 NULL로 채워집니다.

HttpApiCachingFilter 와 CachedHttpServletRequestWrapper

• json과 multipart 외 form-urlencoded의 경우도 허용하면서 logging 정보 남기는 filter 구현 예시
• request 의 inputStream을 한번 읽으면 휘발되기 때문에 이를 방지하는 로직이 중요합니다.

HttpApiCachingFilter

@Component
@Order(value = Ordered.HIGHEST_PRECEDENCE)
@WebFilter(filterName = "HttpApiCachingFilter", urlPatterns = "/*")
@Slf4j
public class HttpApiCachingFilter extends OncePerRequestFilter {

    private static String APPLICATION_NAME;

    @Value("${spring.application.name}")
    private void setApplicationName(String value) {
        APPLICATION_NAME = value;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {
        if (isAsyncDispatch(request)) {
            filterChain.doFilter(request, response);
        } else if (isMultipartRequest(request)) {
            doFilterWrapped(new StandardMultipartHttpServletRequest(request), new CachedHttpServletResponseWrapper(response), filterChain);
        } else {
            doFilterWrapped(new CachedHttpServletRequestWrapper(request), new CachedHttpServletResponseWrapper(response), filterChain);
        }
    }

    protected void doFilterWrapped(HttpServletRequestWrapper request, ContentCachingResponseWrapper response, FilterChain filterChain)
        throws ServletException, IOException {
        try {
            logRequestHeader(request);
            logRequest(request);
            filterChain.doFilter(request, response);
        } finally {
            logResponseHeader(response);
            logResponse(response);
            response.copyBodyToResponse();
        }
    }

    private static void logRequestHeader(HttpServletRequestWrapper request) {
        Enumeration<String> headerNames = request.getHeaderNames();
        if (headerNames != null) {
            Collections.list(headerNames).forEach(headersName -> {
                String headerValue = request.getHeader(headersName);
                log.info("Request Header {}: {}", headersName, headerValue);
            });
        }
    }

    private static void logRequest(HttpServletRequestWrapper request) throws IOException {
        String contentType = request.getContentType();

        log.info("Request body: {} uri=[{}] content-type=[{}]", request.getMethod(),
            request.getRequestURI(), contentType);

        if (contentType != null && contentType.startsWith(MediaType.APPLICATION_FORM_URLENCODED_VALUE)) {
            Map<String, String[]> paramMap = request.getParameterMap();
            paramMap.forEach((key, values) -> {
                for (String value : values) {
                    log.info("REQUEST Param: {} = {}", key, value);
                }
            });
        } else {
            logPayload("REQUEST", contentType, request.getInputStream(), request.getRequestURI());
        }
    }

    private static void logResponseHeader(ContentCachingResponseWrapper response) {
        Collection<String> headerNames = response.getHeaderNames();
        for (String headerName : headerNames) {
            for (String value : response.getHeaders(headerName)) {
                log.info("Response Header {}: {}", headerName, value);
            }
        }
    }

    private static void logResponse(ContentCachingResponseWrapper response) throws IOException {
        logPayload("RESPONSE", response.getContentType(), response.getContentInputStream(), null);
    }

    private static void logPayload(String direction,
                                   String contentType,
                                   InputStream inputStream,
                                   String targetUri
    ) throws IOException {
        boolean visible = isVisible(MediaType.valueOf(contentType == null ? "application/json" : contentType));
        if (visible) {
            byte[] content = StreamUtils.copyToByteArray(inputStream);
            if (content.length > 0) {
                String contentString = new String(content);
                log.info("{} Payload: {}", direction, contentString);
            }
        } else {
            log.info("{} Payload: Binary Content", direction);
        }
    }

    private static boolean isVisible(MediaType mediaType) {
        final List<MediaType> VISIBLE_TYPES = Arrays.asList(MediaType.valueOf("text/*"),
            MediaType.APPLICATION_FORM_URLENCODED,
            MediaType.APPLICATION_JSON,
            MediaType.APPLICATION_XML,
            MediaType.valueOf("application/*+json"),
            MediaType.valueOf("application/*+xml"),
            MediaType.MULTIPART_FORM_DATA);
        return VISIBLE_TYPES.stream().anyMatch(visibleType -> visibleType.includes(mediaType));
    }

    private boolean isMultipartRequest(HttpServletRequest request) {
        String contentType = request.getContentType();
        return request.getMethod().equalsIgnoreCase("POST")
            && contentType != null
            && contentType.startsWith("multipart/form-data");
    }
}

CachedHttpServletRequestWrapper.java

public class CachedHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private final byte[] cachedBody;
    private Map<String, String[]> parameterMap;

    public CachedHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        this.cachedBody = request.getInputStream().readAllBytes();

        // form-urlencoded 타입일 때만 파라미터 파싱
        String contentType = request.getContentType();
        if (contentType != null && contentType.startsWith(MediaType.APPLICATION_FORM_URLENCODED_VALUE)) {
            String encoding = request.getCharacterEncoding();
            if (encoding == null) {
                encoding = StandardCharsets.UTF_8.name();
            }
            this.parameterMap = parseFormParameters(new String(this.cachedBody, encoding));
        } else {
            // 원본 request의 파라미터 맵 사용
            this.parameterMap = super.getParameterMap();
        }
    }

    @Override
    public ServletInputStream getInputStream() {
        ByteArrayInputStream bais = new ByteArrayInputStream(cachedBody);

        return new ServletInputStream() {
            @Override
            public int read() {
                return bais.read();
            }

            @Override
            public boolean isFinished() {
                return bais.available() == 0;
            }

            @Override
            public boolean isReady() {
                return true;
            }

            @Override
            public void setReadListener(ReadListener listener) {
            }
        };
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        return this.parameterMap;
    }

    @Override
    public BufferedReader getReader() {
        String encoding = getCharacterEncoding();
        if (encoding == null) {
            encoding = StandardCharsets.UTF_8.name();
        }
        return new BufferedReader(new InputStreamReader(getInputStream(), Charset.forName(encoding)));
    }

    private Map<String, String[]> parseFormParameters(String body) throws UnsupportedEncodingException {
        Map<String, List<String>> tempMap = new LinkedHashMap<>();

        // 빈 바디 처리
        if (body == null || body.trim().isEmpty()) {
            return new LinkedHashMap<>();
        }

        for (String pair : body.split("&")) {
            if (pair.trim().isEmpty()) {
                continue; // 빈 pair 건너뛰기
            }

            String[] parts = pair.split("=", 2);
            if (parts.length == 0) {
                continue;
            }

            String key = URLDecoder.decode(parts[0], StandardCharsets.UTF_8);
            String value = parts.length > 1 ? URLDecoder.decode(parts[1], StandardCharsets.UTF_8) : "";
            tempMap.computeIfAbsent(key, k -> new ArrayList<>()).add(value);
        }

        return tempMap.entrySet().stream()
            .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().toArray(new String[0])));
    }
}

CachedHttpServletResponseWrapper.java

public class CachedHttpServletResponseWrapper extends ContentCachingResponseWrapper {

    public CachedHttpServletResponseWrapper(HttpServletResponse response) {
        super(response);
    }
}