spring学习1:IOC的概念和作用

spring学习1:IOC的概念和作用

一、spring的优势

1.1 方便解耦，简化开发

通过spring提供的ioc容器，可以将对象间的依赖关系交给spring管理,避免硬编码造成的程序过渡耦合

1.2 AOP编程的支持

通过spring的aop功能可以实现面向切面编程

1.3 声明式的事务支持

1.4 方便集成其他第三方框架

二、ioc的概念和作用

ioc指的是控制反转,指的就是以前我们获取一个对象时采用的是自己创建一个的方式，这是一个主动的过程；而控制反转后，当我们需要对象时就跟工厂要，而工厂来帮我们创建或者查找对象，这是一个被动的过程。

这种被动接收对象的方式就是控制反转。

它的作用是削减计算机程序的耦合(解除代码中的依赖关系)

三、spring ioc的简单使用

创建一个maven工程，引入spring的依赖

pom文件的内容如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lyy</groupId>
    <artifactId>spring01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.16</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <!--spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

创建一个UserService的接口和实现类,以下是实现类

public class UserServiceImpl implements IUserService {
    @Override
    public void findAllUser() {
        userDao.findAll();
        System.out.println("查询全部用户");
    }
}

在resources目录下创建spring的配置文件applicationContext.xml，在其中配置一个userService的bean

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

    <!--把对象的创建交给spring来管理-->

    <bean id="userService" class="com.lyy.service.impl.UserServiceImpl">
    </bean>

</beans>

测试使用ioc来获取对象

public class Test2 {
    public static void main(String[] args) {
        //加载配置文件，初始化spring容器
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationCotext0.xml");
        //获取bean
        IUserService userService= (IUserService) app.getBean("userService");
        //执行bean的方法
        userService.findAllUser();

    }
}

以上的测试方法中，先初始化了spring容器，在这个过程中spring会将配置文件中配置的bean对象都放在容器中。然后再从容器中根据bean的id获取对象，执行对象的方法。

四、实例化bean的三种方式

4.1 使用无参数构造函数

默认情况下spring会使用bean的class指定的类中的无参数构造函数来创建bean,如果没有无参构造就会创建失败。

4.2 spring管理静态工厂,使用静态工厂的方法来创建bean对象

模拟一个静态工厂

public class UserServiceFactory {
    public static IUserService getInstance(){
        return new UserServiceImpl();
    }
}

在spring配置文件中使用工厂

<bean id="userService2" class="com.lyy.util.UserServiceFactory" factory-method="getInstance"></bean>

4.3 spring管理实例工厂,使用实例工厂的方法来创建bean对象

模拟一个实例工厂

public class UserServiceFactory2 {

    public  IUserService getUserService(){
        return new UserServiceImpl();
    }
}

在spring配置文件中先把实例工厂配置为bean,在使用实例工厂来创建对象

<bean id="userServiceFactory2" class="com.lyy.util.UserServiceFactory2">
</bean>

<bean id="userService3" factory-bean="userServiceFactory2" factory-method="getUserService">
</bean>

五、spring的依赖注入

通过控制反转， 把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。 ioc 解耦只是降低他们的依赖关系，但不会消除。例如service层的实现类肯定会依赖dao层。使用spring后可以让spring来维护这种依赖关系，就是让框架把持久层的对象传到service层

5.1 构造方法注入

在配置bean的标签中使用constructor-arg 标签来给bean注入属性

以下是一个用户类

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

下面通过构造方法在配置bean时传入属性

<bean id="user" class="com.lyy.domain.User">
        <constructor-arg name="name" value="张三"/>
        <constructor-arg name="age" value="18"/>
</bean>

5.2 set方法注入

在bean对应的类中提供set方法，在配置文件中使用proerty标签来传递属性值

<bean id="user2" class="com.lyy.domain.User">
       <property name="name" value="李四"/>
        <property name="age" value="22"/>
    </bean>

5.3 p名称空间注入，本质还是set方法

5.4 注入集合属性

5.4.1 数组

用来给bean中的数组类型的属性注入值

 <bean id="user3" class="com.lyy.domain.User">
        <property name="myArray">
            <array>
                <value>element1</value>
                <value>element2</value>
                <value>element3</value>
            </array>
        </property>
 </bean>

5.4.2 List

用来给bean中的List类型的属性注入值

<bean id="user4" class="com.lyy.domain.User">
        <property name="myList">
            <list>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </list>
        </property>
    </bean>

5.4.3 Set

用来给bean中的Set类型的属性注入值

<bean id="user5" class="com.lyy.domain.User">
        <property name="mySet">
            <set>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </set>
        </property>
    </bean>

5.4.4 Map

用来给bean中的Map类型的属性注入值

<bean id="user6" class="com.lyy.domain.User">
        <property name="myMap">
            <map>
                <entry key="a" value="1"></entry>
                <entry key="b" value="1"></entry>
                <entry key="c" value="1"></entry>
            </map>
        </property>
 </bean>

5.4.5 Properties

用来给bean中的Properties类型的属性注入值

<bean id="user7" class="com.lyy.domain.User">
        <property name="myProperties">
            <props>
                <prop key="x">1</prop>
                <prop key="y">1</prop>
                <prop key="z">1</prop>
            </props>
        </property>
 </bean>