嘿,朋友。还记得你第一次写出 “Hello, World!” 时的兴奋吗?那种看着代码跑起来、确认自己掌握了新技能的成就感,是编程路上最纯粹的快乐。但如果你只停留在那个阶段,就像刚学会走路就以为能跑马拉松一样,很快会撞上现实的墙。
Spring 框架的出现,彻底改变了 Java 开发的游戏规则。它不仅仅是一个工具包,更像是一套精心设计的”项目管理哲学”,帮你把原本混乱的代码整理得井井有条。今天,我们就一起揭开 Spring 的神秘面纱,从最基础的依赖注入聊起,一路走到企业级应用的核心。
入门:Spring 为什么如此流行?
先问自己一个问题:如果你自己管理对象,会是什么样子?想象一下,你写了一个用户注册功能,需要用到数据库连接、邮件发送、日志记录……如果没有 Spring,你可能需要手动创建这些对象,手动传递引用,手动管理生命周期。代码会变成什么样? spaghetti code(意大利面条式代码),到处是耦合,改一处崩全身。
Spring 的核心思想很简单:让框架来帮你管理对象。你只需要告诉 Spring “我需要这个对象”,它会负责创建、配置和连接这些对象。这种思想叫做控制反转(IoC),而具体实现 IoC 的方式叫依赖注入(DI)。
别被术语吓到。想象你在餐厅吃饭:你不需要自己种菜、做饭、洗碗,你只需要点菜,服务员(Spring)会把菜(对象)端到你面前。这就是依赖注入的直观理解。
依赖注入:Spring 的心脏
让我们看一个最基础的例子。假设你有一个 UserService 类,它需要一个 UserDao 来访问数据库:
// 传统方式:手动创建依赖
public class UserService {
private UserDao userDao;
public UserService() {
this.userDao = new UserDaoImpl(); // 硬编码,难以测试和替换
}
public void createUser(String name) {
userDao.insert(name);
}
}
这种写法的坏处很明显:如果你哪天想把 UserDaoImpl 换成另一个实现(比如为了测试或者性能优化),你得改 UserService 的代码。而且单元测试会变得很麻烦,因为每次都要创建真实的数据库连接。
现在看看 Spring 怎么解决:
// Spring 方式:通过构造器注入依赖
@Component
public class UserService {
private final UserDao userDao;
// Spring 会自动找到 UserDao 的实现并注入进来
@Autowired
public UserService(UserDao userDao) {
this.userDao = userDao;
}
public void createUser(String name) {
userDao.insert(name);
}
}
注意几个关键点:
@Component注解告诉 Spring:”我是一个能被管理的组件,请把我放进你的容器里”@Autowired告诉 Spring:”我需要这个类型的对象,请帮我找到并注入进来”- 使用构造器注入(而不是字段注入)是最佳实践,因为这样依赖关系更清晰,也方便测试
Spring 容器(ApplicationContext)就像一个大管家,管理着应用中所有的”豆子”(Bean)。它负责创建这些对象,处理它们之间的依赖关系,并在适当的时候销毁它们。
控制反转(IoC)容器:Spring 的大脑
要真正理解 Spring,你得理解 IoC 容器。容器是什么?简单来说,它就是管理对象生命周期和依赖关系的框架。
当你启动 Spring 应用时,会发生这几件事:
- Spring 扫描你指定的包,找到所有标注了
@Component、@Service、@Repository、@Controller的类 - 根据注解信息创建这些对象(Bean)
- 分析每个 Bean 的依赖,找到对应的 Bean 并注入
- 将所有创建好的 Bean 放入一个 Map 中,等待程序使用
你可以这样配置 Spring 告诉它去哪里扫描:
@Configuration
@ComponentScan(basePackages = "com.example.myapp")
public class AppConfig {
// 这里还可以定义额外的 Bean
}
或者用 XML 配置(老项目常见):
<beans>
<context:component-scan base-package="com.example.myapp" />
</beans>
但现代 Spring 开发几乎都用 Java Config,因为类型安全、可重构性强。
Bean 的作用域:对象的生命周期管理
Spring 创建的 Bean 有不同的”活法”,这叫作用域(Scope)。最常见的两种:
Singleton(单例):整个应用中只有一个实例。这是默认值,适合无状态的服务类。
@Service
public class OrderService {
// 整个应用只有一个 OrderService 实例
}
Prototype(原型):每次请求都创建新实例。适合有状态的组件。
@Scope("prototype")
@Component
public class GameCharacter {
private String name;
private int health;
// 每次注入都会得到新对象
}
还有其他作用域如 Request、Session、Application,主要在 Web 应用中使用。理解作用域很重要,因为不当使用 singleton 来处理有状态数据会导致线程安全问题。
Spring MVC:处理 Web 请求
当你的应用需要对外提供服务时,Spring MVC 派上用场了。它遵循经典的 MVC 模式,把请求处理分成三层:
@Controller
public class UserController {
@Autowired
private UserService userService;
// GET 请求:获取用户列表
@GetMapping("/users")
@ResponseBody
public List<User> getUsers() {
return userService.findAll();
}
// POST 请求:创建用户
@PostMapping("/users")
@ResponseBody
public User createUser(@RequestBody User user) {
return userService.create(user);
}
// GET 请求:获取单个用户
@GetMapping("/users/{id}")
@ResponseBody
public User getUser(@PathVariable Long id) {
return userService.findById(id);
}
}
这里每个注解都有明确职责:
@Controller:标识这是一个 Web 控制器@GetMapping/@PostMapping:映射 HTTP 方法@ResponseBody:告诉 Spring 直接返回对象(转为 JSON),而不是渲染视图@PathVariable:从 URL 路径中提取变量@RequestBody:把请求体(JSON)绑定到 Java 对象
对比传统的 Servlet 编程,Spring MVC 把 URL 映射、参数解析、请求分发这些繁琐工作都封装好了,你只需要关注业务逻辑。
Spring Boot:让开发更简单
说实话,原始 Spring 的配置太繁琐了。你需要配置 DispatcherServlet、HandlerMapping、ViewResolver 等等。Spring Boot 的出现解决了这个问题。
Spring Boot 的核心理念是”约定优于配置”。它默认帮你配置好了 90% 的东西,你只需要关注那 10% 的独特业务。
一个最简单的 Spring Boot 应用:
@SpringBootApplication
public class MyApp {
public static void main(String[] args) {
SpringApplication.run(MyApp.class, args);
}
}
就这三行!@SpringBootApplication 是一个组合注解,包含了:
@Configuration:启用配置类@EnableAutoConfiguration:自动配置 Spring@ComponentScan:扫描组件
然后你需要在 pom.xml 中添加依赖:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
spring-boot-starter-web 会帮你引入 Spring MVC、Tomcat 等所有 Web 开发需要的依赖。你不需要手动管理版本,Spring Boot 已经帮你协调好了。
启动应用后,你直接访问 http://localhost:8080 就能看到结果。不需要部署到外部 Tomcat,Spring Boot 内嵌了 Tomcat。
数据访问:Spring Data JPA
企业应用离不开数据库。Spring Data JPA 让数据访问变得极其简单:
// 定义实体
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String email;
// 构造器、getter、setter...
}
// 定义 Repository(不需要写实现!)
public interface UserRepository extends JpaRepository<User, Long> {
List<User> findByNameContaining(String name);
Optional<User> findByEmail(String email);
}
// 服务层
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
public List<User> searchUsers(String keyword) {
return userRepository.findByNameContaining(keyword);
}
public User createUser(String name, String email) {
User user = new User();
user.setName(name);
user.setEmail(email);
return userRepository.save(user);
}
}
看,你只需要定义接口,Spring Data 会自动生成实现。它基于 JPA 规范,底层可以用 Hibernate 作为实现。你常用的 CRUD 方法(save、findById、findAll、delete 等)都已经有了,不需要写一行 SQL。
当然,复杂查询还是需要写 SQL 的,Spring Data 支持 @Query 注解:
public interface UserRepository extends JpaRepository<User, Long> {
@Query("SELECT u FROM User u WHERE u.email LIKE %:domain%")
List<User> findByEmailDomain(@Param("domain") String domain);
}
配置文件也不需要很多,只需要告诉 Spring 数据库连接信息:
# application.yml
spring:
datasource:
url: jdbc:mysql://localhost:3306/mydb
username: root
password: secret
jpa:
hibernate:
ddl-auto: update
show-sql: true
事务管理:保证数据一致性
企业级应用必须处理事务。想象一下转账场景:从 A 账户扣钱,往 B 账户加钱。如果第二步失败了,第一步必须回滚。这就是事务的 ACID 特性。
Spring 让事务管理变得非常简单:
@Service
public class TransferService {
@Autowired
private AccountRepository accountRepository;
@Transactional // 声明式事务
public void transfer(Long fromId, Long toId, BigDecimal amount) {
Account from = accountRepository.findById(fromId)
.orElseThrow(() -> new IllegalArgumentException("账户不存在"));
Account to = accountRepository.findById(toId)
.orElseThrow(() -> new IllegalArgumentException("账户不存在"));
if (from.getBalance().compareTo(amount) < 0) {
throw new InsufficientBalanceException("余额不足");
}
from.setBalance(from.getBalance().subtract(amount));
to.setBalance(to.getBalance().add(amount));
accountRepository.save(from);
accountRepository.save(to);
// 如果任何地方抛出异常,整个方法会回滚
}
}
只需一个 @Transactional 注解,Spring 会在方法执行前开启事务,成功则提交,失败则回滚。你不需要手动写 beginTransaction()、commit()、rollback()。
更高级的用法可以指定传播行为、隔离级别、超时时间:
@Transactional(
propagation = Propagation.REQUIRED, // 必须有事务,没有则创建
isolation = Isolation.READ_COMMITTED, // 隔离级别
timeout = 30, // 30秒超时
rollbackFor = Exception.class // 所有异常都回滚
)
public void complexOperation() {
// ...
}
安全防护:Spring Security
没有安全的企业应用是不完整的。Spring Security 提供了完整的安全框架:
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Autowired
private UserService userService;
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests(auth -> auth
.requestMatchers("/api/public/**").permitAll() // 公开接口
.requestMatchers("/api/admin/**").hasRole("ADMIN") // 管理员接口
.anyRequest().authenticated() // 其他需要认证
)
.httpBasic(Customizer.withDefaults()) // 基础认证
.csrf(csrf -> csrf.disable()); // 禁用 CSRF(如果是纯 API 服务)
return http.build();
}
@Bean
public AuthenticationManager authenticationManager(
AuthenticationConfiguration config) throws Exception {
return config.getAuthenticationManager();
}
}
用户认证流程:
@Service
public class CustomUserDetailsService implements UserDetailsService {
@Autowired
private UserRepository userRepository;
@Autowired
private PasswordEncoder passwordEncoder;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
User user = userRepository.findByEmail(username)
.orElseThrow(() -> new UsernameNotFoundException("用户不存在"));
return new org.springframework.security.core.userdetails.User(
user.getEmail(),
user.getPassword(),
user.getRoles().stream()
.map(role -> new SimpleGrantedAuthority("ROLE_" + role))
.collect(Collectors.toList())
);
}
}
注意密码存储要用 BCrypt 加密,不要明文存储。Spring Security 内置了 BCryptPasswordEncoder。
测试:保证代码质量
企业级项目必须有测试。Spring 提供了强大的测试支持:
@SpringBootTest // 加载完整 Spring 上下文
@AutoConfigureMockMvc // 启用 MockMvc 测试 MVC
class UserControllerTest {
@Autowired
private MockMvc mockMvc;
@Autowired
private UserRepository userRepository;
@Autowired
private UserService userService;
@Test
void testCreateUser() throws Exception {
// 准备测试数据
User testUser = new User("Test User", "test@example.com");
// 执行请求并验证响应
mockMvc.perform(post("/api/users")
.contentType(MediaType.APPLICATION_JSON)
.content(objectToJson(testUser)))
.andExpect(status().isOk())
.andExpect(jsonPath("$.name").value("Test User"))
.andExpect(jsonPath("$.email").value("test@example.com"));
// 验证数据库确实保存了
Optional<User> saved = userRepository.findByEmail("test@example.com");
assertTrue(saved.isPresent());
}
@Test
@Transactional // 测试后自动回滚
void testGetUser() throws Exception {
// 准备数据,测试结束后自动回滚
User user = userService.create("Test User", "test2@example.com");
mockMvc.perform(get("/api/users/" + user.getId()))
.andExpect(status().isOk())
.andExpect(jsonPath("$.name").value("Test User"));
// 断言:数据库中没有这个用户(因为事务回滚了)
assertTrue(userRepository.findByEmail("test2@example.com").isEmpty());
}
}
单元测试可以 Mock 依赖:
class UserServiceTest {
@Mock
private UserRepository userRepository;
@InjectMocks
private UserService userService; // 自动注入 Mock
@BeforeEach
void setUp() {
MockitoAnnotations.openMocks(this);
}
@Test
void testCreateUser() {
// 准备 Mock 行为
when(userRepository.save(any())).thenAnswer(invocation -> {
User user = invocation.getArgument(0);
user.setId(1L);
return user;
});
// 执行测试
User result = userService.create("Test", "test@example.com");
// 验证
assertEquals(1L, result.getId());
verify(userRepository).save(any());
}
}
实战案例:构建一个完整的用户管理系统
让我们把学到的知识组合起来,构建一个真正的企业级应用:
”`java // 实体层 @Entity @Table(name = “users”) public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, length = 50)
private String username;
@Column(nullable = false, unique = true, length = 100)
private String email;
@Column(nullable = false)
private String password;
@ElementCollection(fetch = FetchType.EAGER)
@CollectionTable(name = "user_roles", joinColumns = @JoinColumn(name = "user_id"))
@Column(name = "role")
private Set<String> roles = new HashSet<>();
private boolean enabled = true;
private LocalDateTime createdAt;
private LocalDateTime updatedAt;
@PrePersist
protected void onCreate() {
createdAt = LocalDateTime.now();
updatedAt = LocalDateTime.now();
}
@PreUpdate
protected void onUpdate() {
updatedAt = LocalDateTime.now();
}
// getters and setters...
}
// DTO 层(数据传输对象,避免暴露实体) public class UserCreateRequest {
private String username;
private String email;
private String password;
// getters and setters...
}
public class UserResponse {
private Long id;
private String username;
private String email;
private Set<String> roles;
private LocalDateTime createdAt;
// getters and setters...
}
// Repository 层
public interface UserRepository extends JpaRepository
Optional<User> findByEmail(String email);
Optional<User> findByUsername(String username);
boolean existsByEmail(String email);
boolean existsByUsername(String username);
}
// Service 层 @Service public class UserService {
@Autowired
private UserRepository userRepository;
@Autowired
private PasswordEncoder passwordEncoder;
@Transactional
public UserResponse createUser(UserCreateRequest request) {
// 参数校验
if (userRepository.existsByEmail(request.getEmail())) {
throw new BusinessException("邮箱已注册");
}
if (userRepository.existsByUsername(request.getUsername())) {
throw new BusinessException("用户名已存在");
}
// 创建用户
User user = new User();
user.setUsername(request.getUsername());
user.setEmail(request.getEmail());
user.setPassword(passwordEncoder.encode(request.getPassword()));
