파이프 필테 아키텍쳐 샘플

[ywbestPark]

import java.util.ArrayList;
import java.util.List;

// 필터 인터페이스 정의
interface Filter<T> {
    T process(T input);
}

// 문자열을 대문자로 변환하는 필터
class UppercaseFilter implements Filter<String> {
    @Override
    public String process(String input) {
        return input.toUpperCase();
    }
}

// 문자열을 역순으로 변환하는 필터
class ReverseFilter implements Filter<String> {
    @Override
    public String process(String input) {
        return new StringBuilder(input).reverse().toString();
    }
}

// 정수를 제곱하는 필터
class SquareFilter implements Filter<Integer> {
    @Override
    public Integer process(Integer input) {
        return input * input;
    }
}

// 파이프라인 클래스
class Pipeline<T> {
    private List<Filter<T>> filters = new ArrayList<>();

    public Pipeline<T> addFilter(Filter<T> filter) {
        filters.add(filter);
        return this;
    }

    public T execute(T input) {
        T result = input;
        for (Filter<T> filter : filters) {
            result = filter.process(result);
        }
        return result;
    }
}

public class PipeAndFilterArchitecture {
    public static void main(String[] args) {
        // 문자열 파이프라인 예제
        Pipeline<String> stringPipeline = new Pipeline<>();
        stringPipeline.addFilter(new UppercaseFilter())
                     .addFilter(new ReverseFilter());

        String text = "Hello, World!";
        String processedText = stringPipeline.execute(text);
        System.out.println("Processed text: " + processedText);

        // 정수 파이프라인 예제
        Pipeline<Integer> integerPipeline = new Pipeline<>();
        integerPipeline.addFilter(new SquareFilter());

        int number = 5;
        int processedNumber = integerPipeline.execute(number);
        System.out.println("Processed number: " + processedNumber);
    }
}

[ywbestPark]

import java.lang.reflect.Method;

public class DynamicMethodInvocationWithParameters {
    public static void main(String[] args) {
        try {
            // 클래스 이름과 메서드 이름을 입력받음
            String className = "YourClassName"; // 대상 클래스 이름
            String methodName = "yourMethodName"; // 실행할 메서드 이름

            // 클래스를 동적으로 로드
            Class<?> targetClass = Class.forName(className);

            // 메서드를 동적으로 가져옴
            Method method = targetClass.getMethod(methodName, String.class, int.class); // 예시: 문자열과 정수 파라미터

            // 인스턴스 생성 (기본 생성자를 사용할 경우)
            Object instance = targetClass.getDeclaredConstructor().newInstance();

            // 메서드 실행에 필요한 인수 설정
            String inputParam1 = "Example Input";
            int inputParam2 = 42;

            // 메서드 실행
            Object result = method.invoke(instance, inputParam1, inputParam2);

            // 결과 출력
            System.out.println("Method result: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

[ywbestPark]

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class DynamicConstructorInvocation {
    public static void main(String[] args) {
        try {
            // 클래스 이름을 입력받음
            String className = "YourClassName"; // 대상 클래스 이름

            // 클래스를 동적으로 로드
            Class<?> targetClass = Class.forName(className);

            // 생성자 인수 타입을 결정 (예시: String, int)
            Class<?>[] constructorParameterTypes = {String.class, int.class};

            // 생성자 가져오기
            Constructor<?> constructor = targetClass.getConstructor(constructorParameterTypes);

            // 생성자를 사용하여 객체 인스턴스 생성
            Object instance = constructor.newInstance("Example Input", 42);

            // 실행할 메서드 이름을 입력받음
            String methodName = "yourMethodName"; // 실행할 메서드 이름

            // 실행할 메서드의 시그니처를 결정 (예시: String, int)
            Class<?>[] methodParameterTypes = {String.class, int.class};

            // 메서드 가져오기
            Method method = targetClass.getMethod(methodName, methodParameterTypes);

            // 메서드 실행에 필요한 입력 파라미터 설정
            Object[] methodArgs = {"Method Input", 123};

            // 메서드 실행
            Object result = method.invoke(instance, methodArgs);

            // 결과 출력
            System.out.println("Method result: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}