dubbo-common模块
dubbo-common提供了dubbo中的一系列基础公共方法
1、beanUtil包
JavaBeanAccessor：Java类的访问器，是一个枚举类，定义了 字段访问器，方法访问器和 all(method prefer to field ： 方法优于字段)。
public enum JavaBeanAccessor {
/**
* Field accessor.
*/
FIELD,
/**
* Method accessor.
*/
METHOD,
/**
* Method prefer to field.
*/
ALL;
public static boolean isAccessByMethod(JavaBeanAccessor accessor) {
return METHOD.equals(accessor) || ALL.equals(accessor);
}
public static boolean isAccessByField(JavaBeanAccessor accessor) {
return FIELD.equals(accessor) || ALL.equals(accessor);
}
}JavaBeanDescriptor：Java bean的描述类，其中定义了不同类型的常量值，还提供了得到iterator的方法、containsProperty、getProperty等。
private static final long serialVersionUID = -8505586483570518029L;
public static final int TYPE_CLASS = 1;
public static final int TYPE_ENUM = 2;
public static final int TYPE_COLLECTION = 3;
public static final int TYPE_MAP = 4;
public static final int TYPE_ARRAY = 5;
/**
* @see org.apache.dubbo.common.utils.ReflectUtils#isPrimitive(Class)
*/
public static final int TYPE_PRIMITIVE = 6;
public static final int TYPE_BEAN = 7;
private static final String ENUM_PROPERTY_NAME = "name";
private static final String CLASS_PROPERTY_NAME = "name";
private static final String PRIMITIVE_PROPERTY_VALUE = "value";
/**
* Used to define a type is valid.
*
* @see #isValidType(int)
*/
private static final int TYPE_MAX = TYPE_BEAN;
/**
* Used to define a type is valid.
*
* @see #isValidType(int)
*/
private static final int TYPE_MIN = TYPE_CLASS;
private String className;
private int type;
private Map properties = new LinkedHashMap<>();
JavaBeanSerializeUtil：提供了将对象Object像转化为JavaBeanDescriptor，将JavaBeanDescriptior转化为对象Object。通过反射机制提供了获取构造方法、instance实例、setter方法，根据名称(name)转化为一个实例对象-name2Class。需要注意的是，类中作为cache的map类型为IdentityHashMap
private static Method getSetterMethod(Class cls, String property, Class valueCls) {
String name = "set" + property.substring(0, 1).toUpperCase() + property.substring(1);
Method method = null;
try {
method = cls.getMethod(name, valueCls);
} catch (NoSuchMethodException e) {
for (Method m : cls.getMethods()) {
if (ReflectUtils.isBeanPropertyWriteMethod(m)
&& m.getName().equals(name)) {
method = m;
}
}
}
if (method != null) {
method.setAccessible(true);
}
return method;
}
private static Object instantiate(Class cl) throws Exception {
Constructor[] constructors = cl.getDeclaredConstructors();
Constructor constructor = null;
int argc = Integer.MAX_VALUE;
for (Constructor c : constructors) {
if (c.getParameterTypes().length < argc) {
argc = c.getParameterTypes().length;
constructor = c;
}
}
if (constructor != null) {
Class[] paramTypes = constructor.getParameterTypes();
Object[] constructorArgs = new Object[paramTypes.length];
for (int i = 0; i < constructorArgs.length; i++) {
constructorArgs[i] = getConstructorArg(paramTypes[i]);
}
try {
constructor.setAccessible(true);
return constructor.newInstance(constructorArgs);
} catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
LogHelper.warn(logger, e.getMessage(), e);
}
}
return cl.newInstance();
}
public static Object getConstructorArg(Class cl) {
if (boolean.class.equals(cl) || Boolean.class.equals(cl)) {
return Boolean.FALSE;
}
if (byte.class.equals(cl) || Byte.class.equals(cl)) {
return (byte) 0;
}
if (short.class.equals(cl) || Short.class.equals(cl)) {
return (short) 0;
}
if (int.class.equals(cl) || Integer.class.equals(cl)) {
return 0;
}
if (long.class.equals(cl) || Long.class.equals(cl)) {
return 0L;
}
if (float.class.equals(cl) || Float.class.equals(cl)) {
return (float) 0;
}
if (double.class.equals(cl) || Double.class.equals(cl)) {
return (double) 0;
}
if (char.class.equals(cl) || Character.class.equals(cl)) {
return (char) 0;
}
return null;
}
/**
* Transform the Class.forName String to Class Object.
*
* @param name Class.getName()
* @return Class
* @throws ClassNotFoundException Class.forName
*/
public static Class name2Class(ClassLoader loader, String name) throws ClassNotFoundException {
if (TYPES.containsKey(name)) {
return TYPES.get(name);
}
if (isArray(name)) {
int dimension = 0;
while (isArray(name)) {
++dimension;
name = name.substring(1);
}
Class type = name2Class(loader, name);
int[] dimensions = new int[dimension];
for (int i = 0; i < dimension; i++) {
dimensions[i] = 0;
}
return Array.newInstance(type, dimensions).getClass();
}
if (isReferenceType(name)) {
name = name.substring(1, name.length() - 1);
}
return Class.forName(name, false, loader);
}2、bytecode包
bytecode包中定义了两个Exception类：NoSuchMethodException和NoSuchPropertyException，另外还有ClassGenerator、MiXin、Proxy和Wrapper四个类。主要基于javassist类完成。
ClassGenerator类：ClassPool和CtClass类都在javassist包中。用来动态的生成一个类，添加其成员、方法等。在添加成员、方法和构造方法时需要添加限定(eg:public protected private static volatile等)，根据传递的mod与相应的限定符做位运算，来确定是否添加某一个限定符。也运用了反射机制。
private static String modifier(int mod) {
StringBuilder modifier = new StringBuilder();
if (Modifier.isPublic(mod)) {
modifier.append("public");
}
if (Modifier.isProtected(mod)) {
modifier.append("protected");
}
if (Modifier.isPrivate(mod)) {
modifier.append("private");
}
if (Modifier.isStatic(mod)) {
modifier.append(" static");
}
if (Modifier.isVolatile(mod)) {
modifier.append(" volatile");
}
return modifier.toString();
}
/**
* @param name
* @param mod 用来计算相应的限定符
* @param type 成员是什么类型的 String、 Integer 等
* @param def 初始值
* @return
*/
public ClassGenerator addField(String name, int mod, Class type, String def) {
StringBuilder sb = new StringBuilder();
sb.append(modifier(mod)).append(' ').append(ReflectUtils.getName(type)).append(' ');
sb.append(name);
if (StringUtils.isNotEmpty(def)) {
sb.append('=');
sb.append(def);
}
sb.append(';');
return addField(sb.toString());
}
public ClassGenerator addMethod(String code) {
if (mMethods == null) {
mMethods = new ArrayList();
}
mMethods.add(code);
return this;
}
/**
* @param name 方法名称
* @param mod 计算限定符，private public protected等
* @param rt 方法返回值类型 class
* @param pts 参数列表类型 class
* @param body 方法体
* @return
*/
public ClassGenerator addMethod(String name, int mod, Class rt, Class[] pts, String body) {
return addMethod(name, mod, rt, pts, null, body);
}
/**
* @param name
* @param mod
* @param rt 返回值类型
* @param pts 参数类型
* @param ets 异常的类型 class
* @param body
* @return
*/
public ClassGenerator addMethod(String name, int mod, Class rt, Class[] pts, Class[] ets,
String body) {
StringBuilder sb = new StringBuilder();
sb.append(modifier(mod)).append(' ').append(ReflectUtils.getName(rt)).append(' ').append(name);
sb.append('(');
for (int i = 0; i < pts.length; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(ReflectUtils.getName(pts[i]));
sb.append(" arg").append(i);
}
sb.append(')');
if (ArrayUtils.isNotEmpty(ets)) {
sb.append(" throws ");
for (int i = 0; i < ets.length; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(ReflectUtils.getName(ets[i]));
}
}
sb.append('{').append(body).append('}');
return addMethod(sb.toString());
}
/**
* 构造方法在增加的时候，添加SIMPLE_NAME_TAG 标签
*
* @param mod
* @param pts
* @param ets
* @param body
* @return
*/
public ClassGenerator addConstructor(int mod, Class[] pts, Class[] ets, String body) {
StringBuilder sb = new StringBuilder();
sb.append(modifier(mod)).append(' ').append(SIMPLE_NAME_TAG);
sb.append('(');
for (int i = 0; i < pts.length; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(ReflectUtils.getName(pts[i]));
sb.append(" arg").append(i);
}
sb.append(')');
if (ArrayUtils.isNotEmpty(ets)) {
sb.append(" throws ");
for (int i = 0; i < ets.length; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(ReflectUtils.getName(ets[i]));
}
}
sb.append('{').append(body).append('}');
return addConstructor(sb.toString());
}
public ClassGenerator addConstructor(Constructor c) {
String desc = ReflectUtils.getDesc(c);
addConstructor(":" + desc);
if (mCopyConstructors == null) {
mCopyConstructors = new ConcurrentHashMap>(4);
}
mCopyConstructors.put(desc, c);
return this;
}
Mixin类：个人理解是对生成的Java类进行混淆，将变量名称、方法名称、构造方法名称等变为d，加入"$"符号等。利用上面提到的ClassGenerator类生成一个混淆后的类。
/**
* mixin interface and delegates.
* all class must be public.
*
* @param ics interface class array.
* @param dcs delegate class array.
* @param cl class loader.
* @return Mixin instance.
*/
public static Mixin mixin(Class[] ics, Class[] dcs, ClassLoader cl) {
assertInterfaceArray(ics);
long id = MIXIN_CLASS_COUNTER.getAndIncrement();
String pkg = null;
ClassGenerator ccp = null, ccm = null;
try {
// 持有一个classloader的类生成器
ccp = ClassGenerator.newInstance(cl);
// impl constructor 实现构造方法
StringBuilder code = new StringBuilder();
for (int i = 0; i < dcs.length; i++) {
// 只有当delegate的modifier为public类型时进入
if (!Modifier.isPublic(dcs[i].getModifiers())) {
String npkg = dcs[i].getPackage().getName(); // 获得当前dcs的包名称
if (pkg == null) {
pkg = npkg;
} else {
if (!pkg.equals(npkg)) {
// 如果不是来自同一个包里的类就抛异常
throw new IllegalArgumentException("non-public interfaces class from different packages");
}
}
}
// 添加一个混淆成员 private 类型 d1/2/3 ...
ccp.addField("private " + dcs[i].getName() + " d" + i + ";");
// stringbuffer d1 = (类型)$1[1] => d1 = (String)$1[1]
code.append("d").append(i).append(" = (").append(dcs[i].getName()).append(")$1[").append(i).append("];\n");
// isAssignableFrom() => 是判断是否为某个类的父类，如果当前类对象是MixinAware的子类，则setMixinInstance
if (MixinAware.class.isAssignableFrom(dcs[i])) {
code.append("d").append(i).append(".setMixinInstance(this);\n");
}
}
ccp.addConstructor(Modifier.PUBLIC, new Class[]{Object[].class}, code.toString());
// impl methods. 实现普通方法
Set worked = new HashSet();
for (int i = 0; i < ics.length; i++) {
// 只有public类型的才进入判断
if (!Modifier.isPublic(ics[i].getModifiers())) {
String npkg = ics[i].getPackage().getName();
if (pkg == null) {
pkg = npkg;
} else {
if (!pkg.equals(npkg)) {
throw new IllegalArgumentException("non-public delegate class from different packages");
}
}
}
ccp.addInterface(ics[i]);
for (Method method : ics[i].getMethods()) {
// Object类的方法不做处理
if ("java.lang.Object".equals(method.getDeclaringClass().getName())) {
continue;
}
String desc = ReflectUtils.getDesc(method);
if (worked.contains(desc)) {
continue;
}
worked.add(desc);
// 查找此method在worked中的位置，如果不存在，异常
int ix = findMethod(dcs, desc);
if (ix < 0) {
throw new RuntimeException("Missing method [" + desc + "] implement.");
}
// 得到方法返回值，名称等，使用类生成器进行混淆
Class rt = method.getReturnType();
String mn = method.getName();
if (Void.TYPE.equals(rt)) {
ccp.addMethod(mn, method.getModifiers(), rt, method.getParameterTypes(), method.getExceptionTypes(),
"d" + ix + "." + mn + "($$);");
} else {
ccp.addMethod(mn, method.getModifiers(), rt, method.getParameterTypes(), method.getExceptionTypes(),
"return ($r)d" + ix + "." + mn + "($$);");
}
}
}
if (pkg == null) {
pkg = PACKAGE_NAME;
}
// create MixinInstance class.
String micn = pkg + ".mixin" + id;
ccp.setClassName(micn);
ccp.toClass();
// create Mixin class.
String fcn = Mixin.class.getName() + id;
ccm = ClassGenerator.newInstance(cl);
ccm.setClassName(fcn);
ccm.addDefaultConstructor();
ccm.setSuperClass(Mixin.class.getName());
ccm.addMethod("public Object newInstance(Object[] delegates){ return new " + micn + "($1); }");
Class mixin = ccm.toClass();
return (Mixin) mixin.newInstance();
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e.getMessage(), e);
} finally {
// release ClassGenerator
if (ccp != null) {
ccp.release();
}
if (ccm != null) {
ccm.release();
}
}
} Proxy类：cache的key以interface class name list as key
/**
* Get proxy.
*
* @param cl class loader.
* @param ics interface class array.
* @return Proxy instance.
*/
public static Proxy getProxy(ClassLoader cl, Class... ics) {
if (ics.length > MAX_PROXY_COUNT) {
throw new IllegalArgumentException("interface limit exceeded");
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < ics.length; i++) {
String itf = ics[i].getName();
if (!ics[i].isInterface()) {
throw new RuntimeException(itf + " is not a interface.");
}
Class tmp = null;
try {
tmp = Class.forName(itf, false, cl);
} catch (ClassNotFoundException e) {
}
if (tmp != ics[i]) {
throw new IllegalArgumentException(ics[i] + " is not visible from class loader");
}
sb.append(itf).append(';');
}
// use interface class name list as key.
String key = sb.toString();
// get cache by class loader.
final Map cache;
synchronized (PROXY_CACHE_MAP) {
// 如果classloader对应的值不存在，初始化一个hashmap
cache = PROXY_CACHE_MAP.computeIfAbsent(cl, k -> new HashMap<>());
}
Proxy proxy = null;
synchronized (cache) {
do {
Object value = cache.get(key);
if (value instanceof Reference) {
proxy = (Proxy) ((Reference) value).get();
if (proxy != null) {
return proxy;
}
}
// PENDING_GENERATION_MARKER = new Object(); ？？？ 为什么加一个object进去
if (value == PENDING_GENERATION_MARKER) {
try {
cache.wait();
} catch (InterruptedException e) {
}
} else {
cache.put(key, PENDING_GENERATION_MARKER);
break;
}
}
while (true);
}
long id = PROXY_CLASS_COUNTER.getAndIncrement();
String pkg = null;
ClassGenerator ccp = null, ccm = null;
try {
ccp = ClassGenerator.newInstance(cl);
Set worked = new HashSet<>();
List methods = new ArrayList<>();
for (int i = 0; i < ics.length; i++) {
if (!Modifier.isPublic(ics[i].getModifiers())) {
// 判断interface是否属于同一个包的public接口
String npkg = ics[i].getPackage().getName();
if (pkg == null) {
pkg = npkg;
} else {
if (!pkg.equals(npkg)) {
throw new IllegalArgumentException("non-public interfaces from different packages");
}
}
}
ccp.addInterface(ics[i]);
for (Method method : ics[i].getMethods()) {
String desc = ReflectUtils.getDesc(method);
if (worked.contains(desc)) {
continue;
}
if (ics[i].isInterface() && Modifier.isStatic(method.getModifiers())) {
continue;
}
worked.add(desc);
int ix = methods.size();
Class rt = method.getReturnType();
Class[] pts = method.getParameterTypes();
StringBuilder code = new StringBuilder("Object[] args = new Object[").append(pts.length).append("];");
for (int j = 0; j < pts.length; j++) {
code.append(" args[").append(j).append("] = ($w)$").append(j + 1).append(";");
}
code.append(" Object ret = handler.invoke(this, methods[").append(ix).append("], args);");
// 返回值不为void时，追加return
if (!Void.TYPE.equals(rt)) {
code.append(" return ").append(asArgument(rt, "ret")).append(";");
}
methods.add(method);
ccp.addMethod(method.getName(), method.getModifiers(), rt, pts, method.getExceptionTypes(), code.toString());
}
}
if (pkg == null) {
pkg = PACKAGE_NAME;
}
// create ProxyInstance class.
String pcn = pkg + ".proxy" + id;
ccp.setClassName(pcn);
ccp.addField("public static java.lang.reflect.Method[] methods;");
ccp.addField("private " + InvocationHandler.class.getName() + " handler;");
ccp.addConstructor(Modifier.PUBLIC, new Class[]{InvocationHandler.class}, new Class[0], "handler=$1;");
ccp.addDefaultConstructor();
Class clazz = ccp.toClass();
clazz.getField("methods").set(null, methods.toArray(new Method[0]));
// create Proxy class.
String fcn = Proxy.class.getName() + id;
ccm = ClassGenerator.newInstance(cl);
ccm.setClassName(fcn);
ccm.addDefaultConstructor();
ccm.setSuperClass(Proxy.class);
ccm.addMethod("public Object newInstance(" + InvocationHandler.class.getName() + " h){ return new " + pcn + "($1); }");
Class pc = ccm.toClass();
proxy = (Proxy) pc.newInstance();
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e.getMessage(), e);
} finally {
// release ClassGenerator
if (ccp != null) {
ccp.release();
}
if (ccm != null) {
ccm.release();
}
synchronized (cache) {
if (proxy == null) {
cache.remove(key);
} else {
// put进生成的proxy代理对象
cache.put(key, new WeakReference(proxy));
}
cache.notifyAll();
}
}
return proxy;
}
3、logger包
logger包中定义了LoggerFactory、LoggerAdapter、Logger、Level以及各个日志工具的logger和adapter（包括jcl jdk log4j log4j2 slf4j）。xxxLogger继承了Logger接口实现了自己特定的方法，LoginAdapter继承了LoggerAdapter.