首页手记 Spring入门：新手必备教程

Spring入门：新手必备教程

标签：

Spring

概述

Spring入门介绍了Spring框架的基本概念、核心思想以及环境搭建方法，涵盖了控制反转(IoC)和依赖注入(DI)等核心特性。文章详细讲解了如何配置项目环境并创建第一个Spring项目，为初学者提供了全面的指导。

Spring框架简介

Spring框架的基本概念

Spring框架是一个开源的Java平台下的轻量级框架，由Rod Johnson在2003年创建，旨在简化企业应用开发。Spring框架通过其核心容器提供了一套全面的、通用的企业服务，支持面向切面编程（AOP）、数据库事务管理、持久化层集成等功能。Spring框架的设计目标是降低Java EE开发的复杂性，通过使用基本的JavaBean代替EJB，并提供了更多的企业特征。

Spring框架主要通过依赖注入（Dependency Injection，DI）和控制反转（Inversion of Control，IoC）来管理对象依赖关系，使开发人员能够专注于应用逻辑，而不必担心底层框架的复杂性。

Spring框架的核心思想

控制反转（IoC）：IoC意味着对象不是自己创建依赖对象，而是依赖对象由外部容器创建，然后注入到对象中。这是Spring框架的核心特性之一。
依赖注入（DI）：DI是指对象的依赖关系通过配置文件或者注解来注入，而不是通过硬编码的方式。Spring框架提供了多种依赖注入的方式，如通过构造器注入、setter方法注入等。
面向切面编程（AOP）：Spring框架支持AOP，允许开发者定义一些通用的行为，如日志记录、事务管理等，这些行为可以横切地应用到多个类中，而无需修改这些类的源代码。
声明式事务管理：Spring框架通过AOP来实现声明式事务管理，这意味着开发者可以在配置文件中声明事务属性，而不是在代码中显式地编写事务处理代码。

Spring框架的版本和下载

Spring框架的最新版本可以在Spring官网下载。截至2023年，Spring框架的最新稳定版本是5.3.18。Spring框架提供了多种下载方式，包括从Maven仓库下载依赖、从Spring官网下载压缩包等。

Spring框架的依赖可以通过Maven或Gradle等构建工具进行管理。以下是如何将Spring框架及其相关依赖添加到Maven项目的pom.xml文件中的示例：

<dependencies>
    <!-- Spring Core Dependency -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!-- Spring Context Dependency -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!-- Spring AOP Dependency -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!-- Spring JDBC Dependency -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.18</version>
    </dependency>
</dependencies>

Spring环境搭建

开发环境要求

为了搭建Spring环境，你需要安装以下软件：

JDK：Spring框架运行在Java虚拟机上，因此你需要安装Java开发工具包（JDK），建议使用Java 8及以上版本。
IDE：推荐使用IntelliJ IDEA或Eclipse等流行的Java集成开发环境。
构建工具：你可以选择Maven或Gradle等构建工具来管理项目依赖。

创建第一个Spring项目

创建一个简单的Spring项目可以分为以下几个步骤：

创建一个新的Maven项目。
在pom.xml文件中添加Spring的依赖。
创建一个简单的Java类，并配置Spring容器来管理该类。

以下是如何创建一个简单的Spring项目的步骤：

创建一个Maven项目：
- 使用IDE创建一个新的Maven项目。
- 在pom.xml文件中添加Spring框架的依赖，如上所述。

创建一个简单的Java类：

package com.example.demo;

public class HelloWorld {
   private String message;

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

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

创建Spring配置文件：

在src/main/resources目录下创建一个applicationContext.xml文件。
在该文件中配置HelloWorld类的bean。

<?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/bsn/spring-beans.xsd">

   <bean id="helloWorld" class="com.example.demo.HelloWorld">
       <property name="message" value="Hello World"/>
   </bean>
</beans>

编写测试代码：

package com.example.demo;

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

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

运行测试代码：运行MainApp类中的main方法，输出结果应为Your Message : Hello World。

配置项目环境

在项目中配置Spring环境通常涉及以下几个步骤：

创建Spring配置文件：applicationContext.xml，用于定义Bean及其属性。
加载Spring配置文件：在代码中使用ApplicationContext来加载配置文件。
使用Bean：从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("applicationContext.xml");
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
        obj.getMessage();
    }
}

Spring核心概念

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

IoC是Spring框架的核心概念之一，它指的是对象的创建和依赖关系的管理由外部容器来完成，而不是由对象自身来完成。依赖注入是实现IoC的一种方式，通过配置文件或注解将依赖对象注入到需要使用这些依赖的类中。

IoC容器：Spring容器负责创建、配置和管理这些对象的生命周期。容器会负责管理这些对象的创建和销毁，以及它们之间的依赖关系。
依赖注入：通过XML配置文件或注解来配置依赖关系，从而使对象的依赖关系由容器来管理，而不是由对象自身来管理。

依赖注入示例

以下是如何通过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/bsn/spring-beans.xsd">

    <bean id="helloWorld" class="com.example.demo.HelloWorld">
        <property name="message" value="Hello World"/>
    </bean>
</beans>

以下是如何通过注解来实现依赖注入的示例：

package com.example.demo;

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

@Component
public class HelloWorld {
    private String message;

    @Autowired
    public HelloWorld() {
        this.message = "Hello World";
    }

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

Bean的定义和作用域

Bean的定义

在Spring配置文件中，可以使用<bean>标签来定义一个Bean。每个<bean>标签都定义了一个Spring容器可以管理的对象。<bean>标签的常用属性包括id、class、scope等。

id：Bean的唯一标识符。
class：Bean对应的Java类。
scope：Bean的作用域，常用的scope有singleton、prototype、request、session等。

示例代码

<bean id="helloWorld" class="com.example.demo.HelloWorld" scope="singleton">
    <property name="message" value="Hello World"/>
</bean>

Bean的作用域

singleton：单例模式，整个应用中只有一个实例。
prototype：原型模式，每次请求都会创建一个新的实例。
request：每个HTTP请求都会创建一个新的Bean实例。
session：每个HTTP session都有一个Bean实例。

Bean的生命周期

Bean的生命周期包括以下几个主要阶段：

实例化：Spring容器根据配置文件中的配置信息创建Bean的实例。
设置属性：Spring容器通过设置属性将依赖对象注入到Bean中。
初始化：调用Bean的初始化方法，如init-method属性定义的方法。
使用Bean：Bean实例开始执行业务逻辑。
销毁：当Bean的生命周期结束时，Spring容器会调用Bean的销毁方法，如destroy-method属性定义的方法。

生命周期示例

<bean id="helloWorld" class="com.example.demo.HelloWorld" init-method="init" destroy-method="destroy" scope="singleton">
    <property name="message" value="Hello World"/>
</bean>

package com.example.demo;

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

public class HelloWorld implements InitializingBean, DisposableBean {
    private String message;

    public HelloWorld() {
        this.message = "Hello World";
    }

    public void init() throws Exception {
        System.out.println("Initializing...");
    }

    public void destroy() throws Exception {
        System.out.println("Destroying...");
    }

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

Spring常用功能详解

AOP（面向切面编程）

AOP允许开发者定义一些通用的行为，如日志记录、事务管理等，这些行为可以横切地应用到多个类中，而无需修改这些类的源代码。

AOP代理：Spring通过两种方式来实现AOP代理：JDK动态代理和CGLIB代理。
切面：切面定义了横切关注点的实现，如日志记录、事务管理等。
通知：通知定义了何时以及如何执行横切关注点的行为。
切入点：切入点定义了横切关注点应用到哪些方法或类上。

示例代码

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

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

package com.example.demo;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.After;

@Aspect
public class LoggingAspect {
    @Before("execution(* com.example.demo.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Log before: " + joinPoint.getSignature().getName());
    }

    @After("execution(* com.example.demo.*.*(..))")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("Log after: " + joinPoint.getSignature().getName());
    }
}

常用注解的应用

Spring提供了多种注解来简化配置和开发，常用的注解包括@Component、@Service、@Repository、@Controller、@Autowired等。

@Component：用于标记任何Spring组件。
@Service：用于标记业务逻辑组件。
@Repository：用于标记数据访问组件。
@Controller：用于标记控制器组件。
@Autowired：用于自动装配依赖。

示例代码

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Controller;

@Component
public class HelloWorld {
    private String message;

    @Autowired
    public HelloWorld() {
        this.message = "Hello World";
    }

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

@Service
public class BusinessService {
    private HelloWorld helloWorld;

    @Autowired
    public BusinessService(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void performBusinessLogic() {
        helloWorld.getMessage();
    }
}

@Repository
public class DataService {
    public void fetchData() {
        System.out.println("Fetching data...");
    }
}

@Controller
public class WebController {
    private BusinessService businessService;

    @Autowired
    public WebController(BusinessService businessService) {
        this.businessService = businessService;
    }

    public void handleRequest() {
        businessService.performBusinessLogic();
    }
}

配置文件与注解配置

Spring支持通过XML配置文件和注解来配置Bean及其依赖关系。

XML配置：通过XML配置文件来定义Bean及其属性。
注解配置：通过Java注解来定义Bean及其属性。

示例代码

<bean id="helloWorld" class="com.example.demo.HelloWorld" scope="singleton">
    <property name="message" value="Hello World"/>
</bean>

package com.example.demo;

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("Your Message : " + message);
    }
}

Spring与数据库操作

数据库连接配置

为了使用Spring框架进行数据库操作，需要对数据库配置进行设置。

添加数据库驱动依赖：在pom.xml文件中添加数据库驱动的依赖。

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.26</version>
</dependency>

创建数据源配置：在Spring配置文件中定义数据源配置。

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="root"/>
    <property name="password" value="password"/>
</bean>

创建JdbcTemplate：使用JdbcTemplate来执行SQL查询。

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
</bean>

实现简单的数据库操作

创建DAO类：定义一个DAO类来封装数据库操作。

package com.example.demo;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.util.List;

public class UserDao {
    private JdbcTemplate jdbcTemplate;

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

    public List<User> getAllUsers() {
        String sql = "SELECT * FROM users";
        return jdbcTemplate.query(sql, new RowMapper<User>() {
            @Override
            public User mapRow(ResultSet rs, int rowNum) throws SQLException {
                User user = new User();
                user.setId(rs.getInt("id"));
                user.setName(rs.getString("name"));
                user.setEmail(rs.getString("email"));
                return user;
            }
        });
    }

    public void addUser(User user) {
        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
        jdbcTemplate.update(sql, user.getName(), user.getEmail());
    }

    public void updateUser(User user) {
        String sql = "UPDATE users SET name = ?, email = ? WHERE id = ?";
        jdbcTemplate.update(sql, user.getName(), user.getEmail(), user.getId());
    }

    public void deleteUser(int id) {
        String sql = "DELETE FROM users WHERE id = ?";
        jdbcTemplate.update(sql, id);
    }
}

测试DAO类：编写测试代码来验证DAO类的实现。

package com.example.demo;

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

import java.util.List;

public class UserDaoTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean(UserDao.class);

        userDao.addUser(new User(1, "John Doe", "john.doe@example.com"));
        userDao.addUser(new User(2, "Jane Doe", "jane.doe@example.com"));

        List<User> users = userDao.getAllUsers();
        for (User user : users) {
            System.out.println(user);
        }

        userDao.updateUser(new User(1, "John Smith", "john.smith@example.com"));
        userDao.deleteUser(2);
    }
}

事务管理

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

编程式事务

编程式事务管理是通过编码方式来显式地控制事务的边界。这种方式需要在代码中显式地编写事务开始、提交和回滚的逻辑。

package com.example.demo;

import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.support.JdbcTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionStatus;

public class TransactionManagerExample {
    private DataSourceTransactionManager transactionManager;

    public void performTransaction() {
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionStatus(true));
        try {
            // 执行数据库操作
            transactionManager.commit(status);
        } catch (Exception e) {
            transactionManager.rollback(status);
            throw e;
        }
    }
}

声明式事务

声明式事务管理是通过配置文件或注解的方式来声明事务属性，而无需在代码中显式地编写事务处理逻辑。

配置文件：在Spring配置文件中配置事务管理器和事务属性。

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<tx:annotation-driven transaction-manager="transactionManager"/>

注解：使用@Transactional注解来声明事务属性。

package com.example.demo;

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

public class UserService {
    private JdbcTemplate jdbcTemplate;

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

    @Transactional
    public void addUser(User user) {
        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
        jdbcTemplate.update(sql, user.getName(), user.getEmail());
    }
}

实战案例

编写一个简单的Spring应用程序

创建项目：创建一个新的Spring项目。
定义Bean：在Spring配置文件中定义Bean及其依赖关系。
编写业务逻辑：编写业务逻辑代码，使用Spring框架提供的功能。

示例代码

<?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/bsn/spring-beans.xsd">

    <bean id="helloWorld" class="com.example.demo.HelloWorld">
        <property name="message" value="Hello World"/>
    </bean>
</beans>

package com.example.demo;

public class HelloWorld {
    private String message;

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

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

package com.example.demo;

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

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

测试和部署应用程序

编写单元测试：使用JUnit等测试框架编写单元测试来验证业务逻辑的正确性。

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class HelloWorldTest {
    @Test
    public void testHelloWorld() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
        obj.getMessage();

        assertEquals("Hello World", obj.message);
    }
}

部署应用程序：将应用程序部署到应用服务器或云平台，如Tomcat或Spring Boot。

解决常见问题

Bean定义问题：确保所有Bean都正确定义并配置了依赖关系。
依赖注入问题：确保依赖对象正确注入到需要使用它们的类中。
事务管理问题：确保事务管理器和事务属性配置正确。

示例代码

<bean id="helloWorld" class="com.example.demo.HelloWorld">
    <property name="message" value="Hello World"/>
</bean>

<bean id="businessService" class="com.example.demo.BusinessService">
    <property name="helloWorld" ref="helloWorld"/>
</bean>

package com.example.demo;

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

@Component
public class BusinessService {
    private HelloWorld helloWorld;

    @Autowired
    public BusinessService(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void performBusinessLogic() {
        helloWorld.getMessage();
    }
}

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

呼啦一阵风

手记
篇

粉丝

73

获赞与收藏

319

关注作者，订阅最新文章

阅读免费教程

Spring Cloud Hystrix

15个小节 6139 120

Spring Security

28个小节 16550 264

Spring MVC 入门教程

24个小节 23407 325

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Spring入门：新手必备教程

Spring框架的基本概念

Spring框架的核心思想

Spring框架的版本和下载

开发环境要求

创建第一个Spring项目

配置项目环境

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

依赖注入示例

Bean的定义和作用域

Bean的定义

示例代码

Bean的作用域

Bean的生命周期

生命周期示例

Spring常用功能详解

AOP（面向切面编程）

示例代码

常用注解的应用

示例代码

配置文件与注解配置

示例代码

数据库连接配置

实现简单的数据库操作

事务管理

编程式事务

声明式事务

编写一个简单的Spring应用程序

示例代码

测试和部署应用程序

解决常见问题

示例代码

阅读免费教程