SpringBoot简介，包含常见注解，RESTFul风格和Thymeleaf等内容

青灯文案

已于 2024-04-28 17:38:35 修改

阅读量197

点赞数 1

分类专栏： Java 项目文章标签： spring boot java

于 2022-08-21 22:19:30 首次发布

本文链接：https://blog.csdn.net/Reggie97/article/details/126456177

版权

Java 项目专栏收录该内容

26 篇文章 0 订阅

订阅专栏

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

一、SpringBoot简介

1、SpringBoot

SpringBoot就相当于不需要配置文件的Spring+SpringMVC。

自动配置：SpringBoot会根据项目中添加的jar依赖关系，自动配置你的Spring应用。例如，如果你在classpath路径下添加了HSQLDB，并且你没有手动配置任何数据库连接beans，那么SpringBoot会自动配置一个内存型（in-memory）数据库。
独立运行：SpringBoot 内嵌了如 Tomcat 、Jetty 和 Undertow 这样的Servlet容器，所以你可以打包成一个jar或war文件，然后直接运行。
生产就绪特性：SpringBoot提供了很多非业务性功能，例如运行状况检查（health checks）、外部化配置（externalized configuration）以及安全的特性。
无代码生成和XML配置：SpringBoot并不是一个新的框架，它默认配置了很多框架的使用方式，就像Maven整合了所有的jar包一样，SpringBoot整合了所有的框架。

SpringBoot是一个强大的框架，它大大简化了Spring应用的搭建和开发过程，使开发者能够更专注于业务逻辑的实现，而不是花费大量时间在配置和整合各种框架上。

SpringBoot事务简介示例请看：Sping事务简介

2、JavaConfig

JavaConfig是Spring框架提供的一种 替代XML配置 的方式，旨在简化和增强应用程序的配置过程。传统的Spring框架使用XML文件来定义应用程序的配置信息，包括Bean的定义、依赖关系、AOP切面等。然而，使用XML配置可能会导致配置文件冗长、繁琐，并且容易出错。

JavaConfig通过引入Java类来替代XML配置文件，使得配置更加直观、类型安全，并且可以充分利用Java语言的特性。

使用JavaConfig，可以通过编写一个或多个Java类来定义应用程序的配置。这些配置类通常使用注解来标识Bean的定义、依赖关系和其他配置信息。 JavaConfig还提供了一些额外的功能，例如条件化配置、组件扫描和AOP的支持。

2.1、JavaConfig的优点

使用Java类作为XML配置文件的替代，是配置spring容器的纯Java的方式。在这个Java类这可以创建Java对象，把对象放入Spring容器中（注入到容器）。

面向对象的配置：由于配置被定义为JavaConfig中的类，因此用户可以充分利用Java中的面向对象功能。 一个配置类可以继承另一个，重写它的@Bean方法等。
减少或消除XML配置：JavaConfig提供了一种纯Java方法来配置与XML配置概念相似的Spring容器。
类型安全和重构友好：JavaConfig提供了一种类型安全的方法来配置Spring容器，使得代码更加健壮和易于维护。

2.2、@Configuration 和 @Bean

@Configuration ：放在一个类的上面，表示这个类是作为配置文件使用的。
@Bean ：声明对象，把对象注入到容器中。

import com.qdwa.vo.Student;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Configuration:表示当前类是作为配置文件使用的。 就是用来配置容器的
 * 位置：在类的上面
 * SpringConfig这个类就相当于beans.xml
 */
@Configuration
public class SpringConfig {
    /**
     * 创建方法，方法的返回值是对象。 在方法的上面加入@Bean
     * 方法的返回值对象就注入到容器中。
     * @Bean: 把对象注入到spring容器中。 作用相当于<bean>
     *     位置：方法的上面
     *     说明：@Bean,不指定对象的名称，默认是方法名是 id
     */
    @Bean
    public Student createStudent(){
        Student s1  = new Student();
        s1.setName("张三");
        s1.setAge(26);
        s1.setSex("男");
        return s1;
    }
    /***
     * 指定对象在容器中的名称（指定<bean>的id属性）
     * @Bean的name属性，指定对象的名称（id）
     */
    @Bean(name = "listStudent")
    public Student makeStudent(){
        Student s2  = new Student();
        s2.setName("李四");
        s2.setAge(22);
        s2.setSex("男");
        return s2;
    }
}

3、@ImporResource

@ImportResource 作用导入其他的XML配置文件，等于在XML。

<import resources="其他配置文件"/>

例如：

@Configuration
@ImportResource(value ={ "classpath:applicationContext.xml","classpath:beans.xml"})
public class SpringConfig {
}

4、@PropertyResource

@PropertyResource：读取properties属性配置文件。使用属性配置文件可以实现外部化配置，在程序代码之外提供数据。

在resources目录下，创建properties文件，使用k-v的格式提供数据。
在PropertyResource 指定properties文件的位置。
使用 @Value(value="${key}") 。

@Configuration
@ImportResource(value ={ "classpath:applicationContext.xml","classpath:beans.xml"})
@PropertySource(value = "classpath:config.properties")
@ComponentScan(basePackages = "com.bjpowernode.vo")
public class SpringConfig {
}

5、起步依赖

Spring Boot的起步依赖（Starter Dependencies）是一组预配置的依赖项，用于快速启动特定类型的应用程序。这些起步依赖包含了应用程序所需的所有依赖库，以及必要的配置和默认设置。通过使用起步依赖，可以轻松地集成各种技术栈，如Web开发、数据库访问、安全性等。

在Spring Boot中，起步依赖本质上是一个Maven项目对象模型（POM），它定义了对其他库的传递依赖，这些依赖加在一起支持某项功能。 起步依赖的名字通常具有很好的可读性，从名字上就可以大致了解其功能。例如，spring-boot-starter-web 就是一个用于Web开发的起步依赖，它包含了 开发Web应用程序所需的所有核心库和配置 。

二、SpringBoot项目

1、SpringBoot的配置文件

配置文件名称：application.properties 对应 k=v 结构，application.yml 对应 k:v 结构。

application.properties 设置端口和上下文

#设置端口号
server.port=8082
#设置访问应用上下文路径， contextpath
server.servlet.context-path=/myboot

application.yml 设置端口和上下文

server:
  port: 8083
  servlet:
    context-path: /myboot2

实际项目搭建中，有存在开发环境，测试环境，上线的环境。每个环境有不同的配置信息，例如端口，上下文件，数据库url，用户名，密码等等。使用多环境配置文件，可以方便的切换不同的配置。

使用方式：创建多个配置文件，名称规则：application-环境名称.properties(yml) 。

创建开发环境的配置文件：application-dev.properties(application-dev.yml)
创建测试者使用的配置：application-test.properties

2、常见注解简介

@SpringBootApplication ：放在启动类上面，包含了三个注解。@SpringBootConfiguration， @EnableAutoConfiguration， @ComponentScan 。
@SpringBootConfiguration ：使用了该注解标注的类，可以作为配置文件使用的，可以使用Bean声明对象，注入到容器。
@EnableAutoConfiguration ：启用自动配置，把java对象配置好，注入到spring容器中。例如可以把mybatis的对象创建好，放入到容器中。
@ComponentScan ：扫描器，找到注解，根据注解的功能创建对象，给属性赋值等等。有一个默认位置，Application位于主目录下，其余位于子包目录中。默认扫描的包： @ComponentScan所在的类所在的包和子包。
@RestController ：放在类的上面，创建控制器对象，注入到容器中。是一个复合注解 @Controller ，@ResponseBody, 使用这个注解类的，里面的控制器方法的返回值，都是数据。
@Controller ：放在类的上面，创建控制器对象，注入到容器中。
@Service ：放在业务层的实现类上面，创建service对象，注入到容器。
@Repository ：放在dao层的实现类上面，创建dao对象，放入到容器。持久层对象。
@Component ：放在类的上面，创建此类的对象，注入到容器中。和三层架构无关系，如果一个类不是持久层，也不是业务层，也不是控制层的，就使用这个。
@Value ：简单类型的赋值。
@Autowired ：引用类型赋值自动注入的，支持byName，byType，默认是byType。
@Qualifer ：给引用类型赋值，使用byName方式。@Autowird, @Qualifer都是Spring框架提供的。
@Resource ：来自jdk中的定义， javax.annotation。实现引用类型的自动注入，支持byName, byType。默认是byName, 如果byName失败，再使用byType注入。在属性上面使用。
@Configuration ：放在类的上面，表示这是个配置类，相当于xml配置文件
@Bean ：放在方法的上面，把方法的返回值对象，注入到spring容器中。
@ImportResource ：加载其他的xml配置文件，把文件中的对象注入到spring容器中
@PropertySource ：读取其他的properties属性配置文件。
@ResponseBody ：放在方法的上面，表示方法的返回值是数据，不是视图。
@RequestBody ：把请求体中的数据，读取出来，转为java对象使用。
@ControllerAdvice ：控制器增强，放在类的上面，表示此类提供了方法，可以对controller增强功能。
@ExceptionHandler ：处理异常的，放在方法的上面。
@Transcational ：处理事务的，放在service实现类的public方法上面，表示此方法有事务
@ConfigurationProperties ：把配置文件的数据映射为java对象。

3、@ConfigurationProperties

属性：prefix 配置文件中的某些key的开头的内容。

@Component
@ConfigurationProperties(prefix = "school")
@Data
public class SchoolInfo {
    private String name;
    private String website;
    private String address;
}

application.properties文件配置

#配置端口号
server.port=8082
#context-path
server.servlet.context-path=/myboot

#自定义key=value
school.name=青灯文案
school.website=www.qdwa.com
school.address=上海市普通新区
site=www.qdwa.com

4、创建拦截器

拦截器是SpringMVC中一种对象，能拦截器对Controller的请求。拦截器框架中有系统的拦截器，还可以自定义拦截器。实现对请求预先处理。

实现自定义拦截器：

1、创建类实现SpringMVC框架的HandlerInterceptor接口

public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }
    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }
    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

2、需在SpringMVC的配置文件中，声明拦截器

<mvc:interceptors>
	<mvc:interceptor>
    	<mvc:path="url" />
        <bean class="拦截器类全限定名称"/>
    </mvc:interceptor>
</mvc:interceptors>

3、SpringBoot中注册拦截器

@Configuration
public class MyAppConfig implements WebMvcConfigurer {
    //添加拦截器对象， 注入到容器中
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //创建拦截器对象
        HandlerInterceptor interceptor = new LoginInterceptor();
        //指定拦截的请求uri地址
        String path []= {"/user/**"};
        //指定不拦截的地址
        String excludePath  [] = {"/user/login"};
        registry.addInterceptor(interceptor).addPathPatterns(path).excludePathPatterns(excludePath);
    }
}

5、创建Servlet

在SpringBoot框架中使用Servlet对象。

创建Servlet类。创建类继承HttpServlet

//创建Servlet类
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //使用HttpServletResponse输出数据，应答结果
        resp.setContentType("text/html;charset=utf-8");
        PrintWriter out  = resp.getWriter();
        out.println("===执行的是Servlet==");
		out.flush();
        out.close();
    }
}

注册Servlet，让框架能找到Servlet

@Configuration
public class WebApplicationConfig {
    // 定义方法， 注册Servlet对象
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){
        // public ServletRegistrationBean(T servlet, String... urlMappings)
	// 第一个参数是 Servlet对象， 第二个是url地址
        // ServletRegistrationBean bean = new ServletRegistrationBean(new MyServlet(),"/myservlet");
        ServletRegistrationBean bean = new ServletRegistrationBean();
        bean.setServlet( new MyServlet());
        bean.addUrlMappings("/login","/test"); // <url-pattern>
	return bean;
    }
}

6、创建过滤器

Filter是Servlet规范中的过滤器，可以处理请求，对请求的参数，属性进行调整。常常在过滤器中处理字符编码。

创建自定义过滤器类

// 自定义过滤器
public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, 
	FilterChain filterChain) throws IOException, ServletException {
        System.out.println("执行了MyFilter，doFilter ");
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

注册Filter过滤器对象

@Configuration
public class WebApplicationConfig {
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean bean  = new FilterRegistrationBean();
        bean.setFilter( new MyFilter());
        bean.addUrlPatterns("/user/*");
        return bean;
    }
}

7、创建字符集过滤器

CharacterEncodingFilter：解决post请求中乱码的问题。

第一种方式：

1、配置字符集过滤器

@Configuration
public class WebSystemConfig {
	// 注册Servlet
	@Bean
	public ServletRegistrationBean servletRegistrationBean(){
		MyServlet myServlet = new MyServlet();
		ServletRegistrationBean reg = new ServletRegistrationBean(myServlet,"/myservlet");
		return reg;
	}
	// 注册Filter
	@Bean
	public FilterRegistrationBean filterRegistrationBean(){
		FilterRegistrationBean reg = new FilterRegistrationBean();
		//使用框架中的过滤器类
		CharacterEncodingFilter filter = new CharacterEncodingFilter();
		//指定使用的编码方式
		filter.setEncoding("utf-8");
		//指定request，response都使用encoding的值
		filter.setForceEncoding(true);
		reg.setFilter(filter);
		//指定 过滤的url地址
		reg.addUrlPatterns("/*");
		return reg;
	}
}

2、修改 application.properties 文件，让自定义的过滤器起作用。

#SpringBoot中默认已经配置了CharacterEncodingFilter。编码默认ISO-8859-1
#设置enabled=false 作用是关闭系统中配置好的过滤器，使用自定义的CharacterEncodingFilter
server.servlet.encoding.enabled=false

第二种方式： 修改 application.properties 文件

server.port=9001
server.servlet.context-path=/myboot
#让系统的CharacterEncdoingFilter生效
server.servlet.encoding.enabled=true
#指定使用的编码方式
server.servlet.encoding.charset=utf-8
#强制request，response都使用charset属性的值
server.servlet.encoding.force=true

三、MyBatis框架操作MySQL

使用MyBatis框架操作数据，在SpringBoot框架集成MyBatis

MyBatis起步依赖：完成MyBatis对象自动配置，对象放在容器中。
pom.xml 指定把 src/main/java 目录中的xml文件包含到classpath中。
创建实体类Student。
创建Dao接口StudentDao，创建一个查询学生的方法。
创建Dao接口对应的Mapper文件，xml文件，写sql语句。
创建Service层对象，创建StudentService接口和他的实现类。去dao对象的方法。完成数据库的操作。
创建Controller对象，访问Service。
写 application.properties 文件，配置数据库的连接信息。

1、@Mapper

@Mapper：放在dao接口的上面，每个接口都需要使用这个注解。

/**
 * @Mapper：告诉MyBatis这是dao接口，创建此接口的代理对象。
 *     位置：在类的上面
 */
@Mapper
public interface StudentDao {
    Student selectById(@Param("stuId") Integer id);
}

2、@MapperScan

/**
 * @MapperScan: 找到Dao接口和Mapper文件
 *     basePackages：Dao接口所在的包名
 */
@SpringBootApplication
@MapperScan(basePackages = {"com.bjpowernode.dao","com.bjpowernode.mapper"})
public class Application {
}

3、Mapper文件和Dao接口分开管理

把Mapper文件放在 resources 目录下，在 resources 目录中创建子目录 mapper 。
把mapper文件放到 mapper 目录中。
在 application.properties 文件中，指定 mapper 文件的目录。

#指定mapper文件的位置
mybatis.mapper-locations=classpath:mapper/*.xml
#指定mybatis的日志
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

在 pom.xml 中把 resources 目录中的文件，编译到目标目录中。

<!--resources插件-->
<resources>
   <resource>
      <directory>src/main/resources</directory>
      <includes>
         <include>**/*.*</include>
      </includes>
   </resource>
</resources>

四、RESTful风格

RESTful风格是一种面向资源的软件架构风格，它 基于HTTP协议 ，通过定义一组统一的接口和交互方式，来提高系统的可扩展性、可靠性和可维护性。其核心设计思想是资源的表示、标识和状态转移。

在RESTful风格中，每个资源都有一个唯一的URI（统一资源标识符），客户端通过HTTP请求访问这些资源，并使用HTTP方法来执行特定的操作。例如，GET用于检索资源，POST用于创建资源，PUT用于更新资源，DELETE用于删除资源。

RESTful风格适用于各种网络应用程序，尤其是移动互联网厂商作为业务接口的场景，实现第三方调用移动网络资源的功能。通过使用RESTful风格，可以简化应用程序之间的通信和交互，提高系统的灵活性和可扩展性。

主要特点：

资源：将应用程序的功能封装为资源，每个资源都有一个唯一的标识符（URI）。资源可以是数据实体、集合、服务等。
无状态性：服务器不会保存客户端的状态信息。每个请求应该是独立的，服务器不依赖于先前的请求状态。
使用URI来定位资源：通过使用URI来标识和定位资源，客户端可以通过合适的URI来访问和操作特定的资源。
使用HTTP状态码：使用HTTP状态码来表示操作结果的状态和信息。例如，200表示成功，404表示资源未找到，500表示服务器错误等。
使用合适的数据格式：通常使用JSON或XML等常见的数据格式来表示资源的表示形式。

后续添加Restful示例

五、SpringBoot项目打包简介

1、打包war文件

创建了一个jsp应用，修改 pom.xml 。

1、指定打包后的文件名称

<build>
   <!--打包后的文件名称-->
   <finalName>myboot</finalName>
</build>

2、指定jsp编译目录

<!--resources插件， 把jsp编译到指定的目录-->
<resources>
   <resource>
      <directory>src/main/webapp</directory>
      <targetPath>META-INF/resources</targetPath>
      <includes>
         <include>**/*.*</include>
      </includes>
   </resource>

   <!--使用了mybatis ，而且mapper文件放在src/main/java目录-->
   <resource>
      <directory>src/main/java</directory>
      <includes>
         <include>**/*.xml</include>
      </includes>
   </resource>

   <!--把src/main/resources下面的所有文件，都包含到classes目录-->
   <resource>
      <directory>src/main/resources</directory>
      <includes>
         <include>**/*.*</include>
      </includes>
   </resource>
</resources>

3、执行打包是war

<!--打包类型-->
<packaging>war</packaging>

4、主启动类继承SpringBootServletInitializer

/**
 * SpringBootServletInitializer: 继承这个类， 才能使用独立tomcat服务器
 */
@SpringBootApplication
public class JspApplication  extends SpringBootServletInitializer  {

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

   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
      return builder.sources(JspApplication.class);
   }
}

5、部署war

把war放到tomcat等服务器的发布目录中。 tomcat为例， myboot.war放到tomcat/webapps目录。

2、打包为jar文件

创建了一个包含了jsp的项目，修改 pom.xml 。

1、指定打包后的文件名称

<build>
   <!--打包后的文件名称-->
   <finalName>myboot</finalName>
</build>

2、指定 springboot-maven-plugin 版本

<plugins>
   <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
      <!--打包jar， 有jsp文件时，必须指定maven-plugin插件的版本是 1.4.2.RELEASE-->
      <version>1.4.2.RELEASE</version>
   </plugin>
</plugins>

3、最后执行 maven clean package

在target目录中，生成jar文件，例子是myboot.jar
执行独立的springboot项目，在cmd中java -jar myboot.jar

六、Thymeleaf模板引擎

Thymeleaf是一款现代化的服务器端Java模板引擎，适用于Web和独立应用场景。它具备处理HTML、XML、JavaScript、CSS以及纯文本的能力，为开发者提供了一种优雅且自然的模板设计方式，使得开发者能够更加便捷地构建、创建和维护结构化且语义正确的Web页面。

Thymeleaf可以轻易地与Spring MVC等Web框架进行集成，作为Web应用的模板引擎。它的应用场景非常广泛，无论是传统的服务器端Web应用程序、单页应用程序，还是移动Web应用程序，Thymeleaf都能够轻松应对。而且，它不仅可以用于动态内容的生成，还可以用于生成静态内容，如电子邮件模板等，为开发者提供了极大的便利和灵活性。

在语法上，Thymeleaf提供了变量表达式、链接表达式、消息表达式等多种表达式，用于访问模板上下文中的变量、生成URL、支持国际化等功能。

Thymeleaf是一款功能强大、灵活易用的模板引擎，适用于各种Web和非Web应用场景。如需更多关于Thymeleaf模板引擎的信息，建议查阅其官方文档或相关教程。

1、主要特点

动静结合：Thymeleaf模板既可以直接使用浏览器打开，查看页面的静态效果，也可以通过Web应用程序进行访问，查看动态页面效果。
开箱即用：Thymeleaf提供了Spring标准方言以及一个与SpringMVC完美集成的可选模块，可以快速地实现表单绑定、属性编辑器、国际化等功能。
多方言支持：它提供了Thymeleaf标准和Spring标准两种方言，可以直接套用模板实现JSTL、OGNL表达式。必要时，开发人员也可以扩展和创建自定义的方言。

此外，

2、变量表表达式

2.1、标准变量表达式

语法：${key}

作用：获取key对于的文本数据，key 是request作用域中的key，使用 request.setAttribute()，model.addAttribute()，在页面中的 html标签中，使用 th:text="${key}"。

<div style="margin-left: 400px">
    <h3>标准变量表达式:  ${key}</h3>
    <p th:text="${site}">key不存在</p>
    <br/>
    <p>获取SysUser对象 属性值</p>
    <p th:text="${myuser.id}">id</p>
    <p th:text="${myuser.name}">姓名</p>
    <p th:text="${myuser.sex}">姓名：m男</p>
    <p th:text="${myuser.age}">年龄</p>
    <p th:text="${myuser.getName()}">获取姓名使用getXXX</p>
</div>

2.2、选择变量表达式（星号变量表达式）

语法：*{key}

作用：获取这个key对应的数据，{key} 需要和 th:object 这个属性一起使用。目的是简单获取对象的属性值。

<p>使用 *{} 获取SysUser的属性值</p>
	<div th:object="${myuser}">
		<p th:text="*{id}"></p>
		<p th:text="*{name}"></p>
		<p th:text="*{sex}"></p>
		<p th:text="*{age}"></p> 
	</div>
<p>使用*{}完成的表示 对象的属性值</p>
<p th:text="*{myuser.name}" ></p>

2.3、链接表达式

语法：@{url}

作用：表示链接

    <script src="..."> , <link href="..."> <a href=".."> ,<form action="..."> <img src="...">

3、Thymeleaf属性

属性是放在html元素中的，就是html元素的属性，加入了 th前缀 。属性的作用不变。加入上th，属性的值由模板引擎处理了。在属性可以使用变量表达式。

<form action="/loginServlet" method="post"></form>
<form th:action="/loginServlet" th:method="${methodAttr}"></form>

4、Thymeleaf语法

4.1、each

each循环，可以循环List，Array

语法：在一个html标签中，使用 th:each 。

<div th:each="集合循环成员,循环的状态变量:${key}">
    <p th:text="${集合循环成员}" ></p>
</div>
集合循环成员,循环的状态变量:两个名称都是自定义的。 “循环的状态变量”这个名称可以不定义，默认是"集合循环成员Stat"

each循环Map

在一个html标签中，使用 th:each 。

<div th:each="集合循环成员,循环的状态变量:${key}">
    <p th:text="${集合循环成员.key}" ></p>
    <p th:text="${集合循环成员.value}" ></p>
</div>
集合循环成员,循环的状态变量:两个名称都是自定义的。 “循环的状态变量”这个名称可以不定义，默认是"集合循环成员Stat"
key:map集合中的key
value：map集合key对应的value值

4.2、th:if

"th:if" ：判断语句，当条件为true，显示html标签体内，反之不显示没有else语句

语法：
<div th:if=" 10 > 0 "> 显示文本内容 </div>

还有一个 th:unless 和 th:if 相反的行为

语法：
<div th:unless=" 10 < 0 "> 当条件为false显示标签体内容 </div>

例子：th:if

<div style="margin-left: 400px">
        <h3> if 使用</h3>
        <p th:if="${sex=='m'}">性别是男</p>
        <p th:if="${isLogin}">已经登录系统</p>
        <p th:if="${age > 20}">年龄大于20</p>
        <!--""空字符是true-->
        <p th:if="${name}">name是“”</p>
        <!--null是false-->
        <p th:if="${isOld}"> isOld是null</p>
 </div>

例子： th:unless

 <div style="margin-left: 400px">
        <h3>unless: 判断条件为false，显示标签体内容</h3>
        <p th:unless="${sex=='f'}">性别是男的</p>
        <p th:unless="${isLogin}">登录系统</p>
        <p th:unless="${isOld}"> isOld是null </p>
 </div>

4.3、th:switch

th:switch 和Java中的 swith 一样的

语法：
<div th:switch="要比对的值">
    <p th:case="值1">
        结果1
    </p>
    <p th:case="值2">
        结果2
    </p>
    <p th:case="*">
        默认结果
    </p>
    以上的case只有一个语句执行    
</div>

4.4、th:inline

1、内联text：在html标签外，获取表达式的值

   <p>显示姓名是：[[${key}]]</p> 
   <div style="margin-left: 400px">
          <h3>内联 text, 使用内联表达式显示变量的值</h3>
          <div th:inline="text">
              <p>我是[[${name}]]，年龄是[[${age}]]</p>
              我是<span th:text="${name}"></span>,年龄是<span th:text="${age}"></span>
          </div>
          <div>
              <p>使用内联text</p>
              <p>我是[[${name}]],性别是[[${sex}]]</p>
          </div>
   </div>

2、内联Javascript

例子：
 <script type="text/javascript" th:inline="javascript">
         var myname = [[${name}]];
         var myage = [[${age}]];

         //alert("获取的模板中数据 "+ myname + ","+myage)

        function fun(){
            alert("单击事件，获取数据 "+ myname + ","+ [[${sex}]])
        }
    </script>

4.5、字面量

 <div style="margin-left: 400px">
       <h3>文本字面量: 使用单引号括起来的字符串</h3>
       <p th:text="'我是'+${name}+',我所在的城市'+${city}">数据显示</p>

       <h3>数字字面量</h3>
       <p th:if="${20>5}"> 20大于 5</p>

       <h3>boolean字面量</h3>
       <p th:if="${isLogin == true}">用户已经登录系统</p>

       <h3>null字面量</h3>
       <p th:if="${myuser != null}">有myuser数据</p>
 </div>

4.6、字符串连接

1、语法使用单引号括起来字符串，使用 + 连接其他的字符串或者表达式

  <p th:text="'我是'+${name}+',我所在的城市'+${city}">数据显示</p>

2、语法使用双竖线， |字符串和表达式|

<p th:text="|我是${name},我所在城市${city|">
    显示数据
</p>

示例：

    <div style="margin-left: 400px">
       <h3>字符串连接方式1：使用单引号括起来的字符串</h3>
       <p th:text="'我是'+${name}+',我所在的城市'+${city}">数据显示</p>
        <br/>
        <br/>
        <h3>字符串连接方式2：|字符串和表达式|</h3>
        <p th:text="|我是${name},所在城市${city},其他人${myuser.name}|"></p>
    </div>

4.7、运算符

算术运 算： + , - - , * , / , %
关系比较 : > , < , >= , <= ( gt , lt , ge , le )
相等判断： == , != ( eq , ne )
<div style="margin-left: 400px">
	<h3>使用运算符</h3>
	<p th:text="${age > 10}">年龄大于 10 </p>
	<p th:text="${ 20 + 30 }">显示运算结果</p>
    <p th:if="${myuser == null}">myuser是null</p>
    <p th:if="${myuser eq null}">myuser是null</p>
    <p th:if="${myuser ne null}">myuser不是null</p>

    <p th:text="${isLogin == true ? '用户已经登录' : '用户需要登录'}"></p>
    <p th:text="${isLogin == true ? ( age > 10 ? '用户是大于10的' : '用户年龄比较小') : '用户需要登录'}"></p>
</div>
三元运算符：
 表达式  ？ true的结果 : false的结果
三元运算符可以嵌套

4.8、内置对象

文档地址：内置对象描述

#request 表示 HttpServletRequest
#session 表示 HttpSession对象
session 表示Map对象的，是#session的简单表示方式，用来获取session中指定的key的值
#session.getAttribute("loginname") 等同于 session.loginname

这些是内置对象，可以在模板文件中直接使用。

<div style="margin-left: 350px">
	<h3>内置对象#request,#session，session的使用</h3>
	<p>获取作用域中的数据</p>
	<p th:text="${#request.getAttribute('requestData')}"></p>
	<p th:text="${#session.getAttribute('sessionData')}"></p>
	<p th:text="${session.loginname}"></p>
	<br/>
	<br/>
	<h3>使用内置对象的方法</h3>
	getRequestURL=<span th:text="${#request.getRequestURL()}"></span><br/>
	getRequestURI=<span th:text="${#request.getRequestURI()}"></span><br/>
	getQueryString=<span th:text="${#request.getQueryString()}"></span><br/>
	getContextPath=<span th:text="${#request.getContextPath()}"></span><br/>
	getServerName=<span th:text="${#request.getServerName()}"></span><br/>
	getServerPort=<span th:text="${#request.getServerPort()}"></span><br/>
</div>

4.9、内置工具类

内置工具类型： Thymeleaf自己的一些类，提供对string， date ，集合的一些处理方法

#dates：处理日器的工具类
#numbers：处理数字的
#lists：处理list集合的

<div style="margin-left: 350px">
	<h3>日期类对象 #dates</h3>
	<p th:text="${#dates.format(mydate )}"></p>
	<p th:text="${#dates.format(mydate,'yyyy-MM-dd')}"></p>
	<p th:text="${#dates.format(mydate,'yyyy-MM-dd HH:mm:ss')}"></p>
	<p th:text="${#dates.year(mydate)}"></p>
	<p th:text="${#dates.month(mydate)}"></p>
	<p th:text="${#dates.monthName(mydate)}"></p>
	<p th:text="${#dates.createNow()}"></p>
	<br/>
	<h3>内置工具类#numbers，操作数字的</h3>
	<p th:text="${#numbers.formatCurrency(mynum)}"></p>
	<p th:text="${#numbers.formatDecimal(mynum,5,2)}"></p>
	<br/>
	<h3>内置工具类#strings,操作字符串</h3>
	<p th:text="${#strings.toUpperCase(mystr)}"></p>
	<p th:text="${#strings.indexOf(mystr,'power')}"></p>
	<p th:text="${#strings.substring(mystr,2,5)}"></p>
	<p th:text="${#strings.substring(mystr,2)}"></p>
	<p th:text="${#strings.concat(mystr,'---java开发的黄埔军校---')}"></p>
	<p th:text="${#strings.length(mystr)}"></p>
	<p th:text="${#strings.length('hello')}"></p>
	<p th:unless="${#strings.isEmpty(mystr)}"> mystring 不是 空字符串  </p>
	<br/>
	<h3>内置工具类#lists,操作list集合</h3>
	<p th:text="${#lists.size(mylist)}"></p>
	<p th:if="${#lists.contains(mylist,'a')}">有成员a</p>
	<p th:if="!${#lists.isEmpty(mylist)}"> list 集合有多个成员</p>
	<br/>
	<h3>处理null</h3>
	<p th:text="${zoo?.dog?.name}"></p>
</div>

青灯文案

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot简介，包含常见注解，RESTFul风格和Thymeleaf等内容

主要介绍了SpringBoot项目中的一些常用注解，配置类方式，介绍了如何创建过滤器、Servlet和监听器等方式，MyBatis操作MySQL的方式，和Thymeleaf模板使用语法
复制链接

扫一扫