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

时间:2024-05-25 14:05:08

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>