SpringBoot项目搭建集成

1、如何创建SpringBoot项目

方式一： 采用IDEA 自带的插件创建 或者 使用eclipse的Spring Tool Suite (STS) 插件创建；
方式二：直接使用 Maven 创建项目的方式创建，然后手动添加依赖；（无网络的情况）

2、认识Springboot项目结构及Maven依赖

也是一个标准的maven结构，多了一个前端模板技术的static和template文件夹；

3、SpringBoot项目使用JSP
在Spring boot中使用jsp，按如下步骤进行：
1、在pom.xml文件中配置依赖项

<!--前端页面使用JSP-->
<!--引入Spring Boot内嵌的Tomcat对JSP的解析包-->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>
<!--jstl标签依赖的jar包start -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>

2、在application.properties文件配置spring mvc的视图展示为jsp：

spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

3、在src/main 下创建一个webapp目录，然后在该目录下新建jsp页面

4、Maven的pom.xml中配置页面编译位置

	<resources>
      <resource>
           <directory>src/main/java</directory>
           <includes>
               <include>**/*.xml</include>
           </includes>
       </resource>
       <resource>
           <directory>src/main/resources</directory>
           <includes>
               <include>**/*.*</include>
           </includes>
       </resource>
       <!--jsp的资源编译到META-INF/resources-->
       <resource>
           <directory>src/main/webapp</directory>
           <targetPath>META-INF/resources</targetPath>
           <includes>
               <include>**/*.*</include>
           </includes>
       </resource>
   </resources>

4、SpringBoot集成mybatis

Spring boot 集成 MyBatis的步骤如下：
1、在pom.xml中配置相关jar依赖；

<!-- mybatis-spring-boot-starter -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.1</version>
</dependency>
<!-- MySQL的jdbc驱动包 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

2、在Springboot的核心配置文件application.properties中配置数据源：

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.230.128:3306/workdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&useSSL=false

3、通过反向工程生成mapper接口和model类；

4、在MyBatis的Mapper接口中添加@Mapper注解；
或者
在运行的主类上添加
@MapperScan(“com.bjpowernode.springboot.mapper”) 注解包扫描；

5、接下来就是按照ssm框架的方式编写代码即可；

5、SpringBoot项目热部署插件

不是太实用。
热部署是指当我们修改代码后，服务能自动重启加载新修改的内容, Spring boot热部署通过添加一个插件实现；
插件为：spring-boot-devtools，在Maven中配置如下：

<!-- springboot 开发自动热部署 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

该热部署插件在实际使用中会有一些小问题，特别是分布式开发，比如dubbo开发框架，有点问题，需要手动重启；

6、SpringBoot增删改查

和原来的SSM项目开发一致；

7、SpringBoot多数据源与事务

Springboot 多数据源
userdb – 用户数据库
goodsdb – 商品数据库
orderdb – 订单数据库
SpringBoot 多数据源分布式事务

jta+atomikos的分布式事务

1.引入pom文件

<!--jta+atomikos分布式事务-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jta-atomikos</artifactId>
</dependency>

2.application.properties 中配置多数据源

# 自己指定的配置文件，springboot框架不识别，所以是淡黄色，自己配置的需要自己写代码去读取（springboot框架读取不了）
spring.datasource.userdb.username=root
spring.datasource.userdb.password=root
spring.datasource.userdb.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.userdb.jdbcUrl=jdbc:mysql://192.168.197.128:3306/userdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&useSSL=false

spring.datasource.goodsdb.username=root
spring.datasource.goodsdb.password=root
spring.datasource.goodsdb.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.goodsdb.jdbcUrl=jdbc:mysql://192.168.197.128:3306/goodsdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&useSSL=false

spring.datasource.orderdb.username=root
spring.datasource.orderdb.password=root
spring.datasource.orderdb.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.orderdb.jdbcUrl=jdbc:mysql://192.168.197.128:3306/orderdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&useSSL=false

3.配置config

@Configuration // == xml
@MapperScan(basePackages = {"com.bjpowernode.springboot.mapper.goods"}, sqlSessionFactoryRef = "goodsdbSqlSessionFactory")
public class GoodsDBDataSource4jtaConfig {

    @Value("${spring.datasource.goodsdb.username}")
    private String username;

    @Value("${spring.datasource.goodsdb.password}")
    private String password;

    @Value("${spring.datasource.goodsdb.driverClassName}")
    private String driverClassName;

    @Value("${spring.datasource.goodsdb.jdbcUrl}")
    private String jdbcUrl;

    /**
     * 配置一个数据源的bean
     *
     * @return
     */
    @Bean(name = "goodsdbDataSource")
    public DataSource goodsdbDataSource() {
        //创建一个XA数据源
        MysqlXADataSource xaDataSource = new MysqlXADataSource();
        xaDataSource.setUrl(jdbcUrl);
        xaDataSource.setUser(username);
        xaDataSource.setPassword(password);

        AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean();
        atomikosDataSourceBean.setXaDataSource(xaDataSource);
        atomikosDataSourceBean.setUniqueResourceName("goodsdbDataSource");
        atomikosDataSourceBean.setMaxPoolSize(30);
        atomikosDataSourceBean.setMinPoolSize(5);
        return atomikosDataSourceBean;
    }

    @Bean(name = "goodsdbSqlSessionFactory")
    public SqlSessionFactory goodsdbSqlSessionFactory(@Qualifier("goodsdbDataSource") DataSource goodsdbDataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(goodsdbDataSource);
        return sqlSessionFactoryBean.getObject();
    }

    @Bean(name = "goodsdbSqlSessionTemplate")
    public SqlSessionTemplate goodsdbSqlSessionTemplate(@Qualifier("goodsdbSqlSessionFactory") SqlSessionFactory goodsdbSqlSessionFactory) {
        return new SqlSessionTemplate(goodsdbSqlSessionFactory);
    }
}

@Configuration // == xml
@MapperScan(basePackages = {"com.bjpowernode.springboot.mapper.orders"}, sqlSessionFactoryRef = "orderdbSqlSessionFactory")
public class OrderDBDataSource4jtaConfig {

    @Value("${spring.datasource.orderdb.username}")
    private String username;

    @Value("${spring.datasource.orderdb.password}")
    private String password;

    @Value("${spring.datasource.orderdb.driverClassName}")
    private String driverClassName;

    @Value("${spring.datasource.orderdb.jdbcUrl}")
    private String jdbcUrl;

    /**
     * 配置一个数据源的bean
     *
     * @return
     */
    @Bean(name = "orderdbDataSource")
    public DataSource orderdbDataSource() {
        //创建一个XA数据源
        MysqlXADataSource xaDataSource = new MysqlXADataSource();
        xaDataSource.setUrl(jdbcUrl);
        xaDataSource.setUser(username);
        xaDataSource.setPassword(password);

        AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean();
        atomikosDataSourceBean.setXaDataSource(xaDataSource);
        atomikosDataSourceBean.setUniqueResourceName("orderdbDataSource");
        atomikosDataSourceBean.setMaxPoolSize(30);
        atomikosDataSourceBean.setMinPoolSize(5);
        return atomikosDataSourceBean;
    }

    @Bean(name = "orderdbSqlSessionFactory")
    public SqlSessionFactory orderdbSqlSessionFactory(@Qualifier("orderdbDataSource") DataSource orderdbDataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(orderdbDataSource);
        return sqlSessionFactoryBean.getObject();
    }

    @Bean(name = "orderdbSqlSessionTemplate")
    public SqlSessionTemplate orderdbSqlSessionTemplate(@Qualifier("orderdbSqlSessionFactory") SqlSessionFactory orderdbSqlSessionFactory) {
        return new SqlSessionTemplate(orderdbSqlSessionFactory);
    }
}

@Configuration // == xml
@MapperScan(basePackages = {"com.bjpowernode.springboot.mapper.users"}, sqlSessionFactoryRef = "userdbSqlSessionFactory")
public class UserDBDataSource4jtaConfig {

    @Value("${spring.datasource.userdb.username}")
    private String username;

    @Value("${spring.datasource.userdb.password}")
    private String password;

    @Value("${spring.datasource.userdb.driverClassName}")
    private String driverClassName;

    @Value("${spring.datasource.userdb.jdbcUrl}")
    private String jdbcUrl;

    /**
     * 配置一个数据源的bean
     *
     * @return
     */
    @Bean(name = "userdbDataSource")
    public DataSource userdbDataSource() {
        //创建一个XA数据源
        MysqlXADataSource xaDataSource = new MysqlXADataSource();
        xaDataSource.setUrl(jdbcUrl);
        xaDataSource.setUser(username);
        xaDataSource.setPassword(password);

        AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean();
        atomikosDataSourceBean.setXaDataSource(xaDataSource);
        atomikosDataSourceBean.setUniqueResourceName("userdbDataSource");
        atomikosDataSourceBean.setMaxPoolSize(30);
        atomikosDataSourceBean.setMinPoolSize(5);
        return atomikosDataSourceBean;
    }

    @Bean(name = "userdbSqlSessionFactory")
    public SqlSessionFactory userdbSqlSessionFactory(@Qualifier("userdbDataSource") DataSource userdbDataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(userdbDataSource);
        return sqlSessionFactoryBean.getObject();
    }

    @Bean(name = "userdbSqlSessionTemplate")
    public SqlSessionTemplate userdbSqlSessionTemplate(@Qualifier("userdbSqlSessionFactory") SqlSessionFactory userdbSqlSessionFactory) {
        return new SqlSessionTemplate(userdbSqlSessionFactory);
    }
}

4.开启事务：@Transactional，会多数据源回滚

 /**
     * 下单
     *
     * @param uid
     * @param goodsId
     * @param buyNum
     * @return
     */
    @Transactional
    public ResultObject doOrder(Integer uid, Integer goodsId, Integer buyNum) {
        //减库存 (操作商品库)
        goodsMapper.updateByStore(goodsId, buyNum);
        //下订单
        Orders orders = new Orders();
        orders.setBuynum(buyNum);
        orders.setUid(uid);
        orders.setCreatetime(new Date());
        orders.setGoodsid(goodsId);

        //发生异常，测试是否回滚
        int i = 10 / 0;

        //操作订单库
        ordersMapper.insertSelective(orders);

        return new ResultObject(Constant.ZERO, "下单成功", orders);
    }

8、SpringBoot使用拦截器

1、按照Spring mvc的方式编写一个拦截器类；

/**
 * 登录拦截器
 *
 */
public class LoginInterceptor implements HandlerInterceptor {

    /**
     * 进入controller之前执行
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        Users userInfo = (Users)request.getSession().getAttribute(Constant.LOGIN_USER);

        if (userInfo == null) {
            //未登录
            response.sendRedirect(request.getContextPath() + "/login.jsp");
            return false;
        }
        //登录，当返回true的时候，就会继续去执行我们的controller
        return true;
    }
}

2、编写一个配置类implements WebMvcConfigurer接口，添加@Configuration注解，标注此类为一个配置类，让Spring boot 扫描到

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //对来自 /api/** 链接的请求进行拦截，对登录请求/api/login不进行拦截
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/boot/**") //要拦截哪些路径
                .excludePathPatterns("/boot/login", "/boot/logout"); //不拦截哪些路径
    }
}

9、SpringBoot全局异常处理

1.配置类

/**
 * 也可以使用@RestControllerAdvice，它用于直接返回json的，不能返回jsp页面的
 */
@ControllerAdvice //可以用来返回统一的错误json或者是统一错误jsp页面
public class GlobalExceptionHandler {

    //也可以注入其他的bean
    @Autowired
    private UsersService usersService;

    /**
     * 方式一：统一返回一个错误的json格式的数据
     *
     * @param request
     * @param e
     * @return
     * @throws Exception
     */
    @ExceptionHandler(value = FileNotFoundException.class)
    public @ResponseBody Object errorHandlerByJson(HttpServletRequest request, Exception e) throws Exception {
        //可以拿到异常信息
        //e.printStackTrace();

        System.out.println(usersService);
        usersService.show();

        //可以返回统一数据
        return new ResultObject(Constant.ONE, "Sorry，服务器开小差啦~");
    }

    /**
     * 当发生异常的时候，跳转到统一的错误页
     *
     * @param request
     * @param e
     * @return
     * @throws Exception
     */
    @ResponseStatus(code = HttpStatus.BAD_REQUEST)
    @ExceptionHandler(value = Exception.class)
    public ModelAndView errorHandlerByView(HttpServletRequest request, Exception e) throws Exception {

        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("exception", e.getMessage());
        modelAndView.addObject("url", request.getRequestURL());

        //设置发生异常的时候，跳转到哪个页面
        modelAndView.setViewName("50x");
        //可以返回统一数据
        return modelAndView;
    }

}

10、SpringBoot 404页面处理

当输入地址有误，我们可以统一定义一个全局的404错误处理；
需要定义一个 config 和 controller

@Configuration
public class NotFoundConfig {

    /**
     * 处理404页面找不到错误
     * 配置一个bean
     *
     */
    @Bean
    public WebServerFactoryCustomizer<ConfigurableWebServerFactory> webServerFactoryCustomizer() {
        return ( factory -> {
            ErrorPage error404Page = new ErrorPage(HttpStatus.NOT_FOUND, "/404");
            factory.addErrorPages(error404Page);
        });
    }
}

/**
 * 异常处理类
 */
@Controller
public class NotFundController {

    /**
     * 当发生404的时候，统一走这个地方
     *
     * @return
     */
    @RequestMapping("/404")
    public String notFund() {
        return "40x";
    }
}

11、SpringBoot静态资源访问

静态资源：js, css, html, 图片，音视频等；
静态资源路径：是指系统可以直接访问的路径，且路径下的所有文件均可被用户直接访问；
Spring Boot默认静态资源目录位置位于classpath下，目录名需符合如下规则：

/static
/public
/META-INF/resources

12、SpringBoot集成Swagger

Swagger2 的作用：
随项目自动生成强大RESTful API文档，减少工作量;
API文档与代码整合在一起，便于同步更新API文档的说明；
页面测试功能来调试每个RESTful API；

1、添加相关依赖

<!-- springfox-swagger2 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

        <!-- springfox-swagger-ui -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

2、配置文件

@EnableSwagger2 //开启Swagger2的支持
@Configuration
public class SwaggerConfig {

    /**
     * 在spring容器配置一个bean对象
     *
     * @Bean等价于 <bean id="createRestApi" class="xxxx.Docket">
     *
     * @return
     */
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))//扫描有ApiOperation注解的方法
                .paths(PathSelectors.any())
                .build();
    }

    /**
     * 创建api的基本信息
     *
     * @return
     */
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("集成Swagger2构建RESTful APIs")
                .description("集成Swagger2构建RESTful APIs")
                .termsOfServiceUrl("http://www.bjpowernode.com/")
                .contact(new Contact("cat","http://www.bjpowernode.com","cat@163.com"))
                .license("采用 Apache 2.0 开源许可证")
                .licenseUrl("http://http://www.bjpowernode.com/licence.txt")
                .version("1.0.0")
                .build();
    }
}

3、编写相关代码，可能需要用到一些注解；

@Api("springboot使用swagger测试")
@RestController
public class SwaggerController {

    @ApiOperation(value = "获取用户信息", notes = "根据id来获取用户详细信息")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "path", name = "id", value = "用户ID",  dataType = "Integer"),
            @ApiImplicitParam(paramType = "path", name = "status", value = "用户状态", dataType = "Integer")
    })
    @ApiResponses({
            @ApiResponse(code = 400, message = "缺少必要的请求参数"),
            @ApiResponse(code = 404, message = "请求路径没有或页面跳转路径不对")
    })
    @RequestMapping(value = "/swagger/{id}/{status}",method = RequestMethod.GET)
    public Users getInfo(@PathVariable("id") Integer id, @PathVariable("status") Integer status) {
        Users users = new Users();
        users.setNick("cat");
        users.setPhone("1370000000");
        users.setPassword("******");
        users.setEmail("cat@163.com");
        users.setAccount("NO68958886878664");
        return users;
    }
}

具体参考课堂上的样例代码；

完成后访问：

4.查看文档:
http://localhost:8080/swagger-ui.html

5.注解可参考官方：
https://github.com/swagger-api/swagger-core/wiki/Annotations

13、SpringBoot集成Redis

Spring boot 集成 Redis 的步骤如下：
1、在pom.xml中配置相关的jar依赖；

<!-- 加载spring boot redis包 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2、在Springboot核心配置文件application.properties中配置redis连接信息：

spring.redis.host=192.168.230.128
spring.redis.port=6379
spring.redis.password=123456

3、配置了上面的步骤，Spring boot将自动配置RedisTemplate，
在需要操作redis的类中注入redisTemplate;

@Service
public class RedisServiceImpl implements RedisService{

    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public void saveKey(String key, String value) {
        redisTemplate.opsForValue().set(key,value);
    }
}

14、SpringBoot自定义starter

在学习SpringBoot的过程中，在集成第三方框架或组件时，都是采用starter依赖，这些starter都是springboot为我们提供的一些封装，这些starter能非常方便快捷的增加功能，并不需要很多配置，即使需要配置也就在application.properties稍微配置下就可以了。
那么我们来看下如何创建属于自己的starter？
（我们以redis为例，我们自己制作一个starter）
1、首先创建一个项目；
2、加入依赖

redis.clients
jedis
3.1.0

3、创建一个RedisProperties用于加载Redis需要的配置；
@Component
@ConfigurationProperties(prefix = “spring.cat.redis”)
public class RedisProperties {

private String host;
private int port;

public int getPort() {
    return port;
}
public void setPort(int port) {
    this.port = port;
}
public String getHost() {
    return host;
}
public void setHost(String host) {
    this.host = host;
}

}
4、创建一个配置类，这个配置类用于加载配置，并实例化Jedis客户端；
@Configuration
@ConditionalOnClass(Jedis.class)
@EnableConfigurationProperties(RedisProperties.class) //开启使用映射实体对象
@ConditionalOnProperty//存在对应配置信息时初始化该配置类
(
prefix = “redis”,//存在配置前缀redis
value = “enabled”,//开启
matchIfMissing = true//缺失检查
)
public class RedisAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public Jedis jedis(RedisProperties redisProperties){
return new Jedis(redisProperties.getHost(), redisProperties.getPort());
}
}
自动化配置代码中有很多我们之前没有用到的注解配置，分别介绍如下：
@Configuration：这个配置就不用多做解释了，我们一直在使用；
@EnableConfigurationProperties：这是一个开启使用配置参数的注解，value值就是我们配置实体参数映射的ClassType，将配置实体作为配置来源；
SpringBoot内置条件注解
@ConditionalOnXxx相关的注解为条件注解，也是我们配置的关键，可以把这些注解理解为具有Xxx条件：
@ConditionalOnBean：当SpringIoc容器内存在指定Bean的条件
@ConditionalOnClass：当Spring Ioc容器内存在指定Class的条件；
@ConditionalOnExpression：基于SpEL表达式作为判断条件
@ConditionalOnJava：基于JVM版本作为判断条件
@ConditionalOnMissingBean：当SpringIoc容器内不存在指定Bean的条件
@ConditionalOnMissingClass：当SpringIoc容器内不存在指定Class的条件
@ConditionalOnNotWebApplication：当前项目不是Web项目的条件
@ConditionalOnProperty：指定的属性是否有指定的值；
@ConditionalOnResource：类路径是否有指定的值
@ConditionalOnSingleCandidate：当指定Bean在SpringIoc容器内只有一个，或者虽然有多个但是指定首选的Bean；
@ConditionalOnWebApplication：当前项目是Web项目的条件
以上注解都是元注解@Conditional演变而来的，根据不用的条件对应创建以上的具体条件注解。
截止到项目我们还没有完成自动化配置starter，我们先来了解Starter自动化配置原理：
在注解@SpringBootApplication上存在一个开启自动化配置的注解@EnableAutoConfiguration来完成自动化配置，注解源码如下所示：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

String ENABLED_OVERRIDE_PROPERTY = “spring.boot.enableautoconfiguration”;

Class<?>[] exclude() default {};

String[] excludeName() default {};
}

在@EnableAutoConfiguration注解内使用到了@import注解来完成导入配置的功能，而EnableAutoConfigurationImportSelector内部则是使用了SpringFactoriesLoader.loadFactoryNames方法进行扫描具有META-INF/spring.factories文件的jar包。我们可以先来看下spring-boot-autoconfigure包内的spring.factories文件内容，如下所示：

可以看到配置的结构形式是Key=>Value形式，多个Value时使用,隔开，目的是为了完成自动化配置，所以我们这里Key则是需要使用：org.springframework.boot.autoconfigure.EnableAutoConfiguration
自定义spring.factories
在src/main/resource目录下创建META-INF目录，并在目录内添加文件spring.factories，具体内容如下：
#配置自定义Starter的自动化配置
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.bjpowernode.redis.RedisAutoConfiguration
至此自定义的starter已经开发完毕；
然后就可以在其他项目里面引用我们自己制作的starter的依赖，然后使用它进行开发；