SpringBoot從入門到高階

阿新 • • 發佈：2019-12-31

前言: 學習SpringBoot不應該直接就是開始使用SpringBoot,如果直接拿來用肯定會有很多人不是很明白特別剛開始入門的,當然官網上也有快速上手的教程但是官網上跨度有點大,在這片文章中為主要是從以前沒使用SpringBoot之前我們怎麼做的以及慢慢的引入SpringBoot,我希望通過自己的體會和認識來幫助更多朋友來學習SpringBoot

目錄結構

SpringJavaConfig

@Configuration和基礎的@Bean

@ComponentScan和測試

@Bean標籤屬性詳解

@Import標籤

XML和Annotation的混用

其他常用標籤(@PropertySource和@PropertySources,@Profile和@ActiveProfile)

第一個HelloWorld

Springboot簡介

Springboot基本使用

應用構建

SpringApplication

引數配置

日誌

預設日誌

外部日誌框架LogBack

Springboot開發WEB應用

靜態資源

Freemarker整合

錯誤處理

mybatis整合

事務處理

檔案上傳

首先了解 Spring Java Config(Spring的java配置)

(在這裡我們先以最原始的方式來建立專案和測試) 建立一個Maven專案新增依賴和加入配置檔案application.xml SomeBean.java

public class SomeBean {}
複製程式碼

application.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop" 

       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
			http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
			http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
			http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
		<bean id="someBean" class="com.jd.javaconfig.SomeBean"></bean>
     </beans>
複製程式碼

這個是基於XML配置的方式 MyTest.java

    public class MyTest {
	@Test
	public void test1(){
		ApplicationContext ctx=new ClassPathXmlApplicationContext("application.xml");
		SomeBean sb = ctx.getBean(SomeBean.class);
		System.out.println(sb);
	}
}
複製程式碼

上面是我們最簡單的一個Spring Demo

下面通過標籤來配置Spring OtherBean.java

public class OtherBean {}
複製程式碼

下面我們寫了一個方法返回一個SomeBean的物件我們要告訴Spring這個方法是Spring幫我們管理的bean通過@Bean標籤

AppConfig .java

    // 作為Spring的主配置檔案
    //@Configuration標籤表示這個類可被Spring識別的配置物件的類,只有有這個標記的標籤的類才能使用@Bean標籤作用於對應的方法上面
    @Configuration
    public class AppConfig {
	//@Bean標籤表示讓Spring幫我們管理bean
	@Bean
	public SomeBean someBean(){
		return new SomeBean();
	}
	@Bean
	public OtherBean otherBean(){
		return new 	OtherBean();
	}
    }
複製程式碼

不像上一個demo,這個是基於AnnotationConfigApplicationContext來配置的 MyTest.java

@Test
public void test() {
	ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
	SomeBean sb = ctx.getBean(SomeBean.class);
	OtherBean ob = ctx.getBean(OtherBean.class);
	System.out.println(sb);
	System.out.println(ob);
}
複製程式碼

到這裡我們就已經學完了兩個重要的標籤 @Configuration和@Bean,@Configuration標籤表示這個類可被Spring識別的配置物件的類,只有有這個標記的標籤的類才能使用 @Bean標籤作用於對應的方法上面 @Bean(destroyMethod = "destory",initMethod = "init")也可以通過這樣的寫法來配置bean的初始化方法和銷燬方法

@Component標籤

@Component
public class SomeBean {}
複製程式碼

@Component
public class OtherBean {}
複製程式碼

//@Configuration標籤表示這個類可被Spring識別的配置物件的類,這有有這個標記的標籤的類才能使用@Bean標籤作用於對應的方法上面
// @ComponentScan:開啟元件自動掃描；預設情況下，它會掃描當前類所在的包及其子包中的所有標籤物件載入到Spring容器
@Configuration
@ComponentScan(basePackages="com.jd.scan")
public class AppConfig {}
複製程式碼

public class MyTest {
@Test
public void test() {
	ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
	SomeBean sb = ctx.getBean(SomeBean.class);
	OtherBean ob = ctx.getBean(OtherBean.class);
	System.out.println(sb);
	System.out.println(ob);
}
}
複製程式碼

@ComponentScan:開啟元件自動掃描；預設情況下，它會掃描當前類所在的包及其子包中的所有標籤物件載入到Spring容器

物件的關係引用

在someBean裡依賴一個otherBean

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = AppConfig.class)
public class MyTest {
@Autowired
@Qualifier("somebean")
private SomeBean somebean;
  //@Autowired
 //@Qualifier("somebean2")
 //private SomeBean somebean2;
@Test
public void test() {
	System.out.println(somebean.getOtherBean());
 //System.out.println(somebean2.getOtherBean());
}
}
複製程式碼

   @Configuration
    public class AppConfig {
//第一種方式(物件的注入)
@Bean(destroyMethod = "destory",initMethod = "init")
public SomeBean somebean(OtherBean otherbean) {
	SomeBean sBean = new SomeBean();
	sBean.setOtherBean(otherbean);
	return sBean;
  }
//第二種方式
  //	@Bean
 //	public SomeBean somebean2() {
 //		SomeBean sBean = new SomeBean();
  //		sBean.setOtherBean(otherbean());
  //		return sBean;
 //	}

@Bean
public OtherBean otherbean() {
	return new OtherBean();
}
}
複製程式碼

使用try來關閉容器

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=AppConfig.class)
public class MyTest2 {
@Test
public void test() {
	try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class)) {
		SomeBean sb = context.getBean(SomeBean.class,"somebean");
		System.out.println(sb);
	}
}
}
複製程式碼

@import標籤

public class MyDataSource {}
複製程式碼

public class MyRedisTemplate {}
複製程式碼

@Configuration
public class ConfigRedis {
@Bean
public MyRedisTemplate myRedisTemplate(){
	return new MyRedisTemplate();
}
}
複製程式碼

@Configuration
public class ConfigDataSource {
@Bean
public MyDataSource myDatasource(){
return new MyDataSource();	
}
}
複製程式碼

AppConfig這個類因為打上@Configuration標籤所以是主配置檔案,他需要連線著兩個類ConfigDataSource.class,ConfigRedis.class 只需要使用@Import 標籤就可以表示匯入類

@Configuration
@Import({ConfigDataSource.class,ConfigRedis.class})
public class AppConfig {
}
複製程式碼

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = AppConfig.class)
public class MyTest {
@Autowired
private MyDataSource datasource;
@Autowired
private MyRedisTemplate redisTemplate;
@Test
public void test(){
	System.out.println(datasource);
	System.out.println(redisTemplate);
}
}
複製程式碼

@importresource標籤在javaconfig中混用xml

OtherBean.java

public class OtherBean {}
複製程式碼

application.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<bean id="otherbean" class="com.jd.importresource.OtherBean" />	
</beans>
複製程式碼

SomeBean.java

@Setter@Getter
public class SomeBean {

private OtherBean otherBean;

public void init() {
	System.out.println("===init====");
}

public void destory() {
	System.out.println("====destory=====");
}
}
複製程式碼

AppConfig.java

@Configuration
// @importresource標籤來在javaconfig中混用xml config
@ImportResource("classpath:com/jd/importresource/application.xml")
public class AppConfig {
@Bean(destroyMethod = "destory",initMethod = "init")
public SomeBean somebean(OtherBean otherbean) {
	SomeBean sBean = new SomeBean();
	sBean.setOtherBean(otherbean);
	return sBean;
}
}
複製程式碼

MyTest.java

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = AppConfig.class)
 public class MyTest {
@Autowired
private SomeBean somebean;

@Test
public void test() {
	System.out.println(somebean.getOtherBean());
}
}
複製程式碼

@ImportResource("classpath:com/jd/importresource/application.xml") 通過使用@ImportResource標籤來匯入資源

引入外部的.properties資原始檔(2種方式)

db.properties

db.username=username
db.password=password
db.url=url
db.driverClass=driverClass
複製程式碼

MyDatasource .java

@Setter@Getter@ToString@AllArgsConstructor
public class MyDatasource {

private String username;
private String password;
private String url;
private String driverClass;
}
複製程式碼

第一種方式

AppConfig .java

@Configuration
 // @PropertySource代表引入外部的.properties資原始檔
 //@PropertySources巢狀@PropertySource引入多個外部資原始檔

@PropertySource("classpath:com/jd/properties/db.properties")
public class AppConfig {

@Value("${db.username}")
private String username;
@Value("${db.password}")
private String password;
@Value("${db.url}")
private String url;
@Value("${db.driverClass}")
private String driverClass;

@Bean
public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer (){
	return new PropertySourcesPlaceholderConfigurer();
}
@Bean
public MyDatasource datasource(){
	return new MyDatasource(username,password,url,driverClass);

}
}
複製程式碼

MyTest .java

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = AppConfig.class)
public class MyTest {

@Autowired
private MyDatasource datasource;

@Test
public void test() {
	System.out.println(datasource);
}
}
複製程式碼

第二種方式

@Configuration
 // @PropertySource代表引入外部的.properties資原始檔
 //@PropertySources巢狀@PropertySource引入多個外部資原始檔

@PropertySource("classpath:com/jd/properties/db.properties")
public class AppConfig {
 //Environment代表spring的環境，在環境裡面只有兩種東西： 1，讀入的外部資原始檔(properties)； 2，profile
 
@Autowired
private Environment env;

@Bean
public MyDatasource datasource() {
	return new MyDatasource(env.getProperty("db.username"),env.getProperty("db.password"),env.getProperty("db.url"),env.getProperty("db.driverClass"));
}
}
複製程式碼

profile

db-dev.properties db-profile.properties

db.username=username
db.password=password
db.url=url
db.driverClass=driverClass  
複製程式碼

MyDatasource.java

@Setter@Getter@ToString@AllArgsConstructor
public class MyDatasource {

private String username;
private String password;
private String url;
private String driverClass;
}
複製程式碼

//生產環境的配置物件
@Configuration
@Profile("pro")
@PropertySource("classpath:com/jd/profile/db-pro.properties")
public class ConfigPro {

@Value("${db.username}")
private String username;
@Value("${db.password}")
private String password;
@Value("${db.url}")
private String url;
@Value("${db.driverClass}")
private String driverClass;
@Bean
public MyDatasource datasource() {
	return new MyDatasource(username,driverClass);
}
}
複製程式碼

//針對開發環境的配置
@Configuration
@Profile("dev")
@PropertySource("classpath:com/jd/profile/db-dev.properties")
public class ConfigDev {

@Value("${db.username}")
private String username;
@Value("${db.password}")
private String password;
@Value("${db.url}")
private String url;
@Value("${db.driverClass}")
private String driverClass;

@Bean
public MyDatasource datasource() {
	return new MyDatasource(username,driverClass);
}
}
複製程式碼

AppConfig .java

@Configuration
@Import({ ConfigDev.class,ConfigPro.class })
public class AppConfig {

@Bean
public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
	return new PropertySourcesPlaceholderConfigurer();
}
}
複製程式碼

MyTest.java

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = AppConfig.class)
@ActiveProfiles("dev")
public class MyTest {
@Autowired
private MyDatasource datasource;
@Test
public void test() {
	System.out.println(datasource);
}
}
複製程式碼

到這裡我們把需要回顧和拓展的知識都有一定加深下面我們開始正式學習SpringBoot

SpringBoot的HelloWorld

先演示在位址列訪問loclhost:8080/hello返回字串hello world #####1.在pom.xml檔案中加入依賴

 <parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.5.6.RELEASE</version>
</parent>

<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
</dependencies>
複製程式碼

2.建立一個Controller：

HelloSpringBoot.java

@SpringBootApplication
@Controller
public class HelloSpringBoot {
@RequestMapping("hello")
@ResponseBody
public String hello() {
	return "hello world";
}

public static void main(String[] args) {
	SpringApplication.run(HelloSpringBoot.class,args);
}
}
複製程式碼

#####3.執行 main方法 . ____ _ __ _ _ /\ / ' __ _ () __ __ _ \ \ \
( ( )__ | '_ | '| | ' / ` | \ \ \
\/ )| |)| | | | | || (| | ) ) ) ) ' || .__|| ||| |_,| / / / / =========||==============|/=//// :: Spring Boot :: (v1.5.6.RELEASE)

分析： 1，繼承spring-boot-starter-parent，引入基本的依賴管理配置； 2，引入spring-boot-starter-web，自動引入了springweb相關的包； 3，@SpringBootApplication：這個註解告訴springboot自動的去完成相關配置，包括基礎類的載入，bean的掃描等等，這個後面詳細介紹；簡單理解為這個標籤為我們的應用配置完成了很多基本功能； 4，SpringApplication.run：這個是springboot為我們提供的最大的區別，在於springboot不再是一個web應用，需要我們自己去打包，部署，啟動tomcat，springboot預設把tomcat打包到應用中，我們可以以正常的執行jar的方式來執行springboot應用；

應用獨立執行： 1，pom檔案中新增：

<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
	</plugins>
</build>
複製程式碼

2，使用package命令打包，在命令列中使用java -jar xx.jar執行；注意，一定要引入spring-boot-maven-plugin之後執行package打包才能正常執行；

3，直接使用maven外掛：spring-boot:run執行；

Springboot的優缺點 1. 建立獨立的Spring應用程式 2. 嵌入的Tomcat，無需部署WAR檔案 3. 簡化Maven配置 4. 自動配置Spring 5. 提供生產就緒型功能，如日誌，健康檢查和外部配置 6. XML沒有要求配置 7. 非常容易和第三方框架整合起來；缺點： 1，版本更新較快，可能出現較大變化； 2，因為約定大於配置，所以經常會出現一些很難解決的問題；

1，Springboot應用的基本結構：通過start.spring.io(網址)建立一個springboot應用： 2，spring-boot-starter-parent簡介： 1，包含了常用版本屬性；要修改java編譯版本，可以修改： <java.version>1.7</java.version> 2，包含了常用的dependenceManagement; 3，Springboot非常優秀的地方在於提供了非常多以spring-boot-starter-開頭的開箱即用的工具包，常見工具包有以下一些： spring-boot-starter：核心的工具包，提供了自動配置的支援，日誌和YAML配置支援； spring-boot-starter-activemq：針對快速整合ActiveMQ的工具包； spring-boot-starter-aop：提供了快速整合SpringAOP和AspectJ的工具包； spring-boot-starter-data-redis：提供了快速整合Redis和Jedis的工具包； spring-boot-starter-freemarker：提供了快速整合Freemarker的工具包； spring-boot-starter-mail：提供了快速整合郵件傳送的工具包； spring-boot-starter-test：提供了對Springboot應用的測試工具包； spring-boot-starter-web：提供了對web開發的工具包，包括基於SpringMVC的RESTful應用開發，內建的tomcat伺服器等； spring-boot-starter-actuator：提供了對生產環境中應用監控的工具包； spring-boot-starter-logging：提供了對日誌的工具包，預設使用Logback； 3，Springboot應用的熱部署：除了使用JRebel來實現熱部署，還可以使用Springboot提供的spring-boot-devtools包來完成Springboot應用熱部署； org.springframework.boot spring-boot-devtools true 1）原理： SpringBoot重啟是reload重啟，通過監控classpath的變化，如果classpath中的檔案發生變化，即觸發重啟。springboot通過兩個classpath來完成reload，一個basic classloader中載入不變的類，一個restart classloader中載入classpath中的類，重啟的時候，restart classloader中的類丟棄並重新載入； 2）排除資源： spring.devtools.restart.exclude=static/,templates/ spring.devtools.restart.additional-exclude=public/* (處理預設配置排除之外的) spring.devtools.restart.enabled=false （禁用自動重啟）

@SpringBootApplication簡介： @SpringBootApplication由三個主要的標籤構成：@SpringBootConfiguration，@EnableAutoConfiguration，@ComponentScan 1）@SpringBootConfiguration：本質就是一個@Configuration，代表這是spring容器的主配置類； 2）@EnableAutoConfiguration：開啟自動配置，Springboot使用這個標籤自動的把內建的符合條件的@Configuration類載入進入應用；可以檢視spring-boot-autoconfigure包中的META-INF/spring.factories檔案中的配置項（原理，由@EnableAutoConfiguration標籤引入的AutoConfigurationImportSelector類中，使用Spring的SpringFactoriesLoader類實現載入） 3）@ComponentScan：自動掃描；

SpringApplication簡介： 1，SpringApplication類提供了一個標準化的應用執行流程，並在這個執行流程中為我們提供了一些應用擴充套件點；但大部分情況下，我們只需要使用它就可以了； 2，SpringBoot提供了一些擴充套件點，比如修改Banner： 1）建立一個banner.txt 2）設定banner，在配置檔案中使用spring.main.banner-mode=off 3，可以通過建立物件的方式來執行SpringApplication

 2）通過builder完成：
複製程式碼

4，引數的處理：在應用啟動過程中，可以通過啟動引數給應用傳遞一些額外的引數來控制應用的執行； 1，在main方法中可以直接使用傳入的引數； 2，可以任何類中直接通過@Autowired注入一個ApplicationArguments物件；

Springboot中的日誌

為什麼要用日誌？ 1.比起System.out.println，日誌框架可以把日誌的輸出和程式碼分離； 2.日誌框架可以方便的定義日誌的輸出環境，控制檯，檔案，資料庫； 3.日誌框架可以方便的定義日誌的輸出格式和輸出級別；

Springboot的預設日誌使用： 1.Springboot預設已經開啟日誌；預設的日誌格式為：時間日誌級別 PID 執行緒名稱日誌類日誌說明 2.Springboot的日誌區別系統日誌和應用日誌； 3.Springboot推薦使用Logback作為日誌框架（common-logging，java-logging，log4j，logback，slf4j）

Logback使用方法（推薦使用logback自己的配置檔案） 1.springboot預設支援logback.xml或者logback-spring.xml，推薦使用logback-spring.xml，springboot會增加額外功能； 2.可以通過logging.config=classpath:mylogback.xml指定自己的logback配置檔案（不推薦）； 3.一個典型的logback配置檔案：

Logback使用介紹： 1，:Logback配置根元素屬性包括： 1,scan: 當此屬性設定為true時，配置檔案如果發生改變，將會被重新載入，預設值為true。 2,scanPeriod: 設定監測配置檔案是否有修改的時間間隔，如果沒有給出時間單位，預設單位是毫秒。當scan為true時，此屬性生效。預設的時間間隔為1分鐘。 3,debug: 當此屬性設定為true時，將打印出logback內部日誌資訊，實時檢視logback執行狀態。預設值為false。子元素：：上下文名字； :定義屬性，可以使用${}在配置檔案中使用；

2，：在logback中是用於具體記錄日誌的元件，可以用來配置日誌記錄方式，日誌記錄格式等；屬性包括： name:appender的名字，用於下面在配置日誌的時候指定； class:使用到的appender類；

常見的appender： 1，ch.qos.logback.core.ConsoleAppender:輸出到控制檯； 2，ch.qos.logback.core.FileAppender：輸出到檔案； 3，ch.qos.logback.core.rolling.RollingFileAppender：輸出到檔案，可以配置滾動策略，當日誌達到某個條件之後分檔案記錄； 4，還有其他的appender，比如寫到資料庫等；

元素的基本格式： ...

元素用來規定日誌的輸出格式，所有表示式都以%開始表示接下來是一個特殊識別符號常見識別符號： 1，%logger{n}：輸出Logger物件類名，n代表長度； 2，%class{n}:輸出所在類名， 3，d{pattern}或者date{pattern}：輸出日誌日期，格式同java； 4，L/line：日誌所在行號； 5，m/msg：日誌內容； 6，method：所在方法名稱； 7，p/level：日誌級別； 8，thread：所線上程名稱；

常見的appender使用： 1）ConsoleAppender輸出到控制檯，子元素：：日誌格式化：System.out(預設)或者System.err

2）FileAppender輸出到檔案，子元素： file：被寫入的檔名，可以是相對目錄，也可以是絕對目錄，如果上級目錄不存在會自動建立，沒有預設值。 append：檔案結尾，如果是 false，清空現存檔案，預設是true。 encoder：對日誌進行格式化

3）RollingFileAppender輸出到檔案，可以設定檔案滾動（分割）條件，子元素： append：如果是 true，日誌被追加到檔案結尾，如果是 false，清空現存檔案，預設是true。 rollingPolicy:滾動策略，涉及檔案移動和重新命名。常用滾動策略： ch.qos.logback.core.rolling.TimeBasedRollingPolicy：按照時間控制來控制記錄檔案； fileNamePattern：檔名稱格式，以%d{pattern}； maxHistory: 可選節點，控制保留的歸檔檔案的最大數量，超出數量就刪除舊檔案。（以檔案最小時間為準）

SizeAndTimeBasedRollingPolicy:按照時間和大小控制記錄檔案； fileNamePattern：檔名稱格式，可以使用%i來控制索引編號； maxFileSize：這是活動檔案的大小，預設值是10MB maxHistory: 可選節點，控制保留的歸檔檔案的最大數量，超出數量就刪除舊檔案。（以檔案最小時間為準）

下面我們來通過一個小Demo來說明 application.properties

db.username=username
db.password=password
db.url=url
springboot.randomlong=${random.long[1,100]}
複製程式碼

MyDatasource.java

@Setter@Getter
public class MyDatasource {
private String username;
private String password;
private String url;
}
複製程式碼

HelloController.java

@Controller
public class HelloController {
private static final Logger logger = LoggerFactory.getLogger(HelloController.class);
@Autowired
private MyDatasource datasource;
@RequestMapping("hello")
@ResponseBody
public String hello() {
	//error<warn<info<debug<trace
	logger.info("轉出成功");
	if (logger.isDebugEnabled()) {
		logger.debug("準備轉出10000");
	}
	if (logger.isTraceEnabled()) {
		logger.trace("連線資料庫");
		logger.trace("查詢賬戶餘額為12000");
	}
	if (logger.isDebugEnabled()) {
		logger.debug("檢查轉出賬戶...");
		logger.debug("轉出檢查成功");
		logger.debug("執行轉出10000");
		logger.debug("轉出成功");
	}
	logger.info("轉入成功");
	System.out.println(datasource);
	return "hello world";
}
}
複製程式碼

App.java

@SpringBootApplication
public class App {
@Bean
@ConfigurationProperties(prefix = "db")
public MyDatasource datasource() {
	return new MyDatasource();
}
public static void main(String[] args) {
	new SpringApplicationBuilder(App.class).bannerMode(Mode.OFF).build().run(args);
}
複製程式碼

}

logback日誌的xml配置檔案

logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
	<encoder>
		<pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n</pattern>
	</encoder>
	<target>System.out</target>
</appender>

<appender name="FILE" class="ch.qos.logback.core.FileAppender">
	<encoder>
		<pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n</pattern>
	</encoder>
	<file>springbootdemo.log</file>
	<append>true</append>
</appender>

<appender name="ROLLFILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
	<encoder>
		<pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n</pattern>
	</encoder>
	<append>true</append>
	<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
		<fileNamePattern>springboot.%d{yyyy-MM-dd}.log</fileNamePattern>
		<maxHistory>30</maxHistory>
	</rollingPolicy>
</appender>

<appender name="SIZEROLLFILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
	<encoder>
		<pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n</pattern>
	</encoder>
	<append>true</append>
	<rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
		<fileNamePattern>springboot.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
		<maxFileSize>10MB</maxFileSize>
		<maxHistory>30</maxHistory>
	</rollingPolicy>
</appender>

<root level="DEBUG">
	<appender-ref ref="CONSOLE" />
	<appender-ref ref="SIZEROLLFILE" />
</root>
</configuration>
複製程式碼

Springboot的WEB開發

Springmvc和freemarker的整合

新增依賴引入spring-boot-starter-freemarker;

	<dependency>
		<groupId>org.freemarker</groupId>
		<artifactId>freemarker</artifactId>
		<version>2.3.23</version>
	</dependency>
複製程式碼

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>freemarker</display-name>
  <!-- SpringMVC前端控制器 -->
   <servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>classpath:application-web.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
  <!-- 編碼過濾器 -->
  <filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
	<param-name>encoding</param-name>
	<param-value>utf-8</param-value>
</init-param>
  </filter>
  <filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
  </filter-mapping>
  <welcome-file-list>
<welcome-file>index.do</welcome-file>
  </welcome-file-list>
</web-app>
複製程式碼

application.xml

<!--開啟註解掃描 -->
<context:component-scan base-package="com.jd" />
複製程式碼

application-web.xml

<import resource="classpath:application.xml" />
<!-- 支援springmvc的註解驅動 -->
<mvc:annotation-driven />
<!-- 配置一個freemarker的配置物件 -->
<bean
class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
	<!-- 配置freemarker的檔案編碼 -->
	<property name="defaultEncoding" value="UTF-8" />
	<!-- 配置freemarker尋找模板的路徑 -->
	<property name="templateLoaderPath" value="/WEB-INF/views/" />
</bean>
<!-- 配置一個針對於freemarker的viewresovler -->
<bean id="viewResolver"
class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
	<!-- 配置邏輯檢視自動新增的字尾名 -->
	<property name="suffix" value=".ftl" />
	<!-- 配置檢視的輸出HTML的contentType -->
	<property name="contentType" value="text/html;charset=UTF-8" />
</bean>
複製程式碼

FreemarkerController.java

@Controller
public class FreemarkerController {

@RequestMapping("hello")
public String hello(Model model){
	model.addAttribute("msg","hello 我是 freemarker");
	return "hello";
}
}
複製程式碼

Springboot和freemarker的整合

新增依賴

<properties>
	<java.version>1.8</java.version>
</properties>
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.5.6.RELEASE</version>
</parent>
<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-freemarker</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-devtools</artifactId>
	</dependency>
</dependencies>
<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
	</plugins>
</build>
複製程式碼

建立模板

<!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>Insert title here</title>
</head>
<body>
<h1>${msg}</h1>
</body>
</html>
複製程式碼

FreemarkerController.java

@Controller
public class FreemarkerController {

@RequestMapping("hello")
public String hello(Model model){
	model.addAttribute("msg","hello 我是 freemarker");
	return "hello";
}
}
複製程式碼

App.java

//執行main
@SpringBootApplication
public class App {
public static void main(String[] args) {
	SpringApplication.run(App.class,args);
}
}
複製程式碼

訪問網頁

Springboot對freemarker的配置： 1，spring.freemarker.enabled=true：是否開啟freemarker支援； 2，spring.freemarker.allow-request-override：是否允許request中的屬性覆蓋model中同名屬性；預設false； 3，spring.freemarker.allow-session-override：是否允許session中的屬性覆蓋model中同名屬性；預設false； 4，spring.freemarker.cache：是否支援模板快取；預設false； 5，spring.freemarker.charset=UTF-8：模板編碼 6，spring.freemarker.content-type=text/html：模板contenttype； 7，spring.freemarker.expose-request-attributes：是否開啟request屬性expose，預設false； 8，spring.freemarker.expose-session-attributes：是否開啟session屬性expose，預設false； 9，spring.freemarker.expose-spring-macro-helpers：是否開啟spring的freemarker巨集支援；預設為false； 10，spring.freemarker.prefer-file-system-access：預設為true，支援實時檢查模板修改； 11，spring.freemarker.prefix：載入模板時候的字首； 12，spring.freemarker.settings.*：直接配置freemarker引數 13，spring.freemarker.suffix：模板檔案字尾； 14，spring.freemarker.template-loader-path=classpath:/templates/：模板載入地址

一般情況下我們會把以下配置加入進去的系統會自動讀取

application.properties

spring.freemarker.charset=UTF-8
spring.freemarker.content-type=text/html;charset=UTF-8
spring.freemarker.expose-session-attributes=true
複製程式碼

Springboot錯誤統一處理(@ControllerAdvice)

1).@ControllerAdvice 通過使用@ControllerAdvice定義統一的異常處理類，而不是在每個Controller中逐個定義。@ExceptionHandler用來定義函式針對的異常型別。

GlobalExceptionHandler.java

@ControllerAdvice
public class GlobalExceptionHandler {
    //@ExceptionHandler(logicException.class)也可以分情況處理異常
@ExceptionHandler(Exception.class)
public String errorHandler(Model model,Exception e) {
	model.addAttribute("error",e.getMessage());
	//到模板找到err.ftl將錯誤資訊顯示出來
	return "err";
    }
}
複製程式碼

2）統一的異常頁面 1,SpringBoot預設情況下，把所有錯誤都重新定位到/error這個處理路徑上，由BasicErrorController類完成處理； 2，SpringBoot提供了預設的替換錯誤頁面的路徑： 1，靜態錯誤頁面預設結構：(按照這個目錄結構放置錯誤頁面報錯時就會自動找到相應的介面) src/ resources/public/error/404.html src/ resources/public/error/ 403.html src/ resources/public/error/ 5xx.html

2，也可以使用模板頁面： src/resources/templates/error/5xx.ftl 該路徑方式是通過ErrorMvcAutoConfiguration中的DefaultErrorViewResolver完成的；

Springboot整合DataSource和mybatis

整合DataSource方式1: 先加入依賴

<!-- druid -->
	<dependency>
		<groupId>com.alibaba</groupId>
		<artifactId>druid</artifactId>
		<version>1.0.14</version>
	</dependency>
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<scope>runtime</scope>
	</dependency>
複製程式碼

DatasourceController .java

@Controller
public class DatasourceController {
@Autowired
private DataSource dataSource;

@RequestMapping("ds")
@ResponseBody
public String datasource() {
	return dataSource.getClass() + "  " + dataSource.toString();
}
}
複製程式碼

執行main

@SpringBootApplication
public class App {
  //使用程式碼的方式實現datasource
@Bean
public DataSource dataSource() {
	DruidDataSource dataSource = new DruidDataSource();
	dataSource.setUrl("jdbc:mysql:///p2p");
	dataSource.setUsername("root");
	dataSource.setPassword("123456");
	dataSource.setDriverClassName("com.mysql.jdbc.Driver");
	dataSource.setInitialSize(5);
	dataSource.setMinIdle(5);
	return dataSource;
}
public static void main(String[] args) {
	SpringApplication.run(App.class,args);
}
}
複製程式碼

整合DataSource方式2:

使用配置檔案的方式 application.properties

ds.username=root
ds.password=123456
ds.url=jdbc:mysql:///p2p
ds.driverClassName=com.mysql.jdbc.Driver
ds.initialSize=3
複製程式碼

App.java

@Bean
@ConfigurationProperties(prefix = "ds")
public DataSource dataSource(Properties properties) throws Exception {
	return DruidDataSourceFactory.createDataSource(properties);
}

public static void main(String[] args) {
	SpringApplication.run(App.class,args);
}
複製程式碼

整合DataSource方式3: 修改配置檔案

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql:///p2p
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.initialSize=3
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
複製程式碼

Springboot整合mybatis

mybatis整合：使用mybatis-spring-boot-starter來完成mybatis整合；

1，引入依賴：

<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.0</version>
</dependency>
複製程式碼

2，正常完成mapper介面和mapper.xml 3，mybatis-spring-boot-starter提供了以下配置(具體參考MyBatisProperties物件)：

mybatis.configLocation:mybatis的配置檔案地址； mybatis.mapperLocations：對映檔案地址； mybatis.typeAliasesPackage：別名掃描包；

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql:///p2p
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.initialSize=3
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
mybatis.mapperLocation=classpath:com/jd/springboot/mybatis3/*Mapper.xml
mybatis.typeAliasesPackage=com.jd.springboot.mybatis3
複製程式碼

4，使用@MapperScan標籤掃描mapper介面

@SpringBootApplication
@MapperScan(basePackages="com.jd.springboot.mybatis3")
 public class App {
public static void main(String[] args) {
	SpringApplication.run(App.class,args);
}
}
複製程式碼

事務處理

1,使用程式碼的方式：

1，直接開啟@EnableTransactionManagement註解；相當於在xml中配置tx:annotation-driven/

@SpringBootApplication
@MapperScan(basePackages="com.jd.springboot.demo.mybatis1.mapper")
@EnableTransactionManagement
public class App {
public static void main(String[] args) {
	SpringApplication.run(App.class,args);
}
}
複製程式碼

如果在classpath中新增的是spring-boot-starter-jdbc，那麼springboot自動建立DataSourceTranscationManager；

@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {
	return new DataSourceTransactionManager(dataSource);
}
複製程式碼

如果開啟了@EnableTransactionManagement，只需要在service上面使用@Transactional即可；

2，使用xml配置

將事務相關配置抽取到XML中，使用importResource引入

1，引入aop

<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-aop</artifactId>
	</dependency>
複製程式碼

2，application-tx.xml

<tx:advice id="advice" transaction-manager="transactionManager">
	<tx:attributes>
		<tx:method name="list*" read-only="true" />
		<tx:method name="get*" read-only="true" />
		<tx:method name="query*" read-only="true" />
		<tx:method name="*" />
	</tx:attributes>
</tx:advice>

<aop:config>
	<aop:pointcut expression="execution(* com.jd.springboot.demo..service.*Service.*(..))"
		id="pointCut" />
	<aop:advisor advice-ref="advice" pointcut-ref="pointCut" />
</aop:config>
複製程式碼

3，引入配置

@SpringBootApplication
@MapperScan(basePackages = "com.jd.springboot.demo.mybatis1.mapper")
@ImportResource(locations="classpath:application-tx.xml")
public class App {}
複製程式碼

檔案上傳

1，仍然使用MultipartFile完成上傳，Springboot是使用Servlet3中的Part物件完成上傳，不是使用的fileupload；

2，上傳相關配置： spring.http.multipart.enabled=true：是否允許處理上傳；

spring.http.multipart.maxFileSize=1MB：允許最大的單檔案上傳大小，單位可以是kb，mb；

spring.http.multipart.maxRequestSize=10MB：允許的最大請求大小；

3，也可以通過建立一個MultipartConfigElement型別的bean對上傳進行配置：

@Bean
public MultipartConfigElement multipartConfigElement() {
	MultipartConfigFactory mcf = new MultipartConfigFactory();
	mcf.setMaxFileSize("1MB");
	mcf.setMaxRequestSize("10MB");
	return mcf.createMultipartConfig();
}
複製程式碼

4，關於上傳檔案的處理：因為應用是打成jar包，所以一般會把上傳的檔案放到其他位置，並通過設定 spring.resources.static-locations 來完成資源位置對映。

spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/,file:/Users/zhangshuai/devs/workspace/springboot-demo/upload/

#####SpringBoot總結 1.Maven中專案的繼承依賴包的管理第1：在父專案中新增dependency，子專案不需要新增第2：在父專案中新增dependencyManagement標籤,然後在新增dependency，子類對應的新增需要的dependency，但不需要寫版本號 2.專案分為前臺和後臺兩個應用的好處從安全性考慮，後臺是給公司管理人員用的，前臺是給使用者用的，訪問的URL地址是不一樣的，那這樣的話前臺使用者就不可能通過各種嘗試去訪問後臺管理系統了。從效能方面考慮，專案分成前臺和後臺把請求分發到不同的伺服器中，降低單個伺服器的壓力。 3.什麼是樂觀鎖？樂觀鎖能解決什麼問題？樂觀鎖(Optimistic Lock)：顧名思義，就是很樂觀，每次去拿資料的時候都認為別人不會修改，所以不會上鎖，但是在更新的時候會判斷一下在此期間別人有沒有去更新這個資料 sql 上的體現：加版本/時間戳控制語句 update set version = version+1 ... from .... where version = xxx 解決的問題：資料併發問題(丟失更新/髒讀)

4.事務是什麼？事務有哪些特性？事務用來幹什麼？（1）在資料庫中,所謂事務是指一組邏輯操作單元,使資料從一種狀態變換到另一種狀態。特性:

原子性（Atomicity）原子性是指事務是一個不可分割的工作單位，事務中的操作要麼都發生，要麼都不發生。
一致性（Consistency）事務必須使資料庫從一個一致性狀態變換到另外一個一致性狀態。(資料不被破壞)
隔離性（Isolation）事務的隔離性是指一個事務的執行不能被其他事務幹擾，即一個事務內部的操作及使用的資料對併發的其他事務是隔離的，併發執行的各個事務之間不能互相干擾(事務空間)。
永續性（Durability）永續性是指一個事務一旦被提交，它對（3）資料庫中資料的改變就是永久性的，接下來的其他操作和資料庫故障不應該對其有任何影響

為確保資料庫中資料的一致性,資料的操縱應當是離散的成組的邏輯單元:當它全部完成時,資料的一致性可以保持,而當這個單元中的一部分操作失敗,整個事務應全部視為錯誤,所有從起始點以後的操作應全部回退到開始狀態。

5.Springboot應用的啟動原理？ Springboot應用可以在一個主啟動類中執行main方法或者打成jar包直接執行該jar包。因為Springboot應用一定會在主啟動類貼上一個@SpringBootApplication註解，該註解有包含很多配置，相當於spring的主配置檔案，並且springboot應用內嵌web伺服器，在我們啟動應用時，會先根據@SpringBootApplication註解的配置初始化spring容器，並執行在內嵌的web伺服器上。

6.@Configuration標籤，@ComponentScan和@Bean標籤各自的作用； @Configuration:貼上該註解的類會被spring當成配置物件解析，可以在該配置物件建立bean注入到spring容器（相當於之前我們application.xml寫的配置） @ComponentScan:該註解與@Configuration:結合一起使用，可以掃描應用中的元件，比如貼了@Controller，@Service，@Component的類，並注入到spring容器中。此外，改註解可以填寫掃描的包路徑，如果不寫的話就預設掃描貼了該註解的類所在的包及其子包。 @Bean:該註解結合@Configuration一起使用，作用是把貼上該註解的方法返回的類注入到spring容器中。 7.@ConfigurationProperties標籤的作用；該註解起到引數繫結的作用，可以非常方便的把配置檔案的配置資訊繫結到Properties物件上，並且可以控制到具體哪些字首的配置資訊需要繫結 8.日誌級別: error>warn>Info>debug>trace

點選檢視SpringBoot從入門到高階視訊教程

SpringBoot從入門到高階

首先了解 Spring Java Config(Spring的java配置)

@Component標籤

物件的關係引用

@import標籤

@importresource標籤 在javaconfig中混用xml

引入外部的.properties資原始檔(2種方式)

第一種方式

第二種方式

profile

到這裡我們把需要回顧和拓展的知識都有一定加深下面我們開始正式學習SpringBoot

SpringBoot的HelloWorld

2.建立一個Controller：

Springboot中的日誌

logback日誌的xml配置檔案

Springboot的WEB開發

Springmvc和freemarker的整合

Springboot和freemarker的整合

一般情況下我們會把以下配置加入進去的 系統會自動讀取

Springboot錯誤統一處理(@ControllerAdvice)

1).@ControllerAdvice 通過使用@ControllerAdvice定義統一的異常處理類，而不是在每個Controller中逐個定義。@ExceptionHandler用來定義函式針對的異常型別。

Springboot整合DataSource和mybatis

Springboot整合mybatis

事務處理

1,使用程式碼的方式：

如果開啟了@EnableTransactionManagement，只需要在service上面使用@Transactional即可；

2，使用xml配置

檔案上傳

相關推薦

@importresource標籤在javaconfig中混用xml

一般情況下我們會把以下配置加入進去的系統會自動讀取