SpringBoot整合SSM

其实更准确来说，是整合了myybatis。

1. 创建工程

这里我们推荐使用官方提供的springboot工具，我觉得这个其实听方便的。

 

 

 

 

 

 

 

需要依赖了可以再去加。需要注意的一点是，约定优于配置，这个看自己去理解了。

别的ide像eclipse、idea都是可以通过springboot插件实现和上面类似的方式第一种方式。至于怎么安装，详情见百度。

下面以idea为例，提供示例：

使用idea可以快速创建springboot的工程

 

 

 

这里选择常用的类库，springboot将各种框架类库都进行了封装，可以减少pom文件中的引用配置：

 

 

搞清楚差别，我们同样可以手动修改整合，不过既然有了项目构建框架，我们也实属没必要烧头发了。下面来对比下差别。

比如spring和mybatis整合的时候，传统spring项目中需要引入：

1 2 3 4 5 6 7 8 9 10

<dependency>    <groupid>org.mybatis</groupid>    <artifactid>mybatis</artifactid>    <version>3.4.1</version> </dependency> <dependency>    <groupid>org.mybatis</groupid>    <artifactid>mybatis-spring</artifactid>    <version>1.3.1</version> </dependency>

 

 

而在springboot中引入的是：

1 2 3 4 5

<dependency>    <groupid>org.mybatis.spring.boot</groupid>    <artifactid>mybatis-spring-boot-starter</artifactid>    <version>1.3.1</version> </dependency>

 

 

可以看到这个类库中除了mybatis和mybatis-spring之外，还有spring-boot的东西。

 

 

完整的pom.xml如下:

<parent>

    <groupid>org.springframework.boot</groupid>

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

    <version>1.5.10.release</version>

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

</parent>

<properties>

    <project.build.sourceencoding>utf-8</project.build.sourceencoding>

    <project.reporting.outputencoding>utf-8</project.reporting.outputencoding>

    <java.version>1.8</java.version>

</properties>

<dependencies>

    <dependency>

        <groupid>org.springframework.boot</groupid>

        <artifactid>spring-boot-starter-jdbc</artifactid>

    </dependency>

    <dependency>

        <groupid>org.springframework.boot</groupid>

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

    </dependency>

    <dependency>

        <groupid>org.springframework.boot</groupid>

        <artifactid>spring-boot-starter-aop</artifactid>

    </dependency>

    <dependency>

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

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

        <version>1.3.1</version>

    </dependency>

    <dependency>

        <groupid>org.springframework.boot</groupid>

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

        <scope>provided</scope>

    </dependency>

 

    <dependency>

        <groupid>mysql</groupid>

        <artifactid>mysql-connector-java</artifactid>

        <scope>runtime</scope>

    </dependency>

    <dependency>

        <groupid>org.springframework.boot</groupid>

        <artifactid>spring-boot-starter-test</artifactid>

        <scope>test</scope>

    </dependency>

    <!--使用jsp页面-->

    <dependency>

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

        <artifactid>tomcat-embed-jasper</artifactid>

    </dependency>

    <dependency>

        <groupid>jstl</groupid>

        <artifactid>jstl</artifactid>

        <version>1.2</version>

    </dependency>

</dependencies>

<build>

    <finalname>boot</finalname>

    <plugins>

        <plugin>

            <groupid>org.springframework.boot</groupid>

            <artifactid>spring-boot-maven-plugin</artifactid>

        </plugin>

    </plugins>

    <resources>

        <resource>

            <directory>src/main/java</directory>

            <includes>

                <include>**/*.xml</include>

            </includes>

        </resource>

        <resource>

            <directory>src/main/resources</directory>

            <includes>

                <include>**/*.xml</include>

                <include>**/*.properties</include>

            </includes>

        </resource>

    </resources>

</build>

完整的工程路径如下：

2. 实体类和dao

1 2 3 4 5 6	public class dept {     private integer id;     private string name;       //getter/setter方法略 }
1 2 3 4 5 6 7 8	public interface deptdao {     //查询列表，演示使用传统的mapper映射文件     list<dept> getdeltlist();     //插入，演示使用注解编写sql，省略xml配置     @insert("insert into dept(name) values(#{name})")     @options(usegeneratedkeys = true, keyproperty = "id", keycolumn = "id")     void adddept(string name); }

2. 实体类和dao

1 2 3 4 5 6	public class dept {     private integer id;     private string name;       //getter/setter方法略 }
1 2 3 4 5 6 7 8	public interface deptdao {     //查询列表，演示使用传统的mapper映射文件     list<dept> getdeltlist();     //插入，演示使用注解编写sql，省略xml配置     @insert("insert into dept(name) values(#{name})")     @options(usegeneratedkeys = true, keyproperty = "id", keycolumn = "id")     void adddept(string name); }

deptmapper.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.test.springboot.ssm.dao.deptdao">

 

    <resultmap id="deptmap" type="dept">

        <id property="id" column="id"/>

        <result property="name" column="name"/>

    </resultmap>

 

   <select id="getdeltlist" resultmap="deptmap">

       select id,name from dept

   </select>

</mapper>

3.service

1 2 3 4

public interface deptservice {     list<dept> getdeltlist();     void adddept(string name); }

@service

 public class deptserviceimpl implements deptservice {

     @autowired

     private deptdao deptdao;

  

 @override

     public list<dept> getdeltlist() {

         return deptdao.getdeltlist();

     }

 

    @override

    public void adddept(string name) {

        deptdao.adddept(name);

    }

}

4. controller和页面

@controller

 public class deptcontroller {

     @autowired

     private deptservice deptservice;

  

     @requestmapping("list.html")

     public modelandview list() {

         list<dept> deptlist = deptservice.getdeltlist();

         return new modelandview("list", "deptlist", deptlist);

    }

    @requestmapping("add.html")

    public string add(string name) {

        deptservice.adddept(name);

        //添加成功后重定向到列表页

        return "redirect:list.html";

    }

}

add.jsp

1 2 3 4

<form action="/add.html" method="post">     部门名:<input type="text" name="name"/><br/>     <input type="submit" value="add"/> </form>

list.jsp

1 2 3

<c:foreach items="${deptlist}" var="dept">     ${dept.id}-${dept.name}<br/> </c:foreach>

5.启动类

到目前为止，项目与传统的spring没有任何区别。

传统spring项目中需要增加下面两个配置文件，而springboot中没有配置文件：

传统spring项目中有以下文件：

spring-config.xml

<?xml version="1.0" encoding="utf-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

       http://www.springframework.org/schema/context/spring-context-4.2.xsd

       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

    <!--扫描@service注解-->

    <context:component-scan base-package="com.test.springboot.ssm.service">

        <context:include-filter type="annotation" expression="org.springframework.stereotype.service"/>

    </context:component-scan>

    <!--读取配置文件-->

    <context:property-placeholder location="classpath:db.properties" ignore-unresolvable="true"/>

    <!--从配置文件中获取数据源-->

    <bean id="datasource" class="org.springframework.jdbc.datasource.drivermanagerdatasource">

        <property name="driverclassname" value="${jdbc.driver}"/>

        <property name="url" value="${jdbc.url}"/>

        <property name="username" value="${jdbc.username}"/>

        <property name="password" value="${jdbc.password}"/>

    </bean>

 

    <!--spring管理session工厂-->

    <bean id="sqlsessionfactory" class="org.mybatis.spring.sqlsessionfactorybean">

        <property name="datasource" ref="datasource"/>

        <property name="mapperlocations" value="classpath:com/test/springboot/ssm/dao/mapper/*.xml"/>

        <!--配置实体类别名别名-->

        <property name="typealiasespackage" value="com.test.springboot.ssm.pojo"/>

    </bean>

     

    <!--扫描所有mybatis的dao接口，生成代理实现类-->

    <bean class="org.mybatis.spring.mapper.mapperscannerconfigurer">

        <property name="basepackage" value="com.test.springboot.ssm.dao"/>

    </bean>

     

    <!-- 配置事务管理器 -->

    <bean id="transactionmanager"

          class="org.springframework.jdbc.datasource.datasourcetransactionmanager">

        <property name="datasource" ref="datasource"/>

    </bean>

     

    <!--事务增强-->

    <tx:advice id="txadvice" transaction-manager="transactionmanager">

        <tx:attributes>

            <!-- 传播行为，匹配的是方法名 -->

            <tx:method name="add*" rollback-for="exception"/>

            <tx:method name="delete*" rollback-for="exception"/>

            <tx:method name="update*" rollback-for="exception"/>

            <tx:method name="get*" propagation="supports" read-only="true"/>

            <tx:method name="do*" rollback-for="exception"/>

        </tx:attributes>

    </tx:advice>

     

    <!-- 通过aop配置提供事务增强，让service包下所有bean的所有方法拥有事务 -->

    <aop:config>

        <aop:pointcut id="servicemethod"

                      expression="execution(* com.test.springboot.ssm..*(..))"/>

        <aop:advisor pointcut-ref="servicemethod" advice-ref="txadvice"/>

    </aop:config>

 

</beans>

springmvc-servlet.xml

<?xml version="1.0" encoding="utf-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:mvc="http://www.springframework.org/schema/mvc"

       xsi:schemalocation="

  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd

  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd

  http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd">

 

    <mvc:annotation-driven/>

    <!--扫描controller所在的包-->

    <context:component-scan base-package="com.ssm.blog.controller">

        <context:include-filter type="annotation" expression="org.springframework.stereotype.controller"/>

    </context:component-scan>

 

    <!-- 配置视图解析器-->

    <bean class="org.springframework.web.servlet.view.internalresourceviewresolver">

        <property name="prefix" value="/"></property><!--前缀-->

        <property name="suffix" value=".jsp"></property><!--后缀-->

    </bean>

 

</beans>

web.xml

<?xml version="1.0" encoding="utf-8"?>

<web-app xmlns="http://java.sun.com/xml/ns/javaee"

         xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"

         xsi:schemalocation="http://java.sun.com/xml/ns/javaee

          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"

         version="3.0">

    <context-param>

        <param-name>contextconfiglocation</param-name>

        <param-value>classpath:spring-config.xml</param-value>

    </context-param>

    <!--配置listener，在启动web容器的时候加载spring的配置-->

    <listener>

        <listener-class>org.springframework.web.context.contextloaderlistener</listener-class>

    </listener>

    <filter>

        <filter-name>characterencodingfilter</filter-name>

        <filter-class>org.springframework.web.filter.characterencodingfilter</filter-class>

        <init-param>

            <param-name>encoding</param-name>

            <param-value>utf-8</param-value>

        </init-param>

        <init-param>

            <param-name>forceencoding</param-name>

            <param-value>true</param-value>

        </init-param>

    </filter>

    <filter-mapping>

        <filter-name>characterencodingfilter</filter-name>

        <url-pattern>/*</url-pattern>

    </filter-mapping>

    <!--配置dispatcherservlet -->

    <servlet>

        <servlet-name>springmvc</servlet-name>

        <servlet-class>org.springframework.web.servlet.dispatcherservlet</servlet-class>

    </servlet>

    <servlet-mapping>

        <servlet-name>springmvc</servlet-name>

        <url-pattern>*.html</url-pattern>

    </servlet-mapping>

</web-app>

而springboot中不需要这三个配置文件,写一个启动类，运行main方法即可：

@springbootapplication

 @enabletransactionmanagement//开启事务管理

 @componentscan("com.test.springboot.ssm")//扫描注解元素

 @mapperscan("com.test.springboot.ssm.dao")//mybatis的dao所在包

 public class springbootssmapplication {

     public static void main(string[] args) {

         springapplication.run(springbootssmapplication.class, args);

     }

    public static final string transactionexecution = "execution (* com.test.springboot.service..*(..))";

    @autowired

    private datasource datasource;

    //声明式事务

    @bean

    public defaultpointcutadvisor defaultpointcutadvisor() {

        aspectjexpressionpointcut pointcut = new aspectjexpressionpointcut();

        pointcut.setexpression(transactionexecution);

        defaultpointcutadvisor advisor = new defaultpointcutadvisor();

        advisor.setpointcut(pointcut);

        properties attributes = new properties();

        attributes.setproperty("get*", "propagation_required,-exception");

        attributes.setproperty("add*", "propagation_required,-exception");

        attributes.setproperty("update*", "propagation_required,-exception");

        attributes.setproperty("delete*", "propagation_required,-exception");

        transactioninterceptor txadvice = new transactioninterceptor(new datasourcetransactionmanager(datasource), attributes);

        advisor.setadvice(txadvice);

        return advisor;

    }

}

数据库等配置信息放到application.properties中

#数据源的基本信息

 spring.datasource.url = jdbc:mysql://localhost:3306/test?characterencoding=utf-8

 spring.datasource.username = root

 spring.datasource.password =

 spring.datasource.driverclassname = com.mysql.jdbc.driver 

 #mybatis中mapper文件的路径

 mybatis.mapper-locations=classpath*:com/test/springboot/ssm/dao/mappers/*.xml

 #起别名。可省略写mybatis的xml中的resulttype的全路径

mybatis.type-aliases-package=com.test.springboot.ssm.pojo

#springmvc中的视图信息，响应前缀

spring.mvc.view.prefix=/

# 响应页面默认后缀

spring.mvc.view.suffix=.jsp

#dispatcherservlet中响应的url-pattern

server.sevlet-path=*.html

server.context-path=/boot

#logging.level.root=debug

logging.level.com.test.springboot.ssm.dao=trace

上面的程序只要启动main方法就可以访问了。

另外，如果需要打包发布到tomcat，需要再配置一个servletinitializer，否则tomcat启动后会出现404。

1 2 3 4 5 6

public class servletinitializer extends springbootservletinitializer {     @override     protected springapplicationbuilder configure(springapplicationbuilder application) {         return application.sources(springbootssmapplication.class);     } }

5. 启动原理解析

任何一个springboot程序都有一个启动类：

1 2 3 4 5 6

@springbootapplication public class startapplication {     public static void main(string[] args) {         springapplication.run(startapplication.class, args);     } }

启动类中包含@springbootapplication注解和springapplication.run()方法

5.1@springbootapplication

@springbootapplication是一个组合注解，除了基本的原信息标注以外，重要的注解有三个：

@configuration

@enableautoconfiguration

@componentscan

如下代码等同于使用@springbootapplication注解

1 2 3 4 5 6 7 8

@configuration @enableautoconfiguration @componentscan public class startapplication {     public static void main(string[] args) {         springapplication.run(startapplication.class, args);     } }

每次写三个注解比较繁琐，所以使用@springbootapplication更方便。

5.1.1  @configuration

简单的说，springboot中使用一个@configuration注解的类代替xml配置文件。

如spring-config.xml如下：

1 2 3 4 5 6 7

<?xml version="1.0" encoding="utf-8"?> <beans xmlns="http://www.springframework.org/schema/beans"        xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"        xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd        ">     <!--定义bean--> </beans>

springboot中写成：

1 2 3 4

import org.springframework.context.annotation.configuration; @configuration public class springconfig { }

如果定义一个bean,xml中写成：

1 2 3 4 5 6 7 8

<bean id="dept" class="com.spring.test.springboot.pojo.dept">     <property name="id" value="1"/> </bean>   <bean id="employee" class="com.spring.test.springboot.pojo.employee">     <property name="name" value="tom"/>     <property name="dept" ref="dept"/> </bean>

springboot中写成：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

@bean  public dept dept() {      dept dept = new dept();      dept.setid(1);      return dept;  }     @bean  public employee employee() {     employee employee = new employee();     employee.setname("tom");     employee.setdept(dept());//注入依赖对象直接调用@bean注解的方法     return employee; }

springboot中使用@bean标注一个方法，该方法的方法名将默认成bean的id。注意@configuration的类要被@componentscan扫描到。

5.1.2 @componentscan

@componentscan 自动扫描并加载符合规则的组件。可以通过basepackages指定要扫描的包。如果不指定赛秒范围，springboot默认会从生命@componentscan所在类的包进行扫描。

@componentscan(basepackages = "com.spring.test.springboot.controller",includefilters = {@componentscan.filter(type= filtertype.annotation,value=controller.class)})

等同于

<context:component-scan base-package="com.spring.test.springboot.controller">

    <context:include-filter type="annotation" expression="org.springframework.stereotype.controller"/>

</context:component-scan>

5.5.3 @enableautoconfiguration

这个注解的作用是将所有符合自动配置条件的bean自动加载到ioc容器。比如我们的项目引入了spring-boot-starter-web依赖,springboot 会自动帮我们配置 tomcat 和 springmvc。@enableautoconfigutation中@import了enableautoconfigurationimportselector，enableautoconfigurationimportselector类使用了spring core包的springfactoriesloader类的loadfactorynamesof()方法。 springfactoriesloader会查询meta-inf/spring.factories文件中包含的jar文件。 当找到spring.factories文件后，springfactoriesloader将查询配置文件命名的属性。spring.factories文件，内容如下：。

 5.2 springapplication

springapplication的run方法的实现是我们本次旅程的主要线路，该方法的主要流程大体可以归纳如下：

1） 如果我们使用的是springapplication的静态run方法，那么，这个方法里面首先要创建一个springapplication对象实例，然后调用这个创建好的springapplication的实例方法。在springapplication实例初始化的时候，它会提前做几件事情：

a)  根据classpath里面是否存在某个特征类（org.springframework.web.context.configurablewebapplicationcontext）来决定是否应该创建一个为web应用使用的applicationcontext类型。

b)  使用springfactoriesloader在应用的classpath中查找并加载所有可用的applicationcontextinitializer。

c)  使用springfactoriesloader在应用的classpath中查找并加载所有可用的applicationlistener。

d)  推断并设置main方法的定义类。

2） springapplication实例初始化完成并且完成设置后，就开始执行run方法的逻辑了，方法执行伊始，首先遍历执行所有通过springfactoriesloader可以查找到并加载的springapplicationrunlistener。调用它们的started()方法，告诉这些springapplicationrunlistener，“嘿，springboot应用要开始执行咯！”。

3） 创建并配置当前spring boot应用将要使用的environment（包括配置要使用的propertysource以及profile）。

4） 遍历调用所有springapplicationrunlistener的environmentprepared()的方法，告诉他们：“当前springboot应用使用的environment准备好了咯！”。

5） 如果springapplication的showbanner属性被设置为true，则打印banner。

6） 根据用户是否明确设置了applicationcontextclass类型以及初始化阶段的推断结果，决定该为当前springboot应用创建什么类型的applicationcontext并创建完成，然后根据条件决定是否添加shutdownhook，决定是否使用自定义的beannamegenerator，决定是否使用自定义的resourceloader，当然，最重要的，将之前准备好的environment设置给创建好的applicationcontext使用。

7） applicationcontext创建好之后，springapplication会再次借助spring-factoriesloader，查找并加载classpath中所有可用的applicationcontext-initializer，然后遍历调用这些applicationcontextinitializer的initialize（applicationcontext）方法来对已经创建好的applicationcontext进行进一步的处理。

8） 遍历调用所有springapplicationrunlistener的contextprepared()方法。

9） 最核心的一步，将之前通过@enableautoconfiguration获取的所有配置以及其他形式的ioc容器配置加载到已经准备完毕的applicationcontext。

10） 遍历调用所有springapplicationrunlistener的contextloaded()方法。

11） 调用applicationcontext的refresh()方法，完成ioc容器可用的最后一道工序。

12） 查找当前applicationcontext中是否注册有commandlinerunner，如果有，则遍历执行它们。

13） 正常情况下，遍历执行springapplicationrunlistener的finished()方法、（如果整个过程出现异常，则依然调用所有springapplicationrunlistener的finished()方法，只不过这种情况下会将异常信息一并传入处理）
去除事件通知点后，整个流程如下：

 

6. thymeleaf

springboot官方不推荐使用jsp，官方推荐使用thymeleaf。

thymeleaf是一款用于渲染xml/xhtml/html5内容的模板引擎。类似jsp，velocity，freemaker等，它也可以轻易的与spring mvc等web框架进行集成作为web应用的模板引擎。与其它模板引擎相比，thymeleaf最大的特点是能够直接在浏览器中打开并正确显示模板页面，而不需要启动整个web应用。

6.1  搭建示例工程

引入thymeleaf的包：

1 2 3 4

<dependency>     <groupid>org.springframework.boot</groupid>     <artifactid>spring-boot-starter-thymeleaf</artifactid> </dependency>

在application.properties文件中配置thymeleaf的视图解析：

1 2 3 4 5 6

spring.thymeleaf.content-type=text/html  spring.thymeleaf.mode =legacyhtml5 #开发时关闭缓存,不然没法看到实时页面 spring.thymeleaf.cache=false #配置静态资源路径 spring.mvc.static-path-pattern=/static/**

controller中的代码和以前的项目一样：

1 2 3 4 5 6

@requestmapping("hello") public string helloworld(model model) {     //向页面传值     model.addattribute("welcome", "hello thymeleaf");     return "hello"; }

页面写在/resources/templates下

 

 

页面hello.html，页面的文件名与controller中方法的返回值一致。注意页面的<html>标签中有一个<html xmlns:th="http://www.thymeleaf.org">

1 2 3 4 5 6 7 8 9 10

<!doctype html>  <html xmlns:th="http://www.thymeleaf.org">  <head>      <meta http-equiv="content-type" content="text/html; charset=utf-8" />      <title>title</title>  </head>  <body>  <p th:text="${welcome}"></p>  </body> </html>

页面中所有动态的内容都使用“th:”前缀。

并且在thymeleaf的页面中，html语法要求很严格，比如标签必须闭合。如果要在解析时自动进行标签补全，需要引入jar包：

1 2 3 4 5

<dependency>     <groupid>net.sourceforge.nekohtml</groupid>     <artifactid>nekohtml</artifactid>     <version>1.9.22</version> </dependency>

6.2 基础语法

spring-boot很多配置都有默认配置,比如默认页面映射路径为 
classpath:/templates/*.html 
同样静态文件路径为 
classpath:/static/

 

首先页面的<html>标签要改写：

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

6.2.1  获取变量值

thymeleaf通过${变量名.属性名}来获取属性值，这个语法和el表达式一样。

页面中所有动态的内容都使用“th:”前缀，并且要写在标签中。

<p th:text=${message}>this is tag p</p>

如果直接访问静态页面，会显示“this is tag p”

如果访问动态内容，那么${message}的值会替换掉原来<p>标签中的静态内容。

常见页面操作如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

@requestmapping("hello")  public string helloworld(model model) {      //向页面传值,普通文本      model.addattribute("text", "hello thymeleaf");      //html转义文本      model.addattribute("htmltext", "<h1>html</h1>");      model.addattribute("ahref", "test");      list<string> list = new arraylist<>();      list.add("a");     list.add("b");     model.addattribute("list", list);       list<dept> deptlist = new arraylist<>();     deptlist.add(new dept(1, "技术部"));     deptlist.add(new dept(2, "测试部"));     deptlist.add(new dept(3, "行政部"));     model.addattribute("deptlist", deptlist);     return "hello"; }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

<p th:text="${text}">我是文本</p>   <p th:utext="${htmltext}">我是转义文本</p>   <p><a th:href="@{{ahref}?pa={text}(ahref=${ahref},text=${text})}">我是a标签</a></p>   我是表格<br/>   <table border="1">       <tr th:each="dept:${deptlist}">           <td th:text="${dept.id}">id</td>           <td th:text="${dept.name}">name</td>       </tr>  </table>  我是下拉框      <select  >          <option th:each="dept:${deptlist}" th:value="${dept.id}" th:text="${dept.name}" th:selected="${dept.id}==${param.id[0]}"></option>  </select><br/>      <input th:value="${text}">  <script th:src="@{static/test.js}" type="text/javascript"></script>

6.2.2  条件判断

 

1	<div th:if="${ahref == 'test'}">xxxxxxx</div>