代理模式 (Proxy Pattern)

// 主题接口
public interface Image {
    void display();
}

// 真实主题
public class RealImage implements Image {
    private String fileName;
    
    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk();
    }
    
    private void loadFromDisk() {
        System.out.println("加载图片: " + fileName);
    }
    
    @Override
    public void display() {
        System.out.println("显示图片: " + fileName);
    }
}

// 代理
public class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;
    
    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }
    
    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}

// 使用
Image image = new ProxyImage("photo.jpg");
// 第一次调用时才加载
image.display();

// 接口
public interface UserService {
    void addUser(String name);
    void deleteUser(Long id);
}

// 实现
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("添加用户: " + name);
    }
    
    @Override
    public void deleteUser(Long id) {
        System.out.println("删除用户: " + id);
    }
}

// 代理处理器
public class LogInvocationHandler implements InvocationHandler {
    private Object target;
    
    public LogInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("[LOG] 调用方法: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("[LOG] 方法结束: " + method.getName());
        return result;
    }
}

// 使用
UserService target = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(
    target.getClass().getClassLoader(),
    target.getClass().getInterfaces(),
    new LogInvocationHandler(target)
);

proxy.addUser("张三");

// CGLIB 代理（无需接口）
public class CglibProxy implements MethodInterceptor {
    
    public Object createProxy(Class<?> targetClass) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetClass);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    
    @Override
    public Object intercept(Object obj, Method method, 
                           Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("[CGLIB] 前置处理");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("[CGLIB] 后置处理");
        return result;
    }
}

// 使用
CglibProxy cglibProxy = new CglibProxy();
UserService proxy = (UserService) cglibProxy.createProxy(UserServiceImpl.class);
proxy.addUser("李四");

@Service
public class OrderService {
    
    @Transactional
    public void createOrder(Order order) {
        // 事务管理由代理实现
    }
    
    @Cacheable("orders")
    public Order getOrder(Long id) {
        // 缓存由代理实现
    }
}

// Spring 会自动创建代理
// 1. 如果有接口，使用 JDK 动态代理
// 2. 如果没有接口，使用 CGLIB 代理

@Entity
public class Department {
    @OneToMany(fetch = FetchType.LAZY)
    private List<Employee> employees; // 代理对象
}

// employees 在访问时才真正加载
Department dept = departmentRepository.findById(1L);
// 此时 employees 是代理对象
for (Employee e : dept.getEmployees()) {
    // 第一次遍历时才真正查询数据库
    System.out.println(e.getName());
}

// MyBatis 使用代理实现 Mapper 接口
@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User findById(Long id);
}

// 实际使用时，MyBatis 返回的是代理对象
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
// mapper 是代理对象，实际执行时调用 SqlSession

public interface DocumentService {
    void readDocument(String docId);
    void writeDocument(String docId, String content);
    void deleteDocument(String docId);
}

public class SecurityProxy implements DocumentService {
    private DocumentService target;
    private User currentUser;
    
    public SecurityProxy(DocumentService target, User user) {
        this.target = target;
        this.currentUser = user;
    }
    
    @Override
    public void readDocument(String docId) {
        if (hasPermission("READ")) {
            target.readDocument(docId);
        } else {
            throw new SecurityException("无读取权限");
        }
    }
    
    @Override
    public void writeDocument(String docId, String content) {
        if (hasPermission("WRITE")) {
            target.writeDocument(docId, content);
        } else {
            throw new SecurityException("无写入权限");
        }
    }
    
    private boolean hasPermission(String permission) {
        return currentUser.getPermissions().contains(permission);
    }
}

public class CacheProxy implements UserService {
    private UserService target;
    private Map<Long, User> cache = new ConcurrentHashMap<>();
    
    @Override
    public User getUser(Long id) {
        User user = cache.get(id);
        if (user == null) {
            user = target.getUser(id);
            cache.put(id, user);
        }
        return user;
    }
    
    @Override
    public void updateUser(User user) {
        target.updateUser(user);
        cache.put(user.getId(), user);
    }
}