Spring（1）基本概念+开发的基本步骤

一、Spring的基本概念

1）、Spring 框架简述

Spring 是轻量级、开源的 Java 企业级开发框架，核心设计理念是IoC（控制反转）和AOP（面向切面编程），旨在简化 Java 开发、解耦业务组件、提升代码可维护性和扩展性。

它不替代现有技术，而是整合Servlet、MyBatis、Hibernate、RabbitMQ 等各类框架，成为 Java 后端开发的核心基础设施，几乎是企业级 Java 应用的标配。

核心优势：

解耦：无需手动管理对象依赖，由 Spring 容器统一创建、注入、管理

简化开发：封装大量通用逻辑，减少样板代码

生态完善：覆盖 Web、数据访问、消息、安全等全场景

无侵入：业务代码无需依赖 Spring 特定 API

2）、Spring 核心基本模块

Spring 框架采用模块化设计，按需引入模块，核心模块分为核心容器、AOP、数据访问、Web、测试五大类：

核心容器模块（Spring 的心脏）

负责创建、管理、装配 Java 对象（Bean），是所有模块的基础

spring-core：框架核心工具类，其他模块的基础

spring-beans：Bean 工厂，负责对象的创建、配置、管理

spring-context：上下文模块，封装容器功能，提供框架启动、事件监听等能力

spring-expression：Spring EL 表达式语言，支持运行时查询、操作对象

AOP 与 Instrumentation 模块

实现面向切面编程，解耦日志、事务、权限等通用横切逻辑

spring-aop：AOP 核心实现，支持方法拦截、切面配置

spring-aspects：集成 AspectJ 框架，提供更强大的 AOP 能力

spring-instrument：类加载器模块，用于服务器级别的类增强

数据访问 / 集成模块

简化数据库操作、事务管理，整合持久层框架

spring-jdbc：封装 JDBC，简化数据库连接、SQL 执行

spring-tx：声明式事务管理，无需手动编写事务代码

spring-orm：整合 Hibernate、MyBatis 等 ORM 框架

spring-oxm：对象 XML 映射

spring-jms：消息队列相关操作

Web 模块

用于开发 Web 应用、REST 接口

spring-web：基础 Web 功能，文件上传、过滤器等

spring-webmvc：Spring MVC 框架，实现 MVC 设计模式，开发 Web 接口

spring-websocket：支持 WebSocket 长连接

spring-webflux：响应式 Web 开发模块（高性能、非阻塞）

测试模块

spring-test：提供单元测试、集成测试支持，可测试 Spring 容器中的 Bean

总结

Spring 是Java 企业级核心框架，核心是 IoC（解耦）和 AOP（通用逻辑抽离）；

模块化设计，核心容器是基础，Web、数据访问、AOP 是最常用模块；

日常开发中，Spring Boot 已封装这些模块，开箱即用。

二、开发Spring的基本步骤

第一步：使用Idea创建Maven项目

第二步：修改pom.xml文件导入Spring包

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

<groupId>com.newer</groupId>

<artifactId>testspring</artifactId>

<version>1.0-SNAPSHOT</version>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<version>5.2.8.RELEASE</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-beans</artifactId>

<version>5.2.8.RELEASE</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>5.2.8.RELEASE</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-expression</artifactId>

<version>5.2.8.RELEASE</version>

</dependency>

<groupId>commons-logging</groupId>

<artifactId>commons-logging</artifactId>

</dependency>

</dependencies>

<maven.compiler.source>8</maven.compiler.source>

<maven.compiler.target>8</maven.compiler.target>

</properties>

</project>

第三步：在src/main/java下新建HelloSpring的类，包路径为com.newer

package com.newer;

public class HelloSpring {

private String userName;

public void setUserName(String userName){

this.userName=userName;

}

public void show(){

System.out.println(userName+":欢迎来到Spring");

}

第四步：在main/resources/下创建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>

</beans>

第五步：test/java/下编写测试类TestHelloSpring，包路径为com.newer。其下编写测试方法

import com.newer.HelloSpring;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestHelloSpring {

public static void main(String[] args) {

//初始化spring容器，加载applicationContext.xml配置

ApplicationContext applicationContext=new

ClassPathXmlApplicationContext("applicationContext.xml");

//通过容器获取配置中helloSpring的实例

HelloSpring helloSpring=

(HelloSpring)applicationContext.getBean("helloSpring");

helloSpring.show();//调用方法

}

三、控制反转和依赖注入的基本概念

Spring IoC（控制反转）和 DI（依赖注入）

是 Spring 最核心的设计思想，IoC 是设计思想，DI 是实现 IoC 的具体手段，

经常一起出现但含义不同。

一、IoC（Inversion of Control）控制反转

一句话理解

把对象的创建、管理、生命周期交给 Spring 容器，不再由开发者手动 new 对象，控制权从代码反转给了框架。

通俗解释

传统开发：你需要什么对象，自己 new 出来，自己管理依赖。

Spring IoC：你告诉 Spring 需要什么对象，Spring 帮你创建、组装、管理，你直接用就行。

核心作用

解耦：让类与类之间不硬编码依赖，降低代码耦合，方便维护和测试。

2）、DI（Dependency Injection）依赖注入

一句话理解

Spring 在运行时，自动把需要的依赖对象赋值给需要它的对象，不需要手动赋值。

通俗解释

比如 A 类需要用到 B 对象：

传统：A a = new A(); a.setB(new B());

DI：Spring 自动把创建好的 B 对象 "注入" 给 A，你直接用即可。

三种常用注入方式

构造器注入（官方推荐，最安全）

Setter 方法注入

字段注入（@Autowired 直接写在属性上）

3）、两者关系（最关键）

IoC 是思想：把对象控制权交给容器。

DI 是实现方式：通过注入依赖，完成 IoC。

可以记成一句话：

Spring 通过依赖注入（DI），实现了控制反转（IoC）的设计思想。

总结

IoC 控制反转：对象创建、管理交给 Spring 容器，控制权反转。

DI 依赖注入：Spring 自动把依赖对象赋给目标类。

关系：DI 是手段，IoC 是目的。

四、依赖注入的二种类型

1、构造注入

1）、基本概念

构造注入是 Spring 依赖注入（DI）的首选方式，指通过类的构造方法，将依赖对象自动传入并赋值，完成依赖注入。

核心特点

通过构造方法传入依赖，Spring 调用构造方法时自动把需要的 Bean 传进去

Spring 官方唯一推荐的注入方式

依赖在对象创建时就必须传入，保证依赖不能为空、一定存在

适合强制依赖、必须注入的场景

简单示例

@Service

public class UserService {

private final UserDao userDao;

// 构造注入：Spring 自动传入 UserDao 对象

public UserService(UserDao userDao) {

this.userDao = userDao;

}

优点（为什么推荐）

不可变：可以用 final 修饰依赖，线程安全、更稳定

强制依赖：对象创建时必须传入，避免空指针

易于测试：直接传 mock 对象，不用依赖 Spring

代码更清晰：依赖一目了然

总结

构造注入 = 用构造方法接收依赖，是 Spring 最安全、最推荐的注入方式，保证依赖必传、不可变、更稳定。

2）、使用步骤

第一步：新建User1类，在User1类中定义id、name和password三个属性，定义了User1()的构造方法和toString()方法。

package com.newer;

public class User1 {

private int id;

private String name;

private String password;

//有参构造方法

public User1(int id, String name, String password){

this.id=id;

this.name=name;

this.password=password;

}

public String toString(){

return "id="+id+",name="+name+",password="+password;

}

第二步：获取Bean的配置信息：创建applicationContext-User.xml文件，在该文件中添加User1类的配置信息。

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

<constructor-arg name="id" value="1"></constructor-arg>

<constructor-arg name="name" value="张三"></constructor-arg>

<constructor-arg name="password" value="123"></constructor-arg>

</bean>

</beans>

第三步：编写测试类：创建测试类TestUser1，用于测试依赖注入的结果。

import com.newer.User1;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestUser1 {

public static void main(String[] args)throws Exception{

//加载applicationContext.xml配置

ApplicationContext applicationContext=new

ClassPathXmlApplicationContext("applicationContext-User.xml");

//获取配置中的User1实例

User1 user1=applicationContext.getBean("user1", User1.class);

System.out.println(user1);

}

2、设值注入（SET注入）

第一步：编写用户类：新建User2类，在User2类中定义id、name和password三个属性。

package com.newer;

public class User2 {

private int id;

private String name;

private String password;

public void setId(int id){

this.id=id;

}

public void setName(String name){

this.name=name;

}

public void setPassword(String password){

this.password=password;

}

public String toString(){

return "id="+id+",name="+name+",password="+password;

}

第二步：获取Bean的配置信息：创建applicationContext-User2.xml文件，并在该文件的bean元素中添加User2类的配置信息。

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

</beans>

第三步：编写测试类：创建测试类TestUser2，用于测试依赖注入的结果。

import com.newer.User2;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestUser2 {

public static void main(String[] args)throws Exception {

//加载applicationContext.xml配置

ApplicationContext applicationContext = new

ClassPathXmlApplicationContext("applicationContext-User2.xml");

//获取配置中的User2实例

User2 user2 = applicationContext.getBean("user2", User2.class);

System.out.println(user2);

}

五、基于依赖注入实现三层结构的组装和解耦合。

1）、什么是三层结构

1、分层思想（核心原则）

把一个复杂系统按 "职责" 拆成多层，每层只做自己的事，层与层之间单向依赖、下层为上层服务。

目的：解耦、复用、易维护、易扩展、易分工。

2、经典三层架构（Java Web 最常用）

从上到下分为：表现层 → 业务逻辑层 → 数据访问层

表现层（Controller / Web 层）

负责接收请求、返回响应

做参数校验、封装结果、页面 / 接口交互

不写业务逻辑，只调用 Service

业务逻辑层（Service 层）

核心业务处理、规则判断、事务控制

组合多个 DAO 操作，保证数据一致性

向上给 Controller 提供服务，向下调用 DAO

数据访问层（Dao / Mapper 层）

只和数据库交互：增删改查

封装 JDBC/MyBatis 操作

不处理业务，只做数据读写

3、调用关系

Controller → Service → Dao → DB

上层依赖下层，下层不依赖上层，职责清晰、互不干扰。

一句话总结

三层结构就是：Controller 收请求，Service 做业务，Dao 读写库，通过分层让代码好写、好改、好维护。

2）、基于接口注入实现三层结构的组装和解耦合

第一步：编写DAO层：创建接口IUserDao.java，在IUserDao.java接口中添加方法login()，用于实现登录功能。

package com.newer.dao;

public interface IUserDao {

public boolean login(String name,String password);

}

第二步：编写DAO层的实现类：创建UserDao接口的实现类UserDaoImpl，在UserDaoImpl类中实现login()方法。

package com.newer.dao.impl;

import com.newer.dao.IUserDao;

public class UserDaoImpl implements IUserDao {

@Override

public boolean login(String name, String password) {

if (name.equals("张三")&&password.equals("123")){

return true;

}

return false;

}

第三步：编写Service层：新建service包，在service包下创建接口IUserService.java，在接口中添加方法login()。

package com.newer.service;

public interface IUserService {

public boolean login(String name,String password);

}

第四步、编写Service层实现类：创建UserService接口的实现类UserServiceImpl，在UserServiceImpl类中实现login()方法。

package com.newer.service.impl;

import com.newer.dao.IUserDao;

import com.newer.service.IUserService;

public class UserServiceImpl implements IUserService {

IUserDao userDao;

public void setUserDao(IUserDao userDao) {

this.userDao = userDao;

}

@Override

public boolean login(String name, String password) {

return userDao.login(name,password);

}

第五步：修改applicationContext.xml配置文件：使用<bean>元素添加创建的UserDaoImpl类和UserServiceImpl类的实例，并配置其相关属性。

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

</bean>

</beans>

第六步：编写测试类：在com.itheima包中新建测试类TestSpring，测试依赖注入。

import com.newer.service.IUserService;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {

public static void main(String[] args){

//加载applicationContext.xml配置

ApplicationContext applicationContext=new

ClassPathXmlApplicationContext("applicationContext.xml");

//获取配置中的UserService实例

IUserService userService=(IUserService)

applicationContext.getBean("userService");

boolean flag =userService.login("张三","123");

if (flag){

System.out.println("登录成功");

}else {

System.out.println("登录失败");

}