Java 代理模式（附Object-C）

设计模式学起来像是在学校里学理论，把理论用到实际的工作中，好比写作文，要收集很多的素材，然后在合适的地方安排上，目前感觉自己还差那么点意思，只能多看几遍，希望能够理解它们的精髓所在。

代理模式的定义

代理模式用于由于某些原因，不能直接将对象提供给使用者，使用者不适合或者不能够直接引用目标对象，这个时候引入代理对象作为一个中介。
代理模式的优点在于：
1.代理模式在使用者与目标对象中间祈祷一个中介作用和保护作用；
2.代理对象可以扩展目标对象的功能；
3.代理模式能够将使用者和目标对象分离，降低耦合度。
代理模式的缺点：
1.由于调用由代理对象发起，可能会造成请求处理的速度变慢；
2.增加系统复杂度。

代理模式的结构

代理模式由抽象目标类，真实目标类，代理类组成，代理类提供了与真实目标类相同的接口，其内部含有对真实目标类的引用，它可以访问、控制和扩展真实目标类。

    public void main() {
        ChineseTeacherProxy chineseTeacherProxy = new ChineseTeacherProxy();
        Student student = new Student();
        student.sendHomework(chineseTeacherProxy);
    }

    // 使用者，学生类，学生需要上交作业
    static class Student {
        void sendHomework(ChineseTeacherProxy proxy) {
            proxy.homework();
        }
    }
    
    // 抽象教师类
    interface Teacher {
        void homework();
    }

    // 语文老师类，老师需要得到学生的作业
    static class ChineseTeacher implements Teacher {
        @Override
        public void homework() {
            System.out.println("I need Chinese homework");
        }
    }

    // 语文老师的代理类：语文课代表，负责收集学生的语文作业
    static class ChineseTeacherProxy {
        public static ChineseTeacher teacher;
        public void homework() {
            if (null==teacher) {
                teacher = new ChineseTeacher();
            }
            teacher.homework();
        }
    }

上面的例子十分简单，使用了一个很常见的代理对象，学生需要上交作业，但是老师不会自己来收集所有的作业，而是交给老师的代理，即课代表来负责收集作业。除此之外，课代表不仅可以对作业进行收集，还可以在老师忙碌的时候，自行对作业进行处理然后对老师汇报结果即可。

    // 语文老师的代理类：语文课代表，负责收集学生的语文作业
    static class ChineseTeacherProxy {
        // 学生总人数
        public static final int CLASS_MEMBER_COUNT = 30;
        // 教师类
        public static ChineseTeacher teacher;
        // 作业状态收集
        public static List<Boolean> chineseHomeworkResult;
        // 作业
        public static List<String> chineseHomework;
        // 上交作业
        public void homework(String result) {
            if (null==teacher) {
                teacher = new ChineseTeacher();
            }
            // 如果教师有事情在忙
            if (teacher.isBusy()) {
                // 检查作业并收集结果
                chineseHomeworkResult.add(result.equals("finish"));
                // 收集完毕上报
                if (chineseHomeworkResult.size()==CLASS_MEMBER_COUNT) {
                    teacher.homewordResult(chineseHomeworkResult);
                }
            } else {
                // 教师空闲，直接上交作业
                chineseHomework.add(result);
                // 收集全部作业后上交
                if (chineseHomeworkResult.size()==CLASS_MEMBER_COUNT) {
                    teacher.homework(chineseHomework);
                }
            }
        }

对代理类进行修改后，具有对目标类的控制能力，而且根据教师类的状态，可以进行不同的操作。

代理模式的应用场景

1.需要隐藏目标对象存在于不同空间的情况，方便使用方访问，类似Android端的系统服务，binder代理。
2.权限控制，目标对象只能限制在某些权限下才能使用，可以针对不同权限组开放不同的接口。
3.创建目标的开销很大的时候，可以用代理进行临时替代，等对象创建完毕之后再替换为目标对象。
4.当访问者并不需要目标的直接数据的时候，比如某一组数据的平均分。
5.通过代理来对事务进行安排，达到延迟加载的目的。

代理模式的扩展

在上述代码中，目标对象的方法与代理对象的方法一一对应，当目标方法改变的时候，代理方法也需要改变，这个时候，在Java中，引入了动态代理这个概念。

    public void main() {
        // 语文老师对象
        final Teacher teacher = new ChineseTeacher();
        // 学生对象
        Student student = new Student();

        // 代理类，这里没有单独写一个类了
        Teacher proxy = (Teacher) Proxy.newProxyInstance(
                Thread.currentThread().getContextClassLoader(),
                teacher.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
                        return method.invoke(teacher, args);
                    }
                }
        );

        // 学生对象调用代理对象
        student.sendHomework(proxy,"finish");
    }

为什么标题要加个OC呢，因为在学啊。学无止境吧。

@protocol TTSTeacher <NSObject>
@required
-(void)homework;
@end

@interface TTSChineseTeacher : NSObject <TTSTeacher>
@end

@implementation TTSChineseTeacher

-(void)homework {
    NSLog(@"I need homework");
}

@end

@interface TTSChineseTeacherProxy : NSObject
@property(nonatomic,strong) TTSChineseTeacher *chineseTeacher;
@end

@implementation TTSChineseTeacherProxy

-(instancetype)init {
    if (self==[super init]) {
        if (!_chineseTeacher) {
            self.chineseTeacher = [[TTSChineseTeacher alloc] init];
        }
    }
    return self;
}

+(BOOL)resolveInstanceMethod:(SEL)sel {
    NSLog(@"动态方法解析:");
    return [super resolveClassMethod:sel];
}

-(id)forwardingTargetForSelector:(SEL)aSelector {
    NSLog(@"快速转发路径");
    return [super forwardingTargetForSelector:aSelector];
}

-(void)forwardInvocation:(NSInvocation *)anInvocation {
    if (_chineseTeacher) {
        NSLog(@"以创建的NSInvocation对象作为参数");
        [anInvocation setTarget:_chineseTeacher];
        [anInvocation invoke];
    }
}

-(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    if (_chineseTeacher) {
        NSLog(@"查看Selector对应的方法签名");
        return [_chineseTeacher methodSignatureForSelector:aSelector];
    }
    return [super methodSignatureForSelector:aSelector];
}

@end

@interface TTSStudent : NSObject
-(void)homeworkWith:(TTSChineseTeacherProxy *)proxy;
@end

@implementation TTSStudent

-(void)homeworkWith:(TTSChineseTeacherProxy *)proxy {
    [proxy performSelector:@selector(homework)];
}

@end

int main(int argc, const char * argv[]) {
    TTSChineseTeacherProxy *chineseTeacherProxy = [[TTSChineseTeacherProxy alloc] init];
    TTSStudent *student = [[TTSStudent alloc] init];
    [student homeworkWith: chineseTeacherProxy];
    return 0;
}