1. Introduction to Spring Framework
What is Spring?
Spring is an open source lightweight application development framework. The purpose is to simplify enterprise-level application development and reduce intrusion
The IOC and AOP applications provided by Spring can minimize the coupling of components, that is, decoupling, to facilitate future maintenance and upgrades of the system
Spring provides an overall solution for the system. In addition to the functions it provides, developers can also integrate applications with third-party frameworks and technologies, and can freely choose which technology to use for development
2. Container and Bean management
Introduction to Spring container
In Spring, any java class and javaBean are treated as beans. These beans are managed and applied through the container.
Spring container implements IOC and AOP mechanisms. These mechanisms can simplify the creation of Bean objects and the decoupling between Bean objects.
Spring container has two BeanFactory and ApplicationContext Type
(What is javaBean: a simple and standardized java object; when to use Spring: You can use it when you need to manage javaBean objects. Spring is one of the simplest object management solutions)
Instantiation of Spring container
ApplicationContext inherits from the BeanFactory interface and has more enterprise-level methods. It is recommended to use this type. The instantiation method is as follows:
//Load the configuration file instantiation in the file system
String conf = "C:\applicationContext.xml";
ApplicationContext ac = new FileSystemXmlApplicationContext(conf);
//Load the configuration file instantiation under the project classpath
String conf = "applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
The use of Spring container
In essence, BeanFactory and ApplicationContext are just a high-level factory interface that maintains Bean definitions and interdependencies. We can access the bean definition through BeanFactory and ApplicationContext
First add the Bean definition in the container configuration file applicationContext.xml
Then after creating the BeanFactory and ApplicationContext container objects, call the getBean() method to obtain the instance of the Bean [getBean("identifier")] Instancing of the Bean There are three ways for the Spring container to create Bean objects: -Use the constructor to instantiate (The id or name attribute is used to specify the Bean name and is used to find the Bean object from Spring; class is used to specify the Bean type and will automatically call the parameterless constructor to create the object) -Use static factory method to instantiate (The id attribute is used to specify the Bean name, the class attribute is used to specify the factory type, and the factory-method attribute is used to specify the method for creating Bean objects in the factory. Methods that must be decorated with static) -Use the instance factory method to instantiate (id is used to specify the bean name, the factory-bean attribute is used to specify the factory Bean object, and the factory-method attribute is used to specify the method of creating the Bean object in the factory) (Tell Spring the object creation rules, Spring Will help you create objects; based on configuration and default rules, reducing code writing) Bean naming Bean name: In the Spring container, each Bean needs to have a name (i.e. identifier). The name can be specified using the id or name attribute of the Bean alias: is a defined Bean, and to add another name reference, you can use Bean scope: Spring container is in When instantiating a bean, you can create Bean objects with the following scopes 1, singleton scope (The above Bean scope can be specified through the scope attribute defined by Bean life cycle callback Specify the initialization callback method: Specify the destruction callback method, only applicable to beans in singleton mode:
In each Spring IOC A bean definition in the container corresponds to an object instance. The default item
configures the instance:
or
2、prototype
One bean definition corresponds to multiple object instances
Configuration instance:
or
3. request
request means that a new bean will be generated for each HTTP request, and the bean is only valid within the current HTTP request
When using request, session, and global session, you must first make the following configuration in the web.xml that initializes the web:
If you are using a web container with Servlet 2.4 and above, then you only need Just add the following ContextListener to the XML declaration file web.xml of the web application:
If it is a web container before Servlet2.4, then you have to use an implementation of javax.servlet.Filter :
Then you can configure the scope of the bean:
4, session
session scope means that a new bean will be generated for each HTTP request, and the bean will only be generated during the current HTTP request. Valid within the session (in an HTTPSession, one bean definition corresponds to one instance, limited to the Web environment)
Configuration instance:
The premise is the same as the request configuration instance. After configuring the web startup file, you can configure it as follows:
5、global session
In a global HTTPSession, one bean definition corresponds to one instance, which is only meaningful in portlet-based Web applications. The Portlet specification defines the concept of global Session
Configuration instance:
and The premise of request configuration instance is the same. After configuring the web startup file, you can configure it as follows:
The default-init-method attribute in the top-level
The default-destroy-method attribute in the top-level
Bean delayed instantiation
The default behavior implemented in ApplicationContext is to instantiate all singleton beans in advance at startup
If you don’t want to To allow a singleton bean to be instantiated in advance when the ApplicationContext is initialized, you can use the lazy-init = "true" attribute of the
A lazy-initialized bean will be instantiated the first time it is used
In the top-level
Specify bean dependencies
When a bean has a dependency on another bean, you can use the depends-on attribute of the
When a bean is dependent on multiple When a bean has a dependency relationship, the depends-on attribute can specify multiple bean names, separated by commas
3. Container IOC application
IOC concept
The full name of IOC is Inversion of Control, translated as inversion of control;
IOC refers to the reversal of the acquisition method of objects in the program, from the original new method to creation and injection by a third-party framework. Third-party frameworks generally specify which specific implementation to inject through configuration, thereby reducing the coupling between objects
IOC can be divided into two types: dependency injection DI and dependency lookup depending on the implementation method
Spring container uses DI to implement IOC control. IOC is the foundation and core of Spring container
DI concept
The full name of DI is Dependency Injection, which is translated Injecting dependencies
The basic principle of DI is to connect objects that work together and have relationships through constructor parameters or method parameters. Therefore, the job of the container is to inject those dependencies when creating a bean
IOC is an idea, and DI is the main technical way to realize IOC
DI has two main injection methods, namely Setter injection and constructor injection
Setterr injection
After instantiating a bean by calling the parameterless constructor or parameterless static factory method, and calling the setter method of the bean, setter injection can be achieved
public class JDBCDataSource{
private String driver;
public void setDriver(String driver){
try{
Class .forName(driver);
this.driver = driver;
}catch(Exception e){
throw new RuntimeException(e);
}
}
//Other codes....
}
In the container xml configuration, configure the injection parameters
Constructor injection
Constructor-based injection is done by calling a constructor with parameters It is implemented by the container. When the bean is instantiated, the container executes the corresponding constructor according to the parameter type
public class OracleUserDAO implements UserDAO{
private JDBCDataSource dataSource;
public OracleUserDAO(JDBCDataSource dataSource){
this.dataSource = dataSource;
}
//Other code...
}
Specify injection according to constructor parameter index
< ;constructor-arg index = "0" ref = "dataSource"/>
Autowiring
Spring IOC The container can automatically assemble (autowire) the association between cooperating beans. Autowire can be set for a single bean. The convenience of autowire is to reduce the injection configuration of xml
In the xml configuration file, you can Use the autowire attribute in the ;bean/> element to specify automatic assembly rules. There are five types of values.
The attribute value is no:Autowire is prohibited, and the default value is ;
The attribute value is byName:Automatically assemble based on the attribute name. This option will check the container and find a bean that is exactly the same as the attribute based on the name, and automatically assemble it with the attribute;
The attribute value is byType: If there is a bean with the same type as the specified attribute in the container, it will be automatically assembled with the attribute;
The attribute value is constructor: is similar to byType, except that it is applied to the constructor parameter;
The attribute value is autodetect:Determine whether to use the constructor or byType method for automatic detection through the bean class Assembly, if a default constructor is found, the byType method will be used
Configuration example:
In the above configuration, if there is a method Setter method that receives the UserDao type in UserService, Spring can automatically inject the userDAO object into it
The above is the detailed content of Spring IOC container. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
