Java反射机制与类加载器深度解析

最新推荐文章于 2025-06-30 15:11:05 发布
最新推荐文章于 2025-06-30 15:11:05 发布
阅读量596 收藏 14
点赞数 15
CC 4.0 BY-SA版权
分类专栏： Java基础 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc666_666/article/details/149018052

反射访问字段

通过Java反射机制可以动态读写对象的字段值。要操作字段需要先获取对应的Field对象引用，随后通过特定方法进行读写操作。

基本访问方法

获取字段引用后，根据字段数据类型调用对应的访问方法：

  • 读取字段值：使用getXxx()系列方法（Xxx对应字段类型）
  • 设置字段值：使用setXxx()系列方法
// 获取int类型字段值
int getInt(Object obj) 
// 设置int类型字段值  
void setInt(Object obj, int newValue)

静态与实例字段

静态字段和实例字段的访问方式完全相同。唯一的区别在于：

  • 实例字段：get()/set()方法的第一个参数是对象实例
  • 静态字段：get()/set()方法的第一个参数是类/接口的Class对象

访问控制限制

默认情况下只能访问public修饰的字段。对于私有字段，常规Java语法无法直接访问：

Person john = new Person();
String name = john.name;  // 编译错误：无法访问私有字段

需要通过深度反射技术突破访问限制，具体方式包括：

  1. 使用getDeclaredField()获取字段引用（而非getField()）
  2. 调用setAccessible(true)方法解除访问控制

完整示例

以下代码演示了如何访问PublicPerson类的公共name字段：

public class FieldAccessTest {
    public static void main(String[] args) {
        Class ppClass = PublicPerson.class;
        try {
            PublicPerson p = ppClass.newInstance();
            Field name = ppClass.getField("name");
            
            // 读取字段值
            String nameValue = (String) name.get(p);
            System.out.println("当前name值：" + nameValue);
            
            // 修改字段值
            name.set(p, "Ann");
            nameValue = (String) name.get(p);
            System.out.println("新name值：" + nameValue);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

安全注意事项

当存在SecurityManager时，进行深度反射需要具备ReflectPermission("suppressAccessChecks")权限。可通过策略文件授权：

grant {
    permission java.lang.reflect.ReflectPermission 
        "suppressAccessChecks";
};

对于模块化系统，还需要在模块声明中使用opens语句开放相应包才能跨模块进行深度反射。

类加载器体系

Java运行时采用三级类加载器架构，每个类型都由java.lang.ClassLoader的实例加载。通过Class类的getClassLoader()方法可获取类型的类加载器：

Class cls = Bulb.class;
ClassLoader loader = cls.getClassLoader();

三级类加载器

  1. Bootstrap类加载器
    由JVM原生代码实现，负责加载核心模块如java.base、java.logging等。其加载的类调用getClassLoader()返回null：

    Object.class.getClassLoader() == null  // 返回true

    可通过-Xbootclasspath/a参数追加引导类路径。

  2. Platform类加载器
    替代JDK8的扩展机制，通过ClassLoader.getPlatformClassLoader()获取引用。加载的模块包括：

    - java.compiler
- java.net.http  
- java.sql
- jdk.crypto.ec
- jdk.httpserver

  3. Application类加载器
    通过ClassLoader.getSystemClassLoader()获取，加载应用模块和工具类模块：

    - jdk.compiler
- jdk.javadoc
- jdk.jlink

委托机制变化

JDK9后类加载器委托关系升级为网状结构：

  • Application类加载器可委托给Platform和Bootstrap
  • Platform类加载器可委托给Application和Bootstrap
Application
Platform
Bootstrap

模块加载规则

  1. Application类加载器

    • 先搜索所有类加载器定义的命名模块
    • 未找到则委托给Platform类加载器
    • 最后搜索classpath，加载到未命名模块

  2. Platform类加载器

    • 搜索所有类加载器的命名模块
    • 未找到则委托给Bootstrap类加载器

  3. Bootstrap类加载器

    • 搜索自身命名模块
    • 未找到则搜索-Xbootclasspath/a指定路径

安全控制

类加载过程受安全策略限制：

// 检查安全管理器
SecurityManager smgr = System.getSecurityManager();
if (smgr != null) {
    smgr.checkPermission(new RuntimePermission("getClassLoader"));
}

代码示例

查看模块与类加载器映射关系：

ModuleLayer layer = ModuleLayer.boot();
for (Module m : layer.modules()) {
    ClassLoader loader = m.getClassLoader();
    String loaderName = loader == null ? 
        "bootstrap" : loader.getName();
    System.out.printf("%s: %s%n", loaderName, m.getName());
}

输出示例：

bootstrap: java.base
platform: java.net.http
app: jdk.internal.opt

版本兼容性

注意JDK9+的类加载器变化：

  • JDK8的URLClassLoader被内部实现替代
  • 依赖URLClassLoader特定方法的旧代码需要适配

通过--illegal-access参数可控制对JDK内部API的反射访问警告级别，未来版本将完全禁止非法访问。

反射创建对象

通过Java反射机制可以动态实例化类的对象，这种方式特别适用于需要在运行时确定类名的场景。与直接使用new操作符不同，反射创建对象需要先获取构造器引用，再通过Constructor.newInstance()方法完成实例化。

核心实现步骤

  1. 获取构造器引用
    通过Class对象的getConstructor()方法获取特定参数类型的构造器：

    // 获取无参构造器
Constructor noArgsCons = Person.class.getConstructor();

// 获取带参构造器（int和String参数）
Constructor paramCons = Person.class.getConstructor(
    int.class, String.class);

  2. 调用newInstance实例化
    通过构造器对象的newInstance()方法创建实例，可传入构造参数：

    // 调用无参构造
Person p1 = noArgsCons.newInstance();

// 调用带参构造
Person p2 = paramCons.newInstance(1001, "张三");

类型安全处理

Constructor是泛型类，其类型参数需与实际类匹配：

// 正确声明构造器类型
Constructor cons = Person.class.getConstructor(int.class, String.class);

// 类型安全的实例化
Person p = cons.newInstance(1002, "李四");  // 自动返回Person类型

异常处理要点

反射实例化可能抛出多种异常，建议统一处理：

try {
    Constructor cons = Person.class.getConstructor(int.class, String.class);
    Person p = cons.newInstance(1003, "王五");
} catch (NoSuchMethodException | InstantiationException |
         IllegalAccessException | IllegalArgumentException |
         InvocationTargetException e) {
    System.out.println("实例化失败: " + e.getMessage());
}

与new操作符对比

特性反射创建new操作符
编译时类型检查无有
运行时灵活性高（类名可配置）低
性能开销较大（需查找构造器）极小
代码可读性较低高

典型应用场景

  1. 框架组件初始化
    Spring等IoC容器通过反射实例化Bean：

    Class clazz = Class.forName(beanClassName);
Object bean = clazz.getDeclaredConstructor().newInstance();

  2. 动态代理实现
    JDK动态代理中反射创建代理实例：

    Proxy.newProxyInstance(
    loader, interfaces, invocationHandler);

  3. 插件系统开发
    加载未知插件类的实例：

    Constructor cons = pluginClass.getConstructor(Config.class);
Plugin plugin = (Plugin) cons.newInstance(config);

性能优化建议

对于需要频繁创建的对象，可缓存Constructor对象：

// 缓存构造器引用
private static final Constructor CACHED_CONS;
static {
    try {
        CACHED_CONS = Person.class.getConstructor(int.class, String.class);
    } catch (NoSuchMethodException e) {
        throw new RuntimeException("初始化构造器失败", e);
    }
}

// 使用时直接调用
Person p = CACHED_CONS.newInstance(1004, "赵六");

注意：当类名和结构在编译期已知时，应优先使用new操作符。反射机制主要服务于需要动态特性的框架和工具类开发。

深度反射机制

Java反射机制提供了突破访问限制的能力，允许程序在运行时访问私有字段、方法和构造器。这种技术被称为深度反射(Deep Reflection)，是许多框架(如Hibernate、Spring)实现其核心功能的基础。

访问控制突破原理

通过setAccessible()方法可以解除Java语言的访问控制检查：

Field field = targetClass.getDeclaredField("privateField");
// 关键突破点
field.setAccessible(true);  
Object value = field.get(targetObj);

JDK9引入了更精细的控制方法：

  • trySetAccessible()：尝试设置可访问标志并返回结果
  • canAccess(Object obj)：检查当前上下文是否具有访问权限

模块系统的影响

Java模块化系统对深度反射施加了新的约束：

module com.example {
    // 必须明确开放包才能允许深度反射
    opens com.example.internal;
}

开放包有三种方式：

  1. 使用opens指令开放特定包
  2. 使用opens...to定向开放给指定模块
  3. 声明open module完全开放模块

安全管理器权限

当存在SecurityManager时，必须授予反射权限：

// 安全策略文件配置
grant {
    permission java.lang.reflect.ReflectPermission 
        "suppressAccessChecks";
};

可通过代码检查权限状态：

SecurityManager sm = System.getSecurityManager();
if (sm != null) {
    sm.checkPermission(new ReflectPermission("suppressAccessChecks"));
}

跨模块反射示例

跨模块访问私有字段需要满足：

  1. 目标模块开放对应包
  2. 调用模块具有反射权限
// 模块A的module-info.java
open module moduleA {
    exports com.moduleA.api;
    // 开放内部实现包
    opens com.moduleA.internal; 
}

// 模块B的访问代码
Class clazz = Class.forName("com.moduleA.internal.Secret");
Field hiddenField = clazz.getDeclaredField("value");
hiddenField.setAccessible(true);
Object secretValue = hiddenField.get(instance);

JDK内部API访问限制

对于JDK模块的深度反射存在特殊限制：

// 尝试修改String内部的value字段
Field valueField = String.class.getDeclaredField("value");
valueField.setAccessible(true);  // JDK9+将抛出InaccessibleObjectException

唯一的例外是从未命名模块(传统classpath)访问JDK内部API，但会收到警告：

WARNING: Illegal reflective access by DemoClass to field java.lang.String.value

最佳实践建议

  1. 优先考虑设计重构而非使用深度反射
  2. 必须使用时添加明确的模块opens声明
  3. 对反射操作进行完备的错误处理
  4. 缓存Field/Method/Constructor对象提升性能
  5. 避免在JDK升级敏感场景使用深度反射

以下展示了安全的深度反射实现模板：

try {
    Field field = targetClass.getDeclaredField(fieldName);
    if (field.trySetAccessible()) {
        return field.get(target);
    } else {
        logger.warn("无法访问字段: {}", fieldName);
        return fallbackValue;
    }
} catch (Exception e) {
    throw new ReflectionException("反射操作失败", e);
}

随着Java模块系统的完善，深度反射的使用应该更加审慎。开发者需要平衡灵活性与模块化安全性的关系，确保代码既满足功能需求，又能适应未来的Java版本演进。

跨模块反射实践

requires与opens的协同配置

在模块化系统中实现跨模块深度反射需要精确的模块声明配置。当模块A需要访问模块B的内部成员时，必须满足双重条件：

  1. 模块B导出/开放目标包
    使用exports声明允许编译时访问，opens声明允许运行时反射访问：

    // 模块B的声明
module moduleB {
    exports com.moduleB.api;       // 常规导出
    opens com.moduleB.internal;    // 深度反射开放
}

  2. 模块A声明依赖关系
    即使通过反射访问，也建议显式声明requires：

    // 模块A的声明
module moduleA {
    requires moduleB;
}

特殊情况下可使用opens...to定向开放：

module moduleB {
    opens com.moduleB.internal to moduleA, moduleC;
}

未命名模块的特殊访问规则

未命名模块（传统classpath加载的类）具有特殊的反射权限：

  1. 自动开放所有包
    未命名模块的所有包默认处于开放状态，允许任意反射访问

  2. 访问JDK模块的限制例外
    唯一允许对JDK内部API进行深度反射的场景：

    // 从classpath运行的代码可以反射访问JDK私有字段
Field valueField = String.class.getDeclaredField("value");
valueField.setAccessible(true);  // 能成功但会收到警告

JDK内部API的反射限制

JDK9+对核心模块实施了严格的反射控制：

  1. 命名模块的完全禁止
    任何命名模块中的代码都无法反射访问JDK内部API：

    // 在模块化应用中会抛出InaccessibleObjectException
Field fd = FileDescriptor.class.getDeclaredField("fd");
fd.setAccessible(true);

  2. 警告机制
    从未命名模块访问时产生警告：

    WARNING: Illegal reflective access by DemoClass (file:/app/) 
to field java.io.FileDescriptor.fd

  3. 未来版本策略
    通过--illegal-access参数控制行为：

    --illegal-access=deny   # 完全禁止(默认)
--illegal-access=warn   # 仅警告(JDK9-16)
--illegal-access=debug  # 打印堆栈跟踪

非法反射操作的警告处理

建议采用防御性编程处理反射异常：

try {
    Class clazz = Class.forName("com.external.PrivateClass");
    Field field = clazz.getDeclaredField("secret");
    
    // 优先使用trySetAccessible()
    if (!field.trySetAccessible()) {
        throw new IllegalStateException("无法突破访问限制");
    }
    
    // 检查实际访问权限
    if (field.canAccess(null)) {
        return field.get(target);
    }
} catch (InaccessibleObjectException e) {
    // 模块系统阻止访问
    logger.error("模块配置缺失opens声明", e);
} catch (SecurityException e) {
    // 安全管理器拦截
    logger.error("缺少ReflectPermission权限", e);
}

典型问题解决方案

场景：框架需要注入私有字段值

  1. 模块配置方案：

    open module framework.core {
    exports org.framework.api;
    // 开放扩展包给所有模块
    opens org.framework.internals; 
}

  2. 运行时检查逻辑：

    Field[] fields = targetClass.getDeclaredFields();
for (Field f : fields) {
    if (f.trySetAccessible()) {
        injector.inject(f, target);
    } else {
        logger.debug("字段 {} 不可注入", f.getName());
    }
}

  3. 安全策略文件：

    grant codeBase "file:${framework.home}/lib/*" {
    permission java.lang.reflect.ReflectPermission 
        "suppressAccessChecks";
};

通过合理配置模块声明和安全策略，可以在保持模块化优势的同时，为框架必要的深度反射需求提供合法通道。随着模块化技术的成熟，建议逐步将反射代码迁移到正式API接口。

总结

Java反射机制作为语言动态能力的核心支柱，在模块化时代面临着新的安全与架构挑战。通过本系列内容的系统梳理，我们可以得出以下关键结论：

模块化与反射的平衡艺术

模块化系统通过exports和opens双机制实现了精细化的访问控制：

  • exports保障编译期接口契约
  • opens为运行时深度反射提供可控通道

这种设计既保留了反射的灵活性，又通过模块描述符显式声明了架构意图。开发者应当遵循最小开放原则，仅开放必要的包给特定的模块。

安全模型的演进

现代Java安全体系呈现多层次防护：

  1. 语言级的private/protected修饰符
  2. 模块系统的exports/opens声明
  3. SecurityManager的权限检查
  4. JDK9+对核心模块的强化封装
// 安全反射的典型检查流程
Field field = targetClass.getDeclaredField("sensitiveField");
if (!field.trySetAccessible() || 
    !field.canAccess(target)) {
    throw new SecureAccessException("反射访问被拒绝");
}

实践建议

  1. 模块化应用：

    • 优先使用服务接口而非反射
    • 必须反射时采用opens...to定向开放
    • 在module-info.java中显式记录反射需求

  2. 传统应用：

    • 准备迁移路径应对--illegal-access=deny默认策略
    • 将反射调用逐步替换为合法API

  3. 框架开发：

    • 提供明确的模块开放指南
    • 缓存反射元数据提升性能
    • 优雅降级处理访问拒绝

技术演进趋势

随着Java平台发展，反射机制正在经历重要转变：

  • 从"全权委托"到"最小授权"
  • 从隐式渗透到显式声明
  • 从运行时魔术到编译时契约

这种转变要求开发者更严谨地对待反射使用场景，在框架灵活性与系统安全性之间取得平衡。未来代码应当像下面这样兼具表达力与安全性：

// 理想的现代反射用法
open module my.module {
    opens com.my.internal to framework.core;
}

// 框架侧安全调用
Optional safeGetField(Object target, String fieldName) {
    try {
        Field f = target.getClass().getDeclaredField(fieldName);
        return f.trySetAccessible() ? 
               Optional.of(f.get(target)) : 
               Optional.empty();
    } catch (Exception e) {
        return Optional.empty();
    }
}

Java反射机制仍然是高级框架开发的利器，但模块化时代要求我们以更规范、更安全的方式运用这项能力。这既是挑战，也是提升代码质量的机遇。

深度解析Java类加载器机制与双亲委派模型
m0_66884848的博客
06-17 938
Java类加载器是JVM的核心组件，遵循双亲委派模型实现类的动态加载。系统包含启动类加载器（Bootstrap）、扩展类加载器（Extension）和应用类加载器（Application）三级结构，同时支持自定义类加载器。双亲委派通过父加载器优先机制保证安全性和类唯一性，但存在SPI、模块化系统等需要打破该模型的场景。类加载过程涉及loadClass、findClass等核心方法，开发者可通过继承ClassLoader实现自定义加载逻辑。
一、类加载机制深度解析
weixin_40181736的博客
06-25 1044
第一步：java调用底层的jvm.dll文件创建java虚拟机（这一步由C++实现），这里java.exe是c++写的代码，调用jvm.dll也是c++底层的一个函数，通过调用jvm.dll文件（dll文件相当于java的jar包），会创建java虚拟机，java虚拟机的启动都是c++程序实现的。 第二步：在启动虚拟机的过程中，会创建一个引导类加载器的实例，这个引导类的加载器是C语言实现的，然后jvm虚拟机就启动起来了。 第三步：接下类，c++会调用java的启动程序，刚刚只是创建了java虚拟机，...
深入解析Java类加载器：原理、机制与实战
DeL的博客
03-17 1112
Java类加载器体系不仅是JVM的核心机制，更是软件设计原则的完美实践。双亲委派模型通过层级化的责任划分，完美诠释了“单一职责”与“开闭原则”，在保障安全性的同时实现了灵活扩展。从JDBC的SPI打破委派，到OSGi的动态模块化，每一次技术演进都在平衡“规范”与“突破”的边界。在云原生与动态化趋势下，类加载技术展现出更广阔的应用场景：✅Serverless冷启动优化：通过预加载高频类降低延迟✅微服务多版本共存：类隔离技术实现服务灰度发布✅AOT编译与GraalVM。
Java 类加载机制深度解析
qq_69304031的博客
04-29 1397
如果接口的实现类发生初始化，则接口会在其之前被初始化。
Java反射机制深度解析：方法、实战与底层机制
weixin_49426115的博客
04-08 1097
大家好，我是钢板兽！ 反射作为Java的特性，它不仅是Spring三大特性Ioc、DI、AOP的基础，而且MyBatis、Jackson序列化、rpc远程调用接口都用到了反射机制。 本文将带你系统性地掌握 Java 反射的使用，通过 JSON 反序列化的应用场景了解反射机制在实战中的使用，并通过JVM 底层实现深入剖析反射的底层机制。
Java反射机制深度解析与应用实践
Asuna666w的博客
09-06 1172
反射（Reflection）是Java提供的一种强大的工具，它允许程序在运行时检查或修改类的行为。在运行时分析类的能力（例如，检查类的成员变量、构造函数、方法等）。在运行时访问类的属性和方法（即使这些属性和方法是私有的）。在运行时动态地创建对象实例。在运行时调用任意对象的方法。Java反射机制是Java编程中一个强大而复杂的特性，它提供了在运行时检查、修改和操作类的能力。虽然反射带来了极大的灵活性和动态性，但也伴随着性能开销和安全风险。因此，在使用反射时需要谨慎权衡其利弊。
深入理解Java中的类加载机制
技术研究中心
07-30 1058
类加载机制是Java虚拟机（JVM）中的核心部分，它决定了类的生命周期以及如何将类的字节码加载到内存中。这种模型的核心原则是：一个类加载器在加载类时，会将请求委派给父类加载器，直到启动类加载器。类加载器的层次结构和双亲委派模型使得Java能够实现热部署，即在不重启应用程序的情况下，动态加载或卸载类。类的类加载器以及其父类加载器的信息。通常情况下，应用程序类加载器的父类加载器是扩展类加载器，扩展类加载器的父类加载器是启动类加载器。例如，应用程序类加载器只能加载用户自定义的类，不能加载JDK核心类。
Java类加载机制深度解析：触发类加载的6大场景详解
嗨，欢迎来到我的 CSDN 博客小天地！一名深耕多年的技术发烧友。在这里，我将把日常工作中积累的宝贵经验，从复杂架构设计的精妙之处，到代码优化的实战技巧，毫无保留地分享给大家。
06-21 1134
Java类加载机制深度解析：触发类加载的6大场景详解
Java反射机制深度解析
b123321888的博客
02-25 453
反射（Reflection）是Java语言的一种核心特性，允许程序在运行时（Runtime）动态获取类的元数据（如类名、方法、属性、构造函数等），并能直接操作类或对象的内部属性与方法。通过包中的API，Java程序可以：动态加载类获取类的构造方法、方法、字段等信息调用对象的方法或修改字段值创建对象实例（即使构造方法私有）反射机制绕过了编译时的静态类型检查，使得代码具备更强的灵活性和动态性，但同时也带来了性能开销和安全风险。
Java类加载与反射机制深度解析
了解和掌握Java类加载器与反射机制，能够帮助开发者更好地理解和控制程序的运行过程，提高代码的灵活性和可扩展性。在实际开发中，这两个知识点对于解决复杂问题、优化性能和实现动态功能有着至关重要的作用。
Java反射机制与动态代理技术深度解析
3. **创建代理实例**：使用Proxy类的newProxyInstance方法创建代理实例，这个方法需要三个参数：类加载器、目标接口数组和 InvocationHandler 实例。 动态代理的一些应用场景包括： - **日志记录**：在方法调用...
JAVA反射机制与动态代理深度解析
Class对象的创建是由Java的类加载器（ClassLoader）完成的，这是一个重要的机制，负责将类的字节码从各种来源加载到JVM中。一旦类被加载，它的Class对象就可以用来创建该类的实例。值得注意的是，无论创建多少个类的...
spring-core 资源管理 03 PropertySource 讲解
土司先生的博客
06-30 510
摘要：本文系统介绍了Spring框架中的PropertySource机制，用于统一管理不同来源的配置属性。重点内容包括：1) PropertySource抽象类及其核心方法；2) 多种实现类如MapPropertySource、PropertiesPropertySource等；3) YAML/JSON等特殊格式的处理方式；4) JVM和系统环境变量支持；5) Web应用中的ServletContext/ConfigPropertySource；6) 测试用的MockPropertySource。通过分析源
SpringBoot+MySQL个性化课程推荐系统源码
最新发布
幽络源
06-30 244
的SpringBoot+MySQL个性化课程推荐系统免费Java源码，包含课程管理、用户管理、内容管理等完整功能模块，开箱即用，助力开发学习。
Jenkins Pipeline 与 Python 脚本之间使用环境变量通信
weixin_46903933的博客
06-25 700
本文介绍了Jenkins Pipeline与Python脚本通过环境变量通信的方法。在Jenkinsfile中，通过bat命令设置环境变量（如LATEST_LOG_DIR、BUILD_URL），这些变量可在同一会话的Python脚本中使用os.getenv()读取。文章提供了构造日志链接的示例代码，列出常用Jenkins环境变量，并附上完整流程图。调试建议包括在Jenkins和Python中打印环境变量，以及常见问题排查表（如变量获取失败原因）。该方法适用于构建日志链接并用于钉钉/邮件通知的场景。 （字数：
Java流式处理
阿呆的专栏
06-29 342
在 Java 中，没有直接类似 Python 生成器的语法，但可以通过迭代器（Iterator）和流式处理（如使用或 Reactive Streams）来实现类似生成器的功能。此外，也可以通过和线程的组合实现异步文件解压流。
Java 根据分组key构建合并数据集
南国以南i的博客
06-26 495
Java 根据分组key构建合并数据集
JAVA：JVM 创建对象时，堆会发生抢占吗？
木头
06-26 1081
本文探讨了Java多线程环境下对象创建时的内存分配问题。研究发现，JVM通过TLAB（Thread Local Allocation Buffer）机制有效避免了"堆抢占"现象。TLAB为每个线程分配独立的堆内存区域，使大多数对象分配无需加锁，只有当TLAB耗尽时才需要全局堆分配。通过对比实验发现，开启TLAB时对象分配效率显著高于关闭状态。文中还介绍了指针碰撞、Eden区并发分配等优化机制，建议在常规开发中保持TLAB开启以获得最佳性能。
android实践：canvas文字图片旋转显示
Noodles_ck的博客
06-27 277
问题：如何在手机竖屏模式下将文字/图片旋转显示，即类似横屏方向上显示。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

面朝大海，春不暖，花不开

您的鼓励是我最大的创造动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值