springboot中获得app_SpringBoot

最新推荐文章于 2024-05-25 08:34:46 发布

in whitney

最新推荐文章于 2024-05-25 08:34:46 发布

阅读量438

点赞数

文章标签： springboot中获得app

本文链接：https://blog.csdn.net/weixin_42515339/article/details/112280970

版权

这篇博客详细介绍了Spring Boot的初级阶段，包括项目的搭建、整合servlet、Filter、Listener、静态资源访问、文件上传、以及整合jsp、Freemarker、Thymeleaf等。还深入讲解了Thymeleaf的语法，并提供了Spring Boot整合MyBatis进行CRUD操作的步骤。

摘要由CSDN通过智能技术生成

Spring Boot

概念

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

核心：约定大于配置

特点

1. 创建独立的Spring应用程序

2. 嵌入的Tomcat，无需部署WAR文件

3. 简化Maven配置，可以通过添加启动器坐标的方式自动导入对应、依赖的jar包

4. 自动配置Spring

5. 提供生产就绪型功能，如指标，健康检查和外部配置

6. 绝对没有代码生成并且对XML也没有配置要求

初级阶段

1. SpringBoot项目的搭建

1.1 前提

1）在http://spring.io（spring官网）中可以找到springboot的坐标

2） Springboot对于版本对jdk版本有要求,2.0.0以上的jdk版本是要1.8及以上，2.0.0以下版本就是1.7及以下版本

3） Springboot的坐标有两部分，一个是它继承的父坐标，还一个是它的启动器坐标，我们创建的项目必须也要继承它的父坐标

1.2 创建一个jar项目

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.21.RELEASE</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

1.3 测试环境

注意：启动类和控制器一定要在同一个包下，因为启动器在启动时候是在当前包下查找控制器

所以启动器的位置只能和控制器同一包或者在控制器的上一级别包中

@Controller
public class Hello {

 @RequestMapping("/hello")
 @ResponseBody
 public Map<String,Object> helloword(){
 Map<String,Object> map=new HashMap<>();
        map.put("msg","hello");
 return map;
    }
}

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

2. SpringBoot整合servlet

2.1 思路

Servlet的使用就是用于处理tomcat接收的请求

在web.xml中servlet的配置方式有两部分

<servlet>
 <servlet-name>FirstServlet</servlet-name>
 <servlet-class>com.bjsxt.servlet.FirstServlet</servlet-class>
</servlet>
 
<servlet-mapping>
 <servlet-name>FirstServlet</servlet-name>
 <url-pattern>/first</url-pattern>
</servlet-mapping>

在sprngBoot中servlet对于这些配置有两种方式可以完成

在servlet实体类中添加@WebServlet（name=”” , urlPatterns=””）并在启动类中通过@ServletComponentScan用于扫描完成

在启动类中，通过@bean注解声明方法getServletRegistrationBean

该方法中创建一个ServletRegistrationBean，并且通过调用addUrlMappings（）方法添加拦截路径

2.2 第一种整合方式（基于注解）

@WebServlet(name = "FirstServlet",urlPatterns = "/first") //创建Servlet
public class FirstServlet extends HttpServlet {
 @Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 System.out.println("first");
    }
}

@SpringBootApplication //代表将此类设置为启动类
@ServletComponentScan  //在 springBoot 启动时会扫描@WebServlet，并将该类实例化
public class App {   //创建启动器   
 public static void main(String[] args) {
 SpringApplication.run(App.class,args);
    }
}

2.3 第二种整合方式（方法）

/**
 * SpringBoot 整合 Servlet 方式二
 */
public class MethodServlet extends HttpServlet {  //创建servlet
 @Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 System.out.println("MethodServlet");
    }
}

/**
 * SpringBoot 整合 Servlet 方式二
 */
@SpringBootApplication
public class App2 {   //创建启动器
 public static void main(String[] args) {
 SpringApplication.run(App.class,args);
    }

 @Bean
 public ServletRegistrationBean getServletRegistrationBean(){
 ServletRegistrationBean bean=new ServletRegistrationBean();
        bean.addUrlMappings("/MethodServlet");
 return bean;
    }
}

3. SpringBoot整合Filter

3.1 Filter

它使用户可以改变一个request和修改一个response.

Filter 不是一个servlet，它不能产生一个response，它能够在一个request到达servlet之前预处理request，也可以在response离开servlet时处理response.换种说法，filter其实是一个“servlet chaining“（servlet 链）.

Filter就是一个拦截器，可以拦截请求进行预处理，然后在将请求放行

3.2 整合思路

和servlet一样，在springboot中它也有两种方式

在Filer实体类中添加@WebFilter（filterName=”” , urlPatterns=””）

在启动类添加@ServletComponentScan

urlPatterns的参数是一个可变参数，代表可以设置多个拦截路径

在启动类中，通过@bean注解声明方法getFilterRegistrationBean

该方法中创建一个FilterRegistrationBean，并且通过调用addUrlMappings（）方法添加拦截路径，方法参数是一个字符串数组

3.3 第一种整合方式（注解）

3.3.1 filter

package com.app.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

/**
 *SpringBoot 整合 Filter 方式一
 *<filter>
 * <filter-name>FirstFilter</filter-name>
 * <filter-class>com.filter.FirstFilter</filter-class>
 *</filter>
 *<filter-mapping>
 * <filter-name>FirstFilter</filter-name>
 * <url-pattern>/first</url-pattern>
 *</filter-mapping>
 */
//@WebFilter(filterName="FirstFilter",urlPatterns={"*.do","*.jsp"})
@WebFilter(filterName="FirstFilter",urlPatterns="/first")
public class FirstFilter implements Filter {
 @Override
 public void init(FilterConfig filterConfig) throws ServletException {

    }
 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
 System.out.println("进入 SecondFilter");
 filterChain.doFilter(servletRequest, servletResponse);
 System.out.println("离开 SecondFilter");
    }
 @Override
 public void destroy() {

    }
}

3.3.2 启动类

/**
 *SpringBoot 整合 Filter 方式一
 *
 */
@SpringBootApplication
@ServletComponentScan
public class App {
 public static void main(String[] args) {
 SpringApplication.run(App.class, args);
    }
}

3.4 第二种整合方式（方法）

3.4.1 filter

package com.app.filter;


import javax.servlet.*;
import java.io.IOException;
import java.util.logging.LogRecord;

/**
 *
 *SpringBoot 整合 Filter 方式二
 *
 */
public class MethodFilter implements Filter {
 @Override
 public void init(FilterConfig filterConfig) throws ServletException {

    }

 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
 System.out.println("进入 SecondFilter");
 filterChain.doFilter(servletRequest, servletResponse);
 System.out.println("离开 SecondFilter");
    }

 @Override
 public void destroy() {

    }
}

3.4.2 启动类

package com.app.filter;


import javax.servlet.*;
import java.io.IOException;
import java.util.logging.LogRecord;
/**
 *
 *SpringBoot 整合 Filter 方式二
 *
 */
public class MethodFilter implements Filter {
 @Override
 public void init(FilterConfig filterConfig) throws ServletException {

    }
 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
 System.out.println("进入 SecondFilter");
 filterChain.doFilter(servletRequest, servletResponse);
 System.out.println("离开 SecondFilter");
    }
 @Override
 public void destroy() {

    }
}

4. SpringBoot整合Listener

4.1 Listener

web监听器是一种Servlet中的特殊的类，它们能帮助开发者监听web中的特定事件，比如ServletContext,HttpSession,ServletRequest的创建和销毁；变量的创建、销毁和修改等。可以在某些动作前后增加处理，实现监控。

监听器常用的用途

　　通常使用Web监听器做以下的内容：

　　统计在线人数，利用HttpSessionLisener

　　加载初始化信息：利用ServletContextListener

　　统计网站访问量

实现访问监控

4.2 实现思路

和servlet一样，在springboot中它也有两种方式

在Listener实体类中添加@WebListener

在启动类中，通过@bean注解声明方法getServletListenerRegistrationBean

该方法中创建一个ServletListenerRegistrationBean<T> 对象返回

4.3 第一种整合方式（注解）

4.3.1 创建Listener

package com.app.Listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

/**
 * springBoot 整合 Listener
 *
 *<listener>
 * <listener-class>com.bjsxt.listener.FirstListener</listener-class>
 *</listener>
 */
@WebListener
public class FirstListener  implements ServletContextListener {
 @Override
 public void contextInitialized(ServletContextEvent servletContextEvent) {

    }

 @Override
 public void contextDestroyed(ServletContextEvent servletContextEvent) {
 System.out.println("Listener...init......");
    }
}

4.3.2 创建启动类

package com.app;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
/**
 * springBoot 整合 Listener 方式一
 *
 *
 */
@SpringBootApplication
@ServletComponentScan
public class App {
 public static void main(String[] args) {
 SpringApplication.run(App.class, args);
    }
}

4.4 第二种整合方式（方法）

4.4.1 创建Listener

package com.app.Listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class MethodListener implements ServletContextListener {
 @Override
 public void contextInitialized(ServletContextEvent servletContextEvent) {

    }

 @Override
 public void contextDestroyed(ServletContextEvent servletContextEvent) {
 System.out.println("Listener...init......");
    }
}

4.4.2 创建启动类

package com.app;

import com.app.Listener.MethodListener;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.context.annotation.Bean;

/**
 * springBoot 整合 Listener 方式二
 *
 *
 */
@SpringBootApplication
@ServletComponentScan
public class App2 {
 public static void main(String[] args) {
 SpringApplication.run(App2.class, args);
    }
 /**
     * 注册Listener
     */
 @Bean
 public ServletListenerRegistrationBean<MethodListener> getServletListenerRegistrationBean(){
 ServletListenerRegistrationBean<MethodListener> bean=new ServletListenerRegistrationBean<>(new MethodListener());
 return bean;
    }
}

5. 访问静态资源

5.1 前提

A) SpringBoot 中静态资源访问从 classpath/static 的目录进行

目录名称必须是 static

B) SpringBoot 中静态资源在ServletContext 根目录下

目录名称必须要 webapp

6. 文件上传

6.1 显示页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8" />
    <title>文件上传</title>
</head>
<body>
<form action="fileUploadController" method="post" enctype="multipart/form-data">
    上传文件:<input type="file" name="filename"/>
    <input type="submit"/>
</form>
</body>
</html>

6.2 创建Controller

package com.app.controller;
/**
 * SpringBoot 文件上传
 */
@RestController  //这个注解的作用可以将所有的响应都转换成JSON格式
public class FileUploadController {
 /**
     * 处理文件上传
     */
 @RequestMapping("/fileUploadController")
 public Map<String,Object> fileUpload(MultipartFile filename){
 //输出的上传的文件名
 System.out.println(filename.getOriginalFilename());
 try {
 //将文件写入磁盘
 filename.transferTo(new File("e:/"+filename.getOriginalFilename()));
        }catch (Exception e){
 e.printStackTrace();
        }

 Map<String,Object> map=new HashMap<>();
        map.put("msg","ok");
 return map;
    }
}

6.3 创建启动类

package com.app;

import com.app.controller.FileUploadController;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 文件上传
 */
@SpringBootApplication
public class App {
 public static void main(String[] args) {
 SpringApplication.run(App.class,args);
    }
}

6.4 设置文件上传大小

spring.http.multipart.maxFileSize=200MB
spring.http.multipart.maxRequestSize=200MB

7. SpringBoot整合jsp

7.1 pom配置

因为springboot并不推荐使用jsp，所以内置类库中并不提供对jsp的支持，所以整合需要导入相关的依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.21.RELEASE</version>
    </parent>

    <groupId>com.king</groupId>
    <artifactId>06-spring-boot-view-jsp</artifactId>
    <version>1.0-SNAPSHOT</version>

 <!-- 修改jdk -->
 <properties>
        <java.version>1.7</java.version>
    </properties>


    <dependencies>
 <!-- springboot的启动器 -->
 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

  <!-- jstl -->
 <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>

  <!-- jasper  tomcat中对于jsp处理的一个jsp引擎 -->
 <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>

7.2 创建 springBoot 的全局配置文件，application.properties

这个全局配置文件用于配置对jsp访问的前缀、后缀

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

7.3 创建Controller提供请求处理

package com.app.controller;

import com.pojo.Users;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

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

/**
 * SpringBoot整合jsp
 */
@Controller
public class UserController {
 @RequestMapping("/showUser")
 public String showUser(Model model){
 List<Users> list=new ArrayList<>();
        list.add(new Users("张三",12,"男"));
        list.add(new Users("小红",20,"女"));
        list.add(new Users("王五",100,"男"));
 model.addAttribute("list",list);
 return "userList";
    }
}

7.4 创建启动类

略

8. SpringBoot 整合 Freemarker

8.1 pom配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

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

    <groupId>com.king</groupId>
    <artifactId>07-springboot-view-freemarker</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

 <!-- 修改jdk -->
 <properties>
        <java.version>1.7</java.version>
    </properties>

    <dependencies>
 <!-- springBoot 的启动器 -->
 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 <!-- freemarker 启动器的坐标 -->
 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
    </dependencies>
</project>

8.2 创建视图层

注意：springBoot 要求模板形式的视图层技术的文件必须要放到 src/main/resources 目录下必

须要一个名称为 templates

8.3 创建controller

package com.controller;

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

import com.pojo.Users;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * SpringBoot整合marker
 *
 *
 */
@Controller
public class UserController {
 /*
    * 处理请求，产生数据
    */
 @RequestMapping("/showUser")
 public String showUser(Model model){
 List<Users> list = new ArrayList<>();
      list.add(new Users(1,"张三",20));
      list.add(new Users(2,"李四",22));
      list.add(new Users(3,"王五",24));
 
 //需要一个Model对象
 model.addAttribute("list", list);
 //跳转视图
 return "userList";
   }
}

8.4 创建视图层

<html>
   <head>
      <title>展示用户数据</title>
      <meta charset="utf-9"></meta>
   </head>
 
   <body>
 
      <table border="1" align="center" width="50%">
 
         <tr>
 
            <th>ID</th>
            <th>Name</th>
            <th>Age</th>
         </tr>
 
 <#list list as user >
 <tr>
               <td>${user.userid}</td>
               <td>${user.username}</td>
               <td>${user.userage}</td>
            </tr>
 </#list>   
 </table>
   </body>
</html>

9. SpringBoot 整合 Thymeleaf

Thymelaef 是通过他特定语法对 html 的标记做渲染。

1.Thymeleaf 在有网络和无网络的环境下皆可运行，即它可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果。这是由于它支持 html 原型，然后在 html 标签里增加额外的属性来达到模板+数据的展示方式。浏览器解释 html 时会忽略未定义的标签属性，所以 thymeleaf 的模板可以静态地运行；当有数据返回到页面时，Thymeleaf 标签会动态地替换掉静态内容，使页面动态显示。

2.Thymeleaf 开箱即用的特性。它提供标准和spring标准两种方言，可以直接套用模板实现JSTL、 OGNL表达式效果，避免每天套模板、该jstl、改标签的困扰。同时开发人员也可以扩展和创建自定义的方言。

3. Thymeleaf 提供spring标准方言和一个与 SpringMVC 完美集成的可选模块，可以快速的实现表单绑定、属性编辑器、国际化等功能。

9.1 导入pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

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

    <groupId>com.king</groupId>
    <artifactId>08-SpringBoot-view-Thymeleaf</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

 <!-- 修改jdk -->
 <properties>
        <java.version>1.7</java.version>
  <thymeleaf.version>3.0.2.RELEASE</thymeleaf.version>
        <thymeleaf-layout-dialect.version>2.0.4</thymeleaf-layout-dialect.version>
    </properties>

    <dependencies>
 <!-- springBoot 的启动器 -->
 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 <!-- springBoot 的启动器 -->
 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
    </dependencies>
</project>

9.2 创建视图层资源目录

目录位置：src/main/resources/templates

templates：该目录是安全的。意味着该目录下的内容是不允许外界直接访问的

9.3 创建controller

package com.app.controller;import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.RequestMapping;@Controllerpublic class DemoController {@RequestMapping("/show")public String showInfo(Model model){
model.addAttribute("msg", "Thymeleaf 第一个案例");return "index";
}
}

9.4 创建视图层

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8"/>
<title>Thymeleaf入门</title>
</head>
<body>
<span th:text="Hello"></span>
<hr/>
<span th:text="${msg}"></span>
</body>
</html>

10. Thymeleaf 语法详解

10.1 变量输出与字符串操作

10.1.1 th:text

th:text

在页面中输出值

10.1.2 th:value

th:value

可以将一个值放入到 input 标签的 value 中

10.2 判断字符串是否为空

Thymeleaf 内置对象

注意语法：

1，调用内置对象一定要用#

2，大部分的内置对象都以 s 结尾 strings、numbers、dates

${#strings.isEmpty(key)}

判断字符串是否为空，如果为空返回 true，否则返回 false

<span th:text="${#strings.isEmpty(msg)}"></span>
 
${#strings.contains(msg,'T')}

判断字符串是否包含指定的子串，如果包含返回 true，否则返回 false

<span th:text="${#strings.contains(msg,'结')}">true</span><br/>
 
 
 
${#strings.startsWith(msg,'a')}

判断当前字符串是否以子串开头，如果是返回 true，否则返回 false

<span th:text="${#strings.startsWith(msg,'结')}">true</span><br/>
 
 
${#strings.endsWith(msg,'a')}

判断当前字符串是否以子串结尾，如果是返回 true，否则返回 false

<span th:text="${#strings.endsWith(msg,'结')}">false</span><br/>
 
 
${#strings.length(msg)}

返回字符串的长度

<span th:text="${#strings.length(msg)}">length</span><br/>
 
 
${#strings.indexOf(msg,'h')}

查找子串的位置，并返回该子串的下标，如果没找到则返回-1

<span th:text="${#strings.indexOf(msg,'哈')}">indexOf</span><br/>
 
 
${#strings.substring(msg,13)}
${#strings.substring(msg,13,15)}

截取子串，用户与 jdk String 类下 SubString 方法相同

<span th:text="${#strings.substring(msg,13)}">substring</span><br/>
<span th:text="${#strings.substring(msg,13，15)}">substring</span><br/>

 
${#strings.toUpperCase(msg)}
${#strings.toLowerCase(msg)}

字符串转大小写

<span th:text="${#strings.toUpperCase(msg)}">toUpperCase</span><br/>
<span th:text="${#strings.toLowerCase(msg)}">toLowerCase</span><br/>

10.3 日期格式化处理

${#dates.format(key)}

格式化日期，默认的以浏览器默认语言为格式化标准

<span th:text="${#dates.format(key)}"></span><br/>
 
 
${#dates.format(key,'yyy/MM/dd')}

按照自定义的格式做日期转换

<span th:text="${#dates.format(key,'yyy/MM/dd')}"></span><br/>
 
 
 
${#dates.year(key)}
${#dates.month(key)}
${#dates.day(key)}
 
year：取年
Month：取月
Day：取日
<span th:text="${#dates.year(key)}"></span><br/>
<tr/>
<span th:text="${#dates.month(key)}"></span><br/>
<tr/>
<span th:text="${#dates.day(key)}"></span><br/>

10.4 条件判断

10.4.1 th:if

<span th:if="${sex}== '男' ">男</span>
<span th:if="${sex}=='女' ">女</span>

10.4.2 th:switch

div th:switch="${id}">
    <span th:case="1">ID为1</span>
    <span th:case="2">ID为2</span>
    <span th:case="3">ID为3</span>
    <span th:case="4">ID为4</span>
    <span th:case="5">ID为5</span>
</div>

10.5 迭代遍历

package com.app.controller;

import com.pojo.Users;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

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

@Controller
public class DemoController5 {
 @RequestMapping("/index5")
 public String showInfo(Model model){
 List<Users> list=new ArrayList<>();
        list.add(new Users(1,"张三",20));
        list.add(new Users(2,"李四",20));
        list.add(new Users(3,"王五",20));
 model.addAttribute("list",list);
 return "index5";
    }
}

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <table border="1">
        <tr>
            <th>ID</th>
            <th>Name</th>
            <th>Age</th>
        </tr>
        <tr th:each="u : ${list}">
            <td th:text="${u.userid}"></td>
            <td th:text="${u.username}"></td>
            <td th:text="${u.userage}"></td>
        </tr>
    </table>
 </body>
</html>

10.6 状态变量

package com.app.controller;

import com.pojo.Users;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

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

@Controller
public class DemoController6 {
 @RequestMapping("/index6")
 public String showInfo(Model model){
 List<Users> list=new ArrayList<>();
        list.add(new Users(1,"张三",20));
        list.add(new Users(2,"李四",20));
        list.add(new Users(3,"王五",20));
 model.addAttribute("list",list);
 return "index6";
    }
}

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <table border="1">
        <tr>
            <th>ID</th>
            <th>Name</th>
            <th>Age</th>
            <th>Index</th>
            <th>Count</th>
            <th>Size</th>
            <th>Even</th>
            <th>Odd</th>
            <th>First</th>
            <th>lase</th>
        </tr>
        <tr th:each="u,var : ${list}">
            <td th:text="${u.userid}"></td>
            <td th:text="${u.username}"></td>
            <td th:text="${u.userage}"></td>
            <td th:text="${var.index}"></td>
            <td th:text="${var.count}"></td>
            <td th:text="${var.size}"></td>
            <td th:text="${var.even}"></td>
            <td th:text="${var.odd}"></td>
            <td th:text="${var.first}"></td>
            <td th:text="${var.last}"></td>
        </tr>
    </table>
</body>
</html>

状态变量属性

1,index:当前迭代器的索引从 0 开始

2,count:当前迭代对象的计数从 1 开始

3,size:被迭代对象的长度

4,even/odd:布尔值，当前循环是否是偶数/奇数从 0 开始

5,first:布尔值，当前循环的是否是第一条，如果是返回 true 否则返回 false

6,last:布尔值，当前循环的是否是最后一条，如果是则返回 true 否则返回 false

10.7 th:each 迭代 Map

package com.app.controller;

import com.pojo.Users;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Controller
public class DemoController7 {
 @RequestMapping("/index7")
 public String showInfo(Model model){
 Map<String,Users> map=new HashMap<>();
        map.put("u1",new Users(1,"张三",20));
        map.put("u1",new Users(2,"李四",20));
        map.put("u1",new Users(3,"王五",20));
 model.addAttribute("map",map);
 return "index7";
    }
}
 
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <table border="1">
        <tr>
            <th>ID</th>
            <th>Name</th>
            <th>Age</th>
        </tr>
        <tr th:each="maps : ${map}">
            <td th:each="entry : ${maps}" th:text="${entry.value.userid}"></td>
            <td th:each="entry : ${maps}" th:text="${entry.value.username}"></td>
            <td th:each="entry : ${maps}" th:text="${entry.value.userage}"></td>
        </tr>
    </table>
</body>
</html>

10.8 域对象操作

package com.app.controller;

import com.pojo.Users;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

@Controller
public class DemoController8 {
 @RequestMapping("/index8")
 public String showInfo(HttpServletRequest request,Model model){
 request.setAttribute("req","request");
 request.getSession().setAttribute("sessopm","HttpSession");
 request.getSession().getServletContext().setAttribute("context","HttpServletContext");
 return "index8";
    }
}
 
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <table border="1">
        <tr>
            <th>request</th>
            <th>session</th>
            <th>context</th>
        </tr>
        <tr th:each="maps : ${map}">
            <td th:text="${httpServletRequest.getAttribute('req')}"></td>
            <td th:text="${session.sessopm}"></td>
            <td th:text="${application.context}"></td>
        </tr>
    </table>
</body>
</html>

10.9 URL 表达式

th:href

th:src

基本语法：@{}

10.9.1 URL 类型

绝对路径

<a th:href="@{http://www.baidu.com}">绝对路径</a><br/>

相对路径

1)相对于当前项目的根
相对于项目的上下文的相对路径
<a th:href="@{~/project2/resourcename}">相对于服务器的根</a>
<a th:href="@{/show}">相对路径</a>

10.9.2 在 url 中通过 restful 风格进行参数传递

<a th:href="@{/show(id=1,name=zhagnsan)}">相对路径-传参</a>
<a th:href="@{/path/{id}/show(id=1,name=zhagnsan)}">相对路径-传参-restful</a>

11. SpringBoot整合MyBatis

11.1 创建项目，导入坐标

a) 添加web启动器坐标，并设置新的版本

b) 添加jsp引擎坐标，并设置新的版本

c) 添加mybatis启动器坐标

d) 添加mysql数据库驱动坐标

e) 添加数据库连接池的坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

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

    <groupId>com.king</groupId>
    <artifactId>09-SpringBoot-Springmvc--MyBatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.7</java.version>
        <thymeleaf.version>3.0.2.RELEASE</thymeleaf.version>
        <thymeleaf-layout-dialect.version>2.0.4</thymeleaf-layout-dialect.version>
    </properties>

    <dependencies>
 <!-- springmvc 的启动器 -->
 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 <!-- jsp启动器 -->
 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
 <!-- Mybatis 启动器 -->
 <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
 <!-- mysql 数据库驱动 -->
 <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
 <!-- druid 数据库连接池 -->
 <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.9</version>
        </dependency>
    </dependencies>
</project>

11.2 创建全局配置文件application.properties

spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root



spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
mybatis.type-aliases-package=com.pojo  #给实体类起别名

11.3 完成CRUD操作

11.3.1 创建实体类

正常创建一个users JavaBean

11.3.2 创建mapper接口和映射文件

正常创建

11.3.3 创建业务层

正常创建

@Transactional 该注解开启所以方法的事务

11.3.4 创建 Controller

正常创建

11.3.5 创建视图层

<form th:action="@{/users/adduser}" method="post">
   用户姓名：<input type="text" name="name"/><br/>
   用户年龄：<input type="text" name="age"/><br/>
   <input type="submit" value="确定"/><br/>
</form>

11.3.6 创建启动类

package com.app;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
@MapperScan("com.app.mapper")
public class App {
 public static void main(String[] args) {
 SpringApplication.run(App.class,args);
    }
}