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 Swing实现扫雷小游戏

    Java Swing是Java的一个GUI（图形用户界面）框架，可以用来轻松实现各种交互式应用程序。本文将介绍如何使用Java Swing实现扫雷小游戏，并提供两个示例说明。 准备工作 要使用Java Swing来实现扫雷游戏，需要具备以下几项准备工作： Java开发环境（JDK）的安装和配置。 熟悉Java语言编程基础知识和面向对象编程思想。 熟悉Java…

    Java 2023年5月19日
    00

  • 全面了解java异常

    全面了解 Java 异常 在 Java 编程中，异常是一个不可避免的问题。当程序出现异常时，如果没有妥善的处理，会导致程序的崩溃。因此，全面了解 Java 异常是非常必要的。 什么是 Java 异常 Java 异常是指在程序运行过程中出现的错误或意外情况。Java 异常分为两种：可查异常和非可查异常。 可查异常：Java 编译器会强制程序员在代码中进行处理或…

    Java 2023年5月26日
    00

  • 详解SpringBoot工程的三种搭建方式

    我来详细讲解这个问题。首先需要注意的是，SpringBoot工程的三种搭建方式主要是指基于不同的构建工具来构建SpringBoot工程，它们分别是：Maven、Gradle和Spring Initializr。 Maven构建方式 利用Maven构建SpringBoot工程是一种非常常见的方式。具体步骤如下： 在Maven的官网下载最新版本的Maven，并安…

    Java 2023年5月15日
    00

  • 浅谈Spring Boot 微服务项目的推荐部署方式

    推荐的Spring Boot微服务项目部署方式有以下几种： 1. Docker容器化部署 Docker容器化部署是将微服务应用程序与其所有依赖项打包成Docker镜像，然后将其部署到Docker容器中。使用Docker容器化部署的优点是可以快速部署和升级应用程序，并且不会影响其它应用程序。 以下是采用Docker容器化部署Spring Boot微服务项目的一…

    Java 2023年5月15日
    00

  • Spring Security整合Oauth2实现流程详解

    Spring Security整合Oauth2实现流程详解 前言 在Web开发过程中，安全始终是一个重要的话题。为了保护我们的应用程序免受黑客、欺诈和恶意攻击，我们需要使用安全框架来保护它。在这方面，Spring Security是一个强大的框架，提供了多种身份认证和授权方式。在此基础上，我们还可以使用Oauth2协议来进行安全访问控制。 本文将介绍如何使用…

    Java 2023年5月20日
    00

  • Java运行时动态生成类实现过程详解

    Java运行时动态生成类实现过程详解 Java运行时动态生成类是一种十分强大的功能，它可以帮助我们在程序运行时生成Java类并进行动态修改和加载。在本文中，我们将深入讲解Java运行时动态生成类的实现过程，以帮助读者更好地掌握这一技术。 1. 类的动态生成 Java中，类的动态生成可以通过Java字节码实现。Java字节码是Java源代码编译后的代码，也就是…

    Java 2023年5月26日
    00

  • Springboot集成kafka高级应用实战分享

    为了让大家更好地理解 Springboot 集成 kafka 的应用，我将分别从以下几个部分展开： 环境准备 Springboot 集成 kafka 配置 生产者示例 消费者示例 1. 环境准备 首先需要确保已经正确安装了 Kafka，JDK和 Maven。然后在 pom.xml 文件中引入 Kafka client 相关依赖： <dependenci…

    Java 2023年5月20日
    00

  • Java实现小程序简单五子棋

    下面是Java实现小程序简单五子棋的完整攻略: 简介 五子棋是一种双人对弈的纯策略型棋类游戏，起源于中国古代，俗称”五子连珠”、”连五”等。本文将介绍如何利用Java实现一个简单的五子棋游戏。 步骤 1.创建项目 在Eclipse等开发工具中创建Java项目，选择Swing界面库，创建主类和GUI类。 2.设计界面 利用Swing实现GUI界面，包括棋盘、棋…

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