SpringIOC注入

1.手动注入方法：set注入，构造器注入，静态工厂注入，实例化工厂注入

1.1 set注入

在类中需要别的bean/基本数据类型，需要设置对应的set方法
实例化A时需要B注入，先实例化A，再把B实例化

public class UserService {
    //bean类型注入
    private dao1 dao1;
    public void setDao1(dao1 dao1){
        this.dao1=dao1;
    }

    //基本类型注入
    private String data;
    public void setData(String data){
        this.data=data;
    }

    //集合注入
    private List<String> list;
    public void setList(List<String> list){
        this.list=list;
    }
    public void printList(){
        list.forEach((v -> System.out.println(v)));
    }


    public void test(){
        System.out.println("UserService.test");
        dao1.test();

        System.out.println(data);

        printList();
    }
}

在spring.xml对应的bean标签中设置property属性

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                            https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--set方法注入
            name:属性字段名字
            ref：bean标签的id
            value：具体值 -->
    <bean id="UserService" class="com.xxx.service.UserService">
<!--        bean对象-->
        <property name="dao1" ref="dao1"></property>
<!--        基本类型-->
        <property name="data" value="lwxlwx"></property>
<!--        集合注入-->
        <property name="list">
            <list>
                <value>list1</value>
                <value>list2</value>
            </list>
        </property>
    </bean>

    <bean id="dao1" class="com.xxx.dao.dao1"></bean>


</beans>

调用方法

public static void main( String[] args )
    {
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");

        UserService us=(UserService) ac.getBean("UserService");
        us.test();

    }

1.1.2 p名称空间

在spring.xml添加

xmlns:p="http://www.springframework.org/schema/p"

<!--   p名称空间-->
    <bean id="UserService" class="com.xxx.service.UserService"
          p:dao1-ref="dao1">

    </bean>
    <bean id="dao1" class="com.xxx.dao.dao1"></bean>

1.2 构造器注入

package com.xxx.service;
import com.xxx.dao.dao1;
public class UserService2 {

    private dao1 dao1;
    /**
        构造器注入需要带参构造函数
     */
    public UserService2(dao1 dao1) {
        this.dao1=dao1;
    }

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

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                            https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--构造器方法注入
            constructor-arg：设置要注入的类属性
                name：属性字段名
                ref：要注入的bean标签的id
                index:参数位置从0开始 -->
    <bean id="UserService2" class="com.xxx.service.UserService2">
        <constructor-arg name="dao1" ref="dao1"></constructor-arg>
<!--        多个参数多个constructor-arg标签-->
<!--        <constructor-arg name="dao2" ref="dao2"></constructor-arg>-->
<!--        <constructor-arg name="data" value="strstr" index="0"></constructor-arg>-->
    </bean>

    <bean id="dao1" class="com.xxx.dao.dao1"></bean>

循环依赖

实例化A时需要注入B（第一步先去实例化B，再去实例化A），同时B实例化又需要A

package com.xxx.service;
import com.xxx.dao.dao2;
public class UserService21 {


    private dao2 dao2;
    public UserService21(dao2 dao2){
        this.dao2=dao2;
    }

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

package com.xxx.dao;

import com.xxx.service.UserService21;

public class dao2 {

    private UserService21 userService21;
    public dao2(UserService21 userService21){
        this.userService21=userService21;
    }

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

<!--    循环依赖问题-->
    <bean id="UserService21" class="com.xxx.service.UserService21">
        <constructor-arg name="dao2" ref="dao2"></constructor-arg>
    </bean>

    <bean id="dao2" class="com.xxx.dao.dao2">
        <constructor-arg name="userService21" ref="UserService21"></constructor-arg>

    </bean>

/**
     * 循环依赖问题
     *      直接使用报错：Requested bean is currently in creation: Is there an unresolvable circular reference?
     *      通过set注入解决
     */
    public void fun(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring2.xml");

        UserService21 us=(UserService21) ac.getBean("UserService21");
        us.test();
    }

2.自动注入方式：注解方式注入

2.1 Resource注解

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
<!--        自动注入-->
    <context:annotation-config></context:annotation-config>

    <bean id="UserService" class="com.xxx.service.UserService"></bean>
    <bean id="dao1" class="com.xxx.dao.dao1"></bean>

<!--    接口实现类-->
    <bean id="daoi" class="com.xxx.dao.daoi"></bean>
</beans>

public class UserService {
    /**
     * 1、默认通过字段名称查找对于bean的id
     * 2、属性字段不一样，通过类型来找到
     * 3.属性字段提不提供set方法都可以
     * 4。注解可以声明在属性字段/set方法上
     * 5.可以设置name属性，要与bean的id一致 @Resource(name="name")
     * 6.当注入接口时，接口有多个实现类，要用name来指定
     */
    @Resource
    private dao1 dao1;

    //注入接口
    @Resource(name="daoi")
    private dao dao;

    public void test(){
        System.out.println("us.test");
        dao.test();
    }
}

2.1 Autowired注解

public class User {
    /**
     * 1.默认使用类型去查，和属性字段名称无关
     * 2、set方法可以不提供也可以提供
     * 3.写在字段/方法前
     * 4、想通过名字查，要用Qualifier(value='id')结合使用
     */
    @Autowired
    private UserDao userDao;

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