SpringBoot整合ssm

1.创建工程

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

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

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

 1 <dependency>
 2    <groupId>org.mybatis</groupId>
 3    <artifactId>mybatis</artifactId>
 4    <version>3.4.1</version>
 5 </dependency>
 6 <dependency>
 7    <groupId>org.mybatis</groupId>
 8    <artifactId>mybatis-spring</artifactId>
 9    <version>1.3.1</version>
10 </dependency>

而在SpringBoot中引入的是：

1 <dependency>
2    <groupId>org.mybatis.spring.boot</groupId>
3    <artifactId>mybatis-spring-boot-starter</artifactId>
4    <version>1.3.1</version>
5 </dependency>

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

完整的pom.xml如下:

 1 <parent>
 2     <groupId>org.springframework.boot</groupId>
 3     <artifactId>spring-boot-starter-parent</artifactId>
 4     <version>1.5.10.RELEASE</version>
 5     <relativePath/> <!-- lookup parent from repository -->
 6 </parent>
 7
 8 <properties>
 9     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
10     <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
11     <java.version>1.8</java.version>
12 </properties>
13
14 <dependencies>
15     <dependency>
16         <groupId>org.springframework.boot</groupId>
17         <artifactId>spring-boot-starter-jdbc</artifactId>
18     </dependency>
19     <dependency>
20         <groupId>org.springframework.boot</groupId>
21         <artifactId>spring-boot-starter-web</artifactId>
22     </dependency>
23     <dependency>
24         <groupId>org.springframework.boot</groupId>
25         <artifactId>spring-boot-starter-aop</artifactId>
26     </dependency>
27     <dependency>
28         <groupId>org.mybatis.spring.boot</groupId>
29         <artifactId>mybatis-spring-boot-starter</artifactId>
30         <version>1.3.1</version>
31     </dependency>
32     <dependency>
33         <groupId>org.springframework.boot</groupId>
34         <artifactId>spring-boot-starter-tomcat</artifactId>
35         <scope>provided</scope>
36     </dependency>
37
38     <dependency>
39         <groupId>mysql</groupId>
40         <artifactId>mysql-connector-java</artifactId>
41         <scope>runtime</scope>
42     </dependency>
43     <dependency>
44         <groupId>org.springframework.boot</groupId>
45         <artifactId>spring-boot-starter-test</artifactId>
46         <scope>test</scope>
47     </dependency>
48     <!--使用jsp页面-->
49     <dependency>
50         <groupId>org.apache.tomcat.embed</groupId>
51         <artifactId>tomcat-embed-jasper</artifactId>
52     </dependency>
53     <dependency>
54         <groupId>jstl</groupId>
55         <artifactId>jstl</artifactId>
56         <version>1.2</version>
57     </dependency>
58 </dependencies>
59
60 <build>
61     <finalName>boot</finalName>
62     <plugins>
63         <plugin>
64             <groupId>org.springframework.boot</groupId>
65             <artifactId>spring-boot-maven-plugin</artifactId>
66         </plugin>
67     </plugins>
68     <resources>
69         <resource>
70             <directory>src/main/java</directory>
71             <includes>
72                 <include>**/*.xml</include>
73             </includes>
74         </resource>
75         <resource>
76             <directory>src/main/resources</directory>
77             <includes>
78                 <include>**/*.xml</include>
79                 <include>**/*.properties</include>
80             </includes>
81         </resource>
82     </resources>
83 </build>

完整的工程路径如下：

2. 实体类和DAO

1 public class Dept {
2     private Integer id;
3     private String name;
4
5     //getter/setter方法略
6 }
1 public interface DeptDAO {
2     //查询列表，演示使用传统的mapper映射文件
3     List<Dept> getDeltList();
4
5     //插入，演示使用注解编写sql，省略xml配置
6     @Insert("insert into DEPT(NAME) values(#{name})")
7     @Options(useGeneratedKeys = true, keyProperty = "id", keyColumn = "ID")
8     void addDept(String name);
9 }

DeptMapper.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
 3 <mapper namespace="com.test.springboot.ssm.dao.DeptDAO">
 4
 5     <resultMap id="deptMap" type="Dept">
 6         <id property="id" column="ID"/>
 7         <result property="name" column="NAME"/>
 8     </resultMap>
 9
10     <select id="getDeltList" resultMap="deptMap">
11         select ID,NAME from DEPT
12     </select>
13 </mapper>

3.Service

1 public interface DeptService {
2     List<Dept> getDeltList();
3
4     void addDept(String name);
5 }
 1 @Service
 2 public class DeptServiceImpl implements DeptService {
 3     @Autowired
 4     private DeptDAO deptDAO;
 5
 6     @Override
 7     public List<Dept> getDeltList() {
 8         return deptDAO.getDeltList();
 9     }
10
11     @Override
12     public void addDept(String name) {
13         deptDAO.addDept(name);
14     }
15 }

4. Controller和页面

 1 @Controller
 2 public class DeptController {
 3     @Autowired
 4     private DeptService deptService;
 5
 6     @RequestMapping("list.html")
 7     public ModelAndView list() {
 8         List<Dept> deptList = deptService.getDeltList();
 9         return new ModelAndView("list", "deptList", deptList);
10     }
11
12     @RequestMapping("add.html")
13     public String add(String name) {
14         deptService.addDept(name);
15         //添加成功后重定向到列表页
16         return "redirect:list.html";
17     }
18 }

add.jsp

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

list.jsp

1 <c:forEach items="${deptList}" var="dept">
2     ${dept.id}-${dept.name}<br/>
3 </c:forEach>

5.启动类

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

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

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

spring-config.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:aop="http://www.springframework.org/schema/aop"
 5        xmlns:context="http://www.springframework.org/schema/context"
 6        xmlns:tx="http://www.springframework.org/schema/tx"
 7        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 8         http://www.springframework.org/schema/context
 9        http://www.springframework.org/schema/context/spring-context-4.2.xsd
10        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
11        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
12     <!--扫描@Service注解-->
13     <context:component-scan base-package="com.test.springboot.ssm.service">
14         <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
15     </context:component-scan>
16     <!--读取配置文件-->
17     <context:property-placeholder location="classpath:db.properties" ignore-unresolvable="true"/>
18     <!--从配置文件中获取数据源-->
19     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
20         <property name="driverClassName" value="${jdbc.driver}"/>
21         <property name="url" value="${jdbc.url}"/>
22         <property name="username" value="${jdbc.username}"/>
23         <property name="password" value="${jdbc.password}"/>
24     </bean>
25
26     <!--spring管理session工厂-->
27     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
28         <property name="dataSource" ref="dataSource"/>
29         <property name="mapperLocations" value="classpath:com/test/springboot/ssm/dao/mapper/*.xml"/>
30         <!--配置实体类别名别名-->
31         <property name="typeAliasesPackage" value="com.test.springboot.ssm.pojo"/>
32     </bean>
33
34     <!--扫描所有mybatis的dao接口，生成代理实现类-->
35     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
36         <property name="basePackage" value="com.test.springboot.ssm.dao"/>
37     </bean>
38
39     <!-- 配置事务管理器 -->
40     <bean id="transactionManager"
41           class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
42         <property name="dataSource" ref="dataSource"/>
43     </bean>
44
45     <!--事务增强-->
46     <tx:advice id="txAdvice" transaction-manager="transactionManager">
47         <tx:attributes>
48             <!-- 传播行为，匹配的是方法名 -->
49             <tx:method name="add*" rollback-for="Exception"/>
50             <tx:method name="delete*" rollback-for="Exception"/>
51             <tx:method name="update*" rollback-for="Exception"/>
52             <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
53             <tx:method name="do*" rollback-for="Exception"/>
54         </tx:attributes>
55     </tx:advice>
56
57     <!-- 通过AOP配置提供事务增强，让service包下所有Bean的所有方法拥有事务 -->
58     <aop:config>
59         <aop:pointcut id="serviceMethod"
60                       expression="execution(* com.test.springboot.ssm..*(..))"/>
61         <aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice"/>
62     </aop:config>
63
64 </beans>

springMVC-servlet.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:context="http://www.springframework.org/schema/context"
 5        xmlns:mvc="http://www.springframework.org/schema/mvc"
 6        xsi:schemaLocation="
 7   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
 8   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
 9   http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd">
10
11     <mvc:annotation-driven/>
12     <!--扫描Controller所在的包-->
13     <context:component-scan base-package="com.ssm.blog.controller">
14         <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
15     </context:component-scan>
16
17     <!-- 配置视图解析器-->
18     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
19         <property name="prefix" value="/"></property><!--前缀-->
20         <property name="suffix" value=".jsp"></property><!--后缀-->
21     </bean>
22
23 </beans>

web.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <web-app xmlns="http://java.sun.com/xml/ns/javaee"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
 5           http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
 6          version="3.0">
 7     <context-param>
 8         <param-name>contextConfigLocation</param-name>
 9         <param-value>classpath:spring-config.xml</param-value>
10     </context-param>
11     <!--配置listener，在启动Web容器的时候加载Spring的配置-->
12     <listener>
13         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
14     </listener>
15     <filter>
16         <filter-name>CharacterEncodingFilter</filter-name>
17         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
18         <init-param>
19             <param-name>encoding</param-name>
20             <param-value>UTF-8</param-value>
21         </init-param>
22         <init-param>
23             <param-name>forceEncoding</param-name>
24             <param-value>true</param-value>
25         </init-param>
26     </filter>
27     <filter-mapping>
28         <filter-name>CharacterEncodingFilter</filter-name>
29         <url-pattern>/*</url-pattern>
30     </filter-mapping>
31     <!--配置DispatcherServlet -->
32     <servlet>
33         <servlet-name>springMVC</servlet-name>
34         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
35     </servlet>
36     <servlet-mapping>
37         <servlet-name>springMVC</servlet-name>
38         <url-pattern>*.html</url-pattern>
39     </servlet-mapping>
40 </web-app>

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

 1 @SpringBootApplication
 2 @EnableTransactionManagement//开启事务管理
 3 @ComponentScan("com.test.springboot.ssm")//扫描注解元素
 4 @MapperScan("com.test.springboot.ssm.dao")//Mybatis的DAO所在包
 5 public class SpringbootSsmApplication {
 6
 7     public static void main(String[] args) {
 8         SpringApplication.run(SpringbootSsmApplication.class, args);
 9     }
10
11     public static final String transactionExecution = "execution (* com.test.springboot.service..*(..))";
12
13     @Autowired
14     private DataSource dataSource;
15
16     //声明式事务
17     @Bean
18     public DefaultPointcutAdvisor defaultPointcutAdvisor() {
19         AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
20         pointcut.setExpression(transactionExecution);
21         DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor();
22         advisor.setPointcut(pointcut);
23         Properties attributes = new Properties();
24         attributes.setProperty("get*", "PROPAGATION_REQUIRED,-Exception");
25         attributes.setProperty("add*", "PROPAGATION_REQUIRED,-Exception");
26         attributes.setProperty("update*", "PROPAGATION_REQUIRED,-Exception");
27         attributes.setProperty("delete*", "PROPAGATION_REQUIRED,-Exception");
28         TransactionInterceptor txAdvice = new TransactionInterceptor(new DataSourceTransactionManager(dataSource), attributes);
29         advisor.setAdvice(txAdvice);
30         return advisor;
31     }
32 }

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

 1 #数据源的基本信息
 2 spring.datasource.url = jdbc:mysql://localhost:3306/test?characterEncoding=utf-8
 3 spring.datasource.username = root
 4 spring.datasource.password =
 5 spring.datasource.driverClassName = com.mysql.jdbc.Driver
 6
 7 #mybatis中mapper文件的路径
 8 mybatis.mapper-locations=classpath*:com/test/springboot/ssm/dao/mappers/*.xml
 9 #起别名。可省略写mybatis的xml中的resultType的全路径
10 mybatis.type-aliases-package=com.test.springboot.ssm.pojo
11
12 #springMVC中的视图信息，响应前缀
13 spring.mvc.view.prefix=/
14 # 响应页面默认后缀
15 spring.mvc.view.suffix=.jsp
16 #DispatcherServlet中响应的url-pattern
17 server.sevlet-path=*.html
18 server.context-path=/boot
19
20 #logging.level.root=debug
21 logging.level.com.test.springboot.ssm.dao=trace

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

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

1 public class ServletInitializer extends SpringBootServletInitializer {
2     @Override
3     protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
4         return application.sources(SpringbootSsmApplication.class);
5     }
6 }

5. 启动原理解析

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

1 @SpringBootApplication
2 public class StartApplication {
3     public static void main(String[] args) {
4         SpringApplication.run(StartApplication.class, args);
5     }
6 }

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

[email protected]

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

@Configuration

@EnableAutoConfiguration

@ComponentScan

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

1 @Configuration
2 @EnableAutoConfiguration
3 @ComponentScan
4 public class StartApplication {
5     public static void main(String[] args) {
6         SpringApplication.run(StartApplication.class, args);
7     }
8 }

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

5.1.1  @Configuration

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

如spring-config.xml如下：

1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
5        ">
6     <!--定义bean-->
7 </beans>

SpringBoot中写成：

1 import org.springframework.context.annotation.Configuration;
2
3 @Configuration
4 public class SpringConfig {
5 }

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

1 <bean id="dept" class="com.spring.test.springboot.pojo.Dept">
2     <property name="id" value="1"/>
3 </bean>
4
5 <bean id="employee" class="com.spring.test.springboot.pojo.Employee">
6     <property name="name" value="tom"/>
7     <property name="dept" ref="dept"/>
8 </bean>

SpringBoot中写成：

 1 @Bean
 2 public Dept dept() {
 3     Dept dept = new Dept();
 4     dept.setId(1);
 5     return dept;
 6 }
 7
 8 @Bean
 9 public Employee employee() {
10     Employee employee = new Employee();
11     employee.setName("tom");
12     employee.setDept(dept());//注入依赖对象直接调用@Bean注解的方法
13     return employee;
14 }

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

5.1.2 @ComponentScan

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

1 @ComponentScan(basePackages = "com.spring.test.springboot.controller",includeFilters = {@ComponentScan.Filter(type= FilterType.ANNOTATION,value=Controller.class)})

等同于

1 <context:component-scan base-package="com.spring.test.springboot.controller">
2     <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
3 </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 <dependency>
2     <groupId>org.springframework.boot</groupId>
3     <artifactId>spring-boot-starter-thymeleaf</artifactId>
4 </dependency>

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

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

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

1 @RequestMapping("hello")
2 public String helloWorld(Model model) {
3     //向页面传值
4     model.addAttribute("welcome", "hello thymeleaf");
5     return "hello";
6 }

页面写在/resources/templates下

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

 1 <!DOCTYPE html>
 2 <html xmlns:th="http://www.thymeleaf.org">
 3 <head>
 4     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
 5     <title>Title</title>
 6 </head>
 7 <body>
 8 <p th:text="${welcome}"></p>
 9 </body>
10 </html>

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

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

1 <dependency>
2     <groupId>net.sourceforge.nekohtml</groupId>
3     <artifactId>nekohtml</artifactId>
4     <version>1.9.22</version>
5 </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 @RequestMapping("hello")
 2 public String helloWorld(Model model) {
 3     //向页面传值,普通文本
 4     model.addAttribute("text", "hello thymeleaf");
 5     //html转义文本
 6     model.addAttribute("htmlText", "<h1>html</h1>");
 7     model.addAttribute("ahref", "test");
 8     List<String> list = new ArrayList<>();
 9     list.add("a");
10     list.add("b");
11     model.addAttribute("list", list);
12
13     List<Dept> deptList = new ArrayList<>();
14     deptList.add(new Dept(1, "技术部"));
15     deptList.add(new Dept(2, "测试部"));
16     deptList.add(new Dept(3, "行政部"));
17     model.addAttribute("deptList", deptList);
18     return "hello";
19 }
 1 <p th:text="${text}">我是文本</p>
 2 <p th:utext="${htmlText}">我是转义文本</p>
 3 <p><a th:href="@{{ahref}?pa={text}(ahref=${ahref},text=${text})}">我是a标签</a></p>
 4 我是表格<br/>
 5 <table border="1">
 6     <tr th:each="dept:${deptList}">
 7         <td th:text="${dept.id}">id</td>
 8         <td th:text="${dept.name}">name</td>
 9     </tr>
10 </table>
11 我是下拉框
12     <select  >
13         <option th:each="dept:${deptList}" th:value="${dept.id}" th:text="${dept.name}" th:selected="${dept.id}==${param.id[0]}"></option>
14 </select><br/>
15     <input th:value="${text}">
16 <script th:src="@{static/test.js}" type="text/javascript"></script>

6.2.2  条件判断

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

原文地址：https://www.cnblogs.com/sueyyyy/p/9576415.html

时间： 2024-11-06 03:30:48

SpringBoot整合ssm的相关文章

SpringBoot整合SSM(代码实现Demo)

SpringBoot整合SSM 如图所示: 一.数据准备: 数据库文件:数据库名:saas-export,表名:ss_company 创建表语句: DROP TABLE IF EXISTS ss_company;CREATE TABLE ss_company ( id varchar(40) NOT NULL COMMENT 'ID', name varchar(255) DEFAULT NULL COMMENT '公司名称', expiration_date datetime DEFAULT

SpringBoot整合SSM项目

1.1.1      系统架构图 1.1.2      创建数据库表 p.MsoNormal,li.MsoNormal,div.MsoNormal { margin: 0cm; margin-bottom: .0001pt; text-align: justify; text-indent: 21.0pt; font-size: 10.5pt; font-family: Consolas } h1 { margin-top: 17.0pt; margin-right: 0cm; margin-b

SpringBoot整合SSM三大框架源码剖析之SpringBoot源码剖析

Spring Boot源码剖析 一.Spring Boot 项目的启动入口流程分析 Spring Boot项目的启动入口main线程上有一个@SpringBootApplication( @Configuration + @EnableAutoConfiguration + @ComponentScan )注解, 表明是主配置类, 让程序自动识别并进行必要的配置 项目启动后, 首先进行自动配置, 源码如下: ---在org.springframework.boot.autoconfigure 包

spring-boot整合SSM框架

1.整合spring-MVC拦截器 1.编写拦截器(实现HandlerInterceptor接口) 2.编写配置类实现WebMvcConfigurer,在该类中添加各种组件. a.注册拦截器 b.添加拦截器到spring mvc 拦截器里 2.整合事物和连接池 1.事物配置 a.添加事物相关的启动器依赖,mysql相关依赖 b.编写业务类Service使用事物注解@Transactional 2.数据库连接池hlkari配置 只需要在application配置文件中指定数据库相关参数 3.整合M

SpringBoot整合ssm日期类型转换

日期类型转换,我借助了工具类, 第一种方法 工具类是自定义的 package cn.studio.util; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.SerializerProvider; import java.io.IOException; import

SpringBoot整合SSM之查询

一.引入项目所需要用到的依赖 <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency> <dependency> <groupId&g

springboot整合mybatis,redis,代码(一)

一 搭建项目,代码工程结构 使用idea或者sts构建springboot项目 二  数据库sql语句 SQLyog Ultimate v12.08 (64 bit) MySQL - 5.7.14-log ********************************************************************* */ /*!40101 SET NAMES utf8 */; create table `person` ( `id` int (11), `name`

SpringBoot整合mybatis使用pageHelper插件进行分页操作

SpringBoot整合mybatis分页操作 SpringBoot整合Mybatis进行分页操作,这里需要使用Mybatis的分页插件:pageHelper, 关于pageHelper的介绍,请查看官方文档: https://pagehelper.github.io/ 1.使用前配置 关于pageHelper的使用配置,主要有以下2个步骤: 1.1.在pom文件中导入pageHelper依赖 <dependency> <groupId>com.github.pagehelper&

springboot整合mybatis(SSM开发环境搭建)

0.项目结构: 1.application.properties中配置整合mybatis的配置文件.mybatis扫描别名的基本包与数据源 server.port=80 logging.level.org.springframework=DEBUG #springboot mybatis #jiazai mybatis peizhiwenjian mybatis.mapper-locations = classpath:mapper/*Mapper.xml mybatis.config-loca