Какие плюсы и минусы проксирования?

Проксирование в Java: плюсы и минусы

Проксирование — это паттерн проектирования, позволяющий создавать объект-заместитель, контролирующий доступ к реальному объекту. Рассмотрим его применение в Java.

Плюсы проксирования

Ленивая инициализация (Lazy Initialization) Объект создаётся только при первом обращении:

public class DataSourceProxy implements DataSource {
    private DataSource realDataSource;
    
    @Override
    public Connection getConnection() throws SQLException {
        if (realDataSource == null) {
            realDataSource = new RealDataSource();  // Создание при первом вызове
        }
        return realDataSource.getConnection();
    }
}

Контроль доступа (Access Control) Можно ограничить доступ к чувствительным операциям:

public class UserServiceProxy extends UserService {
    @Override
    public void deleteUser(String id) {
        if (!currentUser.hasRole("ADMIN")) {
            throw new AccessDeniedException("Only admins can delete users");
        }
        super.deleteUser(id);
    }
}

Логирование и аудит Проксирование позволяет логировать все обращения:

public class LoggingProxy<T> implements InvocationHandler {
    private final T target;
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Calling: " + method.getName());
        long start = System.currentTimeMillis();
        Object result = method.invoke(target, args);
        long duration = System.currentTimeMillis() - start;
        System.out.println("Finished in " + duration + "ms");
        return result;
    }
}

Кэширование Проксирование может кэшировать результаты дорогостоящих операций:

public class CachingProxy implements Calculator {
    private final Calculator realCalculator;
    private final Map<String, Integer> cache = new HashMap<>();
    
    @Override
    public int calculate(String expression) {
        if (!cache.containsKey(expression)) {
            cache.put(expression, realCalculator.calculate(expression));
        }
        return cache.get(expression);
    }
}

Отсроченное выполнение (Deferred Execution) Можно накопить операции и выполнить их пакетом:

public class BatchInsertProxy extends DatabaseConnection {
    private List<String> batch = new ArrayList<>();
    
    @Override
    public void insert(String sql) {
        batch.add(sql);  // Не выполняем сразу
        if (batch.size() >= 100) {
            flushBatch();  // Выполняем 100 операций одновременно
        }
    }
}

Защита (Protection Proxy) Проксирование защищает реальный объект от неправильного использования:

public class ProtectionProxy implements Database {
    private final Database database;
    
    @Override
    public void update(String sql) {
        if (isSafeSQL(sql)) {  // Валидация SQL
            database.update(sql);
        } else {
            throw new IllegalArgumentException("Unsafe SQL");
        }
    }
}

Dynamic Proxies (Динамические прокси) Java позволяет создавать прокси во время выполнения без создания отдельного класса:

UserService userService = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(
    UserService.class.getClassLoader(),
    new Class[]{UserService.class},
    new LoggingHandler(userService)
);

Минусы проксирования

Усложнение кода Добавляется дополнительный слой абстракции, что усложняет понимание кода:

// Без прокси — просто
userService.getUser(id);

// С прокси — может быть сложнее отследить что происходит
userServiceProxy.getUser(id);  // Какой там логик внутри?

Снижение производительности Дополнительный вызов метода добавляет overhead:

// Каждый вызов метода через прокси
// требует дополнительных операций:
// - проверка доступа
// - логирование
// - проверка кэша
// - вызов реального объекта

Проблемы с отладкой В stacktrace появляется много слоёв вызовов:

at UserServiceImpl.getUser()
at UserServiceProxy.getUser()
at LoggingProxy.invoke()
at $Proxy0.getUser()
at TestClass.main()
// Какой-то слой ошибку выбросит

Проблемы с типизацией Dynamic proxies теряют информацию о типе:

// Dynamic proxy не сохраняет type information
Object proxy = Proxy.newProxyInstance(...);
if (proxy instanceof UserService) {  // Может быть неправильно
    UserService us = (UserService) proxy;
}

Множественное наследование сложнее Проксирование может не работать с интерфейсами, имеющими статические методы:

public interface MyInterface {
    static void staticMethod() {}
    void instanceMethod();
}
// Прокси не может перехватить staticMethod()

Проблемы с final методами Если использовать наследование вместо интерфейсов:

public class UserService {
    public final void save() {  // final метод
        // ...
    }
}
// Прокси через наследование не может переопределить final

Утечки памяти При неправильной реализации кэширования:

// Неправильно — кэш растёт бесконечно
Map<String, Object> cache = new HashMap<>();  // Никогда не очищается

// Правильно — использовать WeakHashMap или LRU
Map<String, Object> cache = new WeakHashMap<>();

Рекомендации по использованию

1. Используй прокси только когда необходимо:

   • Ленивая инициализация дорогостоящих объектов
   • Контроль доступа и аудит
   • Кэширование результатов

2. Предпочитай интерфейсы наследованию:

   // Хорошо — работает с dynamic proxies
   interface UserService { void save(User user); }
   
   // Сложнее
   class UserServiceProxy extends UserService { ... }
   

3. Документируй использование прокси в коде

4. Тестируй прокси отдельно от реального объекта

5. Следи за производительностью при частых вызовах

Проксирование — мощный инструмент для построения гибких и безопасных приложений, но требует аккуратного применения и понимания его ограничений.