Spring extension
when using ssm. Will find spring first, why?
It should be because we need to hand over the object to srping for unified management,
Let's review first, the two major characteristics of spring
ioc We have worked with spring to help us create classes and decouple our classes
aop You can add some enhanced methods without changing the source code of the class, which can be pre-, post-, exceptions, etc.
When we want to use the framework to achieve more and more functions, we often need to add a lot of bean components. When using it, we can directly use the classes in the ioc container.
post processor
Creating classes is also different
- Singleton with factory creation
- with bean creation
These all require corresponding post-processors. Next, let's take a look at the flexible processors that spring provides us. As long as the bean s injected into the container are about to be initialized, the post-processors will be executed. After it is completed, it is put into the spring pool.
bean handler
BeanPostProcessor: The role of the Bean's post-processor is to add our own logic before and after the initialization method is displayed after the Bean object is instantiated and dependency injected. Note that it is triggered after the Bean is instantiated and after the dependency injection is completed. The source code of the interface is as follows
There are two methods in the source code:
postProcessBeforeInitialization: instantiation, dependency injection is completed, and then call display initialization to complete the task of custom initialization of the game
postProcessAfterInitialization: instantiation, dependency injection, execution after initialization
Here we write a small demo to experience
Create a new class called myBeanPostProcessor, we implement the interface of this post processor
Parameter explanation:
Parameter 1 bean: is the object we injected into the ioc
Parameter 2 beanName : is the name of the object we injected into the ioc
copypublic class MyBeanPostProcessor implements BeanPostProcessor { public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println(beanName+"Before initialization"); return bean; } public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println(beanName+"After initialization"); return bean; } }
Simple example, after implementation, you can see the output information before and after initialization of the injected object
Bean Factory Post Processor
This bean factory processor is some modification to the bean before the creation of all beans. What can we do to the bean before constructing the object,
postProcessBeanFactory method: The parameter has the object of the bean factory, you can view some information

He just returns a created factory object before bena is created, we can view the bean information to be created in the factory
BeanDefinitionRegistryPostProcessor (post bean component information processor)
In order to deal with some configurations when we put the container into spring, such as whether it is a singleton, initialization method, destruction method, etc. post-processor for information

method
The configuration information registration of the postProcessBeanDefinitionRegistrybean object
Enter the bean factory after postProcessBeanFactory
copypublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException { System.out.println("postProcessBeanDefinitionRegistry:" + beanDefinitionRegistry); } public void postProcessBeanFactory( ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException { System.out.println("ConfigurableListableBeanFactory:" + configurableListableBeanFactory); }
The various life cycles of Bean components
- bean component information processor: component information registration
- The bean factory is created, and the post-factory processor we wrote ourselves is the same,
- bean creation and injection completed
- Before initialization
- loading finished
- after initial
- destroy
Small demo, use bean factory to operate bean injection
New configuration file: beanFactoryProcessor.xml, just put two bean objects without any configuration
copy<bean id="mypostProcessBeanFactory" class="com.hyc.Processor.MypostProcessBeanFactory"/> <bean id="demobean" class="com.hyc.springBean.demoBean"></bean>
Manipulate bean objects with beanFactory, implement configuration, and attribute injection
copypublic class MypostProcessBeanFactory implements BeanFactoryPostProcessor { public void postProcessBeanFactory( ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException { System.out.println("configurableListableBeanFactory" + configurableListableBeanFactory); // get object AbstractBeanDefinition demobean = (AbstractBeanDefinition) configurableListableBeanFactory.getBeanDefinition("demobean"); // Set the initialization method demobean.setInitMethodName("init1"); // inject name value MutablePropertyValues propertyValues = demobean.getPropertyValues(); propertyValues.add("name", "PostProcessorFactory bane name"); // set destroy method demobean.setDestroyMethodName("destroy1"); } }
Then output the viewing information

Next we duplicate a custom bean factory

Add a bean to the configuration file
copy<bean id="mypostProcessBeanFactory2" class="com.hyc.Processor.MypostProcessBeanFactory2"/>
Implement the priority interface for the two factories, set the priority,
Factory No. 1 has a priority of 5
Factory 2 has a priority of 10
copypublic class MypostProcessBeanFactory2 implements BeanFactoryPostProcessor, Ordered { //The code of the previous factory is omitted public int getOrder() { return 10; }
start test

It can be seen that the level 5 is executed online
Perfect, the above is the actual combat of using post processors to manipulate bean properties
spring event listener
We can monitor the time that happens in our spring, and we can also customize a spring event listener
We learn this mainly to know what events are dispatched when spring is executed in the container
Here we implement ApplicationListener<ApplicationEvent>
The object in the generic here is the global message, we can also write our own custom
copypublic class MyApplicationEvent extends ApplicationEvent { public MyApplicationEvent(Object source) { super(source); } String username; String emial; public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getEmial() { return emial; } public void setEmial(String emial) { this.emial = emial; } public MyApplicationEvent(Object source, String username, String emial) { super(source); this.username = username; this.emial = emial; } }
Then create a new configuration file Listener.xml to add the event listener to the spring container
copy<bean id="listener" class="com.hyc.listener.myApplicationListener"></bean>
Modify the event listener, let's see what events are dispatched when the bean is generated
copypublic class myApplicationListener implements ApplicationListener<ApplicationEvent> { public void onApplicationEvent(ApplicationEvent event) { System.out.println("received event" + event); //The judgment here is that if there is our own definition content, the event listener will be forced into our custom listener to ensure that our own custom events can also be output. if (event instanceof MyApplicationEvent) { MyApplicationEvent myApplicationEvent = (MyApplicationEvent) event; System.out.println("username" + myApplicationEvent.getUsername()); System.out.println("User mailbox" + myApplicationEvent.getEmial()); } } }
test after
copypublic class listenerMain { public static void main(String[] args) { ClassPathXmlApplicationContext ApplicationContext = new ClassPathXmlApplicationContext("Listener.xml"); //Create event object MyApplicationEvent event = new MyApplicationEvent("event content", "james", "123@qq,com"); //send event ApplicationContext.publishEvent(event); ApplicationContext.close(); // } }

It can be seen that the loading process of spring in the figure is becoming more and more obvious.