Spring入门

共计 19875 个字符，预计需要花费 50 分钟才能阅读完成。

1、Spring 概述

1.1、什么是 Spring

Spring 是一个主流的 Java Web 开发框架，该框架是一个轻量级的应用框架，具有很高的凝聚力和吸引力。Spring 以 IoC（Inverse of Control，控制反转）和 AOP（Aspect Oriented Programming，面向切面编程）为内核。

在实际开发中，通常服务器端采用三层体系架构，分别为表现层（web）、业务逻辑层（service）、持久层（dao）。Spring 对每一层都提供了技术支持。

1.2、Spring 优点

方便解耦，简化开发

Spring 是一个大的工厂，将所有对象的创建、依赖关系和维护都交给 Spring 管理。

方便集成各种优秀框架

Spring 不排斥各种优秀的开源框架，其内部对各种优秀框架都直接支持。

降低 Java EE API 的使用难度

Spring 封装了很多 Java EE 开发的 API 都提供了封装，使 API 应用的难度大大降低。

方便程序的测试

Spring 支持 JUnit 单元测试，可以通过注解方便地测试程序。

AOP 编程的支持

Spring 提供面向切面编程，可以方便地实现对程序进行权限拦截和运行监控等功能。

声明式事务的支持

只需要通过配置就可以完成对事务的管理，而无须手动编程。

1.3、Spring 的发展历程

1.3.1、Spring1.x 时代

在 Spring1.x 时代，都是通过 xml 文件配置 bean，随着项目的不断扩大，需要将 xml 配置分放到不同的配置文件中，需要频繁的在 java 类和 xml 配置文件中切换。

1.3.2、Spring2.x 时代

在 Spring2.x 时代，随着 JDK 1.5 带来的注解支持，Spring2.x 可以使用注解对 Bean 进行申明和注入，大大的减少了 xml 配置文件，同时也大大简化了项目的开发。

在实际开发中：我们在使用应用的基本配置时用 xml，比如：数据源、资源文件等；在业务开发用注解，比如：Service 中注入 bean 等；

1.3.3、Spring3.x 到 Spring5.x（现在）

从 Spring3.x 开始提供了 Java 配置方式，使用 Java 配置方式可以更好的理解你配置的 Bean。

1.3.4、Spring boot 的出现

习惯优于 java 配置，完全取代的 xml。

1.4、Spring 体系结构

Data Access/Integration（数据访问/集成）

数据访问 / 集成层包括 JDBC、ORM、OXM、JMS 和 Transactions 模块，具体介绍如下。

JDBC 模块：提供了一个 JDBC 的抽象层，大幅度减少了在开发过程中对数据库操作的编码。

ORM 模块：对流行的对象关系映射 API，包括 JPA、JDO、Hibernate 和 MyBatis 提供了的集成层。

OXM 模块：提供了一个支持对象 /XML 映射的抽象层实现，如 JAXB、Castor、XMLBeans、JiBX 和 XStream。

JMS 模块：指 Java 消息服务，包含的功能为生产和消费的信息。

Transactions 事务模块：支持编程和声明式事务管理实现特殊接口类，并为所有的 POJO。

Web 模块

Spring 的 Web 层包括 Web、Servlet、Struts 和 Portlet 组件，具体介绍如下。

Web 模块：提供了基本的 Web 开发集成特性，例如多文件上传功能、使用的 Servlet 监听器的 IoC 容器初始化以及 Web 应用上下文。

Servlet 模块：包括 Spring 模型—视图—控制器（MVC）实现 Web 应用程序。

Struts 模块：包含支持类内的 Spring 应用程序，集成了经典的 Struts Web 层。

Portlet 模块：提供了在 Portlet 环境中使用 MV C 实现，类似 Web-Servlet 模块的功能。

Core Container（核心容器）

Spring 的核心容器是其他模块建立的基础，由 Beans 模块、Core 核心模块、Context 上下文模块和 Expression Language 表达式语言模块组成，具体介绍如下。

Beans 模块：提供了 BeanFactory，是工厂模式的经典实现，Spring 将管理对象称为 Bean。

Core 核心模块：提供了 Spring 框架的基本组成部分，包括 IoC 和 DI 功能。

Context 上下文模块：建立在核心和 Beans 模块的基础之上，它是访问定义和配置任何对象的媒介。ApplicationContext 接口是上下文模块的焦点。

Expression Language 模块：是运行时查询和操作对象图的强大的表达式语言。

其他模块

Spring 的其他模块还有 AOP、Aspects、Instrumentation 以及 Test 模块，具体介绍如下。

AOP 模块：提供了面向切面编程实现，允许定义方法拦截器和切入点，将代码按照功能进行分离，以降低耦合性。

Aspects 模块：提供与 AspectJ 的集成，是一个功能强大且成熟的面向切面编程（AOP）框架。

Instrumentation 模块：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。

Messaging：对消息架构和协议的支持

Test 模块：支持 Spring 组件，使用 JUnit 或 TestNG 框架的测试。

1.5、Spring 下载

https://mvnrepository.com/artifact/org.springframework/spring

https://repo.spring.io/release/org/springframework/spring/5.2.5.RELEASE/

spring 依赖的 jar 包

1.6、Spring 特点

** 轻量：** 从大小与开销两方面而言 Spring 都是轻量的。完整的 Spring 框架可以在一个大小只有 1MB 多的 JAR 文件里发布。并且 Spring 所需的处理开销也是微不足道的。

** 控制反转：**Spring 通过控制反转（IoC）的技术促进了低耦合。当应用了 IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。

** 面向切面：**Spring 提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务进行内聚性的开发。将业务与系统分离各自完成自己的事情。

** 容器：**Spring 包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，里面的内容由 bean 构成。

** 框架：**Spring 可以将简单的组件配置、组合成为复杂的应用。在 xml 文件中 Spring 也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

**MVC：**Spring 使用了 MVC 的架构模式思想，将 Web 层进行指责解耦，并管理应用所需的生命周期，为简化日常开发，提供了很大便利。

2、Spring 的第一个程序

通过 maven 创建一个 Spring001 项目

2.1、jar 包导入

pom.xml

<?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.tyschool</groupId>
    <artifactId>spring001</artifactId>
    <version>1.0-SNAPSHOT</version>
<dependencies>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.13.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>
</project>

2.2、定义接口与实体类

IStudentsService.java

public interface IStudentsService {void some();
}

StudentsServiceImpl.java

public class StudentsServiceImpl implements IStudentsService {public void some() {System.out.println("执行 Some 方法");
    }
}

2.3、创建 Spring 配置文件

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">
 <bean id="studentsServiceImpl" class="com.tyschool.spring001.service.StudentsServiceImpl"></bean>
</beans>

2.4、工厂类

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanFactory {private static ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");;
    private BeanFactory(){ }
    public static Object getBean(String snameBean) {Object iss =  context.getBean(snameBean);
        return iss;
    }
}

2.5、测试类

STest.java

package com.tyschoo.spring001.test;

import com.tyschool.spring001.factory.BeanFactory;
import com.tyschool.spring001.service.IStudentsService;
import org.junit.Test;

public class STest {@Test
    public void some(){IStudentsService iss=(IStudentsService) BeanFactory.getBean("studentsService");
        iss.some();}
}

3、内聚与耦合

3.1、模块

模块是由一组语句组成，并且被标识符组成的边界元素所界定。类，方法都是可以称之为一个模块。

3.2、内聚与耦合

内聚是指一个模块内的交互程度，耦合是指模块间的交互程度。我们需要尽力做到高内聚低耦合。

高内聚

比如：211 和专科学校他们招生，211 招的就是高尖子生，他们得共性就是学生里面的顶尖的一批，专科招的就是学生里面学习能力相对较弱的一批，如果把专科生放到 211 里面去，那不符合实际，毕竟专科生和 211 没有多大的关联，符合不了 211。

低耦合

比如：你找了一个女朋友，那你们之间就有了联系，这就是耦合，然后呢，你们同居了，你们之间联系更加密切了，这样耦合就高了，然后突然有一天，你女朋友说要回老家了，你俩不同居了，你们的联系呢也少下去了，但是你俩还是男女朋友关系，只不过没有同居的时候联系那样亲密。

3.3、问题解读

3.3.1、业务层调用持久层

public class StudentsServiceImpl implements IStudentsService{private IStudentsDao isd=new StudetnsDaoImpl();}

业务层调用持久层，并且此时业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类，编译将不能通过。这种编译期依赖关系，应该在我们开发中杜绝。我们需要优化代码解决。

3.3.2、驱动加载

// 第一种方式：
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
// 第二种方式：
Class.forName("com.mysql.jdbc.Driver");

我们的类依赖了数据库的具体驱动类（MySQL），如果这时候更换了数据库品牌（比如 Oracle），需要修改源码来重新数据库驱动。这显然不是我们想要的。

3.4、解耦

3.4.1、解耦思路

 前面提到的 JDBC 连接，我们采用的是反射来注册我们的驱动
Class.forName("com.mysql.jdbc.Driver");//"com.mysql.jdbc.Driver" 只是一窜字符串 
好处：只是不会影响程序的运行，但不一定会运行成功（去掉 mysql 驱动 jar 包）。问题：驱动字符串是在类中写死的，要想连接其他数据库得改我们的类。问题解决方案：使用配置文件（.properties/.xml）。

3.4.2、工厂模式解耦

Spring 中三层

spring 框架中，分为三层 dao,service 和 web 层

**dao：** 数据库访问层
**service：** 业务逻辑层实例 dao 调用增删查改方法
**web：** 前端交互层实例 service 调用业务逻辑方法

MySQL 数据库，加入 Oracle 数据库

serivce 与 dao 的耦合度太高

工厂的耦合太高

通过工厂模式 + 配置文件来解耦

4、IOC

4.1、IOC 概述

控制反转（IoC，Inversion of Control），是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。

实现方式有两种：依赖注入和依赖查找

4.2、依赖倒置

4.2.1、汽车设计 - 方式一：

如果我们修改了车轮，那么其他地方都需要修改。

4.2.2、汽车设计 - 方式二：

如果我们修改了车轮，那么其他地方都不需要修改。

这就是依赖倒置原则——把原本的上层依赖下层“倒置”过来，变成下层依赖上层。上层来确认需要什么，不用管下层如何实现。

4.3、依赖注入

依赖倒置原则的一种代码设计的思路。具体采用的方法就是所谓的依赖注入（Dependency Injection）。

依赖注入（DI）是指程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。

4.4、IOC 访问

4.5、Spring-IOC

5、Spring 第二个程序

通过 maven 创建一个 Spring002 项目

5.1、原始方式

5.1.1、jar 包导入

pom.xml

<?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.tyschool</groupId>
    <artifactId>spring002</artifactId>
    <version>1.0-SNAPSHOT</version>
<dependencies>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.13.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>
</project>

5.1.2、创建 javabean

Students.java

import java.io.Serializable;

public class Students implements Serializable {private int sid;
    private String sname;
    private String ssex;
    private int sage;
    private int cid;

    public int getSid() {return sid;
    }

    public void setSid(int sid) {this.sid = sid;
    }

    public String getSname() {return sname;
    }

    public void setSname(String sname) {this.sname = sname;
    }

    public String getSsex() {return ssex;
    }

    public void setSsex(String ssex) {this.ssex = ssex;
    }

    public int getSage() {return sage;
    }

    public void setSage(int sage) {this.sage = sage;
    }

    public int getCid() {return cid;
    }

    public void setCid(int cid) {this.cid = cid;
    }

    @Override
    public String toString() {return "Students{" +
                "sid=" + sid +
                ", sname='" + sname + '\'' +
                ", ssex='" + ssex + '\'' +
                ", sage=" + sage +
                ", cid=" + cid +
                '}';
    }
}

5.1.3、创建持久层接口与实现类

IStudentsDao.java

import com.tyschool.spring002.javabean.Students;
import java.util.List;

public interface IStudentsDao {public List<Students> findAll();
}

StudentsDaoImpl.java

import com.tyschool.spring002.javabean.Students;
import com.tyschool.spring002.students.dao.IStudentsDao;

import java.util.List;

public class StudentsDaoImpl implements IStudentsDao {public List<Students> findAll() {System.out.println("查询学生所有信息");
        return null;
    }
}

5.1.4、创建业务层接口与实现类

IStudentsService.java

import com.tyschool.spring002.javabean.Students;
import java.util.List;

public interface IStudentsService {public List<Students> findAll();
}

StudentsServiceImpl.java

import com.tyschool.spring002.javabean.Students;
import com.tyschool.spring002.students.dao.IStudentsDao;
import com.tyschool.spring002.students.dao.impl.StudentsDaoImpl;
import com.tyschool.spring002.students.service.IStudentsService;
import java.util.List;

public class StudentsServiceImpl implements IStudentsService {private IStudentsDao isd=new StudentsDaoImpl();
    public List<Students> findAll() {return isd.findAll();}
}

5.2、Spring 解耦方式

5.2.1、创建配置文件

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">
    <!-- 配置 Service-->
    <bean id="studentsServiceImpl"        class="com.tyschool.spring002.students.servcie.impl.StudentsServiceImpl"/>
    <!-- 配置 Dao-->
    <bean id="studentsDaoImpl" 
class="com.tyschool.spring002.students.dao.impl.StudentsDaoImpl"/>
</beans>

5.2.2、创建工厂

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanFactory {private final static ApplicationContext context=new ClassPathXmlApplicationContext("applicationConfig.xml");;
    private BeanFactory(){ }
    public static Object getBean(String snameBean) {Object iss =  context.getBean(snameBean);
        return iss;
    }
}

5.2.3、创建测试类

import com.tyschool.spring002.factory.BeanFactory;
import com.tyschool.spring002.students.dao.IStudentsDao;
import com.tyschool.spring002.students.service.IStudentsService;

public class STest {public static void main(String[] args) {IStudentsService iss= (IStudentsService) BeanFactory.getBean("studentsServiceImpl");
        IStudentsDao isd= (IStudentsDao) BeanFactory.getBean("studentsDaoImpl");

        System.out.println(iss);
        System.out.println(isd);
    }
}

5.3、ApplicationContext 结构

ClassPathXmlApplicationContext

它是从类的根路径下加载配置文件。推荐使用这种

FileSystemXmlApplicationContext

它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

AnnotationConfigApplicationContext

当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

6、配置文件中的 bean

6.1、bean 标签

作为 Spring 核心机制的依赖注入，改变了传统的编程习惯，对组件的实例化不再由应用程序完成，转而交由 Spring 容器完成，在需要时注入应用程序中，从而对组件之间依赖关系进行了解耦。这一切都离不开 Spring 配置文件中使用的 元素。

Spring 配置文件支持两种不同的格式，分别是 XML 文件格式和 Properties 文件格式。

通常情况下，Spring 会以 XML 文件格式作为 Spring 的配置文件，这种配置方式通过 XML 文件注册并管理 Bean 之间的依赖关系。

XML 格式配置文件的根元素是 ，该元素包含了多个 子元素，每一个 子元素定义了一个 Bean，并描述了该 Bean 如何被装配到 Spring 容器中。

6.2、Bean 标签作用

用于配置对象让 spring 来创建的。

默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

6.3、Bean 标签属性

id：给对象在容器中提供一个唯一标识。用于获取对象。

class：指定类的权限定类名。用于反射创建对象。默认情况下调用无参构造函数。

scope：指定对象的作用范围。

• singleton：默认值，单例的。

• prototype：多例的

init-method：指定类中的初始化方法名称。

destory-method：指定类中销毁方法名称。

6.4、生命周期

6.4.1、singleton 值

一个应用只有一个对象的实例。它的作用范围就是整个引用。

生命周期：

对象出生：当应用加载，创建容器时，对象就被创建了。

对象活着：只要容器在，对象一直活着。

对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

6.4.2、prototype 值

每次访问对象时，都会重新创建对象实例。

生命周期：

对象出生：当使用对象时，创建新的对象实例。

对象活着：只要对象在使用中，就一直活着。

对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

6.4.3、测试

import com.tyschool.spring002.factory.BeanFactory;
import com.tyschool.spring002.students.service.IStudentsService;

public class STest {public static void main(String[] args) {IStudentsService iss= (IStudentsService) BeanFactory.getBean("studentsServiceImpl");
        IStudentsService iss1= (IStudentsService) BeanFactory.getBean("studentsServiceImpl");

        System.out.println(iss);
        System.out.println(iss1);
    }
}

7、bean 实例化

7.1、无参构造函数

默认情况，根据无参构造函数来创建类对象。如果实现类中没有默认无参构造函数，创建对象失败

<bean id="studentsServiceImpl"
        class="com.tyschool.spring002.students.service.impl.StudentsServiceImpl"/>

测试

package com.tyschool.test;

import com.tyschool.spring002.factory.BeanFactory;
import com.tyschool.spring002.students.service.IStudentsService;

public class STest {public static void main(String[] args) {IStudentsService iss= (IStudentsService) BeanFactory.getBean("studentsServiceImpl");
      System.out.println(iss);
    }
}

7.2、静态工厂

创建一个静态工厂类，使用新的属性：factory-method

StaticBeanFactory.java

import com.tyschool.spring002.students.service.IStudentsService;
import com.tyschool.spring002.students.service.impl.StudentsServiceImpl;

public class StaticBeanFactory {public static IStudentsService createIStudentsService(){return new StudentsServiceImpl();}
}

<bean id="studentsServiceImpl1" class="com.tyschool.spring002.factory.StaticBeanFactory"
          factory-method="createIStudentsService"/>

测试

import com.tyschool.spring002.factory.StaticBeanFactory;
import com.tyschool.spring002.students.service.IStudentsService;

public class STest {public static void main(String[] args) {IStudentsService iss= (IStudentsService) BeanFactory.getBean("studentsServiceImpl1");
      System.out.println(iss);
    }
}

7.3、实例工厂

创建一个实例工厂，使用新的属性：factory-method，factory-bean

ExampleBeanFactory.java

import com.tyschool.spring002.students.service.IStudentsService;
import com.tyschool.spring002.students.service.impl.StudentsServiceImpl;

public class ExampleBeanFactory {public IStudentsService createIStudentsService(){return new StudentsServiceImpl();}
}

<bean id="exampleBeanFactory" class="com.tyschool.spring002.factory.ExampleBeanFactory"></bean> 
<bean id="studentsServiceImpl2" factory-bean="exampleBeanFactory"
          factory-method="createIStudentsService"></bean>

测试

import com.tyschool.spring002.factory.ExampleBeanFactory;
import com.tyschool.spring002.students.service.IStudentsService;

public class STest {public static void main(String[] args) {IStudentsService iss= (IStudentsService) BeanFactory.getBean("studentsServiceImpl2");
      System.out.println(iss);
    }
}

8、依赖注入实现方式 - 上

8.1、依赖注入概述

依赖注入（Dependency Injection，DI）和控制反转含义相同，它们是从两个角度描述的同一个概念。

当某个 Java 实例需要另一个 Java 实例时，传统的方法是由调用者创建被调用者的实例（例如，使用 new 关键字获得被调用者实例），而使用 Spring 框架后，被调用者的实例不再由调用者创建，而是由 Spring 容器创建，这称为控制反转。

Spring 容器在创建被调用者的实例时，会自动将调用者需要的对象实例注入给调用者，这样，调用者通过 Spring 容器获得被调用者实例，这称为依赖注入。

8.2、构造函数注入

在 StudentsDaoImpl 中加入构造方法，初始化属性

import com.tyschool.spring002.javabean.Students;
import com.tyschool.spring002.students.dao.IStudentsDao;

import java.util.List;

public class StudentsDaoImpl implements IStudentsDao {private String sname;
    private String ssex;
    private int sage;
  	public StudentsDaoImpl(){}
    public StudentsDaoImpl(String sname,String ssex,int sage){this.sname=sname;
        this.ssex=ssex;
        this.sage=sage;
    }
    public List<Students> findAll() {System.out.println("查询学生所有信息");
        System.out.println(sname+":"+ssex+":"+sage);
        return null;
    }
}

constructor-arg 标签：

指定赋值元素：

index: 指定参数在构造函数参数列表的索引位置

type: 指定参数在构造函数中的数据类型

name: 指定参数在构造函数中的名称 用这个找给谁赋值

指定赋值元素值：

value: 它能赋的值是基本数据类型和 String 类型

ref: 让 bean 作为值进行赋值，bean 必须是配置文件中出现过

<!-- 配置 Dao-->
<bean id="studentsDaoImpl"
          class="com.tyschool.spring002.students.dao.impl.StudentsDaoImpl" >
        <constructor-arg name="sname" value="张三"></constructor-arg>
        <constructor-arg name="ssex"  value="男"></constructor-arg>
        <constructor-arg name="sage" value="19"></constructor-arg>
</bean>

<!-- 配置 Service-->
<bean id="studentsServiceImpl" class="com.tyschool.spring002.students.service.impl.StudentsServiceImpl">
        <property name="isd" ref="studentsDaoImpl"></property>
</bean>

修改 StudentsServiceImpl.java 文件

import com.tyschool.spring002.javabean.Students;
import com.tyschool.spring002.students.dao.IStudentsDao;
import com.tyschool.spring002.students.service.IStudentsService;

import java.util.List;

public class StudentsServiceImpl implements IStudentsService {private IStudentsDao isd;

    public IStudentsDao getIsd() {return isd;
    }

    public void setIsd(IStudentsDao isd) {this.isd = isd;
    }

    //private IStudentsDao isd=new StudentsDaoImpl();
    public List<Students> findAll() {return isd.findAll();}
}

测试

import com.tyschool.spring002.factory.BeanFactory;
import com.tyschool.spring002.students.service.IStudentsService;

public class STest {public static void main(String[] args) {IStudentsService iss= (IStudentsService) BeanFactory.getBean("studentsServiceImpl");
      System.out.println(iss);
      iss.findAll();}
}

9、依赖注入实现方式 - 中

9.1、set 注入

修改 StudentsDaoImpl.java 文件

import com.tyschool.spring002.javabean.Students;
import com.tyschool.spring002.students.dao.IStudentsDao;

import java.util.List;

public class StudentsDaoImpl implements IStudentsDao {private String sname;
    private String ssex;
    private int sage;

    public String getSname() {return sname;
    }

    public void setSname(String sname) {this.sname = sname;
    }

    public String getSsex() {return ssex;
    }

    public void setSsex(String ssex) {this.ssex = ssex;
    }

    public int getSage() {return sage;
    }

    public void setSage(int sage) {this.sage = sage;
    }
    
    public List<Students> findAll() {System.out.println("查询学生所有信息");
        System.out.println(sname+":"+ssex+":"+sage);
        return null;
    }
}

property 标签：

属性与值

name：找的是类中 set 方法后面的部分

ref：给属性赋值是其他 bean 类型的

value：给属性赋值是基本数据类型和 string 类型的

<bean id="studentsDaoImpl" class="com.tyschool.spring002.students.dao.impl.StudentsDaoImpl">
        <property name="sname" value="张三"></property>
        <property name="ssex" value="女"></property>
        <property name="sage" value="19"></property>
</bean>

测试类不变继续测试

9.2、空间注入

使用 p:propertyName 来注入数据，它是调用类中的 set 方法实现注入功能

在 beans 里引入 p

xmlns:p="http://www.springframework.org/schema/p" 

在 bean 里使用 p

<bean id="studentsDaoImpl"
class="com.tyschool.spring002.students.dao.impl.StudentsDaoImpl" p:sname="李四" p:ssex="女" p:sage="19">
</bean>

测试类不变继续测试

10、依赖注入实现方式 - 下

10.1、注入类、数组、集合、参数

修改 StudentsDaoImpl.java 文件

import com.tyschool.spring002.javabean.Students;
import com.tyschool.spring002.students.dao.IStudentsDao;

import java.util.*;

public class StudentsDaoImpl implements IStudentsDao {private Date date;
    private String []s;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    private Properties properties;

    public Date getDate() {return date;
    }

    public void setDate(Date date) {this.date = date;
    }

    public String[] getS() {return s;
    }

    public void setS(String[] s) {this.s = s;
    }

    public List<String> getList() {return list;
    }

    public void setList(List<String> list) {this.list = list;
    }

    public Set<String> getSet() {return set;
    }

    public void setSet(Set<String> set) {this.set = set;
    }

    public Map<String, String> getMap() {return map;
    }

    public void setMap(Map<String, String> map) {this.map = map;
    }

    public Properties getProperties() {return properties;
    }

    public void setProperties(Properties properties) {this.properties = properties;
    }
    public List<Students> findAll() {System.out.println("查询学生所有信息");
        //System.out.println(sname+":"+ssex+":"+sage);
        System.out.println(date);
        System.out.println(s);
        System.out.println(list);
        System.out.println(set);
        System.out.println(map);
        System.out.println(properties);
        return null;
    }
}

property 标签：

子标签：array，list，set，map，entry，props，prop

<bean id="date" class="java.util.Date"></bean>
<bean id="studentsDaoImpl"
      class="com.tyschool.spring002.students.dao.impl.StudentsDaoImpl">
        <property name="date" ref="date"></property>
        <property name="s">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>DDD</value>
                <value>EEE</value>
                <value>FFF</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>GGG</value>
                <value>HHH</value>
                <value>III</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="j" value="JJJ"></entry>
                <entry key="k" value="KKK"></entry>
                <entry key="l" value="LLL"></entry>
            </map>
        </property>
        <property name="properties">
           <props>
               <prop key="m">MMM</prop>
               <prop key="n">NNN</prop>
               <prop key="o">OOO</prop>
           </props>
        </property>
</bean>

测试类不变继续测试