Spring源码解析——IOC属性填充

正文

doCreateBean() 主要用于完成 bean 的创建和初始化工作，我们可以将其分为四个过程：

最全面的Java面试网站

  • createBeanInstance() 实例化 bean
  • populateBean() 属性填充
  • 循环依赖的处理
  • initializeBean() 初始化 bean

第一个过程实例化 bean在前面一篇博客中已经分析完了，这篇博客开始分析 属性填充，也就是 populateBean()

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {  PropertyValues pvs = mbd.getPropertyValues();  if (bw == null) {  if (!pvs.isEmpty()) {  throw new BeanCreationException(  mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");  }  else {  // Skip property population phase for null instance.  return;  }  }  // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the  // state of the bean before properties are set. This can be used, for example,  // to support styles of field injection.  boolean continueWithPropertyPopulation = true;  if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {  for (BeanPostProcessor bp : getBeanPostProcessors()) {  if (bp instanceof InstantiationAwareBeanPostProcessor) {  InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;  //返回值为是否继续填充bean  if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {  continueWithPropertyPopulation = false;  break;  }  }  }  }  //如果后处理器发出停止填充命令则终止后续的执行  if (!continueWithPropertyPopulation) {  return;  }  if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||  mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {  MutablePropertyValues newPvs = new MutablePropertyValues(pvs);  // Add property values based on autowire by name if applicable.  //根据名称自动注入  if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {  autowireByName(beanName, mbd, bw, newPvs);  }  // Add property values based on autowire by type if applicable.  //根据类型自动注入  if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {  autowireByType(beanName, mbd, bw, newPvs);  }  pvs = newPvs;  }  //后处理器已经初始化  boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();  //需要依赖检查  boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);  if (hasInstAwareBpps || needsDepCheck) {  PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);  if (hasInstAwareBpps) {  for (BeanPostProcessor bp : getBeanPostProcessors()) {  if (bp instanceof InstantiationAwareBeanPostProcessor) {  InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;  //对所有需要依赖检查的属性进行后处理  pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);  if (pvs == null) {  return;  }  }  }  }  if (needsDepCheck) {  //依赖检查，对应depends-on属性，3.0已经弃用此属性  checkDependencies(beanName, mbd, filteredPds, pvs);  }  }  //将属性应用到bean中  //将所有ProtertyValues中的属性填充至BeanWrapper中。  applyPropertyValues(beanName, mbd, bw, pvs);  
}

我们来分析下populateBean的流程：

（1）首先进行属性是否为空的判断

（2）通过调用InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)方法来控制程序是否继续进行属性填充

（3）根据注入类型（byName/byType）提取依赖的bean，并统一存入PropertyValues中

（4）应用InstantiationAwareBeanPostProcessor的postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName)方法，对属性获取完毕填充前的再次处理，典型的应用是RequiredAnnotationBeanPostProcesser类中对属性的验证

（5）将所有的PropertyValues中的属性填充至BeanWrapper中

上面步骤中有几个地方是我们比较感兴趣的，它们分别是依赖注入（autowireByName/autowireByType）以及属性填充，接下来进一步分析这几个功能的实现细节

分享一份大彬精心整理的大厂面试手册，包含计算机基础、Java基础、多线程、JVM、数据库、Redis、Spring、Mybatis、SpringMVC、SpringBoot、分布式、微服务、设计模式、架构、校招社招分享等高频面试题，非常实用，有小伙伴靠着这份手册拿过字节offer~

需要的小伙伴可以自行下载：

http://mp.weixin.qq.com/s?__biz=Mzg2OTY1NzY0MQ==&mid=2247485445&idx=1&sn=1c6e224b9bb3da457f5ee03894493dbc&chksm=ce98f543f9ef7c55325e3bf336607a370935a6c78dbb68cf86e59f5d68f4c51d175365a189f8#rd

自动注入

Spring 会根据注入类型（ byName / byType ）的不同，调用不同的方法（autowireByName() / autowireByType()）来注入属性值。

autowireByName()

protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {// 获取 Bean 对象中非简单属性String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);for (String propertyName : propertyNames) {// 如果容器中包含指定名称的 bean，则将该 bean 注入到 bean中if (containsBean(propertyName)) {// 递归初始化相关 beanObject bean = getBean(propertyName);// 为指定名称的属性赋予属性值  pvs.add(propertyName, bean);// 属性依赖注入registerDependentBean(propertyName, beanName);if (logger.isDebugEnabled()) {logger.debug("Added autowiring by name from bean name '" + beanName +"' via property '" + propertyName + "' to bean named '" + propertyName + "'");}}else {if (logger.isTraceEnabled()) {logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +"' by name: no matching bean found");}}}
}

该方法逻辑很简单，获取该 bean 的非简单属性，什么叫做非简单属性呢？就是类型为对象类型的属性，但是这里并不是将所有的对象类型都都会找到，比如 8 个原始类型，String 类型 ，Number类型、Date类型、URL类型、URI类型等都会被忽略，如下：

protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {Set<String> result = new TreeSet<>();PropertyValues pvs = mbd.getPropertyValues();PropertyDescriptor[] pds = bw.getPropertyDescriptors();for (PropertyDescriptor pd : pds) {if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&!BeanUtils.isSimpleProperty(pd.getPropertyType())) {result.add(pd.getName());}}return StringUtils.toStringArray(result);
}

这里获取的就是需要依赖注入的属性。

autowireByName()函数的功能就是根据传入的参数中的pvs中找出已经加载的bean，并递归实例化，然后加入到pvs中

autowireByType

autowireByType与autowireByName对于我们理解与使用来说复杂程度相似，但是实现功能的复杂度却不一样，我们看下方法代码：

protected void autowireByType(  String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {  TypeConverter converter = getCustomTypeConverter();  if (converter == null) {  converter = bw;  }  Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);  //寻找bw中需要依赖注入的属性  String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);  for (String propertyName : propertyNames) {  try {  PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);  // Don't try autowiring by type for type Object: never makes sense,  // even if it technically is a unsatisfied, non-simple property.  if (!Object.class.equals(pd.getPropertyType())) {  //探测指定属性的set方法  MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);  // Do not allow eager init for type matching in case of a prioritized post-processor.  boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());  DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);  //解析指定beanName的属性所匹配的值，并把解析到的属性名称存储在autowiredBeanNames中，  Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);  if (autowiredArgument != null) {  pvs.add(propertyName, autowiredArgument);  }  for (String autowiredBeanName : autowiredBeanNames) {  //注册依赖  registerDependentBean(autowiredBeanName, beanName);  if (logger.isDebugEnabled()) {  logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +  propertyName + "' to bean named '" + autowiredBeanName + "'");  }  }  autowiredBeanNames.clear();  }  }  catch (BeansException ex) {  throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);  }  }  
}

根据名称第一步与根据属性第一步都是寻找bw中需要依赖注入的属性，然后遍历这些属性并寻找类型匹配的bean,其中最复杂就是寻找类型匹配的bean。spring中提供了对集合的类型注入支持，如使用如下注解方式：

@Autowired
private List<Test> tests;

这种方式spring会把所有与Test匹配的类型找出来并注入到tests属性中，正是由于这一因素，所以在autowireByType函数，新建了局部遍历autowireBeanNames，用于存储所有依赖的bean，如果只是对非集合类的属性注入来说，此属性并无用处。

对于寻找类型匹配的逻辑实现是封装在了resolveDependency函数中，其实现如下：

public Object resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());  if (descriptor.getDependencyType().equals(ObjectFactory.class)) {  //ObjectFactory类注入的特殊处理  return new DependencyObjectFactory(descriptor, beanName);  }  else if (descriptor.getDependencyType().equals(javaxInjectProviderClass)) {  //javaxInjectProviderClass类注入的特殊处理  return new DependencyProviderFactory().createDependencyProvider(descriptor, beanName);  }  else {  //通用处理逻辑  return doResolveDependency(descriptor, descriptor.getDependencyType(), beanName, autowiredBeanNames, typeConverter);  }  
}  protected Object doResolveDependency(DependencyDescriptor descriptor, Class<?> type, String beanName,  Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {  /* * 用于支持Spring中新增的注解@Value */  Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);  if (value != null) {  if (value instanceof String) {  String strVal = resolveEmbeddedValue((String) value);  BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);  value = evaluateBeanDefinitionString(strVal, bd);  }  TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());  return (descriptor.getField() != null ?  converter.convertIfNecessary(value, type, descriptor.getField()) :  converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));  }  //如果解析器没有成功解析，则需要考虑各种情况  //属性是数组类型  if (type.isArray()) {  Class<?> componentType = type.getComponentType();  //根据属性类型找到beanFactory中所有类型的匹配bean，  //返回值的构成为：key=匹配的beanName,value=beanName对应的实例化后的bean（通过getBean(beanName)返回）  Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);  if (matchingBeans.isEmpty()) {  //如果autowire的require属性为true而找到的匹配项却为空则只能抛出异常  if (descriptor.isRequired()) {  raiseNoSuchBeanDefinitionException(componentType, "array of " + componentType.getName(), descriptor);  }  return null;  }  if (autowiredBeanNames != null) {  autowiredBeanNames.addAll(matchingBeans.keySet());  }  TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());  //通过转换器将bean的值转换为对应的type类型  return converter.convertIfNecessary(matchingBeans.values(), type);  }  //属性是Collection类型  else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {  Class<?> elementType = descriptor.getCollectionType();  if (elementType == null) {  if (descriptor.isRequired()) {  throw new FatalBeanException("No element type declared for collection [" + type.getName() + "]");  }  return null;  }  Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType, descriptor);  if (matchingBeans.isEmpty()) {  if (descriptor.isRequired()) {  raiseNoSuchBeanDefinitionException(elementType, "collection of " + elementType.getName(), descriptor);  }  return null;  }  if (autowiredBeanNames != null) {  autowiredBeanNames.addAll(matchingBeans.keySet());  }  TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());  return converter.convertIfNecessary(matchingBeans.values(), type);  }  //属性是Map类型  else if (Map.class.isAssignableFrom(type) && type.isInterface()) {  Class<?> keyType = descriptor.getMapKeyType();  if (keyType == null || !String.class.isAssignableFrom(keyType)) {  if (descriptor.isRequired()) {  throw new FatalBeanException("Key type [" + keyType + "] of map [" + type.getName() +  "] must be assignable to [java.lang.String]");  }  return null;  }  Class<?> valueType = descriptor.getMapValueType();  if (valueType == null) {  if (descriptor.isRequired()) {  throw new FatalBeanException("No value type declared for map [" + type.getName() + "]");  }  return null;  }  Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType, descriptor);  if (matchingBeans.isEmpty()) {  if (descriptor.isRequired()) {  raiseNoSuchBeanDefinitionException(valueType, "map with value type " + valueType.getName(), descriptor);  }  return null;  }  if (autowiredBeanNames != null) {  autowiredBeanNames.addAll(matchingBeans.keySet());  }  return matchingBeans;  }  else {  Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);  if (matchingBeans.isEmpty()) {  if (descriptor.isRequired()) {  raiseNoSuchBeanDefinitionException(type, "", descriptor);  }  return null;  }  if (matchingBeans.size() > 1) {  String primaryBeanName = determinePrimaryCandidate(matchingBeans, descriptor);  if (primaryBeanName == null) {  throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());  }  if (autowiredBeanNames != null) {  autowiredBeanNames.add(primaryBeanName);  }  return matchingBeans.get(primaryBeanName);  }  // We have exactly one match.  Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();  if (autowiredBeanNames != null) {  autowiredBeanNames.add(entry.getKey());  }  //已经确定只有一个匹配项  return entry.getValue();  }  
}

主要就是通过Type从BeanFactory中找到对应的benaName，然后通过getBean获取实例

protected Map<String, Object> findAutowireCandidates(@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {//在BeanFactory找到所有Type类型的beanNameString[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this, requiredType, true, descriptor.isEager());Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);//遍历所有的beanName,通过getBean获取for (String candidate : candidateNames) {if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {//addCandidateEntry(result, candidate, descriptor, requiredType);}}return result;
}private void addCandidateEntry(Map<String, Object> candidates, String candidateName,DependencyDescriptor descriptor, Class<?> requiredType) {Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);if (!(beanInstance instanceof NullBean)) {candidates.put(candidateName, beanInstance);}
}public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)throws BeansException {//通过类型找到beanName,然后再找到其实例return beanFactory.getBean(beanName);
}

applyPropertyValues

程序运行到这里，已经完成了对所有注入属性的获取，但是获取的属性是以PropertyValues形式存在的，还并没有应用到已经实例化的bean中，这一工作是在applyPropertyValues中。继续跟踪到方法体中：

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {  if (pvs == null || pvs.isEmpty()) {  return;  }  MutablePropertyValues mpvs = null;  List<PropertyValue> original;  if (System.getSecurityManager() != null) {  if (bw instanceof BeanWrapperImpl) {  ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());  }  }  if (pvs instanceof MutablePropertyValues) {  mpvs = (MutablePropertyValues) pvs;  //如果mpvs中的值已经被转换为对应的类型那么可以直接设置到beanwapper中  if (mpvs.isConverted()) {  // Shortcut: use the pre-converted values as-is.  try {  bw.setPropertyValues(mpvs);  return;  }  catch (BeansException ex) {  throw new BeanCreationException(  mbd.getResourceDescription(), beanName, "Error setting property values", ex);  }  }  original = mpvs.getPropertyValueList();  }  else {  //如果pvs并不是使用MutablePropertyValues封装的类型，那么直接使用原始的属性获取方法  original = Arrays.asList(pvs.getPropertyValues());  }  TypeConverter converter = getCustomTypeConverter();  if (converter == null) {  converter = bw;  }  //获取对应的解析器  BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);  // Create a deep copy, resolving any references for values.  List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());  boolean resolveNecessary = false;  //遍历属性，将属性转换为对应类的对应属性的类型  for (PropertyValue pv : original) {  if (pv.isConverted()) {  deepCopy.add(pv);  }  else {  String propertyName = pv.getName();  Object originalValue = pv.getValue();  Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);  Object convertedValue = resolvedValue;  boolean convertible = bw.isWritableProperty(propertyName) &&  !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);  if (convertible) {  convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);  }  // Possibly store converted value in merged bean definition,  // in order to avoid re-conversion for every created bean instance.  if (resolvedValue == originalValue) {  if (convertible) {  pv.setConvertedValue(convertedValue);  }  deepCopy.add(pv);  }  else if (convertible && originalValue instanceof TypedStringValue &&  !((TypedStringValue) originalValue).isDynamic() &&  !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {  pv.setConvertedValue(convertedValue);  deepCopy.add(pv);  }  else {  resolveNecessary = true;  deepCopy.add(new PropertyValue(pv, convertedValue));  }  }  }  if (mpvs != null && !resolveNecessary) {  mpvs.setConverted();  }  // Set our (possibly massaged) deep copy.  try {  bw.setPropertyValues(new MutablePropertyValues(deepCopy));  }  catch (BeansException ex) {  throw new BeanCreationException(  mbd.getResourceDescription(), beanName, "Error setting property values", ex);  }  
}

我们来看看具体的属性赋值过程

public class MyTestBean {private String name ;public MyTestBean(String name) {this.name = name;}public MyTestBean() {}public String getName() {return name;}public void setName(String name) {this.name = name;}
}<bean id="myTestBean"  class="dabin.spring01.MyTestBean"><property name="name" value="dabin"></property>
</bean>

如上 bw.setPropertyValues 最终都会走到如下方法

@Override
public void setValue(final @Nullable Object value) throws Exception {//获取writeMethod，也就是我们MyTestBean的setName方法final Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :this.pd.getWriteMethod());if (System.getSecurityManager() != null) {AccessController.doPrivileged((PrivilegedAction<Object>) () -> {ReflectionUtils.makeAccessible(writeMethod);return null;});try {AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->writeMethod.invoke(getWrappedInstance(), value), acc);}catch (PrivilegedActionException ex) {throw ex.getException();}}else {ReflectionUtils.makeAccessible(writeMethod);//通过反射调用方法进行赋值writeMethod.invoke(getWrappedInstance(), value);}
}

就是利用反射进行调用对象的set方法赋值

至此，doCreateBean() 第二个过程：属性填充 已经分析完成了，下篇分析第三个过程：循环依赖的处理，其实循环依赖并不仅仅只是在 doCreateBean() 中处理，其实在整个加载 bean 的过程中都有涉及，所以下篇内容并不仅仅只局限于 doCreateBean()。

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

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

相关文章

卷积层与池化层输出的尺寸的计算公式详解

卷积层与池化层输出的尺寸的计算公式详解

用文字简单表述如下 卷积后尺寸计算公式&#xff1a; (图像尺寸-卷积核尺寸 2*填充值)/步长1 池化后尺寸计算公式&#xff1a; (图像尺寸-池化窗尺寸 2*填充值)/步长1 一、卷积中的相关函数的参数定义如下&#xff1a; in_channels(int) – 输入信号的通道 out_channels(int)…
阅读更多...
Vue3 reactive和ref详解

Vue3 reactive和ref详解

reactive Vue3.0中的reactive reactive 是 Vue3 中提供的实现响应式数据的方法。在 Vue2 中响应式数据是通过 defineProperty 来实现的&#xff0c;在 Vue3 中响应式数据是通过 ES6 的 Proxy来实现的。reactive 参数必须是对象 (json / arr)如果给 reactive 传递了其它对象 默…
阅读更多...
合宙Air780e+luatos+腾讯云物联网平台完成设备通信与控制（属性上报+4G远程点灯）

合宙Air780e+luatos+腾讯云物联网平台完成设备通信与控制（属性上报+4G远程点灯）

1.腾讯云物联网平台 首先需要在腾讯云物联网平台创建产品、创建设备、定义设备属性和行为&#xff0c;例如&#xff1a; &#xff08;1&#xff09;创建产品 &#xff08;2&#xff09;定义设备属性和行为 &#xff08;3&#xff09;创建设备 &#xff08;4&#xff09;准备参…
阅读更多...
【高阶数据结构】图详解第一篇：图的基本概念及其存储结构（邻接矩阵和邻接表）

【高阶数据结构】图详解第一篇：图的基本概念及其存储结构（邻接矩阵和邻接表）

文章目录 1. 图的基本概念1.1 什么是图1.2 有向图和无向图1.3 完全图1.4 邻接顶点1.5 顶点的度1.6 路径1.7 路径长度1.8 简单路径与回路1.9 子图1.10 连通图1.11 强连通图1.12 生成树 2. 图的存储结构2.1 邻接矩阵2.2 邻接矩阵代码实现结构定义构造函数添加边打印图测试 2.3 邻…
阅读更多...
ToBeWritten之改进威胁猎杀：自动化关键角色与成功沟通经验

ToBeWritten之改进威胁猎杀：自动化关键角色与成功沟通经验

也许每个人出生的时候都以为这世界都是为他一个人而存在的&#xff0c;当他发现自己错的时候&#xff0c;他便开始长大 少走了弯路&#xff0c;也就错过了风景&#xff0c;无论如何&#xff0c;感谢经历 转移发布平台通知&#xff1a;将不再在CSDN博客发布新文章&#xff0c;敬…
阅读更多...
10款录屏软分析与选择使用，只看这篇文章就轻松搞定所有，高清4K无水印录屏，博主UP主轻松选择

10款录屏软分析与选择使用，只看这篇文章就轻松搞定所有，高清4K无水印录屏，博主UP主轻松选择

录屏软件整理 如下为录屏软件&#xff0c;通过思维导图展示分析介绍&#xff1a; https://www.drawon.cn/template/details/6522bd5e0dad9029a0b528e1 如下为整理的录屏软件列表 名称产地价格支持的平台下载地址说明OBS国外免费开源windows/linux/machttps://obsproject.co…
阅读更多...
linux 笔记:远程服务器登录jupyter notebook

linux 笔记:远程服务器登录jupyter notebook

1 生成jupyter notebook 配置文件&#xff08;服务器端&#xff09; jupyter notebook --generate-config #Writing default config to: /home/shuailiu/.jupyter/jupyter_notebook_config.py2 Ipython中设置密码&#xff08;服务器端&#xff09; 3 修改jupyter 配置文件&…
阅读更多...
汇编语言是怎么一回事？

汇编语言是怎么一回事？

汇编语言基础 汇编指令和机器码的区别 数据的表示 各类汇编指令 数据传送和算法运算 位运算 条件分支指令 函数调用 字符串处理 流水线和指令调度 流水线实现指令级并行 编译器指令调度 CPU乱序与投机执行 汇编器将汇编语言翻译成 CPU 可以执行的机器码&#xff0c…
阅读更多...
强烈推荐这5款功能强大的小软件

强烈推荐这5款功能强大的小软件

​ 今日的栽种&#xff0c;明日的果实&#xff0c;今天继续分享五个功能强大的小软件。 1.文本编辑——IDM UltraEdit ​ IDM UltraEdit是一款功能强大的文本编辑器&#xff0c;它支持多种编程语言和文件格式&#xff0c;可以处理大型文件&#xff0c;进行代码折叠&#xff0…
阅读更多...
reactjs开发环境搭建

reactjs开发环境搭建

Reactjs是一个前端web页面应用开发框架工具集&#xff0c;其支持前端构建页面以及后端构建页面两种常用的开发场景&#xff0c;其中&#xff0c;支持reactjs的开发框架包括next.js、remix、gatsby以及其他&#xff0c;本文主要描述next.js开发环境的搭建&#xff0c;next.js是一…
阅读更多...
c++中的map和set

c++中的map和set

文章目录 1. 关联式容器2. 键值对3. 树形结构的关联式容器3.1 set3.1.1 set的介绍3.1.2 set的使用 3.2 map3.2.1 map的介绍3.2.2 map的使用 3.3 multiset3.3.1 multiset的介绍3.3.2 multiset的使用 3.4 multimap3.4.1 multimap的介绍3.4.2 multimap的使用 1. 关联式容器 在初阶…
阅读更多...
java socket实现代理Android App

java socket实现代理Android App

实现逻辑就是转发请求和响应。 核心代码 // 启动代理服务器private void startProxyServer() {new Thread(new ProxyServer()).start();}// 代理服务器static class ProxyServer implements Runnable {Overridepublic void run() {try {// 监听指定的端口int port 8098; //一…
阅读更多...
CSS 实现：常见布局

CSS 实现：常见布局

1 设备与视口 设备屏幕尺寸是指屏幕的对角线长度。像素是计算机屏幕能显示一种特定颜色的最小区域&#xff0c;分为设备像素和逻辑像素。 在 Apple 的视网膜屏&#xff08;Retina&#xff09;中&#xff0c;默认每 4 个设备像素为一组&#xff0c;渲染出普通屏幕中一个像素显示…
阅读更多...
HTML5+CSS3+JS小实例：鼠标滚轮水平滚动

HTML5+CSS3+JS小实例：鼠标滚轮水平滚动

实例：鼠标滚轮水平滚动 技术栈：HTML+CSS+JS 效果： 源码： 【html】 <!DOCTYPE html> <html><head><meta http-equiv="content-type" content="text/html; charset=utf-8"><meta name="viewport" content="…
阅读更多...
《游戏编程模式》学习笔记（十二）类型对象 Type Object

《游戏编程模式》学习笔记（十二）类型对象 Type Object

定义 定义类型对象类和有类型的对象类。每个类型对象实例代表一种不同的逻辑类型。 每种有类型的对象保存对描述它类型的类型对象的引用。 定义往往不是人能看懂的&#xff0c;我们需要例子才能够理解。 举例 假设你要为一款游戏制作一些怪物敌人。这些敌人有不同的血量及攻…
阅读更多...
Stable Diffusion云服务器部署完整版教程

Stable Diffusion云服务器部署完整版教程

Stable Diffusion云服务器部署完整版教程 2023年07月04日 22:30 3607浏览 18喜欢 22评论 <span class"bili-avatar-icon bili-avatar-right-icon "></span> </div>薯片_AI 粉丝&#xff1a; 1513 文章&#xff1a; 1 设置分组取消关注 已关注 …
阅读更多...
四位十进制频率计VHDL，DE1开发板验证，仿真和源码

四位十进制频率计VHDL，DE1开发板验证，仿真和源码

名称&#xff1a;四位十进制频率计VHDL&#xff0c;DE1开发板验证 软件&#xff1a;Quartus 语言&#xff1a;VHDL 要求&#xff1a; 数字频率计设计要求 1、四位十进制数字显示的数学式频率计,其频率测量范围为10~9999khz,测量单位为kHz。 2、要求量程能够转换。即测几十…
阅读更多...
CDN体系架构及部署方案探索

CDN体系架构及部署方案探索

如今是科技技术飞速发展的时代&#xff0c;特别是互联网技术在各个方面都得到了质的提升。对于CDN技术来说&#xff0c;该项技术的基本功能、体系构架以及运营部署等方面都取得了长足的发展&#xff0c;不仅技术日新月异&#xff0c;而且整个体系日趋成熟&#xff0c;并且不断朝…
阅读更多...
Tasmota系统之外设配置

Tasmota系统之外设配置

Tasmota系统之外设配置 &#x1f388;相关篇《ESP32/ESP8266在线刷写Sonoff Tasmota固件以及配置简要》&#x1f516;这里以ESP32配置DS18B20温度传感器和dht11温湿度传感器为例。 ✨如果想接特定型号的显示屏幕&#xff0c;需要下载指定的固件&#xff0c;目前官方所提供的固件…
阅读更多...
学计算机Java和c语言哪个出路比较好？

学计算机Java和c语言哪个出路比较好？

学计算机Java和c语言哪个出路比较好&#xff1f; 首先&#xff0c;这两者相比来说&#xff0c;个人更推荐你学习Java。 C比较复杂一些&#xff0c;难学一些。 Java相对于更适合大多数人&#xff0c;适合非高等学府出来的人。 第一、按Java目前的需求来说最近很多小伙伴找我&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023