刘玉杰个人博客

1. 引言

Spring框架简介

Spring框架是一个功能强大且灵活的开源框架，旨在简化企业级Java开发。它的核心功能是通过依赖注入（Dependency Injection）和面向切面编程（Aspect-Oriented Programming）来实现松耦合、模块化和可测试的代码。

Spring的历史和发展

Spring由Rod Johnson在2002年首次发布，旨在替代复杂的企业JavaBean（EJB）。从Spring 1.x到现在的Spring 5.x，Spring框架不断发展，增加了许多强大的功能，如Spring Boot、Spring Cloud等。

Spring的核心理念和设计原则

Spring的设计原则包括模块化、松耦合、测试驱动开发（TDD）和依赖注入。Spring通过提供一系列便捷的功能和工具，帮助开发者构建健壮、可维护和可扩展的企业级应用程序。

2. Spring核心组件

Spring IoC（控制反转）

控制反转（Inversion of Control，IoC）是Spring的核心概念之一，它通过依赖注入（DI）实现。在Spring中，IoC容器负责创建和管理Bean的生命周期，自动注入它们之间的依赖关系。

Bean和BeanFactory

public class HelloWorld {
    private String message;

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

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

配置文件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 Spring!"/>
    </bean>

</beans>

主程序：

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();
    }
}

ApplicationContext

ApplicationContext是BeanFactory的一个子接口，提供了更多的企业级功能，如国际化支持、事件传播和AOP集成。以下是一个简单的示例：

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();
    }
}

Bean的生命周期

Bean的生命周期包括实例化、属性设置、初始化和销毁。Spring提供了多种方式来管理Bean的生命周期，包括@PostConstruct和@PreDestroy注解、自定义初始化和销毁方法以及BeanPostProcessor接口。

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class HelloWorld {
    private String message;

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

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

    @PostConstruct
    public void init(){
        System.out.println("Bean is going through init.");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("Bean will destroy now.");
    }
}

3. Spring中的数据访问

Spring JDBC

Spring JDBC模块简化了原始JDBC的使用，提供了模板类JdbcTemplate来减少样板代码，并提供异常处理机制。

import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;

public class StudentJDBCTemplate implements StudentDAO {
    private DataSource dataSource;
    private JdbcTemplate jdbcTemplateObject;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
        this.jdbcTemplateObject = new JdbcTemplate(dataSource);
    }

    public void create(String name, Integer age) {
        String SQL = "insert into Student (name, age) values (?, ?)";
        jdbcTemplateObject.update(SQL, name, age);
        System.out.println("Created Record Name = " + name + " Age = " + age);
    }
}

Spring ORM（对象关系映射）

Spring ORM模块支持与多种ORM框架集成，如Hibernate、JPA。Spring为这些框架提供了模板类和事务管理，简化了ORM的使用。

使用JPA

实体类：

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Student {
    @Id
    private int id;
    private String name;
    private int age;

    // getters and setters
}

DAO类：

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.transaction.Transactional;
import java.util.List;

public class StudentDAO {
    @PersistenceContext
    private EntityManager entityManager;

    @Transactional
    public void save(Student student) {
        entityManager.persist(student);
    }

    public List<Student> findAll() {
        return entityManager.createQuery("from Student").getResultList();
    }
}

配置文件persistence.xml：

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence" version="2.1">
    <persistence-unit name="myJpaUnit">
        <class>com.example.Student</class>
    </persistence-unit>
</persistence>

Spring Data

Spring Data项目旨在简化数据访问层的开发，包括支持JPA、MongoDB、Redis等数据存储。Spring Data JPA是一个流行的子项目，提供了JPA Repository接口，简化了JPA的使用。

使用Spring Data JPA

实体类：

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Student {
    @Id
    private int id;
    private String name;
    private int age;

    // getters and setters
}

Repository接口：

import org.springframework.data.repository.CrudRepository;

public interface StudentRepository extends CrudRepository<Student, Integer> {
}

服务类：

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

@Service
public class StudentService {
    @Autowired
    private StudentRepository studentRepository;

    public void saveStudent(Student student) {
        studentRepository.save(student);
    }

    public Iterable<Student> getAllStudents() {
        return studentRepository.findAll();
    }
}

配置类：

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

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

4. Spring中的事务管理

声明式事务管理

Spring通过@Transactional注解支持声明式事务管理，允许我们在不修改业务逻辑代码的情况下管理事务。

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

@Service
public class StudentService {
    @Autowired
    private StudentRepository studentRepository;

    @Transactional
    public void saveStudent(Student student) {
        studentRepository.save(student);
    }
}

编程式事务管理

编程式事务管理允许我们在代码中显式地控制事务的开始、提交和回滚，通常在需要细粒度控制的场景中使用。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

public class StudentService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private DataSourceTransactionManager transactionManager;

    public void saveStudent(String name, int age) {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(def);

        try {
            String SQL = "insert into Student (name, age) values (?, ?)";
            jdbcTemplate.update(SQL, name, age);
            transactionManager.commit(status);
        } catch (Exception e) {
            transactionManager.rollback(status);
            throw e;
        }
    }
}

事务传播行为和隔离级别

Spring支持多种事务传播行为（如REQUIRED、REQUIRES_NEW）和隔离级别（如READ_COMMITTED、SERIALIZABLE），我们可以根据实际需求进行配置。

import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class StudentService {
    @Autowired
    private StudentRepository studentRepository;

    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED)
    public void saveStudent(Student student) {
        studentRepository.save(student);
    }
}

5. Spring MVC

MVC模式简介

MVC（Model-View-Controller）模式是一种常用的设计模式，用于分离应用的表示层、控制逻辑和数据模型。Spring MVC是Spring框架的一部分，提供了强大的Web应用开发支持。

Spring MVC的架构和工作原理

Spring MVC的核心组件包括DispatcherServlet、Controller、ModelAndView和ViewResolver。DispatcherServlet是前端控制器，负责将请求分发到相应的控制器。

控制器、视图和模型

控制器负责处理用户请求并返回模型数据，视图负责将模型数据呈现给用户。Spring MVC支持多种视图技术，如JSP、Thymeleaf和FreeMarker。

控制器示例：

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
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 sayHello(Model model) {
        model.addAttribute("message", "Hello, Spring MVC!");
        return "hello";
    }
}

视图（hello.jsp）：

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<body>
    <h2>${message}</h2>
</body>
</html>

表单处理和数据绑定

Spring MVC提供了丰富的表单处理和数据绑定功能，支持表单验证、数据格式化和类型转换。

表单处理示例：

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class StudentController {

    @RequestMapping(value = "/student", method = RequestMethod.GET)
    public String studentForm(Model model) {
        model.addAttribute("student", new Student());
        return "studentForm";
    }

    @RequestMapping(value = "/student", method = RequestMethod.POST)
    public String studentSubmit(@ModelAttribute Student student, Model model) {
        model.addAttribute("student", student);
        return "studentResult";
    }
}

表单视图（studentForm.jsp）：

<%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<html>
<body>
    <h2>Student Form</h2>
    <form:form method="post" action="/student" modelAttribute="student">
        Name: <form:input path="name" /><br/>
        Age: <form:input path="age" /><br/>
        <input type="submit" value="Submit"/>
    </form:form>
</body>
</html>

拦截器和过滤器

Spring MVC支持拦截器和过滤器，用于在请求处理的各个阶段执行额外的逻辑，如权限检查、日志记录和请求预处理。

拦截器示例：

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LoggingInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        System.out.println("Before handling the request");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        System.out.println("After handling the request");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        System.out.println("After completing the request");
    }
}

配置拦截器：

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoggingInterceptor());
    }
}

6. Spring Boot

Spring Boot简介

Spring Boot是Spring生态系统中的一部分，旨在简化Spring应用的创建、配置和部署。它通过自动配置、嵌入式服务器和简化的依赖管理，使得Spring应用开发更加高效。

Spring Boot的自动配置

Spring Boot的自动配置功能基于约定优于配置的原则，自动配置常见的Spring组件和第三方库，减少了繁琐的手动配置。

创建Spring Boot应用程序

使用Spring Initializr创建Spring Boot项目：

curl https://start.spring.io/starter.zip \
    -d dependencies=web \
    -d name=myapp \
    -d packageName=com.example.myapp \
    -o myapp.zip
unzip myapp.zip -d myapp
cd myapp
./mvnw spring-boot:run

主程序：

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

@SpringBootApplication
public class MyAppApplication {

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

Spring Boot中的配置管理

Spring Boot支持多种配置方式，如application.properties、application.yml和外部配置文件。它还提供了丰富的配置属性和Profile机制，支持多环境配置管理。

application.properties示例：

server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

Spring Boot中的测试

Spring Boot为测试提供了多种工具和注解，如@SpringBootTest、@WebMvcTest和@DataJpaTest，简化了Spring应用的单元测试和集成测试。

测试示例：

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class MyAppApplicationTests {

    @Test
    void contextLoads() {
    }
}

7. Spring Security

Spring Security简介

Spring Security是一个强大的安全框架，提供了全面的身份验证和授权支持，保护应用免受常见的安全威胁。

身份验证和授权

Spring Security支持多种身份验证方式，如表单登录、HTTP Basic和OAuth2。它还提供了细粒度的授权机制，基于角色和权限控制用户访问。

配置示例：

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.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }

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

使用Spring Security保护Web应用程序

Spring Security可以与Spring MVC无缝集成，通过配置文件或注解方式保护Web应用程序。常见的配置包括访问控制、会话管理和跨站请求伪造（CSRF）防护。

常见的安全需求和解决方案

Spring Security提供了许多常见的安全功能，如密码加密、记住我功能、双因素认证和LDAP集成，帮助开发者应对各种安全需求。

8. Spring Cloud

Spring Cloud简介

Spring Cloud是一组工具集，帮助开发者构建分布式系统和微服务架构。它基于Spring Boot，提供了微服务的配置管理、服务发现、负载均衡、熔断和API网关等功能。

微服务架构与Spring Cloud

微服务架构是一种将应用拆分为多个独立服务的架构模式，每个服务负责特定的功能。Spring Cloud提供了丰富的工具，简化了微服务的开发和运维。

Spring Cloud的核心组件

Eureka：服务注册与发现
Ribbon：客户端负载均衡
Feign：声明式HTTP客户端
Hystrix：熔断器，提供故障隔离和降级功能
Zuul：API网关，提供路由和过滤功能

Spring Cloud Stream与消息驱动架构

Spring Cloud Stream是一个用于构建消息驱动微服务的框架，它基于Spring Boot和Spring Integration，提供了一致的编程模型和消息中间件的抽象。通过使用Spring Cloud Stream，我们可以轻松地集成Apache Kafka、RabbitMQ等消息代理，实现分布式系统的异步通信和事件驱动架构。

9. 高级主题

Spring中的事件处理

Spring提供了事件发布和监听机制，通过ApplicationEvent和ApplicationListener接口，我们可以在应用程序中发布和处理自定义事件。

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

public class CustomEvent extends ApplicationEvent {
    public CustomEvent(Object source) {
        super(source);
    }
}

@Component
public class CustomEventListener implements ApplicationListener<CustomEvent> {
    @Override
    public void onApplicationEvent(CustomEvent event) {
        System.out.println("Received custom event - " + event.getSource());
    }
}

Spring中的定时任务调度

Spring支持定时任务调度，可以通过@Scheduled注解或SchedulingConfigurer接口配置定时任务，支持固定速率、固定延迟和Cron表达式。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {

    @Scheduled(fixedRate = 5000)
    public void reportCurrentTime() {
        System.out.println("The time is now " + System.currentTimeMillis());
    }
}

Spring与其他技术的集成

与Apache Kafka集成：通过Spring Kafka实现与Kafka的集成，支持消息生产和消费、消息转换和批量处理。
与RabbitMQ集成：通过Spring AMQP实现与RabbitMQ的集成，支持消息队列、发布/订阅和RPC模式。

Spring Kafka示例：

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class KafkaProducerConsumer {

    private final KafkaTemplate<String, String> kafkaTemplate;

    public KafkaProducerConsumer(KafkaTemplate<String, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    public void sendMessage(String message) {
        kafkaTemplate.send("myTopic", message);
    }

    @KafkaListener(topics = "myTopic", groupId = "myGroup")
    public void listen(String message) {
        System.out.println("Received Message: " + message);
    }
}

10. 实战案例

基于Spring Boot的电商系统开发

系统架构设计
用户管理模块
商品管理模块
订单管理模块
支付和结算模块
安全和权限管理

使用Spring Cloud构建微服务架构

微服务拆分和设计
服务注册与发现（Eureka）
负载均衡和服务调用（Ribbon和Feign）
熔断和降级（Hystrix）
API网关（Zuul）
配置管理（Spring Cloud Config）

集成Spring Security进行权限管理

用户身份认证和授权
角色和权限管理
安全配置和自定义扩展
安全事件和日志记录

11. 总结

复习核心概念

回顾Spring框架的核心组件和功能，总结常见的开发实践和技巧。

展望Spring的未来发展方向

展望Spring框架的发展趋势和新特性，如Spring 6.x、Spring Native和Spring GraphQL。

参考资料和学习资源

提供推荐的书籍、在线课程、官方文档和社区资源，帮助读者进一步学习和深入理解Spring框架。

如果觉得文章对你有用，请随意赞赏

技术相关

Spring框架：从入门到精通

https://www.qiu-feng.cn/archives/Spring%E6%A1%86%E6%9E%B6%EF%BC%9A%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E7%B2%BE%E9%80%9A

作者

秋枫

发布于

2021-06-01

更新于

2024-06-25

许可协议

CC BY 4.0