设计模式学习笔记—代理模式

代理模式(Proxy Pattern)

如果想在一个类中大多数方法之前或之后统一做一些事，那就用代理模式吧。

代理模式的用途也不少，比如大多数 service 中的方法之前都要判断一下用户是否登录，如果没有登录肯定就不能让这个用户进行操作，或者 dao 中每次都要打开然后关闭一些东西什么的，这样就可以把这些公共的部分提取出来，比较著名的 spring 面向切面编程(AOP) 就是代理模式的一种实现，虽然我已经忘了 AOP 怎么写的了。 T T
正常情况下的代理模式(所以肯定有非正常的 = =)，要与被代理的类继承同一个接口，就像这样

public interface BookService {
    List<Book> getByUserId(int userId);
    void create(Book book, int userId);
    void update(Book book);
    void delete(Book book);
}

public class BookServiceImpl implements BookService {

    @Override
    public List<Book> getByUserId(int userId) {
        System.out.println("get");
        return new ArrayList<Book>();
    }

    @Override
    public void create(Book book, int userId) {
        System.out.println("create");
    }

    @Override
    public void update(Book book) {
        System.out.println("update");
    }

    @Override
    public void delete(Book book) {
        System.out.println("delete");
    }

}

public class ServiceProxy implements BookService {
    private BookService mBookService;

    public ServiceProxy(BookService bookService) {
        mBookService = bookService;
    }

    @Override
    public List<Book> getByUserId(int userId) {
        this.before();
        List<Book> books =  mBookService.getByUserId(userId);
        this.after();
        return books;
    }

    @Override
    public void create(Book book, int userId) {
        this.before();
        mBookService.create(book, userId);
        this.after();
    }

    @Override
    public void update(Book book) {
        this.before();
        mBookService.update(book);
        this.after();
    }

    @Override
    public void delete(Book book) {
        mBookService.delete(book);
    }

    private void before() {
        System.out.println("before");
    }

    private void after() {
        System.out.println("after");
    }

}

然而这些代码并没有什么实际的意义，话说 service 和 dao 的例子我已经用了好多个了，Because I think that the majority of people studied it in college.(然而我英语并不好 - -)
调用的时候会是这样

        BookService bookService = new ServiceProxy(new BookServiceImpl());
        bookService.create(new Book(), 1);
        bookService.delete(new Book());

看起来调用还不错，作为一个设计模式而言，不过不单单是这一个类需要这样的代理，可能程序中的每一个 service 都需要一个代理，虽然可以用工厂给封装起来，但是那么多的代理类基本上也是做的相同的工作，所以就有了动态代理。

public class ServiceProxy implements InvocationHandler {
    private Object mServiceObj = null;

    public ServiceProxy(Object serviceObj) {
        mServiceObj = serviceObj;
    }

    private void before() {
        System.out.println("before");
    }

    private void after() {
        System.out.println("after");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 这就是为什么 service 中经常以这种规范进行命名的原因
        String[] limits = new String[] {"get", "create", "update"};
        boolean isAllow = false;
        String methodName = method.getName();
        for (String limit : limits) {
            if (methodName.startsWith(limit)) {
                isAllow = true;
            }
        }
        Object result = null;
        if (isAllow) {
            this.before();
        }
        // 这个就是需要执行的那个方法
        result = method.invoke(mServiceObj, args);
        if (isAllow) {
            this.after();
        }
        return result;
    }
}

代理类的话改动比较大，实际上就多了几行对于方法名限定，如果简单的话完全可以这么写

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        this.before();
        // 这个就是需要执行的那个方法
        result = method.invoke(mServiceObj, args);
        this.after();
        return result;
    }

然后，我们需要一个工厂，不然调用部分的代码会很难看

public class ServiceFactory {
    public static Object getBean(String name) {
        if ("bookService".equals(name)) {
            BookService service = new BookServiceImpl();
            ServiceProxy proxy = new ServiceProxy(service);
            return Proxy.newProxyInstance(service.getClass().getClassLoader(),
                    service.getClass().getInterfaces(), proxy);
        }
        return null;
    }
}

嘛，工厂的责任就是负责组装好组件之间的关系，最后的调用会是这个样子的

        BookService bookService = (BookService) ServiceFactory.getBean("bookService");
        bookService.create(new Book(), 1);
        bookService.delete(new Book());

这样看起来就好多了。
PS：如果将代理类作为一个模板方法，before after 之类的延迟到子类去实现，工厂负责读取 xml，反射创建对象，这样的话应该也能有点框架的意思了吧。

The end.