springBoot入门教程(图文+源码+sql)

springBoot入门

1   springBoot

1.1 SpringBoot简介

Spring Boot让我们的Spring应用变的更轻量化。比如：你可以仅仅依靠一个Java类来运行一个Spring引用。你也可以打包你的应用为jar并通过使用java -jar来运行你的Spring Web应用。

Spring Boot的主要优点：

为所有Spring开发者更快的入门

开箱即用，提供各种默认配置来简化项目配置

内嵌式容器简化Web项目

没有冗余代码生成和XML配置的要求

本章主要目标完成Spring Boot基础项目的构建，并且实现一个简单的Http请求处理，通过这个例子对Spring Boot有一个初步的了解，并体验其结构简单、开发快速的特性。

1.2 系统要求

Java1.8及以上

Spring Framework 4.1.5及以上

本文采用Java 1.8.0_73、Spring Boot 1.3.3调试通过。

2      快速入门

2.1 创建一个maven工程

名为“springBoot-helloWorld”类型为jar的工程项目

直接next到下一步点击finish。

新建maven项目如下：

2.2  pom文件引入依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.3.3.RELEASE</version>
</parent>
<dependencies>
    <!--SpringBoot
web 组件 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

spring-boot-starter-parent作用

spring-boot-starter-parent是一个特殊的starter，它用来提供相关的Maven默认依赖。使用它之后，常用的包依赖可以省去version标签。

spring-boot-starter-web作用

springweb 核心组件

spring-boot-maven-plugin作用

在添加了该插件之后，当运行“mvn
package”进行打包时，会打包成一个可以直接运行的 JAR 文件，使用“java -jar”命令就可以直接运行。这在很大程度上简化了应用的部署，只需要安装了 JRE 就可以运行。

如下：

2.3
编写HelloWorld服务

包名为：com.springBoot;类名为：HelloController

2.4
编写启动类

包名为：com ;类名为：StartAPP

注：这里的启动类必须要在所有的类的上一级或同级，注解@SpringBootApplication才能扫描到。

2.5
启动应用程序

2.5.1     
方式一：

直接运行main方法：springBoot内部自带tomcat服务器

出现如下，表示服务器已经启动：

2.5.2     
方式二：

打包项目：然后利用cmd命令：java  –jar  jar包名称

打包：双击package即可

出现如下：表示打包成功

切换到jar包所在目录，利用命令java –jar jar包名运行：

2.6
查看结果

打开浏览器，在浏览器输入：http://localhost:8080/hello/world，结果如下：

2.7
上面所用到的注解解释

2.7.1     
@SpringBootApplication

他相当于@Configuration、@EnableAutoConfiguration、ComponentScan三个注解之和。

其中：

@ComponentScan：自动扫描符合条件的组件或bean；让spring Boot扫描到Configuration类并把它加入到程序上下文。

@Configuration ：IOC容器配置，等同于spring的XML配置文件；使用Java代码可以检查类型安全。

@EnableAutoConfiguration ：自动配置，将所有符合自动配置的bean加载到IOC容器中。

2.7.2     
@RestController

@RestController：注解是@Controller和@ResponseBody的合集,表示这是个控制器bean,并且是将函数的返回值直接填入HTTP响应体中,是REST风格的控制器。

@ResponseBody：表示该方法的返回结果直接写入HTTP response body中，一般在异步获取数据时使用，用于构建RESTful的api。在使用@RequestMapping后，返回值通常解析为跳转路径，加上@Responsebody后返回结果不会被解析为跳转路径，而是直接写入HTTP response
body中。比如异步获取json数据，加上@Responsebody后，会直接返回json数据。该注解一般会配合@RequestMapping一起使用。

@Controller：用于定义控制器类，在spring项目中由控制器负责将用户发来的URL请求转发到对应的服务接口（service层），一般这个注解在类中，通常方法需要配合注解@RequestMapping。

2.7.3     
@RequestMapping

@RequestMapping：提供路由信息，负责URL到Controller中的具体函数的映射。

3     
web开发

3.1
静态资源访问

在我们开发Web应用的时候，需要引用大量的js、css、图片等静态资源。

默认配置

Spring Boot默认提供静态资源目录位置需置于classpath下，目录名需符合如下规则：

/static

/public

/resources

/META-INF/resources

举例：我们可以在src/main/resources/目录下创建static，在该位置放置一个图片文件。启动程序后，尝试访问http://localhost:8080/D.jpg。如能显示图片，配置成功。

启动程序并访问：

3.2
全局捕获异常

/**
 *     @ExceptionHandler 表示拦截异常
 * •   @ControllerAdvice 是 controller 的一个辅助类，最常用的就是作为全局异常处理的切面类
 * •   @ControllerAdvice 可以指定扫描范围
 * •   @ControllerAdvice 约定了几种可行的返回值，如果是直接返回 model 类的话，需要使用 @ResponseBody 进行 json 转换
 * o   返回 String，表示跳到某个 view
 * o   返回 modelAndView
 * o   返回 model + @ResponseBody
 */
  @ControllerAdvice
  public class GlobalExceptionHandler {
    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public Map<String,Object> exceptionHandler(){
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("errorCode","101");
        map.put("errorMsg","系统错误");
        return map;
    }

}

3.3 渲染web页面

渲染Web页面

在之前的示例中，我们都是通过@RestController来处理请求，所以返回的内容为json对象。那么如果需要渲染html页面的时候，要如何实现呢？

模板引擎

在动态HTML实现上Spring Boot依然可以完美胜任，并且提供了多种模板引擎的默认配置支持，所以在推荐的模板引擎下，我们可以很快的上手开发动态网站。

Spring Boot提供了默认配置的模板引擎主要有以下几种：

•     Thymeleaf

•     FreeMarker

•     Velocity

•     Groovy

•     Mustache

Spring Boot建议使用这些模板引擎，避免使用JSP，若一定要使用JSP将无法实现Spring Boot的多种特性，具体可见后文：支持JSP的配置；

当你使用上述模板引擎中的任何一个，它们默认的模板配置路径为：src/main/resources/templates。当然也可以修改这个路径，具体如何修改，可在后续各模板引擎的配置属性中查询并修改。

3.4 使用FreeMarker模板引擎渲染web视图

3.4.1      pom文件引入

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

3.4.2      freemarker配置

新建application.properties文件

########################################################

###FREEMARKER (FreeMarkerAutoConfiguration)

########################################################

spring.freemarker.allow-request-override=false

spring.freemarker.cache=true

spring.freemarker.check-template-location=true

spring.freemarker.charset=UTF-8

spring.freemarker.content-type=text/html

spring.freemarker.expose-request-attributes=false

spring.freemarker.expose-session-attributes=false

spring.freemarker.expose-spring-macro-helpers=false

#spring.freemarker.prefix=

#spring.freemarker.request-context-attribute=

#spring.freemarker.settings.*=

spring.freemarker.suffix=.ftl  （好像设置为html不可以）

spring.freemarker.template-loader-path=classpath:/templates/

#comma-separated list

#spring.freemarker.view-names= # whitelist of view names that can be resolved

3.4.3      后台代码

在HelloController中加上如下代码：

/**
 * 使用Freemarker模板引擎渲染web视图
 * @param map
 * @return
 */
  @RequestMapping("/index")
  public String index(Map<String,Object> map){
    map.put("name","张志强。。。");
    map.put("age","18");
    map.put("say","我叫张志强，今年18岁。。");
    return "aa";//aa是跳转到aa.flt页面
}

3.4.4      前台代码

在src/main/resources/创建一个templates文件夹，然后在文件夹下面创建aa.flt文件，内容如下：

<!DOCTYPE html>
  <html>
  <head lang="en">
    <meta charset="UTF-8" />
    <title></title>
  </head>
  <body>
    <h1>前台页面aa.ftl</h1>
    我叫：${name}
    <br>
    今年：${age}
    <br>
    我想说：${say}
  </body>
  </html>

3.4.5      测试

启动服务程序——>在页面输入http://localhost:8080/hello/index后成功显示出页面：

3.4.6      Freemarker其他用法

主要就是判断、集合；

例如：

后端代码：

@RequestMapping("/freemarkerIndex")
  public String freemarkerIndex(Map<String, Object> result) {
    result.put("name", "王坤");
    result.put("sex", "1");
    List<String> listResult = new ArrayList<String>();
    listResult.add("zhangsan");
    listResult.add("lisi");
    result.put("listResult", listResult);
    return "bb";
}

前端代码：在templates文件夹下面新建bb.flt文件，内容如下：

<!DOCTYPE html>
  <html>
  <head lang="en">
    <meta charset="UTF-8" />
    <title></title>
  </head>
  <body>
    <h1>前台页面</h1>
    ${name}
    <#--条件判断-->
    <#if sex=="1">
        男
    <#elseif sex=="2">
        女
    <#else>
        其他
    </#if>
    <br>
    <#--显示集合数据-->
    <#list listResult as list1>
        <br>
        <h1>1号 </h1>
        ${list1}
        <br>
    </#list>
  </body>
  </html>

启动服务——>打开浏览器输入：http://localhost:8080/hello/freemarkerIndex显示页面：

3.5 使用JSP渲染web视图

3.5.1      pom文件引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
  </dependency>
  <dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
  </dependency>

3.5.2      在application.properties创建以下配置

# 页面默认前缀目录
  spring.mvc.view.prefix=/WEB-INF/jsp/
  # 响应页面默认后缀
  spring.mvc.view.suffix=.jsp

3.5.3      后端代码

注意：创建SpringBoot整合JSP，一定要为war类型，否则会找不到页面.

在包controller下面新建IndexController类：

@Controller
  public class IndexController {
    @RequestMapping("/index")
    public String index(Map<String,Object> map) {
        map.put("name","张三");
        map.put("age","22");
        return "index";
    }
}

如下：

3.5.4      前台jsp页面

注意：Jsp页面文件夹必须建立main文件夹下面webapp文件夹——>jsp文件夹下面创建*.jsp。

如下所示目录结构：

3.5.5      运行并测试

运行：启动StartApp，并打开浏览器输入网址：

注：这里的整合jsp与freemarker模板引擎并不冲突（由于刚开始将WEB-INF放在了resources下面，导致一直报错，后来调整了目录结构就好了。）

4      数据访问

4.1 springBoot整合JdbcTemplate

4.1.1      pom文件引入

<!--整合JDBC访问数据-->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
  </dependency>
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
  </dependency>

4.1.2      application.properties新增配置

spring.datasource.url=jdbc:mysql://localhost:3306/test
  spring.datasource.username=root
  spring.datasource.password=123465
  spring.datasource.driver-class-name=com.mysql.jdbc.Driver

4.1.3      创建UserService类

先创建service包，在创建UserService类

@Service
  public class UserService {
    //导入JdbcTemplate模板
    @Autowired
    private JdbcTemplate jdbcTemplate;
    public void createUser(String name,Integer age){
        jdbcTemplate.update("insert into users values(null,?,?);",name,age);
        System.out.println("成功添加一个用户。。");
    }
}

4.1.4      创建UserController类调用UserService的方法

@Controller
  public class UserController {
    @Autowired
    private UserService userService;
    @RequestMapping("/insertUser")
    public void insertUser(){
        userService.createUser("张三三",22);
    }
}

4.1.5      创建数据库

4.1.6      运行程序并测试

测试结果如下：

注意: spring-boot-starter-parent要在1.5以上。

4.2 springBoot整合mybatis

4.2.1      pom文件引入

在上面之前建立的pom文件的依赖下再添加下面的mybatis依赖

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

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
  </dependency>

4.2.2      配置文件引入

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=123465
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

4.2.3     
Mapper代码

创建UserMapper类

@Mapper
@Repository//注解
  public interface UserMapper {
    @Select("SELECT * FROM USERS WHERE NAME = #{name}")
    User findByName(@Param("name") String name);
    //插入用户
    @Insert("INSERT INTO USERS(NAME, AGE) VALUES(#{name}, #{age})")
    int insert(@Param("name") String name, @Param("age") Integer age);
}

4.2.4      创建service层调用mapper层

public User findUserByName(String name){
    User u = userMapper.findByName(name);
    return u;
}
  public int insertUser(String name,int age){
    return userMapper.insert(name,age);
}

4.2.5      创建controller层代码

/**
 * 添加用户
 * @param name
 * @param age
 * @return
 */
  @RequestMapping("/insertUser")
  @ResponseBody
  public int insertUser(String name,int age){
    return userService.insertUser(name,age);
}

 /**
 * 根据姓名查询用户
 * @param name
 * @return
 */
  @RequestMapping("/findUserByName")
  @ResponseBody
  public User findUserByName(String name){
    return userService.findUserByName(name);
}

4.2.6      测试

运行并测试：

测试插:1：这里注意url拼接name不需要加“”，否则代入数据库的也包含“”。例如：

测试插入2：

测试查询：

4.3 springboot整合使用springjpa

4.3.1      pom文件引入依赖

<!--整合使用springjpa-->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
  </dependency>

4.3.2      创建Student实体类

@Entity(name = "student")
  public class Student {
    @Id
    @GeneratedValue//主键
    private Integer sid;
    @Column
    private String sname;
    @Column
    private String sage;

// ..get/set方法

}

4.3.3      创建StudentDao

JpaRepository类中封装了对数据库的基本的增删改查方法。

public interface StudentDao extends JpaRepository<Student,Integer> {

}

4.3.4      在 StudentController中新建代码

@RestController
@RequestMapping("/jpa")
  public class StudentController {
    @Autowired
    private StudentDao studentDao;

    @RequestMapping("/findStudent")
    public List<Student> findStudent(Integer id){
        List<Student> allStu = studentDao.findAll();
        for (int i = 0; i <allStu.size() ; i++) {
            System.out.println(allStu.get(i).getSname());
        }
        return allStu;
    }

    //插入一个student
    @RequestMapping("/insertStu")
    public Student insertStu(Student stu){
        Student student = studentDao.save(stu);
        return student;
    }
}

4.3.5      启动项目测试

4.3.5.1        Jpa插入一个学生

学生表主键是：自增

这里sname与sage要与数据库字段对应上。

数据库：

4.3.5.2        查询所有学生

5      事务管理

5.1 springBoot整合事物管理

springboot默认集成事物,在主要在方法上加上@Transactional即可

5.2 SpringBoot分布式事物管理

使用spring-boot-starter-jta-atomikos 分布式事物管理

5.2.1      新增配置文件信息

<dependency>

      <groupId>org.springframework.boot</groupId>

      <artifactId>spring-boot-starter-jta-atomikos</artifactId>

</dependency>

6      缓存

6.1 注解配置与EhCache使用

6.1.1      pom文件引入

<!--配置缓存-->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
  </dependency>

6.1.2      新建ehcache.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
  <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <diskStore path="java.io.tmpdir/Tmp_EhCache" />

    <!-- 默认配置 -->
    <defaultCache maxElementsInMemory="5000" eternal="false"
                  timeToIdleSeconds="120" timeToLiveSeconds="120"
                  memoryStoreEvictionPolicy="LRU" overflowToDisk="false" />

    <cache name="baseCache" maxElementsInMemory="10000"
           maxElementsOnDisk="100000" />

  </ehcache>

配置信息介绍

<!--配置信息说明-->
 <!--  
   name:缓存名称。  
   maxElementsInMemory：缓存最大个数。  
   eternal:对象是否永久有效，一但设置了，timeout将不起作用。  
   timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。  
   timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。  
   overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。  
   diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。  
   maxElementsOnDisk：硬盘最大缓存个数。  
   diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.  
   diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。  
   memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。  
   clearOnFlush：内存数量最大时是否清除。  
--> 

6.1.3      代码使用Cacheable

@CacheConfig(cacheNames = "baseCache")

public interface UserMapper {

      @Select("select * from users where name=#{name}")

      @Cacheable

      UserEntity findName(@Param("name") String name);

}

6.1.4      清除缓存

@Autowired

private CacheManager cacheManager;

@RequestMapping("/remoKey")

public void remoKey() {

      cacheManager.getCache("baseCache").clear();

}

6.1.5      启动加入缓存

在启动类中加入：

@EnableCaching // 开启缓存注解

6.2 使用Redis做集中式缓存

6.2.1      POM.xml文件中添加依赖

<!--spring-boot-redis组件  -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>

6.2.2      添加redis配置

application.properties中配置Redis连接信息，如下：

 

#redis配置
# Redis数据库索引（默认为0，总共16个）
  spring.redis.database=0
  # Redis服务器地址
  spring.redis.host=127.0.0.1
  # Redis服务器连接端口
  spring.redis.port=6379
  # Redis服务器连接密码（默认为空）
  spring.redis.password=
  # 连接池最大连接数（使用负值表示没有限制）
  spring.redis.pool.max-active=8
  # 连接池最大阻塞等待时间（使用负值表示没有限制）
  spring.redis.pool.max-wait=-1
  # 连接池中的最大空闲连接
  spring.redis.pool.max-idle=8
  # 连接池中的最小空闲连接
  spring.redis.pool.min-idle=0
  # 连接超时时间（毫秒）
  spring.redis.timeout=0

Redis数据库：

6.2.3     
后台封装redis业务代码

业务层代码：

package com.springBoot.service;

  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.data.redis.core.ListOperations;
  import org.springframework.data.redis.core.StringRedisTemplate;
  import org.springframework.stereotype.Service;
  import org.springframework.util.StringUtils;
  import java.util.List;
  /**
 * springBoot -redis使用
 */
  @Service
  public class RedisService {
    @Autowired
    StringRedisTemplate stringRedisTemplate ;

    //封装resids保存数据的方法
    public void setObject(String key,Object value){
        if(StringUtils.isEmpty(key) || value ==null){
            return ;
        }
        //判断是否String
        if(value instanceof String){
            String strValue=(String)value;
            stringRedisTemplate.opsForValue().set(key, strValue);
        }
        //判断是否List
        if(value instanceof List){
            List<String> listValue=(List<String>)value;
            for (String str:listValue) {
                stringRedisTemplate.opsForList().leftPush(key, str);
            }
        }
    }
    //获取redis中的内容
    public String getObject(String key){
        return stringRedisTemplate.opsForValue().get(key);
    }

    //获取redis中内容 List
    public List<String> lRange(String k, long l, long l1){
        ListOperations<String, String> list = stringRedisTemplate.opsForList();
        return list.range(k,l,l1);
    }
}

控制层代码：

package com.springBoot.controller;

  import com.springBoot.service.RedisService;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;

  import java.util.ArrayList;
  import java.util.List;

  @RestController
  public class RedisController {
    @Autowired
    RedisService redisService;

    @RequestMapping("/setString")
    public String setString(String key,String value){
        redisService.setObject(key, value);
        return "success";
    }
    @RequestMapping("/setList")
    public String setList(String key){
        List list=new ArrayList();
        list.add("lg");
        list.add("30");
        redisService.setObject(key, list);
        return "success";
    }

    @RequestMapping("/getString")
    public String getString(String key){
        return redisService.getObject(key);
    }

    @RequestMapping("/getList")
    public List<String> getList(String k, long l, long l1){
        return redisService.lRange(k, l, l1);
    }
}

6.2.4      测试

6.2.4.1        先查看redis数据库内容：

6.2.4.2        存一个String类型的数据进去

启动程序:

查看数据库:

6.2.4.3        查询刚刚存进去的name

6.2.4.4        存一个list类型的对象（person）

查看数据库：

 

6.2.4.5        查询刚刚的list（person）

查询key=person的对象，从0到2，表示查询list下标从0开始到2的前三个对象。

7      其他内容

7.1.1      使用@Scheduled创建定时任务

在Spring Boot的主类中加入@EnableScheduling注解，启用定时任务的配置

@Component

public class ScheduledTasks {

private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");

@Scheduled(fixedRate = 5000)

public void reportCurrentTime() {

System.out.println("现在时间：" + dateFormat.format(new Date()));

}

}

7.1.2      使用@Async实现异步调用

启动加上@EnableAsync ,需要执行异步方法上加入 @Async

 

7.1.3      自定义参数

配置文件值

name=我是配置文件中的自定义参数

后台代码：在IndexController中

@Value("${name}")
  private String name;
  @ResponseBody
@RequestMapping("/getValue")
  public String getValue() {
    return name;
}

7.1.3.1        测试

7.1.4      多环境配置

spring.profiles.active=pre

application-dev.properties：开发环境

application-test.properties：测试环境

application-prod.properties：生产环境

7.1.5      修改端口号

server.port=8888

server.context-path=/springBoot

7.1.6      SpringBoot yml 使用

创建application.yml

注意：这里的冒号后面必须要有空格。

server:

  port:  8090

  #  全局路径设置

  context-path: /springBoot

启动程序类：查看端口号已经是8090了。

查询redis中的name：

7.1.7      发布打包

使用mvn package 打包

使用java –jar 包名

如果报错没有主清单,在pom文件中新增

    <build>
    <plugins>
        <plugin>
            <!--打包-->
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
        <plugin>
            <!--启动类配置-->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <mainClass>com.springBoot.StartApp</mainClass>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
  </build>