package test.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
@Component
@Aspect
@Order(10)
public class AspectTest2 {
@Around("execution(void test.aop.*.b(..))")
public void aroundb2(ProceedingJoinPoint joinPoint){
System.out.println("b222222");
try {
joinPoint.proceed();
} catch (Throwable throwable) {
throwable.printStackTrace();
运行结果如下：
可以发现确实按类是没有问题的。如果不相信，可以自行调换order的值来证明，这里就不证明了。
为什么会这样呢？我们查看官网：
https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-autowired-annotation
Your target beans can implement the org.springframework.core.Ordered interface or use the @Order or standard @Priority annotation if you want items in the array or list to be sorted in a specific order. Otherwise, their order follows the registration order of the corresponding target bean definitions in the container.
You can declare the @Order annotation at the target class level and on @Bean methods, potentially for individual bean definitions (in case of multiple definitions that use the same bean class). @Order values may influence priorities at injection points, but be aware that they do not influence singleton startup order, which is an orthogonal concern determined by dependency relationships and @DependsOn declarations.
Note that the standard javax.annotation.Priority annotation is not available at the @Bean level, since it cannot be declared on methods. Its semantics can be modeled through @Order values in combination with @Primary on a single bean for each type.
有道翻译如下：
您的目标bean可以实现org.springframework.core。如果希望数组或列表中的项按特定顺序排序，请使用@Order或标准@Priority注释。否则，它们的顺序遵循容器中相应的目标bean定义的注册顺序。
您可以在目标类级别和@Bean方法上声明@Order注释，这可能适用于单个bean定义(在多个定义使用同一个bean类的情况下)。@Order值可能会影响注入点的优先级，但是要注意它们不会影响单例启动顺序，这是由依赖关系和@DependsOn声明决定的正交关系。
注意，标准javax.annotation。Priority注释在@Bean级别不可用，因为它不能在方法上声明。它的语义可以通过@Order值和@Primary对每个类型的单个bean进行建模。
从这个翻译可以大致看出@Order主要是针对单个bean的排序，即只能在类或者Bean方法中使用，无法作用于普通方法。@Priority无法作用域方法上，因此该注释也不行。
我们再看看@Order的官方定义：
https://docs.spring.io/spring/docs/5.3.0-SNAPSHOT/javadoc-api/
看这段：
NOTE: Since Spring 4.0, annotation-based ordering is supported for many kinds of components in Spring, even for collection injection where the order values of the target components are taken into account (either from their target class or from their @Bean method). While such order values may influence priorities at injection points, please be aware that they do not influence singleton startup order which is an orthogonal concern determined by dependency relationships and @DependsOn declarations (influencing a runtime-determined dependency graph).
Since Spring 4.1, the standard Priority annotation can be used as a drop-in replacement for this annotation in ordering scenarios. Note that @Priority may have additional semantics when a single element has to be picked (see AnnotationAwareOrderComparator.getPriority(java.lang.Object)).
翻译如下：
注意:从Spring 4.0开始，Spring中许多类型的组件都支持基于注释的排序，即使是考虑到目标组件的顺序值的集合注入(从它们的目标类或从它们的@Bean方法)也是如此。虽然这些顺序值可能会影响注入点的优先级，但请注意，它们不会影响单例启动顺序，单例启动顺序是由依赖关系和@DependsOn声明决定的正交关系(影响运行时确定的依赖关系图)。
从Spring 4.1开始，在排序场景中，标准优先级注释可以作为该注释的替代。注意，当必须选择单个元素时，@Priority可能具有额外的语义(请参阅注释awareordercomparator . getpriority (java.lang.Object))。
这里明确指示出@Order只是作用域目标类或从它们的@Bean方法，且无法改变启动的顺序。因此从这里也证明了@Order无法对普通方法排序。
因此作用域普通方法的@Order并没有办法起到作用，控制优先级。因为单例一旦加载其顺序已经固定，可能spring认为再去调整类中方法执行的优先级意义不大，且实际使用也很少有此要求。
我们最后再看看aop的排序的介绍：
https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#aop-ataspectj-advice-ordering
What happens when multiple pieces of advice all want to run at the same join point? Spring AOP follows the same precedence rules as AspectJ to determine the order of advice execution. The highest precedence advice runs first “on the way in” (so, given two pieces of before advice, the one with highest precedence runs first). “On the way out” from a join point, the highest precedence advice runs last (so, given two pieces of after advice, the one with the highest precedence will run second).
When two pieces of advice defined in different aspects both need to run at the same join point, unless you specify otherwise, the order of execution is undefined. You can control the order of execution by specifying precedence. This is done in the normal Spring way by either implementing the org.springframework.core.Ordered interface in the aspect class or annotating it with the Order annotation. Given two aspects, the aspect returning the lower value from Ordered.getValue() (or the annotation value) has the higher precedence.
When two pieces of advice defined in the same aspect both need to run at the same join point, the ordering is undefined (since there is no way to retrieve the declaration order through reflection for javac-compiled classes). Consider collapsing such advice methods into one advice method per join point in each aspect class or refactor the pieces of advice into separate aspect classes that you can order at the aspect level.
翻译如下：
当多个通知都想在同一个连接点上运行时会发生什么?Spring AOP遵循与AspectJ相同的优先规则来确定通知执行的顺序。优先级最高的通知在“进来的路上”首先运行(因此，给定两个before通知，优先级最高的先运行)。从连接点“在出去的路上”，优先级最高的通知最后运行(因此，给定两个after通知，优先级最高的通知将运行在第二位)。
当在不同方面定义的两个通知都需要在同一个连接点上运行时，除非您另外指定，否则执行的顺序是未定义的。您可以通过指定优先级来控制执行的顺序。这是通过实现org.springframework.core以正常的Spring方式完成的。方面类中的有序接口或使用有序注释对其进行注释。给定两个方面，从order . getvalue()(或注释值)返回较低值的方面具有较高的优先级。
当在同一个方面定义的两个通知都需要在同一个连接点上运行时，顺序是未定义的(因为没有办法通过反射为javac编译的类检索声明顺序)。考虑将这些通知方法分解为每个方面类中的每个连接点的一个通知方法，或者将这些通知重新分解为可以在方面级别排序的单独的方面类。
注意理解这句话。就能知道为什么aop没有办法在同一个类中进行排序了。最后一段指明了spring官网就推荐使用类的排序，而不使用方法排序。所以我暂时找不出什么办法来解决这个问题。
因为目前来说：
@Order普通方法的排序不生效。
@Priority不能作用域方法上。
@Primary也不行。
如果某天找到了办法就更新到这里来。
为什么想到这个问题？在实际工作开发中，因为之前写过一个aop，使用了一个方法，但代码并不多，但是新的需求也是能使用到aop的，且会影响之前写的aop，因此想要在同一个类中针对同一个方法进行排序。事实证明不行。测试如下：package test.aop;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Asp
1、Spring 4.2 利用@Order控制配置类的加载顺序，
2、Spring在加载Bean的时候，有用到order注解。
3、通过@Order指定执行顺序，值越小，越先执行
4、@Order注解常用于定义的AOP先于事物执行
1.@Order的注解源码解读
注解类：
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@Document
•在
同一个连接点上应用不止一个切面时, 除非明确指定, 否则它们的
优先级是不确定的.
•切面的
优先级可以通过实现
Ordered 接口或利用 @
Order 注解指定.
•实现
Ordered 接口, get
Order()
方法的返回值越小,
优先级越高.
•若使用 @
Order 注解, 序号出现在注解中（@
Order（number）中的数值越小
优先级越高）
踩坑：@PostConstruct、@DependsOn、@Order注解嵌套使用案例
今天在工作中写需求代码时，遇到的一个关于Sping Bean对象加载优先级问题，结合了Spring源码，大概总结了一下遇到Bean加载顺序需求问题时，比较常用的3个注解：@PostConstruct、@DependsOn、@Order。
一、@Order注解的作用
@Order注解的作用是定义Spring IOC容器中Bean的执行顺序的优先级。
使用案例：
@Component
@Order(0)
public
转载：https://blog.csdn.net/wcy1026580943/article/details/82658721
Spring 4.0中默认情况下遵循从低到高的顺序，即最低值具有高优先级。 这意味着它们首先出现在列表或数组中。 因为默认情况下，排序优先级为LOWEST_PRECEDENCE。 如果您首先需要最高值，那么我们需要将此值更改为Ordered.HIGHEST_PRECEDENCE。
源码中默认为
@Retention(RetentionPolicy.RUNTIME)
@Target
注解
类：
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@Documented
public @i...
注解@
Order或者接口
Ordered的作用是定义
Spring IOC容器中Bean的执行顺序的
优先级，而不是定义Bean的加载顺序，Bean的加载顺序不受@
Order或
Ordered接口的影响；
注解源码解读：
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@Documented
public @interface
Order {
写在前面：
本篇博客主要是通过测试来 解决关于@Order注解的使用位置问题，关于这个问题呢，我查了很多的博客，得到的答案是这样的：可以使用在类和方法上。因为我个人认为是只能用在类上的，因此就做了这个测试。
在springBoot的AOP编程中，自定义切面，为了测试方便，只利用了前置通知的方式。
1.定义一个切面类，在切面类中定义多个前置通知，让他们去切同一个servcie方法...
Spring的@
Order注解或者
Ordered接口大家都知道是控制顺序的，那么它们到底是控制什么顺序的？是控制Bean的注入顺序，还是Bean的实例化顺序，还是Bean的执行顺序呢？那么我们先直接给出结论再来验证结论。
结论：
Spring的@
Order注解或者
Ordered接口，不决定Bean的加载顺序和实例化顺序，只决定Bean的执行顺序。
实例论证：@
Order不决定Bean的加载和实例化顺序
步骤一：创建DemoService接口和三个实现
类，分别打上注解@
Order(0)-DemoSer
【障碍再现】
MyBatis配置多数据源时，数据源切换失败。
【原因分析】 自定义切面和Spring自带事务切面“即<aop:advisor>”执行的先后顺序导致数据源不能切换成功。
【解决方案】1、配置代码
1 <aop:config>
2 <!-- 1、Spring框架自身提供的切面 ...
今天要来说一下Orderd接口以及@Order、@Primary、@Priority注解这几个东西，原本只是想介绍一下@Order，但是这几个有一定的关联，因此这里一起进行介绍。这几个接口是用来排序，本文主要介绍用法，具体的比如Spring什么时候对他们排序啊，后面在介绍Spring的处理过程的时候再介绍，还有怎么排序的这些比较好理解的也不介绍了。
1、如何发现Orderd接口以及@Order、@Primary、@Priority
在前面文章说过要通过一些常用的注解以及在学习过程中不断的发现，因此这里我还是
MySQL的order by语句可以用于对查询结果集进行排序，常常需要使用多个字段来进行排序。在多字段排序时，遵循以下规则：
1. 排序字段的顺序按照order by语句中的先后顺序进行，先根据第一个排序字段排序，如果有相同的值，则根据第二个排序字段排序，以此类推。
2. 对于数字类型的字段，排序是根据数值大小进行的。对于文本类型的字段，排序则根据字面的字符顺序进行，即按照字典顺序排序。
3. 对于字符串类型的字段，如果希望进行不区分大小写的排序，则可以使用lower或upper函数进行转换，例如：order by lower(name)。
4. 可以在排序规则中指定升序（asc）或降序（desc），默认是升序。如果需要使用降序排序，则需要在字段后加上desc。
5. 如果存在NULL值，排序结果可能不稳定。可以使用order by字段1,字段2,coalesce(字段3,0)来指定NULL值排序规则。
总之，MySQL的order by语句可以很灵活地进行多字段排序，并且可以指定不同字段的排序规则，需要根据实际情况进行灵活运用。
### 回答2：
在MySQL中，ORDER BY多字段的排序规则分为以下三种：
1. 升序排序（ASC）：使用ASC来排序，将会按照指定的字段按照从小到大的顺序进行排列。例如：
```mysql
SELECT * FROM `mysql_demo` ORDER BY `age` ASC, `name` ASC;
2. 降序排序（DESC）：使用DESC来排序，将会按照指定的字段按照从大到小的顺序进行排列。例如：
```mysql
SELECT * FROM `mysql_demo` ORDER BY `age` DESC, `name` DESC;
3. 混合排序：在使用多个字段进行排序时，有时需要将一个字段按照升序排序，另一个字段按照降序排序。这时需要使用升序排序和降序排序的组合。例如：
```mysql
SELECT * FROM `mysql_demo` ORDER BY `age` ASC, `name` DESC;
在混合排序中，将按照`age`字段进行升序排序，如果`age`相同则按照`name`字段进行降序排序。
需要注意的是，当使用多个字段进行排序时，排序字段的顺序将会影响结果。例如：
```mysql
SELECT * FROM `mysql_demo` ORDER BY `name` ASC, `age` DESC;
在这个例子中，首先将按照`name`进行升序排序，如果`name`相同则按照`age`进行降序排序。如果将`name`和`age`的顺序颠倒，则会按照`age`进行降序排序，如果`age`相同则按照`name`进行升序排序。因此，在使用多个字段进行排序时，需要根据实际需求确定排序字段的顺序。
### 回答3：
在 MySQL 中，ORDER BY 子句用于指定排序的规则。对于多字段排序，可以使用多个排序字段来定义排序规则。一般来说，多字段排序是根据所需的字段中的第一个字段进行排序，并且在第一个字段具有相同值的记录中，使用第二个字段进行排序，以此类推。
例如，假设有一个包含以下字段的表：
id | name | age | gender
如果我们想按照年龄和性别来对记录进行排序，我们可以使用以下SQL语句：
SELECT * FROM table_name
ORDER BY age DESC, gender ASC;
在上面的SQL语句中，我们首先根据年龄字段进行降序排序，这意味着年龄最大的记录将会排在前面。如果某些记录拥有相同的年龄值，则这些记录将按照性别字段进行升序排序，这意味着男性记录将排在女性记录之前。
此外，还可以使用 ORDER BY 子句中的一个特殊关键字，即 NULLS FIRST 或 NULLS LAST，来控制空值的排序。例如，我们可以使用以下 SQL 语句来将空值排在最前面：
SELECT * FROM table_name
ORDER BY age DESC NULLS FIRST;
总之，在 MySQL 中，ORDER BY 子句可用于根据一个或多个字段对记录排序。多字段排序时，第一个排序字段是最重要的，随后的字段是副要素，可以用来细化排序规则。同时，还可以使用 NULLS FIRST 或 NULLS LAST 来控制空值在排序中的位置。
spring（十四）---InstantiationAwareBeanPostProcessor（postProcessBeforeInstantiation）第一次调用
xqcode:
spring（十四）---InstantiationAwareBeanPostProcessor（postProcessBeforeInstantiation）第一次调用
流光1013
