首页手记 Spring入门教程：轻松掌握Spring框架基础

Spring入门教程：轻松掌握Spring框架基础

标签：

SpringBoot Spring Cloud Spring

概述

Spring框架是由Rod Johnson在2003年设计并发布的，旨在简化企业级Java开发。Spring的核心理念包括控制反转（IoC）和面向切面编程（AOP），并通过多个模块提供了丰富的功能，如核心容器、AOP模块、数据访问和Web模块。文章将详细讲解如何搭建开发环境、配置Spring项目以及使用Spring的核心功能。

Spring框架简介

Spring框架的起源与发展

Spring框架是由Rod Johnson在2003年设计并发布的。最初，Spring的目标是简化企业级Java开发，提供一种轻量级的解决方案来替代传统的Java EE技术。Spring 1.0版本于2004年3月发布，随后在社区的支持下不断发展，加入了更多功能和模块。Spring 2.0版本引入了Spring Expression Language (SpEL)，进一步增强了配置的灵活性。Spring 3.0版本引入了对Java 5的全面支持，包括泛型、注解等特性。Spring 3.1版本引入了Spring Boot，极大地简化了Spring项目的配置和管理。自此，Spring Boot成为了快速开发Spring应用程序的标准工具。

Spring框架的核心理念

Spring框架的核心理念之一是控制反转（Inversion of Control, IoC）。IoC通过将对象之间的依赖关系管理从应用程序代码转移到外部配置文件中，使得对象的创建和依赖关系的管理变得更为灵活。另一个核心理念是面向切面编程（Aspect-Oriented Programming, AOP）。AOP通过将横切关注点（如日志记录、事务管理等）从核心业务逻辑中分离出来，使得代码结构更加清晰，维护性更强。

Spring框架的主要模块介绍

Spring框架由多个模块组成，每个模块提供特定的功能：

核心容器：提供了Spring框架的基本功能，包括IoC容器的实现。核心模块还包括Bean工厂（BeanFactory）和应用上下文（ApplicationContext）。
AOP模块：支持AOP编程，提供了声明式事务管理、日志记录等功能。
数据访问/集成：提供了对JDBC、ORM框架（如Hibernate、MyBatis）、OXM（对象-XML映射）、JMS（Java消息服务）的支持。
Web模块：提供了对Web应用的支持，包括Spring MVC框架，用于构建Web应用和RESTful服务。
测试模块：提供了对JUnit支持的测试扩展，使得依赖注入和切面编程在测试中变得容易。
消息模块：提供了对AMQP（高级消息队列协议）的支持，便于构建基于消息传递的应用。

Spring环境搭建

开发环境准备

在开始使用Spring框架之前，首先需要准备开发环境。以下是环境准备的基本步骤：

安装Java开发工具包（JDK）：确保安装了Java开发环境，如JDK 8及以上版本。
安装IDE：推荐使用Eclipse或IntelliJ IDEA等IDE。
安装构建工具：常用的构建工具包括Maven和Gradle，本教程将介绍如何使用Maven。

Maven或Gradle配置

Maven

Maven是一个强大的项目管理和构建工具，可以管理项目的构建、报告和文档。以下是使用Maven的步骤：

创建一个新的Maven项目：

打开命令行工具，切换到项目目录，执行以下命令：

mvn archetype:generate -DgroupId=com.example -DartifactId=spring-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

这个命令会创建一个新的基于Maven的Java项目，项目结构如下：

spring-demo
└── src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── App.java
│   └── resources
└── test
    └── java
        └── com
            └── example
                └── AppTest.java

pom.xml配置：

打开pom.xml文件，添加Spring依赖：

<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.example</groupId>
<artifactId>spring-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.3.10</version>
</dependency>
</dependencies>
</project>

Gradle

Gradle是一个构建自动化工具，它的配置文件为build.gradle。

创建一个新的Gradle项目：

在命令行中执行：
```
gradle init --type java-application
```

这个命令会创建一个新的Java项目，项目结构如下：

spring-demo
└── src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── App.java
│   └── resources
└── test
    └── java
        └── com
            └── example
                └── AppTest.java

build.gradle配置：
- 打开build.gradle文件，添加Spring依赖：
```
plugins {
id 'java'
}
```
repositories {
mavenCentral()
}

dependencies {
implementation 'org.springframework:spring-context:5.3.10'
}

Spring项目创建与配置

创建一个新的Spring项目后，需要配置Spring的核心文件applicationContext.xml。这个文件位于src/main/resources目录下，用于声明Bean和配置IoC容器。

创建applicationContext.xml：

在src/main/resources目录下创建一个名为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="myBean" class="com.example.MyBean"/>
</beans>

创建一个简单的Java类：
- 在src/main/java/com/example目录下创建一个名为MyBean.java的文件，并添加以下内容：
```
package com.example;
```
public class MyBean {
public MyBean() {
System.out.println("MyBean constructor is called.");
}
}
在主类中加载Spring容器：
- 在App.java中加载Spring配置文件，并获取MyBean实例：
```
package com.example;
```
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
MyBean myBean = (MyBean) context.getBean("myBean");
}
}

Spring IoC容器

什么是IoC（控制反转）

IoC是Spring框架的核心概念之一，全称为Inversion of Control（控制反转）。IoC的核心思想是将对象之间的依赖关系的控制从应用程序代码转移到外部配置文件中。通过这种方式，应用程序的耦合度降低，代码的可测试性和可维护性得到提高。

IoC容器是Spring框架中的一个组件，它负责创建、管理并装配对象依赖关系。IoC容器通过配置文件（如applicationContext.xml）来了解对象之间的依赖关系，然后根据这些配置来创建对象实例并装配依赖关系。

配置Bean的方式

Bean是Spring中的一个基本概念，代表了一个具有特定功能的对象。Bean的配置可以通过XML、Java注解或Java配置类来完成。

XML配置

使用XML配置文件来定义Bean的配置是最常见的方法。以下是XML配置的基本语法：

<bean id="myBean" class="com.example.MyBean"/>

在上面的示例中，id属性是Bean的唯一标识符，class属性指定了Bean的类。

Java注解配置

Spring还支持使用Java注解来配置Bean。常用的注解包括@Component、@Service、@Repository和@Controller。这些注解可以标记在类的定义上，表示该类是Spring管理的Bean。

package com.example;

import org.springframework.stereotype.Component;

@Component
public class MyBean {
    public MyBean() {
        System.out.println("MyBean constructor is called.");
    }
}

Java配置类

Java配置类是另一种配置Bean的方式，通过编写Java代码来定义Bean。这种方式提供了更大的灵活性，支持嵌入逻辑和条件配置。

package com.example;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
}

IoC容器的基本使用

IoC容器提供了一系列方法来操作和使用Bean。以下是一些常用的方法：

getBean(String name)：根据Bean的名称获取Bean实例。
getBean(Class<T> requiredType)：根据Bean的类型获取Bean实例。
getBean(String name, Class<T> requiredType)：根据Bean的名称和类型获取Bean实例。

以下是一个简单的示例，演示如何在应用程序中使用IoC容器：

package com.example;

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

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MyBean myBean = (MyBean) context.getBean("myBean");
        System.out.println(myBean);
    }
}

Spring依赖注入

依赖注入的概念

依赖注入（Dependency Injection，DI）是Spring框架的核心特性之一，与IoC容器紧密相关。依赖注入的思想是将对象的依赖关系通过外部配置文件传递给对象，而不是在类内部创建依赖对象。这样做的好处是降低了对象之间的耦合度，使得代码更易于测试和维护。

依赖注入可以通过多种方式实现，包括构造器注入、setter注入和注解注入。

Setter注入与Constructor注入

Setter注入

Setter注入是通过调用对象的setter方法来注入依赖关系。这种方式适用于依赖关系较为简单的场景。

package com.example;

import org.springframework.beans.factory.annotation.Autowired;

public class UserService {
    private UserRepository userRepository;

    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void performUserOperations() {
        // 使用userRepository执行操作
    }
}

Constructor注入

Constructor注入是通过构造器参数来注入依赖关系。这种方式提供了更好的类型安全性，因为构造器参数是编译时固定的。

package com.example;

import org.springframework.beans.factory.annotation.Autowired;

public class UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void performUserOperations() {
        // 使用userRepository执行操作
    }
}

通过注解实现依赖注入

Spring框架提供了多种注解来实现依赖注入。常用的注解包括@Autowired、@Inject和@Resource。

`@Autowired`注解

@Autowired注解用于自动装配依赖关系。

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void performUserOperations() {
        // 使用userRepository执行操作
    }
}

`@Inject`和`@Resource`注解

@Inject和@Resource注解也可以实现依赖注入，它们的用法和@Autowired类似。

package com.example;

import javax.inject.Inject;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;

@Component
public class UserService {
    private final UserRepository userRepository;

    @Inject
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Resource
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void performUserOperations() {
        // 使用userRepository执行操作
    }
}

Spring AOP（面向切面编程）

AOP的基本概念

面向切面编程（Aspect-Oriented Programming，AOP）是Spring框架提供的另一种核心特性。AOP允许开发者将横切关注点（如日志记录、事务管理等）从核心业务逻辑中分离出来，以实现更为清晰、模块化的代码结构。

AOP的核心概念包括切面（Aspect）、通知（Advice）和切入点（Pointcut）。

切面（Aspect）

切面是将横切关注点封装成独立模块的抽象。切面可以跨越多个类和方法，通常使用注解或配置文件来定义。

通知（Advice）

通知是在特定切入点执行的代码。通知分为前置通知（Before）、后置通知（After）、返回通知（AfterReturning）和异常通知（AfterThrowing）等类型。

切入点（Pointcut）

切入点定义了通知何时执行。可以使用表达式语言（如AspectJ表达式语言）来指定切入点。

切面、通知、切入点的定义

以下是一个简单的AOP示例，演示如何定义切面、通知和切入点。

定义切面：
- 创建一个切面类，并使用@Aspect注解标记为切面。
- 定义通知方法，并使用相应的注解（如@Before、@After等）标记。
- 使用@Pointcut注解定义切入点。

package com.example;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class LoggingAspect {
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethods() {}

    @Before("serviceMethods()")
    public void logBefore() {
        System.out.println("Logging before service method execution");
    }
}

配置AOP：
- 在Spring配置文件中启用AOP功能，并指定切面类。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="com.example"/>

    <aop:config>
        <aop:aspect ref="loggingAspect">
            <aop:pointcut expression="execution(* com.example.service.*.*(..))" id="serviceMethods"/>
            <aop:before method="logBefore" pointcut-ref="serviceMethods"/>
        </aop:aspect>
    </aop:config>

    <bean id="loggingAspect" class="com.example.LoggingAspect"/>
</beans>

AOP在Spring中的配置与使用

以下是一个完整的AOP配置示例，演示如何在Spring项目中使用AOP。

创建服务类：
- 创建一个简单的服务类，并添加一个方法。

package com.example.service;

public class UserService {
    public void performUserOperations() {
        System.out.println("Performing user operations");
    }
}

配置Spring上下文：
- 在applicationContext.xml中启用Spring的AOP功能，并配置切面。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="com.example"/>

    <aop:config>
        <aop:aspect ref="loggingAspect">
            <aop:pointcut expression="execution(* com.example.service.*.*(..))" id="serviceMethods"/>
            <aop:before method="logBefore" pointcut-ref="serviceMethods"/>
        </aop:aspect>
    </aop:config>

    <bean id="loggingAspect" class="com.example.LoggingAspect"/>
    <bean id="userService" class="com.example.service.UserService"/>
</beans>

在主类中加载Spring上下文：
- 在主类中加载Spring配置文件，并获取服务类的实例。

package com.example;

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

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.performUserOperations();
    }
}

Spring MVC初探

MVC设计模式简介

Model-View-Controller（MVC）是一种常见的软件架构模式，广泛应用于Web应用的开发中。MVC模式将应用程序分为三个部分：Model、View和Controller，每个部分负责不同的功能。

Model：模型层负责业务逻辑和数据处理。模型层通常包含业务对象（如User、Product等）和持久化逻辑。
View：视图层负责用户界面的展示。视图层通常由HTML、JSP、Thymeleaf等模板引擎生成。
Controller：控制器层负责处理用户请求并调用模型层和视图层。控制器层通常处理HTTP请求，调用模型层的方法，并将结果传递给视图层进行展示。

Spring MVC的工作流程

Spring MVC是Spring框架提供的一个MVC实现。它遵循标准的MVC架构，将请求处理分为多个步骤：

用户发起请求：用户通过浏览器或API客户端发起HTTP请求。
DispatcherServlet拦截请求：Spring MVC的中心控制器DispatcherServlet拦截请求，并根据请求类型（如GET、POST）将其分发给相应的处理器。
处理器执行业务逻辑：处理器（通常是一个控制器类）执行业务逻辑并调用模型层。
视图解析：处理器将处理结果传递给视图解析器，视图解析器根据配置将结果映射到具体的视图。
视图渲染：视图解析器将模型数据传递给视图，视图根据模型数据生成HTML响应。
响应用户：视图渲染完成后，响应被发送回客户端。

控制器、视图、模型的实现

以下是一个简单的Spring MVC示例，演示如何实现控制器、视图和模型。

创建模型类：
- 创建一个简单的模型类，用于存储业务数据。

package com.example.model;

public class User {
    private String name;
    private int age;

    public User() {}

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

创建控制器类：
- 创建一个控制器类，并使用@Controller注解标记为控制器。

package com.example.controller;

import com.example.model.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class UserController {
    @GetMapping("/user")
    @ResponseBody
    public User getUser() {
        User user = new User();
        user.setName("John Doe");
        user.setAge(30);
        return user;
    }
}

配置Spring MVC：
- 在applicationContext.xml中配置Spring MVC的相关组件。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="com.example"/>

    <mvc:annotation-driven/>
</beans>

配置Web应用：
- 创建web.xml文件，配置DispatcherServlet。

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
          http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
          version="3.1">

    <display-name>Spring MVC Example</display-name>

    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/applicationContext.xml</param-value>
        </init-param>
    </servlet>

    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

测试Spring MVC应用：
- 使用浏览器访问http://localhost:8080/user，查看返回的用户信息。

通过以上步骤，可以创建一个简单的Spring MVC应用，实现基本的请求处理和视图渲染功能。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

梵蒂冈之花

手记
篇

粉丝

30

获赞与收藏

168

关注作者，订阅最新文章

阅读免费教程

Spring Cloud Hystrix

15个小节 6169 121

Spring Security

28个小节 16624 266

Spring MVC 入门教程

24个小节 23502 326

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空