Spring Boot Development

manutej/luxor-claude-marketplace/plugins/luxor-backend-toolkit/skills/spring-boot-development

作者 manutej1861cc9720d5無授權條款62 個星標收錄於 2026年10月8日更新於 2026年10月8日儲存庫3 個月前更新

Comprehensive Spring Boot development skill covering auto-configuration, dependency injection, REST APIs, Spring Data, security, and enterprise Java applications

僅含說明Software Development
AI 產生的概覽

指導建置 Spring Boot 應用，涵蓋自動設定、REST API、Spring Data JPA 與 Spring Security。

功能
此技能提供開發 Spring Boot 應用程式的參考指引與程式碼範例，涵蓋自動設定、依賴注入方式、REST 控制器、Spring Data JPA 實體與儲存庫、應用程式設定與多環境設定，以及包含 JWT 驗證的 Spring Security。產出為說明性文件與範例程式碼，不會執行指令碼，也不會產生檔案。
適用情境
適用於建置或擴充 Spring Boot 後端，例如 REST API、微服務或資料驅動的 Java 服務。也適合實作驗證與授權，或將傳統 Spring 專案移轉至 Spring Boot 的情境。
執行需求
未隨附指令碼或工具，僅有說明與範例。依範例實作需要 Java 與 Spring Boot 專案及相關依賴，例如 Spring Web、Spring Data JPA 與 Spring Security，並在使用相關模式時準備資料庫與 JWT 設定。

Spring Boot Development Skill

This skill provides comprehensive guidance for building modern Spring Boot applications using auto-configuration, dependency injection, REST APIs, Spring Data, Spring Security, and enterprise Java patterns based on official Spring Boot documentation.

When to Use This Skill

Use this skill when:

  • Building enterprise REST APIs and microservices
  • Creating web applications with Spring MVC
  • Developing data-driven applications with JPA and databases
  • Implementing authentication and authorization with Spring Security
  • Building production-ready applications with actuator and monitoring
  • Creating scalable backend services with Spring Boot
  • Migrating from traditional Spring to Spring Boot
  • Developing cloud-native applications
  • Building event-driven systems with messaging
  • Creating batch processing applications

Core Concepts

Auto-Configuration

Spring Boot automatically configures your application based on the dependencies you have added to the project. This reduces boilerplate configuration significantly.

How Auto-Configuration Works:

java
@SpringBootApplicationpublic class MyApplication {    public static void main(String[] args) {        SpringApplication.run(MyApplication.class, args);    }}

The @SpringBootApplication annotation is a combination of:

  • @Configuration: Tags the class as a source of bean definitions
  • @EnableAutoConfiguration: Enables Spring Boot's auto-configuration mechanism
  • @ComponentScan: Enables component scanning in the current package and sub-packages

Conditional Auto-Configuration:

java
@Configuration@ConditionalOnClass(DataSource.class)@ConditionalOnProperty(name = "spring.datasource.url")public class DataSourceAutoConfiguration {
    @Bean    @ConditionalOnMissingBean    public DataSource dataSource() {        return DataSourceBuilder.create().build();    }}

Customizing Auto-Configuration:

java
// Exclude specific auto-configurations@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})public class MyApplication {    // ...}
// Or in application.properties// spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

Dependency Injection

Spring's IoC (Inversion of Control) container manages object creation and dependency injection.

Constructor Injection (Recommended):

java
@Servicepublic class UserService {
    private final UserRepository userRepository;    private final EmailService emailService;
    // Constructor injection - recommended approach    public UserService(UserRepository userRepository, EmailService emailService) {        this.userRepository = userRepository;        this.emailService = emailService;    }
    public User createUser(User user) {        User saved = userRepository.save(user);        emailService.sendWelcomeEmail(saved);        return saved;    }}

Field Injection (Not Recommended):

java
@Servicepublic class UserService {
    @Autowired  // Avoid field injection    private UserRepository userRepository;
    // Difficult to test and creates tight coupling}

Setter Injection (Optional Dependencies):

java
@Servicepublic class UserService {
    private UserRepository userRepository;    private EmailService emailService;
    @Autowired    public void setUserRepository(UserRepository userRepository) {        this.userRepository = userRepository;    }
    @Autowired(required = false)    public void setEmailService(EmailService emailService) {        this.emailService = emailService;    }}

Component Stereotypes:

java
@Component  // Generic componentpublic class MyComponent { }
@Service    // Business logic layerpublic class MyService { }
@Repository // Data access layerpublic class MyRepository { }
@Controller // Presentation layer (web)public class MyController { }
@RestController // REST API controllerpublic class MyRestController { }

Spring Web (REST APIs)

Build RESTful web services with Spring MVC annotations.

Basic REST Controller:

java
@RestController@RequestMapping("/api/users")public class UserController {
    private final UserService userService;
    public UserController(UserService userService) {        this.userService = userService;    }
    @GetMapping    public List<User> getAllUsers() {        return userService.findAll();    }
    @GetMapping("/{id}")    public ResponseEntity<User> getUserById(@PathVariable Long id) {        return userService.findById(id)            .map(ResponseEntity::ok)            .orElse(ResponseEntity.notFound().build());    }
    @PostMapping    public ResponseEntity<User> createUser(@RequestBody @Valid User user) {        User created = userService.save(user);        URI location = ServletUriComponentsBuilder            .fromCurrentRequest()            .path("/{id}")            .buildAndExpand(created.getId())            .toUri();        return ResponseEntity.created(location).body(created);    }
    @PutMapping("/{id}")    public ResponseEntity<User> updateUser(@PathVariable Long id,                                          @RequestBody @Valid User user) {        return userService.update(id, user)            .map(ResponseEntity::ok)            .orElse(ResponseEntity.notFound().build());    }
    @DeleteMapping("/{id}")    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {        if (userService.delete(id)) {            return ResponseEntity.noContent().build();        }        return ResponseEntity.notFound().build();    }}

Request Mapping Variations:

java
@RestController@RequestMapping("/api/products")public class ProductController {
    // Query parameters    @GetMapping("/search")    public List<Product> search(@RequestParam String name,                               @RequestParam(required = false) String category) {        return productService.search(name, category);    }
    // Multiple path variables    @GetMapping("/categories/{categoryId}/products/{productId}")    public Product getProductInCategory(@PathVariable Long categoryId,                                       @PathVariable Long productId) {        return productService.findInCategory(categoryId, productId);    }
    // Request headers    @GetMapping("/{id}")    public Product getProduct(@PathVariable Long id,                             @RequestHeader("Accept-Language") String language) {        return productService.find(id, language);    }
    // Matrix variables    @GetMapping("/{id}")    public Product getProductWithMatrix(@PathVariable Long id,                                       @MatrixVariable Map<String, String> filters) {        return productService.findWithFilters(id, filters);    }}

Response Handling:

java
@RestController@RequestMapping("/api/orders")public class OrderController {
    // Return different status codes    @PostMapping    public ResponseEntity<Order> createOrder(@RequestBody Order order) {        Order created = orderService.create(order);        return ResponseEntity.status(HttpStatus.CREATED).body(created);    }
    // Custom headers    @GetMapping("/{id}")    public ResponseEntity<Order> getOrder(@PathVariable Long id) {        Order order = orderService.findById(id);        return ResponseEntity.ok()            .header("X-Order-Version", order.getVersion().toString())            .body(order);    }
    // No content response    @DeleteMapping("/{id}")    public ResponseEntity<Void> deleteOrder(@PathVariable Long id) {        orderService.delete(id);        return ResponseEntity.noContent().build();    }}

Spring Data JPA

Spring Data JPA provides repository abstractions for database access.

Entity Definition:

java
@Entity@Table(name = "users")public class User {
    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    private Long id;
    @Column(nullable = false, unique = true)    private String email;
    @Column(nullable = false)    private String name;
    @Column(name = "created_at", nullable = false, updatable = false)    private LocalDateTime createdAt;
    @Column(name = "updated_at")    private LocalDateTime updatedAt;
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)    private List<Order> orders = new ArrayList<>();
    @ManyToOne(fetch = FetchType.LAZY)    @JoinColumn(name = "department_id")    private Department department;
    @PrePersist    protected void onCreate() {        createdAt = LocalDateTime.now();        updatedAt = LocalDateTime.now();    }
    @PreUpdate    protected void onUpdate() {        updatedAt = LocalDateTime.now();    }
    // Getters and setters}

Repository Interface:

java
@Repositorypublic interface UserRepository extends JpaRepository<User, Long> {
    // Query method - Spring Data generates implementation    Optional<User> findByEmail(String email);
    List<User> findByNameContaining(String name);
    List<User> findByDepartmentId(Long departmentId);
    // Custom JPQL query    @Query("SELECT u FROM User u WHERE u.email = ?1")    Optional<User> findByEmailQuery(String email);
    // Named parameters    @Query("SELECT u FROM User u WHERE u.name LIKE %:name% AND u.department.id = :deptId")    List<User> searchByNameAndDepartment(@Param("name") String name,                                        @Param("deptId") Long deptId);
    // Native SQL query    @Query(value = "SELECT * FROM users WHERE email = ?1", nativeQuery = true)    Optional<User> findByEmailNative(String email);
    // Modifying query    @Modifying    @Query("UPDATE User u SET u.name = :name WHERE u.id = :id")    int updateUserName(@Param("id") Long id, @Param("name") String name);
    // Pagination and sorting    Page<User> findByDepartmentId(Long departmentId, Pageable pageable);
    List<User> findByNameContaining(String name, Sort sort);}

Repository Usage:

java
@Servicepublic class UserService {
    private final UserRepository userRepository;
    public UserService(UserRepository userRepository) {        this.userRepository = userRepository;    }
    public Optional<User> findById(Long id) {        return userRepository.findById(id);    }
    public User save(User user) {        return userRepository.save(user);    }
    public List<User> findAll() {        return userRepository.findAll();    }
    public Page<User> findAll(int page, int size) {        Pageable pageable = PageRequest.of(page, size, Sort.by("name"));        return userRepository.findAll(pageable);    }
    public boolean delete(Long id) {        if (userRepository.existsById(id)) {            userRepository.deleteById(id);            return true;        }        return false;    }}

Relationships:

java
// One-to-Many@Entitypublic class Order {    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    private Long id;
    @ManyToOne(fetch = FetchType.LAZY)    @JoinColumn(name = "user_id")    private User user;
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)    private List<OrderItem> items = new ArrayList<>();}
// Many-to-Many@Entitypublic class Student {    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    private Long id;
    @ManyToMany    @JoinTable(        name = "student_course",        joinColumns = @JoinColumn(name = "student_id"),        inverseJoinColumns = @JoinColumn(name = "course_id")    )    private Set<Course> courses = new HashSet<>();}

Configuration

Spring Boot uses application.properties or application.yml for configuration.

Application Properties:

properties
# Server configurationserver.port=8080server.servlet.context-path=/api
# Database configurationspring.datasource.url=jdbc:postgresql://localhost:5432/mydbspring.datasource.username=userspring.datasource.password=passwordspring.datasource.driver-class-name=org.postgresql.Driver
# JPA configurationspring.jpa.hibernate.ddl-auto=validatespring.jpa.show-sql=truespring.jpa.properties.hibernate.format_sql=truespring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
# Logginglogging.level.root=INFOlogging.level.com.example=DEBUGlogging.level.org.springframework.web=DEBUGlogging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} - %msg%n
# Custom propertiesapp.name=My Applicationapp.version=1.0.0

Application YAML:

yaml
server:  port: 8080  servlet:    context-path: /api
spring:  datasource:    url: jdbc:postgresql://localhost:5432/mydb    username: user    password: password    driver-class-name: org.postgresql.Driver
  jpa:    hibernate:      ddl-auto: validate    show-sql: true    properties:      hibernate:        format_sql: true        dialect: org.hibernate.dialect.PostgreSQLDialect
logging:  level:    root: INFO    com.example: DEBUG    org.springframework.web: DEBUG
app:  name: My Application  version: 1.0.0

Configuration Properties Class:

java
@Configuration@ConfigurationProperties(prefix = "app")public class AppConfig {
    private String name;    private String version;    private Security security = new Security();
    public static class Security {        private int tokenExpiration = 3600;        private String secretKey;
        // Getters and setters    }
    // Getters and setters}
// Usage@Servicepublic class MyService {
    private final AppConfig appConfig;
    public MyService(AppConfig appConfig) {        this.appConfig = appConfig;    }
    public void printConfig() {        System.out.println("App: " + appConfig.getName());        System.out.println("Version: " + appConfig.getVersion());    }}

Environment-Specific Configuration:

properties
# application.properties (default)spring.profiles.active=dev
# application-dev.propertiesspring.datasource.url=jdbc:postgresql://localhost:5432/mydb_devlogging.level.root=DEBUG
# application-prod.propertiesspring.datasource.url=jdbc:postgresql://prod-server:5432/mydb_prodlogging.level.root=WARN

Profile-Specific Beans:

java
@Configurationpublic class DatabaseConfig {
    @Bean    @Profile("dev")    public DataSource devDataSource() {        return new EmbeddedDatabaseBuilder()            .setType(EmbeddedDatabaseType.H2)            .build();    }
    @Bean    @Profile("prod")    public DataSource prodDataSource() {        return DataSourceBuilder.create().build();    }}

Spring Security

Implement authentication and authorization in your application.

Basic Security Configuration:

java
@Configuration@EnableWebSecuritypublic class SecurityConfig {
    @Bean    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {        http            .csrf().disable()            .authorizeHttpRequests(auth -> auth                .requestMatchers("/api/public/**").permitAll()                .requestMatchers("/api/admin/**").hasRole("ADMIN")                .requestMatchers("/api/users/**").hasAnyRole("USER", "ADMIN")                .anyRequest().authenticated()            )            .httpBasic();
        return http.build();    }
    @Bean    public PasswordEncoder passwordEncoder() {        return new BCryptPasswordEncoder();    }}

In-Memory Authentication:

java
@Configuration@EnableWebSecuritypublic class SecurityConfig {
    @Bean    public UserDetailsService userDetailsService(PasswordEncoder passwordEncoder) {        UserDetails user = User.builder()            .username("user")            .password(passwordEncoder.encode("password"))            .roles("USER")            .build();
        UserDetails admin = User.builder()            .username("admin")            .password(passwordEncoder.encode("admin"))            .roles("ADMIN", "USER")            .build();
        return new InMemoryUserDetailsManager(user, admin);    }}

Database Authentication:

java
@Servicepublic class CustomUserDetailsService implements UserDetailsService {
    private final UserRepository userRepository;
    public CustomUserDetailsService(UserRepository userRepository) {        this.userRepository = userRepository;    }
    @Override    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {        User user = userRepository.findByEmail(username)            .orElseThrow(() -> new UsernameNotFoundException("User not found: " + username));
        return org.springframework.security.core.userdetails.User.builder()            .username(user.getEmail())            .password(user.getPassword())            .roles(user.getRoles().toArray(new String[0]))            .build();    }}
@Configuration@EnableWebSecuritypublic class SecurityConfig {
    private final CustomUserDetailsService userDetailsService;
    public SecurityConfig(CustomUserDetailsService userDetailsService) {        this.userDetailsService = userDetailsService;    }
    @Bean    public DaoAuthenticationProvider authenticationProvider(PasswordEncoder passwordEncoder) {        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();        provider.setUserDetailsService(userDetailsService);        provider.setPasswordEncoder(passwordEncoder);        return provider;    }}

JWT Authentication:

java
@Componentpublic class JwtTokenProvider {
    @Value("${app.security.jwt.secret}")    private String jwtSecret;
    @Value("${app.security.jwt.expiration}")    private int jwtExpiration;
    public String generateToken(Authentication authentication) {        UserPrincipal userPrincipal = (UserPrincipal) authentication.getPrincipal();
        Date now = new Date();        Date expiryDate = new Date(now.getTime() + jwtExpiration);
        return Jwts.builder()            .setSubject(Long.toString(userPrincipal.getId()))            .setIssuedAt(now)            .setExpiration(expiryDate)            .signWith(SignatureAlgorithm.HS512, jwtSecret)            .compact();    }
    public Long getUserIdFromJWT(String token) {        Claims claims = Jwts.parser()            .setSigningKey(jwtSecret)            .parseClaimsJws(token)            .getBody();
        return Long.parseLong(claims.getSubject());    }
    public boolean validateToken(String authToken) {        try {            Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(authToken);            return true;        } catch (SignatureException | MalformedJwtException | ExpiredJwtException |                 UnsupportedJwtException | IllegalArgumentException ex) {            return false;        }    }}
@Componentpublic class JwtAuthenticationFilter extends OncePerRequestFilter {
    private final JwtTokenProvider tokenProvider;    private final CustomUserDetailsService customUserDetailsService;
    public JwtAuthenticationFilter(JwtTokenProvider tokenProvider,                                  CustomUserDetailsService customUserDetailsService) {        this.tokenProvider = tokenProvider;        this.customUserDetailsService = customUserDetailsService;    }
    @Override    protected void doFilterInternal(HttpServletRequest request,                                   HttpServletResponse response,                                   FilterChain filterChain) throws ServletException, IOException {        try {            String jwt = getJwtFromRequest(request);
            if (jwt != null && tokenProvider.validateToken(jwt)) {                Long userId = tokenProvider.getUserIdFromJWT(jwt);
                UserDetails userDetails = customUserDetailsService.loadUserById(userId);                UsernamePasswordAuthenticationToken authentication =                    new UsernamePasswordAuthenticationToken(                        userDetails, null, userDetails.getAuthorities()                    );
                SecurityContextHolder.getContext().setAuthentication(authentication);            }        } catch (Exception ex) {            logger.error("Could not set user authentication", ex);        }
        filterChain.doFilter(request, response);    }
    private String getJwtFromRequest(HttpServletRequest request) {        String bearerToken = request.getHeader("Authorization");        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {            return bearerToken.substring(7);        }        return null;    }}

API Reference

Common Annotations

Core Spring Annotations:

  • @SpringBootApplication: Main application class
  • @Component: Generic component
  • @Service: Service layer component
  • @Repository: Data access layer component
  • @Configuration: Configuration class
  • @Bean: Bean definition method
  • @Autowired: Dependency injection
  • @Value: Inject property values
  • @Profile: Conditional beans based on profiles

Web Annotations:

  • @RestController: REST API controller
  • @Controller: MVC controller
  • @RequestMapping: Map HTTP requests
  • @GetMapping: Map GET requests
  • @PostMapping: Map POST requests
  • @PutMapping: Map PUT requests
  • @DeleteMapping: Map DELETE requests
  • @PatchMapping: Map PATCH requests
  • @PathVariable: Extract path variables
  • @RequestParam: Extract query parameters
  • @RequestBody: Extract request body
  • @RequestHeader: Extract request headers
  • @ResponseStatus: Set response status

Data Annotations:

  • @Entity: JPA entity
  • @Table: Table mapping
  • @Id: Primary key
  • @GeneratedValue: Auto-generated values
  • @Column: Column mapping
  • @OneToOne: One-to-one relationship
  • @OneToMany: One-to-many relationship
  • @ManyToOne: Many-to-one relationship
  • @ManyToMany: Many-to-many relationship
  • @JoinColumn: Join column
  • @JoinTable: Join table

Validation Annotations:

  • @Valid: Enable validation
  • @NotNull: Field cannot be null
  • @NotEmpty: Field cannot be empty
  • @NotBlank: Field cannot be blank
  • @Size: String or collection size
  • @Min: Minimum value
  • @Max: Maximum value
  • @Email: Email format
  • @Pattern: Regex pattern

Transaction Annotations:

  • @Transactional: Enable transaction management
  • @Transactional(readOnly = true): Read-only transaction

Security Annotations:

  • @EnableWebSecurity: Enable security
  • @PreAuthorize: Method-level authorization
  • @PostAuthorize: Post-method authorization
  • @Secured: Role-based access

Async and Scheduling:

  • @EnableAsync: Enable async processing
  • @Async: Async method
  • @EnableScheduling: Enable scheduling
  • @Scheduled: Scheduled method

Workflow Patterns

REST API Design Pattern

Complete CRUD REST API:

java
// Entity@Entity@Table(name = "products")public class Product {    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    private Long id;
    @NotBlank(message = "Name is required")    private String name;
    @NotBlank(message = "Description is required")    private String description;
    @NotNull(message = "Price is required")    @Min(value = 0, message = "Price must be positive")    private BigDecimal price;
    @NotNull(message = "Stock is required")    @Min(value = 0, message = "Stock must be positive")    private Integer stock;
    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}
// Repository@Repositorypublic interface ProductRepository extends JpaRepository<Product, Long> {    List<Product> findByNameContaining(String name);    List<Product> findByPriceBetween(BigDecimal minPrice, BigDecimal maxPrice);}
// Service@Service@Transactionalpublic class ProductService {
    private final ProductRepository productRepository;
    public ProductService(ProductRepository productRepository) {        this.productRepository = productRepository;    }
    @Transactional(readOnly = true)    public Page<Product> findAll(Pageable pageable) {        return productRepository.findAll(pageable);    }
    @Transactional(readOnly = true)    public Optional<Product> findById(Long id) {        return productRepository.findById(id);    }
    public Product create(Product product) {        return productRepository.save(product);    }
    public Optional<Product> update(Long id, Product productDetails) {        return productRepository.findById(id)            .map(product -> {                product.setName(productDetails.getName());                product.setDescription(productDetails.getDescription());                product.setPrice(productDetails.getPrice());                product.setStock(productDetails.getStock());                return productRepository.save(product);            });    }
    public boolean delete(Long id) {        return productRepository.findById(id)            .map(product -> {                productRepository.delete(product);                return true;            })            .orElse(false);    }}
// Controller@RestController@RequestMapping("/api/products")public class ProductController {
    private final ProductService productService;
    public ProductController(ProductService productService) {        this.productService = productService;    }
    @GetMapping    public Page<Product> getAllProducts(            @RequestParam(defaultValue = "0") int page,            @RequestParam(defaultValue = "10") int size,            @RequestParam(defaultValue = "id") String sortBy) {        Pageable pageable = PageRequest.of(page, size, Sort.by(sortBy));        return productService.findAll(pageable);    }
    @GetMapping("/{id}")    public ResponseEntity<Product> getProductById(@PathVariable Long id) {        return productService.findById(id)            .map(ResponseEntity::ok)            .orElse(ResponseEntity.notFound().build());    }
    @PostMapping    public ResponseEntity<Product> createProduct(@Valid @RequestBody Product product) {        Product created = productService.create(product);        URI location = ServletUriComponentsBuilder            .fromCurrentRequest()            .path("/{id}")            .buildAndExpand(created.getId())            .toUri();        return ResponseEntity.created(location).body(created);    }
    @PutMapping("/{id}")    public ResponseEntity<Product> updateProduct(            @PathVariable Long id,            @Valid @RequestBody Product product) {        return productService.update(id, product)            .map(ResponseEntity::ok)            .orElse(ResponseEntity.notFound().build());    }
    @DeleteMapping("/{id}")    public ResponseEntity<Void> deleteProduct(@PathVariable Long id) {        if (productService.delete(id)) {            return ResponseEntity.noContent().build();        }        return ResponseEntity.notFound().build();    }}

Exception Handling Pattern

Global Exception Handler:

java
// Custom exceptionspublic class ResourceNotFoundException extends RuntimeException {    public ResourceNotFoundException(String message) {        super(message);    }}
public class BadRequestException extends RuntimeException {    public BadRequestException(String message) {        super(message);    }}
// Error responsepublic class ErrorResponse {    private LocalDateTime timestamp;    private int status;    private String error;    private String message;    private String path;
    // Constructors, getters, setters}
// Global exception handler@RestControllerAdvicepublic class GlobalExceptionHandler {
    @ExceptionHandler(ResourceNotFoundException.class)    public ResponseEntity<ErrorResponse> handleResourceNotFound(            ResourceNotFoundException ex,            WebRequest request) {        ErrorResponse error = new ErrorResponse(            LocalDateTime.now(),            HttpStatus.NOT_FOUND.value(),            "Not Found",            ex.getMessage(),            request.getDescription(false).replace("uri=", "")        );        return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);    }
    @ExceptionHandler(BadRequestException.class)    public ResponseEntity<ErrorResponse> handleBadRequest(            BadRequestException ex,            WebRequest request) {        ErrorResponse error = new ErrorResponse(            LocalDateTime.now(),            HttpStatus.BAD_REQUEST.value(),            "Bad Request",            ex.getMessage(),            request.getDescription(false).replace("uri=", "")        );        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);    }
    @ExceptionHandler(MethodArgumentNotValidException.class)    public ResponseEntity<Map<String, Object>> handleValidationErrors(            MethodArgumentNotValidException ex) {        Map<String, Object> errors = new HashMap<>();        errors.put("timestamp", LocalDateTime.now());        errors.put("status", HttpStatus.BAD_REQUEST.value());
        Map<String, String> fieldErrors = new HashMap<>();        ex.getBindingResult().getFieldErrors().forEach(error ->            fieldErrors.put(error.getField(), error.getDefaultMessage())        );        errors.put("errors", fieldErrors);
        return new ResponseEntity<>(errors, HttpStatus.BAD_REQUEST);    }
    @ExceptionHandler(Exception.class)    public ResponseEntity<ErrorResponse> handleGlobalException(            Exception ex,            WebRequest request) {        ErrorResponse error = new ErrorResponse(            LocalDateTime.now(),            HttpStatus.INTERNAL_SERVER_ERROR.value(),            "Internal Server Error",            ex.getMessage(),            request.getDescription(false).replace("uri=", "")        );        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);    }}

Database Integration Pattern

Complete Database Setup:

java
// application.yml/*spring:  datasource:    url: jdbc:postgresql://localhost:5432/mydb    username: user    password: password  jpa:    hibernate:      ddl-auto: validate    show-sql: true    properties:      hibernate:        dialect: org.hibernate.dialect.PostgreSQLDialect*/
// Flyway migrations (db/migration/V1__Create_users_table.sql)/*CREATE TABLE users (    id BIGSERIAL PRIMARY KEY,    email VARCHAR(255) NOT NULL UNIQUE,    name VARCHAR(255) NOT NULL,    password VARCHAR(255) NOT NULL,    created_at TIMESTAMP NOT NULL,    updated_at TIMESTAMP NOT NULL);
CREATE INDEX idx_users_email ON users(email);*/
// Entity with auditing@Entity@Table(name = "users")@EntityListeners(AuditingEntityListener.class)public class User {    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    private Long id;
    @Column(nullable = false, unique = true)    private String email;
    @Column(nullable = false)    private String name;
    @Column(nullable = false)    private String password;
    @CreatedDate    @Column(name = "created_at", nullable = false, updatable = false)    private LocalDateTime createdAt;
    @LastModifiedDate    @Column(name = "updated_at")    private LocalDateTime updatedAt;
    // Getters and setters}
// Enable JPA auditing@Configuration@EnableJpaAuditingpublic class JpaConfig {}

Testing Pattern

Unit Tests:

java
@SpringBootTestclass UserServiceTest {
    @Mock    private UserRepository userRepository;
    @InjectMocks    private UserService userService;
    @BeforeEach    void setUp() {        MockitoAnnotations.openMocks(this);    }
    @Test    void testFindById_Success() {        User user = new User();        user.setId(1L);        user.setEmail("[email protected]");
        when(userRepository.findById(1L)).thenReturn(Optional.of(user));
        Optional<User> result = userService.findById(1L);
        assertTrue(result.isPresent());        assertEquals("[email protected]", result.get().getEmail());        verify(userRepository, times(1)).findById(1L);    }
    @Test    void testFindById_NotFound() {        when(userRepository.findById(1L)).thenReturn(Optional.empty());
        Optional<User> result = userService.findById(1L);
        assertFalse(result.isPresent());    }}

Integration Tests:

java
@SpringBootTest@AutoConfigureMockMvc@Transactionalclass UserControllerIntegrationTest {
    @Autowired    private MockMvc mockMvc;
    @Autowired    private ObjectMapper objectMapper;
    @Autowired    private UserRepository userRepository;
    @Test    void testCreateUser_Success() throws Exception {        User user = new User();        user.setEmail("[email protected]");        user.setName("Test User");
        mockMvc.perform(post("/api/users")                .contentType(MediaType.APPLICATION_JSON)                .content(objectMapper.writeValueAsString(user)))            .andExpect(status().isCreated())            .andExpect(jsonPath("$.email").value("[email protected]"))            .andExpect(jsonPath("$.name").value("Test User"));    }
    @Test    void testGetUser_Success() throws Exception {        User user = new User();        user.setEmail("[email protected]");        user.setName("Test User");        User saved = userRepository.save(user);
        mockMvc.perform(get("/api/users/" + saved.getId()))            .andExpect(status().isOk())            .andExpect(jsonPath("$.id").value(saved.getId()))            .andExpect(jsonPath("$.email").value("[email protected]"));    }
    @Test    void testGetUser_NotFound() throws Exception {        mockMvc.perform(get("/api/users/999"))            .andExpect(status().isNotFound());    }}

Best Practices

1. Use Constructor Injection

Constructor injection is the recommended approach for dependency injection.

java
// Good - Constructor injection@Servicepublic class UserService {    private final UserRepository userRepository;    private final EmailService emailService;
    public UserService(UserRepository userRepository, EmailService emailService) {        this.userRepository = userRepository;        this.emailService = emailService;    }}
// Bad - Field injection@Servicepublic class UserService {    @Autowired    private UserRepository userRepository;}

2. Use DTOs for API Requests/Responses

Don't expose entities directly through REST APIs.

java
// DTOpublic class UserDTO {    private Long id;    private String email;    private String name;
    // No password field exposed    // Getters and setters}
// Mapper@Componentpublic class UserMapper {    public UserDTO toDTO(User user) {        UserDTO dto = new UserDTO();        dto.setId(user.getId());        dto.setEmail(user.getEmail());        dto.setName(user.getName());        return dto;    }
    public User toEntity(UserDTO dto) {        User user = new User();        user.setEmail(dto.getEmail());        user.setName(dto.getName());        return user;    }}
// Controller@RestController@RequestMapping("/api/users")public class UserController {    private final UserService userService;    private final UserMapper userMapper;
    @GetMapping("/{id}")    public ResponseEntity<UserDTO> getUser(@PathVariable Long id) {        return userService.findById(id)            .map(userMapper::toDTO)            .map(ResponseEntity::ok)            .orElse(ResponseEntity.notFound().build());    }}

3. Use Validation

Always validate input data.

java
// Entity with validation@Entitypublic class User {    @NotBlank(message = "Email is required")    @Email(message = "Email should be valid")    private String email;
    @NotBlank(message = "Name is required")    @Size(min = 2, max = 100, message = "Name must be between 2 and 100 characters")    private String name;
    @NotBlank(message = "Password is required")    @Size(min = 8, message = "Password must be at least 8 characters")    private String password;}
// Controller@PostMappingpublic ResponseEntity<User> createUser(@Valid @RequestBody User user) {    // Validation happens automatically    return ResponseEntity.ok(userService.save(user));}

4. Use Transactions Properly

Mark service methods with appropriate transaction settings.

java
@Service@Transactionalpublic class OrderService {
    @Transactional(readOnly = true)    public List<Order> findAll() {        return orderRepository.findAll();    }
    @Transactional    public Order createOrder(Order order) {        // Multiple database operations in one transaction        Order saved = orderRepository.save(order);        inventoryService.decreaseStock(order.getItems());        emailService.sendOrderConfirmation(saved);        return saved;    }}

5. Use Pagination

Always paginate large datasets.

java
@GetMappingpublic Page<Product> getProducts(        @RequestParam(defaultValue = "0") int page,        @RequestParam(defaultValue = "20") int size,        @RequestParam(defaultValue = "id") String sortBy) {    Pageable pageable = PageRequest.of(page, size, Sort.by(sortBy));    return productService.findAll(pageable);}

6. Handle Exceptions Globally

Use @RestControllerAdvice for centralized exception handling.

java
@RestControllerAdvicepublic class GlobalExceptionHandler {
    @ExceptionHandler(ResourceNotFoundException.class)    public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex) {        return ResponseEntity.status(HttpStatus.NOT_FOUND)            .body(new ErrorResponse(ex.getMessage()));    }}

7. Use Logging

Implement proper logging throughout your application.

java
@Servicepublic class UserService {    private static final Logger logger = LoggerFactory.getLogger(UserService.class);
    public User createUser(User user) {        logger.info("Creating user with email: {}", user.getEmail());        try {            User saved = userRepository.save(user);            logger.info("User created successfully with id: {}", saved.getId());            return saved;        } catch (Exception e) {            logger.error("Error creating user: {}", e.getMessage(), e);            throw e;        }    }}

8. Secure Your Endpoints

Implement proper authentication and authorization.

java
@Configuration@EnableWebSecuritypublic class SecurityConfig {
    @Bean    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {        http            .authorizeHttpRequests(auth -> auth                .requestMatchers("/api/public/**").permitAll()                .requestMatchers("/api/admin/**").hasRole("ADMIN")                .anyRequest().authenticated()            )            .oauth2ResourceServer().jwt();
        return http.build();    }}

9. Use Database Migrations

Use Flyway or Liquibase for database version control.

sql
-- V1__Create_users_table.sqlCREATE TABLE users (    id BIGSERIAL PRIMARY KEY,    email VARCHAR(255) NOT NULL UNIQUE,    name VARCHAR(255) NOT NULL,    created_at TIMESTAMP NOT NULL);
-- V2__Add_password_column.sqlALTER TABLE users ADD COLUMN password VARCHAR(255);

10. Monitor Your Application

Use Spring Boot Actuator for monitoring.

properties
# application.propertiesmanagement.endpoints.web.exposure.include=health,info,metricsmanagement.endpoint.health.show-details=always

Examples

See EXAMPLES.md for detailed code examples including:

  • Basic Spring Boot Application
  • REST API with CRUD Operations
  • Database Integration with JPA
  • Custom Queries and Specifications
  • Request Validation
  • Exception Handling
  • Authentication with JWT
  • Role-Based Authorization
  • File Upload/Download
  • Caching with Redis
  • Async Processing
  • Scheduled Tasks
  • Multiple Database Configuration
  • Actuator and Monitoring
  • Docker Deployment

Summary

This Spring Boot development skill covers:

  1. Auto-Configuration: Automatic configuration based on dependencies
  2. Dependency Injection: IoC container, constructor injection, component stereotypes
  3. REST APIs: Controllers, request mapping, response handling
  4. Spring Data JPA: Entities, repositories, relationships, queries
  5. Configuration: Properties, YAML, profiles, custom properties
  6. Security: Authentication, authorization, JWT, role-based access
  7. Exception Handling: Global exception handling, custom exceptions
  8. Testing: Unit tests, integration tests, MockMvc
  9. Best Practices: DTOs, validation, transactions, pagination, logging
  10. Production Ready: Actuator, monitoring, database migrations, deployment

The patterns and examples are based on official Spring Boot documentation (Trust Score: 7.5) and represent modern enterprise Java development practices.

來源與署名

來源：manutej/luxor-claude-marketplace位於plugins/luxor-backend-toolkit/skills/spring-boot-development提交1861cc9

授權條款： 無授權條款

內容歸原作者所有。SourceWeft 從公開儲存庫中收錄這些內容。

檢舉或申請下架

更多來自 manutej/luxor-claude-marketplace 的技能

Ui Design Patterns

manutej

常見 UI 設計模式參考指南，涵蓋導覽、表單、資料呈現、回饋與無障礙設計。

Design & Creative623 個月前更新

Tailwind Css

manutej

Tailwind CSS 使用參考，涵蓋工具類別、響應式設計、深色模式與主題客製化。

Software Development623 個月前更新

Responsive Design

manutej

提供行動優先響應式 CSS 版面、媒體查詢、Flexbox、Grid、視埠單位與響應式圖片的參考指引。

Design & Creative623 個月前更新

React Patterns

manutej

現代 React 模式參考指南，涵蓋 Hooks、元件組合、狀態管理與效能最佳化。

Software Development623 個月前更新

React Development

manutej

關於使用 hooks、元件、狀態管理、context、副作用與效能最佳化來建置 React 應用程式的參考指南。

Software Development623 個月前更新

Shell Testing Framework

manutej

指導撰寫 bash shell 指令碼測試套件，涵蓋 arrange-act-assert 結構、四類測試與效能檢查。

Software Development623 個月前更新

更多Software Development技能

Playground

anthropics

精選

建立自成一體的互動式 HTML 遊樂場，包含控制項、即時預覽與可複製的提示詞輸出。

Software Development37K今天更新

M5 Onboard

anthropics

精選

透過 USB 偵測 M5Stack ESP32 開發板，燒錄 UIFlow 2.0 韌體並安裝 MicroPython 應用程式套件。

Software Development37K今天更新

Cardputer Buddy

anthropics

精選

指導迭代 Cardputer-Adv 的 MicroPython 應用程式套件：新增應用程式、透過 USB 序列埠推送檔案、查看日誌並執行 REPL 指令。

Software Development37K今天更新

Web Design Guidelines

vercel-labs

精選

依據從遠端來源取得的 Web Interface Guidelines 審查 UI 程式碼，並以 file:line 形式回報問題。

Software Development32K5 週前更新

Vercel React Native Skills

vercel-labs

精選

React Native 與 Expo 最佳實務規則，涵蓋清單效能、動畫、導覽、UI 模式、狀態與 monorepo 設定。

Software Development32K5 週前更新

Vercel React Best Practices

vercel-labs

精選

Vercel 的 React 與 Next.js 效能指南，以 70 條規則的形式用於撰寫、審查與重構程式碼。

Software Development32K5 週前更新