混型的基本概念是混合多个类的能力，以产生一个可以表示混型中所有类型的类。
我们来看个简单的需求：现在需要把获取当前时间戳、获取计数器和存取某个值的三个类合成一个混型。
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 任意类型进行方法调用。
倘若我们需要添加新的类型至混型之中，只需要拓展对应的接口。相比直接通过接口实现混型，此方式的代码量更少，也更为灵活。
本次分享至此结束，希望本文对你有所帮助，若能点亮下方的点赞按钮，在下感激不尽，谢谢您的【精神支持】。
若有任何疑问，也欢迎与我交流，若存在不足之处，也欢迎各位指正！