spring第一天IOC对象创建以及属性注入与其配置文件核心总结_实现ioc创建主人对象,并注入房子和车子属性spring的xml配置和spring的注解配置-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_39734087/article/details/97830875

本文详细介绍了Spring框架的核心组成部分——IOC（控制反转），包括对象创建和属性注入的不同方式，如set方法注入、构造函数注入、p名称空间注入以及对象属性注入，并提供了配置文件的核心总结。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

spring是一站式框架

spring在javaee三层结构中，每一层都提供不同的解决技术

web层：springMVC
service层：spring的ioc
dao层：spring的jdbcTemplate

spring的核心两部分

aop：面向切面编程，扩展功能不休改代码实现
ioc：控制反转，一般创建对象通过new来完成，而spring则通过配置文件完成

spring的ioc操作

1.把对象创建交给spring配置文件进行管理

2.ioc操作两部分

ioc的配置文件方式
ioc的注解方式

IOC底层原理

xml配置文件
dom4j解决xml
工厂设计模式

ioc示例之对象创建

1.导入jar包
spring基础jar包

2.需要被创建的类

public class User {

    public void add(){
        System.out.println("add...");
    }

//   public static void main(String[] args){
        //创建类的原始做法
//        User user = new User();
//        user.add();
//    }

}

3.创建spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- ioc入门 通过无参构造函数创建User类对象最简单常用 
		id:取名称，可任意命名
		class:需要创建类的全路径
		scope:多实例视需求而定
		-->
    <bean id="user" class="cn.itcast.ioc.User" scope="prototype"></bean>
</beans>

4.测试类及方法

public class TestIoc {
    @Test
    public void testUser(){
        //1.加载spring的配置文件，创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        //2.得到配置创建对象
        User user1 = (User) context.getBean("user");
        User user2 = (User) context.getBean("user");
        System.out.println("user1:"+user1);
        System.out.println("user2:"+user2);
        user1.add();

    }
}

ioc示例之属性注入

创建对象时，向类里面设置属性值
属性注入的三种方式，前两种最为常用

属性注入之set方法注入

1.需要注入的类

package cn.itcast.property;

public class Book {
    private String bookName;

    public void setBookName(String bookName){
        this.bookName = bookName;
    }

    public void demoBook(){
        System.out.println("book:"+bookName);
    }
}

2.创建spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

  
    <!-- 使用set方法注入属性，先创建对象 -->
    <bean id="book" class="cn.itcast.property.Book">
        <!-- 注入属性值 -->
        <property name="bookName" value="红楼梦"/>
    </bean>

</beans>

3.创建测试类

package cn.itcast.property;

import cn.itcast.ioc.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestProperty {
  @Test
    public void testBook(){
        //1.加载spring配置文件，根据文件创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        Book book =(Book) context.getBean("book");
        book.demoBook();
    }
}

属性注入之有参构造函数注入

1.需要注入的类

package cn.itcast.property;

public class PropertyDemo1 {
    private String username;

    public PropertyDemo1(String username) {
        this.username = username;
    }
    public void test1(){
        System.out.println("demo1:"+username);
    }
}

2.创建spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

  <!-- 使用有参数构造来注入属性 -->
    <bean id="demo1" class="cn.itcast.property.PropertyDemo1">
        <!-- 注入属性值 -->
        <constructor-arg name="username" value="小马"/>
    </bean>

</beans>

3.创建测试类

package cn.itcast.property;

import cn.itcast.ioc.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestProperty {
  @Test
    public void testDemo1(){
        //1.加载spring配置文件，根据文件创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        
       PropertyDemo1 propertyDemo1 =(PropertyDemo1) context.getBean("demo1");
       propertyDemo1.test1();
    }
}

属性注入之p名称空间注入

1.需要注入的类

package cn.itcast.property;

public class Person {
    private String pname;

    public void setPname(String pname){
        this.pname = pname;
    }

    public void test1(){
        System.out.println("person:"+pname);
    }
}

2.创建spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 <!-- p名称空间注入 -->
    <bean id="person" class="cn.itcast.property.Person" p:pname="lucy"></bean>
</beans>

3.创建测试类

package cn.itcast.property;

import cn.itcast.ioc.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestProperty {
@Test
    public void testPerson() {
        //1.加载spring配置文件，根据文件创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        Person person = (Person) context.getBean("person");
        person.test1();
    }
}

属性注入之对象属性注入

1.需要注入的类

package cn.itcast.ioc;

public class UserService {

    //1.定义一个dao类型属性
    private UserDao userDao;

    //2.生成set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("service");
    }
}

package cn.itcast.ioc;

public class UserDao {
    public void add() {
        System.out.println("UserDao");
    }
}

2.创建spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

   <!-- 注入对象类型的属性 -->
    <!-- 配置service和dao对象 -->
    <bean id="userDao" class="cn.itcast.ioc.UserDao"></bean>
    <bean id="userService" class="cn.itcast.ioc.UserService">
        <!-- 注意:现在已经不是value了，而是ref;value赋值是字符串，ref赋值是对象 -->
        <property name="userDao" ref="userDao"/>
    </bean>

3.创建测试类

package cn.itcast.property;

import cn.itcast.ioc.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestProperty {
@Test
    public void testPerson() {
        //1.加载spring配置文件，根据文件创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        Person person = (Person) context.getBean("person");
        person.test1();
    }
}

属性注入之复杂数据注入

1.需要注入的类

package cn.itcast.property;

import java.util.List;
import java.util.Map;
import java.util.Properties;

public class Complex {
    private String[] args;
    private List<String> list;
    private Map<String,String> map;
    private Properties properties;

    public void setArgs(String[] args) {
        this.args = args;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void test1(){
        System.out.println("args:"+args);
        System.out.println("list:"+list);
        System.out.println("map:"+map);
        System.out.println("properties:"+properties);
    }
}

2.创建spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

   <!-- 注入复杂类型数据 -->
    <bean id="complex" class="cn.itcast.property.Complex">
        <!-- 数组 -->
        <property name="args">
            <list>
                <value>小王</value>
                <value>小马</value>
                <value>小宋</value>
            </list>
        </property>

        <!-- list -->
        <property name="list">
            <list>
                <value>阿猫</value>
                <value>阿狗</value>
                <value>阿三</value>
            </list>
        </property>

        <!-- map -->
        <property name="map">
            <map>
                <entry key="AA" value="11"></entry>
                <entry key="BB" value="22"></entry>
                <entry key="CC" value="33"></entry>
            </map>
        </property>

        <!-- properties -->
        <property name="properties">
            <props>
                <prop key="driverClass">com.mysql.jdbc.driver</prop>
                <prop key="username">tom</prop>
            </props>
        </property>
    </bean>

3.创建测试类

package cn.itcast.property;

import cn.itcast.ioc.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestProperty {
 @Test
    public void testComplex() {
        //1.加载spring配置文件，根据文件创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        //
        Complex complex = (Complex) context.getBean("complex");
        complex.test1();
    }
}

属性注入与其配置文件核心总结

set方法注入普通属性

    <bean id="book" class="cn.itcast.property.Book">
        <!-- 注入属性值 -->
        <property name="bookName" value="红楼梦"/>
    </bean>

有参构造函数注入普通属性

<bean id="demo1" class="cn.itcast.property.PropertyDemo1">
        <!-- 注入属性值 -->
        <constructor-arg name="username" value="小马"/>
 </bean>

set方法p名称空间注入

<bean id="person" class="cn.itcast.property.Person" p:pname="lucy"></bean>
注：pname是Person类中的set方法setPname

对象属性注入

<bean id="userDao" class="cn.itcast.ioc.UserDao"></bean>
    <bean id="userService" class="cn.itcast.ioc.UserService">
        <property name="userDao" ref="userDao"/>
    </bean>
    注：在userService中注入userDao
    property:value,取值是字符串;ref，取值是对象类型。