动态代理生成空对象

 动态代理和空对象的结合会产生什么样的火花？动态代理提供了将实现了某一接口或继承自某一超类的子类提供统一的代理机制，从而实现对某一些类功能的增强。而空对象类则是对某一为的NULL类实例实现的行为方式，这样就可以与非NULL统一起来，使对象的使用更方便。

//:typeinfo/util/Null.java

package typeinfo.util;

/**
 * 空对象接口
 * @author LYL
 *
 */
public interface Null {}

//:typeinfo/util/Operation.java

package typeinfo.util;

public interface Operation {
    String description();
    void command();
}

//:typeinfo/util/Robot.java

package typeinfo.util;

import java.util.List;

public interface Robot {
    String name();
    String model();
    List<Operation> operations();
    /***
     * 嵌套类，用于对实现了Robot接口的对象进行测试
     * @author LYL
     *
     */
    class Test{
        public static void test(Robot r){
            if(r instanceof Null){
                System.out.println("Null Robot");
            }
            System.out.println("Robot name:"+r.name());
            System.out.println("Robot model:"+r.model());
            System.out.println("Robot operations: ");
            
            for(Operation operation : r.operations()){
                System.out.println(operation.description());
                operation.command();
            }
            
        }
    }
}

//:typeinf/SnowRemovalRobot.java

/**
 * 
 */
package typeinfo;

import java.util.Arrays;
import java.util.List;

import typeinfo.util.Operation;
import typeinfo.util.Robot;

/**
 * @author LYL
 *
 */
public class SnowRemovalRobot implements Robot {
    private String name;
    public SnowRemovalRobot(String name){
        this.name=name;
    }
    /* (non-Javadoc)
     * @see typeinfo.util.Robot#name()
     */
    @Override
    public String name() {
        return this.name;
    }

    /* (non-Javadoc)
     * @see typeinfo.util.Robot#model()
     */
    @Override
    public String model() {
        return "SnowBot 1";
    }

    /* (non-Javadoc)
     * @see typeinfo.util.Robot#operations()
     */
    @Override
    public List<Operation> operations() {
        //通过匿名类，创建机器人的操作列表
        return Arrays.asList(
            new Operation(){
            @Override
            public String description() {
                return name+" can shovel snow";
            }
            @Override
            public void command() {
                System.out.println(name+" shoveling snow");
            }},
            new Operation(){
                @Override
                public String description() {
                    return name+" can chip ice";
                }
                @Override
                public void command() {
                    System.out.println(name+"chipping ice");
                }
            },
            new Operation(){
                @Override
                public String description() {
                    return name+" can clear roof";
                }

                @Override
                public void command() {
                    System.out.println(name+" clearing roof");
                }
            });
    }
    
    public static void main(String args[]){
        //测试验证
        Robot.Test.test(new SnowRemovalRobot("除雪一号"));
    }
}

//:typeinfo/NullRobot.java

/**
 * 
 */
package typeinfo;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collections;
import java.util.List;

import typeinfo.util.Robot;
import typeinfo.util.Operation;

import typeinfo.util.Null;

/***
 * NullRobot执行处理器。
 * @author LYL
 *
 */
class NullRobotHandler implements InvocationHandler{
    private String nullTypeName;
    private NRobot proxied=new NRobot();
    /**
     * 创建一
     * @param type
     */
    public NullRobotHandler(Class<? extends Robot> type){
        nullTypeName=type.getSimpleName()+" Null Robot";
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //执行空对象
        return method.invoke(proxied, args);
    }
    /**
     * 空的Robot类
     * 内部类，外面不会用到，另一方面是可以很方便地使用外转类的域和方法
     * @author LYL
     *
     */
    private class NRobot implements Null,Robot{
        public String model(){return nullTypeName;}
        public String name(){ return nullTypeName;}
        
        public List<Operation> operations(){
            return Collections.emptyList();
        }
    }
}

/**
 * 
 * @author LYL
 *
 */
public class NullRobot {
    /**
     * 动态生成指定Robot类的空对象
     * @param type 
     * @return
     */
    public static Robot newNullRobot(Class<? extends Robot> type){
        return (Robot)Proxy.newProxyInstance(Robot.class.getClassLoader(), 
                new Class[]{Null.class,Robot.class},
                new NullRobotHandler(type));
    }
    public static void main(String args[]){
        //创建一个Robot数组，其中有一个是Null对象
        Robot[] robots={
                new SnowRemovalRobot("除雪二号"),
                newNullRobot(SnowRemovalRobot.class),
        };
        System.out.println(robots.length);
        for(Robot robot : robots){
            Robot.Test.test(robot);
        }
    }
}