Spring源码-依赖注入

news2024/11/30 15:33:29

核心方法是：populateBean

整体流程：首先进行Spring自带的依赖注入，包括byName和byType，然后进行注解Autowired的注入

1.Spring自带依赖注入byName和byType

核心代码：

int resolvedAutowireMode = mbd.getResolvedAutowireMode();// byName 还是 byType
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    // MutablePropertyValues是PropertyValues具体的实现类
    MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    // Add property values based on autowire by name if applicable.
    if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
        autowireByName(beanName, mbd, bw, newPvs);
    }
    // Add property values based on autowire by type if applicable.
    if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        autowireByType(beanName, mbd, bw, newPvs);
    }
    pvs = newPvs;
}

核心：当bean中只有set方法的时候，即使没有定义属性，也会进行属性注入

入口方法：autowireByName和autowireByType

1.propertyNames = unsatisfiedNonSimpleProperties

拿到可以进行依赖注入的属性名字

在这里包含以下几步：getPropertyDescriptors，从属性描述器拿到属性。属性描述器对应的属性名字是setXXX中的XXX。属性是private并且有get\set方法，那么java就认为他是一个真正的属性；然后依次判断属性是否符合注入的条件，也就是确定该属性是否需要进行注入，!pvs.contains，!isSimpleProperty。

注意：byName和byType不支持简单类型的注入，比如Number、Date；@Autowired支持简单类型注入。

简单类型如下：

public static boolean isSimpleValueType(Class<?> type) {
    return (Void.class != type && void.class != type &&
    (ClassUtils.isPrimitiveOrWrapper(type) ||
     Enum.class.isAssignableFrom(type) ||
     CharSequence.class.isAssignableFrom(type) ||
     Number.class.isAssignableFrom(type) ||
     Date.class.isAssignableFrom(type) ||
     Temporal.class.isAssignableFrom(type) ||
     URI.class == type ||
     URL.class == type ||
     Locale.class == type ||
     Class.class == type));
}

2.bean = getBean(propertyName)

依据属性name去找到bean

3.pvs.add(propertyName, bean)

存放依赖的bean，还没有真正赋值，赋值在Autowired注入之后。(而Autowired会直接注入)

4.registerDependentBean

记录一下propertyName对应的Bean被beanName给依赖了（注入关系）

在Autowired注入完成后，调用applyPropertyValues进行属性赋值，它会把字段Autowired注入的值覆盖，而不会覆盖方法的值，因为方法的值在注入的时候进行了判断。

2.处理Autowired注解

1）首先找到注入点，通过反射找到字段以及方法是否加了@Autowired注解和@Value注解和Inject注解，如果加了，则是注入点；

2）然后开始注入属性。

方法入口：filterPropertyDescriptorsForDependencyCheck

使用的核心类：AutowiredAnnotationBeanPostProcessor

两个核心方法：postProcessMergedBeanDefinition（先执行）、postProcessProperties（后执行）

if (hasInstAwareBpps) {
    if (pvs == null) {
        pvs = mbd.getPropertyValues();// 在这之前 我已经通过beanDefinition的方式进行属性赋值了
    }
    for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
        // 这里会调用AutowiredAnnotationBeanPostProcessor的postProcessProperties()方法，会直接给对象中的属性赋值
        // AutowiredAnnotationBeanPostProcessor内部并不会处理pvs，直接返回了
        PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
        if (pvsToUse == null) {
            if (filteredPds == null) {
                // 处理Autowired注解
                filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            }
            // 过期方法 不用了
            pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
                return;
            }
        }
        pvs = pvsToUse;
    }
}

2.1postProcessMergedBeanDefinition的执行流程

核心方法：findAutowiringMetadata

作用：寻找注入点

1.如果一个Bean的类型是String...，那么则根本不需要进行依赖注入（以java.开头的类）

2.找字段上是否存在@Autowired注解和@Value注解和Inject注解

static filed（静态属性）不是注入点，不会进行自动注入。（因为如果注入的bean是原型的，那么会导致静态属性被多次注入）

3.determineRequiredStatus

@Autowired(required = false)，查看required字段，是否必须注入（默认为true）

4.currElements.add(new AutowiredFieldElement(field, required))

将找到的注入点的字段加到这个集合中

5.遍历所有方法是否存在@Autowired、@Value、@Inject中的其中一个

静态方法不能被注入。如果方法的入参数量为0，会打印日志，如果该方法加了@Autowired注解，他就是注入点。入参就是需要注入的对象

if (method.getParameterCount() == 0) {
    if (logger.isInfoEnabled()) {
        logger.info("Autowired annotation should only be used on methods with parameters: " +
                    method);
    }
}

6.bridgedMethod

把桥接方法过滤掉（带泛型的方法）

(产生桥接方法的场景：一个子类在继承（或实现）一个父类（或接口）的泛型方法时，在子类中明确指定了泛型类型，那么在编译时编译器会自动生成桥接方法)

7.currElements.add

注入点的方法添加到集合中

8.InjectionMetadata.forElements(elements, clazz)

最终封装成这个对象，并进行缓存

2.2postProcessProperties的执行流程

作用：属性注入

1.findAutowiringMetadata-->injectionMetadataCache.get

此时就能从缓存中拿出来注入点了

2.inject

点进来默认的inject方法是处理@Resource的

要去找它的子类实现的方法，分别是字段AutowiredFieldElementh和方法AutowiredMethodElement。

其中：在方法中会判断checkPropertySkipping，如果pvs中有值，则跳过注入。（存在Spring自动注入的情况，也就是byName和byType）

注意：@Autowired先进行注入，然后进行set方法的注入。（程序员的赋值会覆盖spring自动的注入）

// 如果当前Bean中的BeanDefinition中设置了PropertyValues，那么最终将是PropertyValues中的值，覆盖@Autowired
if (pvs != null) {
    applyPropertyValues(beanName, mbd, bw, pvs);
}

3.resolveFieldValue

根据filed从BeanFactory中查到的匹配的Bean对象

4.field.set

反射给filed赋值(也就是属性注入)

3.Spring具体注入流程

调用顺序：postProcessProperties-->metadata.inject-->inject

注入分为两种类型：Field和Method（字段和方法）

resolveFieldValue：根据filed从BeanFactory中查到的匹配的Bean对象，然后调用resolveDependency注入

resolveMethodArguments：根据参数信息构造依赖描述符，然后去找Bean，然后调用resolveDependency注入

核心方法是DefaultListableBeanFactory#resolveDependency。

3.1 六种筛选逻辑

在byType到byName之间发生了6层筛选！

1.属性判断，bd中的属性

2.泛型判断

3.@Qualifier注解判断（用处：可以实现不同负载均衡的策略）

4.primary判断

5.优先级priority最高的判断

6.name判断

3.2 resolveDependency

1.initParameterNameDiscovery

初始化用来获取方法入参名字的发现器。（反射和字节码分析两种方式）

两种方法： 1.StandardReflectionParameterNameDiscoverer 反射（1.8+）； 2.LocalVariableTableParameterNameDiscoverer ASM分析.class文件

2.进入不同的不同if分支

3.所需要的类型是Optional

4.所需要的的类型是ObjectFactory，或ObjectProvider

5.else分支，result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary

其他类型，一般我们定义的都会进到这个分支。判断字段或者入参是否加了@Lazy注解。

如果加了@Lazy注解，就调用buildLazyResolutionProxy生成代理对象。(@Lazy可以写到类上，属性上)

说明：当用到代理对象的时候，才会用它去找到真正的bean，执行对应的方法

6.doResolveDependency，下面的方法都属于这个方法

7.去缓存拿依赖关系

8.处理@Value注解

8.1首先，getAutowireCandidateResolver().getSuggestedValue：获取@Value所指定的值；

8.2然后，进行占位符填充(${})，去Environment找对应key的value（如果没有找到key，则直接赋值给orderService，如果类型不同，要看存不存在对应的类型转换器，比如将String转化为OrderService的类型转换器）。

8.3然后，evaluateBeanDefinitionString：解析Spring表达式(#{})，也就是去Spring容器找对应名字的bean；

8.4最后，converter.convertIfNecessary(value, type）：将找到的bean进行类型匹配或者转换，需要看对应的类型转换器存不存在

后面就是处理@Autowired注解（先byType，后byName）

9.resolveMultipleBeans

处理集合或者Map的bean，如果是map，则要求key必须是String类型，为bean的名字；如果是Collection，也可以。

如果集合的类型为T，则直接抛出异常；如果为Object，则会找出来所有的bean

10.findAutowireCandidates（进行bean的筛选），第二小节详细讲这部分代码！

找到所有Bean，key是beanName, value有可能是bean对象，也有可能是beanClass，放到Map中。

Map<String, Object> matchingBeans = findAutowireCandidates

// 找到所有Bean，key是beanName, value有可能是bean对象，有可能是beanClass
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
    // required为true，抛异常
    if (isRequired(descriptor)) {
        raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
    }
    return null;
}

11.如果找到了一个bean，其就直接成为候选bean

12.如果找到了多个bean，需要继续筛选determineAutowireCandidate

筛选结果：筛选完后，要么有一个，要么有0个。（里面有控制，多于1个抛异常）

过程：

1)determinePrimaryCandidate：判断候选Bean有没有primary字段，如果存在@primary，就不要继续进行name匹配了。直接将找到的bean作为候选bean。

@Nullable
protected String determinePrimaryCandidate(Map<String, Object> candidates, Class<?> requiredType) {
    String primaryBeanName = null;
    for (Map.Entry<String, Object> entry : candidates.entrySet()) {
        String candidateBeanName = entry.getKey();
        Object beanInstance = entry.getValue();
        if (isPrimary(candidateBeanName, beanInstance)) {//
            if (primaryBeanName != null) {
                boolean candidateLocal = containsBeanDefinition(candidateBeanName);
                boolean primaryLocal = containsBeanDefinition(primaryBeanName);
                if (candidateLocal && primaryLocal) {
                    throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(),
                                                              "more than one 'primary' bean found among candidates: " + candidates.keySet());
                }
                else if (candidateLocal) {
                    primaryBeanName = candidateBeanName;
                }
            }
            else {
                primaryBeanName = candidateBeanName;
            }
        }
    }
    return primaryBeanName;
}

2)determineHighestPriorityCandidate：处理@Priority注解。取优先级最高的Bean，如果优先级相同，则抛异常。

但是@Priority注解不能写在方法上，得按下面的方法使用

3)matchesBeanName：判断候选bean的name和我需要的name是否相同（name匹配）。

// Fallback
// 匹配descriptor的名字，要么是字段的名字，要么是set方法入参的名字
for (Map.Entry<String, Object> entry : candidates.entrySet()) {
    String candidateName = entry.getKey();
    Object beanInstance = entry.getValue();

    // resolvableDependencies记录了某个类型对应某个Bean，启动Spring时会进行设置，比如BeanFactory.class对应BeanFactory实例
    // 注意：如果是Spring自己的byType，descriptor.getDependencyName()将返回空，只有是@Autowired才会方法属性名或方法参数名
    if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
        matchesBeanName(candidateName, descriptor.getDependencyName())) {
        return candidateName;
    }
}

13.resolveCandidate

有可能筛选出来的是某个bean的类型Class，此处就进行实例化，调用getBean

14.找到的bean是NullBean，抛异常

3.3 findAutowireCandidates

基于类型去找候选Bean，找到的bean可能有多个

1.String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors

从自己的BeanFactory中根据类型找bean的名字，也要去父BeanFactory找bean，然后合并找到的beanName

其中调用getBeanNamesForType，将找到的结果存到两个Map中，

Map<Class<?>, String[]> allBeanNamesByType 存放所有bean，Map<Class<?>

String[]> singletonBeanNamesByType 存放单例bean。

注意：在创建FactoryBean的时候，重写了getObjectType方法，这个方法用于告诉bean的类型是什么，getObject此时不用被调用。可以减少创建bean的数量

2.去resolvableDependencies找，看有没有符合情况的bean(在工厂启动的时候，会向这个map存放bean，也可以手动加入bean)

Map<Class<?>, Object> resolvableDependencies是额外存放bean的地方，在Spring启动的时候就会往里面放一些bean

Map：某个类型对应的Bean对象

3.将找到的beanName放到result

4.继续筛选。isSelfReference：判断是不是自己，找到多个bean，优先注入别人。如果别的bean都不符合条件，最后选择注入自己。

5.isAutowireCandidate

责任链模式，涉及三个主要的类，分别是：QualifierAnnotationAutowireCandidateResolver（判断@Qualifier注解）；GenericTypeAwareAutowireCandidateResolver（判断泛型）；SimpleAutowireCandidateResolver（判断属性是否为true/false）

包含三种筛选：1.属性判断(autowireCandidate)；2.泛型判断；3.@Qualifier注解判断

筛选的顺序（父类来判断该bean是否能依赖注入）：SimpleAutowireCandidateResolver(属性判断)--> GenericTypeAwareAutowireCandidateResolver（泛型）--> QualifierAnnotationAutowireCandidateResolver（@Qualifier）

@Qualifier，限定词，找到相同的限定词。可以用来实现分组，用于切换不同的负载均衡算法

3.4 为什么缓存的是BeanName呢

因为如果是原型bean，那么每次注入的时候都应该是不同的bean，缓存name保证了每次注入都通过beanName去创建一个新的bean用来注入。

3.5 @Resource的工作原理

先byName，再byType

(如果根据name找不到bean，就根据type去找)

也是先找注入点，然后注入

它的inject在父类中

注入点对象为ResourceElement

使用@Resource时没有指定具体的name，那么则用field的name，或setXxx()中的xxx

@Override
protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
    return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :
            getResource(this, requestingBeanName));
}

buildLazyResourceProxy：如果加了@Lazy注解，那就直接生成一个代理对象，返回；

getResource->autowireResource：如果没加@Lazy注解，

假设@Resource中没有指定name，并且field的name或setXxx()的xxx不存在对应的bean，那么则根据field类型或方法参数类型从BeanFactory去找

// 假设@Resource中没有指定name，并且field的name或setXxx()的xxx不存在对应的bean，那么则根据field类型或方法参数类型从BeanFactory去找
if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
    autowiredBeanNames = new LinkedHashSet<>();
    resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);// 根据属性的类型去找
    if (resource == null) {
        throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
    }
}
else {
    resource = beanFactory.resolveBeanByName(name, descriptor);// 根据name去getBean
    autowiredBeanNames = Collections.singleton(name);
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2191585.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C++ | Leetcode C++题解之第459题重复的子字符串

C++ | Leetcode C++题解之第459题重复的子字符串

题目&#xff1a; 题解&#xff1a; class Solution { public:bool kmp(const string& query, const string& pattern) {int n query.size();int m pattern.size();vector<int> fail(m, -1);for (int i 1; i < m; i) {int j fail[i - 1];while (j ! -1 &…
阅读更多...
【星汇极客】手把手教学STM32 HAL库+FreeRTOS之任务管理（2）

【星汇极客】手把手教学STM32 HAL库+FreeRTOS之任务管理（2）

前言 本人是一名嵌入式学习者&#xff0c;在大学期间也参加了不少的竞赛并获奖&#xff0c;包括但不限于&#xff1a;江苏省电子设计竞赛省一、睿抗机器人国二、中国高校智能机器人国二、嵌入式设计竞赛国三、光电设计竞赛国三、节能减排竞赛国三。 后面会经常写一下博客&…
阅读更多...
Spring Boot与iTextPdf：高效生成PDF文件预览

Spring Boot与iTextPdf：高效生成PDF文件预览

​ 博客主页: 南来_北往 系列专栏&#xff1a;Spring Boot实战 在现代应用程序开发中&#xff0c;生成PDF文件是一个常见的需求。PDF文件因其跨平台性和易读性&#xff0c;被广泛应用于文档交换、报告生成和打印预览等场景。Spring Boot作为一个用于简化Spring应用开发的框…
阅读更多...
华为OD机试 - 几何平均值最大子数（Python/JS/C/C++ 2024 E卷 200分）

华为OD机试 - 几何平均值最大子数（Python/JS/C/C++ 2024 E卷 200分）

华为OD机试 2024E卷题库疯狂收录中&#xff0c;刷题点这里 专栏导读 本专栏收录于《华为OD机试真题&#xff08;Python/JS/C/C&#xff09;》。 刷的越多&#xff0c;抽中的概率越大&#xff0c;私信哪吒&#xff0c;备注华为OD&#xff0c;加入华为OD刷题交流群&#xff0c;…
阅读更多...
uniapp固定document.title标题

uniapp固定document.title标题

由于业务中需要将h5的标题固定 但是uniapp没有对应的接口 所以使用Object.defineProperty拦截set方法来实现 代码也很简单 在App.vue的onLaunch加上就行了 onLaunch: function() {document.title 固定标题;Object.defineProperty(document, title, {set() {return false;}});…
阅读更多...
USB 3.0？USB 3.1？USB 3.2？怎么区分？

USB 3.0？USB 3.1？USB 3.2？怎么区分？

还记得小白刚接触电脑的时候&#xff0c;电脑普及的USB接口大部分是USB 2.0&#xff0c;还有少部分USB 1.0的&#xff08;现在基本上找不到了&#xff09;。 当时的电脑显示器&#xff0c;可能00后的小伙伴都没见过&#xff0c;它们大概长这样&#xff1a; 当时小白以为电脑最…
阅读更多...
C++ 算法学习——1.6 差分算法与二维差分算法

C++ 算法学习——1.6 差分算法与二维差分算法

一维差分算法概述&#xff1a; 差分算法是一种用于计算序列中相邻元素之间差值的技术。在C中&#xff0c;STL&#xff08;标准模板库&#xff09;提供了std::adjacent_difference函数来实现差分算法。 std::adjacent_difference函数&#xff1a; std::adjacent_difference函数位…
阅读更多...
基于MindSpore实现CycleGAN壁画修复

基于MindSpore实现CycleGAN壁画修复

基于MindSpore实现CycleGAN壁画修复_哔哩哔哩_bilibili 本案例运行需要较大内存&#xff0c;建议在Ascend/GPU上运行。 模型介绍 模型简介 CycleGAN(Cycle Generative Adversarial Network) 即循环对抗生成网络&#xff0c;来自论文 Unpaired Image-to-Image Translation us…
阅读更多...
指针赋值or常数赋值

指针赋值or常数赋值

int main (){int a 10;int b ;b a;int *c &a;int *d c; } 常数 a,b赋值&#xff1a; 都是将存储的值&#xff08;10&#xff09;赋值给别人。 指针赋值也是类似的&#xff1a; 指针存储的值&#xff08;&a&#xff09;为地址&#xff0c;就是把c指向的地址赋值给…
阅读更多...
C语言 | Leetcode C语言题解之第458题可怜的小猪

C语言 | Leetcode C语言题解之第458题可怜的小猪

题目&#xff1a; 题解&#xff1a; int poorPigs(int buckets, int minutesToDie, int minutesToTest){int base minutesToTest / minutesToDie 1;int pigs ceil(log(buckets)/log(base));return pigs; }
阅读更多...
24-10-2-读书笔记（二十二）-《契诃夫文集》（一）上（[俄] 契诃夫 [译] 汝龙）啊！真想生活。

24-10-2-读书笔记（二十二）-《契诃夫文集》（一）上（[俄] 契诃夫 [译] 汝龙）啊！真想生活。

文章目录 《契诃夫文集》&#xff08;一&#xff09;上&#xff08;[俄] 契诃夫 [译] 汝龙 &#xff09;早期生活——塔甘罗格&#xff08;人物家庭简介&#xff09;学生时期——莫斯科&#xff08;写作与学习&#xff09;流浪时期——哈萨林&#xff08;游历与流浪&#xff09…
阅读更多...
VCSEL驱动电路

VCSEL驱动电路

1.1 驱动电路 发射端可用MOS管控制VCSEL二极管负极方式发出脉冲光(正极对地)&#xff0c;具体作用过程如下&#xff1a; Step 1: MOS管断开, C2 电容充电(左侧HV)&#xff1b; Step 2: 信号控制MOS管打开&#xff1b; Step 3: MOS管打开后, C2电容左侧电压降为0V, 右侧变为…
阅读更多...
当你系统有多个模块的时候，要设计统一入口页了。

当你系统有多个模块的时候，要设计统一入口页了。

本次给大家带来一批系统统一入口页的界面&#xff0c;这次都是科技感十足的界面。入口页将所有系统集中展示出来&#xff0c;并辅以其他设计元素进行氛围烘托&#xff0c;别看简单&#xff0c;但真的不好设计。
阅读更多...
免费送源码：Java+B/S+MySQL 基于springboot网上书店管理系统 计算机毕业设计原创定制

免费送源码：Java+B/S+MySQL 基于springboot网上书店管理系统 计算机毕业设计原创定制

基于springboot网上书店管理系统 摘 要 网上书店管理系统采用B/S结构、java开发语言、以及Mysql数据库等技术。系统主要分为管理员和用户两部分&#xff0c;管理员管理主要功能包括&#xff1a;首页、网站管理&#xff08;轮播图、网站公告&#xff09;人员管理&#xff08;管…
阅读更多...
MATLAB - 机械臂手眼标定（眼在手内） - 估计安装在机器人上的移动相机的姿态

MATLAB - 机械臂手眼标定（眼在手内） - 估计安装在机器人上的移动相机的姿态

系列文章目录 前言 本示例展示了如何为装有手眼构型摄像头的机械臂或机械手执行和验证手眼校准。 一、概述 执行手眼校准有助于操作配备末端执行器&#xff08;简称 “手”&#xff09;的机械臂&#xff0c;该末端执行器依赖于摄像头提供的视觉数据。一旦完成了眼在手外的校准&…
阅读更多...
数据结构阶段测试2的一点小补充

数据结构阶段测试2的一点小补充

数据结构阶段测试2的一点小补充 1.已知⼩根堆为8,15,10,21,34,16,12&#xff0c;删除关键字8之后需重建堆&#xff0c;最后的叶⼦ 节点为() A. 34 B. 21 C. 16 D. 12 解题思路 向下调整算法删除堆顶元素 &#x1f4a1; 答案&#xff1a;C 删除堆顶元素的思路&#xff1a; …
阅读更多...
环境对象刺激，recordnunber，记忆柱，记忆柱群，主注意对象，目的对象，状态中枢，奖惩预期，思维等等之间的联系

环境对象刺激，recordnunber，记忆柱，记忆柱群，主注意对象，目的对象，状态中枢，奖惩预期，思维等等之间的联系

我们清醒状态下&#xff0c;随时都有目的&#xff0c;目的控制影响着我们思想行为的方向。目的是用对象来表征的&#xff08;目的对象&#xff09;&#xff0c;对象之所以能够表征目的&#xff0c;是因为对象能够被&#xff08;状态性&#xff09;赋值&#xff08;任何赋值都是…
阅读更多...
UE4 材质学习笔记03（翻书（Flipbook）动画/环境混合）

UE4 材质学习笔记03（翻书（Flipbook）动画/环境混合）

一.FlipBook Animation 如果你想让游戏以每秒30帧的速度运行&#xff0c;所有内容都必须在33毫秒内渲染出来&#xff0c; 如果你想让游戏以每秒60帧的速度运行的话&#xff0c;必须在16毫秒内。 所以当一个效果需要很多细节的时候&#xff0c;往往会离线创建它&#xff0c;然…
阅读更多...
【Qt】控件概述（4）—— 输出类控件

【Qt】控件概述（4）—— 输出类控件

输出类控件 1. QLineEdit——单行输入框2. QTextEdit——多行输入框3. QComboBox——下拉框4. QSpinBox——微调框5. QDateEdit && QTimeEdit && QDateTimeEdit6 QDial——旋钮7. QSlider——滑动条 1. QLineEdit——单行输入框 QLineEdit是一个单行的输入框&…
阅读更多...
BUU刷题-Pwn-shanghai2018_baby_arm(ARM_ROP_csu_init,ARM架构入门)

BUU刷题-Pwn-shanghai2018_baby_arm(ARM_ROP_csu_init,ARM架构入门)

解题思路&#xff1a; 泄露或修改内存数据&#xff1a; 堆地址&#xff1a;无需栈地址&#xff1a;无需libc地址&#xff1a;无需BSS段地址&#xff1a;无需 劫持程序执行流程&#xff1a;ARM_ROP && mprotect函数(运行内存权限修改) && [[ARM_ROP_csu_init]…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023