SpringBoot

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

<!--父项目-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.6</version>
</parent>
<!--web工程依赖-->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

1
2
3
4
5
6
7
8

//声明这是一个SpringBoot工程
@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        //运行main方法即可让整个工程运行 不再需要配置tomcat服务器
        SpringApplication.run(Main.class, args);
    }
}

1
2
3
4
5
6
7
8

//声明一个Controll类 类中所有方法的返回值都会原样返回给客户端
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello springboot";
    }
}

1
2

server:
  port: 8088

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
    		 <configuration>
    			<!--设置主类-->
    			<mainClass>com.xinnn.boot.Main</mainClass>
    		</configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

1
2
3
4
5
6
7
8

<!--
	自定义版本号
	1.在 spring-boot-dependencies 里面查看规定该插件版本使用的 key
	2.在当前pom文件中重写
-->
<properties>
    <mysql.version>8.0.1</mysql.version>
</properties>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

/**
 * 声明这是一个配置类
 * @Configuration(proxyBeanMethods = true)
 * proxyBeanMethods：代理bean的方法
 *      等于 true 时，是full模式，每个bean方法返回的对象都是单例的
 *      等于 false 时，是lite模式，每个bean方法返回的对象都是新创建的
 *		类组件之间无依赖关系使用lite模式，加速启动；有依赖使用full模式 确保得到的是同一个
 */
@Configuration(proxyBeanMethods = true)
public class SpringConfig {

    @Bean //在容器中添加组件 组件的id等于方法的名字 类型是方法的返回类型
    public User user(){
        User user = new User("张三", 18);
        //user组件依赖于cat组件 设置proxyBeanMethods=true 确保依赖的组件是同一个。
        user.setCat = (cat());
        return user;
    }
    @Bean("tom") //自定义id cat方法在容器中的id为 tom
    public Cat cat(){
        return new Cat("小黑");
    }
}
//测试代码
//scanBasePackages 指定扫描组件的包 默认为主类同级和子包
@SpringBootApplication(scanBasePackages = "com.xinnn")
public class Main {
    public static void main(String[] args) {
        //获取IOC容器
        ConfigurableApplicationContext applicationContext = SpringApplication.run(Main.class, args);
        //获取容器中所有组件的id
        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        //获取user组件
        User user = applicationContext.getBean("user", User.class);
        //获取cat组件
        Cat cat = applicationContext.getBean("tom", Cat.class);
    }
}

1
2

//在容器中创建这两个类型的组件，默认id是类的全类名
@Import({User.class, Date.class}) 

1
2
3
4

//条件装配 条件满足时才执行 这是根注解 有非常多的派生注解 可以被标识在方法和类上
@Conditional
//容器中存在名称为tom的组件时才会执行被标识的方法或类
@ConditionalOnBean(name = "tom")

1
2

//通过配置文件导入bean
@ImportResource("classpath:spring.xml")

1
2
3
4
5
6
7
8

//声明一个组件
@Component
//配置绑定 properties文件中配置的前缀 car.name=byd
@ConfigurationProperties(prefix = "car")
public class Car{
    //自动赋值为 byd
    private String name;
}

1
2
3
4
5

//在配置类上声明 Car类会自动注册为容器中的组件并开始配置绑定
@EnableConfigurationProperties(Car.class)

//在Car类上声明 用法同上
@ConfigurationProperties(prefix = "car")

1
2
3
4
5

@SpringBootApplication
//这个注解可以被拆分为
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

1
2

@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//配置文件上传解析器
@Bean
//容器中有这个组件
@ConditionalOnBean(MultipartResolver.class)
//容器中没有这个名字 multipartResolver 的组件
@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME) 
public MultipartResolver multipartResolver(MultipartResolver resolver) {
    //给@Bean标注的方法传入了对象参数，这个参数的值就会从容器中找。
    //相当于对原有的对象进行重命名 文件上传解析器的名字需要符合规范
    return resolver;
}

1
2
3
4
5

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

1
2
3
4
5

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-configuration-processor</artifactId>
  <optional>true</optional>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

spring:
  mvc:
  	# 添加访问前缀
  	# 此时访问静态资源链接为 项目地址 + 访问前缀 + 资源名
    static-path-pattern: /sta/**
  web:
    resources:
      # 自定义静态资源目录 数组类型
      static-locations: classpath:/zystatic
      # 禁用所有静态资源
      add-mappings: false

1
2
3
4
5

spring:
  mvc:
    hiddenmethod:
      filter:
        enabled: true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

//WebMvcConfigurer 重写其中的addFormatters方法 添加自定义的参数解析器
@Override
public void addFormatters(FormatterRegistry registry) {
    //Converter负责将请求参数转换为指定的数据类型 将String转为Book类型
    registry.addConverter(new Converter<String, Book>(){
        @Override
        //具体的转换方法
        public Book convert(String source) {
            String[] stu = source.split(",");
            Integer id = Integer.parseInt(stu[0]);
            return new Book(id, stu[1]);
        }
    });
}

//具体的请求 为Post请求 Student类包含了的一个Book类的实体类型 通过一个参数为Book类的两个属性赋值
http://localhost:8088/test/stu?id=1&name=jony&age=18&book=2,语文

1
2
3
4
5

//开启
spring:
  mvc:
    contentnegotiation:
      favor-parameter: true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//添加根据标头请求协议的自定义协议
//WebMvcConfigurer中的extendMessageConverters方法
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
    //要定义协议支持的类型 也可以为Object
    converters.add(new HttpMessageConverter<Book>() {
        @Override
        public List<MediaType> getSupportedMediaTypes(Class<?> clazz) {
            return HttpMessageConverter.super.getSupportedMediaTypes(clazz);
        }
        @Override
        //是否可读 用于请求参数的转换
        public boolean canRead(Class<?> clazz, MediaType mediaType) {
            return false;
        }
        @Override
        //是否可写 用于返回参数的转换
        public boolean canWrite(Class<?> clazz, MediaType mediaType) {
            return clazz.isAssignableFrom(Book.class);
        }
        @Override
        //支持的协议
        public List<MediaType> getSupportedMediaTypes() {
            //自定义的协议名称
            return MediaType.parseMediaTypes("application/x-xin");
        }
        @Override
        public Book read(Class<? extends Book> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
            return null;
        }
        @Override
        //转换方法的具体实现
        public void write(Book book, MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
            //通过反射获取类中的所有参数
            Class bookClass = book.getClass();
            Field[] bookFields = bookClass.getDeclaredFields();
            StringBuilder msg = new StringBuilder();
            for(Field field : bookFields){
                field.setAccessible(true);
                try {
                    Object bookObj = field.get(book);
                    //将参数拼接起来 中间用;分隔
                    msg.append(String.valueOf(bookObj)).append(";");
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
            }
            //将主体内容返回给客户端
            outputMessage.getBody().write(msg.toString().getBytes());
        }
    });
}

//添加根据请求参数的自定义协议
@Override
public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
    Map<String, MediaType> map = new HashMap<>();
    //添加数据类型 原生支持的json和xml也必须添加
    //设置请求参数的自定义媒体类型处理器时 必须先添加该协议
    map.put("xin", MediaType.parseMediaType("application/x-xin"));
    map.put("json", MediaType.APPLICATION_JSON);
    map.put("xml", MediaType.APPLICATION_XML);
    //根据请求参数的解析器
    ParameterContentNegotiationStrategy parameterContentNegotiationStrategy = new ParameterContentNegotiationStrategy(map);
    //根据标头的解析器 不设置的话无法通过标头进行内容协商
    HeaderContentNegotiationStrategy headerContentNegotiationStrategy = new HeaderContentNegotiationStrategy();
    //把新生成的解析器添加到配置中
    configurer.strategies(Arrays.asList(parameterContentNegotiationStrategy, headerContentNegotiationStrategy));
}

1
2
3
4
5

//请求必须为Post 前端form表单要设置 enctype="multipart/form-data"
@PostMapping("/upload")
//@RequestPart("author")文件输入框的name属性值 使用MultipartFile[]接受多个文件
public String uploadFile(@RequestParam("email") String email, @RequestParam("username") String username,
                         @RequestPart("author")MultipartFile author, @RequestPart("imgs") MultipartFile[] imgs) throws IOException {}

1
2
3
4
5
6
7

spring:
  servlet:
    multipart:
     # 单个文件最大大小
      max-file-size: 10MB
      # 单次上传总文件 最大大小
      max-request-size: 100MB

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

//1、声明异常处理类
@ControllerAdvice
public class MyExceptionHandler {
    //该方法能够处理的异常类型
    @ExceptionHandler({NullPointerException.class, ArrayIndexOutOfBoundsException.class})
    public String nullExceptionHandler(){
        return "error";
    }
}

//2、自定义异常处理类 当抛出这个自定义异常时 会返回 value状态码和自定义的消息 message
@ResponseStatus(value = HttpStatus.CONFLICT, reason = "message")
public class ResponeException extends RuntimeException{
    public ResponeException(String message){
        super(message);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

@Component
//优先级为最高 不然会被默认的异常处理器处理
@Order(value = Ordered.HIGHEST_PRECEDENCE)
public class CustomException implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        try {
            //直接返回错误码和错误消息
            response.sendError(512, "error");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        //返回一个ModelAndView对象 不然上层方法会忽略当前异常处理器并继续执行下一个
        return new ModelAndView();
    }
}

1
2
3
4
5
6
7
8
9

spring:
  datasource:
    url: jdbc:postgresql://120.46.151.166:5432/zhsx
    username: lisang
    password: 00000...
    driver-class-name: org.postgresql.Driver
    max-active: 10
    # 开启Druid的Sql统计和Sql防火墙
    filters: stat, wall

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

@Configuration
//Druid数据源的配置类
public class DruidDatasourceConfig {
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dataSource() throws SQLException {
        DruidDataSource dataSource = new DruidDataSource();
        //开启了配置文件绑定 参数直接写在配置文件中即可
//        dataSource.setUrl("//");
//        dataSource.setMaxActive(10);
//        dataSource.setFilters("stat, wall");
        return dataSource;
    }
    //配置Druid的监控面板
    @Bean
    public ServletRegistrationBean<StatViewServlet> statViewServlet(){
        StatViewServlet servlet = new StatViewServlet();
        ServletRegistrationBean<StatViewServlet> druidServlet = new ServletRegistrationBean<>(servlet, "/druid/*");
        druidServlet.addInitParameter("loginUsername", "admin");
        druidServlet.addInitParameter("loginPassword", "admin");
        return druidServlet;
    }
    //配置Druid的Web统计
    @Bean
    public FilterRegistrationBean<WebStatFilter> webStatFilter(){
        WebStatFilter statFilter = new WebStatFilter();
        FilterRegistrationBean<WebStatFilter> druidWebStatFilter = new FilterRegistrationBean<>(statFilter);
        druidWebStatFilter.addUrlPatterns("/*");
        druidWebStatFilter.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        return druidWebStatFilter;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

mybatis:
  # mapper接口配置文件所在的路径
  mapper-locations: classpath:mappers/*.xml
  # config-location 和 configuration 不能同时存在
  # config-location: classpath:mybatis/
  # 驼峰映射
  type-aliases-package: com.xinnn.boot.pojo
  # 配置文件中的配置项
  configuration:
    map-underscore-to-camel-case: true

1
2
3
4
5
6

@Mapper
public interface ScenicMapper {
    @Select("select * from t_scenic where id = #{id}")
    //可以通过 @Options 注解开启一直在sql标签里的配置
    Scenic getScenic(@Param("id") Integer id);
}

1
2
3
4

@Select("select * from t_scenic where id = #{id}")
Scenic getScenic(@Param("id") Integer id);

void deleteScenicById(@Param("id") Integer id);

1
2
3

<delete id="deleteScenicById">
    delete from t_scenic where id = #{id}
</delete>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

spring:
  # reids的配置都在 spring.redis 下
  redis:
    host: localhost
    password: 00000...
    port: 6379
    database: 0
    # 声明 redisTempletes底层要使用那个客户端操作redis lettuce和jedis是可选的 lettuce默认选择
    # 如果需要使用 jedis 那么还需要导入jedis的依赖
    client-type: lettuce
    lettuce:
      pool:
        max-active: 10

1
2
3
4

//对redis的简单操作
ValueOperations<String, String>  redisStringTemplate = redisTemplate.opsForValue();
redisStringTemplate.set("hello", "world");
String hello = redisStringTemplate.get("hello");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//在测试类上标注了 @SpringBootTest 后，这个测试类会以Spring的单元测试驱动运行，可以使用Spring的全部功能
@SpringBootTest
public class MyTest {
    
    @Test
    //测试方法完成后 事务会自动回滚
    @Transactional
    public void redisTest(){
        System.out.println("1");
    }
}

1
2
3
4
5
6

@Test
@DisplayName("前置条件")
public void test(){
    Assumptions.assumeTrue(1 == 2);
    System.out.println("ok");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

@DisplayName("A stack")
class TestingAStackDemo {

    Stack<Object> stack;

    @Test
    @DisplayName("is instantiated with new Stack()")
    void isInstantiatedWithNew() {
        new Stack<>();
    }

    @Nested
    @DisplayName("when new")
    class WhenNew {

        @BeforeEach
        //内部类的方法执行时 会先 new 一个 Stack
        void createNewStack() {
            stack = new Stack<>();
        }

        @Test
        @DisplayName("is empty")
        void isEmpty() {
            //因为先 new 了一个 Stack 并且里面现在还没有任何元素 断言通过
            assertTrue(stack.isEmpty());
        }

        @Test
        @DisplayName("throws EmptyStackException when popped")
        void throwsExceptionWhenPopped() {
            //现在 stack 里面没有任何元素 无法调用stack的pop方法弹出一个元素 抛出EmptyStackException异常 断言通过
            assertThrows(EmptyStackException.class, stack::pop);
        }

        @Test
        @DisplayName("throws EmptyStackException when peeked")
        void throwsExceptionWhenPeeked() {
            //同上
            assertThrows(EmptyStackException.class, stack::peek);
        }

        @Nested
        @DisplayName("after pushing an element")
        class AfterPushing {

            String anElement = "an element";

            @BeforeEach
            void pushAnElement() {
                stack.push(anElement);
            }

            @Test
            @DisplayName("it is no longer empty")
            void isNotEmpty() {
                //执行方法会向调用外部的 createNewStack() 在执行内部的 @BeforeEach 这时stack不为空了
                assertFalse(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when popped and is empty")
            void returnElementWhenPopped() {
                //stack可以弹出一个元素
                assertEquals(anElement, stack.pop());
                //弹出一个元素后里面又空了
                assertTrue(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when peeked but remains not empty")
            void returnElementWhenPeeked() {
                //同上
                assertEquals(anElement, stack.peek());
                assertFalse(stack.isEmpty());
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

@ParameterizedTest
@DisplayName("int入参")
//使用基本类型作为入参
@ValueSource(ints = {1,2,3,4})
public void testValueSource(int i){
    System.out.println(i);
}

//使用方法返回值作为入参
@ParameterizedTest
@DisplayName("method入参")
@MethodSource("getAllUser")
public void testMethodSource(User user){
    System.out.println(user.getUsername());
    System.out.println(user.getPassword());
}
static Stream<User> getAllUser(){
    User user = new User("admin", "admin");
    return Stream.of(user);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//判断网络是否联通
@Component
public class NetworkHealthIndicator extends AbstractHealthIndicator {
    @Override
    protected void doHealthCheck(Health.Builder builder) throws Exception {
        Map<String, String> map = new HashMap<>();
        long startTime = System.currentTimeMillis();
        boolean bl = InetAddress.getByName("120.46.151.166").isReachable(3000);
        long time = System.currentTimeMillis() - startTime;
        if(bl){
            //up表示健康状况良好
            builder.up();
            map.put("msg", "网络连接正常");
            map.put("120.16.151.166", "连接耗时" + time + "毫秒");
        }else{
            //down表示宕机
            builder.down();
            map.put("msg", "网络连接失败");
        }
        //往builder中添加消息体
        builder.withDetails(map);
    }
}

1
2
3
4
5
6
7
8
9

@Component
//需要继承 InfoContributor 接口
public class MyInfoContributor implements InfoContributor {
    @Override
    public void contribute(Info.Builder builder) {
        //添加信息
        builder.withDetail("appName", "admin").withDetail("appVersion", "1.0");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

@Service
public class ScenicService {
    @Autowired
    private ScenicMapper scenicMapper;
    Counter counter;
    public ScenicService(MeterRegistry meterRegistry){
        //计数的指标监控
        counter = meterRegistry.counter("scenicServer.getScenic.count");
    }
    public Scenic getScenic(Integer id){
        //每次访问这个方法就加1
        counter.increment();
        return scenicMapper.getScenic(id);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

@Component
//这里的id就是后面访问的路径
@Endpoint(id = "main")
public class MyEndpoint {
    @ReadOperation
    public Map<String, String> getMyEndpoint(){
        Map<String, String> map = new HashMap<>();
        map.put("msg", "ok");
        //map会被序列化为json响应给客户端
        return map;
    }
    @WriteOperation
    public void stopMyEndpoint(){
        System.out.println("stop");
    }
}