SpringBoot整合其他技术

1.springboot整合mybatis

1.1创建Spring Starter Project

增加web，jdbc，mybatis，mysql相关组件

1.2添加Mybatis的起步依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.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-web</artifactId>
        </dependency>
 
        <!--SpingBoot集成junit测试的起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </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>
 
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

1.3增加application.yml

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://192.168.137.3:3306/springboot?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.jdbc.Driver
mybatis:
  config-location: classpath:/mybatis/mybatis-config.xml #指定主配置文件
  mapper-locations: classpath:/mybatis/mapper/*.xml # 指定xml映射文件路径
  type-aliases-package: com.atguigu.domain # 指定mybatis别名包
logging:
  level:
    com.atguigu.dao: debug # 配置日志

1.4创建表

-- ----------------------------
-- Table structure for `user`
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  `name` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
 
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'zhangsan', '123', '张三');
INSERT INTO `user` VALUES ('2', 'lisi', '123', '李四');

1.5增加实体类

public class User implements Serializable {
    // 主键
    private Integer id;
    // 用户名
    private String username;
    // 密码
    private String password;
    // 姓名
    private String name;
  
    //此处省略getter和setter方法 .. ..
    
}

1.6增加mapper接口

@Mapper
public interface UserDao{
public List<User> findAll();
}

注意：

@Mapper标记该类是一个mybatis的mapper接口，可以被spring boot自动扫描到spring上下文中

1.7增加映射配置文件

在resource文件夹下面新建 /mybatis/mapper/UserDao.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.atguigu.dao.UserDao">
    <select id="findAll" resultType="user">
        select * from user
    </select>
</mapper>

1.8增加service

public interface UserService {
    List<User> findAll();
} 
@Service
public class UserServiceImpl implements UserService {
 
    @Autowired
    private UserDao userDao;
 
    @Override
    public List<User> findAll() {
        return userDao.findAll();
    }
}

1.10增加控制器

@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;
 
    @RequestMapping("/findAll")
    public List<User> findAll(){
        return userService.findAll();
    }
}

1.11增加mapper扫描

/**
 * @MapperScan(basePackages = "com.atguigu.dao")
 * 扫描指定包下的所有Mapper接口，将动态代理的实现类对象注入Spring容器中
 * basePackages属性：指定扫描的包路径地址
 * 作用相当于：
 * <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
 *     <property name="basePackage" value="com.atguigu.dao"/>
 * </bean>
 */
@MapperScan("com.atguigu.dao")
@SpringBootApplication
public class SpringBoot03Application {
public static void main(String[] args) {
SpringApplication.run(SpringBoot03Application.class, args);
}
}

2.springboot整合druid数据源

2.1 增加依赖

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.12</version>
</dependency>

2.2 配置数据源

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://192.168.137.3:3306/atcrowdfunding?useSSL=false&useUnicode=true&characterEncoding=UTF-8
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

2.3测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBoot03ApplicationTests {
 
@Autowired
DataSource dataSource;
 
/*
 * HikariDataSource 默认数据源，性能很高
 * DruidDataSource 使用很高，很稳定
 */
@Test
public void contextLoads() throws SQLException {
System.out.println(dataSource.getClass());
Connection connection = dataSource.getConnection();
System.out.println(connection);
connection.close();
}
}

3.springboot继承业务层事物

3.1扫描Dao接口，需要在主程序类中增加扫描注解@MapperScan("com.atguigu.**.dao")及事务管理@EnableTransactionManagement

3.2传统的SSM架构中采用的是声明式事务，需要在配置文件中增加AOP事务配置，Spring Boot框架中简化了这种配置，可以在Service接口中增加注解@Transactional

2.springboot整合spring data JPA

2.1新建项目springboot_jpa

2.2添加spring Data JPA的起步依赖

     <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> 
    </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-web</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
 
        <!-- springBoot JPA的起步依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
 
        <!-- MySQL连接驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
 
    </dependencies>

2.3添加数据库

<!-- MySQL连接驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

2.4在application.yml中配置数据库和jpa相关属性

logging:
  level:
    com.atguigu.dao: debug # 配置日志
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/springboot?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.jdbc.Driver
  jpa:
  #指定数据库提供商
    database: mysql
    #打印SQL
    show-sql: true
    #是jpa层面对数据表生成策略的控制
    generate-ddl: true
    hibernate:
      #是jpa实现hibernate层面上对数据表生成策略的控制
      ddl-auto: update
      #指定命名策略
      naming_strategy: org.hibernate.cfg.ImprovedNamingStrategy
  main:
allow-bean-definition-overriding: true

server: 
  port: 18081

2.5 创建实体配置实体

import javax.persistence.*;
import java.io.Serializable;

@Entity
@Table(name = "user")
public class User implements Serializable {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
 
    @Column(name = "username")
    private String username;
 
    @Column(name = "password")
    private String password;
 
    @Column(name = "name")
    private String name;
 
    //此处省略setter和getter方法... ...
}

2.6 编写userrepository

import com.atguigu.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;
 
public interface UserDao extends JpaRepository<User,Integer> {
}

2.7编写service类

package com.atguigu.service;
 
import com.atguigu.domain.User;
import java.util.List;
 
public interface UserService {
    List<User> findUsers();
    User findUserById(Integer id);
    void saveUser(User user);
    void updateUser(User user);
    void deleteUserById(Integer id);
}


import com.atguigu.dao.UserDao;
import com.atguigu.domain.User;
import com.atguigu.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
 
@Service
public class UserServiceImpl implements UserService {
 
    @Autowired
    private UserDao userDao;
 
    /**
     * 查询所有
     */
    @Override
    public List<User> findUsers() {
        return userDao.findAll();
    }
    /**
     * 根据id查询
     */
    @Override
    public User findUserById(Integer id) {
        return userDao.findById(id).get();
    }
    /**
     * 保存
     */
    @Override
    public void saveUser(User user) {
        userDao.save(user);
    }
    /**
     * 更新
     */
    @Override
    public void updateUser(User user) {
        userDao.save(user);
    }
    /**
     * 根据id删除
     */
    @Override
    public void deleteUserById(Integer id) {
        userDao.deleteById(id);
    }
}

2.8 编写controller


import com.atguigu.domain.User;
import com.atguigu.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
 
@RestController
@RequestMapping("/user")
public class UserController {
 
    @Autowired
    private UserService userService;
 
    @RequestMapping("/findUsers")
    public List<User> findUsers(){
        return userService.findUsers();
    }

    @RequestMapping("/findUserById/{id}")
    public User findUserById(@PathVariable("id") Integer id) {
        return userService.findUserById(id);
    }
    @RequestMapping("/saveUser")
    public void saveUser(User user) {
        userService.saveUser(user);
    }
    @RequestMapping("/updateUser")
    public void updateUser(User user) {
        userService.updateUser(user);
    }
    @RequestMapping("/deleteUserById/{id}")
    public void deleteUserById(@PathVariable("id")  Integer id) {
        userService.deleteUserById(id);
}
}

3.springboot整合redis

3.1添加redis的起步依赖

<!-- 配置使用redis启动器 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

3.2配置redis的连接信息

在application.yml文件添加redis的配置信息

mybatis:
  type-aliases-package: com.atguigu.domain # 指定mybatis别名包
  mapper-locations: classpath:com/atguigu/dao/*.xml # 指定xml映射文件路径
logging:
  level:
    com.atguigu.dao: debug # 配置日志
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/springboot?useUnicode=true&characterEncoding=utf8
    driver-class-name: com.mysql.jdbc.Driver
  redis: 
    port: 6379
    host: 127.0.0.1
server:
  port: 18081

注入redisTemplate测试redis操作

在service的试下类里面实现业务逻辑


import com.atguigu.dao.UserDao;
import com.atguigu.domain.User;
import com.atguigu.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.List;
 
@Service
public class UserServiceImpl implements UserService {
 
    @Autowired
    private UserDao userDao;
 
    @Autowired
    private RedisTemplate redisTemplate;
 
    @Override
    public List<User> findAll() {
        // redis的key
        String key = "alluser";
        // 先查询redis中是否有数据，如果有直接返回redis的数据
        List<User> users = (List<User>) redisTemplate.boundValueOps(key).get();
        if (users!=null) {
            System.out.println("从Redis中获取缓存数据="+users);
            return users;
        }
 
        // 如果没有，查询数据库
        users = userDao.findAll();
        // 将数据库数据存入到redis中
        if (users != null && users.size()>0) {
            System.out.println("从数据库中获取数据存放到Redis缓存="+users);
            redisTemplate.boundValueOps(key).set(users);
        }
        return users;
    }
}

4.springboot整合定时任务

4.1创建项目springboot_task

4.2 添加pom文件

<!--父工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/>
    </parent>
 
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- 添加 Scheduled 坐标 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
    </dependencies>

4.3创建bootapplication

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
 
@SpringBootApplication
@EnableScheduling
public class BootApplication {
    public static void main(String[] args) {
        SpringApplication.run(BootApplication.class, args);
    }
}

4.4 创建TaskController

import java.text.SimpleDateFormat;
import java.util.Date;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
 
@Component
public class TaskController {
 
    /**
     *  @Scheduled:定时规则
     *       cron：项目启动后每5秒执行一次
     *
     *       fixedDelay：距离上一次定时任务执行完毕后N毫秒再执行，
     *       执行A任务花了5秒，比如参数是3000，A任务执行完成之后，再过3秒执行
     *
     *       fixedRate：执行周期，执行频率
     *       定时任务执行开始，再过N毫秒后执行，
     *       执行A任务花了2秒，比如参数是3000，A任务执行完成之后，再过1秒后执行，
     *       执行A任务花了15秒，比如参数是3000，A任务执行完成之后，立即执行。
     */
    @Scheduled(fixedDelay = 3000)
    public void myTask() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(simpleDateFormat.format(new Date()));
    }
}

5.springboot整合末班Thymeleaf

5.1Thymeleaf介绍

开发传统Java WEB工程时，我们可以使用JSP页面模板语言，但是在SpringBoot中已经不推荐使用了。SpringBoot支持如下页面模板语言
- Thymeleaf
- FreeMarker
- Velocity
- Groovy
- JSP

上面并没有列举所有SpringBoot支持的页面模板技术。其中Thymeleaf是SpringBoot官方所推荐使用的

Thymeleaf介绍

在应用开发中，你可以使用Thymeleaf来完全代替JSP

模板：将一些重复内容写好，其中某些可能发生变化的内容，采用占位符方式动态加载（JSP），类似10086群发短信每个人收到的短信内容一模一样，只是名字不一样，一样的内容称之为模板。
模板引擎技术：可以基于写好的模板，动态给写好的模板加载数据。

Thymeleaf：Thymeleaf是一个模板引擎工具，主要用于页面渲染操作(页面数据填充操作)，可以取代之前的jsp操作。

5.2 整合Thymeleaf

- 使用springboot 来集成使用Thymeleaf可以大大减少单纯使用thymleaf的代码量，所以我们接下来使用springboot集成使用thymeleaf。
- 实现的步骤为：
  - 创建一个Springboot项目
  - 添加thymeleaf的起步依赖
  - 添加spring web的起步依赖
  - 编写html 使用thymeleaf的语法获取变量对应后台传递的值
  - 编写controller设置变量的值到model中
- 视图：
  - prefix: classpath:/templates/
  - suffix: .html

创建工程

创建一个独立的工程springboot-thymeleaf

pom.xml依赖

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> 
    </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-thymeleaf</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-test</artifactId>
            <scope>test</scope>
        </dependency>
 
        <!--热部署插件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
 
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

创建html

在 resources 中创建 templates 目录，在templates 目录创建 demo1.html ,代码如下：

<!DOCTYPE html>
<!--这句声明使用thymeleaf标签-->
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Thymeleaf的入门</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
</head>
<body>
<!--
输出hello数据
这句使用 th:text="${变量名}" 表示 使用thymeleaf获取文本数据，类似于EL表达式。
thymeleaf：都是作用于HTML标签之上
-->
<p th:text="${hello}"></p>
</body>
</html>

修改application.yml配置

创建 application.yml ,并设置 thymeleaf 的缓存设置，设置为false

spring:
  thymeleaf:
    cache: false

开启自动编译

控制层

创建 controller 用于测试后台设置数据到model中。
创建 com.atguigu.controller.TestController，代码如下：


import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
 
@Controller
@RequestMapping("/test")
public class TestController {
 
    /***
     * 访问/test/hello  跳转到demo1页面
     */
    @RequestMapping("/hello")
    public String hello(Model model){
        model.addAttribute("hello","hello welcome");
        return "demo1";
    }
}

测试

创建启动类ThtmeleafApplication，代码如下：


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class ThymeleafApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(ThymeleafApplication.class,args);
    }
}

Thymeleaf基本语法

1.th:action

定义后台控制器路径，类似<form>标签的action属性。

例如：修改刚刚 demo01.html 页面

<form id="login-form" th:action="@{/test/hello}" method="post">
   <button>提交</button>
</form>

2.th:each

对象遍历，功能类似 jstl 中的<c:forEach>标签。
创建 com.atguigu.model.User ,代码如下：


import java.io.Serializable;
 
public class User implements Serializable {
    private Integer id;
    private String name;
    private String address;
    //省略..get..set  toString
 
    public User(Integer id, String name, String address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }
 
    public User() {
    }

Controller添加数据


import com.atguigu.domain.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.List;
 
@Controller
@RequestMapping("/test")
public class TestController {
 
    /***
     * 访问/test/hello  跳转到demo1页面
     */
    @RequestMapping("/hello")
    public String hello(Model model){
        model.addAttribute("hello","hello welcome");
 
        //集合数据
        List<User> users = new ArrayList<User>();
        users.add(new User("张三","123","张三"));
        users.add(new User("李四","123","李四"));
        users.add(new User("王五","123","王五"));
        model.addAttribute("users",users);
        return "demo1";
    }
}

修改页面

<!DOCTYPE html>
<!--这句声明使用thymeleaf标签-->
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Thymeleaf的入门</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
</head>
<body>
<table border="1" >
    <tr>
        <td>下标</td>
        <td>用户名</td>
        <td>密码</td>
        <td>姓名</td>
    </tr>
    <tr th:each="user,userStat:${users}">
        <td>
            <span th:text="${userStat.index+1}"></span>
        </td>
        <td th:text="${user.username}"></td>
        <td th:text="${user.password}"></td>
        <td th:text="${user.name}"></td>
    </tr>
</table> 
</body>
</html>

3.Map输出

后台添加Map


import com.atguigu.domain.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
@RequestMapping("/test")
public class TestController {
 
    /***
     * 访问/test/hello  跳转到demo1页面
     */
    @RequestMapping("/hello")
    public String hello(Model model){
        //Map定义
        Map<String,Object> dataMap = new HashMap<String,Object>();
        dataMap.put("No","123");
        dataMap.put("address","深圳");
        model.addAttribute("dataMap",dataMap);
        return "demo1";
    }
}

页面输出添加demo01.html

<!DOCTYPE html>
<!--这句声明使用thymeleaf标签-->
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Thymeleaf的入门</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
</head>
<body>
 
<table>
    <!-- 读取map 2种方式
    1：知道map的key ， 直接根据key 获取数据
    2：不知道map的key，循环方式获取key，然后获取数据
   -->
    <h5>方式1</h5>
    <div>
       获取Key=NO的值：<span th:text="${dataMap.No}"></span><br/>
       获取key=address的值：<span th:text="${dataMap.address}"></span> <br/>
    </div>
    <h5>方式2</h5>
    <div th:each="map:${dataMap}">
        <span th:text="${map.key}"></span>:<span th:text="${map.value}"></span>
    </div>
</table>
 
</body>
</html>

数组输出

后台添加数组


import com.atguigu.domain.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
@RequestMapping("/test")
public class TestController {
 
    /***
     * 访问/test/hello  跳转到demo1页面
     */
    @RequestMapping("/hello")
    public String hello(Model model){
         //存储一个数组
        String[] names = {"张三","李四","王五"};
        model.addAttribute("names",names);
        return "demo1";
    }
}

页面输出

<div th:each="nm,nmStat:${names}">
    <span th:text="${nmStat.count}"></span><span th:text="${nm}"></span>
    ==============================================
</div>

Date输出

后台添加日期


import com.atguigu.domain.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.*;
 
@Controller
@RequestMapping("/test")
public class TestController {
 
    /***
     * 访问/test/hello  跳转到demo1页面
     */
    @RequestMapping("/hello")
    public String hello(Model model){
        //日期
        model.addAttribute("now",new Date());
        return "demo1";
    }
}

页面输出

<!DOCTYPE html>
<!--这句声明使用thymeleaf标签-->
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Thymeleaf的入门</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
</head>
<body>
 
<div>
    <span th:text="${#dates.format(now,'yyyy-MM-dd HH:mm:ss')}"></span>
</div>
 
</body>
</html>

6.th:if条件

后台添加年龄


import com.atguigu.domain.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.*;
 
@Controller
@RequestMapping("/test")
public class TestController {
 
    /***
     * 访问/test/hello  跳转到demo1页面
     */
    @RequestMapping("/hello")
    public String hello(Model model){
        //if条件
        model.addAttribute("age",22);
        return "demo1";
    }
}

页面输出

<!DOCTYPE html>
<!--这句声明使用thymeleaf标签-->
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Thymeleaf的入门</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
</head>
<body>
 
<!--
if:th：unless表示条件不成立 ，输出数据
-->
<div>
    <span th:if="${(age>=18)}">终于长大了！</span>
    <span th:unless="${age<18}">成年人</span>
</div>
 
</body>
</html>

7.th:fragment定义一个模块

可以定义一个独立的模块，在 templates 文件夹下面，创建一个 footer.html 代码如下：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta http-equiv="Content-Type" content="text/html;charset=charset=utf-8">
    <title>fragment</title>
</head>
<body>
<div th:fragment="copy">
    关于我们<br/>
</div>
</body>

8.th:include

可以直接引入th:fragment，在 demo1.html 中引入如下代码：

<!DOCTYPE html>
<!--这句声明使用thymeleaf标签-->
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Thymeleaf的入门</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
</head>
<body>
 
<div th:include="footer::copy"></div>
 
</body>
</html>

6.springboot整合web组件

6.1监听器

 
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
 
@WebListener
public class HelloListener implements ServletContextListener {
@Override
public void contextDestroyed(ServletContextEvent arg0) {
System.out.println("应用销毁了....HelloListener");
}
 
@Override
public void contextInitialized(ServletContextEvent arg0) {
System.out.println("应用启动了....HelloListener");
}
}

6.2 过滤器


import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
 
@WebFilter(urlPatterns="/*")
public class HelloFilter implements Filter {
 
@Override
public void destroy() {
 
}
 
@Override
public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain arg2)
throws IOException, ServletException {
System.out.println("HelloFilter............放行之前");
arg2.doFilter(arg0, arg1);
System.out.println("HelloFilter............放行之后");
}
 
@Override
public void init(FilterConfig arg0) throws ServletException {
 
}
 
}

6.3 servlet


import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
@WebServlet(urlPatterns="/my")
public class MyServlet extends HttpServlet {
 
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.getWriter().write("MyServlet do.......");
}
 
}

6.4 扫描组件

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

都说程序员要会，今天浅谈一下springboot（2）

SpringBoot整合其他技术

1.springboot整合mybatis

1.1创建Spring Starter Project

1.2添加Mybatis的起步依赖

1.3增加application.yml

1.4创建表

1.5增加实体类

1.6增加mapper接口

1.7增加映射配置文件

1.8增加service

1.10增加控制器

1.11增加mapper扫描

2.springboot整合druid数据源

2.1 增加依赖

2.2 配置数据源

2.3测试

3.springboot继承业务层事物

2.springboot整合spring data JPA

2.1新建项目springboot_jpa

2.2添加spring Data JPA的起步依赖

2.3添加数据库

2.4在application.yml中配置数据库和jpa相关属性

2.5 创建实体配置实体

2.6 编写userrepository

2.7编写service类

2.8 编写controller

3.springboot整合redis

3.1添加redis的起步依赖

3.2配置redis的连接信息

4.springboot整合定时任务

4.1创建项目springboot_task

4.2 添加pom文件

4.3创建bootapplication

4.4 创建TaskController

5.springboot整合末班Thymeleaf

5.1Thymeleaf介绍

5.2 整合Thymeleaf

创建工程

修改application.yml配置

控制层

测试

Thymeleaf基本语法

1.th:action

2.th:each

Controller添加数据

修改页面

3.Map输出

后台添加Map

页面输出添加demo01.html

数组输出

Date输出

页面输出

6.th:if条件

后台添加年龄

页面输出

7.th:fragment定义一个模块

8.th:include

6.springboot整合web组件

6.1监听器

6.2 过滤器

6.3 servlet

6.4 扫描组件

猜你喜欢