自学内容网 自学内容网
自学内容网 > 正文

SpringBoot

🕗 发布于 2024-12-29 20:12 spring boot  后端  java  spring  

一、什么是

  • 基于 Spring开源框架
  • 快速开发
  • 独立运行
  • 说的白一点，SpringBoot只是简化了ssm，为ssm提供了环境和方便

二、核心特性

1.自动配置

  • 自动配置：Spring Boot 会根据项目中的依赖自动配置 Spring 应用，减少了手动配置的工作量。
  • 条件注解：通过 @Conditional 注解，Spring Boot 可以根据条件决定是否加载某个配置类或 Bean。 

2.起步依赖

  • 起步依赖：通过引入特定的 Starter 依赖，可以快速引入一组相关的依赖，简化了依赖管理。
  • 常用 Starter
  • 用于构建 Web 应用
spring-boot-starter-web
用于 JPA 数据访问
spring-boot-starter-data-jpa
用于 Thymeleaf 模板引擎
spring-boot-starter-thymeleaf
用于 Spring Security
spring-boot-starter-security

3. 嵌入式服务器

  • 内置服务器：Spring Boot 内置了 Tomcat等服务器，无需单独部署。
  • 配置服务器：可以通过 application.properties 或 application.yml 配置服务器端口等属性。

三、环境搭建

1.开发工具

  • IDE：推荐使用 IntelliJ IDEA 或 Eclipse。
  • 构建工具：Maven 或 Gradle。 

2.创建项目

  • 选择项目类型（Maven/Gradle）、语言（Java）、Spring Boot 版本等。
  • 选择需要的依赖（如 Web、JPA 等）。 

3.手动创建

  • 创建 Maven 或 Gradle 项目。
  • 添加 Spring Boot 依赖。 

四、 基本配置

1.application.properties/yml

  • application.properties 
  • server.port=8080 
spring.datasource.url=jdbc:mysql://localhost:3306/mydb 
spring.datasource.username=root 
spring.datasource.password=password
  • application.yml 
  • server:
  port: 8080 
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db
    username: root
    password: password

2.主类

  • SpringBootApplication 注解
  •   
    import org.springframework.boot.SpringApplication; 
import org.springframework.boot.autoconfigure.SpringBootApplication; 

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

五、常用注解

1. 核心注解

@SpringBootApplication：组合注解，包含了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan。
@Configuration：声明该类为配置类。
@EnableAutoConfiguration：开启自动配置。
@ComponentScan：扫描指定包下的组件。

2.组件注解

@Controller：用于标记控制器类。
@Service：用于标记服务类。
@Repository：用于标记数据访问层类。
@Component：通用注解，用于标记任何 Spring 管理的组件。

3.依赖注入注解

@Autowired：自动注入依赖。
@Value：注入配置文件中的值。

4.请求映射注解

@GetMapping：处理 GET 请求。
@PostMapping：处理 POST 请求。
@PutMapping：处理 PUT 请求。
@DeleteMapping：处理 DELETE 请求。
@RequestMapping：通用请求映射注解。

六、 控制器和视图

1. restful API

  • import org.springframework.web.bind.annotation.GetMapping; 
import org.springframework.web.bind.annotation.RestController; 

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}

2.Thymeleaf

  • import org.springframework.stereotype.Controller; 
import org.springframework.ui.Model; 
import org.springframework.web.bind.annotation.GetMapping; 

@Controller
public class HelloController {

    @GetMapping("/hello")
    public String sayHello(Model model) {
        model.addAttribute("message",  "Hello, World!");
        return "hello";
    }
}
    hello.html 
  • <!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org"> 
<head>
    <title>Hello</title>
</head>
<body>
    <h1 th:text="${message}"></h1>
</body>
</html>

七、数据访问

1.实体类

  • import javax.persistence.Entity; 
import javax.persistence.GeneratedValue; 
import javax.persistence.GenerationType; 
import javax.persistence.Id; 

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
}

2.Repository

  • import org.springframework.data.jpa.repository.JpaRepository; 

public interface UserRepository extends JpaRepository<User, Long> {
}

3.Service

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

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null); 
    }

    public User saveUser(User user) {
        return userRepository.save(user); 
    }
}

4.Controller

  • import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.web.bind.annotation.*; 

@RestController 
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserById(id); 
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userService.saveUser(user); 
    }
}

八、安全-Spring Security

1.依赖

  • <dependency>
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

2.配置类

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

@Configuration 
@EnableWebSecurity
public class SecurityConfig 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() {
        UserDetails user =
            User.withDefaultPasswordEncoder() 
                .username("user")
                .password("password")
                .roles("USER")
                .build();

        return new InMemoryUserDetailsManager(user);
    }
}

九、异常处理

@ControllerAdvice：用于定义全局异常处理器。

import org.springframework.http.HttpStatus; 
import org.springframework.http.ResponseEntity; 
import org.springframework.web.bind.annotation.ControllerAdvice; 
import org.springframework.web.bind.annotation.ExceptionHandler; 

@ControllerAdvice 
public class GlobalExceptionHandler {

    @ExceptionHandler(value = {IllegalArgumentException.class}) 
    public ResponseEntity<Object> handleIllegalArgumentException(IllegalArgumentException ex) {
        return new ResponseEntity<>(ex.getMessage(),  HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(value = {Exception.class}) 
    public ResponseEntity<Object> handleException(Exception ex) {
        return new ResponseEntity<>(ex.getMessage(),  HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

十、事务管理

@Transactional：用于声明事务管理。

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

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Transactional 
    public User createUser(User user) {
        return userRepository.save(user); 
    }

    @Transactional 
    public void updateUser(User user) {
        userRepository.save(user); 
    }
}

十一、日志

1.日志

  • Logback：Spring Boot 默认使用的日志框架。
  • 配置日志：通过 logback-spring.xml 或 logback.xml 配置日志。 
  • <configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"> 
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

十二、测试

1.单元测试-junit

  • import org.junit.jupiter.api.Test; 
import org.mockito.InjectMocks; 
import org.mockito.Mock; 
import org.mockito.MockitoAnnotations; 
import static org.junit.jupiter.api.Assertions.*; 
import static org.mockito.Mockito.*; 

public class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    public void testGetUserById() {
        User mockUser = new User();
        mockUser.setId(1L); 
        mockUser.setName("John  Doe");

        when(userRepository.findById(1L)).thenReturn(Optional.of(mockUser)); 

        User result = userService.getUserById(1L); 
        assertNotNull(result);
        assertEquals("John Doe", result.getName()); 
    }
}

2.集成测试-SpringBootTest

  • import org.junit.jupiter.api.Test; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.boot.test.context.SpringBootTest; 
import static org.junit.jupiter.api.Assertions.*; 

@SpringBootTest
public class UserControllerTest {

    @Autowired
    private UserController userController;

    @Test
    public void testCreateUser() {
        User user = new User();
        user.setName("John  Doe");
        user.setEmail("john.doe@example.com"); 

        User result = userController.createUser(user); 
        assertNotNull(result);
        assertEquals("John Doe", result.getName()); 
    }
}

原文地址：https://blog.csdn.net/m0_73757039/article/details/144715449

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2025