在JAVA中实现混型的两种方式 --《JAVA编程思想》 62

原创于 2021-10-23 21:15:49 发布 · 406 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java #后端 #动态代理 #泛型

JAVA编程思想专栏收录该内容

90 篇文章

订阅专栏

混型的基本概念是混合多个类的能力，以产生一个可以表示混型中所有类型的类。

我们来看个简单的需求：现在需要把获取当前时间戳、获取计数器和存取某个值的三个类合成一个混型。

1. 通过接口实现

首先，我们可以直接通过接口的形式来满足需求。

public interface TimeStamped {
    long getStamp();
}

public class TimeStampedImp implements TimeStamped {

    @Override
    public long getStamp() {
        return new Date().getTime();
    }

}

public interface SerialNumbered {
    long getSerialNumber();
}

public class SerialNumberedImp implements SerialNumbered {

    private static Long counter = 1L;

    private final long serialNumber = counter++;

    @Override
    public long getSerialNumber() {
        return serialNumber;
    }
    
}

public interface Basic {

    void set(String val);

    String get();

}

public class BasicImp implements Basic {

    private String val;

    @Override
    public void set(String val) {
        this.val = val;
    }

    @Override
    public String get() {
        return val;
    }

}

public class Mixin extends BasicImp implements TimeStamped, SerialNumbered {

    private TimeStamped timeStamped = new TimeStampedImp();

    private SerialNumbered serialNumbered = new SerialNumberedImp();

    @Override
    public long getSerialNumber() {
        return serialNumbered.getSerialNumber();
    }

    @Override
    public long getStamp() {
        return timeStamped.getStamp();
    }
    
}

public class Mixins {

    public static void main(String[] args) {
        Mixin mixin = new Mixin();
        mixin.set("Today is a good day!");
        System.out.println(mixin.get());
        System.out.println(mixin.getStamp());
        System.out.println(mixin.getSerialNumber());
    }
    
}

Today is a good day!
1634979111046
1

TimeStamped 和 TimeStampedImp 为获取当前时间戳的接口和实现类；

SerialNumbered 和 SerialNumberedImp 为获取计数器的接口和实现类；

Basic 和 BasicImp 为设置和获取 String 类型值得接口和实现类。

Mixin 继承 BasicImp 获得存取值得能力，再通过实现 TimeStamped 和 SerialNumbered 两个接口，在内部注入两个对应接口的实现类，从而使得 Mixin 同时混合了三个类的能力。

使用此种方式实现混型都要求每种被混入的类型在 Mixin 中有对应的域，还得在混型类中编写方法将调用转发给具体的实现类，业务越复杂代码量就会越大。

2. 通过动态代理来实现混合

其次，我们可以通过动态代理来实现。由于动态代理的限制，每个被混入的类都要求为接口。

public class TwoTuple<A, B> {


    public TwoTuple(A first, B second) {
        this.first = first;
        this.second = second;
    }

    private A first;

    private B second;

    public A getFirst() {
        return first;
    }

    public B getSecond() {
        return second;
    }
    
}

public class MixinProxy implements InvocationHandler {

    Map<String, Object> delegatesByMethod;

    public MixinProxy(TwoTuple<Object, Class<?>>... pairs) {
        delegatesByMethod = new HashMap<>();
        //将需要代理的方法放入Map
        for (TwoTuple<Object, Class<?>> pair : pairs) {
            Method[] methods = pair.getSecond().getMethods();
            for (Method method : methods) {
                String methodName = method.getName();
                if (!delegatesByMethod.containsKey(methodName)) {
                    delegatesByMethod.put(methodName, pair.getFirst());
                }
            }
        }
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        //返回实际处理业务的对象
        Object delegate = delegatesByMethod.get(methodName);
        return method.invoke(delegate, args);
    }

    public static Object newInstance(TwoTuple... pairs) {
        //收集代理的接口
        Class[] interfaces = new Class[pairs.length];
        for (int i = 0; i < interfaces.length; i++) {
            interfaces[i]= (Class) pairs[i].getSecond();
        }
        ClassLoader cl=pairs[0].getFirst().getClass().getClassLoader();
        return Proxy.newProxyInstance(cl,interfaces,new MixinProxy(pairs));
    }

}

public class DynamicProxyMixin {

    public static void main(String[] args) {
        Object mixin = MixinProxy.newInstance(new TwoTuple(new BasicImp(), Basic.class),
                new TwoTuple(new TimeStampedImp(),
                TimeStamped.class), new TwoTuple(new SerialNumberedImp(), SerialNumbered.class));
        Basic b= (Basic) mixin;
        TimeStamped t = (TimeStamped) mixin;
        SerialNumbered s = (SerialNumbered) mixin;
        b.set("dynamicProxy");
        System.out.println(b.get());
        System.out.println(t.getStamp());
        System.out.println(s.getSerialNumber());
    }

}

dynamicProxy
1634985088839
1

TwoTuple 存储两个类型参数，第一个为被代理接口的实现类，第二个为被代理接口。

在 MixinProxy 代理类的构造方法中，将需要代理的方法作为 key ，实现代理方法的实现类作为 value 存入 delegatesByMethod 中。

通过 newInstance() 方法获取实例时，传入第一个接口实现类的类加载器（任意一个接口实现类的加载器都行，传入第一个是防止因下标越界引起异常）、需要被代理的接口、实现 InvocationHandler 接口的类，从而返回代理对象。因代理对象同时代理了多组接口，故可以转换为 Basic 、TimeStamped 、SerialNumbered 任意类型进行方法调用。

倘若我们需要添加新的类型至混型之中，只需要拓展对应的接口。相比直接通过接口实现混型，此方式的代码量更少，也更为灵活。

本次分享至此结束，希望本文对你有所帮助，若能点亮下方的点赞按钮，在下感激不尽，谢谢您的【精神支持】。

若有任何疑问，也欢迎与我交流，若存在不足之处，也欢迎各位指正！