1. Python技术站首页
  2. 其他
  3. Java

springboot 自定义启动器的实现

• Java

下面是关于“springboot 自定义启动器的实现”的攻略，包含两个示例：

一、为什么要自定义启动器

Spring Boot是一款非常流行的Java Web框架，它极大地提高了我们的开发效率。而自定义启动器则是在Spring Boot框架下进行自定义的一种方式。通常情况下，我们会将一系列相关的模块封装进一个自定义的启动器中，以便于其他项目能够更加方便的使用这些模块。而Spring Boot的自动配置机制则会在项目启动时自动加载这些模块的配置，从而降低了我们的开发难度。

二、自定义启动器的实现步骤

1.创建一个自定义的starter项目

第一步，我们需要创建一个新的Maven项目，并将其打包方式修改为pom。可以通过以下的命令快速创建一个新项目：

mvn archetype:generate -DgroupId=com.example -DartifactId=my-spring-boot-starter -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

2.添加依赖

在pom.xml文件中添加以下依赖：

  • spring-boot-starter-parent：Spring Boot的parent pom文件，可以方便的继承Spring Boot的各种功能。

  • spring-boot-autoconfigure：Spring Boot的自动化配置模块，用于自动化配置应用程序上下文。

  • spring-boot-starter：Spring Boot的基础模块，包含了 Spring 和 Spring MVC 所需的模块。

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-autoconfigure</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.1.RELEASE</version>
  </dependency>
</dependencies>

3.编写自动配置类

编写一个AutoConfiguration类，该类用于自动化配置应用程序上下文，并在Spring Boot启动时加载对应的配置。我们可以在自动配置类中定义一些Bean，以便其他项目可以进行依赖注入。

@Configuration
@ConditionalOnClass(MyService.class)
@EnableConfigurationProperties(MyProperties.class)
public class MyAutoConfiguration {
    @Autowired
    private MyProperties myProperties;

    @Bean
    @ConditionalOnMissingBean(MyService.class)
    public MyService myService() {
        MyService service = new MyService();
        service.setPrefix(myProperties.getPrefix());
        service.setSuffix(myProperties.getSuffix());
        return service;
    }
}

  • @Configuration：将该类定义为配置文件类。

  • @ConditionalOnClass：指定当类路径下存在指定的类时，该配置才会生效。

  • @EnableConfigurationProperties：启用对指定自定义属性类的支持。

  • @Autowired：自动注入MyProperties类。

  • @Bean：定义一个Bean，Bean的名称默认为方法名。

  • @ConditionalOnMissingBean：指定当没有指定名称的Bean时，才会创建该Bean。

4.编写自定义属性类

创建一个用于封装自定义属性的类，用于向用户暴露可配置的选项。

@ConfigurationProperties(prefix = "my.service")
public class MyProperties {

    private String prefix;
    private String suffix;

    public String getPrefix() {
        return prefix;
    }

    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }

    public String getSuffix() {
        return suffix;
    }

    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }
}
  • @ConfigurationProperties：指定前缀，将其与多个配置属性进行绑定。

5.创建启动器

创建一个用于引入以上两个类的启动器和Demo类。

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

6.测试启动器

编写一个测试类来测试启动器是否工作。

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyServiceTests {

    @Autowired(required=false)
    private MyService myService;

    @Test
    public void contextLoads() {
        assertThat(myService, instanceOf(MyService.class));
        assertEquals("hellomy spring boot", myService.wrap("spring boot"));
    }
}

三、应用实例1

需求：创建一个自定义启动器，封装Redis操作，使得其他项目可以更加方便的使用Redis。

1.创建一个新的Maven项目，并将其打包方式修改为pom。

2.在pom.xml文件中添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-autoconfigure</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.2</version>
    </dependency>
</dependencies>

3.编写自动配置类

RedisAutoConfiguration.java

@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
@EnableConfigurationProperties(RedisProperties.class)
@ConditionalOnClass({JedisCluster.class, RedisTemplate.class})
@ConditionalOnBean(RedisProperties.class)
public class RedisAutoConfiguration {
    @Autowired
    private RedisProperties redisProperties;

    @Bean
    public JedisConnectionFactory jedisConnectionFactory() {
        RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
        configuration.setHostName(redisProperties.getHost());
        configuration.setPort(redisProperties.getPort());
        configuration.setDatabase(redisProperties.getDatabase());
        configuration.setPassword(redisProperties.getPassword());

        JedisClientConfiguration.JedisClientConfigurationBuilder jedisClientConfiguration = JedisClientConfiguration.builder();
        jedisClientConfiguration.connectTimeout(Duration.ofMillis(redisProperties.getTimeout()));

        return new JedisConnectionFactory(configuration, jedisClientConfiguration.build());
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory jedisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(jedisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }

    @Bean
    public RedisLockAspect redisLockAspect(RedisTemplate<String, Object> redisTemplate) {
        return new RedisLockAspect(redisTemplate);
    }
}

4.编写自定义属性类

@ConfigurationProperties(prefix = "redis")
public class RedisProperties {
    private String host;
    private int port;
    private int timeout;
    private String password;
    private int database = 0;

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getDatabase() {
        return database;
    }

    public void setDatabase(int database) {
        this.database = database;
    }
}

5.创建启动器

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

四、应用实例2

需求：创建一个自定义启动器，封装常用的通用异常信息。

1.创建一个新的Maven项目，并将其打包方式修改为pom。

2.在pom.xml文件中添加以下依赖：

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

3.编写自动配置类

@Configuration
@EnableConfigurationProperties(ExceptionProperties.class)
public class ExceptionAutoConfiguration {

    @Autowired
    private ExceptionProperties exceptionProperties;

    @Bean
    public CommonExceptionHandler commonExceptionHandler() {
        return new CommonExceptionHandler(exceptionProperties.getBasePackage());
    }

}

4.编写自定义属性类

@ConfigurationProperties(prefix = "spring.exception")
public class ExceptionProperties {

    private String basePackage = "";

    public String getBasePackage() {
        return basePackage;
    }

    public void setBasePackage(String basePackage) {
        this.basePackage = basePackage;
    }
}

5.创建启动器

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

五、总结

以上是Spring Boot自定义启动器的整个过程，其核心是自动化配置类，该类包含一些Bean定义和属性自动装配。自定义启动器可以方便地对一些功能进行封装，方便其他项目复用。如果您刚开始学习Spring Boot，我建议您先尝试完成一个简单的示例，从而熟悉Spring Boot的有关概念和技术。如果您在实践过程中遇到问题，可以查找相关文档或在社区中询问，不要放弃。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：springboot 自定义启动器的实现 - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年5月19日
下一篇 2023年5月19日

相关文章

  • Java实现的简单音乐播放器功能示例

    下面我将为你讲解“Java实现的简单音乐播放器功能示例”的完整攻略。 需求分析 在实现一个音乐播放器之前，首先要明确该播放器需要实现哪些功能。可以列出以下需求： 能够载入音乐文件并播放。 能够停止、暂停播放。 提供音量调节功能。 提供进度调节功能。 能够显示正在播放的音乐文件名和剩余时间。 能够自动切换下一首歌曲。 实现步骤 创建一个主窗口，并添加播放器控制…

    Java 2023年5月19日
    00

  • 分析SpringBoot的启动原理

    下面我会详细地讲解分析Spring Boot启动原理的攻略，内容如下。 什么是Spring Boot Spring Boot 是一个基于Spring Framework构建的用于快速构建Web应用程序和微服务的开源框架。 Spring Boot的主要目的是简化Spring的配置和开发过程。Spring Boot集成了Spring框架，内嵌了Tomcat、Je…

    Java 2023年5月15日
    00

  • Java axios与spring前后端分离传参规范总结

    Java axios与Spring前后端分离传参规范总结 本攻略主要介绍了在Java axios与Spring前后端分离的开发中，如何进行传参规范。 一、传参规范 在前后端分离的开发中，一般通过JSON格式传递参数。在发送请求时，需要规范JSON数据的格式，保证后端能够正确解析参数。 以axios请求为例，将参数封装在data属性中，如下： javascri…

    Java 2023年6月3日
    00

  • Java持久化框架Hibernate与Mybatis优劣及选择详解

    Java持久化框架Hibernate与Mybatis优劣及选择详解 1. 什么是Java持久化框架？ Java持久化框架是为了简化Java应用程序与关系型数据库之间数据交互的过程所设计的一套框架。通过使用Java持久化框架，在Java应用程序中可以通过对象来操作数据库，这样可以实现面向对象编程与关系型数据库的无缝对接。 2. Hibernate与Mybati…

    Java 2023年5月31日
    00

  • Java之Arrays的各种功能和用法总结

    Java之Arrays的各种功能和用法总结 简介 Java中的Arrays类提供了一组用于操作数组的静态方法。Arrays类中的方法支持对数组的排序、搜索、比较、填充和转换等操作，该类还提供了一个asList()方法来创建一个ArrayList. 方法列表 下面是Arrays类中一些常用方法的列表： 方法 描述 sort() 对数组进行排序。 binaryS…

    Java 2023年5月26日
    00

  • Java算法练习题,每天进步一点点(1)

    首先，对于这篇题解的标题，可以使用一二级标题展示： Java算法练习题,每天进步一点点(1) 题意说明 本练习题题目数量较多，可根据自己的情况自行选择练习。本文以题目1为例： 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。 示例1： 输入: “abcabcbb”输出: 3解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。 示…

    Java 2023年5月19日
    00

  • java8中的lambda表达式简介

    首先我们来介绍一下Java 8中的Lambda表达式。Lambda表达式是一种新的语言特性，也是Java 8引入的最为重要的新特性之一。它简化了代码编写的难度，可以使代码更加简洁、易读。在Java 8之前，“匿名内部类”是开发人员实现不同功能所必须使用的主要方式。但是，使用匿名内部类的语法造成了很多冗余的代码，让代码可读性下降，而使用Lambda表达式可以使…

    Java 2023年5月26日
    00

  • Java简易计算器程序设计

    下面我就给您讲解Java简易计算器程序设计的完整攻略。 1. 确定需求 在开始设计Java简易计算器程序之前，我们需要先明确需求，即我们要实现什么样的功能。在这里，我们可以列出计算器程序的基本功能： 支持基本的加减乘除四则运算 支持小数计算 支持括号功能 2. 设计代码框架 在明确需求之后，我们需要开始设计Java程序的代码框架。我们可以将计算器程序分成以下…

    Java 2023年5月23日
    00
合作推广
合作推广
分享本页
返回顶部