1. 项目创建
使用 Spring Initializr：
访问 https://start.spring.io/ 或使用 IDE 插件创建项目。
使用 CLI：
```bash
# 安装 Spring Boot CLI
brew install spring-boot
# 创建项目
spring init --dependencies=web,data-jpa,postgresql my-project
```
Maven 项目结构：
```
my-project/
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/example/
│ │ │ └── MyApplication.java
│ │ └── resources/
│ │ ├── application.properties
│ │ └── application.yml
│ └── test/
├── pom.xml
└── README.md
```
2. 自动配置
Spring Boot 通过自动配置简化了配置工作。
application.yml：
```yaml
spring:
application:
name: my-app
datasource:
url: jdbc:postgresql://localhost:5432/mydb
username: postgres
password: password
driver-class-name: org.postgresql.Driver
jpa:
hibernate:
ddl-auto: update
show-sql: true
server:
port: 8080
```
application.properties：
```properties
spring.application.name=my-app
spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=postgres
spring.datasource.password=password
spring.datasource.driver-class-name=org.postgresql.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
server.port=8080
```
3. 依赖注入
使用 @Component：
```java
@Component
public class UserService {
public String getUserName(Long id) {
return "User " + id;
}
}
```
使用 @Service：
```java
@Service
public class UserService {
private final UserRepository userRepository;
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
public User findById(Long id) {
return userRepository.findById(id)
.orElseThrow(() -> new UserNotFoundException(id));
}
}
```
使用 @Repository：
```java
@Repository
public interface UserRepository extends JpaRepository {
Optional findByEmail(String email);
List findByNameContaining(String name);
}
```
4. Web 开发
REST Controller：
```java
@RestController
@RequestMapping("/api/users")
public class UserController {
private final UserService userService;
public UserController(UserService userService) {
this.userService = userService;
}
@GetMapping
public List getAllUsers() {
return userService.findAll();
}
@GetMapping("/{id}")
public User getUserById(@PathVariable Long id) {
return userService.findById(id);
}
@PostMapping
public User createUser(@RequestBody User user) {
return userService.save(user);
}
@PutMapping("/{id}")
public User updateUser(@PathVariable Long id, @RequestBody User user) {
return userService.update(id, user);
}
@DeleteMapping("/{id}")
public void deleteUser(@PathVariable Long id) {
userService.delete(id);
}
}
```
异常处理：
```java
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(UserNotFoundException.class)
public ResponseEntity handleUserNotFound(UserNotFoundException ex) {
ErrorResponse error = new ErrorResponse(
HttpStatus.NOT_FOUND.value(),
ex.getMessage()
);
return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
}
}
```
5. 数据访问
JPA Entity：
```java
@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String name;
@Column(unique = true, nullable = false)
private String email;
// Getters and Setters
}
```
Repository：
```java
@Repository
public interface UserRepository extends JpaRepository {
Optional findByEmail(String email);
List findByNameContaining(String name);
@Query("SELECT u FROM User u WHERE u.email = :email")
Optional findByEmailCustom(@Param("email") String email);
}
```
Service：
```java
@Service
@Transactional
public class UserService {
private final UserRepository userRepository;
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
public User save(User user) {
return userRepository.save(user);
}
public Optional findById(Long id) {
return userRepository.findById(id);
}
public List findAll() {
return userRepository.findAll();
}
public void delete(Long id) {
userRepository.deleteById(id);
}
}
```
6. 配置管理
@ConfigurationProperties：
```java
@ConfigurationProperties(prefix = "app")
@Data
public class AppProperties {
private String name;
private String version;
private Database database;
@Data
public static class Database {
private String host;
private int port;
private String name;
}
}
```
使用配置：
```yaml
app:
name: my-app
version: 1.0.0
database:
host: localhost
port: 5432
name: mydb
```
7. 安全（Spring Security）
依赖：
```xml
org.springframework.boot
spring-boot-starter-security
```
配置：
```java
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests(auth -> auth
.requestMatchers("/api/public/**").permitAll()
.anyRequest().authenticated()
)
.httpBasic();
return http.build();
}
}
```
8. 测试
单元测试：
```java
@SpringBootTest
class UserServiceTest {
@Autowired
private UserService userService;
@Test
void testFindById() {
User user = userService.findById(1L)
.orElseThrow();
assertNotNull(user);
}
}
```
集成测试：
```java
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureMockMvc
class UserControllerTest {
@Autowired
private MockMvc mockMvc;
@Test
void testGetUser() throws Exception {
mockMvc.perform(get("/api/users/1"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.name").value("John"));
}
}
```
|