简单搭建Spring Boot项目和使用

Allen-law

已于 2024-04-02 16:55:30 修改

阅读量878

点赞数 19

于 2024-03-31 01:57:08 首次发布

本文链接：https://blog.csdn.net/qq_37220201/article/details/137177038

版权

1.搭建方式：

1.1 方式一：通过idea开发工具产搭建Spring Boot项目

1.2 方式二：基于普通的Maven项目工程创建

1）pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.allen.spring</groupId>
    <artifactId>allen-spring</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.6</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
      
 </dependencies>
    
</project>

2）在resources目录目录下创建application.yml

server:
    port: 8080

3) 创建启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AllenSpringBootApplicationStart {

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

4）编写简单Controller做测试

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

@RestController
@RequestMapping("/test")
public class HelloController {

    @GetMapping("/hello")
    public String sayHello(){
        String hello = "Hello I am Allen";
        System.out.println(hello);
        return hello;
    }
}

5）简单项目结构：

2 .Spring Boot 整合其它组件三大步骤：

1) 引入组件依赖

2）编写引入组件的对应配置

3）写注解

2.1 Spring Boot 整合整合MyBatis

1) 依赖

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>

2)写配置

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/study?useSSL=false&serverTimezone=UTC
    username: root
    assword: root
    driver-class-name: com.mysql.cj.jdbc.Driver

3) 写注解

4）编写业务代码 dao、service、controller

2.2 警惕整合Spring Boot Actuator 引发的安问题具体参考以下链接：警惕 Spring Boot Actuator 引发的安全问题-腾讯云开发者社区-腾讯云 (tencent.com)

3、Spring Boot 自动装配

3.1、装配单个Bean

1） Student类

public class Student {
    
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

2) 配置类SingleConfiguration：

import com.allen.spring.config.entity.Student;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SingleConfiguration {

    @Bean
    public Student student() {
        Student student = new Student();
        student.setAge(20);
        student.setName("Allen");
        return student;
    }
}

3) 解析测试：

import com.allen.spring.config.SingleConfiguration;
import com.allen.spring.config.entity.Student;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SingleConfiguration.class);
        Student student = (Student)context.getBean("student");
        System.out.println("student name is " + student.getName());
    }
}

4）写测试controller

@RestController
@RequestMapping("/test")
public class HelloController {

    @Autowired
    private Student student;

    @GetMapping("/getStudent")
    public Object getStudent() {
        return student;
    }
}

访问地址：localhost:8080/test/getStudent

5) Spring Boot验证:@SpringBootConfiguration+@Bean RestTemplate

ps:@SpringBootApplication包含@SpringBootConfiguration

package com.allen.spring;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class AllenSpringBootApplicationStart {

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

    @Bean
    public RestTemplate restTemplate() {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setReadTimeout(180000);
        factory.setConnectTimeout(8000);
        return new RestTemplate(factory);
              
    }
}

3.2、批量配置Bean

1）配置类

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.allen.spring.service")
public class BatchConfiguration {
}

2）批量装配目标类：comc.allen.spring.service


@Service
public class OrderServiceImpl {

    public String getOrder() {
        return "深入了解JAVA";
    }
}


@Service
public class UserServiceImpl {

    public String getUserName() {
        return "Hello I am Allen";
    }
}

3）解析测试：

import com.allen.spring.config.BatchConfiguration;
import com.allen.spring.service.impl.OrderServiceImpl;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BatchConfiguration.class);
        OrderServiceImpl orderService = (OrderServiceImpl)context.getBean("orderServiceImpl");
        System.out.println(orderService.getOrder());
        for (String s : context.getBeanDefinitionNames()) {
            System.out.println(s);
        }

    }

}

4)Spring Boot验证

@SpringBootConfiguration+@ComponentScan+@Component[@Controller、@Service、
@Repository]

3.3 第三方Bean装配

3.3.1使用@Import(XXXAutoConfiguration.class)装配第三方jar指定Bean:

1-1）准备第三方jar包创建普通的maven工程，groupid为: com.allen.spring，artifact id为allen-mybatis-spring-boot-starter，其中有两个类AllenMyBatisConnection和AllenMyBatisTemplate，将其打包成一个jar包

public class AllenMyBatisConnection{
    private String url="127.0.0.1:3306";
    public void connect(){
        System.out.println("connect url : "+url);
    }
}



public class AllenMyBatisTemplate{
    public void insert(){}
    public void delete(){}
    public void update(){}
    public void select(){}
}

1-2) 在allen-mybatis-spring-boot-starter 中新建一个配置类，然后把需要交给IoC容器管理的Bean配置一下，但是要确保@Configuration能够找到，所以可以引入spring-context.jar

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.24</version>
    </dependency>
</dependencies>

@Configuration
public class AllenMybatisAutoConfiguration {
    @Bean
    public AllenMyBatisConnection allenMyBatisConnection() {
        return new AllenMyBatisConnection();
    }
}

2-1）引入第三方依赖到allen-spring中

<dependency>
    <groupId>edu.gp</groupId>
    <artifactId>allen-mybatis-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

3）在springboot工程中使用第三方jar包的bean

@RestController
@RequestMapping("/mybatis")
public class MyBatisController {
    @Resource
    private AllenMyBatisConnection allenMyBatisConnection;
    @RequestMapping("/connnect")
    public void connnect(){
        this.allenMyBatisConnection.connect();
    }
}

4）此时只需要在springboot-mybatis工程中把AllenMyBatisAutoConfiguration合并到Spring Boot的配置类中即可

@SpringBootApplication
@Import(AllenMybatisAutoConfiguration.class)
public class SpringbootMyBatisApplication {

}

3.3.2 利用SPI定制jar包合实现装配jar包指定的Bean

如果有很多starter(第三方jar包)，每次引入一个starter的时候，难道都需要手动导入 @Import(XXXAutoConfiguration.class)吗？显然很麻烦，所以不妨做个约定（SPI机制）

约定优越配置：
对于starter而言：
（1）创建META-INF/spring.factories文件
（2）通过指定的key，把配置类的信息进行配置，比如：
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.allen.AllenMybati
sAutoConfiguration
（3）看看其他starter，比如：mybatis、nacos等
对于Spring Boot项目而言，目的就是寻找所有starter中指定配置文件中的配置类：
（1）@SpringBootApplication->@EnableAutoConfiguration-
>@Import(AutoConfigurationImportSelect.class)
（2）AutoConfigurationImportSelect#getAutoConfigurationEntry-
>getCandidateConfigurations

4 条件装配

Spring Boot 条件装配原文：https://docs.spring.io/spring-boot/docs/2.7.6/reference/htmlsingle/#features.developing -auto-configuration.condition-annotations

条件装配：只有满足特定的条件，Bean才会被注入到IoC容器中

1）ConditionalOnClass：当且仅当ClassPath存在指定的Class时，才创建标记上该注解的类的实例

2）ConditionalOnBean: 当且仅当指定的bean classes and/or bean names在当前容器中,才创建标记上该注解的类的实例

3）ConditionalOnProperty：当且仅当Application.properties存在指定的配置项时，创建标记上了该注解的类的实例

4）ConditionalOnResource：在classpath下存在指定的resource时创建

5）ConditionalOnWebApplication：在web环境下创建

4.1自定义@ConditionalOnAllen条件装配

1）创建@ConditionalOnAllen注解

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
@Documented
@Conditional(OnAllenCondition.class)
public @interface ConditionalOnAllen {
}

2)创建OnAllenCondition类

public class OnAllenCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 只有当env中存在key为age，value为17的键值对时，才会自动装配
        String value = context.getEnvironment().getProperty("name");
        if (value != null && value.equals("17")) {
            return true;
        }
        return false;
    }
}

3）配置environment variables