Является ли метод, получаемый объект Proxy, статическим?

Статические методы и Proxy объекты в Spring

Коротко: Нет, не является статическим

Методы Proxy объекта — это обычные (нестатические) методы. Proxy перехватывает вызовы экземплярных методов, но НЕ может перехватывать статические методы.

Как работают Proxy в Spring

Spring использует две технологии для создания proxies:

1. JDK Dynamic Proxy (интерфейсы)

// Интерфейс
public interface UserService {
    void saveUser(User user);  // экземплярный метод
    static void staticMethod() {}  // статический метод
}

// Реализация
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser(User user) {
        System.out.println("Saving user: " + user);
    }
    
    @Override
    public static void staticMethod() {
        System.out.println("Static");
    }
}

// Spring создаст Proxy
public class UserServiceProxy implements UserService {
    private UserService target;
    
    public UserServiceProxy(UserService target) {
        this.target = target;
    }
    
    @Override
    public void saveUser(User user) {
        // ПЕРЕХВАТЫВАЕТ вызов
        System.out.println("Before saving");
        target.saveUser(user);  // вызов реального метода
        System.out.println("After saving");
    }
    
    @Override
    public static void staticMethod() {
        // ОШИБКА! Прокси НЕ может переопределить статический метод
        // Статический метод не может быть переопределён в интерфейсе (Java запрещает)
    }
}

// Использование
@Service
public class UserService {
    @Autowired
    private UserRepository repository;
    
    public void saveUser(User user) {
        repository.save(user);
    }
}

@Component
public class MyComponent {
    @Autowired
    private UserService userService;  // Spring внедрит PROXY!
    
    public void test() {
        // Вызов проходит через proxy
        userService.saveUser(new User("John"));
        
        // Это работает, потому что saveUser() — экземплярный метод,
        // а proxy может его перехватить
    }
}

Статические методы НЕ перехватываются

public class UserService {
    
    // Экземплярный метод — БУДЕТ перехвачен
    @Transactional
    public void saveUser(User user) {
        // ...
    }
    
    // Статический метод — НЕ БУДЕТ перехвачен
    @Transactional  // Эта аннотация не сработает!
    public static void staticSave(User user) {
        // ...
    }
}

@Component
public class App {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(UserService.class, args);
        UserService service = context.getBean(UserService.class);
        
        // saveUser ИМЕЕТ транзакцию (proxy перехватит)
        service.saveUser(new User());  // OK
        
        // staticSave НЕ ИМЕЕТ транзакцию (proxy не может перехватить)
        UserService.staticSave(new User());  // Без транзакции!
    }
}

CGLib Proxy (для классов без интерфейсов)

// Класс БЕЗ интерфейса
@Service
public class UserService {
    
    public void saveUser(User user) {
        System.out.println("Save: " + user);
    }
    
    public static void staticMethod() {
        System.out.println("Static");
    }
}

// Spring создаст CGLib прокси (наследование от класса)
public class UserService$$EnhancerByCGLIB$$123 extends UserService {
    private UserService target;
    
    @Override
    public void saveUser(User user) {
        // ПЕРЕХВАТЫВАЕТ
        System.out.println("Before");
        super.saveUser(user);
        System.out.println("After");
    }
    
    // Статический метод НЕ может быть переопределён в классе
    // (Java не позволяет переопределять статические методы)
}

// Результат: статические методы всё равно не перехватываются

Почему статические методы не работают с Proxy?

Причина 1: Статические методы привязаны к классу, не к объекту

public class Example {
    // Экземплярный метод
    public void instanceMethod() {
        System.out.println("Instance");
    }
    
    // Статический метод
    public static void staticMethod() {
        System.out.println("Static");
    }
}

Example obj = new Example();
obj.instanceMethod();        // Вызов через объект — может быть перехвачен
Example.staticMethod();      // Вызов через класс — не может быть перехвачен

// Статический метод НЕ зависит от конкретного объекта
// Proxy работает с объектами, не с классами

Причина 2: Невозможно переопределить статический метод

public class Parent {
    public static void staticMethod() {
        System.out.println("Parent");
    }
}

public class Child extends Parent {
    // Это НЕ переопределение, это новый статический метод
    public static void staticMethod() {
        System.out.println("Child");
    }
}

// Java это называет "method hiding", не "override"
Parent p = new Child();
p.staticMethod();  // Выведет "Parent", не "Child"!

Пример с AOP (Aspect-Oriented Programming)

// AOP интерцептор работает только с экземплярными методами
@Aspect
@Component
public class LoggingAspect {
    
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Calling: " + joinPoint.getSignature());
    }
}

@Service
public class UserService {
    
    // БУДЕТ залогирован
    public void saveUser(User user) {
        System.out.println("Saving");
    }
    
    // НЕ БУДЕТ залогирован (статический метод)
    public static void bulkCreate(List<User> users) {
        System.out.println("Bulk creating");
    }
}

// Результат при использовании
UserService service = context.getBean(UserService.class);
service.saveUser(new User());  // Выведет:
                               // Calling: void saveUser(...)
                               // Saving

UserService.bulkCreate(users);  // Выведет только:
                                // Bulk creating
                                // (без логирования!)

@Transactional на статических методах (ОПАСНО!)

public class OrderService {
    
    @Transactional  // РАБОТАЕТ
    public void placeOrder(Order order) {
        // Этот метод будет выполнен в транзакции
    }
    
    @Transactional  // НЕ РАБОТАЕТ!
    public static void generateReport() {
        // Этот метод НЕ будет в транзакции
        // Если произойдёт ошибка, rollback не случится
    }
}

Правильный способ: экземплярные методы

@Service
public class UserService {
    
    @Autowired
    private UserRepository repository;
    
    // ПРАВИЛЬНО: экземплярный метод с @Transactional
    @Transactional
    public void saveUser(User user) {
        repository.save(user);
    }
    
    // ПРАВИЛЬНО: экземплярный метод для bulk операций
    @Transactional
    public void saveUsers(List<User> users) {
        for (User user : users) {
            repository.save(user);
        }
    }
    
    // НЕПРАВИЛЬНО: статический метод с @Transactional
    // (аннотация просто не сработает)
    @Transactional
    public static void staticSave(User user) {
        // БЕЗ транзакции!
    }
}

// Использование
@Component
public class OrderProcessor {
    
    @Autowired
    private UserService userService;  // Это PROXY
    
    public void process(List<User> users) {
        // Вызов через объект — proxy перехватит, транзакция работает
        userService.saveUsers(users);
        
        // Вызов статического метода напрямую
        UserService.staticSave(new User());  // Без транзакции!
    }
}

Тестирование Proxy

@SpringBootTest
public class UserServiceTest {
    
    @Autowired
    private UserService userService;
    
    @Test
    public void testProxyCreation() {
        // userService — это PROXY, не реальный объект
        System.out.println(userService.getClass());  
        // Выведет что-то типа: class com.example.UserService$$EnhancerByCGLIB$$1234
        
        // Экземплярный метод будет перехвачен
        userService.saveUser(new User());  // Работает с proxy
        
        // Статический метод НЕ будет перехвачен
        UserService.staticMethod();  // Прямой вызов без proxy
    }
}

Выводы

1. Proxy перехватывает ТОЛЬКО экземплярные методы
2. Статические методы НЕ перехватываются proxy
3. Почему:
   • Статические методы привязаны к классу, не к объекту
   • Нельзя переопределить статический метод
   • Java не позволяет переопределение в интерфейсах
4. Не используй на статических методах:
   • @Transactional
   • @Cacheable
   • @Async
   • Другие аннотации для proxy
5. Всегда используй экземплярные методы для Spring функциональности
6. Помни: когда видишь ClassName$$EnhancerByCGLIB$, это proxy, и он работает только с экземплярными методами