else高清图片

‘壹’ 以下Python代码else为啥没和if对齐，这里else起什么作用

这个else是跟if里面的for都（py的一个语法）。就是当for循环不是break退出的时候就会运行else的代码

‘贰’ c# 打印里图片这么让png的高清大图按比例缩小，

// <summary>
/// 生成缩略图
/// </summary>
/// <param name="originalImagePath">源图路径（物理路径）</param>
/// <param name="thumbnailPath">缩略图路径（物理路径）</param>
/// <param name="width">缩略图宽度</param>
/// <param name="height">缩略图高度</param>
/// <param name="mode">生成缩略图的方式</param>
public static void MakeThumbnail(string originalImagePath, string thumbnailPath, int width, int height, string mode)
{
System.Drawing.Image originalImage = System.Drawing.Image.FromFile(originalImagePath);
int towidth = width;
int toheight = height;

int x = 0;
int y = 0;
int ow = originalImage.Width;
int oh = originalImage.Height;

switch (mode)
{
case "HW": //指定高宽缩放（可能变形）
break;
case "W": //指定宽，高按比例
toheight = originalImage.Height * width / originalImage.Width;
break;
case "H": //指定高，宽按比例
towidth = originalImage.Width * height / originalImage.Height;
break;
case "Cut": //指定高宽裁减（不变形）
if ((double)originalImage.Width / (double)originalImage.Height > (double)towidth / (double)toheight)
{
oh = originalImage.Height;
ow = originalImage.Height * towidth / toheight;
y = 0;
x = (originalImage.Width - ow) / 2;
}
else
{
ow = originalImage.Width;
oh = originalImage.Width * height / towidth;
x = 0;
y = (originalImage.Height - oh) / 2;
}
break;
default:
break;
}

//新建一个bmp图片
System.Drawing.Image bitmap = new System.Drawing.Bitmap(towidth, toheight);

//新建一个画板
System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(bitmap);

//设置高质量插值法
g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.High;

//设置高质量,低速度呈现平滑程度
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;

//清空画布并以透明背景色填充
g.Clear(System.Drawing.Color.Transparent);

//在指定位置并且按指定大小绘制原图片的指定部分
g.DrawImage(originalImage, new System.Drawing.Rectangle(0, 0, towidth, toheight), new System.Drawing.Rectangle(x, y, ow, oh), System.Drawing.GraphicsUnit.Pixel);

try
{
//以jpg格式保存缩略图
bitmap.Save(thumbnailPath, System.Drawing.Imaging.ImageFormat.Jpeg);
}
catch (System.Exception e)
{
throw e;
}
finally
{
originalImage.Dispose();
bitmap.Dispose();
g.Dispose();
}
}

‘叁’ 跪求这张图片的超清或高清图片 可以做壁纸的那种

提取码:9qa9

‘肆’ 我需要一张单片机最小系统图，黑白清晰的~

给你个程序你看看吧，看不懂那我也没办法了，自己借书看吧

publicsealedclassCRC

{

privatestaticushort[]CRC16Table=null;

privatestaticuint[]CRC32Table=null;

()

{

if(CRC16Table!=null)return;

CRC16Table=newushort[256];

for(ushorti=0;i<256;i++)

{

ushortvCRC=i;

for(intj=0;j<8;j++)

if(vCRC%2==0)

vCRC=(ushort)(vCRC>>1);

elsevCRC=(ushort)((vCRC>>1)^0x8408);

CRC16Table[i]=vCRC;

}

}

//设计ZswangY372007-02-14

()

{

if(CRC32Table!=null)return;

CRC32Table=newuint[256];

for(uinti=0;i<256;i++)

{

uintvCRC=i;

for(intj=0;j<8;j++)

if(vCRC%2==0)

vCRC=(uint)(vCRC>>1);

elsevCRC=(uint)((vCRC>>1)^0xEDB88320);

CRC32Table[i]=vCRC;

}

}

publicstaticushortUpdateCRC16(byteAByte,ushortASeed)

{

return(ushort)(CRC16Table[(ASeed&0x000000FF)^AByte]^(ASeed>>8));

}

publicstaticuintUpdateCRC32(byteAByte,uintASeed)

{

return(uint)(CRC32Table[(ASeed&0x000000FF)^AByte]^(ASeed>>8));

}

publicstaticushortCRC16(byte[]ABytes)

{

MakeCRC16Table();

ushortResult=0xFFFF;

foreach(bytevByteinABytes)

Result=UpdateCRC16(vByte,Result);

return(ushort)(~Result);

}

publicstaticushortCRC16(stringAString,EncodingAEncoding)

{

returnCRC16(AEncoding.GetBytes(AString));

}

publicstaticushortCRC16(stringAString)

{

returnCRC16(AString,Encoding.UTF8);

}

publicstaticuintCRC32(byte[]ABytes)

{

MakeCRC32Table();

uintResult=0xFFFFFFFF;

foreach(bytevByteinABytes)

Result=UpdateCRC32(vByte,Result);

return(uint)(~Result);

}

publicstaticuintCRC32(stringAString,EncodingAEncoding)

{

returnCRC32(AEncoding.GetBytes(AString));

}

publicstaticuintCRC32(stringAString)

{

returnCRC32(AString,Encoding.UTF8);

}

}

‘伍’ c语言的if和else后面的语句怎么回事 我接下来准备在这张图片中的zhekou后面添加一个p

if (condition) AAAAAAAA; else BBBBBB;
ccccc； 直接写就好了，和 elese无关，

但是建议你写成 if (condition) { AAAAAAAA; } else {BBBBBB;} cccccc;

这样，更容易理解

‘陆’ python中else的必须有么

if可以不带else，但这是由逻辑需求决定的。

比如这里，如果你的逻辑是当price小于等于2时输出1、2，其它则输出3，就必须带else。

否则，像你的代码，当price小于等于2时，就会输出：
1
2
3
而这是不符合假设的逻辑需求的。

所以，这里就必须带else。

‘柒’ C语言中，if……else if结构中，可以省略最后的一个else吗如果可以，那是为什么呢如图

带不带else都是语法所容许的，都可以通过编译，然而带和不带并不等效，所以不能称之为省略。

这里的x=-0;这一条语句没有带else，表示它并不受前面的条件控制。

这道题分析的时候，主要利用if不带花括号的情况下只管最近的一条语句这一点，不要被不科学的缩进格式所迷惑。这样简单分析后，不难发现x=-0;根本就没有在任何一层if块内，不管怎样都会执行到。

‘捌’ 求else的Paris的百度云链接

使用网络网盘免费分享给你，链接:https://pan..com/s/12O8kdfEOLokTyZSkF-mN1A

《Paris》是美国纽约电音乐队烟鬼组合（TheChainsmokers）制作、烟鬼组合成员安德鲁·塔格特与美国女歌手EmilyWarren合作录唱的一首电子舞曲[1]，作为TheChainsmokers首张录音室专辑《Memories...DoNotOpen》的首支推广单曲被发行于2017年1月12日。

‘玖’ 能详细地解释下这个if和else起的作用吗

是的没有错，图片中就是俗称的垃圾程序，或者说错误的程序。有些bug也可能是蓄意留下的。
这里代码的本意，应该是要校验起始行终止行是否满足被8整除，如果不能就强行向后面撑满。由于y被重复使用，因此失去了意义。

‘拾’ 有那位大佬能看出来上面的字是什么，或者可以用ps变得清晰一点

一 . 前言

BeanPostProcessor 是 Spring 的核心组件之一 , Bean 实现 BeanPostProcessor 可以实现很多复杂的功能

二 . PostProcessor 的结构 2.1 接口方法

该接口中主要提供了2种 , 其中提供了前置调用和后置调用 . 还可以看到 , 这里通过 default 修饰 , 所以并不是强制重写的

public interface BeanPostProcessor { default Object (Object bean, String beanName) throws BeansException { return bean; } default Object (Object bean, String beanName) throws BeansException { return bean; }}2.2 常见实现类

这里可以看到 , AOP , 定时 , 配置等都实现了相关的集成

三 . Spring 源码深入分析 3.1 使用案例

这一部分来看一下 Spring 内部是如何使用 PostProcessor 特性的 , 这一部分以 为例.

@Overridepublic Object (Object bean, String beanName) { // 可以看到 , 前置处理并没有太多处理 , 直接返回 return bean;}@Overridepublic Object (Object bean, String beanName) { if (bean instanceof AopInfrastructureBean || bean instanceof TaskScheler || bean instanceof ScheledExecutorService) { // Ignore AOP infrastructure such as scoped proxies. return bean; } // Step 1 : 开始特殊处理 Class targetClass = AopProxyUtils.ultimateTargetClass(bean); if (!this.nonAnnotatedClasses.contains(targetClass) && AnnotationUtils.isCandidateClass(targetClass, Arrays.asList(Scheled.class, Scheles.class))) { // Step 2 : 获取 Method 对应 Scheled 的集合 Map> annotatedMethods = MethodIntrospector.selectMethods(targetClass, (MethodIntrospector.MetadataLookup>) method -> { Set scheledAnnotations = AnnotatedElementUtils.( method, Scheled.class, Scheles.class); return (!scheledAnnotations.isEmpty() ? scheledAnnotations : null); }); if (annotatedMethods.isEmpty()) { this.nonAnnotatedClasses.add(targetClass); } else { // Step 3 : 方法不为空 , 执行 Process annotatedMethods.forEach((method, scheledAnnotations) -> scheledAnnotations.forEach(scheled -> processScheled(scheled, method, bean))); } } return bean;}

PS : 后面就不看了 , 主要就是通过一个 ScheledTask 运行 Runable 对象

从具体的使用上 , 不难看出 , 他是在创建Bean的时候去做补充的操作 , 那么下面来看一下具体的处理流程

这个流程在Bean 初始化流程 中进行了全面的跟踪 , 这里更关注其中的一些细节

3.2 Before/After 调用流程

入口一 : # initializeBean 调用

其中流程也比较简单 , for 循环所有的 BeanPostProcessors 进行处理

3.3 BeanPostProcessors 的管理// 在 AbstractBeanFactory 中有一个集合用于管理 BeanPostProcessorprivate final List beanPostProcessors = new ();// 不论是哪种类型 ,都会通过以下2种方式进行调用 , 先删除, 后添加public void addBeanPostProcessors(Collection beanPostProcessors) { this.beanPostProcessors.removeAll(beanPostProcessors); this.beanPostProcessors.addAll(beanPostProcessors);}public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) { this.beanPostProcessors.remove(beanPostProcessor); this.beanPostProcessors.add(beanPostProcessor);}

• 类型一 : 手动添加的流程

可以通过手动添加的方式 ,实现 BeanPostProcessor 的添加 , 参考对象 AbstractApplicationContext

protected void prepareBeanFactory( beanFactory) { // ............. // Configure the bean factory with context callbacks. beanFactory.addBeanPostProcessor(new (this)); // .............}

• 类型二 : Refresh 添加环节

哈哈 , 又到了这个地方 , 之前看 Refresh 代码的时候就注意到了这个地方 , 会注册相关的 BeanPostProcessors

protected void registerBeanPostProcessors( beanFactory) { // Step 1 : 调用 进行注册 .registerBeanPostProcessors(beanFactory, this);}

源码注释非常清晰 ,这里就是简单翻译了一下

public static void registerBeanPostProcessors( beanFactory, AbstractApplicationContext applicationContext) { // postProcessor 数组列表 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); // processor 计数 int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length; //注册BeanPostProcessorChecker，当bean在BeanPostProcessor实例化期间创建时，即当bean不符合所有BeanPostProcessors处理的条件时，该checker会记录信息消息 beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount)); // 区别 PriorityOrdered, internalPostProcessor List priorityOrderedPostProcessors = new ArrayList<>(); List internalPostProcessors = new ArrayList<>(); // 有序化 List orderedPostProcessorNames = new ArrayList<>(); List nonOrderedPostProcessorNames = new ArrayList<>(); for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); priorityOrderedPostProcessors.add(pp); // 运行时用于合并bean定义的后处理器回调接口 if (pp instanceof ) { internalPostProcessors.add(pp); } } // 如果实现了 Ordered 接口 , 则需要有序处理 else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { orderedPostProcessorNames.add(ppName); } else { nonOrderedPostProcessorNames.add(ppName); } } // 首先，注册实现prioritordered的BeanPostProcessors sortPostProcessors(priorityOrderedPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors); // 接下来，注册实现Ordered的BeanPostProcessors List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size()); for (String ppName : orderedPostProcessorNames) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); orderedPostProcessors.add(pp); if (pp instanceof ) { internalPostProcessors.add(pp); } } sortPostProcessors(orderedPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, orderedPostProcessors); // 现在，注册所有常规的BeanPostProcessors List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size()); for (String ppName : nonOrderedPostProcessorNames) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); nonOrderedPostProcessors.add(pp); if (pp instanceof ) { internalPostProcessors.add(pp); } } registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors); // 最后，重新注册所有内部BeanPostProcessors sortPostProcessors(internalPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, internalPostProcessors); // 将用于检测内部bean的后处理器重新注册为ApplicationListeners，将其移动到处理器链的末端 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));}四 . 深入定制 4.1 添加 BeanPostProcessor

• 方法一 : 手动添加

PS : 当然 , 这种方式过于复杂 , 适用场景不多

@Autowiredprivate DefaultListableBeanFactory beanFactory;@Bean(initMethod = "initMethod")public CommonService getCommonService() { // 通过 BeanFactory 进行添加 beanFactory.addBeanPostProcessor(new CustomizePostProcessor()); return new CommonService();}

• 方法二 : 直接继承接口

上面分析的时候也看到 , 实现了接口就自动添加了

五 .问题补充 5.1 与四种常见的初始化方式有什么区别 ?

回顾一下四种初始化运行的方式 :

• 实现 InitializingBean 接口方法 afterPropertiesSet

• 实现 ApplicationRunner 接口方法 run(ApplicationArguments args)

• 方法标注注解 @PostConstruct

• @Bean(initMethod = "initMethod") 通过注解指定

• 调用的区别

: ------> this is @PostConstruct <-------: ------> this is InitializingBean <-------: ------> this is in @Bean(initMethod = "initMethod") <-------: ------> this is <-------: ------> this is <-------: ------> this is <-------: ------> this is <-------: ------> this is <-------: ------> this is <-------: Started DemoApplication in 0.822 seconds (JVM running for 2.597): ------> this is ApplicationRunner :getCommonService <-------

• 调用次数: 四种方法只会调用一次 ,而 和 会在每个Bean创建的时候调用

• 调用时机: 集中在每个 BeaninitializeBean环节调用

六. 我们能用它干什么 ?

这里不讨论是否真的有场景会使用 ,只是发散思维 , 去思考如何利用他的特点去做点什么

6.1 结合设计模式

代理是 postProcess 最合适的使用之一 , AOP 即使用了他的特性进行的代理 , 我们可以模拟 AOP , 去做一个更偏向于业务的静态代理模式 .

同时也可以实现装饰器模式 , 对 Bean 的处理进行加强 .

• Step 1 : 准备接口和实现类

// 统一接口public interface Sourceable { void method();}// 对应实现类 (实际业务类)@Servicepublic class Source implements Sourceable { @Override public void method() { System.out.println("the original method!"); }}

• Step 2 : 准备中间类

public class AopProxyImpl implements Sourceable { private Sourceable source; public AopProxyImpl(Sourceable source) { super(); // 注意 ,代理模式是在代理类中创建一个对象 // this.source = new Source(); // 修饰模式是传入对应的对象 this.source = source; } @Override public void method() { before(); source.method(); atfer(); } private void atfer() { System.out.println("after proxy!"); } private void before() { System.out.println("before proxy!"); }}

• Step 3 : BeanPostProcessor 进行处理

@Servicepublic class AopPostProcessor implements BeanPostProcessor { private Logger logger = LoggerFactory.getLogger(this.getClass()); @Override public Object (Object bean, String beanName) throws BeansException { logger.info("------> AopPostProcessor <-------"); return bean; } @Override public Object (Object bean, String beanName) throws BeansException { logger.info("------> AopPostProcessor <-------"); if (bean instanceof Sourceable) { logger.info("------> AopPostProcessor build Aop <-------"); AopProxyImpl proxy = new AopProxyImpl((Sourceable)bean); return proxy; } return bean; }}

• 补充 ：

• 这里如果没有 , 则一定会抛出 , 因为 Spring 会去坚持类是否匹配

• 这里我们属于静态代理 , 其实还可以更活用的使用cglib 动态代理

• 还有很多种整合设计模式的方式可以灵活使用

6.2 Manager 管理指定类型对象

这种方式是在 postProcessor 中对指定的Bean 进行一个管理记录

大概的使用方式是准备一个BeanManager , 然后在 postProcessor 中进行管理

@Componentpublic class BeanManager { // 对特殊的Bean 进行分组 private static Map typeOne = new ConcurrentHashMap(); private static Map typeTwo = new ConcurrentHashMap(); // PS : 这种方式适合处理更复杂的场景 , 简单场景可以考虑通过 ApplicationContext.getBean 获取对应的类}public Object (Object bean, String beanName) throws BeansException { logger.info("------> ManagerPostProcessor <-------"); if (bean instanceof TypeBean) { logger.info("------> AopPostProcessor build Aop <-------"); beanManager.getTypeOne().put(beanName, (TypeBean) bean); } return bean;}// PS : 实际上和注入的是同一个对象------> typeOne.get("typeBeanImpl") == (typeBean) :true <-------

这是最简单的使用方式 , 相对更复杂的还可以整合注解 , 整合接口或者父类 , 或者仅记录class信息等方式 ,达到自己的业务效果

6.3 注入特殊属性

从图片中我们可以看到 , BeanPostProcessor 是在 PopulateBean 环节之后进行处理的 , 那么我们可以通过这个环节 , 对 Bean 中的属性进行修饰 , 常见的使用想法包括 :

• 为特定属性设置动态代理

• 从 Remote 端获取属性 , 并且设置

这个就比较好理解了 , 实际上这个时候包括RestTemplate 都已经加载完成 , JDBC 也可以使用 , 在这个时候完全可以从远端获取配置信息

// 作用一 : 使用 JDBC (JPA 应该也已经加载可用) , 从数据库获取配置 , 判断当前类是否有特定注解 , 刷新注解的配置// 作用二 : 调用远端配置中心 , 自定义刷新配置// 作用三 : 刷新特殊的属性或者对象等等

特殊对象的刷新有多种任意的使用 , 可以根据自己的业务灵活运用

6.4 其他思路

这里只是抛砖引玉 , 欢迎大佬们提出自己的想法

• 重构属性

• 定制化过程中对类进行覆盖

总结

• 注意点 :

• 主要在 initializeBean 调用环节

• 除了initializeBean外还在多个环节被调用, 包括 等等几个 Factory 去实例化的过程中

• 避免循环 , ManagerPostProcessor 不会处理自己

• BeanPostProcessor 在每个 bean 创建时都会调用 ,过多会影响启动效率

• BeanPostProcessor 主要在populateBean 之后 , 注意前后顺序

• 作者：AntBlack 原文链接：https://juejin.cn/post/7016160419093938207