2021-3-4

Spring入门

什么是Spring

​ Spring 是一个轻量级 Java 开发框架,最早由 Rod Johson 创建,

目的:是为了解决企业级应用开发的业务逻辑层和其他层的耦合问题

​ 它是一个分层的 JavaSE/EE full-stack(一站式)轻量级开源框架,为开发 Java 应用程序提供全面的基础架构支持。Spring 负责基础架构,因此 Java 开发者可以专注于应用程序的开发。

准备工作

  • IDE
  • Tomcat
  • 依赖Jar包
    • Spring-core
    • Spring-beans
    • Spring-context
    • Spring-expression
    • commons-logging

Spring IoC

基本概念

控制反转(Inversion of Control,IoC)是一个比较抽象的概念,是Spring 框架的核心用来消减计算机程序的耦合问题

依赖注入(Dependency Injection,DI)是 IoC 的另一种说法,只是从不同的角度描述相同的概念。

​ 从 Spring 容器角度来看,Spring 容器负责将被依赖对象赋值给调用者的成员变量,相当于为调用者注入它所依赖的实例,这就是 Spring 的控制反转

​ 综上所述,控制反转是一种通过描述(在 Spring 中可以是 XML 或注解)并通过第三方去产生或获取特定对象的方法。

​ 在 Spring 中实现控制反转的是 IoC 容器,其实现方法是依赖注入。

Spring IoC 容器

​ IoC 容器的设计主要是基于 BeanFactory 和 ApplicationContext 两个接口。

BeanFactory(不常用)

​ BeanFactory 提供了完整的 IoC 服务支持,是一个管理 Bean 的工厂,主要负责初始化各种 Bean。

public class Test {
    public static void main(String[] args) {
        // 初始化Spring容器,加载配置文件
        BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource("D:\\Project\\Java\\idea\\ssm-study\\src\\applicationContext.xml"));
        // 通过容器加载 test 实例
        TestDao test = (TestDao) beanFactory.getBean("test");
        test.sayHello();
    }

ApplicationContext

​ ApplicationContext 是 BeanFactory 的子接口,也称为应用上下文,由 org.springframework.context.ApplicationContext 接口定义。

​ ApplicationContext 接口除了包含 BeanFactory 的所有功能外,还添加了对国际化、资源访问、事件传播等内容的支持。

​ 创建 ApplicationContext 接口实例通常有以下3种方法:

  1. 通过 ClassPathXmlApplicationContext 创建

    ClassPathXmlApplicationContext 将从类路径目录(src根目录)中寻找指定的 XML 配置文件。

public class Test2 {
    public static void main(String[] args) {
        // 初始化Spring容器,加载配置文件
        // 通过 ClassPathXmlApplicationContext 创建
        ApplicationContext appCon = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过容器加载 test 实例
        TestDao test = (TestDao) appCon.getBean("test");
        test.sayHello();
    }
}
  1. 通过 FileSystemXmlApplicationContext 创建(灵活性差,不推荐)

    FileSystemXmlApplicationContext 将从指定文件的绝对路径中寻找 XML 配置文件,找到并装载完成 ApplicationContext 的实例化工作。

public class Test3 {
    public static void main(String[] args) {
        // 初始化Spring容器,加载配置文件
        // 通过 FileSystemXmlApplicationContext  创建
        ApplicationContext appCon = new FileSystemXmlApplicationContext("D:\\Project\\Java\\idea\\ssm-study\\src\\applicationContext.xml");
        // 通过容器加载 test 实例
        TestDao test = (TestDao) appCon.getBean("test");
        test.sayHello();
    }
}
  1. 通过 Web 服务器实例化 ApplicationContext 容器

    在 Web 服务器实例化 ApplicationContext 容器时,一般使用基于 org.springframework.web.context.ContextLoaderListener 的实现方式(需要导入 spring-web-5.0.2.RELEASE.jar 到 WEB-INF/lib 目录下),此方法只需要在 Web.xml 中添加如下代码:

    <context-param>
        <!-- 加载 src 目录下的applicationContext.xml 文件 -->
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath:applicationContext.xml
        </param-value>
    </context-param>
    <!-- 指定以 ContextLoaderListener 方式启动 Spring 容器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

那么,怎么用它呢?)注释?

通常,在 Spring 的 Java 应用中采取通过 ClassPathXmlApplicationContext 类来实例化 ApplicationContext 容器的工作,而在 Web 应用中,ApplicationContext 容器的实例化工作将交给 Web 服务器完成。

依赖注入类型

​ 在 Spring 中实现 IoC 容器的方法是依赖注入,依赖注入的作用是在使用 Spring 框架创建对象时动态地将所依赖的对象(例如属性值)注入 Bean 的组件中

​ Spring 框架的依赖注入通常有两种实现方式:

  • 使用构造方法注入
  • 使用属性的 setter 方法注入。

使用构造方法注入

​ Spring 框架可以采用 Java 的反射机制,通过构造方法完成依赖注入。

​ 实现过程:

​ 完成目录结构:

  1. 创建 dao 包

    创建 dao 包的目的是在 service 中使用构造方法依赖注入 TestDao 接口对象

    TestDao 接口的代码如下:

package com.lbz.dao;
public interface TestDao {
    public void sayHello();
}

​ TestDaoImpl 实现类的代码如下:

package com.lbz.dao.impl;
import com.lbz.dao.TestDao;
public class TestDaoImpl implements TestDao {
    @Override
    public void sayHello() {
        System.out.println("hello,world!");
    }
}
  1. 创建 service 包

    在 TestServiceImpl 中使用构造方法依赖注入 TestDao 接口对象

    TestService 接口代码如下:

package com.lbz.service;
public interface TestService {
    public void sayHello();
}

​ TestServiceImpl 接口代码如下:

package com.lbz.service.impl;
import com.lbz.dao.TestDao;
import com.lbz.service.TestService;

public class TestServiceImpl implements TestService {
    private TestDao testDao;
    //构造方法,用于实现依赖注入接口对象 testDao
    public TestServiceImpl(TestDao testDao){
        super();
        this.testDao = testDao;
    }
    @Override
    public void sayHello() {
        // 调用 testDao 中的 sayHello 方法
        testDao.sayHello();
        System.out.println("TestService 构造方法注入say:Hello");
    }
}
  1. 编写配置文件

    在 src 根目录下创建 Spring 配置文件 applicationContext.xml 。在配置文件中首先将 dao.TestDaoImpl 类托管给 Spring ,让 Spring 创建其对象,然后将 service.TestServiceImpl 类托管给 Spring,让 Spring 创建其对象,同时给构造方法传递实参。

    配置文件代码如下:

<?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">
    <!-- 将指定类TestDaoImpl配置给 Spring,让 Spring 创建其实例 -->
    <bean id="myTestDao" class="com.lbz.dao.impl.TestDaoImpl" />
    <!-- 使用构造方法注入 -->
    <bean id="testService" class="com.lbz.service.impl.TestServiceImpl">
        <!-- 将 myTestDao 注入到 TestServiceImpl 类的属性 testDao 上 -->
        <constructor-arg index="0" ref="myTestDao"></constructor-arg>
    </bean>
</beans>

​ 在配置文件中,constructor-arg 元素用于定义类构造方法的参数,index 用于定义参数的位置,ref 指向某个实例的引用。

​ 如果参数是常量值,ref 由 value 代替

  1. 创建test包
package com.lbz.test;
import com.lbz.service.TestService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        // 初始化Spring容器,加载配置文件
        ApplicationContext appCon = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过容器获取 testService 实例,测试构造方法注入
        TestService testService = (TestService) appCon.getBean("testService");
        testService.sayHello();
    }
}

使用属性的 setter 方法注入

​ 使用 setter 方法注入式 Spring 框架中最主流的注入方式,它利用 Java Bean 规范所定义的 setter 方法来完成注入,灵活且可读性高

​ 对于 setter 方法注入,Spring 框架也是使用 Java 的反射机制实现的。

  1. 创建接口实现类 TestServiceImpl1

    具体代码如下:

package com.lbz.service.impl;
import com.lbz.dao.TestDao;
import com.lbz.service.TestService;

public class TestServiceImpl1 implements TestService {
    private TestDao testDao;

    // 添加 testDao 属性的 setter 方法,用于实现依赖注入
    public void setTestDao(TestDao testDao) {
        this.testDao = testDao;
    }

    @Override
    public void sayHello() {
        // 调用 testDao 中的 sayHello 方法
        testDao.sayHello();
        System.out.println("TestService setter方法注入say:Hello");
    }
}
  1. 将 TestServiceImpl1 托管给 Spring

    在配置文件中添加代码:

    <!-- 使用 setter 方法注入 -->
    <bean id="testService1" class="com.lbz.service.impl.TestServiceImpl1">
        <!-- 调用 TestServiceImpl 类的 setter 方法,将 myTestDao 注入到 TestServiceImpl1 类的属性 testDao 上 -->
        <property name="testDao" ref="myTestDao"></property>
    </bean>
  1. 在 test 测试中测试 setter 方法注入

    在主类中添加测试代码:

        // 通过容器获取 testService1 实例,测试 setter 方法注入
        TestService testService1 = (TestService) appCon.getBean("testService1");
        testService1.sayHello();
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页