J2EE进阶学习——Spring框架(二):IOC

一、IOC入门

第一步：导入jar包

• 做Spring最基本功能的时候，导入四个核心jar包即可
• 导入支持日志输出的jar包

只需导入选中包即可完成基本操作

第二步：创建类，在类里面创建方法

IOC底层原理

原始做法

package com.TiHom.ioc;

/**
 * @author TiHom
 */
public class User {
    public void add(){
        System.out.println("add...");
    }

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

第三步：创建Spring配置文件，配置创建类

1.Spring核心配置文件名称和位置不是固定的

• 建议放到src下面，官方建议applicationContext.xml

2.编写xml文件时，需要引入schema约束，参考Spring文档中的写法，下面是Spring Framework文档的网站

https://docs.spring.io/spring/docs/current/spring-framework-reference/

<?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
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <bean id="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <!-- more bean definitions go here -->

</beans>

可以看到在文档中xml文件是这样来配置的

3.配置对象创建

<!-- ioc入门 -->
    <bean id="user" class="com.TiHom.ioc.User"></bean>

4.写代码测试对象创建

• 这段代码在测试中使用，实际开发不用写

package com.TiHom.ioc;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author TiHom
 */
public class TestIOC {
    @Test
    public void testUser(){
        //1.加载spring的配置文件，根据创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //2.得到配置创建的对象
        User user = (User) context.getBean("user");
        System.out.println(user);
        user.add();
    }
}

---

---

二、bean实例化的三种方式（后面两种基本不用，但要求知道）

1.使用类的无参构造创建对象（重点）

在User类中
public User(){}
在xml文件中
<bean id="user" class="com.TiHom.ioc.User" ></bean>

2.静态工厂创建对象

静态工厂方法

pubic class Bean2Factory{
    //静态的方法，返回Bean2对象
    public static Bean2 getBean2(){
        return new Bean2();
    }   
}

xml中的配置

<bean id="bean2" class="com.TiHom.bean.Bean2Factory" factory-method="getBean2"></bean>

3.实例工厂创建对象

实例工厂方法

public class Bean3Factory{
    //普通的方法，返回Bean3对象
    public Bean3 getBean3(){
        return new Bean3();
    }
}

xml中的配置

<!-- 先创建工厂对象 -->
<bean id="bean3Factory" class="com.TiHom.bean.Bean3Factory" ></bean>
<bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3"></bean> 

Bean3

public class Bean3{
    public void add(){
        .....
    }
}

---

---

三、bean标签常用属性

1. id属性：根据id值得到配置对象
2. class属性：创建对象所在类的全路径
3. name属性：功能和id属性一样的，id属性值中不能包含特殊符号，但是name可以（不怎么用，这是遗留性的）
4. scope属性

• singleton：默认值，单例
• prototype：多例

<bean id="xxx" class="xxx" scope="prototype"></bean>

User user1 =  (User) context.getBean("xxx");
User user2 =  (User) context.getBean("xxx");

输出的结果就是两个user为不同的地址

---

---

四、属性注入

1.创建对象的时候，向类里面属性里面设置值
2.属性注入的方式：（java代码中）

三种注入方式

3.在Spring框架里面，支持前两种方式

• set方法注入（重点，实际开发用的最多）
  创建一个Book对象

public class Book{
    private String bookname;
    public void setBookname(String bookname){
        this.bookname = bookname;
    }
    
    public void demobook(){
        .....
    }
}

xml中的配置

<bean id="book" class="com.TiHom.property.Book">
    <!-- 
          name属性值：类里面定义的属性名称
          value属性值：设置具体的值
    -->
    <property name="bookname" value="龙族"></property>
</bean>

---

• 有参构造注入
  xml中配置

<bean id="demo" class="com.TiHom.property.PropertyDemo1">
    <!-- 有参注入 -->
    <constructor-arg name="username" value="TiHom"></constructor-arg>
</bean>

PropertyDemo1

public class PropertyDemo1{
    private String username;
    public PropertyDemo1(String username){
        this.username = username;
    }
    public void test(){
        .....
    }
}

---

---

五、注入对象属性值

创建一个UserDao

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

创建一个UserService

public class UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

xml

<bean id="userDao" class="com.TiHom.ioc.UserDao"></bean>
    <bean id="userService" class="com.TiHom.ioc.UserService">
        <!--
            name属性：service类里面属性的名称
            ref属性：dao配置bean标签id值
        -->
        <property name="userDao" ref="userDao"></property>
    </bean>

xml配置

p名称空间注入

<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
        http://www.springframework.org/schema/beans/spring-beans.xsd"
        xmlns:p="http://www.springframework.org/schema/p">
<bean id="person" class="com.TiHom.property.Person" p:pname="xxx"></bean>

---

---

六、复杂类型注入

1.数组
2.list集合
3.map集合
4.properties类型

xml

<bean id="person" class="com.TiHom.ioc.Person">
        <!-- 数组 -->
        <property name="arrs">
            <list>
                <value></value>
                <value></value>
                <value></value>
            </list>
        </property>
        <!-- list -->
        <property name="list">
            <list>
                <value></value>
            </list>
        </property>
        <!-- map -->
        <property name="map">
            <map>
                <entry key="aaa" value="xx"></entry>
            </map>
        </property>
        <!-- properties -->
        <property name="properties">
            <props>
                <prop key="driverClass">com.mysql.jdbc.Driver</prop>
                <prop key="username">root</prop>
            </props>
        </property>
    </bean>

Person

public class Person {
    private String pname;

    private String[] arrs;
    private List<String> list;
    private Map<String,String> map;
    private Properties properties;

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

    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }

    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(arrs);
        System.out.println(list);
        System.out.println(map);
        System.out.println(properties);
    }
}

---

---

七、IOC和DI的区别

1.IOC：控制反转，将对象的创建交给Spring进行配置
2.DI：依赖注入，将类里面的属性中设置值
3.关系：依赖注入不能单独存在，需要在IOC的基础上完成操作