starter_starter使用手册 - CSDN
精华内容
参与话题
  • Spring Boot Starter 理解

    万次阅读 2019-05-10 13:01:37
    Spring Boot Starter是在SpringBoot组件中被提出来的一种概念,stackoverflow上面已经有人概括了这个starter是什么东西,想看完整的回答戳这里 Starter POMs are a set of convenient dependency descriptors that...

    Spring Boot Starter是在SpringBoot组件中被提出来的一种概念,stackoverflow上面已经有人概括了这个starter是什么东西,想看完整的回答戳这里

    Starter POMs are a set of convenient dependency descriptors that you can include in your application. You get a one-stop-shop for all the Spring and related technology that you need, without having to hunt through sample code and copy paste loads of dependency descriptors. For example, if you want to get started using Spring and JPA for database access, just include the spring-boot-starter-data-jpa dependency in your project, and you are good to go.

    大概意思就是说starter是一种对依赖的synthesize(合成),这是什么意思呢?我可以举个例子来说明。

    传统的做法

    在没有starter之前,假如我想要在Spring中使用jpa,那我可能需要做以下操作:

    1. 在Maven中引入使用的数据库的依赖(即JDBC的jar)
    2. 引入jpa的依赖
    3. 在xxx.xml中配置一些属性信息
    4. 反复的调试直到可以正常运行

    需要注意的是,这里操作在我们每次新建一个需要用到jpa的项目的时候都需要重复的做一次。也许你在第一次自己建立项目的时候是在Google上自己搜索了一番,花了半天时间解决掉了各种奇怪的问题之后,jpa终于能正常运行了。有些有经验的人会在OneNote上面把这次建立项目的过程给记录下来,包括操作的步骤以及需要用到的配置文件的内容,在下一次再创建jpa项目的时候,就不需要再次去Google了,只需要照着笔记来,之后再把所有的配置文件copy&paste就可以了。

    像上面这样的操作也不算不行,事实上我们在没有starter之前都是这么干的,但是这样做有几个问题:

    1. 如果过程比较繁琐,这样一步步操作会增加出错的可能性
    2. 不停地copy&paste不符合Don’t repeat yourself精神
    3. 在第一次配置的时候(尤其如果开发者比较小白),需要花费掉大量的时间

    使用Spring Boot Starter提升效率

    starter的主要目的就是为了解决上面的这些问题。

    starter的理念:starter会把所有用到的依赖都给包含进来,避免了开发者自己去引入依赖所带来的麻烦。需要注意的是不同的starter是为了解决不同的依赖,所以它们内部的实现可能会有很大的差异,例如jpa的starter和Redis的starter可能实现就不一样,这是因为starter的本质在于synthesize,这是一层在逻辑层面的抽象,也许这种理念有点类似于Docker,因为它们都是在做一个“包装”的操作,如果你知道Docker是为了解决什么问题的,也许你可以用Docker和starter做一个类比。

    starter的实现:虽然不同的starter实现起来各有差异,但是他们基本上都会使用到两个相同的内容:ConfigurationProperties和AutoConfiguration。因为Spring Boot坚信“约定大于配置”这一理念,所以我们使用ConfigurationProperties来保存我们的配置,并且这些配置都可以有一个默认值,即在我们没有主动覆写原始配置的情况下,默认值就会生效,这在很多情况下是非常有用的。除此之外,starter的ConfigurationProperties还使得所有的配置属性被聚集到一个文件中(一般在resources目录下的application.properties),这样我们就告别了Spring项目中XML地狱。

    starter的整体逻辑:

    上面的starter依赖的jar和我们自己手动配置的时候依赖的jar并没有什么不同,所以我们可以认为starter其实是把这一些繁琐的配置操作交给了自己,而把简单交给了用户。除了帮助用户去除了繁琐的构建操作,在“约定大于配置”的理念下,ConfigurationProperties还帮助用户减少了无谓的配置操作。并且因为 application.properties 文件的存在,即使需要自定义配置,所有的配置也只需要在一个文件中进行,使用起来非常方便。

    了解了starter其实就是帮助用户简化了配置的操作之后,要理解starter和被配置了starter的组件之间并不是竞争关系,而是辅助关系,即我们可以给一个组件创建一个starter来让最终用户在使用这个组件的时候更加的简单方便。基于这种理念,我们可以给任意一个现有的组件创建一个starter来让别人在使用这个组件的时候更加的简单方便,事实上Spring Boot团队已经帮助现有大部分的流行的组件创建好了它们的starter,你可以在这里查看这些starter的列表。

    创建自己的Spring Boot Starter

    如果你想要自己创建一个starter,那么基本上包含以下几步

    1. 创建一个starter项目,关于项目的命名你可以参考这里
    2. 创建一个ConfigurationProperties用于保存你的配置信息(如果你的项目不使用配置信息则可以跳过这一步,不过这种情况非常少见)
    3. 创建一个AutoConfiguration,引用定义好的配置信息;在AutoConfiguration中实现所有starter应该完成的操作,并且把这个类加入spring.factories配置文件中进行声明
    4. 打包项目,之后在一个SpringBoot项目中引入该项目依赖,然后就可以使用该starter了

    我们来看一个例子(例子的完整代码位于https://github.com/RitterHou/learn-spring-boot-starter

    首先新建一个Maven项目,设置 pom.xml 文件如下:

    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
    
    <?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>
        <artifactId>http-starter</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    
        <!-- 自定义starter都应该继承自该依赖 -->
        <!-- 如果自定义starter本身需要继承其它的依赖,可以参考 https://stackoverflow.com/a/21318359 解决 -->
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starters</artifactId>
            <version>1.5.2.RELEASE</version>
        </parent>
    
        <dependencies>
            <!-- 自定义starter依赖此jar包 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
            <!-- lombok用于自动生成get、set方法 -->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.16.10</version>
            </dependency>
        </dependencies>
    
    </project>
    

     

    创建proterties类来保存配置信息:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    
    @ConfigurationProperties(prefix = "http") // 自动获取配置文件中前缀为http的属性,把值传入对象参数
    @Setter
    @Getter
    public class HttpProperties {
    
        // 如果配置文件中配置了http.url属性,则该默认属性会被覆盖
        private String url = "http://www.baidu.com/";
    
    }
    

     

    上面这个类就是定义了一个属性,其默认值是 http://www.baidu.com/,我们可以通过在 application.properties 中添加配置 http.url=https://www.zhihu.com 来覆盖参数的值。

    创建业务类:

    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
    
    @Setter
    @Getter
    public class HttpClient {
    
        private String url;
    
        // 根据url获取网页数据
        public String getHtml() {
            try {
                URL url = new URL(this.url);
                URLConnection urlConnection = url.openConnection();
                BufferedReader br = new BufferedReader(new InputStreamReader(urlConnection.getInputStream(), "utf-8"));
                String line = null;
                StringBuilder sb = new StringBuilder();
                while ((line = br.readLine()) != null) {
                    sb.append(line).append("\n");
                }
                return sb.toString();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return "error";
        }
    
    }
    

     

    这个业务类的操作非常简单,只包含了一个 url 属性和一个 getHtml 方法,用于获取一个网页的HTML数据,读者看看就懂了。

    创建AutoConfiguration

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    
    @Configuration
    @EnableConfigurationProperties(HttpProperties.class)
    public class HttpAutoConfiguration {
    
        @Resource
        private HttpProperties properties; // 使用配置
    
        // 在Spring上下文中创建一个对象
        @Bean
        @ConditionalOnMissingBean
        public HttpClient init() {
            HttpClient client = new HttpClient();
    
            String url = properties.getUrl();
            client.setUrl(url);
            return client;
        }
    
    }
    

     

    在上面的AutoConfiguration中我们实现了自己要求:在Spring的上下文中创建了一个HttpClient类的bean,并且我们把properties中的一个参数赋给了该bean。
    关于@ConditionalOnMissingBean 这个注解,它的意思是在该bean不存在的情况下此方法才会执行,这个相当于开关的角色,更多关于开关系列的注解可以参考这里

    最后,我们在 resources 文件夹下新建目录 META-INF,在目录中新建 spring.factories 文件,并且在 spring.factories 中配置AutoConfiguration:

    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    com.nosuchfield.httpstarter.HttpAutoConfiguration
    

    到此,我们的starter已经创建完毕了,使用Maven打包该项目。之后创建一个SpringBoot项目,在项目中添加我们之前打包的starter作为依赖,然后使用SringBoot来运行我们的starter,代码如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    
    @Component
    public class RunIt {
    
        @Resource
        private HttpClient httpClient;
    
        public void hello() {
            System.out.println(httpClient.getHtml());
        }
    
    }
    

     

    正常情况下此方法的执行会打印出url http://www.baidu.com/ 的HTML内容,之后我们在application.properties中加入配置:

    http.url=https://www.zhihu.com/
    

    再次运行程序,此时打印的结果应该是知乎首页的HTML了,证明properties中的数据确实被覆盖了。

     

    本文链接: http://www.nosuchfield.com/2017/10/15/Spring-Boot-Starters/

    展开全文
  • 自己实现一个Starter

    2019-11-05 11:25:01
    SpringBoot自动配置中Starter的原理,自己实现一个,测试用例

    自己实现一个Starter

    自己实现SpringBoot里面的Starter

    原理

    一个公用是starter我们只需要引入pom文件,SpringBoot就会进行自动配置。那么SpringBoot是如何知道要实例化哪些类,并进行简单配置呢?

    1. 首先,SpringBoot在启动时会去依赖的Starter包中寻找resources/META-INF/spring.factories 文件,然后根据文件中配置的Jar包去扫描项目所依赖的Jar包,这类似于 Java 的 SPI 机制。

    2. 第二步,根据 spring.factories配置加载AutoConfigure

    3. 最后,根据 @Conditional注解的条件,进行自动配置并将Bean注入Spring Context 上下文当中。

      我们也可以使用@ImportAutoConfiguration({MyServiceAutoConfiguration.class}) 指定自动配置哪些类。

    可以认为starter是一种服务——使得使用某个功能的开发者不需要关注各种依赖库的处理,不需要具体的配置信息, 由Spring Boot自动通过classpath路径下的类发现需要的Bean,并织入相应的Bean。举个栗子,spring-boot-starter-jdbc这个starter的存在, 使得我们只需要在BookPubApplication下用@Autowired引入DataSource的bean就可以,Spring Boot会自动创建DataSource的实例。

    核心知识

    1. @Conditional注解

    核心就是条件注解 @Conditional ,使用方式如下

    //当项目当前Classpath存在 HelloService的时候 后面的配置才生效
    @ConditionalOnClass(HelloService.class)
    public class HelloServiceAutoConfiguration {}
    

    SpringBoot许多源码里面,都会出现条件注解,这就是Starter配置的核心之一。

    1. spring.factories 文件,这个是springboot启动会扫描的文件,然后寻找所依赖的jar包,写法如下
    org.springframework.boot.autoconfigure.EnableAutoConfiguration = 
    //等于号后面是定义的starter的路径
    com.example.autocinfigure.StarterAutoConfigure
    

    这里举个栗子:我们自己开发项目引入的mybatis-starter如下
    同样能看到mybatis的spring.factories文件
    同样能看到mybatis的spring.factories文件

    打开后,如下

    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

    开发自己的Starter

    所谓starter,就是一个普通的Maven项目

    我们要实现的starter很简单, 提供一个Service, 包含一个sayHello() 方法

    主要分为下面几步骤

    1. 创建Maven项目
    2. 编写service
    3. 编写属性类
    4. 编写自动配置类
    5. 创建spring.factories文件,打包

    创建Maven工程

    新建一个普通Maven项目

    • 命名:这里说下artifactId的命名问题,Spring 官方 Starter通常命名为spring-boot-starter-{name}spring-boot-starter-web

      Spring官方建议非官方Starter命名应遵循{name}-spring-boot-starter的格式。

    • 注意其中 spring-boot-configuration-processor 的作用是编译时生成spring-configuration-metadata.json, 此文件主要给IDE使用,用于提示使用。如在intellij idea中,当配置此jar相关配置属性在application.yml, 你可以用ctlr+鼠标左键,IDE会跳转到你配置此属性的类中。

    <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.xncoding</groupId>
        <artifactId>simple-spring-boot-starter</artifactId>
        <version>1.0.0-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <name>simple-spring-boot-starter</name>
        <description>一个简单的自定义starter</description>
        <url>http://maven.apache.org</url>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <java.version>1.8</java.version>
        </properties>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.4.RELEASE</version>
        </parent>
    
    
        <dependencies>
            <!-- @ConfigurationProperties annotation processing (metadata for IDEs)
                     生成spring-configuration-metadata.json类,需要引入此类-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-autoconfigure</artifactId>
            </dependency>
        </dependencies>
    </project>
    

    编写Servcie

    public class ExampleService {
    
        private String prefix;
        private String suffix;
    
        public ExampleService(String prefix, String suffix) {
            this.prefix = prefix;
            this.suffix = suffix;
        }
        public String wrap(String word) {
            return prefix + word + suffix;
        }
    }
    

    编写配置属性类

    @ConfigurationProperties("example.service")
    public class ExampleServiceProperties {
        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;
        }
    }
    

    其中@ConfigurationPropeties 注解是读取 application.yml中 以 example.service 开头的属性

    编写自动配置类

    @Configuration
    @ConditionalOnClass(ExampleService.class)
    @EnableConfigurationProperties(ExampleServiceProperties.class)
    public class ExampleAutoConfigure {
    
        private final ExampleServiceProperties properties;
    
        @Autowired
        public ExampleAutoConfigure(ExampleServiceProperties properties) {
            this.properties = properties;
        }
    
        @Bean
        @ConditionalOnMissingBean
        @ConditionalOnProperty(prefix = "example.service", value = "enabled",havingValue = "true")
        ExampleService exampleService (){
            return  new ExampleService(properties.getPrefix(),properties.getSuffix());
        }
    
    }
    

    解释下用到的几个和Starter相关的注解:

    1. @ConditionalOnClass,当classpath下发现该类的情况下进行自动配置。
    2. @ConditionalOnMissingBean,当Spring Context中不存在该Bean时。
    3. @ConditionalOnProperty(prefix = "example.service",value = "enabled",havingValue = "true"),当配置文件中example.service.enabled=true时。
    

    最后一步:添加spring.factories文件

    最后一步,在resources/META-INF/下创建spring.factories文件,内容供参考下面:

    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    com.xncoding.starter.config.ExampleAutoConfigure
    

    如果有多个自动配置类,用逗号分隔换行即可。

    OK,完事,运行 mvn:install 打包安装,一个Spring Boot Starter便开发完成了。

    测试

    打包好了当然要测试一下看看了。另外创建一个SpringBoot工程,在maven中引入这个starter依赖, 然后在单元测试中引入这个Service看看效果。

    <dependency>
        <groupId>com.xncoding</groupId>
        <artifactId>simple-spring-boot-starter</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </dependency>
    

    修改application.yml配置文件,添加如下内容:

    example.service:
      enabled: true
      prefix: ppp
      suffix: sss
    

    测试类

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class ApplicationTests {
        @Autowired
        private ExampleService exampleService;
    
        @Test
        public void testStarter() {
            System.out.println(exampleService.wrap("hello"));
        }
    }
    

    运行结果

    ppphellosss
    
    展开全文
  • SpringBoot四大神器之Starter

    千次阅读 2016-11-25 22:47:04
    本文主要分两部分,一部分是列出一些starter的依赖,另一部分是教你自己写一个starter。 部分starters的依赖 Starter(Group ID: org.springframework.boot) 传递依赖于 spring-boot-...

    SpringBoot的starter主要用来简化依赖用的。本文主要分两部分,一部分是列出一些starter的依赖,另一部分是教你自己写一个starter。

    部分starters的依赖

    Starter(Group ID: org.springframework.boot) 传递依赖于
    spring-boot-starter-log4j2 ■ org.apache.logging.log4j:log4j-slf4j-impl
    ■ org.apache.logging.log4j:log4j-api
    ■ org.apache.logging.log4j:log4j-core
    ■ org.slf4j:jcl-over-slf4j
    ■ org.slf4j:jul-to-slf4j
    spring-boot-starter-logging ■ ch.qos.logback:logback-classic
    ■ org.slf4j:jcl-over-slf4j
    ■ org.slf4j:jul-to-slf4j
    ■ org.slf4j:log4j-over-slf4j
    spring-boot-starter-mail ■ org.springframework.boot:spring-boot-starter
    ■ org.springframework:spring-context
    ■ org.springframework:spring-context-support
    ■ com.sun.mail:javax.mail
    spring-boot-starter-mobile ■ org.springframework.boot:spring-boot-starter
    ■ org.springframework.boot:spring-boot-starter-web
    ■ org.springframework.mobile:spring-mobile-device
    spring-boot-starter-mustache ■ org.springframework.boot:spring-boot-starter
    ■ org.springframework.boot:spring-boot-starter-web
    ■ com.samskivert:jmustache
    spring-boot-starter-redis ■ org.springframework.boot:spring-boot-starter
    ■ org.springframework.data:spring-data-redis
    ■ redis.clients:jedis
    spring-boot-starter-remote-shell ■ org.springframework.boot:spring-boot-starter
    ■ org.springframework.boot:spring-boot-starter-actuator
    ■ org.crashub:crash.cli
    ■ org.crashub:crash.connectors.ssh (excludes org.codehaus.groovy:groovy-all)
    ■ org.crashub:crash.connectors.telnet (excludes javax.servlet:servlet-api, log4j :log4j, commons-logging:commons-logging)
    ■ org.crashub:crash.embed.spring(excludes org.springframework:spring-web, org.codehaus.groovy:groovy-all)
    ■ org.crashub:crash.plugins.cron (excludes org.codehaus.groovy:groovy-all)
    ■ org.crashub:crash.plugins.mail (excludes org.codehaus.groovy:groovy-all)
    ■ org.crashub:crash.shell (excludes org.codehaus.groovy:groovy-all)
    ■ org.codehaus.groovy:groovy
    spring-boot-starter-security ■ org.springframework.boot:spring-boot-starter
    ■ org.springframework:spring-aop
    ■org.springframework.security:spring-security-config
    ■org.springframework.security:spring-security-web
    spring-boot-starter-social-facebook ■org.springframework.boot:spring-boot-starter
    ■ org.springframework.boot:spring-boot-starter-web
    ■org.springframework.social:spring-social-config
    ■ org.springframework.social:spring-social-core
    ■ org.springframework.social:spring-social-web
    ■org.springframework.social:spring-social-facebook
    spring-boot-starter-social-linkedin ■org.springframework.boot:spring-boot-starter
    ■ org.springframework.boot:spring-boot-starter-web
    ■org.springframework.social:spring-social-config
    ■ org.springframework.social:spring-social-core
    ■ org.springframework.social:spring-social-web
    ■org.springframework.social:spring-social-linkedin
    spring-boot-starter-social-twitter ■org.springframework.boot:spring-boot-starter
    ■ org.springframework.boot:spring-boot-starter-web
    ■ org.springframework.social:spring-social-config
    ■ org.springframework.social:spring-social-core
    ■org.springframework.social:spring-social-web
    ■ org.springframework.social:spring-social-twitter
    spring-boot-starter-test ■ junit:junit
    ■ org.mockito:mockito-core
    ■ org.hamcrest:hamcrest-core
    ■ org.hamcrest:hamcrest-library
    ■ org.springframework:spring-core(excludes commons-logging:commons-logging)
    ■ org.springframework:spring-test
    spring-boot-starter-thymeleaf ■ org.springframework.boot:spring-boot-starter
    ■ org.springframework.boot:spring-boot-starter-web
    ■ org.thymeleaf:thymeleaf-spring4
    ■nz.net.ultraq.thymeleaf:thymeleaf-layout-dialect
    spring-boot-starter-tomcat ■ org.apache.tomcat.embed:tomcat-embed-core
    ■ org.apache.tomcat.embed:tomcat-embed-el
    ■org.apache.tomcat.embed:tomcat-embed-logging-juli
    ■org.apache.tomcat.embed:tomcat-embed-websocket
    spring-boot-starter-undertow ■ io.undertow:undertow-core
    ■ io.undertow:undertow-servlet(excludes org.jboss.spec.javax.servlet:jboss-servlet-api_3.1_spec)
    ■ io.undertow:undertow-websockets-jsr
    ■ javax.servlet:javax.servlet-api
    ■ org.glassfish:javax.el
    spring-boot-starter-validation ■ org.springframework.boot:spring-boot-starter
    ■ org.apache.tomcat.embed:tomcat-embed-el
    ■org.hibernate:hibernate-validator
    spring-boot-starter-velocity ■ org.springframework.boot:spring-boot-starter
    ■ org.springframework.boot:spring-boot-starter-web
    ■ commons-beanutils:commons-beanutils
    ■ commons-collections:commons-collections
    ■ commons-digester:commons-digester
    ■ org.apache.velocity:velocity
    ■ org.apache.velocity:velocity-tools
    ■ org.springframework:spring-context-support
    spring-boot-starter-web ■ org.springframework.boot:spring-boot-starter
    ■ org.springframework.boot:spring-boot-starter-tomcat
    ■ org.springframework.boot:spring-boot-starter-validation
    ■com.fasterxml.jackson.core:jackson-databind
    ■ org.springframework:spring-web
    ■ org.springframework:spring-webmvc
    spring-boot-starter-websocket ■ org.springframework.boot:spring-boot-starter
    ■ org.springframework.boot:spring-boot-starter-web
    ■ org.springframework:spring-messaging
    ■org.springframework:spring-websocket
    spring-boot-starter-ws ■ org.springframework.boot:spring-boot-starter
    ■ org.springframework.boot:spring-boot-starter-web ■org.springframework:spring-jms
    ■ org.springframework:spring-oxm
    ■ org.springframework.ws:spring-ws-core
    ■ org.springframework.ws:spring-ws-support

    Reference

    来自<<Spring Boot in Action>>的附录B SpringBoot Starters的内容

    如何自己写starter

    主要步骤

    • 1、选择已有的starters,在此基础上进行扩展.

    • 2、创建自动配置文件并设定META-INF/spring.factories里的内容.

    • 3、发布你的starter

    添加依赖管理

    <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>${spring.boot.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
    </dependencyManagement>

    添加starter自己的依赖

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

    新建configuration

    @Configuration
    @ComponentScan( basePackages = {"com.patterncat.actuator"} )
    public class WebAutoConfiguration {
    
        /**
         * addViewController方法不支持placeholder的解析
         * 故在这里用变量解析出来
         */
        @Value("${actuator.web.base:}")
        String actuatorBase;
    
    //    @Bean
    //    public ActuatorNavController actuatorNavController(){
    //        return new ActuatorNavController();
    //    }
    
        @Bean
        public WebMvcConfigurerAdapter configStaticMapping() {
            return new WebMvcConfigurerAdapter() {
                @Override
                public void addViewControllers(ViewControllerRegistry registry) {
                    //配置跳转
                    registry.addViewController(actuatorBase+"/nav").setViewName(
                            "forward:/static/nav.html");
                }
    
                @Override
                public void addResourceHandlers(ResourceHandlerRegistry registry) {
                    registry.addResourceHandler("/static/**").
                            addResourceLocations("classpath:/static/");
                }
            };
        }
    
    }

    修改/META-INF/spring.factories

    # AutoConfigurations
    org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.patterncat.actuator.configuration.WebAutoConfiguration

    发布

    mvn clean install

    引用

            <dependency>
                <groupId>com.patterncat</groupId>
                <artifactId>spring-boot-starter-actuator-web</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>

    启动访问

    mvn spring-boot:run

    访问

    http://localhost:8080/nav

    note

    展开全文
  • 如何 自定义starter?

    2020-10-26 21:25:37
    什么是SpringBoot中的starter? 如何定义自己的starter?

    1. 前言

    在看这篇文章之前呢,我希望大伙应该了解SpringBoot的自动装配的原理,如果这个不清楚的话,这篇文章或许看起来就有些困难了。

    这个SpringBoot的自动装配原理其实很简单,没有什么特别难理解的地方。来回那么回事儿,想想也知道。比如:之前在用spring 的时候,集成一个别的技术,需要配置这个,配置那个的。比如你在这个项目A中要使用Mybatis,所以你需要把其整合到Spring中来,需要“这么”配置,那么在这个项目B中也要集成Mybatis,你的配置是否与项目A中的配置类似(或许只是参数不同)?是不是这些个配置出现重复了?那么SpringBoot的自动装配原理就来了,那么既然基本的配置都这么配置 那干脆我直接给你提供这个配置得了,你直接给我配置里面需要的参数即可了(在application.yml 中配置的就是参数了)。那么在SpringBoot启动的时候,就会去扫描这些个自动配置的类,如果其符合要求,就给他加到spring的容器中使其生效。然后就用起来非常的爽,就给几个参数,就可以整合一个技术。

    需要的可以看一下我的SpringBoot自动装配原理的文章: 点击跳转

    2. 什么是starter?

    那么话说回来,啥是starter 呢?比如我们SpringBoot 需要 web 的话 需要的坐标:

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

    整合Mybatis 的话,需要的坐标:

    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    

    整合Jpa 的话,需要的坐标:

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    

    上面的就是starter,或许也就是看着名字像,那他的具体作用是什么呢?还是没有体现出来。

    2.1 下面以SpringDataJpa举例

    如果直接使用Spring 整合SpringDataJpa的话,需要如下坐标:

    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-jpa</artifactId>
    </dependency>
    <!-- hibernate beg -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>${hibernate.version}</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-entitymanager</artifactId>
        <version>${hibernate.version}</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
        <version>5.2.1.Final</version>
    </dependency>
    <!-- hibernate end -->
    .....................
    .....................
    .....................
    

    然后在做spring Data Jpa 的配置:

    <!--配置entityManagerFactory-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--配置要扫描的包(entity的包)-->
        <property name="packagesToScan" value="com.lzy.pojo"/>
        <!--配置jpa实现的厂家-->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>
        <!--jpa供应商的适配器-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="database" value="MYSQL"/>
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
                <!--配置是否 自动创建数据库表-->
                <property name="generateDdl" value="false"/>
                <property name="showSql" value="true"/>
            </bean>
        </property>
    
        <!-- 注入jpa原生的配置 -->
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    
    </bean>
    
    
    <!--sping 整合jpa-->
    <jpa:repositories
                      base-package="com.lzy.dao"
                      transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactory">
    </jpa:repositories>
    
    

    如果SpringBoot 的话引入坐标的话:

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    

    application.yml中配置:

    spring:
      application:
        name: boot-research
      jpa:
        database: mysql
        show-sql: true
        generate-ddl: false
        hibernate:
          ddl-auto: update
          naming:
            physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy
            implicit-strategy: org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl
        database-platform: org.hibernate.dialect.MySQLDialect
    

    发现没有,SpringBoot 默认的情况下 我们根本就没有写配置文件。

    2.2 说明的问题

    从2.1 可以看出, SpringBoot 中Starter的作用:

    • 依赖jar包
    • 提供默认的配置

    从2.1 的例子就能看出来, Spring 中整合jpa 是不是写了一堆坐标?而在SpringBoot 中就依赖了一个jpa starter 。那么结果显然是starter 中已经依赖了jpa需要的坐标,我们只需要依赖jpa的starter ,那些特别难记的坐标,就自动引入了。

    还有就是,我们在依赖的starter 之后,并没有写配置文件,那么显然在starter中也是提供了默认的配置类,我们只需要配置参数即可。(需要说明的是:jpa的配置类并不是jpa的starter提供的。其他的非spring的技术在写自己的starter的时候,是需要自己提供的,因为spring 肯定没有提供。)

    3. 定义自己的 starter

    从上面的阐述我们知道了starter 是什么,下面我以自定义Swagger2的starter 为例来定义自己的starter。

    3.1 正常的swagger2的整合

    3.1.1 pom

    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>${swagger.version}</version>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>${swagger.version}</version>
    </dependency>
    

    3.1.2 config

    
    @Configuration
    @EnableSwagger2
    public class SwaggerConfig {
    
        @Bean
        public Docket webApiConfig(){
            return new Docket(DocumentationType.SWAGGER_2)
                .groupName("groupNamexxx")
                .apiInfo(webApiInfo())
                .select()
                .paths(PathSelectors.any())
                .build();
        }
    
        private ApiInfo webApiInfo(){
            return new ApiInfoBuilder()
                .title("xxx")
                .description("xxxx")
                .version("1.0")
                .contact(new Contact("Immort", "http://www.xxx.com", "xxxxx@qq.com"))
                .build();
        }
    }
    

    3.1.3 使用

    直接打注解使用即可

    3.2 自定义starter

    3.2.1 创建项目

    在这里插入图片描述

    3.2.2 pom

    在这里插入图片描述

    3.2.3 config

    定义porperties类用来存储yml中的配置
    在这里插入图片描述

    定义默认配置类(其中几个注解的作用可以看我上篇文章,或者查阅相关资料):

    在这里插入图片描述

    定义spring.factories文件(至于为什么,请看我上篇文章,或者查阅相关资料)

    在这里插入图片描述
    在这里插入图片描述

    additional-spring-configuration-metadata.json文件的编写,这个文件可写可不写,如果写了的话,在我们在填写application.yml 的时候会有相应的提示,至于该文件的书写规范请:点击跳转

    在这里插入图片描述

    3.2.4 打包

    使用maven 打包即可,如果你使用gradle 也是一样的。

    3.3 自定义starter 的使用

    3.3.1 随便找个其他的项目

    在这里插入图片描述

    3.3.2 引入我们自定义的starter

    在这里插入图片描述

    3.3.3 application.yml 中配置

    在这里插入图片描述

    3.3.4 使用-好好滴

    在这里插入图片描述

    4. 总结

    没有什么好说的。

    展开全文
  • STARTER使用手册

    2015-07-21 14:19:35
    STARTER的简单使用手册。 STARTER是西门子新的伺服调整工具,支持对多种波形的定义和跟踪。
  • springboot学习之创建自己的starter

    千次阅读 2018-03-30 22:22:49
    之前在springboot学习之Starter中提到springboot官方提供了很多starter来实现自动配置,简化我们的开发,那么我们能不能把自己常用的一些组件也封装成一个starter来进行自动配置呢?答案是可以的,只要按照...
  • 关于 SpringBoot 自动装配前言 前言
  • 目录前言starter的有关规范结构命名自定义starter新建项目新建starter模块新建autoconfigure模块配置autoconfigure模块 前言 使用过Spring Boot的同学,都应该对starter不陌生,Spring官方提供了很多starter,对应于...
  • Spring Boot入门教程(三十一): 自定义Starter

    万次阅读 多人点赞 2018-04-09 11:37:40
    在springboot中,使用的最多的就是starterstarter可以理解为一个可拔插式的插件,例如,你想使用jdbc插件,那么可以使用spring-boot-starter-jdbc;如果想使用mongodb,可以使用spring-boot-starter-data-mongodb...
  • 填坑之路!SpringBoot导包坑之spring-boot-starter-parent

    万次阅读 多人点赞 2018-11-14 21:03:25
    在新建springboot项目引入RELEASE版本时,有几率从远程仓库下载jar包出错,导致jar包无法导入.即使我把相关的包都删完,都不行,要么换个仓库,要么换个版本.下面给出两个解决方法。 <parent>...
  • 新版本的SpringBoot 2的spring-boot-starter-data-elasticsearch中支持的Elasticsearch版本是2.X, 但Elasticsearch实际上已经发展到6.5.X版本了,为了更好的使用Elasticsearch的新特性, 所以弃用了spring-boot-...
  • 之前学过spring-security,最近又在学习spring-cloud-starter-security和spring-cloud-starter-oauth2, 脑子里顿时冒出一个问题: 之前学的spring-security和最近学的spring-cloud-starter-security有什么关系, spring...
  • springboot自定义Starter

    万次阅读 2018-08-14 10:11:51
    在我们学习SpringBoot时都已经了解到starter是SpringBoot的核心组成部分,SpringBoot为我们提供了尽可能完善的封装,提供了一系列的自动化配置的starter插件,我们在使用spring-boot-starter-web时只需要在pom.xml...
  • 在Spring Boot中,官方提供了`spring-boot-autoconfigure`包和starter包用来帮助我们简化配置,比如之前要建一个Spring mvc项目,需要我们配置web.xml,dispatcherservlet-servlet.xml,applicationContext.xml等等
  • 如何实现自己的Spring Boot Starter

    千次阅读 2019-04-22 01:36:39
    Spring Boot Starter是在SpringBoot组件中被提出来的一种概念,stackoverflow上面已经有人概括了这个starter是什么东西,想看完整的回答戳这里 Starter POMs are a set of convenient dependency descriptors that...
  • Spring Boot的启动器Starter详解

    万次阅读 多人点赞 2016-01-30 10:15:48
    Spring Boot的启动器Starter详解作者:chszs,未经博主允许不得转载。经许可的转载需注明作者和博客主页:http://blog.csdn.net/chszsSpring Boot应用启动器基本的一共有44种,具体如下:1)spring-boot-starter 这...
  • Spring Boot 各Starter介绍

    万次阅读 2018-05-08 13:53:30
    原文链接:https://blog.csdn.net/u014430366/article/details/53648139Spring-Boot-Starters 最通俗的理解— jar 包,引用了...WeGamespring-boot-starter-web—&gt;英雄联盟及其小工具的合集SpringMVC—&g...
  • 编写自己的springboot starter

    万次阅读 2019-03-19 15:07:29
    一、编写自己的springboot-starter 引入对应的依赖 编写实现类 编写配置文件读取类 主要注解是@ConfigruationProperties(“配置的值例如 example.a”) 编写自动装配类 编写默认的配置文件 在resources/META-...
  • Druid(新版starter)在SpringBoot下的使用

    万次阅读 多人点赞 2018-08-10 14:44:10
    说明 Druid是Java语言中最好的数据库连接池。...最近发现Druid在springboot框架下有更加好用的Druid Spring Boot Starter,可以省去原本写Druid的一些配置文件或者@Configuration来配置,直接将配置写在applicat...
  • spring boot starter工程对于使用者是非常方便的,使用者通常只要在pom.xml引入starter的jar,则此工程依赖的类,就全部自动引入。因此我们常用的开源组件都会提供一个start工程给开发者,让开发者非常方便集成本...
1 2 3 4 5 ... 20
收藏数 229,475
精华内容 91,790
关键字:

starter