MyBatis源码解析(二) --- 反射模块Reflector

最新推荐文章于 2024-02-20 13:12:37 发布
最新推荐文章于 2024-02-20 13:12:37 发布
阅读量464 收藏
点赞数 1
分类专栏： MyBatis MyBatis源码解析
原文链接：https://www.cnblogs.com/nullllun/p/9352792.html
版权

本文主要介绍MyBatis的反射模块是如何实现的。
在这里插入图片描述

DefaultReflectorFactory 源码分析

基础支持层反射模块Reflector/ReflectorFactory，DefaultReflectorFactory 用于创建 Reflector，同时兼有缓存的功能，它的源码如下。

public class DefaultReflectorFactory implements ReflectorFactory {

    private boolean classCacheEnabled = true;
    /** 目标类和反射器映射缓存 */
    private final ConcurrentMap<Class<?>, Reflector> reflectorMap = new ConcurrentHashMap<Class<?>, Reflector>();

    // 省略部分代码

    @Override
    public Reflector findForClass(Class<?> type) {
        // classCacheEnabled 默认为 true
        if (classCacheEnabled) {
            // 从缓存中获取 Reflector 对象
            Reflector cached = reflectorMap.get(type);
            // 缓存为空，则创建一个新的 Reflector 实例，并放入缓存中
            if (cached == null) {
                cached = new Reflector(type);
                // 将 <type, cached> 映射缓存到 map 中，方便下次取用
                reflectorMap.put(type, cached);
            }
            return cached;
        } else {
            // 创建一个新的 Reflector 实例
            return new Reflector(type);
        }
    }
}

如上，DefaultReflectorFactory 的findForClass方法逻辑不是很复杂，包含两个访存操作，和一个对象创建操作。代码注释的比较清楚了，就不多说了。接下来，来分析一下反射器 Reflector。

Reflector 源码分析

Reflector 这个类的用途主要是是通过反射获取目标类的 getter 方法及其返回值类型，setter 方法及其参数值类型等元信息。并将获取到的元信息缓存到相应的集合中，供后续使用。
我将会分析三部分逻辑，分别如下：

  1. Reflector 构造方法及成员变量分析
  2. getter 方法解析过程
  3. setter 方法解析过程

Reflector 构造方法及成员变量分析

Reflector 构造方法中包含了很多初始化逻辑，目标类的元信息解析过程也是在构造方法中完成的，这些元信息最终会被保存到 Reflector 的成员变量中。下面我们先来看看 Reflector 的构造方法和相关的成员变量定义，代码如下：

public class Reflector {

  private final Class<?> type;
  private final String[] readablePropertyNames;
  private final String[] writeablePropertyNames;
  private final Map<String, Invoker> setMethods = new HashMap<String, Invoker>();
  private final Map<String, Invoker> getMethods = new HashMap<String, Invoker>();
  private final Map<String, Class<?>> setTypes = new HashMap<String, Class<?>>();
  private final Map<String, Class<?>> getTypes = new HashMap<String, Class<?>>();
  private Constructor<?> defaultConstructor;

  private Map<String, String> caseInsensitivePropertyMap = new HashMap<String, String>();

  public Reflector(Class<?> clazz) {
    type = clazz;
    // 解析目标类的默认构造方法，并赋值给 defaultConstructor 变量
    addDefaultConstructor(clazz);
     // 解析 getter 方法，并将解析结果放入 getMethods 中
    addGetMethods(clazz);
    // 解析 setter 方法，并将解析结果放入 setMethods 中
    addSetMethods(clazz);
     // 解析属性字段，并将解析结果添加到 setMethods 或 getMethods 中
    addFields(clazz);
     // 从 getMethods 映射中获取可读属性名数组
    readablePropertyNames = getMethods.keySet().toArray(new String[getMethods.keySet().size()]);
     // 从 setMethods 映射中获取可写属性名数组
    writeablePropertyNames = setMethods.keySet().toArray(new String[setMethods.keySet().size()]);
    // 将所有属性名的大写形式作为键，属性名作为值，存入到 caseInsensitivePropertyMap 中
    for (String propName : readablePropertyNames) {
      caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
    }
    for (String propName : writeablePropertyNames) {
      caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
    }
  }
  }

如上，Reflector 的构造方法看起来略为复杂，不过好在一些比较复杂的逻辑都封装在了相应的方法中，这样整体的逻辑就比较清晰了。

getter 方法解析过程

getter 方法解析的逻辑被封装在了addGetMethods方法中，这个方法除了会解析形如getXXX的方法，同时也会解析isXXX方法。该方法的源码分析如下：

  private void addGetMethods(Class<?> cls) {
    Map<String, List<Method>> conflictingGetters = new HashMap<String, List<Method>>();
    // 获取当前类，接口，以及父类中的方法。该方法逻辑不是很复杂，这里就不展开了
    Method[] methods = getClassMethods(cls);
    // getter 方法不应该有参数，若存在参数，则忽略当前方法
    for (Method method : methods) {
      if (method.getParameterTypes().length > 0) {
        continue;
      }
      String name = method.getName();
      // 过滤出以 get 或 is 开头的方法
      if ((name.startsWith("get") && name.length() > 3)
          || (name.startsWith("is") && name.length() > 2)) {
          // 将 getXXX 或 isXXX 等方法名转成相应的属性，比如 getName -> name
        name = PropertyNamer.methodToProperty(name);
        /*
             * 将冲突的方法添加到 conflictingGetters 中。考虑这样一种情况：
             * 
             * getTitle 和 isTitle 两个方法经过 methodToProperty 处理，
             * 均得到 name = title，这会导致冲突。
             *
             * 对于冲突的方法，这里先统一起存起来，后续再解决冲突
             */
        addMethodConflict(conflictingGetters, name, method);
      }
    }
    // 解决 getter 冲突
    resolveGetterConflicts(conflictingGetters);
  }

如上，addGetMethods 方法的执行流程如下：

  1. 获取当前类，接口，以及父类中的方法
  2. 遍历上一步获取的方法数组，并过滤出以get和is开头的方法
  3. 将方法名转换成相应的属性名
  4. 将属性名和方法对象添加到冲突集合中
  5. 解决冲突

前四步比较简单，大家看一下就能懂。在这几步中，第5步逻辑比较复杂，这一步逻辑我们重点关注一下。

/** 添加属性名和方法对象到冲突集合中 */
 private void addMethodConflict(Map<String, List<Method>> conflictingMethods, String name, Method method) {
    List<Method> list = conflictingMethods.get(name);
    if (list == null) {
      list = new ArrayList<Method>();
      conflictingMethods.put(name, list);
    }
    list.add(method);
  }

/** 解决冲突 */
 private void resolveGetterConflicts(Map<String, List<Method>> conflictingGetters) {
    for (Entry<String, List<Method>> entry : conflictingGetters.entrySet()) {
      Method winner = null;
      String propName = entry.getKey();
      for (Method candidate : entry.getValue()) {
        if (winner == null) {
          winner = candidate;
          continue;
        }
        // 获取返回值类型
        Class<?> winnerType = winner.getReturnType();
        Class<?> candidateType = candidate.getReturnType();

          /* 
             * 两个方法的返回值类型一致，若两个方法返回值类型均为 boolean，则选取 isXXX 方法
             * 为 winner。否则无法决定哪个方法更为合适，只能抛出异常
             */
        if (candidateType.equals(winnerType)) {
          if (!boolean.class.equals(candidateType)) {
            throw new ReflectionException(
                "Illegal overloaded getter method with ambiguous type for property "
                    + propName + " in class " + winner.getDeclaringClass()
                    + ". This breaks the JavaBeans specification and can cause unpredictable results.");
            /*
                 * 如果方法返回值类型为 boolean，且方法名以 "is" 开头，
                 * 则认为候选方法 candidate 更为合适
                 */
          } else if (candidate.getName().startsWith("is")) {
            winner = candidate;
          }
            /*
             * winnerType 是 candidateType 的子类，类型上更为具体，
             * 则认为当前的 winner 仍是合适的，无需做什么事情
             */
        } else if (candidateType.isAssignableFrom(winnerType)) {
         /*
             * candidateType 是 winnerType 的子类，此时认为 candidate 方法更为合适，
             * 故将 winner 更新为 candidate
             */
        } else if (winnerType.isAssignableFrom(candidateType)) {
          winner = candidate;
        } else {
          throw new ReflectionException(
              "Illegal overloaded getter method with ambiguous type for property "
                  + propName + " in class " + winner.getDeclaringClass()
                  + ". This breaks the JavaBeans specification and can cause unpredictable results.");
        }
      }
      // 将筛选出的方法添加到 getMethods 中，并将方法返回值添加到 getTypes 中
      addGetMethod(propName, winner);
    }
  }


private void addGetMethod(String name, Method method) {
    if (isValidPropertyName(name)) {
        getMethods.put(name, new MethodInvoker(method));
        // 解析返回值类型
        Type returnType = TypeParameterResolver.resolveReturnType(method, type);
        // 将返回值类型由 Type 转为 Class，并将转换后的结果缓存到 setTypes 中
        getTypes.put(name, typeToClass(returnType));
    }
}

上就是解除冲突的过程，代码有点长，不太容易看懂。这里大家只要记住解决冲突的规则即可理解上面代码的逻辑。相关规则如下：

  1. 冲突方法的返回值类型具有继承关系，子类返回值对应的方法被认为是更合适的选择
  2. 冲突方法的返回值类型相同，如果返回值类型为boolean，那么以is开头的方法则是更合适的方法
  3. 冲突方法的返回值类型相同，但返回值类型非boolean，此时出现歧义，抛出异常
  4. 冲突方法的返回值类型不相关，无法确定哪个是更好的选择，此时直接抛异常

分析完 getter 方法的解析过程，下面继续分析 setter 方法的解析过程。

setter 方法解析过程

与 getter 方法解析过程相比，setter 方法的解析过程与此有一定的区别。主要体现在冲突出现的原因，以及冲突的解决方法上。那下面，我们深入源码来找出两者之间的区别。

private void addSetMethods(Class<?> cls) {
    Map<String, List<Method>> conflictingSetters = new HashMap<String, List<Method>>();
    // 获取当前类，接口，以及父类中的方法。该方法逻辑不是很复杂，这里就不展开了
    Method[] methods = getClassMethods(cls);
    for (Method method : methods) {
        String name = method.getName();
        // 过滤出 setter 方法，且方法仅有一个参数
        if (name.startsWith("set") && name.length() > 3) {
            if (method.getParameterTypes().length == 1) {
                name = PropertyNamer.methodToProperty(name);
                /*
                 * setter 方法发生冲突原因是：可能存在重载情况，比如：
                 *     void setSex(int sex);
                 *     void setSex(SexEnum sex);
                 */
                addMethodConflict(conflictingSetters, name, method);
            }
        }
    }
    // 解决 setter 冲突
    resolveSetterConflicts(conflictingSetters);
}

从上面的代码和注释中，我们可知道 setter 方法之间出现冲突的原因。即方法存在重载，方法重载导致methodToProperty方法解析出的属性名完全一致。而 getter 方法之间出现冲突的原因是getXXX和isXXX对应的属性名一致。既然冲突发生了，要进行调停，那接下来继续来看看调停冲突的逻辑。

private void resolveSetterConflicts(Map<String, List<Method>> conflictingSetters) {
    for (String propName : conflictingSetters.keySet()) {
        List<Method> setters = conflictingSetters.get(propName);
        /*
         * 获取 getter 方法的返回值类型，由于 getter 方法不存在重载的情况，
         * 所以可以用它的返回值类型反推哪个 setter 的更为合适
         */
        Class<?> getterType = getTypes.get(propName);
        Method match = null;
        ReflectionException exception = null;
        for (Method setter : setters) {
            // 获取参数类型
            Class<?> paramType = setter.getParameterTypes()[0];
            if (paramType.equals(getterType)) {
                // 参数类型和返回类型一致，则认为是最好的选择，并结束循环
                match = setter;
                break;
            }
            if (exception == null) {
                try {
                    // 选择一个更为合适的方法
                    match = pickBetterSetter(match, setter, propName);
                } catch (ReflectionException e) {
                    match = null;
                    exception = e;
                }
            }
        }
        // 若 match 为空，表示没找到更为合适的方法，此时抛出异常
        if (match == null) {
            throw exception;
        } else {
            // 将筛选出的方法放入 setMethods 中，并将方法参数值添加到 setTypes 中
            addSetMethod(propName, match);
        }
    }
}

/** 从两个 setter 方法中选择一个更为合适方法 */
private Method pickBetterSetter(Method setter1, Method setter2, String property) {
    if (setter1 == null) {
        return setter2;
    }
    Class<?> paramType1 = setter1.getParameterTypes()[0];
    Class<?> paramType2 = setter2.getParameterTypes()[0];

    // 如果参数2可赋值给参数1，即参数2是参数1的子类，则认为参数2对应的 setter 方法更为合适
    if (paramType1.isAssignableFrom(paramType2)) {
        return setter2;
        
    // 这里和上面情况相反
    } else if (paramType2.isAssignableFrom(paramType1)) {
        return setter1;
    }
    
    // 两种参数类型不相关，这里抛出异常
    throw new ReflectionException("Ambiguous setters defined for property '" + property + "' in class '"
        + setter2.getDeclaringClass() + "' with types '" + paramType1.getName() + "' and '"
        + paramType2.getName() + "'.");
}

private void addSetMethod(String name, Method method) {
    if (isValidPropertyName(name)) {
        setMethods.put(name, new MethodInvoker(method));
        // 解析参数类型列表
        Type[] paramTypes = TypeParameterResolver.resolveParamTypes(method, type);
        // 将参数类型由 Type 转为 Class，并将转换后的结果缓存到 setTypes
        setTypes.put(name, typeToClass(paramTypes[0]));
    }
}

关于 setter 方法冲突的解析规则，这里也总结一下吧。如下：

  1. 冲突方法的参数类型与 getter 的返回类型一致，则认为是最好的选择
  2. 冲突方法的参数类型与 getter 的返回类型一致，则认为是最好的选择
  3. 冲突方法的参数类型不相关，无法确定哪个是更好的选择，此时直接抛异常

到此关于 setter 方法的解析过程就说完了。我在前面说过 MetaClass 的hasSetter最终调用了 Refactor 的hasSetter方法，那么现在是时候分析 Refactor 的hasSetter方法了。代码如下如下：

public boolean hasSetter(String propertyName) {
    return setMethods.keySet().contains(propertyName);
}

PropertyTokenizer 源码分析

对于较为复杂的属性，需要进行进一步解析才能使用。那什么样的属性是复杂属性呢？ PropertyTokenizer 对数组和复合属性均进行了处理。那它是如何处理的呢？

public class PropertyTokenizer implements Iterator<PropertyTokenizer> {

    private String name;
    private final String indexedName;
    private String index;
    private final String children;

    public PropertyTokenizer(String fullname) {
        // 检测传入的参数中是否包含字符 '.'
        int delim = fullname.indexOf('.');
        if (delim > -1) {
            /*
             * 以点位为界，进行分割。比如：
             *    fullname = www.coolblog.xyz
             *
             * 以第一个点为分界符：
             *    name = www
             *    children = coolblog.xyz
             */ 
            name = fullname.substring(0, delim);
            children = fullname.substring(delim + 1);
        } else {
            // fullname 中不存在字符 '.'
            name = fullname;
            children = null;
        }
        indexedName = name;
        // 检测传入的参数中是否包含字符 '['
        delim = name.indexOf('[');
        if (delim > -1) {
            /*
             * 获取中括号里的内容，比如：
             *   1. 对于数组或List集合：[] 中的内容为数组下标，
             *      比如 fullname = articles[1]，index = 1
             *   2. 对于Map：[] 中的内容为键，
             *      比如 fullname = xxxMap[keyName]，index = keyName
             *
             * 关于 index 属性的用法，可以参考 BaseWrapper 的 getCollectionValue 方法
             */
            index = name.substring(delim + 1, name.length() - 1);

            // 获取分解符前面的内容，比如 fullname = articles[1]，name = articles
            name = name.substring(0, delim);
        }
    }

    // 省略 getter

    @Override
    public boolean hasNext() {
        return children != null;
    }

    @Override
    public PropertyTokenizer next() {
        // 对 children 进行再次切分，用于解析多重复合属性
        return new PropertyTokenizer(children);
    }

    // 省略部分方法
}
在云端123
关注
专栏目录
精尽 MyBatis 源码分析 —— 反射模块
qq_32782279的博客
08-09 297
1.概述 Java 中的反射虽然功能强大，但对大多数开发人员来说，写出高质量的反射代码还是 有一定难度的。MyBatis 中专门提供了反射模块，该模块对 Java 原生的反射进行了良好的封装，提了更加简洁易用的 API，方便上层使调用，并且对反射操作进行了一系列优化，例如缓存了类的元数据，提高了反射操作的性能。 2. Reflector org.apache.ibatis.reflection.Reflector ，反射器，每个 Reflector 对应一个类。Reflector 会缓存反射操作需要的类的信
Mybatis的反射
qq_33640789的博客
11-12 1432
  我们都知道Mybatis是ORM框架，主要是实现数据库字段和Java对象的映射，其中用到的就是反射。Mybatis的反射是一个特别强大的模块。   Mybatis的反射这里主要介绍ObjectFactory，Reflector，ReflectorFactory，ObjectWrapper，MetaObject 一：ObjectFactory   ObjectFactory主要提供了create方法，通过mapper.xml里面的对象路径反射生成对象。DefaultObjectFactory继承了Obje
reflectoring.github.io:反思博客
03-29
反射器 这是有关软件工程和Java主题的博客的存储库。 在Windows上本地运行博客 使用下载并安装ruby（我已经成功使用了Ruby + Devkit 2.6.5-1） 打开控制台并运行ruby --version来验证它是否已成功安装（如果此命令似乎永远运行，请重新启动计算机，然后重试:) 在您将此仓库克隆到的文件夹中，运行bundle install 运行bundle exec jekyll serve以启动jekyll 转到在浏览器中查看博客 对markdown文件的更改应自动触发jekyll的重新启动（如果不是，请使用CMD+C终止该进程并重新启动它） 在本地查看您的博客文章 将现有博客文章.md文件之一从_posts文件夹复制到新文件中 更改文件名，使其包含今天的日期和您的博客文章标题 将文件标题中的date和modified字段更改为今天的日期（将+1100替换为本
Mybatis的Reflector解析
Donald_Draper
11-18 258
Mybatis的MetaObject解析:[url]http://donald-draper.iteye.com/admin/blogs/2338818[/url] 在上篇分析MetaObejct时候，MetaObejct的方法的实现是依赖ObjectWrapper，ObjectWrapper依赖于MetaClass，而MetaClass依赖于Reflector，这一节我们就来看看Reflect...
Mybatis-Reflector
seasonsbin的专栏
06-24 253
Mybatis是一个ORM（Object Relation Mapping）框架，既然是ORM框架，那么DB与POJO之间的相互映射必然是其重要工作之一。Reflector是对反射的二次封装。它更侧重于增强getter/setter方法。Reflector对Getter/Setter的增强主要围绕以下几点： 1.缓存Class信息，提高效率。 缓存class信息实际上并不是由Reflector本身来完成的，而是由ReflectorFactory接口负责，其接口定义如下： /** * 缓存Refle
【mybatis】Reflector反射类
大乐乐
02-20 773
Reflector类是 MyBatis 框架中不可或缺的一环，它通过高效地处理反射操作，极大地增强了 MyBatis 的灵活性和易用性。深入理解Reflector的设计和实现，有助于更好地把握 MyBatis 的内部工作机制，以及如何在项目中有效利用 MyBatis 提供的强大功能。
MyBatis反射工具模块之Reflector
哆啦A梦丶幻想的博客
02-26 224
文章目录前言一、01. MyBatis反射工具模块之Reflector1. 参数注释说明2. 主要注释方法说明3. 主要注释子方法详细说明总结 前言 用了两年多的Spring Data JPA, 再来熟读一下mybatis源码 一、01. MyBatis反射工具模块之Reflector 1. 参数注释说明 // 类型 private final Class<?> type; // getter属性名称集合 private final String[] readableProp
mybatis-plus-boot-starter-3.4.3.3.jar
最新发布
04-13
mybatis-plus-boot-starter.jar 各个版本下载， SpringBoot 集成 MybatisPlus jar 包下载， Mybatis-Plus（简称MP）是一个基于MyBatis的增强工具库，它简化了与数据库的交互操作并提供了一系列增强功能，使开发者...
mybatis-plus最新代码生成器项目源码 ：mybatis-plus-generator.zip
07-20
mybatis-plus最新代码生成器项目源码 ：mybatis-plus-generator.zip mybatis-plus最新代码生成器项目源码 ：mybatis-plus-generator.zip mybatis-plus最新代码生成器项目源码 ：mybatis-plus-generator.zip ...
mybatis-3.5.9 源码（mybatis-3-mybatis-3.5.9.tar.gz）
02-07
通过对 MyBatis-3.5.9 源码的学习，开发者可以深入理解其工作原理，从而更好地优化自己的代码，解决潜在的问题，甚至为 MyBatis 做出贡献。这份源码不仅包含了 MyBatis 的核心功能，还反映了设计模式和最佳实践，...
Mybatis-ehcache 1.2.1源码（ehcache-cache-mybatis-ehcache-1.2.1.zip）
07-05
Mybatis-ehcache 1.2.1 是一个集成Mybatis和Ehcache的缓存模块，用于提高Mybatis框架的查询效率。Ehcache是一个广泛使用的Java缓存解决方案，它能够有效地存储和检索数据，减少数据库的负载，提高应用程序性能。在...
Mybatis源码解析之SpringBoot集成mybatis-spring-boot-starter分析
热门推荐
翻身已碰头的博客
03-28 1万+
Mybatis源码解析之核心类分析 Mybatis源码解析之初始化分析 Mybatis源码解析之执行流程解析 Mybatis源码解析之数据库连接和连接池 Mybatis源码解析之事务管理 Mybatis源码解析之缓存机制（一）：一级缓存 Mybatis源码解析之缓存机制（二）：二级缓存 Mybatis源码解析之插件机制 Mybatis源码解析之mapper接口的代理模式 Mybatis源码解析之D...
mybatis源码学习------Reflector类
我是兴锅的博客
08-12 501
Reflector简介 Reflector反射器，每个Reflector对象对应一个类，该对象会缓存反射操作所需要的类元信息，便于后续反射操作。 Reflector的类注释如下(难得作者心情好，写了两行注释)： This class represents a cached set of class definition information that allows for easy mapping between property names and getter/setter methods. 此类表
浅谈MyBatis源码工具类之——Reflector类
持续Java学习中
10-27 530
最近在看MyBatis源码，发现MyBatis底层有一个自己封装的工具类——Reflector，该类位于org.apache.ibatis.reflection包下。MyBatis在解析数据库查询返回数据的时候，会使用到我们配置的映射类型，它在底层实现的时候，就使用到了该工具类。 在阅读了这个工具类方法的源码之后，特作简单小节。该工具类就是一个反射方法的封装体，能够传入指定的Class类，然后解析出类中相关的数据信息。 文章目录一、使用分享1、方法测试2、简单使用二、源码分享1、addFields2、
mybatis底层组件介绍-Reflector和ReflectorFactory
lxlneversettle的博客
03-21 231
mybatis中的反射工具 mybatis对java中的反射进一步封装，使其更加易用。 首先看一下Reflector的类注释 This class represents a cached set of class definition information that allows for easy mapping between property names and getter/setter ...
用reflector分析.net源代码
weixin_33943347的博客
03-26 154
今天在博客堂（不是博客园哦！）看到mvm写的一段代码，可惜作者敝帚自珍，不肯公布源代码。但作者好心，给了一个提示方法，叫我用reflector直接在Assembly里面去看。真是不错，让我又多了一个好工具。用了一下reflector，还真是好使。注册了博客园，也该有点奉献。可惜自己拿不出什么好东东，只有拿别人的东西来撑门面了。 这个软件地址是http://www.aisto.com/roeder...
MyBatis的ReflectorFactory配置
Zn昕的博客
03-13 1427
MyBatis 的 ReflectorFactory 配置 反射工厂 MyBatis 用于缓存 Reflector 的功能，其配置如下 <reflectorFactory type="com.yczuoxin.reflectorFactory.MyReflectorFactory"/> ReflectorFactory 接口 public interface ReflectorFac...
mybatis初始化配置——反射组件
cygodwg的专栏
04-08 265
这篇我准备介绍下mybatis另一个基础支撑组件，反射组件组。 1、Reflector 我们来看下Reflector类的属性和构造器，通过属性和构造器我们基本上就能了解Reflector这个类了 public class Reflector { private final Class<?> type; private final String[] readableP...
reflector
Momoanna的博客
11-09 783
反编译下载 http://www.aisto.com/roeder/dotnet/ 文件输出下载 http://www.denisbauer.com/Downloads/Reflector.FileDisassembler.zip 各类插件 http://www.codeplex.com/reflectoraddins
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值