Java设计模式-代理模式

背景

团队协作不管在现实还是虚拟世界中，都有着至关重要的作用。在SRW中，单打独斗显然是不可行的，队友的协助才能够更好的在机战的世界生存。
机战有一种机制，叫做援助防御，当我方机体遭受攻击时，邻接机体能够挺身而出，代替该机体挨打~。我想，援助防御的行为可以使用代理模式来实现。
代理模式分为三种：静态代理、jdk动态代理和cglib动态代理，现在我就分别来实现这个功能。

接口和实现类

接口：处理攻击的行为：回避、挨打和防御

/**
 * 面对敌人的攻击，我们有三种行为：回避、挨打和防御
 * 注：
 * 回避：完全回避敌人的攻击，不受伤害
 * 挨打：受到敌人的攻击
 * 防御：受到敌人的攻击，但是伤害没有挨打那么大
 */
public interface IHandleAttack {

    /**
     * 回避
     */
    public void avoid();
    
    /**
     * 挨打
     */
    public void sufferAttack();
    
    /**
     * 防御
     */
    public void defense();
    
}

实现类：古铁处理攻击的方式

public class AncientIronHandleAttack implements IHandleAttack {

    @Override
    public void avoid() {
        System.out.println("我完美的回避了这一击~~");
    }

    @Override
    public void sufferAttack() {
        System.out.println("反正我血厚得很，尽管打我~~");
    }

    @Override
    public void defense() {
        System.out.println("给敌人点面子，还是防御一下吧~~");
    }

}

使用静态代理

静态代理类：需要实现IHandleAttack接口

/**
 * 援助防御代理类
 * 注：援助防御是游戏的一种机制，简单说就是：当兄弟受到攻击时，挺身而出，帮兄弟挡一刀
 */
public class AssistDefenseProxy implements IHandleAttack {
    
    private IHandleAttack handleAttack;

    public AssistDefenseProxy(IHandleAttack handleAttack) {
        super();
        this.handleAttack = handleAttack;
    }

    @Override
    public void avoid() {
        handleAttack.avoid();
        System.out.println("你都回避了，我就不帮你了~~");
    }

    @Override
    public void sufferAttack() {
        System.out.println("糟糕，你被打了，帮你挡一刀~~");
        handleAttack.sufferAttack();
        System.out.println("mdzz，我帮你挡一刀，竟然还装逼！");
    }

    @Override
    public void defense() {
        System.out.println("糟糕，你被打了，帮你挡一刀~~");
        handleAttack.defense();
        System.out.println("mdzz，我帮你挡一刀，竟然还装逼！");
    }

}

测试类

public class StaticProxyTest {

    public static void main(String[] args) {
        IHandleAttack handleAttack = new AssistDefenseProxy(new AncientIronHandleAttack());
        System.out.println("-----------");
        handleAttack.avoid();
        System.out.println("-----------");
        handleAttack.sufferAttack();
        System.out.println("-----------");
        handleAttack.defense();
    }
    
}

运行结果

-----------
我完美的回避了这一击~~
你都回避了，我就不帮你了~~
-----------
糟糕，你被打了，帮你挡一刀~~
反正我血厚得很，尽管打我~~
mdzz，我帮你挡一刀，竟然还装逼！
-----------
糟糕，你被打了，帮你挡一刀~~
给敌人点面子，还是防御一下吧~~
mdzz，我帮你挡一刀，竟然还装逼！

使用jdk动态代理

测试类

/**
 * 使用jdk代理实现援助防御
 */
public class JdkProxyTest {

    public static void main(String[] args) {
        final IHandleAttack handleAttack = new AncientIronHandleAttack();
        IHandleAttack handleAttackProxy = (IHandleAttack) Proxy.newProxyInstance(
                handleAttack.getClass().getClassLoader(), handleAttack.getClass().getInterfaces(), new InvocationHandler() {
            
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("兄弟，不管你能不能躲过这一击，我都想帮你一下！");
                Object obj = method.invoke(handleAttack, args);
                return obj;
            }
        });
        
        handleAttackProxy.avoid();
        System.out.println("--------");
        handleAttackProxy.sufferAttack();
        System.out.println("--------");
        handleAttackProxy.defense();
    }
}

运行结果

兄弟，不管你能不能躲过这一击，我都想帮你一下！
我完美的回避了这一击~~
--------
兄弟，不管你能不能躲过这一击，我都想帮你一下！
反正我血厚得很，尽管打我~~
--------
兄弟，不管你能不能躲过这一击，我都想帮你一下！
给敌人点面子，还是防御一下吧~~

使用cglib动态代理

cglib代理类

public class AssistDefenseProxy implements MethodInterceptor {
    
    private Object target;
    
    public AssistDefenseProxy(Object target) {
        super();
        this.target = target;
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] objs, MethodProxy methodProxy) throws Throwable {
        System.out.println("兄弟，不管你能不能躲过这一击，我都想帮你一下！");
        Object object = method.invoke(target, objs);
        return object;
    }

}

测试类

public class CglibProxyTest {
    
    public static void main(String[] args) {
        AncientIronHandleAttack attack = new AncientIronHandleAttack();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(attack.getClass());
        enhancer.setCallback(new AssistDefenseProxy(attack));
        AncientIronHandleAttack attackProxy = (AncientIronHandleAttack) enhancer.create();

        attackProxy.avoid();
        System.out.println("--------");
        attackProxy.sufferAttack();
        System.out.println("--------");
        attackProxy.defense();
    }
    
}

运行结果

兄弟，不管你能不能躲过这一击，我都想帮你一下！
我完美的回避了这一击~~
--------
兄弟，不管你能不能躲过这一击，我都想帮你一下！
反正我血厚得很，尽管打我~~
--------
兄弟，不管你能不能躲过这一击，我都想帮你一下！
给敌人点面子，还是防御一下吧~~

结论

代理模式不好举例，将就这个例子看下吧，可能有点不合适。