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,添加了项目依赖，则必须重新启动项目才可以，热部署不行！！！！！