BeanPostProcessor，bean，Aware，ApplicationContextAware RequestContextHolder

 

 

 HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
 String token = request.getHeader("");

@Autowired
protected HttpServletRequest request;

 

SuperScheduledPostProcessor implements BeanPostProcessor, ApplicationContextAware {
BeanPostProcessor该接口我们也叫后置处理器，作用是在Bean对象在实例化和依赖注入完毕后，在初始化方法的前后添加我们自己的逻辑
通过 BeanPostProcessor 解析Scheduled注解，收集指定注解的类、方法名

implements ApplicationRunner, ApplicationContextAware {
ApplicationRunner springBoot项目启动时候,有时候需要再启动之后直接执行某一段代码。这个时候就用到了 ApplicationRunner 这个类
@Override
public void run(ApplicationArguments args) {

SuperScheduledManager.addScheduled
threadPoolTaskScheduler.schedule(runnable, new CronTrigger(scheduledSource.getCron()));

@EnablexxxJmsMqListener 注解中引入 @Import(ImportxxxJsmListenerBeanDefinition.class)
ImportxxxJsmListenerBeanDefinition implements ImportBeanDefinitionRegistrar, EnvironmentAware {//获取注解依次处理

 

public class SuperScheduledPostProcessor implements BeanPostProcessor, ApplicationContextAware {

    ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

        Method[] methods = bean.getClass().getDeclaredMethods();
        MyTestService myTestService;
         //循环处理对每个方法逐一处理
        if (methods.length > 0) {
            for (Method method : methods) {
                //3.尝试在该方法上获取@Scheduled注解（SpringBoot的定时任务注解）
                ProcessTest annotation = method.getAnnotation(ProcessTest.class);
                //如果无法获取到@Scheduled注解，就跳过这个方法
                if (annotation == null) {
                    continue;
                }
                System.out.println(beanName+" "+method.getName()+" "+annotation.value());
                myTestService = (MyTestService) this.applicationContext.getBean("myTestService");
                if(myTestService.getMap() == null){
                    myTestService.setMap(new HashMap());
                }
                myTestService.getMap().put(beanName,method.getName()+":"+annotation.value());
            }
        }

        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

@Configuration
@Import(SuperScheduledPostProcessor.class)// 等同于注册实例到容器
public class ConfigTest {

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ProcessTest {
    String value();
}

@Service
public class MyTestService {
    private Map map ;

    public Map getMap() {
        return map;
    }

    public void setMap(Map map) {
        this.map = map;
    }
}
@Service
public class MyTestMain {
    @ProcessTest("mytestMainValue")
    public void mytestMainMethod(){
    }
}
@Service
public class MyTest {
    public String s ="s";

    @ProcessTest("myTestValue")
    public void myTestMethod(){

    }
}

测试
    @Autowired
    MyTestService myTestService;
    @RequestMapping("/hello")
    @ResponseBody
    public String hello() {
        System.out.println("***************hello1："+myTestService.getMap());
        return "hello:";
    }

BeanNameAware 获得到容器中Bean的名称
BeanFactoryAware 获得当前bean Factory,从而调用容器的服务
ApplicationContextAware 当前的application context从而调用容器的服务
MessageSourceAware 得到message source从而得到文本信息
ApplicationEventPublisherAware 应用时间发布器,用于发布事件
ResourceLoaderAware 获取资源加载器,可以获得外部资源文件

public class SuperScheduledApplicationRunnerMy implements ApplicationRunner{
    @Override
    public void run(ApplicationArguments args) {
       //服务启动后需要执行的代码

这个接口表面上的作用就是让实现这个接口的bean知道自己在spring容器里的名字，而且听官方的意思是这个接口更多的使用在spring的框架代码中，实际开发环境应该不建议使用，因为spring认为bean的名字与bean的联系并不是很深

@Service
public class BeanNameAwareTest implements BeanNameAware {
    @Override
    public void setBeanName(String s) {
        System.out.println("BeanNameAwareTest************"+s);
    }
}
 
@Service
public class BeanFactoryAwareTest implements BeanFactoryAware {
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        MyTestService myTestService = beanFactory.getBean(MyTestService.class);
        myTestService.myService();
    }
}
 
@Service
public final class SettingsBean implements ResourceLoaderAware {
    private static Properties settings;
    private ResourceLoader loader;
    private static final String SETTINGS_FILE = "classpath:/config/settings.properties";
     
    @Override
    public void setResourceLoader(ResourceLoader loader) {
        this.loader = loader;
        try {
            FileInputStream inputStream = new FileInputStream(loader.getResource(SETTINGS_FILE).getFile());
            settings = new Properties();
            settings.load(inputStream);
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public void save() {
        try {
            OutputStream outputStream = new FileOutputStream(loader.getResource(SETTINGS_FILE).getFile());
            settings.store(outputStream, "");
            outputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public Properties getSettings() {
        return settings;
    }
    public void setProperty(String key, String value) {
        settings.setProperty(key, value);
 
    }
    public static String getProperty(String key) {
        return settings.getProperty(key);
    }
 
    public double getDouble(String key) {
        return Double.parseDouble(settings.getProperty(key));
    }
 
    public int getInteger(String key) {
        return Integer.parseInt(settings.getProperty(key));
    }
}

 

@Configuration
public class ConfigTest {
    @Bean
    public MyTest myTestsssss(){//生产myTestsssss实例id
        return new MyTest();
    }

    @Bean
    public MyTestMain myTestMainxxxx(MyTest myTestsssss){
        System.out.println("*********************myTestsssss:"+myTestsssss+","+myTestsssss.s);
        System.out.println("*********************myTestsssss():"+myTestsssss());
        return new MyTestMain();
    }

    @Bean
    public ResultVo resultVo(){
        System.out.println("*********************");
        myTestMainxxxx(new MyTest());
        return null;
    }

实例化完成后，不会重复实例化
*********************myTestsssss:cn.com.domain.MyTest@18eec010,s
*********************myTestsssss():cn.com.domain.MyTest@18eec010
*********************

　　

java的注解实现的核心技术是反射，让我们通过一些例子以及自己实现一个注解来理解它工作的原理

@Override注解使用java官方提供的注解，它的定义里面并没有任何的实现逻辑。注意，所有的注解几乎都是这样的，注解只能是被看作元数据，它不包含任何业务逻辑。　注解更像是一个标签，一个声明，表面被注释的这个地方，将具有某种特定的逻辑，那么注解的功能是如何实现的呢？答案必然是别的某个地方对这个注解做了实现。以@Override注解为例，他的功能是重写一个方法，而他的实现者就是JVM，java虚拟机，java虚拟机在字节码层面实现了这个功能

我们自己想定义一个独一无二的注解的话，则我们需要自己为注解写一个实现逻辑，换言之，我们需要实现自己注解特定逻辑的功能。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SimpleAnnotation {
String value();
}
它的目标注释对象是方法，保留策略是在运行期间。

在Spring的众多注解中，经常会发现很多注解的不同属性起着相同的作用，比如@RequestMapping的value属性和path属性，这就需要做一些基本的限制，比如value和path的值不能冲突，比如任意设置value或者设置path属性的值，都能够通过另一个属性来获取值等等。为了统一处理这些情况，Spring创建了@AliasFor标签。