依赖注入的三种方式

DI(依赖注入)

注入的三种方法：构造器方法注入，set注入，基于注解的注入（接口注入）

1：构造器方法注入

创建一个Address类；

public class Address {
    private String address;

    public Address() {
    }

    public Address(String address) {
        this.address = address;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}

配置bean.xml

     <bean id="address" class="com.kuang.pojo.Address">
        <constructor-arg index="0" value="diqui"/>
    </bean>

在bean标签内部使用 constructor-arg标签

type属性：使用类型指定构造方法中参数的类型

index属性：使用构造方法中参数索引值来 进行注入

name属性 ：使用构造方法中参数名称 来注入 （ 常用！）

value属性：要注入的值（基本数据类型和String类型）

ref属性：要注入的值（引用在IOC容器中其他的bean对象）

优点：创建时必须要指定构造方法中的全部参数，bean才能被创建，保证了对象创建出来之后，成员变量一定都有值

缺点：必须要指定全部参数，否则无法创建，使用该方式改变了对象的创建过程

2： set注入

Set属性注入:必须要有一个无参的构造方法，否则只能用构造方法构造

1：创建一个User的类，给User一个Name属性；（这里是通过调用我们的set方法进行实现的）

2：配置xml文件

<!--IOC创建对象的方式，默认使用无参的构造方法！-->
<bean id="user" class="com.kuang.pojo.User">
    <property name="name" value="幺鸡"/>
</bean>

本质上包含两步：
第一步，需要new UserServiceImpl()创建对象, 所以需要默认构造函数
第二步，调用setUserDao()函数注入userDao的值, 所以需要setUserDao()函数

UserDaoImpl

public class UserDaoImpl implements UserDao {

    @Override
    public void getUser() {
        System.out.println("默认获取用户的数据！");
    }
}

UserServiceImpl

public class UserServiceImpl implements UserService {


    private UserDao userDao;


    //利用set进行动态实现值的注入！
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

依赖注入：Set注入

• 依赖：bean 对象的创建依赖于容器
• 注入：bean 对象中的所有属性，有容器来注入！

1：谁依赖于谁：
当然是应用程序依赖于IoC容器；

2：为什么需要依赖：
应用程序需要IoC容器来提供对象需要的外部资源

3：谁注入谁：
很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；

4：注入了什么：
就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

https://blog.csdn.net/qq_42709262/article/details/81951402

【环境搭建】

复杂类型
1：创建一个Student的类；

public class Student {

    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> cards;
    private Set<String> games;
    //空指针
    private String wife;
    //Properties 配置类（配置文件等）
    private Properties info;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbys() {
        return hobbys;
    }

    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }

    public Map<String, String> getCards() {
        return cards;
    }

    public void setCards(Map<String, String> cards) {
        this.cards = cards;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbys=" + hobbys +
                ", cards=" + cards +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

2：配置bean.xml

<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">

    <bean id="address" class="com.kuang.pojo.Address">
        <property name="address" value="地球"/>
    bean>

    <bean id="student" class="com.kuang.pojo.Student">
        
        <property name="name" value="hanshuo"/>

        
        <property name="address" ref="address"/>

        
        <property name="books">
            <array>
                <value>西游记value>
                <value>红楼梦value>
                <value>水浒传value>
                <value>三国演义value>
            array>
        property>

        
        <property name="hobbys">
            <list>
                <value>听歌value>
                <value>敲代码value>
                <value>改Bugvalue>
            list>
        property>

        
        <property name="cards">
            <map>
                <entry key="身份证" value="12345680"/>
                <entry key="手机号" value="8676442268"/>
            map>
        property>

        
        <property name="games">
            <set>
                <value>LOLvalue>
                <value>COCvalue>
                <value>BOBvalue>
            set>
        property>

        
        <property name="wife">
            <null/>
        property>

        
        <property name="info">
            <props>
                <prop key="driver">20192301prop>
                <prop key="url">com.baidu.dirverprop>
                <prop key="username">rootprop>
                <prop key="paeeword">rootprop>
            props>
        property>
    bean>

beans>

3：测试

    @Test
    public void address(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Address address = context.getBean("address", Address.class);


        System.out.println(address.getAddress());

        System.out.println(address.toString());
    }

    @Test
    public void student(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = context.getBean("student", Student.class);

        System.out.println(student.toString());
    }

4：测试结果：

/**
 * 
 * 
 * 
 * 地球
 * Address{address='地球'}
 * 
 * 
 * 
 * 
 Student{
 name='hanshuo',
 address=Address{address='山东'},
 books=[西游记, 红楼梦, 水浒传, 三国演义],
 hobbys=[听歌, 敲代码, 改Bug],
 cards={身份证=12345680, 手机号=8676442268},
 games=[LOL, COC, BOB],
 wife='null',
 info={url=com.baidu.dirver, driver=20192301, username=root, paeeword=root}
 }

 */

p 命名和c 命名空间注入

1：创建一个User的类

public class User {
    private String name;
    private int age;

    public User(){

    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2；配置它的Bean

<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"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    
    <bean id="user" class="com.kuang.pojo.User" p:name="绘画" p:age="12"/>

    
    <bean id="user2" class="com.kuang.pojo.User" c:name="幺鸡" c:age="20"/>


beans>

可以直接输入属性的值： property
注意点：p命名空间和c命名空间不能直接使用，需要导入xml约束

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

测试：

    //p命名空间
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("userBeans.xml");
        User user = context.getBean("user", User.class);
        User user1 = context.getBean("user", User.class);

        System.out.println(user == user1);

        System.out.println(user);
    }

Bean的作用域

1：单例模式（Spring默认机制，）

<bean id="user" class="com.kuang.pojo.User" p:name="绘画" p:age="12" scope="singleton"/>

2：原型模式：每次从原型中get的时候，都会产生一个新的对象；

<bean id="user" class="com.kuang.pojo.User" p:name="绘画" p:age="12" scope="prototype"/>

3：其余的request , session, application

Spring 只帮我们管理单例模式 Bean 的完整生命周期，对于 prototype 的 bean ，Spring 在创建好交给使用者之后则不会再管理后续的生命周期。

Spring 容器可以管理 singleton 作用域 Bean 的生命周期，在此作用域下，Spring 能够精确地知道该 Bean 何时被创建，何时初始化完成，以及何时被销毁。

而对于 prototype 作用域的 Bean，Spring 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理，Spring 容器将不再跟踪其生命周期。每次客户端请求 prototype 作用域的 Bean 时，Spring 容器都会创建一个新的实例，并且不会管那些被配置成 prototype 作用域的 Bean 的生命周期。

了解 Spring 生命周期的意义就在于，可以利用 Bean 在其存活期间的指定时刻完成一些相关操作。这种时刻可能有很多，但一般情况下，会在 Bean 被初始化后和被销毁前执行一些相关操作。

关于Bean的生命周期
https://www.cnblogs.com/zrtqsk/p/3735273.html