动态代理模式 完成增删查改

动态代理模式是一种常用的设计模式，它可以在运行时为接口或类生成代理对象，从而实现在不修改原有代码的情况下，对原有代码进行增强或扩展。

下面是使用动态代理模式实现增删查改的示例代码：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

public class ProxyPatternDemo {
    public static void main(String[] args) {
        // 创建目标对象
        UserDao userDao = new UserDaoImpl();

        // 创建代理对象
        UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(
                userDao.getClass().getClassLoader(),
                userDao.getClass().getInterfaces(),
                new UserDaoInvocationHandler(userDao));

        // 使用代理对象进行增删查改操作
        userDaoProxy.addUser(new User("张三", "123456"));
        userDaoProxy.addUser(new User("李四", "123456"));
        List<User> userList = userDaoProxy.getUserList();
        System.out.println(userList);
        userDaoProxy.updateUser("张三", new User("张三", "654321"));
        userDaoProxy.deleteUser("李四");
        userList = userDaoProxy.getUserList();
        System.out.println(userList);
    }
}

// 用户类
class User {
    private String username;
    private String password;

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

// 用户DAO接口
interface UserDao {
    void addUser(User user);

    void deleteUser(String username);

    void updateUser(String username, User user);

    List<User> getUserList();
}

// 用户DAO实现类
class UserDaoImpl implements UserDao {
    private List<User> userList = new ArrayList<>();

    @Override
    public void addUser(User user) {
        userList.add(user);
    }

    @Override
    public void deleteUser(String username) {
        for (User user : userList) {
            if (user.getUsername().equals(username)) {
                userList.remove(user);
                break;
            }
        }
    }

    @Override
    public void updateUser(String username, User user) {
        for (int i = 0; i < userList.size(); i++) {
            if (userList.get(i).getUsername().equals(username)) {
                userList.set(i, user);
                break;
            }
        }
    }

    @Override
    public List<User> getUserList() {
        return userList;
    }
}

// 用户DAO代理类
class UserDaoInvocationHandler implements InvocationHandler {
    private UserDao userDao;

    public UserDaoInvocationHandler(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        String methodName = method.getName();
        if ("addUser".equals(methodName)) {
            System.out.println("添加用户前的操作");
            result = method.invoke(userDao, args);
            System.out.println("添加用户后的操作");
        } else if ("deleteUser".equals(methodName)) {
            System.out.println("删除用户前的操作");
            result = method.invoke(userDao, args);
            System.out.println("删除用户后的操作");
        } else if ("updateUser".equals(methodName)) {
            System.out.println("更新用户前的操作");
            result = method.invoke(userDao, args);
            System.out.println("更新用户后的操作");
        } else if ("getUserList".equals(methodName)) {
            System.out.println("获取用户列表前的操作");
            result = method.invoke(userDao, args);
            System.out.println("获取用户列表后的操作");
        }
        return result;
    }
}

在上述示例代码中，我们定义了一个`User`类，一个`UserDao`接口和一个`UserDaoImpl`实现类，代表着我们要进行增删查改的操作。同时，我们还定义了一个`UserDaoInvocationHandler`实现`InvocationHandler`接口，用于代理`UserDao`接口的方法。

在`main`方法中，我们首先创建了一个`UserDaoImpl`对象，然后使用`Proxy.newProxyInstance()`方法创建了一个`UserDaoInvocationHandler`对象，最后将这个代理对象强制转换为`UserDao`接口类型，并调用它的方法，实现了对`UserDaoImpl`对象的增删查改操作。

在`UserDaoInvocationHandler`中，我们使用了`Method.invoke()`方法来调用被代理的对象的方法。在调用方法前后，我们还可以进行一些其他的操作，例如输出日志、记录操作时间等等。

需要注意的是，在`deleteUser`方法中，我们不能直接使用`for-each`循环来遍历`userList`并删除其中的元素，否则会触发`ConcurrentModificationException`异常。因此，我们需要使用`for`循环和`Iterator`迭代器来遍历并删除其中的元素。