首页手记 Spring入门：新手必读的简单教程

Spring入门：新手必读的简单教程

标签：

Java Spring

概述

Spring入门介绍了Spring框架的基础概念，包括IoC容器、依赖注入和Bean生命周期管理。文章还详细讲解了如何搭建Spring开发环境，并提供了多个示例代码和配置文件。此外，文章还涵盖了Spring MVC、Spring Data JPA和Spring Security等常用模块的使用方法。希望通过本文，读者能够全面了解并掌握Spring框架的基本用法。

Spring框架简介

什么是Spring

Spring是一个开源的Java应用程序框架，它使用了依赖注入（Dependency Injection，简称DI）和面向切面编程（Aspect-Oriented Programming，简称AOP）的编程模式。Spring旨在简化Java应用程序的开发，降低应用程序的复杂性，使开发过程更加模块化和可测试。

Spring框架最初由Rod Johnson创建，其目标是使企业应用程序的开发变得简单。Spring框架的核心目标是使开发过程中的组件之间的依赖关系更加松散，从而提高代码的可维护性和可测试性。Spring框架提供了完整的全功能企业应用开发平台，能够简化开发流程，提高开发效率。

Spring的核心优势

降低代码复杂性：Spring框架通过其IoC容器和DI容器，使代码更加松耦合，从而简化了Java开发。
易于测试：Spring的DI和AOP特性使得单元测试变得更加容易，因为它们可以轻松地模拟和替换依赖关系。
解决企业级开发中的常见问题：Spring提供了许多模块来解决企业级开发中的常见问题，比如事务管理、安全性和数据访问等。
支持多种编程模型：Spring框架支持多种编程模型，包括面向对象的编程和面向切面的编程，使得开发者可以灵活地选择适合自己的开发方式。
与第三方库集成：Spring框架能够与许多第三方库进行无缝集成，比如数据库访问框架（如Hibernate和JDBC）、Web框架（如Spring MVC）等。

Spring的版本及最新特性

Spring框架的版本号遵循语义化版本控制（Semantic Versioning）。当前的稳定版本是Spring 5.x，其中Spring 5.3.12是最新的稳定版本。

Spring 5.x版本引入了许多新特性和改进，包括：

改进的WebFlux支持：WebFlux是Spring 5中的响应式Web框架，提供了异步、非阻塞的编程模型，提高了应用程序的性能和可伸缩性。
Spring Boot 2.x集成：Spring Boot 2.x版本与Spring 5.x版本紧密集成，提供了更简单、更快速的Spring应用程序开发体验。
Java 11兼容性：Spring 5.x版本支持Java 11，这是Java平台的长期支持版本。
改进的AOP支持：Spring 5.x版本优化了面向切面编程的支持，使得开发者可以更灵活地定义和使用切面。

示例代码

// 示例代码：简单的Spring IoC容器使用
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        SimpleBean simpleBean = (SimpleBean) context.getBean("simpleBean");
        simpleBean.sayHello();
    }
}

// SimpleBean类
public class SimpleBean {
    public void sayHello() {
        System.out.println("Hello, world!");
    }
}

Spring环境搭建

安装Java开发环境

为了使用Spring框架，首先需要安装Java开发环境。以下是安装步骤：

下载Java JDK：前往Oracle官网或者其他资源网站下载Java JDK，推荐使用Java 8或更高版本。
安装Java JDK：根据系统的不同，按照安装向导进行安装。
配置环境变量：在系统环境变量中配置JAVA_HOME和PATH，确保Java可以被系统识别和使用。

示例代码

# 设置环境变量
export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH

下载并导入Spring框架

获取Spring框架：可以下载Spring框架的JAR包，或者使用Maven和Gradle等构建工具通过依赖管理来自动获取Spring框架。
Maven配置：在pom.xml文件中添加Spring的依赖配置。

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.12</version>
    </dependency>
</dependencies>

Gradle配置：在build.gradle文件中添加Spring的依赖配置。

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

配置IDE开发环境

选择IDE：选择一款支持Java开发的IDE，例如Eclipse、IntelliJ IDEA或者NetBeans。
导入项目：将项目导入IDE中，确保项目依赖被正确解析。
配置Spring支持：在IDE中配置Spring支持，例如在Eclipse中安装Spring工具插件。

示例代码

<!-- pom.xml文件示例 -->
<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-example</artifactId>
  <version>1.0-SNAPSHOT</version>
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.3.12</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.12</version>
    </dependency>
  </dependencies>
</project>

Spring核心概念

Inversion of Control (IoC) 容器

IoC容器是Spring的核心组件之一，负责管理应用程序中的对象及其依赖关系。IoC容器通过DI机制，将对象的依赖关系注入到对象中，从而使得应用程序中的对象之间的耦合度降低。

IoC容器的主要功能包括：

对象的创建和管理：IoC容器负责创建应用程序中的对象，并管理它们的生命周期。
依赖关系的注入：IoC容器将一个对象的依赖关系注入到另一个对象中，从而减少对象之间的耦合度。
配置管理：IoC容器负责管理应用程序的配置信息，通常是通过XML文件或者Java注解的方式。

示例代码

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

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        MyService myService = context.getBean(MyService.class);
        myService.doSomething();
    }
}

public class MyService {
    private MyDependency myDependency;

    // 使用setter注入依赖
    public void setMyDependency(MyDependency myDependency) {
        this.myDependency = myDependency;
    }

    public void doSomething() {
        myDependency.doSomething();
    }
}

public class MyDependency {
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

<!-- beans.xml -->
<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="myDependency" class="com.example.MyDependency" />

    <bean id="myService" class="com.example.MyService">
        <property name="myDependency" ref="myDependency" />
    </bean>
</beans>

Dependency Injection (DI) 依赖注入

依赖注入（DI）是Spring框架的核心设计模式之一，它允许开发者将对象的依赖关系从代码中解耦出来，转移到外部配置中。Spring框架提供了多种方式来实现依赖注入，包括构造函数注入、setter方法注入和接口注入。

构造函数注入

构造函数注入通过构造函数参数来传递依赖项。

Setter方法注入

setter方法注入通过setter方法来传递依赖项，如前面示例代码所展示的。

接口注入

接口注入通过接口来传递依赖项，这种方式较少使用。

示例代码

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

@Component
public class MyService {
    private MyDependency myDependency;

    @Autowired
    public MyService(MyDependency myDependency) {
        this.myDependency = myDependency;
    }

    public void doSomething() {
        myDependency.doSomething();
    }
}

public class MyDependency {
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

<!-- beans.xml -->
<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="myDependency" class="com.example.MyDependency" />

    <bean id="myService" class="com.example.MyService">
        <constructor-arg ref="myDependency" />
    </bean>
</beans>

Bean的生命周期管理

Spring框架管理Bean的生命周期，从Bean的创建到销毁，Spring框架会处理整个过程。Spring框架提供了多种方式来管理Bean的生命周期，包括生命周期回调方法和后处理器。

生命周期回调方法

Spring框架提供了几个生命周期回调方法，如InitializingBean接口的afterPropertiesSet方法和DisposableBean接口的destroy方法。

示例代码

import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class MyBean implements InitializingBean, DisposableBean, BeanNameAware {
    private String beanName;

    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化完成后的处理
        System.out.println("Bean " + beanName + " 初始化完成");
    }

    @Override
    public void destroy() throws Exception {
        // 销毁前的处理
        System.out.println("Bean " + beanName + " 正在销毁");
    }

    @Override
    public void setBeanName(String name) {
        // 设置Bean名
        this.beanName = name;
    }
}

<!-- beans.xml -->
<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>

后处理器

Spring框架还提供了后处理器来处理Bean的生命周期，如BeanPostProcessor接口的postProcessBeforeInitialization和postProcessAfterInitialization方法。

示例代码

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 初始化前的处理
        System.out.println("Bean " + beanName + " 在初始化前被处理");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 初始化后的处理
        System.out.println("Bean " + beanName + " 在初始化后被处理");
        return bean;
    }
}

<!-- beans.xml -->
<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" />
    <bean id="myBeanPostProcessor" class="com.example.MyBeanPostProcessor" />
</beans>

Spring常用模块介绍

Spring MVC

Spring MVC是一个强大的Web框架，它以Spring框架为基础，为Web应用程序提供了模型-视图-控制器（Model-View-Controller，简称MVC）的实现。Spring MVC框架的特点包括：

清晰的职责分离：Spring MVC框架将应用程序的不同职责分离，使得开发更加模块化。
灵活的配置：Spring MVC框架提供了高度灵活的配置方式，可以使用XML配置、Java配置或者注解来定义控制器、处理器映射和视图解析器等。
强大的数据绑定功能：Spring MVC框架提供了强大的数据绑定功能，可以将HTTP请求中的数据绑定到Java对象中。

示例代码

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class MyController {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public ModelAndView hello(@RequestParam(value = "name", required = false, defaultValue = "World") String name) {
        ModelAndView modelAndView = new ModelAndView("hello");
        modelAndView.addObject("message", "Hello, " + name + "!");
        return modelAndView;
    }
}

<!-- hello.jsp -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello Page</title>
</head>
<body>
    <h1>${message}</h1>
</body>
</html>

<!-- spring-mvc.xml -->
<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>

Spring Data JPA

Spring Data JPA是Spring Data项目的一个部分，它提供了一套简化数据访问的API，使得开发人员可以更加方便地进行数据库操作。Spring Data JPA的核心特点是：

声明式数据访问：Spring Data JPA通过声明式的方式来访问数据，使得开发人员无需编写大量的SQL或者存储过程。
自动生成SQL：Spring Data JPA可以自动生成SQL语句，减少了开发人员的工作量。
与各种数据库兼容：Spring Data JPA支持多种数据库，包括关系型数据库（如MySQL、Oracle等）和NoSQL数据库（如MongoDB、Cassandra等）。

示例代码

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getter and Setter methods
}

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

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

@Service
public class UserService {
    private UserRepository userRepository;

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

    public User findById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

<!-- application.properties -->
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

Spring Security

Spring Security是一个强大的安全框架，它为Web应用程序提供了全面的安全解决方案。Spring Security的主要功能包括：

认证和授权：Spring Security提供了认证和授权的功能，可以基于用户名和密码、JWT、OAuth和其他认证方式来验证用户身份。
加密和解密：Spring Security提供了加密和解密的功能，可以保护敏感的数据。
安全的Web访问：Spring Security提供了一系列的安全配置，可以保护Web应用程序免受各种攻击。

示例代码

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER")
            .and()
            .withUser("admin").password("{noop}password").roles("ADMIN");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasRole("USER")
                .antMatchers("/", "/home").permitAll()
            .and()
                .formLogin()
                .loginPage("/login")
                .permitAll()
            .and()
                .logout()
                .permitAll();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        manager.createUser(User.withDefaultPasswordEncoder()
            .username("user")
            .password("password")
            .roles("USER")
            .build());
        manager.createUser(User.withDefaultPasswordEncoder()
            .username("admin")
            .password("password")
            .roles("ADMIN")
            .build());
        return manager;
    }
}

实战演练：创建第一个Spring应用

创建一个新的Spring项目

创建一个新的Spring项目，可以通过IDE创建，也可以通过Maven或Gradle创建。

Maven项目

创建项目目录结构

spring-example/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com.example/
│   │   │       └── application/
│   │   │           └── App.java
│   │   └── resources/
│   │       └── application.properties
│   └── test/
│       └── java/
│           └── com.example/
│               └── application/
│                   └── AppTest.java
└── pom.xml

配置pom.xml

<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-example</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>5.3.12</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-beans</artifactId>
          <version>5.3.12</version>
      </dependency>
  </dependencies>
</project>

编写简单的业务逻辑

编写简单的业务逻辑，如创建一个简单的服务类和控制器类。

服务类

import org.springframework.stereotype.Service;

@Service
public class MyService {
    public String sayHello() {
        return "Hello, world!";
    }
}

控制器类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {
    private MyService myService;

    @Autowired
    public MyController(MyService myService) {
        this.myService = myService;
    }

    @GetMapping("/hello")
    public String hello() {
        return myService.sayHello();
    }
}

测试应用程序

测试应用程序，确保一切正常运行。

运行程序

运行主应用程序

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class App {
   public static void main(String[] args) {
       SpringApplication.run(App.class, args);
   }
}

访问URL
启动应用程序后，访问http://localhost:8080/hello，应该看到返回的字符串Hello, world!。

常见问题与调试技巧

常见错误及解决方法

找不到Bean定义：确保Bean定义正确，检查XML配置文件或注解配置是否正确。
依赖注入失败：确保依赖关系正确配置，检查依赖注入的类型和名称是否匹配。
类路径问题：确保所有必要的库和依赖项都在类路径中，检查pom.xml或build.gradle文件中的依赖配置是否正确。

示例代码

<!-- 解决找不到Bean定义的问题 -->
<bean id="myBean" class="com.example.MyBean" />

// 解决依赖注入失败的问题
@Autowired
private MyDependency myDependency;

<!-- 解决类路径问题 -->
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.3.12</version>
    </dependency>
</dependencies>

调试技巧和最佳实践

使用IDE调试工具：利用IDE提供的调试工具，在代码执行时逐行调试，查看变量的值。
日志记录：使用日志框架（如Log4j或SLF4J）记录关键信息，便于诊断问题。
单元测试：编写单元测试，确保代码的正确性。

示例代码

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class MyService {
    private static final Logger logger = LogManager.getLogger(MyService.class);

    public void doSomething() {
        logger.info("Doing something...");
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class MyServiceTest {
    @Autowired
    private MyService myService;

    @Test
    public void testDoSomething() {
        myService.doSomething();
        // 添加断言
        // Assert.assertEquals(expected, actual);
    }
}

Spring社区资源推荐

Spring官网：Spring官网提供了丰富的文档和示例代码，是学习Spring框架的首选资源。
Stack Overflow：Stack Overflow是一个问答网站，上面有大量的Spring相关的问题和答案。
GitHub：GitHub上有大量的Spring项目和示例代码，可以参考这些项目来学习和实践。

示例代码

<!-- Stack Overflow上的Spring问题 -->
https://stackoverflow.com/questions/tagged/spring

// GitHub上的Spring项目
https://github.com/spring-projects

通过以上内容，您可以全面了解Spring框架的基本概念、环境搭建、常用模块和实际应用中的问题解决方法。希望这些内容能帮助您更好地理解和使用Spring框架。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕标琳琳

手记
篇

粉丝

18

获赞与收藏

140

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19277 315

Java 并发原理入门教程

26个小节 39001 568

Java 入门教程

50个小节 342035 3165

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Spring入门：新手必读的简单教程

示例代码

示例代码

示例代码

示例代码

构造函数注入

Setter方法注入

接口注入

示例代码

生命周期回调方法

示例代码

后处理器

示例代码

示例代码

示例代码

示例代码

Maven项目

服务类

控制器类

运行程序

示例代码

示例代码

示例代码

阅读免费教程