Spring IoC

I. IoC Container (Concept)

1. What is IoC?

Inversion of control, which gives Spring control over object creation and calls between objects
The purpose of using IoC is to reduce coupling

2. What technologies are used at the bottom of IoC?

XML parsing
The factory pattern
reflection

3. Spring provides two ways to implement the IoC container (two interfaces) :

BeanFactory interface: the basic implementation of IoC container, is the internal interface of Spring, not provided for developers to use (loading configuration file will not create objects, only when the object is back to create objects, lazy loading)
ApplicationContext: A subinterface of the BeanFactory interface that provides more powerful functionality and is typically used by developers (the configuration file object is created when the configuration file is loaded)

4. Implementation class of the ApplicationContext interface

FileSystemXmlApplicationContext: load the XML configuration file using the absolute path
ClassPathXmlApplicationContext: load the XML configuration file using a relative path, the SRC directory to the root directory

Ii. IoC container-bean Management (BASED on XML)

1. Bean management consists of two operations:

Spring creates objects
Spring injected properties

2. Create objects based on XML

When creating an object, the default is to execute the method of no argument construction to complete the object creation

<bean id="Id name, unique identifier of the Bean object" class="The full class name of the Bean object"></bean>
Copy the code

3. Inject attributes based on XML

DI: dependency injection ** (DI is a concrete implementation of IoC) **

Use the set method for injection

public class Book {
    // Create a property
    private String bname;

    // Create the set method corresponding to the attribute
    public void setBname(String bname) {
        this.bname = bname; }}Copy the code

<bean id="book" class="com.atguigu.spring5.Book">
    <! Name: the name of the property in the class value: the value injected into the property -->
    <propert1y name="bname" value="Hello"></property>
    <property name="bauthor" value="World"></property>
</bean>
Copy the code

Parameter constructor injection

public class Orders {
    / / property
    private String oname;
    private String address;
    // There are arguments
    public Orders(String oname,String address) {
        this.oname = oname;
        this.address = address; }}Copy the code

<bean id="orders" class="com.atguigu.spring5.Orders">
    <constructor-arg name="oname" value="Hello"></constructor-arg>
    <constructor-arg name="address" value="China！"></constructor-arg>
</bean>
Copy the code

P namespace injection

<! Add the p namespace to the configuration file header -->

        
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"		<!--Add a line herep-->

	<! Insert a property into a bean tag -->
    <bean id="book" class="com.atguigu.spring5.Book" p:bname="hello" p:bauthor="world"></bean>
</beans>
Copy the code

4. XML injects other types of attributes

Injection of null values

<property name="address">
    <null/>
</property>
Copy the code

Inject special symbols

<! There are two ways to escape symbols: &lt; To replace <, use CDATA -->
<property name = "address">
    <value><! [CDATA [< < Nanking > >]] ></value>
</property>
Copy the code

5. Inject properties: External beans

Create two classes, the Service class and the DAO class
Service invokes methods in dao

Do this in the Spring configuration file

Public class UserDao {private UserDao UserDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void add() { System.out.println("service add..............." ); // Call the DAO method userdao.update (); Public class UserDaoImpl implements UserDao {@override public void update() {system.out.println ("dao ") update..........." ); }}
Copy the code

Do this in the Spring configuration file

<bean id="userService" class="com.atguigu.spring5.UserService">    <! Ref attribute: create userDao bean tag id value -->    <property name="userDao" ref="userDaoImpl"></property></bean><bean id="userDaoImpl" class="com.atguigu.spring5.UserDaoImpl"></bean>
Copy the code

6. Inject properties: internal beans

One-to-many relationship: Departments and employees. One department has multiple employees, and one employee belongs to the same department

The one-to-many relationship between entity classes is represented, and the employee represents the department, which is represented by object type attributes

Public class Dept {private String dname; public void setDname(String dname) { this.dname = dname; Public class Emp {private String ename; private String gender; // Employees belong to a certain department. Private Dept Dept; public void setDept(Dept dept) { this.dept = dept; } public void setEname(String ename) { this.ename = ename; } public void setGender(String gender) { this.gender = gender; }}
Copy the code

Configure it in the Spring configuration file

<bean id="emp" class="com.atguigu.spring5.bean.Emp">    <! -- Set the value of the normal property -->    <property name="ename" value="Andy"></property>    <property name="gender" value="Female"></property>        <! Set the properties of the object type -->    <property name="dept">        <bean id="dept" name="com.atguigu.spring5.bean.Dept">            <property name="dname" value="Security Department"></property>        </bean>    </property></bean>
Copy the code

7. Inject properties: Cascade assignments

Method 1: Cascade assignment

<! -- Method 1: Cascade assignment --><bean id="emp" class="com.atguigu.spring5.bean.Emp">    <! Set two general properties -->    <property name="ename" value="Andy"></property>    <property name="gender" value="Female"></property>    <! -- Cascade assignment -->    <property name="dept" ref="dept"></property></bean><bean id="dept" class="com.atguigu.spring5.bean.Dept">    <property name="dname" value="Public relations department."></property></bean>
Copy the code

Generate the dept get method ** (must have get method) **

 <! -- Cascade assignment --><bean id="emp" class="com.atguigu.spring5.bean.Emp">    <! Set two general properties -->    <property name="ename" value="jams"></property>    <property name="gender" value="Male"></property>    <! -- Cascade assignment -->    <property name="dept" ref="dept"></property>    <property name="dept.dname" value="Technical Department"></property></bean><bean id="dept" class="com.atguigu.spring5.bean.Dept"></bean>
Copy the code

8. XML injects collection attributes

Inject array type properties
Inject the List collection type attribute
Inject Map collection type attributes
Inject the Set collection type property

Public class Stu {//1 private String[] courses; Private list 
      
        list; private list 
       
         list; //3 Map collection type attribute private map 
        
          maps; Private set 
         
           sets; private set 
          
            sets; public void setSets(Set
           
             sets) { this.sets = sets; } public void setCourses(String[] courses) { this.courses = courses; } public void setList(List
            
              list) { this.list = list; } public void setMaps(Map
             
               maps) { this.maps = maps; }}
             ,>
            
           
          
         
        ,string>
       
      
Copy the code

<! -- (2) Configure in the Spring configuration file --><bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">    <! -- Array type property injection -->    <property name="courses">        <array>            <value>Java classes</value>            <value>Database course</value>        </array>    </property>    <! --list type attribute injection -->    <property name="list">        <list>            <value>Zhang SAN</value>            <value>Small three</value>        </list>    </property>    <! -- Map attribute injection -->    <property name="maps">        <map>            <entry key="JAVA" value="java"></entry>            <entry key="PHP" value="php"></entry>        </map>    </property>    <! -- Set type attribute injection -->    <property name="sets">        <set>            <value>MySQL</value>            <value>Redis</value>        </set>    </property></bean>
Copy the code

9. Set the object type value in the collection

If the element type in the collection is an object, it cannot be injected in the normal way

Public class Course {private String cname; public void setCname(String cname) { this.cname = cname; } @Override public String toString() { return "Course{" + "cname='" + cname + '\'' + '}'; }}
Copy the code

Then edit the XML configuration file

<! Create course object --><bean id="course1" class="com.atguigu.spring5.collectiontype.Course">    <property name="cname" value="Spring5 framework"></property></bean><bean id="course2" class="com.atguigu.spring5.collectiontype.Course">    <property name="cname" value="MyBatis framework"></property></bean><! -- Then inject --> into the property<bean>    <property name="courseList">        <list>            <ref bean="course1"></ref>            <ref bean="course2"></ref>        </list>    </property></bean>
Copy the code

Extract the injected parts of the collection

Start by mapping the namespace util into the Spring configuration file


        <beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:util="http://www.springframework.org/schema/util"       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"></beans>
Copy the code

Use the util tag to complete the List collection injection extraction

<util:list id="bookList">    <value>Yi jin jing</value>    <value>Nine Yin true through</value>    <value>Sunflower treasure dian</value></util:list>
Copy the code

Inject the extracted collection type properties into use

<bean id="book" class="com.atguigu.spring5.collectiontype.Book">    <property name="list" ref="bookList"></property></bean>
Copy the code

11. FactoryBean

Spring beans come in two types: plain beans and factory Beans.
- Plain beans: The bean type defined in the configuration is the return type
- Factory Beans: Define bean types in configuration files that are different from return types
The first step is to create a class that acts as a FactoryBean and implements the interface FactoryBean

The second step is to implement the method in the interface and define the returned bean type in the implemented method

public class MyBean implements FactoryBean<Course> {    Throws Exception {Course Course = new Course(); // Override public Course getObject() throws Exception {Course Course = new Course(); course.setCname("hhh"); return course; }}
Copy the code

<bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean"></bean>
Copy the code

@Testpublic void test(a) {    ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");    Course Course = Context.getBean ("myBean", course.class); System.out.println(course); }
Copy the code

12. Bean scope

In Spring, beans are singleton objects by default (they can also be multi-instance objects, but we need to configure them manually)
Setting single-instance or multi-instance:
- There are properties in the Spring configuration file bean tagscopeTo set single-instance/multi-instance
- Scope attributes have two values: Singleton (single instance, default) and Prototype (multi-instance)
```
<! -- Set it to a multi-instance object --><bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype">        <property name="list" ref="bookList"></property></bean>
Copy the code
```
Singleton and Prototype
- Singleton instance, Prototype multi-instance
- Setting scope to Singleton creates a singleton when the Spring configuration file is loaded. With a value of prototype, create multi-instance objects only when calling getBean (lazy)

13. Bean life cycle

What is the life cycle: the process from object creation to destruction

Bean life cycle:

Create bean instance through constructor (no-parameter construction)
Set values for bean properties and references to other beans (set method)
Call the bean’s initialization method (configuration initialization method required)
You’ve got the object and you’re ready to use it
When the container is closed, the bean’s destruction method is called, at which point the object is destroyed (configuration destruction method is required)

public class Orders {    private String oname;        // No argument construct public Orders() {system.out.println (" the first step is to execute the no-argument construct to create the bean instance "); } public void setOname(String oname) { this.oname = oname; System.out.println(" Call the set method in the second step to set the property value "); } public void initMethod() {system.out.println (" the third step of the initialization method "); } public void destroyMethod() {system.out.println (" fifth destroyMethod "); }}
Copy the code

<bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">    <property name="oname" value="Mobile phone"></property></bean>
Copy the code

 @Test public void testBean3(a) {	ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");	Orders orders = context.getBean("orders", Orders.class);	System.out.println("Step 4 Get the create bean instance object");	System.out.println(orders); 	/ / manual for the bean instance destruction, need downward transition (ClassPathXmlApplicationContext applicationContext). The close (); }
Copy the code

The normal life cycle has five steps, and if a rear processor is configured, it has seven steps
1. Create bean instance through constructor (no-parameter construction)
2. Set values for bean properties and references to other beans (set method)
3. = = the bean bean instance transfer method of post processor (postProcessBeforeInitialization) = =
4. Call the bean’s initialization method (configuration initialization method required)
5. = = the bean bean instance transfer method of post processor (postProcessAfterInitialization) = =
6. You’ve got the object and you’re ready to use it
7. When the container is closed, the bean’s destruction method is called, at which point the object is destroyed (configuration destruction method is required)

Configure the backend handler (this applies to all beans in the configuration file if the backend handler is configured) :

// Create a post-processor implementation class, MyBeanPost implements BeanPostProcessor {@override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {system.out.println (" method executed before initialization "); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {system.out.println (" method executed after initialization "); return bean; }}
Copy the code

<bean id="myBeanPost" class="com.atguigu.spring5.bean.MyBeanPost"></bean>
Copy the code

14. Automatic assembly

What is auto-assembly?
- Spring automatically injects matching properties based on the specified assembly rule (property name or property type)

Implement automatic assembly process

The bean label property autowire configures autowire
Two common values for autowire:
- ByName: Automatic injection based on the property name. The id of the injected bean should be the same as the class property name
- ByType: Inject ** (cannot have two beans of the same type) ** based on the property type

Automatic injection based on the property name

<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">	<! --<property name="dept" ref="dept"></property>--></bean><bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
Copy the code

Automatic injection based on the property type

<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">	<! --<property name="dept" ref="dept"></property>--></bean><bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
Copy the code

15. External properties files

Configure the database information directly

Configure the Druid connection pool
Importing jar packages that druid depends on

<! Configure connection pool directly --><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>    <property name="url" value="jdbc:mysql://localhost:3306/study"></property>    <property name="username" value="root"></property>    <property name="password" value="root"></property></bean>
Copy the code

Import an external properties file to configure the database connection pool

Create external properties file, properties format file, write connection using database information

driverClass=com.mysql.jdbc.Driverurl=jdbc:mysql://localhost:3306/studyusername=rootpassword=root
Copy the code

Introduce the external properties properties file into the Spring configuration file ** (introduce the context namespace) **

<beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:context="http://www.springframework.org/schema/context"       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">    	<! Import external properties files with tags -->    <context:property-placeholder location="classpath:jdbc.properties"/>    <! -- Configure connection pool -->    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">        <property name="driverClassName" value="${driverClass}"></property>        <property name="url" value="${url}"></property>        <property name="username" value="${userName}"></property>        <property name="password" value="${password}"></property>    </bean></beans>
Copy the code

mo4tech.com (Moment For Technology) is a global community with thousands techies from across the global hang out!Passionate technologists, be it gadget freaks, tech enthusiasts, coders, technopreneurs, or CIOs, you would find them all here.

Spring Notes (1)

Spring IoC

I. IoC Container (Concept)

1. What is IoC?

2. What technologies are used at the bottom of IoC?

3. Spring provides two ways to implement the IoC container (two interfaces) :

4. Implementation class of the ApplicationContext interface

Ii. IoC container-bean Management (BASED on XML)

1. Bean management consists of two operations:

2. Create objects based on XML

3. Inject attributes based on XML

4. XML injects other types of attributes

5. Inject properties: External beans

6. Inject properties: internal beans

7. Inject properties: Cascade assignments

8. XML injects collection attributes

9. Set the object type value in the collection

Extract the injected parts of the collection

11. FactoryBean

12. Bean scope

13. Bean life cycle

14. Automatic assembly

15. External properties files

Spring Notes (1)

Spring IoC

I. IoC Container (Concept)

1. What is IoC?

2. What technologies are used at the bottom of IoC?

3. Spring provides two ways to implement the IoC container (two interfaces) :

4. Implementation class of the ApplicationContext interface

Ii. IoC container-bean Management (BASED on XML)

1. Bean management consists of two operations:

2. Create objects based on XML

3. Inject attributes based on XML

4. XML injects other types of attributes

5. Inject properties: External beans

6. Inject properties: internal beans

7. Inject properties: Cascade assignments

8. XML injects collection attributes

9. Set the object type value in the collection

Extract the injected parts of the collection

11. FactoryBean

12. Bean scope

13. Bean life cycle

14. Automatic assembly

15. External properties files

Related Posts

Tree structure and Java implementation

Java interviewers’ favorite keyword -volatile

Code specification