第三阶段 Day02~03 - HelloWorld开发者社区

1.SpringBoot 高级用法

1.1 为属性赋值操作

1.1.1 业务需求说明

说明: 当程序中出现了频繁变化的数据时,如果采用人为的方式进行修改并且变异打包则导致代码的耦合性较高.不便于维护.所以能否为属性动态赋值.
第三阶段 Day02~03

1.1.2 关于YML文件说明

`# YML文件语法
    #  1. key:(空格)  value
    #  2. key与key之间有层级的缩进关系.
server:
  port: 8090

# 属性赋值操作,编辑属性时注意前缀.  只要springboot启动该数据就会被写入内存中 key-value格式
redis:
  host: 192.168.126.130
  port: 6379`

1.1.3 为属性赋值操作

`//动态获取ip和端口数据
//@ResponseBody    作用1: 将对象转化为JSON  作用2: 如果返回值是String类型,则返回字符串本身
//                 作用3:  一般客户端发起ajax请求时,采用该注解返回数据, 将不会执行视图解析器操作
@RestController
public class RedisController {

    @Value("${redis.host}") //spel表达式
    private String  host;   // = "192.168.126.130";      private String  host;   // = "192.168.126.130";
    @Value("${redis.port}")
    private Integer port;   // = 6379;

    @RequestMapping("/getMsg")
    public String getMsg(){

        return host + ":" + port;
    }
}`

1.2 指定配置文件为属性赋值

说明: 由于YML配置文件中的数据一般都是系统级别的数据,所以一般的业务数据都会写到properties的配置文件中.

1.2.1 编辑properties配置文件

第三阶段 Day02~03

1.2.2 编辑RedisController

`package com.jt.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

//动态获取ip和端口数据
//@ResponseBody    作用1: 将对象转化为JSON  作用2: 如果返回值是String类型,则返回字符串本身
//                 作用3:  一般客户端发起ajax请求时,采用该注解返回数据, 将不会执行视图解析器操作
@RestController
//动态的导入pro配置文件,交给spring容器进行加载.
@PropertySource("classpath:/properties/redis.properties")
public class RedisController {

    @Value("${redis.host}") //spel表达式
    private String  host;   // = "192.168.126.130";      private String  host;   // = "192.168.126.130";
    @Value("${redis.port}")
    private Integer port;   // = 6379;

    @Value("${pro.redis.host}")
    private String  proHost;
    @Value("${pro.redis.port}")
    private Integer proPort;

    //指定properties文件进行赋值操作.
    @RequestMapping("/getMsg")
    public String getMsg(){
        //从yml配置文件中动态获取
        return host + ":" + port;
    }

    @RequestMapping("/getPro")
    public String getPro(){

        return proHost + ":" + proPort;
    }
}`

1.3 环境切换

业务说明:由于开发时都是链接公司自己的数据库/服务器等.把这个环境称之为"开发环境."
当开发完成之后需要进行上线部署,则需要链接"生产环境"
如果频繁的切换环境,则导致项目由于修改错误,导致问题的发生.
项目优化: 能否提供一种策略.简化上述操作的开发过程.

`#第一份配置文件,用来指定默认的环境标识
spring:
  profiles:
    active: prod

---
# YML文件语法
    #  1. key:(空格)  value
    #  2. key与key之间有层级的缩进关系.

#指定环境的名称
spring:
  profiles: dev
server:
  port: 8090

# 属性赋值操作,编辑属性时注意前缀.  只要springboot启动该数据就会被写入内存中 key-value格式
redis:
  host: 192.168.126.129
  port: 6379

# 1.需要将环境一分为二
---
spring:
  profiles:  prod
server:
  port: 9000

# 属性赋值操作,编辑属性时注意前缀.  只要springboot启动该数据就会被写入内存中 key-value格式
redis:
  host: 111.111.111.111
  port: 7000`

1.4 关于lombok说明

1.4.1 添加jar包

 `<!--引入插件lombok 自动的set/get/构造方法插件  -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>`

1.4.2 lombok案例

第三阶段 Day02~03

1.4.3 问题

说明:如果需要使用lombok工具就必须提前安装插件.如果在上线的时候Linux系统中,是否需要提前安装lombok插件?? 不需要安装.
第三阶段 Day02~03
原因: lombok插件在编译器有效. 将.java文件编译为.class文件时lombok会动态的添加get/set/toString…等方法.添加到.class文件中.
Linux上线部署时运行的时.jar文件 .jar包含的文件(.class文件)

1.4.4 知识小结

1.SpringBoot 开箱即用原理;
2.属性赋值的操作 @Value("${}")
3.动态导入资源文件 @PropertySource(“classpath:/properties/redis.properties”)
4.环境的切换 —, spring.profiles: dev ,默认的选项
5.lombok常用操作

2.SpringBoot整合Mybatis

2.1 新建项目

第三阶段 Day02~03
暂时只需要勾选webjar包即可

2.2 导入jt.sql的数据库

2.2.1 准备数据库工具

第三阶段 Day02~03

2.2.2 链接数据库

第三阶段 Day02~03

2.2.3 添加jar包文件

`<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.jt</groupId>
    <artifactId>springboot_demo2_mybatis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_demo2_mybatis</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <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>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!--引入插件lombok 自动的set/get/构造方法插件  -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--引入数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!--springBoot数据库连接  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!--spring整合mybatis  暂时  -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>`

2.2.4 编辑POJO对象

`@Data
@Accessors(chain = true)
public class User implements Serializable {
    private Integer Id;
    private String name;
    private Integer age;
    private String sex;
}`

2.2.5 编辑UserDao接口

`@Mapper //将接口交给Spring管理
public interface UserDao {

    //查询user表的所有的记录
    @Select("select * from user")
    List<User> findAll();

}`

2.2.6 编辑测试类

`package com.jt;

import com.jt.dao.UserDao;
import com.jt.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class SpringbootDemo2MybatisApplicationTests {

    @Autowired
    private UserDao userDao;

    @Test
    public void testFind(){

        List<User> userList = userDao.findAll();
        System.out.println(userList);
    }
}`

2.3 关于YML文件配置信息

2.3.1 关于数据库url说明

1.时区设定
serverTimezone=GMT%2B8 %2B= +号
2.编码格式设定
useUnicode=true&characterEncoding=utf8
3.是否自动的重新链接
autoReconnect=true
4.是否允许批量操作
allowMultiQueries=true

2.3.2 关于Mybatis配置说明

`mybatis:
  #定义别名包
  type-aliases-package: com.jt.pojo    可以简化mapper映射文件的编辑
  #加载user标签的mapper文件
  mapper-locations: classpath:/mybatis/mappers/*.xml
  #开启驼峰映射
  configuration:
    map-underscore-to-camel-case: true`

`<!--
        前提:   Mybatis进行映射时必须满足属性名称一致
        业务说明:
            表:      user_id   user_name
            对象:    userId   userName

        解决方案:  开启mybatis驼峰规则映射
        原理:
            字段名称user_id~~~去除"_"线~~~userid
            ~~~~首字母大写userId~~~~~属性userId
            只要名称一致,则可以自动映射.
        注意事项:  如果开启驼峰规则,则必须满足要求.
                 问: 对象的属性user_id 与字段user_id能否映射?  不能映射

    -->`

2.3.3 关于Mapper注解优化说明

由于每个接口都需要添加Mapper注解导致代码繁琐.可以采用包扫描的方式动态导入代码如下

`@SpringBootApplication
@MapperScan("com.jt.dao") //主要告诉mapper的包路径,会自动的完成包扫描
public class SpringbootDemo2MybatisApplication {

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

}`

3 Mybatis-plus介绍

3.1 ORM

对象关系映射（英语：Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。如今已有很多免费和付费的ORM产品，而有些程序员更倾向于创建自己的ORM工具。
实质: 对象与数据库中表完成映射
分析:

对象与表一一映射.
对象中的属性与表中的字段一一映射.

实质: 以对象的方式操作数据库.

说明 : Mybatis满足ORM对象映射的要求,但是Mybatis是一种半自动化的ORM映射框架
案例1: Mybatis进行数据库查询时,是否可以直接转化为对象,供用户使用呢 true 表与对象完成映射.
案例2: Mybatis在进行数据库更新操作时,能否利用对象直接操作呢??? false 不可以.需要自己手写sql.

3.2 MP介绍

MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

3.3 MP特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

3.4 MP入门案例

3.4.1 引入jar包

 `<!--spring整合mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>`

3.4.2 编辑POJO对象

`@Data
@Accessors(chain = true)
@TableName  //("user")      //1.将对象与表 进行一对一关联
public class User implements Serializable {
    @TableId(type = IdType.AUTO)    //主键的信息  设定自增
    private Integer Id;
    //@TableField(value = "name")     //如果字段名称与属性的名称一致(包含驼峰规则),可以省略不写
    private String name;
    private Integer age;
    private String sex;
}`

3.4.3 编辑Mapper接口

第三阶段 Day02~03

3.4.4修改YML映射文件

第三阶段 Day02~03

3.4.5 入门案例测试

`@Test
    public void testSelect01(){

        List<User> userList = userDao.selectList(null);
        System.out.println(userList);
    }`

3.5 MP实现原理

3.5.1 对象与表如何映射

可以利用自定义的注解的方式实现映射. @TableName 不能省略 @TableField(“name”)如果名称一致可以省略
1.对象的名称与表的名称一一映射.
2.对象中的属性与表中的字段一一映射.

3.5.2 利用接口封装公共的CURD方法

MP主要的目的是实现单表的CRUD操作.所以将公共的方法写到同一个接口中 BaseMapper
以后用户使用时,只需要继承即可.
第三阶段 Day02~03

3.5.3 需要将对象动态转化为SQL

要求:以对象的方式操作数据库. 需要方法动态转化为SQL
userMapper.insert(user对象)
Sql: insert into 表名(字段名称1,字段名称2....) values (属性值1,属性值2......)
personMapper.insert(person对象)
Sql: insert into 表名(字段名称1,字段名称2....) values (属性值1,属性值2......)

底层实现时需要动态的拼接Sql即可.
表名: @TableName注解动态获取
字段名称: @TableField(“name”) 获取
属性值: 动态利用get方法取值即可.

MP将上述的sql结构进行拼接最终形成可执行的Sql.之后利用Mybatis执行sql操作.之后再次封装.

3.6 MP API介绍

`package com.jt;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.jt.dao.UserDao;
import com.jt.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.List;

@SpringBootTest
class SpringbootDemo2MybatisApplicationTests {

    @Autowired
    private UserDao userDao;

    @Test
    public void testFind(){

        List<User> userList = userDao.findAll();
        System.out.println(userList);
    }

    @Test
    public void testSelect01(){

        List<User> userList = userDao.selectList(null);
        System.out.println(userList);
    }

    /**
     * 业务: 查询id=11的用户信息   主键...
     */
    @Test
    public void testSelect02(){

        User user = userDao.selectById(11);
        System.out.println(user);
    }

    /**
     * 业务: 查询name属性为"小乔"的数据
     * sql:  select * from user where name="小乔";
     * 对象的方式  >  sql方式
     */
    @Test
    public void testSelect03(){
        //条件构造器
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", "小乔");
        List<User> userList = userDao.selectList(queryWrapper);
        System.out.println(userList);
    }

    /**
     * 业务: 查询name属性为"小乔"的数据 并且 age >=18岁
     * sql:  select * from user where name="小乔" and age>=18;
     *
     * 大于   >  gt| 小于 <  lt   |
     * 大于等于  >= ge  |  小于等于 le
     */
    @Test
    public void testSelect04(){
        //条件构造器
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", "小乔")
                    .ge("age", 18);
        List<User> userList = userDao.selectList(queryWrapper);
        System.out.println(userList);
    }

    /**
     * 业务: 查询name中包含 "精"的用户,并且sex为女
     * 业务: 查询name中包含 以精结尾的数据,并且sex为女
     * sql:  select * from user where name like "%精%" and sex="女";
     */
    @Test
    public void testSelect05(){
        //条件构造器
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.likeLeft("name", "精")
                    .eq("sex", "女");
        List<User> userList = userDao.selectList(queryWrapper);
        System.out.println(userList);
    }

    /**
     * 需求: 查询user表中的数据 要求按照年龄降序排列,如果年龄相同按照id降序排列
     */
    @Test
    public void testSelect06(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByDesc("age","id");
        List<User> userList = userDao.selectList(queryWrapper);
        System.out.println(userList);
    }

    /**
     * 需求: 查询name属性为null的数据.
     * where name is null
     */
    @Test
    public void testSelect07(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNull("name");
        List<User> userList = userDao.selectList(queryWrapper);
        System.out.println(userList);
    }

    /**
     * 查询name="小乔" age=17 性别=女的用户
     * 如果传递的是对象.会根据对象中不为null的属性充当where条件.
     */
    @Test
    public void testSelect08(){
        User user = new User();
        user.setName("小乔").setAge(17).setSex("女");
        QueryWrapper<User> queryWrapper = new QueryWrapper<>(user);
        List<User> userList = userDao.selectList(queryWrapper);
        System.out.println(userList);
    }

    /**
     * 查询id=1,3,5,10数据.
     * sql: select * from user where id in (1,3,5,10)
     */
    @Test
    public void testSelect09(){
        //转化时,注意使用对象的类型
        Integer[] ids = {1,3,5,10};
        List<Integer> idList = Arrays.asList(ids);
        List<User> userList = userDao.selectBatchIds(idList);
        System.out.println(userList);
    }

    @Test
    public void testInsert(){
        User user = new User();
        user.setName("特朗普").setAge(70).setSex("男");
        userDao.insert(user);
    }

    /**
     * 删除name=null的数据,或者name="特朗普"
     */
    @Test
    public void testDelete(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNull("name")
                    .or()
                    .eq("name", "特朗普");
        userDao.delete(queryWrapper);
    }

    /**
     * 案例1: 将id=1的数据的年龄改为8000岁.
     * sql1:  update user set age=8000 where id=1;
     * 案例2: 要求将name="黑熊精" age=5500.
     * sql2:  update user set age=5500 where name="黑熊精";
     */
    @Test
    public void testUpdate(){
        User user = new User();
        user.setId(1);    //主键充当where条件
        user.setAge(8000);
        userDao.updateById(user);

        //参数说明  1.实体对象  封装set条件的值
        //           2.更新条件构造器
        User temp = new User();
        temp.setAge(5500);
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("name", "黑熊精");
        userDao.update(temp,updateWrapper);
    }
}`

4 SpringBoot整合web资源

4.1 创建web项目

第三阶段 Day02~03

4.2 编辑项目目录结构

第三阶段 Day02~03

4.3 引入jar包文件

`<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.jt</groupId>
    <artifactId>springboot_demo3_web</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>springboot_demo3_web</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <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>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!--引入插件lombok 自动的set/get/构造方法插件  -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--引入数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!--springBoot数据库连接  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!--spring整合mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>

        <!--springBoot整合JSP添加依赖  -->
        <!--servlet依赖 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
        </dependency>

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

        <!--使jsp页面生效 -->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>`

4.4 编辑YML配置文件

`server:
  port: 8090    #定义端口
  servlet:
    context-path: /   #定义项目的发布路径
spring:
  datasource:
    #driver-class-name: com.mysql.cj.jdbc.Driver   springboot程序采用默认的配置
    url: jdbc:mysql://127.0.0.1:3306/jtdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    username: root
    password: root

  mvc:         #引入mvn配置
    view:
      prefix: /WEB-INF/     # /默认代表根目录 src/main/webapp
      suffix: .jsp

mybatis-plus:
  #定义别名包
  type-aliases-package: com.jt.pojo
  #加载user标签的mapper文件
  mapper-locations: classpath:/mybatis/mappers/*.xml
  #开启驼峰映射
  configuration:
    map-underscore-to-camel-case: true

#引入日志信息.
logging:
  level:
    com.jt.mapper: debug`

4.5 查询user列表数据

要求: 用户通过http://localhost:8090/findAll请求.跳转到userList.jsp页面中.并且展现user表所有数据,以MP的方式查询

4.5.1 编辑UserController

`package com.jt.controller;

import com.jt.pojo.User;
import com.jt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

//@RestController   //json  字符串本身   不经过视图解析器
@Controller
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 需求：用户通过http://localhost:8090/findAll
     * 跳转页面路径:userList.jsp
     * 页面取值信息: el表达式:${userList} 从域中取值.
     *              在页面跳转之前应该将userList数据保存到域中 key就是userList.
     */
    @RequestMapping("/findAll")
    public String findAll(Model model){  //利用model对象将数据保存到request对象中.

        //1.查询数据库 获取list集合信息
        List<User> userList = userService.findAll();
        model.addAttribute("userList",userList);
        System.out.println(userList);
        return "userList";
    }

}`

4.5.2 编辑UserService

`package com.jt.service;

import com.jt.mapper.UserMapper;
import com.jt.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService{

    @Autowired
    private UserMapper userMapper;

    @Override
    public List<User> findAll() {

        return userMapper.selectList(null);
    }
}`

4.6 关于IDEA启动web项目配置

说明:配置IDEA启动项.将工作目录配置到本项目即可
第三阶段 Day02~03

4.7 异步的方式实现列表展现

4.7.1 跳转到ajax页面

需求:用户通过http://localhost:8090/ajax请求要求跳转到ajax.jsp页面中

`/**
     * 跳转到ajax.jsp页面
     */
    @RequestMapping("/ajax")
    public String ajax(){

        return "ajax";
    }`

页面效果展现
第三阶段 Day02~03

4.7.2 下载jQuery函数类库

第三阶段 Day02~03

4.7.3 导入函数类库

说明:从课前资料中获取jQuery类库即可
第三阶段 Day02~03

4.7.4 热部署配置

1).添加依赖包

`<!--支持热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>`

2).配置自动加载

第三阶段 Day02~03