1.开端介绍
1.两种核心配置文件同时存在(properties的优先级高于yml)
2.多环境下核心配置文件
3.获取自定义配置
4.将自定义配置映射到对象
5.springboot集成jsp
<!--引入springboot内嵌Tomcat对jsp的解析依赖,不添加解析不了jsp-->
<!--仅仅只是展示jsp页面,只添加以下一个依赖-->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>
<bulid>
<!--
springboot项目默认推荐使用的前端引擎是thymeleaf
现在我们要使用springboot集成jsp,手动指定jsp最后编译的路径
而且springboot集成jsp编译jsp的路径是springboot规定好的位置
META-INF/resources
-->
<resources>
<resource>
<!--源文件-->
<directory>src/main/webapp</directory>
<!--指定编译到META-INF/resources-->
<targetPath>META-INF/resources</targetPath>
<!--指定源文件夹中那个资源要编译进行-->
<includes>
<include>*.*</include>
</includes>
</resource>
</resources>
</bulid>
2. springboot框架web开发
1.集成mybatis 所需的依赖
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<!--mybatis整合springboot框架的起步依赖-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.2.0</version>
</dependency>
2.Mybatis创建逆向工程 (步骤)
<!--mybatis代码自动生成插件-->
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.6</version>
<configuration>
<!--配置文件的位置-->
<configurationFile>GeneratorMapper.xml</configurationFile>
<verbose>true</verbose>
<overwrite>true</overwrite>
</configuration>
</plugin>
GeneratorMapper.xml:
<?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPEgeneratorConfiguration
PUBLIC"-//mybatis.org//DTDMyBatisGeneratorConfiguration1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
<!--指定连接数据库的JDBC驱动包所在位置,指定到你本机的完整路径-->
<classPathEntrylocation="D:\222\abo\mysql-connector-java-5.1.37.jar"/>
<!--配置table表信息内容体,targetRuntime指定采用MyBatis3的版本-->
<contextid="tables"targetRuntime="MyBatis3">
<!--抑制生成注释,由于生成的注释都是英文的,可以不让它生成-->
<commentGenerator>
<propertyname="suppressAllComments"value="true"/>
</commentGenerator>
<!--connectionURL="jdbc:mysql://192.168.80.129:3306/springboot"-->
<!--配置数据库连接信息-->
<jdbcConnectiondriverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/ssm1"
userId="root"
password="123456">
</jdbcConnection>
<!--生成model类,targetPackage指定model类的包名,targetProject指定
生成的model放在eclipse的哪个工程下面-->
<javaModelGeneratortargetPackage="com.jihu.model"
targetProject="src/main/java">
<propertyname="enableSubPackages"value="false"/>
<propertyname="trimStrings"value="false"/>
</javaModelGenerator>
<!--生成MyBatis的Mapper.xml文件,targetPackage指定mapper.xml文件的
包名,targetProject指定生成的mapper.xml放在eclipse的哪个工程下面-->
<sqlMapGeneratortargetPackage="com.jihu.mapper"
targetProject="src/main/java">
<propertyname="enableSubPackages"value="false"/>
</sqlMapGenerator>
<!--生成MyBatis的Mapper接口类文件,targetPackage指定Mapper接口类的包
名,targetProject指定生成的Mapper接口放在eclipse的哪个工程下面-->
<javaClientGeneratortype="XMLMAPPER"
targetPackage="com.jihu.mapper"targetProject="src/main/java">
<propertyname="enableSubPackages"value="false"/>
</javaClientGenerator>
<!--数据库表名及对应的Java模型类名-->
<tabletableName="user"domainObjectName="User"
enableCountByExample="false"
enableUpdateByExample="false"
enableDeleteByExample="false"
enableSelectByExample="false"
selectByExampleQueryId="false"/>
</context>
</generatorConfiguration>
application.properties:(指定了mybatis映射文件路径)
#设置连接数库的配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/ssm1?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=123456
#指定mybatis映射文件的路径
mybatis.mapper-locations=classpath:mapper/*.xml
server.port=9001
开启扫描mapper的两种办法
第一种
第二种
UserController
@RestController
public class UserController {
@Autowired
private UserService userService;
@RequestMapping("/user")
public Object user(Integer id){
User user = userService.queryUserById(id);
return user;
}
}
UserService
public interface UserService {
//根据学生id查询详情
User queryUserById(Integer id) ;
}
UserServiceImpl
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
@Override
public User queryUserById(Integer id) {
return userMapper.selectByPrimaryKey(id);
}
}
UserMapper
package com.jihu.mapper;
import com.jihu.model.User;
import org.apache.ibatis.annotations.Mapper;
@Mapper //扫描DAO接口道spring容器
public interface UserMapper {
int deleteByPrimaryKey(Integer id);
int insert(User record);
int insertSelective(User record);
User selectByPrimaryKey(Integer id);
int updateByPrimaryKeySelective(User record);
int updateByPrimaryKey(User record);
}
UserMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jihu.mapper.UserMapper">
<resultMap id="BaseResultMap" type="com.jihu.model.User">
<!-- id 标签只能修改主键字段-->
<!-- result 除了主键以外的字段-->
<!--
column 数据库中的字段名称
property 映射对象的属性名称
jdbcType 列中数据库中字段的类型(可以省略不写)
-->
<!--
resultMap 作用:
1.当数据库中字段名称与实体类对象的属性名不一致时,可以进行转换
2.当前查询的结果没有对象一个表的时候,可以自定义一个结果集
-->
<!--
数据库表字段名称 实体对象属性名称
user_name userName
product_type productType
-->
<!--
如果数据库中字段名称由多个单词构成,通过mybatis逆向工程生成的对象属性名称 会按照驼峰命名法规则生成属性名称
其中:数据库中字段名称由多个单词构成的时候必须使用 _ 下划线分隔
-->
<id column="id" jdbcType="INTEGER" property="id" />
<result column="username" jdbcType="VARCHAR" property="username" />
<result column="password" jdbcType="VARCHAR" property="password" />
</resultMap>
<!-- sql语句片段, 将公共的部分抽取出来 -->
<sql id="Base_Column_List">
id, username, password
</sql>
<select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from user
where id = #{id,jdbcType=INTEGER}
</select>
<delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
delete from user
where id = #{id,jdbcType=INTEGER}
</delete>
<insert id="insert" parameterType="com.jihu.model.User">
insert into user (id, username, password
)
values (#{id,jdbcType=INTEGER}, #{username,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR}
)
</insert>
<!--
trim: 拼接用的
suffixOverrides:去除多余的逗号
-->
<insert id="insertSelective" parameterType="com.jihu.model.User">
insert into user
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null">
id,
</if>
<if test="username != null">
username,
</if>
<if test="password != null">
password,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null">
#{id,jdbcType=INTEGER},
</if>
<if test="username != null">
#{username,jdbcType=VARCHAR},
</if>
<if test="password != null">
#{password,jdbcType=VARCHAR},
</if>
</trim>
</insert>
<update id="updateByPrimaryKeySelective" parameterType="com.jihu.model.User">
update user
<set>
<if test="username != null">
username = #{username,jdbcType=VARCHAR},
</if>
<if test="password != null">
password = #{password,jdbcType=VARCHAR},
</if>
</set>
where id = #{id,jdbcType=INTEGER}
</update>
<update id="updateByPrimaryKey" parameterType="com.jihu.model.User">
update user
set username = #{username,jdbcType=VARCHAR},
password = #{password,jdbcType=VARCHAR}
where id = #{id,jdbcType=INTEGER}
</update>
</mapper>
User
@Data
public class User {
private Integer id;
private String username;
private String password;
}
3.springboot支持事务
springboot项目下使用事务:
事务是一个完整的功能,也叫做是一个完整的业务
事务只跟什么sql语句有关系? 事务只跟DML语句有关系:增删改
DML,DQL,DDL,TCL,DCL
4.使用 RESTful
5.拦截器(重要)
springboot使用拦截器步骤:
a.定义一个拦截器,实现HandlerInterceptor接口
b.创建一个配置类(即:在SpringMVC配置文件中使用 mvc:interceptors标签)
InterceptorConfig
package com.jihu.config;
import com.jihu.interceptor.UserInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration //定义此类为配置文件(即相当于之前的xml配置文件)
public class InterceptorConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
//要拦截user下的所有访问请求,必须用户登录后才能访问,
//但是这样拦截的路径中有一些是不需要用户登录也可访问的
String[] addPathPattererns = {
"/user/**"
};
//要排除的路径,排除的路径说明不需要用户登录也可以访问
String[] excludePathPatterns={
"/user/out","/user/error","/user/login"
};
registry.addInterceptor(new UserInterceptor()).addPathPatterns(addPathPattererns).excludePathPatterns(excludePathPatterns);
}
}
UserInterceptor
public class UserInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("进入拦截器----------------");
//编写业务拦截的规则
//从session中获取用户的信息
User user = (User) request.getSession().getAttribute("user");
//判断用户是否登录
if (user == null){
//未登录
response.sendRedirect(request.getContextPath() + "/user/error");
return false;
}
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
}
}
UserController
package com.jihu.web;
import com.jihu.model.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
@RestController
@RequestMapping("/user")
public class UserController {
//用户登录请求
@RequestMapping("/login")
public Object login(HttpServletRequest request){
//将用户信息存放到session
User user = new User();
user.setId(1002);
user.setUsername("zhangsan");
request.getSession().setAttribute("user",user);
return "Login Success";
}
//该请求需要用户登录之后才可以访问
@RequestMapping("/center")
public Object center(){
return "See Center Message";
}
//该请求不登录也可以访问
@RequestMapping("/out")
public Object out(){
return "out";
}
//如果用户未登录访问了需要登录才可访问的请求,之后会跳转至该请求路径
@RequestMapping("/error")
public Object error(){
return "error";
}
}
User
@Data
public class User {
private Integer id;
private String username;
}
6.使用 filter(过滤器)
案例1:使用注解方式
案例2:使用注册组件方式
案例1;
MyFilter
package com.jihu.filter;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
@WebFilter(urlPatterns = "/myfilter")
public class MyFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest,
ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
System.out.println("------------您已进入过滤器-------------");
filterChain.doFilter(servletRequest,servletResponse);
}
}
Application
@SpringBootApplication
@ServletComponentScan(basePackages = "com.jihu.filter")
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
案例2:
@Configuration //定义此类为配置类
public class FilterConfig {
@Bean
public FilterRegistrationBean myFilterRegistrationBean(){
//注册过滤器
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new MyFilter());
//添加过滤路径
filterRegistrationBean.addUrlPatterns("/user/*");
return filterRegistrationBean;
}
}
MyFilter
public class MyFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
System.out.println("------------您已进入过滤器 22222-------------");
filterChain.doFilter(servletRequest,servletResponse);
}
}
UserController
@RestController
public class UserController {
@RequestMapping("/user/detail")
public String userDetail(){
return "/user/detail";
}
@RequestMapping("/center")
public String center(){
return "center";
}
}
7.设置字符编码
springboot 框架下设置字符编码
第一种实现方式: 使用CharacterEncodingFilter
第二种实现方式: springboot字符编码设置(强力推荐)
第一种方式:
application.properties
#设置请求响应字符编码
server.servlet.encoding.enabled=true
server.servlet.encoding.force=true
server.servlet.encoding.charset=utf-8
MyServlet
package com.jihu.servlet;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet(urlPatterns = "/myservlet")
public class MyServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.getWriter().println("i love 中国");
//统一设置浏览器编码格式
resp.setContentType("text/html;charset=utf-8");
resp.getWriter().flush();
resp.getWriter().close();
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
Application
@SpringBootApplication
@ServletComponentScan(basePackages = "com.jihu.servlet")
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
第二种方式:
application.properties
#关闭springboot 的http字符编码支持
#只有关闭该选项后,spring字符编码过滤器才生效
server.servlet.encoding.enabled=false
SystemConfig
package com.jihu.config;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.CharacterEncodingFilter;
@Configuration
public class SystemConfig {
@Bean
public FilterRegistrationBean characterEncodingFilterRegistrationBean(){
//创建字符编码过滤器
CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
//设置强制使用指定字符编码
characterEncodingFilter.setForceEncoding(true);
//设置指定字符编码
characterEncodingFilter.setEncoding("UTF-8");
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
//设置字符编码过滤器
filterRegistrationBean.setFilter(characterEncodingFilter);
//设置字符编码过滤器路径
filterRegistrationBean.addUrlPatterns("/*");
return filterRegistrationBean;
}
}
MyServlet
package com.jihu.servlet;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet(urlPatterns = "/myservlet")
public class MyServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.getWriter().println("i love 中国");
//统一设置浏览器编码格式
resp.setContentType("text/html;charset=utf-8");
resp.getWriter().flush();
resp.getWriter().close();
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
Application
@SpringBootApplication
@ServletComponentScan(basePackages = "com.jihu.servlet")
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
8.logback日志
resources/logback-spring.xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为 TRACE < DEBUG < INFO < WARN < ERROR < FATAL,如果
设置为 WARN,则低于 WARN 的信息都不会输出 -->
<!-- scan:当此属性设置为 true 时,配置文件如果发生改变,将会被重新加载,默认值为
true -->
<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认
单位是毫秒。当 scan 为 true 时,此属性生效。默认的时间间隔为 1 分钟。 -->
<!-- debug:当此属性设置为 true 时,将打印出 logback 内部日志信息,实时查看 logback
运行状态。默认值为 false。通常不打印 -->
<configuration scan="true" scanPeriod="10 seconds">
<!--输出到控制台-->
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<!--此日志 appender 是为开发使用,只配置最底级别,控制台输出的日志级别是大
于或等于此级别的日志信息-->
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>debug</level>
</filter>
<encoder>
<Pattern>%date [%-5p] [%thread] %logger{60} [%file : %line] %msg%n
</Pattern>
<!-- 设置字符集 -->
<charset>UTF-8</charset>
</encoder>
</appender>
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<!--<File>/home/log/stdout.log</File>-->
<File>D:/log/stdout.log</File>
<encoder>
<pattern>%date [%-5p] %thread %logger{60} [%file : %line] %msg%n</pattern>
</encoder>
<rollingPolicy
class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 添加.gz 历史日志会启用压缩 大大缩小日志文件所占空间 -->
<!--<fileNamePattern>/home/log/stdout.log.%d{yyyy-MM-dd}.log</fileNam ePattern>-->
<fileNamePattern>D:/log/stdout.log.%d{yyyy-MM-dd}.log</fileNamePattern>
<maxHistory>30</maxHistory><!-- 保留 30 天日志 -->
</rollingPolicy>
</appender>
<!--单个定义-->
<logger name="com.bjpowernode.springboot.mapper" level="DEBUG"/>
<!--如果root标签指定的日志级别那么以根日志级别为准,如果没有则已当前追加器日志级别为准-->
<!--全部定义-->
<root level="INFO">
<appender-ref ref="CONSOLE"/>
<appender-ref ref="FILE"/>
</root>
</configuration>
3.thymeleaf
使用 thymeleaf 时必须加上命名空间
<html lang="en" xmlns:th="http://www.thymeleaf/org">
1.thymeleaf概述
2.springboot集成thymeleaf
application.properties
#设置thymeleaf模板引擎的缓存,设置为false(关闭), 默认为true(开启)
spring.thymeleaf.cache=false
#设置thymeleaf模板引擎的前缀/后缀(可选项)
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
IndexController
package com.jihu.web;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class IndexController {
@RequestMapping("/message")
public ModelAndView message(){
ModelAndView mv = new ModelAndView();
mv.addObject("msg","你好 China!");
mv.setViewName("message");
return mv;
}
@RequestMapping("/index")
public String index(Model model){
model.addAttribute("data","SpringBoot 引擎设置");
return "index";
}
}
message.html
<!DOCTYPE html>
<!--
xmlns:th="http://www.thymeleaf.org"
xmlns ->命名空间
命名空间后面的地址是一个约束文件,约束你使用thymeleaf表达式的一个规则文件,
就好比我们之前在xml文件中的一些dtd文件
-->
<!--
为什么使用了th 前缀就可以获取后台数据?
那是因为项目中添加了thymeleaf的核心依赖,它的核心依赖会去解析thymeleaf自己定义的这些
标签名称,通过thymeleaf自己的java核心代码来获取我们的后台数据
-->
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<!-- thymeleaf模板引擎的页面必须的通过中央调度器 -->
<h1 th:text="${msg}" >xxx </h1>
<h1 th:text="${msg}" >xxx </h1>
<h1 th:text="${msg}" > </h1>
<h1>Thymeleaf</h1>
<h1>Thymeleaf</h1>
</body>
</html>
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1 th:text="${data}">3</h1>
</body>
</html>
3.thymeleaf表达式–4种路径表达式
application.properties
#设置thymeleaf模板引擎的缓存,设置为false(关闭), 默认为true(开启)
spring.thymeleaf.cache=false
#设置thymeleaf模板引擎的前缀/后缀(可选项)
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
UserController
package com.jihu.web;
import com.jihu.model.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class UserController {
@RequestMapping("/user/detail")
public String user(Model model){
User user = new User();
user.setId(1001);
user.setUsername("lisi");
user.setAge(24);
model.addAttribute("user",user);
return "userDetail";
}
@RequestMapping("/url")
public String url(Model model){
model.addAttribute("id",1005);
model.addAttribute("username","zhangsan");
model.addAttribute("age",28);
return "url";
}
@RequestMapping("/test")
public @ResponseBody String test(String username){
return "请求路径/test,参数是:"+username;
}
@RequestMapping("/test1")
public @ResponseBody String test1(Integer id,String username,Integer age){
return "请求路径/test1,参数id:"+id+",username:"+username+",age:"+age;
}
@RequestMapping("/test2/{id}")
public @ResponseBody String test2(@PathVariable("id") Integer id){
return "ID="+id;
}
@RequestMapping("/test3/{id}/{username}")
public @ResponseBody String test3(@PathVariable("id") Integer id,
@PathVariable("username") String username ){
return "ID="+id+"-----username="+username;
}
@RequestMapping("/url2")
public String url2(){
return "url2";
}
@RequestMapping("/property")
public String property(){
return "property";
}
}
User
@Data
public class User {
private Integer id;
private String username;
private Integer age;
}
property.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>常见属性</title>
</head>
<body>
<form action="http://localhost:8080/test1" method="get">
用户编号;<input type="text" name="id" /><br>
用户姓名;<input type="text" name="username" /><br>
用户年龄;<input type="text" name="age" /><br>
<input type="submit" value="提交submit" />
</form>
<form th:action="@{/test1}" method="get">
用户编号;<input type="text" name="id" /><br>
用户姓名;<input type="text" name="username" /><br>
用户年龄;<input type="text" name="age" /><br>
<input type="submit" value="提交submit" />
</form>
<script type="text/javascript">
function test() {
alert("------");
}
</script>
<button th:onclick="test()">submit11</button>
<button onclick="test()">submit22</button>
</body>
</html>
url.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>URL路径表达式 : @{...}</h1>
<h2>a标签中的绝对路径(没有参数)</h2>
<a href="http://www.baidu.com">传统写法:跳至百度</a><br>
<a th:href="@{http://www.bjpowernode1.com}">路径表达式:转跳到动力节点</a><br>
<a th:href="@{http://localhost:8080/user/detail}">转跳至:/user/detail</a><br>
<a href="http://localhost:8080/user/detail">传统写法调至:/user/detail</a>
<h2>URL路径表达式,相对路径【没有参数】(实际开发中推荐使用)</h2>
<a th:href="@{/user/detail}">跳转到:/user/detail</a>
<h2>相对路径(带参数)</h2>
<a th:href="@{/test?username=lisi}" >相对路径,带参数</a><br>
<h2>相对路径(带参数,后台获取的参数值)</h2>
<!--/test?username=1005-->
<a th:href="@{'/test?username='+${id}}">相对路径,带参数,后台获取的参数值</a><br>
<h2>相对路径(带多个参数,后台获取的参数值)</h2>
<!-- /test1?id=1005&username=zhangsan&age=28 -->
<a th:href="@{'/test1?id='+${id}+'&username='+${username}+'&age='+${age}}" >相对路径(带多个参数:后台获取的参数值)</a><br>
<a th:href="@{/test1(id=${id},username=${username},age=${age})}">强烈推荐使用:@{}相对路径(带多个参数:后台获取的参数值)</a><br>
<a th:href="@{'/test2/'+${id}}"> 请求路径为RESTful风格</a><br>
<!--/test3/1005/zhangsan-->
<a th:href="@{'/test3/'+${id}+'/'+${username}}"> 请求路径为RESTful风格</a>
</body>
</html>
url2.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf/org">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script type="text/javascript" th:src="@{/js/jquery-3.4.1.js}"></script>
<script type="text/javascript">
$(function () {
// alert("----");
alert($("#username").val());
});
</script>
</head>
<body>
<input type="text" value="999" id="username" />
<img th:src="@{/img/1.jpg}">
</body>
</html>
userDetail.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1> 标准变量表达式 ;${} (推荐)</h1>
用户编号:<span th:text="${user.id}" > </span><br/>
用户姓名:<span th:text="${user.username}" > </span><br/>
用户年龄:<span th:text="${user.age}" > </span><br/>
<!--
*{}必须使用th:object属性来绑定这个对象
在div子标签中使用*来代替绑定的对象${user}
-->
<h1> 选择变量表达式(星号表达式) ;*{} ->(不推荐) </h1>
<div th:object="${user}">
用户编号:<span th:text="*{id}"></span><br/>
用户姓名:<span th:text="*{username}"></span><br/>
用户年龄:<span th:text="*{age}"></span><br/>
</div>
<h1> 标准变量表达式与选择变量表达式的混合使用 -> (不推荐) </h1>
用户编号:<span th:text="*{user.id}" > </span><br/>
用户姓名:<span th:text="*{user.username}" > </span><br/>
用户年龄:<span th:text="*{user.age}" > </span><br/>
</body>
</html>
3.循环遍历数组
UserController
package com.jihu.controller;
import com.jihu.model.User;
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 UserController {
@RequestMapping("/each/list")
public String eachList(Model model){
List<User> userList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
User user = new User();
user.setId(100+i);
user.setNick("尹"+1);
user.setPhone("1234561421"+i);
user.setAddress("北京大兴"+i);
userList.add(user);
}
model.addAttribute("userList",userList);
return "eachList";
}
@RequestMapping("/each/Map")
public String eachMap(Model model){
Map<Integer,Object> userMap = new HashMap<>();
for (int i = 0; i < 10; i++) {
User user = new User();
user.setId(100+i);
user.setNick("尹"+1);
user.setPhone("1234561421"+i);
user.setAddress("北京大兴"+i);
userMap.put(i,user);
}
model.addAttribute("userMap",userMap);
return "eachMap";
}
@RequestMapping("/each/array")
public String eacharray(Model model){
User[] userarray= new User[10];
for (int i = 0; i < 10; i++) {
User user = new User();
user.setId(100+i);
user.setNick("尹"+1);
user.setPhone("1234561421"+i);
user.setAddress("北京大兴"+i);
userarray[i]=user;
}
model.addAttribute("userarray",userarray);
return "eachArray";
}
}
User
@Data
public class User {
private Integer id;
private String nick;
private String phone;
private String address;
}
循环遍历Array数组(eachArray.html)
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>循环遍历Array数组</title>
</head>
<body>
<h1>循环遍历Array数组(使用方法同list一样)</h1>
<div th:each="userarray:${userarray}">
<span th:text="${userarrayStat.index}"></span>
<span th:text="${userarrayStat.count}"></span>
<span th:text="${userarray.id}"></span>
<span th:text="${userarray.nick}"></span>
<span th:text="${userarray.phone}"></span>
<span th:text="${userarray.address}"></span>
</div>
</body>
</html>
循环遍历list集合(eachList.html)
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>循环遍历list集合</title>
</head>
<body>
<!--
user :当前循环的对象变量名称(随意)
userStat 当前循环对象状态的变量(可选默认就是对象变量名称+Stat)
${userList} 当前循环的集合
-->
<div th:each="user,userStat:${userList}">
<span th:text="${userStat.index}"></span>
<span th:text="${userStat.count}"></span>
<span th:text="${user.id}"></span>
<span th:text="${user.nick}"></span>
<span th:text="${user.phone}"></span>
<span th:text="${user.address}"></span>
</div>
<br>
<div th:each="user:${userList}">
<span th:text="${userStat.count}"></span>
</div>
</body>
</html>
循环遍历Map集合(eachMap.html)
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>循环遍历Map集合</title>
</head>
<body>
<!--
Map集合结构
key value
0 user
1 user
2 user
.. ...
-->
<div th:each="userMap:${userMap}">
<span th:text="${userMapStat.index}"></span>
<span th:text="${userMapStat.count}"></span>
<span th:text="${userMap.key}"></span>
<span th:text="${userMap.value}"></span>
<span th:text="${userMap.value.id}"></span>
<span th:text="${userMap.value.nick}"></span>
<span th:text="${userMap.value.phone}"></span>
<span th:text="${userMap.value.address}"></span>
</div>
</body>
</html>
4.条件判断 (th:if)
UserController
@Controller
public class UserController {
@RequestMapping("/condition")
public String condition(Model model){
model.addAttribute("sex",1);
model.addAttribute("flag",true);
model.addAttribute("productType",0);
return "condition";
}
}
condition.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>条件判断</title>
</head>
<body>
<h2> th:if 用法:如果满足条件显示(执行),否则相反 </h2>
<div th:if="${sex eq 1}">
男
</div>
<div th:if="${sex eq 0}">
女
</div>
<h2>th:unless 用法:与th:if用法想法,即条件判断取反</h2>
<div th:unless="${sex ne 1}">
女
</div>
<h2> th:switch/th:case用法</h2>
<div th:switch="${productType}">
<span th:case="0">产品0</span>
<span th:case="1">产品1</span>
<span th:case="*">无此产品</span>
</div>
</body>
</html>
5.内敛表达式 (th:inline)
UserController
@Controller
public class UserController {
@RequestMapping("/inline")
public String inline(Model model){
model.addAttribute("data","springboot 111");
return "inline-test";
}
}
inline-test.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<div th:text="${data}"></div>
<h2>内敛文本: th:inline="text"</h2>
<div th:inline="text">
[[${data}]]
</div>
数据outside: [[${data}]]
<h2> 内敛脚本 th:inline="javascript" </h2>
<script type="text/javascript" th:inline="javascript">
function showData() {
alert([[${data}]]);
}
</script>
<button type="button" onclick="showData()">展示数据</button>
</body>
</html>
7.字面量
8.字符串拼接
9.数学运算
10.基本表达式对象
UserController
@Controller
public class UserController {
@RequestMapping("/index")
public String index(HttpServletRequest request, Model model,Integer id){
model.addAttribute("username","lisi");
request.getSession().setAttribute("data","sessionData");
return "index";
}
}
index.html
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>从SESSION中获取值</h1>
<span th:text="${#session.getAttribute('data')}"></span><br>
<span th:text="${#httpSession.getAttribute('data')}"></span><br>
<span th:text="${session.data}"></span><br>
<script type="text/javascript" th:inline="javascript">
//http://localhost:8080/springboot/user/inedx
//获取协议名称
var scheme = [[${#request.getScheme()}]];
//获取服务器端口号
var serverName = [[${#request.getServerName()}]];
//获取服务器端口号
var serverPort = [[${#request.getServerPort}]];
//获取上下文根
var contextPath = [[${#request.getContextPath()}]]; //现在上下文根为空
var allPath = scheme+"://"+serverName+":"+serverPort+contextPath;
alert(allPath);
var requestURL = [[${#httpServletRequest.requestURL}]]; //http://localhost:8080/index
var queryString = [[${#httpServletRequest.queryString}]]; //null 获取的参数 //id=101
alert(requestURL);
alert(queryString);
</script>
</body>
</html>
11.功能表达式对象(了解)
在此我向大家推荐一个架构学习交流圈。交流学习伪鑫:539413949(里面有大量的面试题及答案)里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多