首页手记 Spring教程：初学者快速入门指南

Spring教程：初学者快速入门指南

标签：

Spring Cloud Spring

概述

Spring教程介绍了Spring框架的基本概念、版本特性、环境搭建和示例代码，帮助开发者快速上手。文章详细解释了Spring的核心概念，如IoC和DI，并展示了如何使用Spring进行Web开发和数据访问。此外，教程还涵盖了Spring的事务管理和测试方法，确保开发者能够全面了解和应用Spring框架。

Spring框架简介

Spring框架的作用和优势

Spring框架是一个开源的企业级Java开发框架，它简化了Java开发并提供了许多强大的功能，使得构建企业级应用变得更加容易。Spring框架的优势包括：

轻量级框架：Spring是一个轻量级的框架，它降低了应用程序的复杂性，减少了代码量。
依赖注入（DI）：Spring通过依赖注入（Dependency Injection, DI）实现了松耦合，使组件之间更加独立。
面向切面编程（AOP）：Spring支持AOP，可以将横切关注点（如日志、安全、事务）从业务逻辑中分离出来。
事务管理：Spring提供了事务管理功能，支持声明式事务管理。
持久化支持：Spring提供了多种持久化框架的集成支持，如JDBC、JPA、Hibernate等。
MVC框架：Spring MVC是一个强大的MVC框架，可以构建高度可扩展和松耦合的Web应用程序。
完善的异常处理：Spring框架提供了统一的异常处理机制，使得开发人员可以更好地处理和管理异常。

Spring框架的版本与特性

Spring框架的版本分为几个主要系列，包括Spring Framework、Spring Boot等。最新的Spring Framework版本是5.3.x，而Spring Boot则是2.5.x系列。每个版本都引入了许多新特性和改进：

Spring Framework 5.x
- 支持Java 11，增强了对Java 9、10和11模块系统的支持。
- 提供了对Java 9新特性的支持，如JavaFX和模块系统。
- 改进了Spring MVC、Spring WebFlux等模块。
- 引入了新的配置选项和注解。
Spring Boot 2.x
- 自动配置简化了应用程序的初始化过程。
- 支持多种数据库和框架，如JPA、Hibernate、MyBatis等。
- 提供了Spring Cloud集成，简化了微服务开发。
- 支持多种构建工具，如Maven和Gradle。
- 提供了集成测试支持，简化了测试过程。

示例代码

下面是一个简单的Spring应用示例，展示了如何使用Spring的依赖注入和Bean配置。

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

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
        obj.getMessage();
    }
}

<!-- 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="helloWorld" class="com.example.HelloWorld">
        <property name="message" value="Hello World"/>
    </bean>
</beans>

// HelloWorld.java
package com.example;
public class HelloWorld {
    private String message;

    public void setMessage(String message) {
        this.message = message;
    }

    public void getMessage() {
        System.out.println("Hello World: " + message);
    }
}

Spring环境搭建

开发环境准备

要开始开发Spring应用程序，你需要准备以下开发环境：

Java开发环境：确保安装了Java开发工具包（JDK），推荐使用Java 8或更高版本。
开发工具：使用一个集成开发环境（IDE），如IntelliJ IDEA、Eclipse或STS（Spring Tool Suite）。
构建工具：选择一个构建工具，如Maven或Gradle。

IDE配置示例

IntelliJ IDEA配置示例

创建Spring项目：
- 打开IntelliJ IDEA，选择File -> New -> Project。
- 选择Spring Initializr，配置项目信息，选择Java、Maven或Gradle，以及项目依赖。
- 点击Finish完成项目创建。

添加Spring依赖：

打开pom.xml或build.gradle文件，添加所需的Spring依赖。

例如，对于Maven项目：

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

对于Gradle项目：

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

Maven和Gradle配置

Maven配置

在Maven项目中，需要在pom.xml文件中添加Spring依赖。以下是基本的Maven配置：

<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.0</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.10</version>
        </dependency>
        <!-- 添加其他所需依赖 -->
    </dependencies>
</project>

Gradle配置

在Gradle项目中，需要在build.gradle文件中添加Spring依赖。以下是基本的Gradle配置：

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework:spring-core:5.3.10'
    implementation 'org.springframework:spring-context:5.3.10'
    // 添加其他所需依赖
}

示例代码

下面是一个简单的Maven项目配置示例，展示了如何在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-maven-example</artifactId>
    <version>1.0.0</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.10</version>
        </dependency>
    </dependencies>
</project>

下面是一个简单的Gradle项目配置示例，展示了如何在build.gradle文件中添加Spring依赖。

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

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

Spring核心概念与基本使用

IoC与DI基础

什么是IoC

Inversion of Control（IoC）是指将对象的控制权从代码中移出，由容器来创建、管理这些对象。IoC的核心思想是将对象的创建和配置从代码中分离出来，由容器统一管理。

什么是DI（依赖注入）

Dependency Injection（DI）是一种实现IoC的设计模式。它允许将组件的依赖关系通过配置文件（如XML文件）或注解注入到组件中。这样可以降低组件之间的耦合度，提高代码的可维护性和可测试性。

Spring中的IoC容器

Spring提供了两个IoC容器实现：ApplicationContext和BeanFactory。通常推荐使用ApplicationContext，因为它提供了更多的特性，如国际化支持、事件发布等。

示例代码

下面是一个简单的Spring应用示例，展示了如何使用ApplicationContext来管理Bean。

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

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
        obj.getMessage();
    }
}

<!-- 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="helloWorld" class="com.example.HelloWorld">
        <property name="message" value="Hello World"/>
    </bean>
</beans>

// HelloWorld.java
package com.example;
public class HelloWorld {
    private String message;

    public void setMessage(String message) {
        this.message = message;
    }

    public void getMessage() {
        System.out.println("Hello World: " + message);
    }
}

Bean的定义与配置

Bean的定义

在Spring中，Bean的定义通常通过XML文件或注解进行。XML文件配置是传统的配置方式，而注解配置则是更现代的方式。

XML配置

XML配置文件通常放在类路径下，通过<bean>标签定义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="helloWorld" class="com.example.HelloWorld">
        <property name="message" value="Hello World"/>
    </bean>
</beans>

注解配置

使用注解配置Bean通常更简单和更现代。例如：

// HelloWorld.java
package com.example;
import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Value;

@Component
public class HelloWorld {
    @Value("Hello World")
    private String message;

    public void getMessage() {
        System.out.println("Hello World: " + message);
    }
}

示例代码

下面是一个使用注解配置的示例，展示了如何定义和使用Bean。

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        HelloWorld obj = context.getBean(HelloWorld.class);
        obj.getMessage();
    }
}

// HelloWorld.java
package com.example;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class HelloWorld {
    @Value("Hello World")
    private String message;

    public void getMessage() {
        System.out.println("Hello World: " + message);
    }
}

// AppConfig.java
package com.example;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

Spring MVC入门

什么是Spring MVC

Spring MVC是一个基于Java的Web框架，它遵循MVC设计模式。MVC（Model-View-Controller）是一种广泛使用的架构模式，将应用程序分为三个主要部分：模型（Model）、视图（View）和控制器（Controller）。

模型（Model）

模型（Model）是应用程序的核心部分，负责业务逻辑和数据处理。模型通常是由Java类组成，这些类封装了应用程序的数据和业务逻辑。

视图（View）

视图（View）负责用户界面的呈现，通常是HTML文件、JSP页面或Thymeleaf模板等。视图从模型中获取数据并呈现给用户。

控制器（Controller）

控制器（Controller）是用户请求的入口点，负责处理请求、调用模型和渲染视图。控制器通常是由Java类组成，这些类处理HTTP请求并返回HTTP响应。

创建第一个Spring MVC应用程序

创建项目结构

首先，创建一个Spring MVC项目的基本结构，包括Web应用所需的文件和目录结构。

spring-mvc-example/
|-- src/
|   |-- main/
|   |   |-- java/
|   |   |   |-- com/
|   |   |   |   |-- example/
|   |   |   |   |   |-- controller/
|   |   |   |   |   |   |-- HelloWorldController.java
|   |   |   |   |   |-- AppConfig.java
|   |   |-- resources/
|   |   |   |-- application-context.xml
|   |   |-- webapp/
|   |   |   |-- WEB-INF/
|   |   |   |   |-- web.xml
|   |-- test/
|   |   |-- java/
|   |   |   |-- com/
|   |   |   |   |-- example/
|   |   |   |   |   |-- HelloWorldControllerTest.java

配置Spring MVC

在web.xml中配置Spring MVC的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_4_0.xsd"
         version="4.0">
    <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/application-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

创建控制器

创建一个控制器类HelloWorldController，处理HTTP请求并返回相应的视图。

package com.example.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class HelloWorldController {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String printHello(ModelMap model) {
        model.addAttribute("message", "Hello World");
        return "hello";
    }
}

创建视图

创建一个名为hello.jsp的视图文件，用于展示从控制器返回的数据。

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

示例代码

下面是一个完整的Spring MVC应用程序示例，展示了如何创建一个控制器和视图。

package com.example.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class HelloWorldController {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String printHello(ModelMap model) {
        model.addAttribute("message", "Hello World");
        return "hello";
    }
}

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

<!-- WEB-INF/web.xml -->
<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_4_0.xsd"
         version="4.0">
    <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/application-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

<!-- application-context.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="helloWorldController" class="com.example.controller.HelloWorldController"/>
</beans>

Spring数据访问与事务管理

JdbcTemplate与JPA简介

JdbcTemplate

JdbcTemplate是Spring提供的一个类，用于简化JDBC编程。它封装了JDBC操作，处理了关闭资源的问题，提供了丰富的查询方法，简化了数据访问操作。

JPA（Java Persistence API）

JPA（Java Persistence API）是Java EE平台中的一种规范，用于对象关系映射（ORM）。Spring支持JPA，提供了对JPA的集成，使得使用JPA更加简单方便。

事务管理基础

什么是事务

事务是一组操作的集合，这些操作要么全部成功执行，要么全部不执行。事务具有ACID特性：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability）。

Spring中的事务管理

Spring提供了多种事务管理方式，包括编程方式和声明式事务管理。

编程式事务管理

编程式事务管理使用PlatformTransactionManager接口和TransactionDefinition接口来定义事务边界。

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

public class TransactionDemo {
    private JdbcTemplate jdbcTemplate;
    private DataSourceTransactionManager transactionManager;

    public TransactionDemo() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("password");

        this.jdbcTemplate = new JdbcTemplate(dataSource);
        this.transactionManager = new DataSourceTransactionManager(dataSource);
    }

    public void executeTransaction() {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(def);

        try {
            jdbcTemplate.update("INSERT INTO users (username) VALUES (?)", "test");
            transactionManager.commit(status);
        } catch (Exception ex) {
            transactionManager.rollback(status);
        }
    }

    public static void main(String[] args) {
        TransactionDemo demo = new TransactionDemo();
        demo.executeTransaction();
    }
}

声明式事务管理

声明式事务管理通过Spring的@Transactional注解来定义事务边界，不需要编写额外的代码。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {
    private JdbcTemplate jdbcTemplate;

    @Autowired
    public UserService(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Transactional
    public void addUser() {
        jdbcTemplate.update("INSERT INTO users (username) VALUES (?)", "test");
    }
}

示例代码

下面是一个使用JdbcTemplate和声明式事务管理的示例。

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {
    private JdbcTemplate jdbcTemplate;

    public UserService() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("password");

        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    @Transactional
    public void addUser() {
        jdbcTemplate.update("INSERT INTO users (username) VALUES (?)", "test");
    }
}

测试Spring应用程序

单元测试与集成测试

单元测试

单元测试是对最小可测试单元进行测试的测试方式，通常是针对单个类或单个方法的测试。Spring提供了多种单元测试工具，如JUnit、Mockito等。

集成测试

集成测试是对多个模块或组件之间交互进行测试的测试方式。Spring提供了SpringJUnit4ClassRunner和@ContextConfiguration注解来配置测试环境。

使用JUnit和Mockito

JUnit简介

JUnit是一个Java单元测试框架，通过编写测试类和测试方法来验证代码的正确性。Spring与JUnit集成可以方便地进行依赖注入和单元测试。

Mockito简介

Mockito是一个Java单元测试框架，专门用于创建和验证模拟对象。Mockito可以模拟接口和类，使得测试更加灵活。

示例代码

下面是一个使用JUnit和Mockito的示例，展示了如何编写单元测试和集成测试。

import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.when;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
@ComponentScan(basePackages = "com.example")
public class ApplicationTests {
    @Autowired
    private ApplicationContext context;

    @Test
    public void contextLoads() {
        assert(context != null);
    }
}

import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.when;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;

@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {
    @Mock
    private JdbcTemplate jdbcTemplate;

    @InjectMocks
    private UserService userService;

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void testAddUser() {
        when(jdbcTemplate.update("INSERT INTO users (username) VALUES (?)", "test")).thenReturn(1);
        userService.addUser();
        // 这里可以添加更多的断言来验证方法的行为
    }
}

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {
    private JdbcTemplate jdbcTemplate;

    public UserService(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Transactional
    public void addUser() {
        jdbcTemplate.update("INSERT INTO users (username) VALUES (?)", "test");
    }
}


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan(basePackages = "com.example")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
``

以上代码展示了如何使用Spring框架进行单元测试和集成测试。通过这些示例，你可以更好地理解和掌握Spring框架的各种功能和特性。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

MMTTMM

手记
篇

粉丝

65

获赞与收藏

364

关注作者，订阅最新文章

阅读免费教程

Spring Cloud Hystrix

15个小节 6139 120

Spring Security

28个小节 16550 264

Spring MVC 入门教程

24个小节 23405 325

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Spring教程：初学者快速入门指南

IDE配置示例

IntelliJ IDEA配置示例

Maven配置

Gradle配置

什么是IoC

什么是DI（依赖注入）

Spring中的IoC容器

示例代码

Bean的定义

XML配置

注解配置

示例代码

模型（Model）

视图（View）

控制器（Controller）

创建项目结构

配置Spring MVC

创建控制器

创建视图

示例代码

JdbcTemplate

JPA（Java Persistence API）

什么是事务

Spring中的事务管理

编程式事务管理

声明式事务管理

示例代码

单元测试

集成测试

JUnit简介

Mockito简介

示例代码

阅读免费教程