设计模式--代理模式

设计模式--代理模式

1.概述

---

1.1 定义
"Provide a surrogate or placeholder for another object to control access to it"(提供一种代理以控制对这个对象的访问)
代理模式分为动态代理、静态代理，从本质上两者都是产生一个新的类(可以加入一些行为)来代理之前的类。
1.2 分类
静态代理模式：自己手写一个代理类，该代理类会在编译期就生成。这种代理由于不需要再运行期重新生成一个代理类，所以性能较好。但是由于我们需要在代理类中加入一些行为时，需要写的代理较多，且与委托类耦合性较差，代码复用性较差。
动态代理模式：代理类是在运行期生成。相比静态代理，动态代理可以方便的对委托类进行统一处理，代码复用性较好。分为jdk动态代理和cglib动态代理(不懂)。
1.3 应用
代理可以通过延迟实例化(lazily-instantiating)，如Hibrenate中的表的连接查询中就有延迟加载；AOP的核心就是使用的动态代理，通过AOP我们可以进行事务处理、日志处理等，

2.详解

---

2.1 静态代理

代码如下：

public interface Subject {
    void method();
}

public class RealSubject implements Subject {
    @Override
    public void method() {
        System.out.println("RealSubject.method()");
    }
}

public class Proxy implements Subject {
    private Subject realSubject;

    // 通过构造函数传递被代理者
    Proxy(Subject realSubject){
        this.realSubject = realSubject;
    }

    // 真正实现代理，在这里我们可以加入一些行为。
    public void method() {
        System.out.println("Proxy do something");
        realSubject.method();
    }
}

public class Client {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        Subject proxy = new Proxy(realSubject);
        proxy.method();
    }
}output:
Proxy do something
RealSubject.method()

2.2 动态代理
代码如下：

public interface Subject {
    void method();
}

public class RealSubject implements Subject {
    @Override
    public void method() {
        System.out.println("RealSubject.method()");
    }
}

JDK自带的动态代理实现：
利用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口定义代理类的实现

public class SubjectInvocationHandler implements InvocationHandler {
    private Object target;

    SubjectInvocationHandler(Object target) {
        this.target = target;
    }

    // 在这里实现代理，我们可以通过反射机制加入我们想到的行为
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(Objects.equals(method.getName(), "method")) {
            System.out.println("Proxy do something");
        }
        return method.invoke(target, args);
    }

    // 通过JDK自带的动态代理方法生成代理对象
    public Object getProxy() {
        ClassLoader loader = target.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        return Proxy.newProxyInstance(loader, interfaces, this);
    }
}

public class Client {
    public static void main(String[] args) {
        Subject realSuject = new RealSubject();
        SubjectInvocationHandler handler = new SubjectInvocationHandler(realSuject);
        Subject subject = (Subject) handler.getProxy();
        subject.method();
    }
}outpu:
Proxy do something
RealSubject.method()

上面动态代理具体实现还不是很清楚，以后再写。

3. 应用

---

通过动态代理实现了非常简单的事务处理

Entity类

public class User {
    private long id;

    private String email;

    private String password;

    private int sex;

    private int age;

    public User() {

    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPassword() {
        return password;
    }

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

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public User(String email, String password, int sex, int age) {
        this.email = email;
        this.password = password;
        this.sex = sex;
        this.age = age;
    }
}

JDBC工具类

public class JDBCUtil {
    /**
     * 返回一个Connection
     */
    public static Connection getConnection() {
        Connection connection = null;
        String driverClass = "com.mysql.jdbc.Driver";
        String url = "jdbc:mysql://localhost:3306/hibernate?useUnicode=true&characterEncoding=utf8";
        String user = "root";
        String password = "";
        try {
            // 加载mysql驱动
            Class.forName(driverClass);
            // 获得Connection
            connection = DriverManager.getConnection(url, user, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }
}

用户DAO类

public class UserDao {
    private Connection connection;

    // 注入其需要的Connection
    UserDao(Connection connection) {
        this.connection = connection;
    }

    // DAO中saveUser方法：抛出异常表明出现错误，需要Rollback。在这里我们就抛出异常，让Service处理。
    public int saveUser(User user) throws Exception{
        String sql = "INSERT INTO USER(email, password, sex, age) VALUES (?,?,?,?)";
        // 获得PreparedStatement
        PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
        // 预编译
        preparedStatement.setString(1, user.getEmail());
        preparedStatement.setString(2, user.getPassword());
        preparedStatement.setInt(3, user.getSex());
        preparedStatement.setInt(4, user.getAge());
        // 插入数据库
        return preparedStatement.executeUpdate();
    }
}

代理逻辑相关类

/**
 * 被代理接口：用户业务类
 */
public interface UserService {
    boolean saveUser(User user) throws Exception;
}

/**
 * 实际被代理类
 */
public class UserServiceImpl implements UserService {
    private UserDao userDao;

    // 注入UserDao
    UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    // Service中saveUser方法：抛出异常表明出现错误，需要Rollback。在这里我们就抛出异常，让代理类处理。
    public boolean saveUser(User user) throws Exception {
        int countNum = userDao.saveUser(user);
        return countNum == 1;
    }
}

/**
 * 代理类
 */
public class UserServiceProxy implements InvocationHandler {
    // 被代理类
    private UserService userService;

    // 该数据库Connection,因为只有Conenction才能开启事务
    private Connection connection;

    // 注入被代理类及其使用的Connection
    UserServiceProxy(UserService userService, Connection connection) {
        this.userService = userService;
        this.connection = connection;
    }

    @Override
    // 实际代理逻辑
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 如果方法名是savaUser,则需要开启事务
        if(method.getName().equalsIgnoreCase("saveUser")) {
            // 设置Connection不能自动提交
            connection.setAutoCommit(false);
            // 调用真正的saveUser方法：若抛出异常就Rollback, 否则Commit
            try {
                Object object = method.invoke(userService, args);
                connection.commit();
                return object;
            } catch (Exception e) {
                connection.rollback();
                throw new Exception("出现错误, 错误信息是：" + e);
            }
        }
        return method.invoke(userService, args);
    }

    // 实现代理: 通过JDK自带的动态代理方法生成代理对象
    public UserService getProxy() {
        ClassLoader classLoader = userService.getClass().getClassLoader();
        Class<?>[] interfaces = userService.getClass().getInterfaces();
        return (UserService) Proxy.newProxyInstance(classLoader, interfaces, this);
    }
}

测试类：

public class Client {
    public static void main(String[] args) throws Exception {
        Connection connection = JDBCUtil.getConnection();
        User user = new User("kanyuxia@outlook.com", "123456", 0, 21);

        UserDao userDao = new UserDao(connection);
        // 被代理类
        UserService userService = new UserServiceImpl(userDao);
        // 代理类
        UserService proxy = new UserServiceProxy(userService, connection).getProxy();
        // 执行saveUser方法
        proxy.saveUser(user);
    }
}