Java代理之静态代理

 Java代理之静态代理

1 概述

在Java中，静态代理指的是代理类的产生发生在源程序编译阶段，在编译之后生成目标程序中包括代理类的class文件。程序运行时，直接装载代理类，生成代理对象。在前篇文章中，探讨了Java代理之设计模式，接下来将在此基础上，给出静态代理的例子。

2 静态代理的实现

例子场景如下：定一个了一个命令接口Command，ConnectCommand是该接口的一个实现类，用于实现连接功能。现在，需要在执行命令前和执行命令之后，做一些其他的验证和控制工作，比如安全检查、记录日志等。如果用代理模式来实现该场景，则我们可以利用Command接口，选择基于实现接口的代理，也可以利用ConnectCommand类，选择基于继承超类的代理。

2.1 Comand接口和ConnectCommand类

Command接口如下：

public interface Command {

public String execute(String commandStr) throws Exception;

}

ConnectCommand类如下，仅作为演示使用。

public class ConnectCommand implements Command {

public String execute(String commandStr) throws Exception {
System.out.println("Excuting command...");
return "Command was executed sucsessfully.";
}
}

 2.2 实现接口方式的代理

代理类InterfaceStaticProxy 如下所示，在被代理的命令执行前后，可以做一些其他的工作，本例在该处仅仅是输出信息。

public class InterfaceStaticProxy implements Command {
private Command original;

public InterfaceStaticProxy(Command original) {
this.original = original;
}

public String execute(String commandStr) throws Exception {
// do something before
System.out.println("Before excuting command...");
// execute
String result = original.execute(commandStr);
// do something after
System.out.println("After excuting command...");
return result;
}
}

  
测试类InterfaceStaticProxyTest如下：
 

public class InterfaceStaticProxyTest {
/**
* @param args
*/
public static void main(String[] args) {
try {
String commandStr = "connect localhost 8082";
Command orginal = new ConnectCommand();
System.out.println("/nWithout proxying:");
orginal.execute(commandStr);
Command proxy1 = new InterfaceStaticProxy(orginal);
System.out.println("/nWith interface proxying(static):");
proxy1.execute(commandStr);
} catch (Exception e) {
e.printStackTrace();
}
}
}

运行测试类，执行的结果如下：

Without proxying:
Excuting command...

With interface proxying(static):
Before excuting command...
Excuting command...
After excuting command...

  

2.3 继承超类方式的代理

 代理类SubClassStaticProxy如下所示，在超类执行命令前后，可以做一些其他的工作，本例在该处仅仅是输出信息。注意，这里ConnectCommad是否实现Command接口，都无关紧要。
 

public class SubClassStaticProxy extends ConnectCommand {

public String execute(String commandStr) throws Exception {
// do something before
System.out.println("Before excuting command...");
// execute
String result = super.execute(commandStr);
// do something after
System.out.println("After excuting command...");
return result;
}

测试类SubClassStaticProxyTest如下：

public class SubClassStaticProxyTest {
/**
* @param args
*/
public static void main(String[] args) {
try {
String commandStr = "connect localhost 8082";
Command orginal = new ConnectCommand();
System.out.println("/nWithout proxying:");
orginal.execute(commandStr);
Command proxy2 = new SubClassStaticProxy();
System.out.println("/nWith subclass proxying(static):");
proxy2.execute(commandStr);
} catch (Exception e) {
e.printStackTrace();
}
}
}

 运行测试类，执行结果如下：

Without proxying:
Excuting command...

With subclass proxying(static):
Before excuting command...
Excuting command...
After excuting command...

 3 总结分析

在实现接口的方式中，代理对象需要关联到由被代理类生成的被代理对象。而在继承超类的方式中，代理对象和超类对象是合一的，并不需要关联到一个由被代理类生成的被代理对象。    
在上述的例子中，接口和超类中都只定义了一个方法，如果定义了多个方法，那么在代理类中，需要对每个需要代理方法都做处理，如果需要代理的方法很多，那么可以预见会有很多重复性的非常类似的工作。有没有一种通用的机制，将所有的方法集中并统一处理呢？后续将对动态代理进行探讨。