欢迎访问java框架spring入门官网:www.xservx.com

java框架spring入门

一、Spring框架全景概览

作为Java企业级应用开发的核心基石,Spring框架自2003年诞生以来,已从轻量级容器演变为涵盖全技术栈的企业级开发平台。其核心理念——轻量级、非侵入式、面向切面与依赖注入——彻底改变了Java开发范式,使开发者从繁琐的XML配置与硬编码耦合中解放出来。

Spring家族体系庞大而统一,主要包括:

  • Spring Framework:基础容器与核心功能模块,提供IoC容器、AOP支持、事务管理等
  • Spring Boot:约定优于配置的快速开发框架,内嵌Tomcat/Jetty等容器
  • Spring Cloud:分布式系统开发的一站式解决方案,整合服务发现、配置管理、熔断器等
  • Spring Data:统一数据访问API,支持关系型/非关系型数据库及缓存
  • Spring Security:企业级安全认证与授权框架
  • Spring Batch:批处理任务调度框架
  • Spring Integration:企业集成模式实现框架

截至2025年,Spring Framework最新稳定版为6.1.x,全面支持Java 17+并深度适配JDK 21的新特性;Spring Boot最新稳定版为3.2.x,基于Jakarta EE 10规范重构命名空间(从javax.*迁移至jakarta.*),并强化了对云原生特性的支持。

⚡ 提示:Spring 5.3起采用双版本策略——5.3.x支持Java 8+(LTS维护至2024年底),6.x要求Java 17+(LTS维护至2026年底)。新项目建议直接采用Spring 6.x。

二、Spring核心容器架构深度解析

2.1 核心容器分层模型

Spring核心容器采用分层架构设计,各模块职责清晰、低耦合:

2002年

Spring雏形诞生于Rod Johnson的《Expert One-on-One J2EE Design and Development》一书中的接口层实现,早期仅包含IoC容器雏形

2004年

Spring 1.0发布,确立以IoC容器为核心的轻量级架构,引入ApplicationContext接口体系

2006年

Spring 2.0引入Schema-based配置,支持XML命名空间扩展,奠定模块化架构基础

2013年

Spring 4.0全面支持Java 8及lambda表达式,引入Reactive编程模型雏形

2022年

Spring 6.0基于JDK 17+重构,全面拥抱Jakarta EE 9+,移除已废弃API,增强响应式编程支持

2.2 核心组件详解

IoC容器是Spring框架的基石,其核心接口体系如下:

  • BeanFactory:最基础的IoC容器接口,提供基本的Bean管理功能(延迟初始化)
  • ApplicationContext:BeanFactory的子接口,扩展了企业级功能:
    • EnvironmentCapable:环境抽象支持
    • MessageSource:国际化消息支持
    • ApplicationEventPublisher:事件发布/订阅机制
    • ResourceLoader:统一资源加载机制
  • ConfigurableApplicationContext:可配置的ApplicationContext,支持动态刷新

容器初始化流程:

1. 创建BeanFactory实例(默认DefaultListableBeanFactory)
2. 解析配置元数据(XML/注解/Java Config)
3. 注册BeanDefinition到BeanFactory
4. 实例化非懒加载单例Bean
5. 执行BeanPostProcessor后置处理
6. 发布ContextRefreshedEvent事件

应用上下文扩展了基础容器的功能,主要类型包括:

⚙️ 实际开发中,Web项目通常使用AnnotationConfigWebApplicationContext,非Web项目可选用AnnotationConfigApplicationContext或ClassPathXmlApplicationContext
类型适用场景配置方式特点
ClassPathXmlApplicationContext传统XML配置项目类路径下XML文件资源加载快,适合配置固定场景
FileSystemXmlApplicationContext文件系统配置绝对路径XML文件灵活性高,需注意路径安全
AnnotationConfigApplicationContext纯注解项目@Configuration类现代项目主流选择,类型安全
WebApplicationContextWeb应用web.xml/ServletContainerInitializer集成Servlet容器,提供request/session作用域

Bean定义是容器管理对象的元数据描述,支持多种配置方式:

<!-- XML配置方式 -->
<bean id="userService" class="com.example.service.UserService" scope="prototype">
    <property name="userRepository" ref="userRepository"/>
</bean>
<!-- 注解方式 -->
@Service
public class UserService {
    private final UserRepository userRepository;
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}
<!-- Java配置方式 -->
@Configuration
public class AppConfig {
    @Bean
    public UserService userService(UserRepository userRepository) {
        return new UserService(userRepository);
    }
}

Bean作用域说明:

  • singleton(默认):单例模式,容器启动时创建实例(非懒加载)
  • prototype:多例模式,每次请求创建新实例
  • request:每个HTTP请求创建新实例(Web环境)
  • session:每个HTTP会话创建新实例(Web环境)
  • application:整个Web应用生命周期单例(Web环境)
  • websocket:WebSocket会话作用域(Web环境)

三、IoC容器深度机制剖析

3.1 依赖注入方式对比

Spring支持三种依赖注入方式,各有适用场景:

构造器注入是Spring官方推荐方式,具有不可变性与强制依赖校验优势:

@Service
public class OrderService {
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    public OrderService(PaymentService paymentService,
                       InventoryService inventoryService) {
        this.paymentService = paymentService;
        this.inventoryService = inventoryService;
    }
}

优势:

  • 依赖不可变(final字段)
  • 强制依赖在构造时校验
  • 便于单元测试(可直接传入Mock对象)
  • 避免循环依赖问题

Setter注入适用于可选依赖或需要动态调整的场景:

@Service
public class ReportService {
    private EmailService emailService;
    private StorageService storageService;
    @Autowired
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
    @Autowired
    public void setStorageService(StorageService storageService) {
        this.storageService = storageService;
    }
}

适用场景:

  • 可选依赖(允许为null)
  • 需要运行时重新配置
  • 与第三方库集成(无构造器)

字段注入虽简洁但存在严重缺陷,不推荐在生产环境使用:

@Service
public class AuthService {
    @Autowired
    private TokenService tokenService;
}

主要问题:

  • 破坏封装性(字段可被反射修改)
  • 难以测试(无法通过构造器注入Mock)
  • 循环依赖风险高
  • 违反依赖倒置原则

3.2 循环依赖解决方案

Spring通过三级缓存机制解决单例Bean的循环依赖问题:

三级缓存结构:
singletonObjects:存放完全初始化的单例Bean(一级缓存)
earlySingletonObjects:存放早期暴露的Bean(二级缓存)
singletonFactories:存放ObjectFactory(三级缓存)
循环依赖流程:
1. 创建Bean A → 提前暴露ObjectFactory
2. 依赖注入Bean B → 创建Bean B
3. Bean B依赖Bean A → 从三级缓存获取ObjectFactory
4. 调用ObjectFactory.getObject() → 生成早期Bean引用
5. 完成A与B的初始化
⚠️ 注意:构造器注入无法解决循环依赖,仅支持setter注入的循环依赖;多例Bean不支持循环依赖

四、AOP编程范式实战

4.1 AOP核心概念

面向切面编程(AOP)通过动态代理实现横切关注点的模块化,核心概念包括:

通知类型定义切面逻辑的执行时机:

类型注解执行时机典型应用
前置通知@Before目标方法执行前参数校验、日志记录
后置通知@After目标方法执行后(无论异常)资源释放、清理操作
返回通知@AfterReturning目标方法成功返回后结果包装、性能统计
异常通知@AfterThrowing目标方法抛出异常后异常记录、降级处理
环绕通知@Around完全控制方法执行过程缓存、重试机制、安全校验

切入点表达式定义切面作用范围,Spring支持AspectJ语法:

execution(* com.example.service.*.*(..))
→ 匹配service包下所有类的所有方法
execution(* com.example.service..*.*(..))
→ 匹配service包及子包下所有方法
execution(* save*(..))
→ 匹配所有以save开头的方法
@annotation(com.example.annotation.Loggable)
→ 匹配带指定注解的方法
within(com.example.service.UserService)
→ 限定特定类的所有方法

组合通知通过逻辑运算符组合多个切入点:

@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceLayer() {}
@Pointcut("execution(* com.example.repository.*.*(..))")
public void repositoryLayer() {}
@Pointcut("serviceLayer() && repositoryLayer()")
public void serviceAndRepository() {}
@Pointcut("serviceLayer() || repositoryLayer()")
public void serviceOrRepository() {}
@Pointcut("!(serviceLayer() || repositoryLayer())")
public void outsideLayers() {}

4.2 实战案例:操作日志记录

以下实现完整操作日志记录,包含用户信息、请求参数、执行耗时等关键数据
@Aspect
@Component
public class OperationLogAspect {
    @Autowired
    private LogRepository logRepository;
    @Around("@annotation(com.example.annotation.OperationLog)")
    public Object logOperation(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        // 获取方法信息
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        OperationLog annotation = method.getAnnotation(OperationLog.class);
        // 获取请求参数
        Object[] args = joinPoint.getArgs();
        String params = Arrays.stream(args)
            .map(arg -> arg instanceof HttpServletRequest ?
                "[HTTP请求对象]" : JSON.toJSONString(arg))
            .collect(Collectors.joining(", "));
        // 执行目标方法
        Object result = joinPoint.proceed();
        // 计算耗时
        long duration = System.currentTimeMillis() - startTime;
        // 构建日志对象
        OperationLogEntity log = new OperationLogEntity();
        log.setModule(annotation.module());
        log.setAction(annotation.action());
        log.setParams(params);
        log.setDuration(duration);
        log.setOperator(getCurrentOperator());
        log.setIpAddress(getClientIpAddress());
        // 异步保存日志
        logRepository.saveAsync(log);
        return result;
    }
    private String getCurrentOperator() {
        // 从SecurityContext获取当前用户
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        return auth != null ? auth.getName() : "anonymous";
    }
}

使用方式:

@OperationLog(module = "订单管理", action = "创建订单")
@PostMapping("/orders")
public ResponseEntity<OrderDTO> createOrder(@RequestBody OrderCreateRequest request) {
    // 业务逻辑
    return ResponseEntity.ok(orderService.createOrder(request));
}

五、Spring MVC深度解析

5.1 请求处理流程详解

Spring MVC基于前端控制器模式实现,完整请求处理流程如下:

1. 请求到达

DispatcherServlet接收HTTP请求

2. 解析映射

HandlerMapping根据URL查找Handler(Controller方法)

3. 参数绑定

HandlerAdapter执行参数解析、类型转换、数据校验

4. 拦截器执行

执行preHandle拦截器(按注册顺序)

5. 方法调用

执行Controller方法,处理业务逻辑

6. 视图渲染

ViewResolver解析视图名称,渲染模板

7. 后置处理

执行postHandle拦截器(按逆序)

8. 完成回调

执行afterCompletion拦截器(按逆序)

5.2 参数绑定机制

请求参数绑定支持多种来源:

@GetMapping("/users")
public List<User> searchUsers(
    @RequestParam String keyword,    // ?keyword=张三
    @RequestParam(defaultValue = "10") int size,  // ?size=20
    @RequestParam(required = false) String sort,  // 可选参数
    @RequestHeader("User-Agent") String agent,    // 请求头
    @CookieValue("JSESSIONID") String sessionId   // Cookie值
) { ... }

参数校验示例:

public class UserQuery {
    @NotBlank(message = "关键词不能为空")
    private String keyword;
    @Min(value = 1, message = "页码不能小于1")
    @Max(value = 100, message = "页码不能超过100")
    private int page;
    // getter/setter...
}

请求体参数绑定用于JSON/XML数据:

@PostMapping("/users")
public User createUser(@Valid @RequestBody UserCreateRequest request) {
    // @Valid触发JSR-303校验
    // @RequestBody使用HttpMessageConverter解析JSON
    return userService.createUser(request);
}

常见HttpMessageConverter:

  • MappingJackson2HttpMessageConverter:JSON处理(Jackson)
  • MappingJackson2XmlHttpMessageConverter:XML处理(Jackson XML)
  • StringHttpMessageConverter:字符串处理
  • FormHttpMessageConverter:表单数据处理

路径参数绑定用于RESTful风格URL:

@GetMapping("/users/{id}")
public User getUser(@PathVariable("id") Long userId) {
    return userService.getUser(userId);
}
@PatchMapping("/users/{id}/status")
public User updateStatus(
    @PathVariable Long id,
    @RequestParam Status status
) {
    return userService.updateStatus(id, status);
}

5.3 异常处理机制

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(BusinessException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public ErrorResponse handleBusinessException(BusinessException ex) {
        return new ErrorResponse(ex.getCode(), ex.getMessage());
    }
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseBody
    public Map<String, Object> handleValidationException(MethodArgumentNotValidException ex) {
        Map<String, Object> errors = new HashMap<>();
        ex.getBindingResult().getFieldErrors().forEach(error ->
            errors.put(error.getField(), error.getDefaultMessage())
        );
        return errors;
    }
    @ExceptionHandler(Exception.class)
    @ResponseBody
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ErrorResponse handleException(Exception ex) {
        // 记录日志
        log.error("系统异常", ex);
        return new ErrorResponse("500", "服务器内部错误");
    }
}

六、事务管理机制深度解析

6.1 事务传播行为详解

Spring支持7种事务传播行为,满足不同业务场景:

传播行为注解值行为描述典型场景
REQUIREDPropagation.REQUIRED有事务则加入,否则新建默认值,90%场景使用
REQUIRES_NEWPropagation.REQUIRES_NEW always 新建事务日志记录、独立事务操作
NESTEDPropagation.NESTED嵌套事务(Savepoint)部分失败回滚到保存点
SUPPORTSPropagation.SUPPORTS有事务则参与,否则非事务只读操作
NOT_SUPPORTEDPropagation.NOT_SUPPORTED挂起当前事务,非事务执行异步日志发送
NEVERPropagation.NEVER禁止事务执行强制非事务操作
MANDATORYPropagation.MANDATORY必须在事务中执行强制事务边界检查
⚠️ 注意:NESTED传播行为需要JDBC 3.0+ Savepoint支持,且底层必须使用DataSourceTransactionManager

6.2 事务隔离级别对比

@Transactional(isolation = Isolation.READ_COMMITTED)
public void processOrder(Order order) {
    // 避免脏读,但可能出现不可重复读
}

隔离级别说明:

级别问题性能影响适用场景
READ_UNCOMMITTED脏读/不可重复读/幻读最低几乎不使用
READ_COMMITTED不可重复读/幻读低默认值,大多数场景
REPEATABLE_READ幻读中MySQL默认,避免不可重复读
SERIALIZABLE无高强一致性要求场景

6.3 声明式事务最佳实践

@Configuration
@EnableTransactionManagement
public class TxConfig {
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
    @Bean
    public TransactionTemplate transactionTemplate(PlatformTransactionManager txManager) {
        TransactionTemplate template = new TransactionTemplate(txManager);
        template.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
        template.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
        return template;
    }
}
@Service
public class OrderService {
    @Autowired
    private TransactionTemplate txTemplate;
    public void createOrder(Order order) {
        txTemplate.execute(status -> {
            orderRepository.save(order);
            inventoryService.decreaseStock(order.getProductId(), order.getQuantity());
            return true;
        });
    }
}

事务注解使用禁忌:

  • 禁止在private方法上使用@Transactional
  • 避免在final方法上使用@Transactional
  • 同类中方法调用导致事务失效(需通过代理调用)
  • 异常被捕获导致事务未回滚(需手动rollback)

七、Spring Boot快速开发体系

7.1 自动配置原理深度剖析

Spring Boot通过自动配置机制实现“零配置”开发,核心流程如下:

1. 启动类

@SpringBootApplication触发自动配置扫描

2. 元数据加载

读取META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

3. 条件过滤

应用@Conditional注解组合条件

4. 配置类加载

加载符合条件的AutoConfiguration类

5. Bean注册

将自动配置的Bean注册到容器

// 核心注解组合
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
    @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)
})
public @interface SpringBootApplication { ... }

常用自动配置条件注解:

注解条件典型应用
@ConditionalOnClass类路径存在指定类仅当存在Redis类时配置RedisTemplate
@ConditionalOnMissingBean容器缺少指定Bean默认数据源配置
@ConditionalOnProperty配置项满足条件根据配置启用特性功能
@ConditionalOnWebApplicationWeb应用环境Web相关自动配置

7.2 外部化配置最佳实践

配置优先级(从高到低):
1. 命令行参数
2. 来自java:comp/env的JNDI属性
3. Java系统属性(System.getProperties())
4. 操作系统环境变量
5. jar包外部的application-{profile}.properties
6. jar包内部的application-{profile}.properties
7. @Configuration类上的@PropertySource

多环境配置示例:

# application-dev.yml
server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dev_db
    username: dev_user
# application-prod.yml
server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://prod-db:3306/prod_db
    username: prod_user

动态刷新配置(Spring Boot 2.2+):

@RestController
@RefreshScope
public class ConfigController {
    @Value("${app.version:1.0.0}")
    private String version;
    @GetMapping("/version")
    public String getVersion() {
        return version;
    }
}
⚙️ 实际部署中,需配合Spring Cloud Config或Nacos等配置中心实现配置热更新

八、微服务架构集成方案

8.1 服务通信机制

Spring Cloud提供两种服务通信模式:

REST+HTTP模式基于OpenFeign实现:

@FeignClient(name = "user-service", fallbackFactory = UserClientFallback.class)
public interface UserClient {
    @GetMapping("/users/{id}")
    User getUser(@PathVariable("id") Long id);
    @PostMapping("/users")
    User createUser(@RequestBody User user);
}

配置增强:

feign:
  client:
    config:
      default:
        connectTimeout: 5000
        readTimeout: 15000
  compression:
    request:
      enabled: true
    response:
      enabled: true

RPC模式基于gRPC或Dubbo实现:

// gRPC服务定义(.proto文件)
syntax = "proto3";
option java_package = "com.example.grpc";
service UserService {
  rpc GetUser(UserRequest) returns (UserResponse);
  rpc CreateUser(User) returns (User);
}

集成优势:

  • 高性能(二进制协议)
  • 强类型定义
  • 流式处理支持
  • 跨语言能力

8.2 服务治理核心组件

# Nacos配置中心集成
spring:
  cloud:
    nacos:
      config:
        server-addr: nacos-server:8848
        namespace: dev-namespace
        group: DEFAULT_GROUP
      discovery:
        server-addr: nacos-server:8848
        namespace: dev-namespace

熔断降级方案对比:

方案原理优势局限
Hystrix线程池隔离生态成熟已停止维护
Sentinel信号量隔离实时监控、动态规则中文文档完善
Resilience4j函数式编程轻量、响应式学习曲线陡峭
⚡ 推荐方案:新项目优先使用Resilience4j,已有Hystrix项目可平滑迁移到Sentinel

九、Spring测试体系实战

9.1 单元测试最佳实践

Spring Boot测试框架整合了JUnit 5、AssertJ、Mockito等工具:

@SpringBootTest
@AutoConfigureMockMvc
class OrderControllerTest {
    @Autowired
    private MockMvc mockMvc;
    @MockBean
    private OrderService orderService;
    @Test
    void testCreateOrder() throws Exception {
        // 准备测试数据
        OrderCreateRequest request = new OrderCreateRequest();
        request.setProductId(1L);
        request.setQuantity(2);
        // 模拟服务层行为
        when(orderService.createOrder(any()))
            .thenReturn(new Order(1L, 1L, 2));
        // 执行HTTP请求
        mockMvc.perform(post("/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(request)))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.id").value(1));
    }
}

9.2 集成测试策略

数据库测试使用Testcontainers实现真实环境:

@Testcontainers
@SpringBootTest
class UserRepositoryTest {
    @Container
    static PostgreSQLContainer<?> postgres =
        new PostgreSQLContainer<>("postgres:14-alpine")
            .withDatabaseName("testdb");
    @Autowired
    private UserRepository repository;
    @BeforeEach
    void setUp() {
        // 初始化测试数据
        repository.save(new User("test@example.com"));
    }
    @Test
    void testFindByEmail() {
        User user = repository.findByEmail("test@example.com");
        assertNotNull(user);
        assertEquals("test@example.com", user.getEmail());
    }
}

缓存测试验证缓存行为:

@ExtendWith(SpringExtension.class)
@SpringBootTest
@AutoConfigureCache
class CacheTest {
    @Autowired
    private CacheManager cacheManager;
    @Test
    void testCacheHit() {
        // 清空缓存
        cacheManager.getCache("users").clear();
        // 首次调用(未命中缓存)
        userService.getUser(1L);
        assertThat(cacheManager.getCache("users").get(1L)).isNull();
        // 第二次调用(命中缓存)
        userService.getUser(1L);
        assertThat(cacheManager.getCache("users").get(1L)).isNotNull();
    }
}

十、Spring开发最佳实践

10.1 性能优化要点

容器启动优化

使用@ComponentScan过滤无用组件,避免扫描整个应用包

Bean初始化优化

对非关键Bean使用lazy-init,减少启动时间

数据库访问优化

使用JdbcTemplate批量操作,避免N+1查询

HTTP响应优化

开启GZIP压缩,配置Connection: keep-alive

内存管理优化

避免@Scope("prototype")大对象,使用对象池

10.2 安全开发规范

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/actuator/**").hasRole("ACTUATOR")
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .defaultSuccessUrl("/dashboard")
            )
            .logout(logout -> logout
                .logoutUrl("/logout")
                .logoutSuccessUrl("/login?logout")
            );
        return http.build();
    }
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}
⚠️ 重要提醒:生产环境必须启用CSRF保护,禁用不安全的HTTP方法(TRACE/PUT/DELETE需显式授权)

10.3 日志规范建议

// 错误示例(性能差)
log.info("用户{}登录,参数:{}", user, JSON.toJSONString(params));
// 正确示例(条件日志)
if (log.isDebugEnabled()) {
    log.debug("用户{}登录,参数:{}", user, JSON.toJSONString(params));
}
// 错误示例(异常丢失堆栈)
log.error("处理失败", e.getMessage());
// 正确示例(完整异常信息)
log.error("处理失败,用户ID:{}", userId, e);
// 性能敏感场景
if (log.isTraceEnabled()) {
    long start = System.nanoTime();
    processOrder(order);
    log.trace("订单处理耗时:{} ns", System.nanoTime() - start);
}