spring Boot入門

 

springBoot 概述

Build Anything with Spring Boot：Spring Boot is the starting point for building all Spring-based applications. Spring Boot is designed to get you up and running as quickly as possible, with minimal upfront configuration of Spring.
上面是引自官網的一段話，大概是說： Spring Boot 是所有基於 Spring 開發的項目的起點。Spring Boot 的設計是爲了讓你儘可能快的跑起來 Spring 應用程序並且儘可能減少你的配置文件。

什麼是springBoot

• 它使用 “習慣優於配置” 的理念讓你的項目快速運行起來。
• 它並不是什麼新的框架，而是默認配置了很多框架的使用方式，就像 Maven 整合了所有的 jar 包一樣，Spring Boot 整合了所有框架

使用Spring Boot 有什麼好處

回顧我們之前的 SSM 項目，搭建過程還是比較繁瑣的，需要：

• 1）配置 web.xml，加載 spring 和 spring mvc
• 2）配置數據庫連接、配置日誌文件
• 3）配置加載配置文件的讀取，開啓註解
• 4）配置mapper文件
• .....

而使用 Spring Boot 來開發項目則只需要非常少的幾個配置就可以搭建起來一個 Web 項目，並且利用 IDEA 可以自動生成生成，這簡直是太爽了...

總結一下：

Spring Boot 可以簡單、快速、方便地搭建項目；對主流開發框架的無配置集成；極大提高了開發、部署效率。

 

Spring Boot 快速搭建

搭建項目的幾種方式

• 使用 Spring Initializer (http://start.spring.io/) ，填寫相關的項目信息、Spring Boot版本、以及依賴的模塊， 就會生成一個項目的壓縮包，解壓導入 IDE工具即可。
• IDE 下直接創建，推薦使用 STS(Spring Tool Suite) --- Spring 官方提供的工具，或者Eclipse安裝STS插件、IntelliJ IDEA 均可直接搭建，原理同上，需要聯網！！！
• 手動構建 Maven 項目：
  • 創建一個空的Maven項目
  • 修改 pom.xml ,添加 spring boot 的父級依賴，項目就是 spring boot 項目了
  • 添加一個程序入口類  

    @SpringBootApplication
    

    SpringApplication.run(StudentApplication.class, args);

運行Spring Boot 項目的3種方式

• IDE運行項目中Application 類的 main 方法 ： 

   

• 使用maven運行
  • 在項目根目錄運行  mvn spring-boot:run
  • IDEA中也可以雙擊運行：

     

• 使用maven 的 package / install  生成jar包後運行
  • mvn package
    cd target
    java -jar xxx.jar
  • 注意：啓動後可以通過按下 Ctrl + C 進行停止
• 打成 war 包 放入 web 容器中運行
  • pom.xml 中添加 tomcat 的依賴

     

    <!--因配置外部TOMCAT 而配置-->

    <dependency>dependency>

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

                <artifactId>spring-boot-starter-tomcat</artifactId><artifactId>spring-boot-starter-tomcat</artifactId>

                <scope>provided</scope><scope>provided</scope>

            </dependency></dependency>

  • 將 pom.xml 中的打包方式 改成 war

     

    <groupId>com.star</groupId>groupId>com.star</groupId>

    <artifactId>yiyong</artifactId>artifactId>yiyong</artifactId>

    <version>0.0.1-SNAPSHOT</version>version>0.0.1-SNAPSHOT</version>

    <packaging>war</packaging>packaging>war</packaging>

    <!--<packaging>jar</packaging>-->

  • 將啓動類修改爲如下的樣子：
     

     

    @SpringBootApplication

    public class YiyongApplication extends SpringBootServletInitializer{ class YiyongApplication extends SpringBootServletInitializer{

        @Override@Override

        protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {

            return builder.sources(YiyongApplication.class);return builder.sources(YiyongApplication.class);

        }

    ​

    ​

        public static void main(String[] args) {public static void main(String[] args) {

            SpringApplication.run(YiyongApplication.class, args);SpringApplication.run(YiyongApplication.class, args);

        }

    }

  • 使用mvn package 進行打包，部署到tomcat 運行

解析Spring Boot 項目

解析 pom.xml 文件

在默認生成的 pom.xml 文件中有個parent 標籤，這個標籤是配置 spring boot 的父級依賴。

 

<parent>parent>

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

    <artifactId>spring-boot-starter-parent</artifactId><artifactId>spring-boot-starter-parent</artifactId>

    <version>2.0.3.RELEASE</version><version>2.0.3.RELEASE</version>

    <relativePath/> <!-- lookup parent from repository --><relativePath/> <!-- lookup parent from repository -->

</parent>parent>

 

有了這個，當前的項目纔是 Spring Boot 項目，spring-boot-starter-parent 是一個特殊的 starter ，它用來提供相關的 Maven 默認依賴，使用它之後，常用的包依賴就可以省去 version 標籤。

 

<dependencies>dependencies>

    <dependency><dependency>

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

        <artifactId>spring-boot-devtools</artifactId><artifactId>spring-boot-devtools</artifactId>

    </dependency></dependency>

​

    <dependency><dependency>

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

        <artifactId>spring-boot-starter-tomcat</artifactId><artifactId>spring-boot-starter-tomcat</artifactId>

        <scope>provided</scope><scope>provided</scope>

    </dependency></dependency>

​

    <dependency><dependency>

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

        <artifactId>spring-boot-starter-web</artifactId><artifactId>spring-boot-starter-web</artifactId>

    </dependency></dependency>

</dependencies>dependencies>

關於具體 Spring Boot 提供了哪些 jar 包的依賴，我們可以查看本地 Maven 倉庫下：\repository\org\springframework\boot\spring-boot-dependencies\2.0.1.RELEASE\spring-boot-dependencies-2.0.1.RELEASE.pom 文件來查看，挺長的...

 

應用入口類

Spring Boot 項目通常都會提供一個名爲 *Application 的入口類，入口類中有一個 main 方法，這個main方法其實就是一個標準的Java  main 方法。

 

@SpringBootApplication

public class StudentApplication extends SpringBootServletInitializer { class StudentApplication extends SpringBootServletInitializer {

​

    public static void main(String[] args) {public static void main(String[] args) {

        SpringApplication.run(StudentApplication.class, args);SpringApplication.run(StudentApplication.class, args);

    }

}

@SpringBootApplication ： 是 Spring Boot 的核心註解，他是一個組合註解，該註解組合了 @Configuration, @EnableAutoConfiguration, @ComponentScan, 若不使用 @SpringBootApplication, 也可以使用這三個註解代替。

• 其中，@EnableAutoConfiguration 讓 Spring Boot 根據類路徑中的 jar 包依賴爲當前項目進行自動配置，例如，添加了 spring-boot-starter-web 依賴，會自動添加 Tomcat 和 Spring MVC 的依賴，那麼 Spring Boot 會對 Tomcat 和 Spring MVC 進行自動配置。
• Spring Boot 還會自動掃描 @SpringBootApplication 所在類的同級包以及下級包裏的 Bean ，所以入口類建議就配置在 grounpID + arctifactID 組合的包名下。

Spring Boot 配置文件（項目屬性配置）

Spring Boot 使用一個全局的配置文件 application.properties 或 application.yml，放置在【src/main/resources】目錄或者類路徑的 /config 下。

Spring Boot 不僅支持常規的 properties 配置文件，還支持 yaml 語言的配置文件。yaml 是以數據爲中心的語言，在配置數據的時候具有面向對象的特徵。

Spring Boot 的全局配置文件的作用是對一些默認配置的配置值進行修改。

 

• 注意： yml 需要在 “:” 後加一個空格，幸好 IDEA 很好地支持了 yml 文件的格式有良好的代碼提示。

 

我們也可以在配置文件中配置一些自定義的信息，在JavaBean 中只需要通過 @Value 註解即可以訪問配置信息，如下所示：

 

當然，springBoot 也支持面向對象的方式來封裝配置信息，如下：

 

我們可以把配置信息封裝成一個類，首先在我們的 name 和 age 前加一個 student 前綴，然後新建一個 StudentProperties 的類用來封裝這些信息，並用上兩個註解：

• @Component：表明當前類是一個 Java Bean

• @ConfigurationProperties(prefix = "student")：表示獲取前綴爲 sutdent 的配置信息

 

Spring Boot 熱部署

        在目前的 Spring Boot 項目中，當發生了任何修改之後我們都需要重新啓動才能夠正確的得到效果，這樣會略顯麻煩，Spring Boot 提供了熱部署的方式，當發現任何類發生了改變，就會通過 JVM 類加載的方式，加載最新的類到虛擬機中，這樣就不需要重新啓動也能看到修改後的效果了，並且速度會更快，關於熱部署的實現原理，請學習 ： https://www.imooc.com/learn/915

        配置熱部署也很簡單，只需要在 pom.xml 中引入相關的依賴即可。

 

<dependency>dependency>

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

    <artifactId>spring-boot-devtools</artifactId><artifactId>spring-boot-devtools</artifactId>

    <optional>true</optional> <!-- 這個需要爲 true 熱部署纔有效 --><optional>true</optional> <!-- 這個需要爲 true 熱部署纔有效 -->

</dependency>dependency>

重新啓動Spring Boot, 修改任意代碼就可以看到控制檯自動重啓了 Spring Boot.

關於如何在IDEA中配置熱部署，請參考博客： https://blog.csdn.net/xusheng_Mr/article/details/78771746

 

Spring Boot 中的 Bean 配置方式

Spring 提供了xml、註解、Java配置、groovy配置 實現 Bean的創建和注入。

無論xml配置、註解配置還是Java配置，都被稱爲配置元數據，所謂元數據即描述數據的數據。元數據本身不具備任何可執行的能力，只能通過外界代碼對這些元數據進行解析後進行一些有意義操作。Spring容器解析這些配置元數據進行Bean初始化、配置和管理依賴。

1. XML 方式配置

很簡單，你們懂的。

2. 註解 Annotation 配置

使用spring提供的註解 @Component , @Repository , @Service , @Controller 進行組件配置，並配合 @AutoWired 和 @Resource 實現依賴注入管理。

3. Java Code 配置

從Spring 3.x開始，Spring提供了Java配置的能力。Java配置是Spring4.x推薦的配置方式，可以完全替代xml配置；Java配置也是Spring Boot推薦的配置方式。

拋棄了配置文件，Spring的配置方式一般有兩種：註解配置和Java配置。

註解配置：

 

@Component : 基礎組件

@Repository : Dao組件

@Service : 業務層組件

@Controller : 控制器組件

Java配置是通過 @Configuration 和 @Bean 來實現的。 

1、@Configuration聲明當前類是一個配置類，相當於一個Spring配置的xml文件 

2、@Bean註解在方法上，聲明當前方法的返回值爲一個Bean。

 

這兩種方式的區別在於，如果使用註解的方式，你需要在使用Dao和Service的時候，在類上進行註解，就可以獲得spring的依賴注入：

 

//註解配置

@Service  

public class UseFunctionService { class UseFunctionService {

    @Autowired@Autowired

    FunctionService functionService;FunctionService functionService;

​

    public String sayHello(String word) {public String sayHello(String word) {

        return functionService.toHello(word);return functionService.toHello(word);

    }

}

​

如果使用Java配置的方式，就不需要在類上添加註解，直接在配置類中進行聲明即可。

 

@Configuration

public class JavaConfig { class JavaConfig {

    //通過這種方式，獲得spring的依賴注入//通過這種方式，獲得spring的依賴注入

    @Bean@Bean

    public UseFunctionService useFunctionService () {public UseFunctionService useFunctionService () {

        return new UseFunctionService ();return new UseFunctionService ();

    }

    //通過構造的方式實現依賴注入//通過構造的方式實現依賴注入

    @Bean("funcService")@Bean("funcService")

    public UseFunctionService hello(FunctionService service){public UseFunctionService hello(FunctionService service){

        return new UseFunctionService(service);return new UseFunctionService(service);

    }

}

當然，這兩種方式也是可以配合使用的，通過 @ComponetScan 進行註解組件掃描。

這兩種方式沒有什麼所謂的優劣之分，主要看使用情況，一般來說是這樣的：

• 涉及到全局配置的，比如說數據庫配置，就用Java配置方式
• 涉及到業務配置的，就使用註解方式

Spring Boot 使用

        上面已經完成了 Spring Boot 項目的簡單搭建，我們僅僅需要進行一些簡單的設置，寫一個 HelloController 就能夠直接運行了，是不是太簡單了...接下來我們再深入瞭解一下 Spring Boot 的使用。

Spring Boot 支持 JSP

Spring Boot 的默認視圖支持是 Thymeleaf 模板引擎，但是這個我們不熟悉啊，我們還是想要使用 JSP 怎麼辦呢？

第一步：修改pom.xml,增加對JSP的支持

 

<!-- servlet依賴. -->

<dependency>dependency>

    <groupId>javax.servlet</groupId><groupId>javax.servlet</groupId>

    <artifactId>javax.servlet-api</artifactId><artifactId>javax.servlet-api</artifactId>

    <scope>provided</scope><scope>provided</scope>

</dependency>dependency>

<dependency>dependency>

    <groupId>javax.servlet</groupId><groupId>javax.servlet</groupId>

    <artifactId>jstl</artifactId><artifactId>jstl</artifactId>

</dependency>dependency>

<!-- tomcat的支持.-->

<dependency>dependency>

    <groupId>org.apache.tomcat.embed</groupId><groupId>org.apache.tomcat.embed</groupId>

    <artifactId>tomcat-embed-jasper</artifactId><artifactId>tomcat-embed-jasper</artifactId>

    <scope>provided</scope><scope>provided</scope>

</dependency>dependency>

第二步：配置視圖重定向到JSP的位置

 

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

spring.mvc.view.suffix=.jsp

第三步：修改 HelloController

 

package org.aptech.hdax.controller; org.aptech.hdax.controller;

​

import org.springframework.stereotype.Controller; org.springframework.stereotype.Controller;

import org.springframework.ui.Model; org.springframework.ui.Model;

import org.springframework.web.bind.annotation.RequestMapping; org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController; org.springframework.web.bind.annotation.RestController;

​

@Controller

public class IndexController { class IndexController {

​

    @RequestMapping("/index")@RequestMapping("/index")

    public String index(Model model) throws  Exception {public String index(Model model) throws  Exception {

        model.addAttribute("username","aptech");model.addAttribute("username","aptech");

        return "hello";return "hello";

    }

}

第四步：新建Jsp頁面

 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>@ page contentType="text/html;charset=UTF-8" language="java" %>

<html>html>

<head>head>

    <title>Title</title><title>Title</title>

</head>head>

<body>body>

Hello : ${username} <br/> : ${username} <br/>

Welcome to Spring Boot's World to Spring Boot's World

</body>body>

</html>html>

第五步：刷新訪問

 

關於404的問題

關於 404，使用 spring-boot:run 運行項目可以解決。原因正在瞭解中........

集成 MyBatis

第一步：修改pom.xml,增加對 MySQL 和 MyBatis的支持

 

<dependency>dependency>

    <groupId>org.mybatis.spring.boot</groupId><groupId>org.mybatis.spring.boot</groupId>

    <artifactId>mybatis-spring-boot-starter</artifactId><artifactId>mybatis-spring-boot-starter</artifactId>

    <version>1.3.2</version><version>1.3.2</version>

</dependency>dependency>

<!-- mysql -->

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->

<dependency>dependency>

    <groupId>mysql</groupId><groupId>mysql</groupId>

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

​

</dependency>dependency>

注意：mybatis-spring-boot-starter的版本， mysql的不需要指定版本

 

第二步：新增數據庫連接參數：application.properties  或者 application.yml

 

spring::

  mvc::

    view::

      prefix: /WEB-INF/jsp/: /WEB-INF/jsp/

      suffix: .jsp: .jsp

  datasource::

    username: root: root

    password: root: root

    url: jdbc:mysql://localhost:3306/myschool: jdbc:mysql://localhost:3306/myschool

    driver-class-name: com.mysql.jdbc.Driver: com.mysql.jdbc.Driver

第三步：創建實體類和Mapper映射類

 

package org.aptech.hdax.mapper; org.aptech.hdax.mapper;

​

import org.apache.ibatis.annotations.Mapper; org.apache.ibatis.annotations.Mapper;

import org.apache.ibatis.annotations.Select; org.apache.ibatis.annotations.Select;

import org.aptech.hdax.pojo.Grade; org.aptech.hdax.pojo.Grade;

​

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

​

@Mapper

public interface GradeMapper { interface GradeMapper {

    @Select("select * from grade")@Select("select * from grade")

    public List<Grade> selectAll();public List<Grade> selectAll();

}

第四步：編寫控制器，注入Mapper實例

 

package org.aptech.hdax.controller; org.aptech.hdax.controller;

​

import org.aptech.hdax.mapper.GradeMapper; org.aptech.hdax.mapper.GradeMapper;

import org.aptech.hdax.pojo.Grade; org.aptech.hdax.pojo.Grade;

import org.springframework.beans.factory.annotation.Autowired; org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller; org.springframework.stereotype.Controller;

import org.springframework.ui.Model; org.springframework.ui.Model;

import org.springframework.web.bind.annotation.RequestMapping; org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController; org.springframework.web.bind.annotation.RestController;

​

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

​

@Controller

public class IndexController { class IndexController {

    @Autowired@Autowired

    private GradeMapper gradeMapper;private GradeMapper gradeMapper;

​

    public void setGradeMapper(GradeMapper gradeMapper) {public void setGradeMapper(GradeMapper gradeMapper) {

        this.gradeMapper = gradeMapper;this.gradeMapper = gradeMapper;

    }

​

    @RequestMapping("/list")@RequestMapping("/list")

    public String list(Model model) throws  Exception {public String list(Model model) throws  Exception {

        List<Grade> list = gradeMapper.selectAll();List<Grade> list = gradeMapper.selectAll();

        model.addAttribute("list",list);model.addAttribute("list",list);

        return "index";return "index";

    }

}

第五步：編寫Jsp

 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<html>html>

<head>head>

    <title>Title</title><title>Title</title>

</head>head>

<body>body>

this is a jsp page! <br><br>

<c:forEach items="${list}" var="g">c:forEach items="${list}" var="g">

    <p>${g.gradeName}</p><p>${g.gradeName}</p>

</c:forEach>c:forEach>

</body>body>

</html>html>

第六步：重啓服務器運行

 

Spring Boot 集成 FastJSON

Spring Boot 默認集成的是 Jackson 插件，如果小夥伴們喜歡國產的FastJSON 的話，SpringBoot 也可以很方便的集成 FastJSON。

第一步：引入Maven依賴

 

<dependency>dependency>

    <groupId>com.alibaba</groupId><groupId>com.alibaba</groupId>

    <artifactId>fastjson</artifactId><artifactId>fastjson</artifactId>

    <version>1.2.24</version><version>1.2.24</version>

</dependency>dependency>

第二步：在Spring Boot 啓動類中註冊 HttpMessageConverters

 

@SpringBootApplication

public class DemoApplication extends SpringBootServletInitializer { class DemoApplication extends SpringBootServletInitializer {

​

    public static void main(String[] args) {public static void main(String[] args) {

        SpringApplication.run(DemoApplication.class, args);SpringApplication.run(DemoApplication.class, args);

    }

​

    @Bean@Bean

    public HttpMessageConverters fastJsonConfigure(){public HttpMessageConverters fastJsonConfigure(){

        FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();

        FastJsonConfig fastJsonConfig = new FastJsonConfig();FastJsonConfig fastJsonConfig = new FastJsonConfig();

        fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);

        fastJsonConfig.setDateFormat("yyyy-MM-dd");fastJsonConfig.setDateFormat("yyyy-MM-dd");

​

        converter.setFastJsonConfig(fastJsonConfig);converter.setFastJsonConfig(fastJsonConfig);

​

        return new HttpMessageConverters(converter);return new HttpMessageConverters(converter);

    }

}

第三步：沒有第三步，測試就好了

 

Spring Boot 異常處理

 

 

模板引擎 thymeleaf

        Thymeleaf是一款用於渲染XML/XHTML/HTML5內容的模板引擎。類似JSP，Velocity，FreeMaker等，它也可以輕易的與Spring MVC等Web框架進行集成作爲Web應用的模板引擎。與其它模板引擎相比，Thymeleaf最大的特點是能夠直接在瀏覽器中打開並正確顯示模板頁面，而不需要啓動整個Web應用。

第一步：在pom.xml 中添加 thymeleaf 的依賴

 

<dependency>dependency>

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

    <artifactId>spring-boot-starter-thymeleaf</artifactId><artifactId>spring-boot-starter-thymeleaf</artifactId>

</dependency>dependency>

第二步：在application.yml 配置 thymeleaf

 

spring::

  thymeleaf::

    mode: html5: html5

    servlet::

      content-type: text/html: text/html

    encoding: UTF-8: UTF-8

    cache: false: false

第三步： 編寫控制器，主要是提供數據模型

 

@Controller

@RequestMapping("/welcome")("/welcome")

public class WelcomeController { class WelcomeController {

​

    @RequestMapping("/index")@RequestMapping("/index")

    public String index(Model model) throws  Exception {public String index(Model model) throws  Exception {

        model.addAttribute("user","王老五");model.addAttribute("user","王老五");

​

        List<Grade> list = new ArrayList<>();List<Grade> list = new ArrayList<>();

        for (int i = 0; i < 10; i++){for (int i = 0; i < 10; i++){

            Grade grade = new Grade();Grade grade = new Grade();

            grade.setId(i);grade.setId(i);

            grade.setGradeName("年級" + i);grade.setGradeName("年級" + i);

            list.add(grade);list.add(grade);

        }

        model.addAttribute("list",list);model.addAttribute("list",list);

        return "hello";return "hello";

    }

}

第四步：編寫模板(其實就是html頁面)

 

<!DOCTYPE html>

<html lang="en" xmlns:th="http://www.thymeleaf.org">html lang="en" xmlns:th="http://www.thymeleaf.org">

<head>head>

    <meta charset="UTF-8"><meta charset="UTF-8">

    <title>Title</title><title>Title</title>

    <link rel="stylesheet" href="/css/bootstrap.css" th:href="@{/css/bootstrap.css}"><link rel="stylesheet" href="/css/bootstrap.css" th:href="@{/css/bootstrap.css}">

</head>head>

<body>body>

    <h1>Welcome to thymeleaf!</h1><h1>Welcome to thymeleaf!</h1>

    <p><p>

        <!--標準表達式--><!--標準表達式-->

        Welcome: <span th:text="${user}">管理員</span><span th:text="${user}">管理員</span>

        <!--th:if : 滿足條件後a標籤顯示--><!--th:if : 滿足條件後a標籤顯示-->

        <a th:href="@{/logout}" th:if="${user != null}">註銷</a><a th:href="@{/logout}" th:if="${user != null}">註銷</a>

        <!--和th:if 相反，條件不成立時，顯示a標籤--><!--和th:if 相反，條件不成立時，顯示a標籤-->

        <a th:href="@{/login}" th:unless="${user != null}">請登錄</a><a th:href="@{/login}" th:unless="${user != null}">請登錄</a>

    </p></p>

​

    <p><p>

        <h2>訂單狀態：</h2><h2>訂單狀態：</h2>

        <div th:switch="${state}"><div th:switch="${state}">

            <span th:case="0">未付款</span><span th:case="0">未付款</span>

            <span th:case="1">已付款</span><span th:case="1">已付款</span>

            <span th:case="*">配送中</span><span th:case="*">配送中</span>

        </div></div>

    </p></p>

​

    <ul><ul>

        <li th:each="g,status:${list}" ><span th:text="${status.count}">b</span><a href="" th:text="${g.gradeName}"></a></li><li th:each="g,status:${list}" ><span th:text="${status.count}">b</span><a href="" th:text="${g.gradeName}"></a></li>

    </ul></ul>

​

    <p><p>

        當前日期：<span th:text="${#dates.format(#dates.createNow(),'yyyy-MM-dd HH:mm:ss')}"></span> <br><span th:text="${#dates.format(#dates.createNow(),'yyyy-MM-dd HH:mm:ss')}"></span> <br>

​

    </p></p>

</body>body>

</html>html>

thymeleaf 模板的基礎內容包括如下方面，類似jsp去使用：

thymeleaf的使用都是通過html的屬性來實現的

1. 表達式語法 ： ${username} ===> <span th:text="${user}">管理員</span> , 會使用 context 中的user值替換掉 span 中的文本

2. 條件求值：th:if ,  th:unless,  th:swith 和 th:case

3. 循環迭代：th:each="item,status:${items}" ：

    item : 相當於c:forEach 中的 var

    status : 循環變量，可選參數，相當於 varStatus, 提供了 index, count, even, odd 等屬性

    items : 要迭代的集合或者數組 

第五步：運行

注意：如果了修改了pom.xml,添加了項目依賴，則必須重新啓動項目纔可以，熱部署不行！！！！！