【Spring学习01】Spring的Ioc和DI

ぃ小男孩つ

已于 2022-03-25 19:08:01 修改

阅读量235

点赞数 1

分类专栏： SSM 文章标签： spring 学习 java

于 2022-03-18 11:15:37 首次发布

本文链接：https://blog.csdn.net/qq_54699828/article/details/123566535

版权

SSM 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1.Spring简介

1.1 什么是spring

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

提供了展现层 SpringMVC 和持久层 Spring JDBCTemplate 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

DI（Dependency Injection），即“依赖注入”，组件之间依赖关系由容器在运行期决定，即容器动态的将某个依赖关系注入到组件当中。它是是 Spring 框架核心IOC技术的具体实现。

1.2 Spring的优势

1）方便解耦，简化开发：通过 Spring 提供的 IoC容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

2）AOP 编程的支持

3）声明式事务的支持

4）方便程序的测试

5）方便集成各种优秀框架

2.Spring快速入门

2.1 spring开发步骤

① 导入 Spring 开发的基本包坐标

② 编写 Dao 接口和实现类

③ 创建 Spring 核心配置文件

④ 在 Spring 配置文件中配置 UserDaoImpl

⑤ 使用 Spring 的 API 获得 Bean 实例

2.2 导入spring开发基本包坐标

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

2.3 编Dao接口以及实现类

public interface UserDao {
    public void print();
}

public class UserDaoImpl implements UserDao {
@Override
public void print() {
System.out.println("hello spring");
    }
}

2.4 创建spring核心配置文件

在resource下创建applicationContext.xml文件

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

2.5 在 Spring 配置文件中配置 UserDaoImpl

<!--<bean id="UserDao" class="Dao.Impl.UserDaoImpl" scope="singleton">
    </bean>-->

2.6 使用 Spring 的 API 获得 Bean 实例

@Test
public void test1(){
ApplicationContext applicationContext = new 
ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
userDao.save();
}

3. Spring配置文件

3.1 Bean基本标签配置

用于配置对象交由Spring 来创建。 默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

基本属性：

id：Bean实例在Spring容器中的唯一标识

class：Bean的全限定名称

3.2 Bean标签的范围配置

scope：指对象的作用范围，取值主要有：singleton和prototype

3.2.1 singleton：默认值，单例

3.2.2 prototype:多例

3.3 Spring依赖注入入门

1.创建 UserService，UserService 内部在调用 UserDao的print() 方法

public class UserServiceImpl implements UserService {
@Override
public void test() {
ApplicationContext applicationContext = new 
ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
userDao.print();
}
}

2. 将 UserServiceImpl 的创建权交给 Spring

<bean id="UserService" class="service.Impl.UserServiceImpl">

3. 从 Spring 容器中获得 UserService 进行操作

ApplicationContext applicationContext = new 
ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) applicationContext.getBean("userService");
userService.print();

分析

目前UserService实例和UserDao实例都存在与Spring容器中，当前的做法是在容器外部获得UserService 实例和UserDao实例，然后在程序中进行结合。

因为UserService和UserDao都在Spring容器中，而最终程序直接使用的是UserService，所以可以在 Spring容器中，将UserDao设置到UserService内部。

3.4 Bean依赖注入概念

依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。在编写程序时，通过控制反转（Ioc），把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。 IOC 解耦只是降低他们的依赖关系，但不会消除。

例如：业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取

3.5 Bean的依赖注入方式

思考？怎么将UserDao怎样注入到UserService内部呢？

方法：1.set方法 2.构造方法（有参构造）

1）set方法注入

在UserServiceImpl中添加UserDao的set方法

public class UserServiceImpl implements UserService {

    private UserDao userDao;
    //bean的依赖注入
    //1.set方法注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void print() {
        userDao.print();
    }
}

配置Spring容器调用set方法进行注入

    <bean id="UserService" class="service.Impl.UserServiceImpl">
<!--          下面的name代表的是UserServiceImpl下setUserDao中set后面的名称，大写变成小写  -->
<!--                对象的引用使用ref，引用的是Dao里面的id对象UserDao-->
<!--                set方法注入-->
                <property name="userDao" ref="UserDao"></property>       
    </bean>

2）构造方法注入

在UserServiceImpl中添加UserDao的有参构造方法

//2.有参构造方法注入
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

配置Spring容器调用有参构造方法进行注入

 <bean id="UserService" class="service.Impl.UserServiceImpl">
               <!--        有参构造注入,这里的userDao代表的是传入的参数-->
        <constructor-arg name="userDao" ref="UserDao"></constructor-arg>
    </bean>

3.6 spring的依赖注入的数据类型

1. 普通数据类型

2. 引用数据类型（上述就是引用类型，下面不再举例）

3. 集合数据类型

1）普通数据类型

在UserServiceImpl实现类中设置两个成员变量，并且设置它们的set方法

public class UserDaoImpl implements UserDao {

    private String username;
    private int age;

    public void setUsername(String username) {
        this.username = username;
    }

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


    @Override
    public void print() {
        System.out.println(username+":"+age);
    }
}

然后在spring配置文件中添加注入

 <bean id="UserDao" class="Dao.Impl.UserDaoImpl" scope="singleton">

        <property name="username" value="Adrian"></property>
        <property name="age" value="18"></property>
    </bean>

3）集合数据类型

在UserServiceImpl实现类中设置三种集合类型，并且设置它们的set方法

public class UserDaoImpl implements UserDao {

    private List<String > strList;
    private Map<String, User> userMap;
    private Properties properties;

    public void setStrList(List<String> strList) {
        this.strList = strList;
    }

    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public void print() { 
        System.out.println(strList);
        System.out.println(userMap);
        System.out.println(properties);
    }
}

因为在Map集合里面有一个User对象，因此我们新建User对象，在User类里面设置两个成员变量，并且设置set和get方法

public class User {
    private String name;
    private String addr;

    public String getName() {
        return name;
    }

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

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

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

然后在配置文件中设置集合类型的数据注入

 <bean id="UserDao" class="Dao.Impl.UserDaoImpl" scope="singleton">
        <property name="strList">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>
        <property name="userMap">
            <map>
                <entry key="u1" value-ref="user1"></entry>
                <entry key="u2" value-ref="user2"></entry>
            </map>
        </property>

        <property name="properties">
            <props>
                <prop key="p1">hahaha</prop>
                <prop key="p2">lalala</prop>
            </props>
        </property>

    </bean>

设置User的配置文件

<bean id="use1" class="domain.User">
        <property name="name" value="Young"></property>
        <property name="addr" value="XiaMen"></property>
    </bean>
    <bean id="use2" class="domain.User">
        <property name="name" value="Adrian"></property>
        <property name="addr" value="Zhangzhou"></property>
    </bean>

运行结果：

拓展：上述user配置文件我们可以写到单独的applicationContext-user.xml模块中，然后用import标签进行引用

<?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="user1" class="domain.User">
        <property name="name" value="Adrian"></property>
        <property name="addr" value="XiaMen"></property>
    </bean>
    <bean id="user2" class="domain.User">
        <property name="name" value="Young"></property>
        <property name="addr" value="ZhangZhou"></property>

    </bean>
</beans>

 <import resource="applicationContext-user.xml"/>

3.7 Spring的重点配置

4. Spring相关的API

4.1 ApplicationContext的实现类

4.2 getBean的源码以及使用

public Object getBean(String name) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name);
}
public <T> T getBean(Class<T> requiredType) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(requiredType);
}

其中，当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错。

getBean方法的使用

ApplicationContext applicationContext = new 
ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService1 = (UserService) 
applicationContext.getBean("userService");

UserService userService2 = applicationContext.getBean(UserService.class);

4.3 Spring重点API

ApplicationContext app = new ClasspathXmlApplicationContext("xml文件")
app.getBean("id")
app.getBean(Class)

ぃ小男孩つ

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Spring学习01】Spring的Ioc和DI

目录1.Spring简介1.1 什么是spring1.2 Spring的优势2.Spring快速入门2.1 spring开发步骤2.2 导入spring开发基本包坐标2.3 编Dao接口以及实现类2.4 创建spring核心配置文件2.5 在 Spring 配置文件中配置 UserDaoImpl2.6 使用 Spring 的 API 获得 Bean 实例3. Spring配置文件3.1 Bean基本标签配置3.2 Bean标签的范围配置3.3 Spri
复制链接

扫一扫