spring复习01，IOC的思想和第一个spring程序helloWorld

IOC的思想

IOC：Inversion of Control，翻译过来是反转控制。
翻转资源获取方向。把自己创建资源、向环境索取资源变成环境将资源准备好，我们享受资源注入。

• 获取资源的传统方式:
  在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的
  模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效
  率。
• 反转控制方式获取资源:
  反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主
  动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的，只需要提供接收资源
  的方式即可，极大的降低了学习成本，提高了开发的效率。这种行为也称为查找的被动形式。

比较抽象，对吧那就看看下面的小例子。

---

一个小例子，来体会IOC的基础思想。

一个小例子，来体会IOC的基础思想。

dao层

dao层接口

package com.gothic.sunset.dao;

public interface UserDao {

    void getUser();
}

1
2
3
4
5
6
7

dao层实现类

实现类1：

package com.gothic.sunset.dao;

public class UserDaoImpl implements UserDao{


    @Override
    public void getUser() {
        System.out.println("获取数据信息");
    }
}

1
2
3
4
5
6
7
8
9
10
11

实现类2：

package com.gothic.sunset.dao;

public class UserDaoMysqlImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("获取Mysql数据信息");
    }
}

1
2
3
4
5
6
7
8
9

实现类3：

package com.gothic.sunset.dao;

public class UserDaoOracleImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("获取Oracle数据信息");
    }
}

1
2
3
4
5
6
7
8
9

service层

service层接口

package com.gothic.sunset.service;

public interface UserService {

    void getUser();
}

1
2
3
4
5
6
7

service层实现类

package com.gothic.sunset.service;

import com.gothic.sunset.dao.UserDao;
import com.gothic.sunset.dao.UserDaoImpl;

public class UserServiceImpl implements UserService{

    private UserDao userDao = new UserDaoImpl();
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试代码

import com.gothic.sunset.service.UserService;
import com.gothic.sunset.service.UserServiceImpl;

public class MyTest {

    public static void main(String[] args) {
        UserService userService1 = new UserServiceImpl();
        userService1.getUser();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

运行输出后，发现只能根据上面service层实现类中固定的dao实现类对象来输出。
如果现在我需要里面的实现类对象为实现类2的对象，那么我就需要去修改service层中的实现类，然后如果代码比较多的话，改动会非常大，牵一发而动全身。那么如何解决这一问题呢？
其实可以在service层，通过set注入dao实现类对象来进行，修改如下：

service层实现类修改

package com.gothic.sunset.service;

import com.gothic.sunset.dao.UserDao;
import com.gothic.sunset.dao.UserDaoImpl;

public class UserServiceImpl implements UserService{

    private UserDao userDao ;

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

测试代码修改

import com.gothic.sunset.dao.UserDaoImpl;
import com.gothic.sunset.dao.UserDaoMysqlImpl;
import com.gothic.sunset.service.UserService;
import com.gothic.sunset.service.UserServiceImpl;

public class MyTest {

    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(new UserDaoMysqlImpl());//通过set注入将程序主动权释放
        userService.getUser();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

IOC容器在spring中的简单实现

Spring 的 IOC 容器就是 IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建bean 之前，首先需要创建 IOC 容器。
Spring 提供了 IOC 容器的两种实现方式：

• 1.BeanFactory
  这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。
• 2.ApplicationContext
  BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用ApplicationContext 而不是底层的 BeanFactory。
  

创建项目

创建一个maven项目，file–>new–>project，然后一直next到finish即可。

在pom.xml中引入依赖

导入依赖后记得更新依赖。

 	<dependencies>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.3.1version>
        dependency>
        
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>
    dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

实体类创建

第一个例子，当然是helloworld啦！！

package com.gothic.sunset.demo;

public class HelloWorld {

    public void sayHello(){
        System.out.println("HelloWorld!");
    }
}

1
2
3
4
5
6
7
8
9

创建spring的配置文件并且配置bean

在resources目录下，右键选择new–>xml configuration file–>spring config，然后命名为applicationContext.xml.
在applicationContext.xml中，我们需要配置HelloWorld所对应的bean，即将HelloWorld的对象交给Spring的IOC容器管理。
通过bean标签配置IOC容器所管理的bean属性：

• id：设置bean的唯一标识
• class：设置bean所对应类型的全类名

<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="HelloWorld" class="com.gothic.sunset.demo.HelloWorld">bean>
beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

创建测试用例，测试输出

    @Test
    public void testHello(){
    	// 通过ClassPathXmlApplicationContext读取spring配置文件来获取IOC容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloWorld helloWorld = (HelloWorld)ioc.getBean("HelloWorld");
        helloWorld.sayHello();
    }
1
2
3
4
5
6
7
8

---

今天,spring的IOC回顾就到此结束啦！！！！其中的例子只是最简单的例子，后续文章再详细展开。