【學習】019 SpringBoot

1、SpringBoot介紹

1.一、SpringBoot簡介

在您第1次接觸和學習Spring框架的時候,是否由於其繁雜的配置而退卻了?在你第n次使用Spring框架的時候,是否以爲一堆反覆黏貼的配置有一些厭煩?那麼您就不妨來試試使用Spring Boot來讓你更易上手,更簡單快捷地構建Spring應用!css

Spring Boot讓咱們的Spring應用變的更輕量化。好比:你能夠僅僅依靠一個Java類來運行一個Spring引用。你也能夠打包你的應用爲jar並經過使用java -jar來運行你的Spring Web應用。html

Spring Boot的主要優勢:前端

爲全部Spring開發者更快的入門java

開箱即用,提供各類默認配置來簡化項目配置mysql

內嵌式容器簡化Web項目web

沒有冗餘代碼生成和XML配置的要求spring

本章主要目標完成Spring Boot基礎項目的構建,而且實現一個簡單的Http請求處理,經過這個例子對Spring Boot有一個初步的瞭解,並體驗其結構簡單、開發快速的特性。sql

1.二、系統要求:

Java1.8及以上數據庫

Spring Framework 4.1.5及以上apache

本文采用Java 1.8.0_73Spring Boot 1.3.2調試經過。

2、快速入門

2.一、建立一個Maven工程

名爲」springboot-helloworld」 類型爲Jar工程項目

 

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>

spring-boot-starter-parent做用:

在pom.xml中引入spring-boot-start-parent,spring官方的解釋叫什麼stater poms,它能夠提供dependency management,也就是說依賴管理,引入之後在申明其它dependency的時候就不須要version了,後面能夠看到。

spring-boot-starter-web做用:

springweb 核心組件

spring-boot-maven-plugin做用:

 若是咱們要直接Main啓動spring,那麼如下plugin必需要添加,不然是沒法啓動的。若是使用maven 的spring-boot:run的話是不須要此配置的。(我在測試的時候,若是不配置下面的plugin也是直接在Main中運行的。)

2.三、編寫HelloWorld服務

建立package命名爲com.itmayiedu.controller(根據實際狀況修改)

建立HelloController類,內容以下

package com.hongmoshui.test;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@EnableAutoConfiguration
public class HelloController
{
    @RequestMapping("/hello")
    public String index()
    {
        return "Hello World";
    }

    public static void main(String[] args)
    {
        SpringApplication.run(HelloController.class, args);
    }
}

2.四、@RestController

在上加上RestController 表示修飾該Controller全部的方法返回JSON格式,直接能夠編寫Restful接口

2.五、@EnableAutoConfiguration

註解:做用在於讓 Spring Boot   根據應用所聲明的依賴來對 Spring 框架進行自動配置
        這個註解告訴Spring Boot根據添加的jar依賴猜想你想如何配置Spring。因爲spring-boot-starter-web添加了Tomcat和Spring MVC,因此auto-configuration將假定你正在開發一個web應用並相應地對Spring進行設置。

2.6 SpringApplication.run(HelloController.class, args);

   標識爲啓動類

2.七、SpringBoot啓動方式1

Springboot默認端口號爲8080

package com.hongmoshui.test;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@EnableAutoConfiguration
public class HelloController
{
    @RequestMapping("/hello")
    public String index()
    {
        return "Hello World";
    }

    public static void main(String[] args)
    {
        SpringApplication.run(HelloController.class, args);
    }
}

啓動主程序,打開瀏覽器訪問http://localhost:8080/index,能夠看到頁面輸出Hello World

2.八、SpringBoot啓動方式2

package com.hongmoshui;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan(basePackages = "com.hongmoshui.test") // 控制器掃包範圍
@EnableAutoConfiguration
public class TestApp
{
    public static void main(String[] args)
    {
        SpringApplication.run(TestApp.class, args);
    }
}

3、Web開發

3.一、靜態資源訪問

在咱們開發Web應用的時候,須要引用大量的js、css、圖片等靜態資源。

默認配置

Spring Boot默認提供靜態資源目錄位置需置於classpath下,目錄名需符合以下規則:

/static

/public

/resources

/META-INF/resources

舉例:咱們能夠在src/main/resources/目錄下建立static,在該位置放置一個圖片文件。啓動程序後,嘗試訪問http://localhost:8080/D.jpg。如能顯示圖片,配置成功。

3.二、全局捕獲異常

@ExceptionHandler 表示攔截異常

  • @ControllerAdvice 是 controller 的一個輔助類,最經常使用的就是做爲全局異常處理的切面類
  • @ControllerAdvice 能夠指定掃描範圍
  • @ControllerAdvice 約定了幾種可行的返回值,若是是直接返回 model 類的話,須要使用 @ResponseBody 進行 json 轉換
  • 返回 String,表示跳到某個 view
  • 返回 modelAndView
  • 返回 model + @ResponseBody
package com.hongmoshui.test;

import java.util.HashMap;
import java.util.Map;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.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.三、渲染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.四、使用Freemarker模板引擎渲染web視圖

3.4.一、pom文件引入:

        <!-- 引入freeMarker的依賴包. -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>

3.4.二、前端代碼

在src/main/resources/建立一個templates文件夾,後綴爲test.ftl

<!DOCTYPE html>
<html>
<head lang="CN">
<meta charset="UTF-8" />
<title></title>
</head>
<body>
      ${name}
</body> 
</html>

3.4.三、後端代碼

package com.hongmoshui.test;
import java.util.Map;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class TestController
{
    @RequestMapping("/test")
    public String test(Map<String, Object> map)
    {
        map.put("name", "美麗的天使...");
        return "test";
    }

}

3.4.四、Freemarker其餘用法

後端代碼:

    @RequestMapping("/freemarkerTest")
    public String index(Map<String, Object> result)
    {
        result.put("name", "hongmoshui");
        result.put("sex", "1");
        List<String> userList = new ArrayList<String>();
        userList.add("zhangsan");
        userList.add("lisi");
        userList.add("wangwu");
        result.put("userList", userList);
        return "freemarkerTest";
    }

前端代碼:

<!DOCTYPE html>
<html>
<head lang="CN">
<meta charset="UTF-8" />
<title>freemaker測試頁</title>
</head>
<body>
      ${name}<br/>
    <#if sex=="1">
        男
    <#elseif sex=="2">
        女
    <#else>
            其餘      
    </#if><br/>  
    <#list userList as user>
       ${user}<br/>
     </#list>
</body> 
</html>

3.4.五、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
spring.freemarker.template-loader-path=classpath:/templates/
#comma-separated list
#spring.freemarker.view-names= # whitelist of view names that can be resolved

3.五、使用JSP渲染Web視圖

3.5.一、新建應該springBoot-jsp工程,pom文件引入如下依賴

<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.hongmoshui.www</groupId>
    <artifactId>springBoot-jsp</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.3.3.RELEASE</version>
    </parent>
    <dependencies>
        <!-- SpringBoot 核心組件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <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>
    </dependencies>
</project>

3.5.二、在application.properties建立如下配置

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp

3.5.三、後臺代碼

package com.hongmoshui.test.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class TestController
{
    @RequestMapping("/test")
    public String index()
    {
        System.out.println("測試頁面,哈哈哈哈哈哈哈");
        return "test";
    }
}
package com.hongmoshui;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class TestJspApp
{

    public static void main(String[] args)
    {
        SpringApplication.run(TestJspApp.class, args);
    }

}

3.5.三、前臺代碼,目錄結構:/webapp/WEB-INF/jsp/test.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>test page</title>
</head>
<body>測試頁面(建立項目必定要爲war類型)
</body>
</html>

注意:建立SpringBoot整合JSP,必定要爲war類型,不然會找不到頁面

3、數據訪問

4.一、springboot整合使用JdbcTemplate

4.1.1 pom文件引入

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.21</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

4.1.2 application.properties新增配置

spring.datasource.url=jdbc:mysql://localhost:23306/mydatabase
spring.datasource.username=root
spring.datasource.password=master
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

4.1.3 TestController類

package com.hongmoshui.test.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.hongmoshui.test.service.UserService;

@Controller
public class TestController
{
    @Autowired
    UserService userService;

    @RequestMapping("/createUser")
    @ResponseBody
    public String createUser(String name, Integer age)
    {
        if (name == null || age == null)
        {
            return "parameter is error";
        }
        int result = userService.createUser(name, age);
        return result > 0 ? "success" : "fail";
    }

}

4.1.3 UserServiceImpl類

package com.hongmoshui.test.service.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import com.hongmoshui.test.service.UserService;

@Service
public class UserServiceImpl implements UserService
{
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public int createUser(String name, Integer age)
    {
        System.out.println("create user,name:" + name + ",age:" + age);
        int update = jdbcTemplate.update("insert into users values(null,?,?);", name, age);
        return update;
    }
}

4.1.4 TestApp類

package com.hongmoshui;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan(basePackages = "com.hongmoshui.test") // 控制器掃包範圍
@EnableAutoConfiguration
public class TestApp
{
    public static void main(String[] args)
    {
        SpringApplication.run(TestApp.class, args);
    }
}

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

4.二、springboot整合使用mybatis

4.2.一、pom文件引入mybatis依賴的jar包

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

注意:這個jar包依賴,不能是如下的,否則啓動時會報錯,沒法實例化UserDao

        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.4</version>
        </dependency>

4.2.三、UserDao的代碼

package com.hongmoshui.test.dao;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import com.hongmoshui.test.entity.User;

@Mapper
public interface UserDao
{
    @Select("SELECT * FROM users WHERE name = #{name}")
    User queryUser(String name);
}

4.2.四、啓動方式

package com.hongmoshui;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan(basePackages = "com.hongmoshui.test") // 控制器掃包範圍
@EnableAutoConfiguration
@MapperScan("com.hongmoshui.test.dao")
public class TestApp
{
    public static void main(String[] args)
    {
        SpringApplication.run(TestApp.class, args);
    }
}

4.三、springboot整合使用springjpa

4.3.1 pom文件引入依賴

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

4.3.2 User實體類修改,增長相應的註解

package com.hongmoshui.test.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity(name = "users")
public class User
{
    @Id
    @GeneratedValue
    private int id;

    @Column
    private String name;

    @Column
    private int age;

    public int getId()
    {
        return id;
    }

    public void setId(int id)
    {
        this.id = id;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    @Override
    public String toString()
    {
        return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
    }

}
@Entity(name = "users"):表名【users】,
@Id:表的主鍵

@GeneratedValue:主鍵自增
@Column:表的字段屬性

4.3.3 建立UserDaoJPA

package com.hongmoshui.test.dao;
import org.springframework.data.jpa.repository.JpaRepository;
import com.hongmoshui.test.entity.User;

public interface UserDaoJPA extends JpaRepository<User, Integer>
{

}

4.3.4 啓動項目

package com.hongmoshui;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.orm.jpa.EntityScan;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@ComponentScan(basePackages = "com.hongmoshui.test") // 控制器掃包範圍
@EnableAutoConfiguration
@MapperScan("com.hongmoshui.test.dao")
@EnableJpaRepositories("com.hongmoshui.test.dao")
@EntityScan("com.hongmoshui.test.entity")
public class TestApp
{
    public static void main(String[] args)
    {
        SpringApplication.run(TestApp.class, args);
    }
}

@EnableJpaRepositories("com.hongmoshui.test.dao"):dao的包路徑
@EntityScan("com.hongmoshui.test.entity"):實體類的包路徑

4.四、springboot整合多數據源

4.4.1配置文件中新增兩個數據源

##test1
spring.datasource.test1.url=jdbc:mysql://localhost:23306/test1
spring.datasource.test1.username=root
spring.datasource.test1.password=master
spring.datasource.test1.driverClassName=com.mysql.jdbc.Driver
##test2
spring.datasource.test2.url=jdbc:mysql://localhost:23306/test2
spring.datasource.test2.username=root
spring.datasource.test2.password=master
spring.datasource.test2.driverClassName=com.mysql.jdbc.Driver

4.4.2兩個數據源的配置代碼

數據庫test1的配置DataSource1Config.java
package com.hongmoshui.test.datasource.config;
import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

@Configuration // 註冊到springboot容器中
@MapperScan(basePackages = "com.hongmoshui.test.datasource.user.user1", sqlSessionFactoryRef = "test1SqlSessionFactory")
public class DataSource1Config
{

    /**
     * 配置test1數據庫
     * @author 墨水
     */
    @Bean(name = "test1DataSource")
    @Primary // 這個註解表示,默認使用此數據源
    @ConfigurationProperties(prefix = "spring.datasource.test1")
    public DataSource testDataSource()
    {
        return DataSourceBuilder.create().build();
    }

    /**
     * test1 sql會話工廠
     * @author 墨水
     */
    @Bean(name = "test1SqlSessionFactory")
    @Primary
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test1DataSource") DataSource dataSource) throws Exception
    {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
//        bean.setMapperLocations(
//                new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/test1/*.xml"));
        return bean.getObject();
    }

    /**
     * test1 事物管理
     * @author 墨水
     */
    @Bean(name = "test1TransactionManager")
    @Primary
    public DataSourceTransactionManager testTransactionManager(@Qualifier("test1DataSource") DataSource dataSource)
    {
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * test1 sql會話模板
     * @author 墨水
     */
    @Bean(name = "test1SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception
    {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}
數據庫test2的配置DataSource2Config.java
package com.hongmoshui.test.datasource.config;
import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

@Configuration // 註冊到springboot容器中
@MapperScan(basePackages = "com.hongmoshui.test.datasource.user.user2", sqlSessionFactoryRef = "test2SqlSessionFactory")
public class DataSource2Config
{

    /**
     * 配置test2數據庫
     * @author 墨水
     */
    @Bean(name = "test2DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.test2")
    public DataSource testDataSource()
    {
        return DataSourceBuilder.create().build();
    }

    /**
     * test2 sql會話工廠
     * @author 墨水
     */
    @Bean(name = "test2SqlSessionFactory")
    @Primary
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource) throws Exception
    {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
//        bean.setMapperLocations(
//                new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/test2/*.xml"));
        return bean.getObject();
    }

    /**
     * test2 事物管理
     * @author 墨水
     */
    @Bean(name = "test2TransactionManager")
    @Primary
    public DataSourceTransactionManager testTransactionManager(@Qualifier("test2DataSource") DataSource dataSource)
    {
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * test2 sql會話模板
     * @author 墨水
     */
    @Bean(name = "test2SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception
    {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

4.4.2建立分包Mapper

package com.hongmoshui.test.datasource.user.user1;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import com.hongmoshui.test.datasource.entity.User;

public interface User1Mapper
{
    @Insert("insert into users values(null,#{name},#{age});")
    public int addUser(@Param("name") String name, @Param("age") Integer age);

    @Select("select * from users where name=#{name};")
    public User queryUser(String name);
}
package com.hongmoshui.test.datasource.user.user2;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import com.hongmoshui.test.datasource.entity.User;

public interface User2Mapper
{
    @Insert("insert into users values(null,#{name},#{age});")
    public int addUser(@Param("name") String name, @Param("age") Integer age);

    @Select("select * from users where name=#{name};")
    public User queryUser(String name);
}

4.4.3啓動項目

package com.hongmoshui.test.datasource;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan(basePackages = "com.hongmoshui.test.datasource")
@EnableAutoConfiguration
public class datasourceApp {
    public static void main(String[] args) {
        SpringApplication.run(datasourceApp.class, args);
    }
}

3、事物管理

5.1.1springboot整合事物管理

 springboot默認集成事物,只主要在方法上加上@Transactional便可

5.1.2SpringBoot分佈式事物管理

使用springboot+jta+atomikos 分佈式事物管理

5.1.2.1pom文件中,引入新的jar包依賴

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

5.1.2.2新增配置文件信息

# Mysql 1
mysql.datasource.atomikos.test1.url = jdbc:mysql://localhost:23306/test1?useUnicode=true&characterEncoding=utf-8
mysql.datasource.atomikos.test1.username = root
mysql.datasource.atomikos.test1.password = master

mysql.datasource.atomikos.test1.minPoolSize = 3
mysql.datasource.atomikos.test1.maxPoolSize = 25
mysql.datasource.atomikos.test1.maxLifetime = 20000
mysql.datasource.atomikos.test1.borrowConnectionTimeout = 30
mysql.datasource.atomikos.test1.loginTimeout = 30
mysql.datasource.atomikos.test1.maintenanceInterval = 60
mysql.datasource.atomikos.test1.maxIdleTime = 60
mysql.datasource.atomikos.test1.testQuery = select 1

# Mysql 2
mysql.datasource.atomikos.test2.url =jdbc:mysql://localhost:23306/test2?useUnicode=true&characterEncoding=utf-8
mysql.datasource.atomikos.test2.username =root
mysql.datasource.atomikos.test2.password =m

mysql.datasource.atomikos.test2.minPoolSize = 3
mysql.datasource.atomikos.test2.maxPoolSize = 25
mysql.datasource.atomikos.test2.maxLifetime = 20000
mysql.datasource.atomikos.test2.borrowConnectionTimeout = 30
mysql.datasource.atomikos.test2.loginTimeout = 30
mysql.datasource.atomikos.test2.maintenanceInterval = 60
mysql.datasource.atomikos.test2.maxIdleTime = 60
mysql.datasource.atomikos.test2.testQuery = select 1

5.1.2.3 讀取配置文件信息的代碼

package com.hongmoshui.test.datasource.config;
import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "mysql.datasource.atomikos.test1")
public class DBConfig1
{

    private String url;

    private String username;

    private String password;

    private int minPoolSize;

    private int maxPoolSize;

    private int maxLifetime;

    private int borrowConnectionTimeout;

    private int loginTimeout;

    private int maintenanceInterval;

    private int maxIdleTime;

    private String testQuery;

    public String getUrl()
    {
        return url;
    }

    public void setUrl(String url)
    {
        this.url = url;
    }

    public String getUsername()
    {
        return username;
    }

    public void setUsername(String username)
    {
        this.username = username;
    }

    public String getPassword()
    {
        return password;
    }

    public void setPassword(String password)
    {
        this.password = password;
    }

    public int getMinPoolSize()
    {
        return minPoolSize;
    }

    public void setMinPoolSize(int minPoolSize)
    {
        this.minPoolSize = minPoolSize;
    }

    public int getMaxPoolSize()
    {
        return maxPoolSize;
    }

    public void setMaxPoolSize(int maxPoolSize)
    {
        this.maxPoolSize = maxPoolSize;
    }

    public int getMaxLifetime()
    {
        return maxLifetime;
    }

    public void setMaxLifetime(int maxLifetime)
    {
        this.maxLifetime = maxLifetime;
    }

    public int getBorrowConnectionTimeout()
    {
        return borrowConnectionTimeout;
    }

    public void setBorrowConnectionTimeout(int borrowConnectionTimeout)
    {
        this.borrowConnectionTimeout = borrowConnectionTimeout;
    }

    public int getLoginTimeout()
    {
        return loginTimeout;
    }

    public void setLoginTimeout(int loginTimeout)
    {
        this.loginTimeout = loginTimeout;
    }

    public int getMaintenanceInterval()
    {
        return maintenanceInterval;
    }

    public void setMaintenanceInterval(int maintenanceInterval)
    {
        this.maintenanceInterval = maintenanceInterval;
    }

    public int getMaxIdleTime()
    {
        return maxIdleTime;
    }

    public void setMaxIdleTime(int maxIdleTime)
    {
        this.maxIdleTime = maxIdleTime;
    }

    public String getTestQuery()
    {
        return testQuery;
    }

    public void setTestQuery(String testQuery)
    {
        this.testQuery = testQuery;
    }

}
package com.hongmoshui.test.datasource.config;
import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "mysql.datasource.atomikos.test2")
public class DBConfig2
{

    private String url;

    private String username;

    private String password;

    private int minPoolSize;

    private int maxPoolSize;

    private int maxLifetime;

    private int borrowConnectionTimeout;

    private int loginTimeout;

    private int maintenanceInterval;

    private int maxIdleTime;

    private String testQuery;

    public String getUrl()
    {
        return url;
    }

    public void setUrl(String url)
    {
        this.url = url;
    }

    public String getUsername()
    {
        return username;
    }

    public void setUsername(String username)
    {
        this.username = username;
    }

    public String getPassword()
    {
        return password;
    }

    public void setPassword(String password)
    {
        this.password = password;
    }

    public int getMinPoolSize()
    {
        return minPoolSize;
    }

    public void setMinPoolSize(int minPoolSize)
    {
        this.minPoolSize = minPoolSize;
    }

    public int getMaxPoolSize()
    {
        return maxPoolSize;
    }

    public void setMaxPoolSize(int maxPoolSize)
    {
        this.maxPoolSize = maxPoolSize;
    }

    public int getMaxLifetime()
    {
        return maxLifetime;
    }

    public void setMaxLifetime(int maxLifetime)
    {
        this.maxLifetime = maxLifetime;
    }

    public int getBorrowConnectionTimeout()
    {
        return borrowConnectionTimeout;
    }

    public void setBorrowConnectionTimeout(int borrowConnectionTimeout)
    {
        this.borrowConnectionTimeout = borrowConnectionTimeout;
    }

    public int getLoginTimeout()
    {
        return loginTimeout;
    }

    public void setLoginTimeout(int loginTimeout)
    {
        this.loginTimeout = loginTimeout;
    }

    public int getMaintenanceInterval()
    {
        return maintenanceInterval;
    }

    public void setMaintenanceInterval(int maintenanceInterval)
    {
        this.maintenanceInterval = maintenanceInterval;
    }

    public int getMaxIdleTime()
    {
        return maxIdleTime;
    }

    public void setMaxIdleTime(int maxIdleTime)
    {
        this.maxIdleTime = maxIdleTime;
    }

    public String getTestQuery()
    {
        return testQuery;
    }

    public void setTestQuery(String testQuery)
    {
        this.testQuery = testQuery;
    }

}

5.1.2.4 建立多數據源

package com.hongmoshui.test.datasource;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.jta.atomikos.AtomikosDataSourceBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import com.hongmoshui.test.datasource.config.DBConfig1;
import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;

@Configuration
// basePackages 最好分開配置 若是放在同一個文件夾可能會報錯
@MapperScan(basePackages = "com.hongmoshui.test.datasource.user.user1", sqlSessionTemplateRef = "testSqlSessionTemplate")
public class TestMyBatisConfig1
{

    // 配置數據源
    @Primary
    @Bean(name = "testDataSource")
    public DataSource testDataSource(DBConfig1 testConfig) throws SQLException
    {
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        mysqlXaDataSource.setUrl(testConfig.getUrl());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXaDataSource.setPassword(testConfig.getPassword());
        mysqlXaDataSource.setUser(testConfig.getUsername());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);

        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("testDataSource");

        xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
        xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
        xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
        xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
        xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
        xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
        xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
        xaDataSource.setTestQuery(testConfig.getTestQuery());
        return xaDataSource;
    }

    @Primary
    @Bean(name = "testSqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("testDataSource") DataSource dataSource) throws Exception
    {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }

    @Primary
    @Bean(name = "testSqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("testSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception
    {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}
package com.hongmoshui.test.datasource;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.jta.atomikos.AtomikosDataSourceBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.hongmoshui.test.datasource.config.DBConfig1;
import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;

@Configuration
// basePackages 最好分開配置 若是放在同一個文件夾可能會報錯
@MapperScan(basePackages = "com.hongmoshui.test.datasource.user.user1", sqlSessionTemplateRef = "test2SqlSessionTemplate")
public class TestMyBatisConfig2
{

    // 配置數據源
    @Bean(name = "test2DataSource")
    public DataSource testDataSource(DBConfig1 testConfig) throws SQLException
    {
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        mysqlXaDataSource.setUrl(testConfig.getUrl());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXaDataSource.setPassword(testConfig.getPassword());
        mysqlXaDataSource.setUser(testConfig.getUsername());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);

        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("test2DataSource");

        xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
        xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
        xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
        xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
        xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
        xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
        xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
        xaDataSource.setTestQuery(testConfig.getTestQuery());
        return xaDataSource;
    }

    @Bean(name = "test2SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource) throws Exception
    {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }

    @Bean(name = "test2SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception
    {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

5.1.2.4 啓動加載配置

@EnableConfigurationProperties(value = { DBConfig1.class, DBConfig2.class })

3、日誌管理

6.1使用log4j記錄日誌

6.1.2新建log4j配置文件

#log4j.rootLogger=CONSOLE,info,error,DEBUG
log4j.rootLogger=info,error,CONSOLE,DEBUG
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender     
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout     
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n     
log4j.logger.info=info
log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
log4j.appender.info.layout=org.apache.log4j.PatternLayout     
log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.info.datePattern='.'yyyy-MM-dd
log4j.appender.info.Threshold = info   
log4j.appender.info.append=true   
#log4j.appender.info.File=/home/admin/pms-api-services/logs/info/api_services_info
log4j.appender.info.File=D:/testlogspace/pms-api-services/logs/info/api_services_info
log4j.logger.error=error  
log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
log4j.appender.error.layout=org.apache.log4j.PatternLayout     
log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.error.datePattern='.'yyyy-MM-dd
log4j.appender.error.Threshold = error   
log4j.appender.error.append=true   
#log4j.appender.error.File=/home/admin/pms-api-services/logs/error/api_services_error
log4j.appender.error.File=D:/testlogspace/pms-api-services/logs/error/api_services_error
log4j.logger.DEBUG=DEBUG
log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender
log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout     
log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.DEBUG.datePattern='.'yyyy-MM-dd
log4j.appender.DEBUG.Threshold = DEBUG   
log4j.appender.DEBUG.append=true   
#log4j.appender.DEBUG.File=/home/admin/pms-api-services/logs/debug/api_services_debug
log4j.appender.DEBUG.File=D:/testlogspace/pms-api-services/logs/debug/api_services_debug

代碼引入中使用【import org.apache.log4j.Logger】:

private static Logger log = Logger.getLogger(TestController.class);

6.2使用AOP統一處理Web請求日誌

6.2.1POM文件新增jar包依賴

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

6.2.2編寫日誌切面類

package com.hongmoshui.test.datasource.aop;
import java.util.Enumeration;
import javax.servlet.http.HttpServletRequest;
import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

@Aspect
@Component
public class WebLogAspect
{
    private Logger logger = Logger.getLogger(getClass());

    @Pointcut("execution(public * com.hongmoshui.test.datasource.controller..*.*(..))")
    public void webLog()
    {
    }

    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable
    {
        // 接收到請求,記錄請求內容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        // 記錄下請求內容
        logger.info("URL : " + request.getRequestURL().toString());
        logger.info("HTTP_METHOD : " + request.getMethod());
        logger.info("IP : " + request.getRemoteAddr());
        Enumeration<String> enu = request.getParameterNames();
        while (enu.hasMoreElements())
        {
            String name = (String) enu.nextElement();
            logger.info(String.format("name:{},value:{}", name, request.getParameter(name)));
        }
    }

    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable
    {
        // 處理完請求,返回內容
        logger.info("RESPONSE : " + ret);
    }
}

3、緩存支持

7.1註解配置與EhCache使用

7.1.1 pom文件引入新的jar包依賴

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

7.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>
<!--1.配置的相關信息介紹      
2.name:緩存名稱。  
3.maxElementsInMemory:緩存最大個數。  
4.eternal:對象是否永久有效,一但設置了,timeout將不起做用。  
5.timeToIdleSeconds:設置對象在失效前的容許閒置時間(單位:秒)。僅當eternal=false對象不是永久有效時使用,可選屬性,默認值是0,也就是可閒置時間無窮大。  
6.timeToLiveSeconds:設置對象在失效前容許存活時間(單位:秒)。最大時間介於建立時間和失效時間之間。僅當eternal=false對象不是永久有效時使用,默認是0.,也就是對象存活時間無窮大。  
7.overflowToDisk:當內存中對象數量達到maxElementsInMemory時,Ehcache將會對象寫到磁盤中。  
8.diskSpoolBufferSizeMB:這個參數設置DiskStore(磁盤緩存)的緩存區大小。默認是30MB。每一個Cache都應該有本身的一個緩衝區。  
9.maxElementsOnDisk:硬盤最大緩存個數。  
10.diskPersistent:是否緩存虛擬機重啓期數據 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.  
11.diskExpiryThreadIntervalSeconds:磁盤失效線程運行時間間隔,默認是120秒。  
12.memoryStoreEvictionPolicy:當達到maxElementsInMemory限制時,Ehcache將會根據指定的策略去清理內存。默認策略是LRU(最近最少使用)。你能夠設置爲FIFO(先進先出)或是LFU(較少使用)。  
13.clearOnFlush:內存數量最大時是否清除。  
14.--> 

7.1.3代碼使用Cacheable

package com.hongmoshui.test.datasource.user.user1;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import com.hongmoshui.test.datasource.entity.User;

@CacheConfig(cacheNames = "baseCache")
public interface User1Mapper
{
    @Insert("insert into users values(null,#{name},#{age});")
    public int addUser(@Param("name") String name, @Param("age") Integer age);

    @Cacheable
    @Select("select * from users where name=#{name};")
    public User queryUser(String name);
}

7.1.4清除緩存

@Autowired
private CacheManager cacheManager;
@RequestMapping("/remoKey")
public void remoKey() {
    cacheManager.getCache("baseCache").clear();
}

3、其餘內容

8.一、使用@Scheduled建立定時任務

在Spring Boot的主類中加入@EnableScheduling註解,啓用定時任務的配置

package com.hongmoshui.test.datasource;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;

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()));
    }
}

8.二、使用@Async實現異步調用

啓動加上@EnableAsync ,須要執行異步方法上加入  @Async

8.三、自定義參數

配置文件值

name=hongmoshui.com

後臺代碼:

    @Value("${name}")
    private String name;

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

8.四、多環境配置

spring.profiles.active=pre

注:

application-dev.properties:開發環境 application-test.properties:測試環境 application-prod.properties:生產環境

8.五、修改端口號

server.port=8888
server.context-path=/hongmoshui

8.六、SpringBoot yml 使用

建立application.yml

server:
  port:  8090
  context-path: /hongmoshui

8.七、發佈打包

使用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>
                    <maimClass>com.hongmoshui.app.App</maimClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>

            </plugin>
        </plugins>
    </build>
相關文章
相關標籤/搜索