Для чего нужен target метод?

# Target метод в Java

Этот вопрос требует уточнения контекста, так как "target метод" может означать разные вещи в зависимости от области применения. Рассмотрю все основные случаи.

Контекст 1: Spring AOP (Aspect-Oriented Programming)

В контексте Spring AOP "target" — это оригинальный объект, на который указывает прокси.

// Оригинальный объект
@Service
public class UserService {
    public void saveUser(User user) {
        // Реальный код
    }
}

// Spring создает прокси
UserService proxy = proxyFactory.createProxy(userService);

// proxy.saveUser() вызовет:
// 1. Advice (логирование, транзакция)
// 2. target.saveUser() (оригинальный метод)
// 3. Advice (cleanup)

Терминология:

• Target — оригинальный объект UserService
• Proxy — прокси, который обворачивает target
• Joint Point — точка вызова метода
• Advice — код, который выполняется до/после target

Контекст 2: Reflection (отражение)

В reflection API есть методы для работы с методами через reflection:

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        // Получаем класс
        Class<?> clazz = MyClass.class;
        
        // Получаем метод
        Method targetMethod = clazz.getMethod("myMethod");
        
        // Создаем объект
        Object target = clazz.newInstance();
        
        // Вызываем метод на объекте (target)
        targetMethod.invoke(target);  // target — это объект, на котором вызываем
    }
}

public class MyClass {
    public void myMethod() {
        System.out.println("Вызван метод");
    }
}

Контекст 3: Design Patterns

В некоторых паттернах используется терминология "target method" для методов, на которые направлены операции.

Command Pattern

// Command запоминает target объект и target метод
public class Command implements Runnable {
    private Receiver receiver;  // target объект
    
    public void execute() {
        receiver.action();  // target метод
    }
}

// Использование
Receiver receiver = new Receiver();
Command command = new Command(receiver);
command.execute();  // Вызывает receiver.action()

Strategy Pattern

// Разные реализации target метода
interface Strategy {
    void execute();  // target метод
}

class ConcreteStrategyA implements Strategy {
    public void execute() {
        // Реализация A
    }
}

class Context {
    private Strategy strategy;
    
    public void doWork() {
        strategy.execute();  // вызываем target метод
    }
}

Контекст 4: Сборка Maven

В Maven есть параметр "target" для компиляции Java.

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <target>11</target>  <!-- Target Java версия -->
                <source>11</source>
            </configuration>
        </plugin>
    </plugins>
</build>

Это означает: компилируй исходный код (source 11) в bytecode для Java 11 (target 11).

Контекст 5: JUnit Tests

В unit тестах часто используется термин "target" для тестируемого объекта:

public class UserServiceTest {
    private UserRepository repository;  // mock
    private UserService target;  // объект под тестом
    
    @Before
    public void setUp() {
        repository = mock(UserRepository.class);
        target = new UserService(repository);
    }
    
    @Test
    public void testSaveUser() {
        User user = new User("John");
        target.saveUser(user);  // вызываем метод на target
        
        verify(repository).save(user);
    }
}

Наиболее вероятный контекст: Spring AOP

Если это собеседование для Java Developer и контекст Spring, то вопрос скорее всего о Spring AOP.

Полный пример Spring AOP

// 1. Service (target object)
@Service
public class UserService {
    public void saveUser(User user) {
        System.out.println("Saving user: " + user.getName());
    }
}

// 2. Aspect (перехватывает вызовы)
@Aspect
@Component
public class LoggingAspect {
    
    @Before("execution(* UserService.save*(..))")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("BEFORE: " + joinPoint.getSignature());
    }
    
    @After("execution(* UserService.save*(..))")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("AFTER: " + joinPoint.getSignature());
    }
}

// 3. Использование
@RestController
public class UserController {
    @Autowired
    private UserService userService;  // это PROXY, не оригинальный объект
    
    @PostMapping("/users")
    public void createUser(@RequestBody User user) {
        userService.saveUser(user);  // Выполнится:
        // BEFORE logging
        // target.saveUser(user)  <- оригинальный метод
        // AFTER logging
    }
}

Вывод:

• Target = оригинальный UserService объект
• Proxy = обернутый объект с advice
• Target метод = оригинальный saveUser()

Как найти target в runtime

@Aspect
@Component
public class DebugAspect {
    
    @Around("execution(* UserService.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // joinPoint.getTarget() — это target объект
        Object target = joinPoint.getTarget();
        System.out.println("Target class: " + target.getClass());
        System.out.println("Target object: " + target);
        
        // Вызываем оригинальный метод
        return joinPoint.proceed();
    }
}

Выводы

1. Target метод — обычно означает оригинальный метод, который обворачивается
2. В контексте Spring AOP — это метод, на который указывает прокси
3. Target объект — оригинальный bean, который был обернут прокси
4. Proxy — это то, что получает Spring при внедрении зависимости
5. Это важно для понимания как работают transactions, logging, security в Spring

Если в вопросе другой контекст (Maven, Reflection, Test), то ответ может быть другим. Но в большинстве случаев на Java интервью имеют в виду Spring AOP.