springboot 自定义表单自定义springbootstarter

转载

数据大侠客 2024-02-19 14:25:11

文章标签 springboot 自定义表单 spring 自定义 JSON 文章分类 架构后端开发

自定义Starter：

　　Starter会把所有用到的依赖都给包含进来，避免了开发者自己去引入依赖所带来的麻烦。Starter 提供了一种开箱即用的理念，其中核心就是springboot的自动配置原理相关，调用相关的注解实现条件判断，进而进行Bean的注入管理。

　　基于SpringBoot自动配置原理的学习，现在我们来实现一下自定义starter。我们假设有一个格式化的，暂定两个实现，一个是Object-> String,一个是Object->JSON.

1.新建一个maven工程 format-spring-boot-starter,这里的命名在SpringBoot官网有建议：For example, assume that you are creating a starter for "acme" and that you name the auto-configure module acme-spring-boot-autoconfigure and the starter acme-spring-boot-starter. If you only have one module that combines the two, name it acme-spring-boot-starter. pom文件如下：

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <version>2.1.6.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.56</version>
      <optional>true</optional><!--可选-->
    </dependency>
　　 <!--支持ConfigurationProperties-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <version>2.1.6.RELEASE</version>
      <optional>true</optional>
    </dependency>
  </dependencies>

2.构建格式化接口并且定义实现，咱们这里想实现动态注入的想过，定义两个实现以做对比：

public interface FormatProcessor {
    //定义一个格式化的方法
    <T> String format(T obj);
}
//实现1 JSON
public class JsonFormatProcessor implements FormatProcessor{
    @Override
    public <T> String format(T obj) {
        return "JsonFormatProcessor:"+ JSON.toJSONString(obj);
    }
}
//实现2 String
public class StringFormatProcessor implements FormatProcessor{

    @Override
    public <T> String format(T obj) {
        return "StringFormatProcessor:"+Objects.toString(obj);
    }
}

3.这里我们需要把这两个类根据 Conditional 注解动态注入到Spring 容器中，在springboot自动配置中我们说到有个 metadata 文件可以做过滤，而这里的 ConditionalOnClass 是一样的，只是方式不一样：

@Configuration
public class FormatAutoConfiguration {
    //metadata-auto....
    @ConditionalOnMissingClass("com.alibaba.fastjson.JSON")
    @Bean
    @Primary
    public FormatProcessor stringFormat(){
        return new StringFormatProcessor();
    }

    @ConditionalOnClass(name = "com.alibaba.fastjson.JSON")
    @Bean
    public FormatProcessor jsonFormat(){
        return new JsonFormatProcessor();
    }

}

4.我们这里参照着 jdbcTemplate 的模板来实现我们这个需求：

public class HelloFormatTemplate {

    private FormatProcessor formatProcessor;public HelloFormatTemplate(FormatProcessor formatProcessor) {this.formatProcessor = formatProcessor;
    }
　　 //定义一个格式化方法，具体的实现由FormatProcessor实现类实现
    public <T> String doFormat(T obj){
        StringBuilder stringBuilder=new StringBuilder();
        stringBuilder.append("begin:Execute format").append("<br/>");
        stringBuilder.append("Obj format result:").append(formatProcessor.format(obj)).append("<br/>");
        return stringBuilder.toString();

    }
}

5.然后我们需要动态的注入：

@Import(FormatAutoConfiguration.class)
@Configuration
public class HelloAutoConfiguration {

    @Bean
    public HelloFormatTemplate helloFormatTemplate(FormatProcessor formatProcessor){
        return new HelloFormatTemplate(formatProcessor);
    }
}

6.接下去需要在classpath下的META-INF文件夹下创建一个文件 spring.factories：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.wuzz.starter.autoconfiguration.HelloAutoConfiguration

　　然后将该工程打成Jar，然后我们需要做的是在我们需要用到这个Starter的boot项目重中导入该starter

1.导入starter，我们会看到有些starter里面是空的，其实他做的仅仅是依赖传递，这样容器中存在某个类，这个时候符合另外一个类的加载，也能起到开箱即用的效果：

<dependency>
    <groupId>com.wuzz.starter</groupId>
    <artifactId>format-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

2.定义一个实体类如下：

public class User {
    private String name;
    private int age;
　　 //省略 get set
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.我们写一个controller来测试效果：

@RestController
public class FormatController {

    @Autowired
    HelloFormatTemplate helloFormatTemplate;

    @GetMapping("/format")
    public String format(){
        User user=new User();
        user.setAge(18);
        user.setName("wuzz-starter");
        return helloFormatTemplate.doFormat(user);
    }
}

　　其他无需任何配置，我们直接启动该项目，通过 localhost:8080/format 来访问会看到以下效果：

springboot 自定义表单自定义springbootstarter_spring

　　再来，我们导入以下依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.56</version>
</dependency>

　　重启项目再去访问：

springboot 自定义表单自定义springbootstarter_spring_02

　　是不是很爽？这样子就实现了Starter的自定义，

SpringBoot外部配置：

application.properties 中可以配置很多的信息，这个就是springboot的外部配置，取决于注解 @ConfigurationProperties。

　　我们是不是也能实现这样的效果呢？答案是当然咯，那么接下去我们就基于原来的工程进行再一次的改造。

1.增加我们自定义的Properties 类：

@ConfigurationProperties(prefix="wuzz.hello.format")
public class HelloProperties {

    private String appOwner;

    private Map<String,Object> info;

    public String getAppOwner() {
        return appOwner;
    }

    public void setAppOwner(String appOwner) {
        this.appOwner = appOwner;
    }

    public Map<String, Object> getInfo() {
        return info;
    }

    public void setInfo(Map<String, Object> info) {
        this.info = info;
    }
}

2.修改HelloTemplate 如下：

public class HelloFormatTemplate {

    private FormatProcessor formatProcessor;

    private HelloProperties helloProperties;

    public HelloFormatTemplate(HelloProperties helloProperties, FormatProcessor formatProcessor) {
        this.helloProperties = helloProperties;
        this.formatProcessor = formatProcessor;
    }

    public <T> String doFormat(T obj) {

        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("begin:Execute format").append("<br/>");
        stringBuilder.append("HelloProperties:").append(helloProperties.getAppOwner()).append("<br/>")
                .append(formatProcessor.format(helloProperties.getInfo())).append("<br/>");
        stringBuilder.append("Obj format result:").append(formatProcessor.format(obj)).append("<br/>");
        return stringBuilder.toString();

    }
}

3.修改HelloAutoConfiguration如下：

@Import(FormatAutoConfiguration.class)
@EnableConfigurationProperties(HelloProperties.class)
@Configuration
public class HelloAutoConfiguration {

    @Bean
    public HelloFormatTemplate helloFormatTemplate(HelloProperties helloProperties,FormatProcessor formatProcessor){
        return new HelloFormatTemplate(helloProperties,formatProcessor);
    }
}

然后我们重新打个包，再在需要依赖的那个工程中更新导入一下maven。然后我们在application.properties中就可以实现我们的配置：

springboot 自定义表单自定义springbootstarter_springboot 自定义表单_03