大家看看，我这个小代码是不是代理模式，请提意见，马上结贴。

Question

interface Function{
   void f();
}class BackRun implements Function{
   public void f(){
      System.out.println("BackRun");
   }
}
public class Proxy implements Function{
    public void f(){
       System.out.println("proxy");
    }
}class ForeRun{
   public static void main(String[] args) {
      Function x = new Proxy();
      x.f();
   }
}

Answer 1

你这个不是，代理中的构造方法里面应该有被代理的对象引用interface Function{
   void f();
}class BackRun implements Function{
   public void f(){
      System.out.println("BackRun");
   }
}
public class Proxy implements Function{
   private Function func;
   public Proxy(Function func){this.func=func;}
    public void f(){
      System.out.println("proxy");
     func.f();
    }
}class ForeRun{
   public static void main(String[] args) {
      Function x = new Proxy();
      x.f();
   }
}

Answer 2

我赞同2楼不过代理模式的话，代理内应该是封装真实的对象吧？
interface Function{
   void f();
} class BackRun implements Function{
   public void f(){
      System.out.println("BackRun");
   }
}
public class Proxy implements Function{
   private BackRun backRun;
   public Proxy(){
   if(backRun == null)
   backRun = new BackRun();
   }
    public void f(){
      System.out.println("proxy");
      backRun.f();
    }
} class ForeRun{
   public static void main(String[] args) {
      Function x = new Proxy();
      x.f();
   }
}

Answer 3

意思没有错，但是代码有个小问题
  Function x = new Proxy();
new Proxy();里面得放个参，指定你要给谁做代理`~

Answer 4

这个是写死的代理就只能给固定的BackRun做代理了`~~

Answer 5

5楼就是多一个null判断，是吧？

Answer 6

我的那个是直接建立BackRun的代理，加判断是为了确保BackRun对象一开始能正确初始化2楼的则是一个泛用一点的。不过要改一点，就是最后的那里，这个7楼也说了恩
class ForeRun{
   public static void main(String[] args) {
      Function x = new Proxy(BackRun);
      x.f();
   }
}

Answer 7

是的
 public Proxy(){
           if(backRun == null)
               backRun = new BackRun();
       }其实就是在代理的构造器中声明要为BackRun做代理，对应现在的小程序是没有问题的。

Answer 8

class ForeRun{
   public static void main(String[] args) {
      Function x = new Proxy(BackRun);
      x.f();
   }
}这样这样~~·

Answer 9

非代理模式，
参考下数据库连接池的代理模式实现吧：import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;public class ConnectionHandler implements InvocationHandler {
private Connection con;
private connectionPool pool;
public ConnectionHandler(connectionPool pool){
this.pool = pool;
}
    public Connection bind(Connection con){
     this.con = con;
     Connection proxyCon = (Connection)Proxy.newProxyInstance(con.getClass().getClassLoader(),
     con.getClass().getInterfaces(), this);
     return proxyCon;
    }
public Object invoke(Object arg0, Method arg1, Object[] arg2)
throws Throwable {
// TODO Auto-generated method stub
Object obj = null;
if("close".equals(arg1.getName())){
pool.releaseConnection(con);
}else{
obj = arg1.invoke(con, arg2);
}
return obj;
}}