返回首页

JavaWeb学习笔记——By Bug

前言

本笔记是Javaweb开发的笔记，需要有一定的前端基础和Java基础 ​ 笔记中省略了HTML，CSS，JavaScript，Vue，Ajax相关知识，本笔记中主要记录的是Java相关内容，前端相关笔记，请到本站导航站查阅！

说明： 本笔记为本人学习过程中随手写的笔记，为复习使用，笔记中可能存在遗漏或错误，具体请以官方文档和权威书籍为准！谢谢！ 笔记中的一些图片等元素因路径配置问题，可能会发生丢失。 笔记中展示的构造器和方法等的知识点仅为部分内容，完整内容请查阅官方开发文档内容！

参考资料

【黑马程序员JavaWeb开发教程，实现javaweb企业开发全流程（涵盖Spring+MyBatis+SpringMVC+SpringBoot等）】 https://www.bilibili.com/video/BV1m84y1w7Tb/?share_source=copy_web&vd_source=ea0cf64e8dac6f0193a7e28187a0fccb

Web开发简介

什么是Web？ Web即全球广域网，也称万维网，能够通过浏览器访问到的网站

前端web开发

Axios

Axios是对原生的Ajax进行了封装，简化书写

Axios官方文档👇 起步 | Axios中文文档 | Axios中文网 (axios-http.cn)

在vue项目中安装axios

npm i axios

导入axios

xxxxxxxxxx
import axios from axios

前端工程化

Vue

见：Vue2+Vue3笔记

当前主流开发模式：前后端分离模式 前端开发前端页面，后端开发后端程序，前端使用数据时使用API获得相应的数据 以接口文档为标准

流程：需求分析→定义接口文档→前后端并行开发（遵循API文档）→测试（前后端分别测试）→前后端联调测试

接口文档管理平台推荐：YApi，POSTMAN，APIFox

前端工程化开发：模块化（js,css），组件化（UI结构，样式，行为），规范化（结构，编码，接口），自动化（构建，部署，测试）

Element

Element：是一套为开发者，设计师等准备的基于Vue2.0的桌面端组件库 组件：组成网页的部件，如 超链接，按钮，图片，表格，表单等 官网：https://element.eleme.cn/

element-ui组件安装

1. 打开终端，输入以下命令

   xxxxxxxxxx
   npm i element-ui -S
   或
   npm install element-ui@版本号2.15.14
   

2. 在main.js中引入element-ui

   ​x
   import ElementUI from 'element-ui';
   import 'element-ui/lib/theme-chalk/index.css';
   
   Vue.use(ElementUI);
   

3. 访问官网文档，选择需要的组件复制后根据需要进行调整 组件 | Element

前端web开发介绍到此结束

下面是后端web开发内容

后端web开发

Maven

Maven是apache旗下的开源项目，用于管理和构建Java项目的工具 官网：Maven – Welcome to Apache Maven

Maven的作用

1. 依赖管理：方便快捷的管理项目的依赖资源（jar包），避免版本冲突问题

2. 提供标准、统一的项目结构

3. 项目构建：标准跨平台的自动化项目构建方式

Maven的介绍

Maven是一个项目管理和构建工具，它是基于项目对象模型（POM）的概念，通过一小段描述信息来管理项目的构建。

仓库：用于存储资源，管理各种jar包

• 本地仓库：自己计算机上的仓库

• 中央仓库：由Maven团队维护的全球统一的仓库

• 远程仓库：公司团队搭建的私有仓库

Maven的安装

1. 下载并解压压缩包 下载地址：Maven – Download Apache Maven

2. 配置本地仓库：修改conf/settings.xml中的<localRepository>为一个指定目录

   xxxxxxxxxx
   <localRepository>E:\A-learn\JAVA\mavengit</localRepository>
   

3. 配置阿里云私服：修改<mirrors>标签

   xxxxxxxxxx
   <mirror>
       <id>aliyunmaven</id>
       <mirrorOf>*</mirrorOf>
       <name>阿里云公共仓库</name>
       <url>https://maven.aliyun.com/repository/public</url>
   </mirror>
   

4. 配置环境变量：Maven_HOME,并将其Bin目录加入PATH

   xxxxxxxxxx
   检查是否配置完成,执行cmd指令
   mvn -v
   

IDEA集成Maven

• 配置Maven环境

  • 配置当前工程环境

    xxxxxxxxxx
    打开IDEA：File-->Settings-->Build,Execution,Deployment-->Build Tools-->Maven
    配置对应的安装目录，设置xml目录和仓库目录
    

  • 全局配置

    xxxxxxxxxx
    在欢迎界面，点击customize-->All settings-->Build,Execution,Deployment-->Build Tools-->Maven
    

     

• 创建Maven项目 点击创建项目，选择maven，设置配置项

  Maven坐标 Maven坐标是资源的唯一标识，通过该坐标可以唯一定位资源的位置 可以使用坐标来定义或引入项目中需要的依赖

  Maven坐标的组成

  xxxxxxxxxx
  <groupId>org.example</groupId>---->定义当前maven项目历史的组织名称
  <artifactId>untitled</artifactId>---->定义当前Maven项目的名称（模块名称）
  <version>1.0-SNAPSHOT</version>---->定义当前项目的版本号
  

   

Maven依赖管理

• 依赖配置 依赖：指的当前项目运行所需要的jar包，一个项目中可以引入多个依赖 配置：

  1. 在pom.xml中编写<dependencies></dependencies>标签

  2. 在标签中使用<dependency>标签引入坐标

     xxxxxxxxxx
     <dependency>
         <groupId></groupId>
         <artifactId></artifactId>
         <version></version>
     </dependency>
     

  3. 定义坐标的groupId，artifactId，version

  4. 点击刷新按钮，引入新加入的坐标

  查找依赖网站：Maven Repository: Search/Browse/Explore (mvnrepository.com)

• 依赖传递 A项目中依赖的B项目的依赖会传递到A项目 直接依赖：在当前项目中通过依赖配置建立的依赖关系 间接资源：被依赖的资源还依赖了其他资源，当前项目就间接依赖其他资源

  • 排除依赖 主动断开依赖的资源，排除的资源无需指定版本号

    xxxxxxxxxx
    <dependency>
               <groupId>ch.qos.logback</groupId>
               <artifactId>logback-classic</artifactId>
               <version>1.5.6</version>
               <exclusions>
                   <exclusion>
                       <groupId>ch.qos.logback</groupId>
                       <artifactId>logback-classic</artifactId>
                   </exclusion>
               </exclusions>
           </dependency>
    

     

• 依赖范围 依赖的jar包默认情况下可以在任何地方使用 使用<scope></scope>标签设置其作用的范围 作用范围：

  • main(主程序范围内有效)

  • test(测试程序范围有效)

  • package(是否参与打包运行)

  scope取值	主程序	测试程序	打包
  cpmpile(default)	Y	Y	Y
  test		Y
  provide	Y	Y
  runtime		Y	Y

   

• 生命周期 Maven生命周期就是为了对所有的Maven项目构建过程进行抽象和统一 Maven有三套独立的生命周期

  • clean：清理工作

  • default：核心工作，如编译，测试，打包，安装，部署等

  • site：生成报告，发布站点等

  

  • clean：移除上次构建生成的文件

  • compile：编译项目源代码

  • test：使用合适的单元测试框架运行测试

  • package：将编译后的文件打包

  • install：安装项目到本地仓库

   

SpringBoot Web基础

Spring官网：Spring | Home

SpringBoot可以帮助快速构建应用程序，简化开发，提高效率

SpringBoot Web入门

补充教程：IDEA专业版 注意：本方法来源于网络，安全性请自行权衡！如果不放心，可前往官网申请学习产品。

如安装了社区版，请先卸载，到官网下载专业版并安装。 Download IntelliJ IDEA – The Leading Java and Kotlin IDE (jetbrains.com)

下载激活脚本：JetBrains 全家桶激活（2024最新）.zip - 蓝奏云 (lanzouh.com)

运行激活脚本，并检查是否激活成功

也可以申请学习版，申请地址：JetBrains 学习产品

新建第一个springboot应用 需求：使用springBoot开发一个web应用，浏览器发出请求/hello时，返回一个HELLO WORLD字符串

• 创建springBoot工程(请下载专业版)

• 构建工具选择Maven，依赖选SpringWeb

• 定义一个请求处理类

  xxxxxxxxxx
  package org.example.chuli;
  
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;
  
  @RestController
  public class returnhello {
      @RequestMapping("/hello")
      public String hello(){
          System.out.printf("hello");
          return "hello";
      }
  }
  

• 启动项目：启动创建项目时自动创建的启动类

• 访问：

  xxxxxxxxxx
  http://localhost:8080/hello
  

HTTP协议

概述

HTTP：即超文本传输协议，规定了浏览器与服务器之间的数据传输规则

特点

1. 基于TCP协议：面向连接，安全

2. 基于请求--响应模型的：一次请求对应一次响应

3. HTTP协议是无状态的协议：对于事务的处理没有记忆能力。每次请求和响应都是独立的 优点：速度快 缺点：多次请求之间不能共享数据

请求协议

请求格式：

• 请求行：请求数据的第一行（包含请求方式，资源路径，协议）

• 请求头：第二行开始，格式为 key:value

• 请求体：在post请求最后，用于存放请求参数

Get与post请求区别 GET：请求参数在请求行中，没有请求体。 POST：请求参数在请求体中，POST请求大小没有限制。

请求方式

常用的HTTP请求头

响应协议

响应组成

• 响应行

• 响应头

• 响应体

响应码介绍

状态码分类

1. 信息响应 (100–199)

2. 成功响应 (200–299)

3. 重定向消息 (300–399)

4. 客户端错误响应 (400–499)

5. 服务端错误响应 (500–599)

状态码解释

常用的HTTP响应头

Web服务器

Web服务器是一个软件程序，对HTTP协议的操作进行了封装，使得程序员不需要直接对协议进行操作，使得开发更加便捷。

TomCat介绍

TomCat是一个开源免费的轻量级WEB服务器，支持servlet/jsp少量JavaEE规范

TomCat安装和使用

注意：TomCat已经内置在SpringBoot中，无需再进行下载和安装

TomCat官网：Apache Tomcat® - Welcome!

请求响应

• 请求(HttpServletRequest)：获取请求数据

• 响应(HttpServletResponse)：设置响应数据

• BS架构：Browser/server，浏览器/服务器架构

请求

POSTMAN

一款功能强大的网页调试与发送请求的chrome插件，常用于进行接口测试 官网：Postman API Platform | Sign Up for Free 其他工具：APIPOST, APIFOX

1. 下载安装包，并进行安装

2. 注册账号，并进行登录

3. 创建工作空间（workspaces）

简单参数

• 原始方式(了解) 在原始的web程序中，获取请求参数，需要通过HttpServletRequest对象手动获取

  xxxxxxxxxx
  package org.example.chuli;
  
  import jakarta.servlet.http.HttpServletRequest;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;
  
  @RestController
  public class returnhello {
      @RequestMapping("/hello")
      public String qingqiu(HttpServletRequest request) {
          String name = request.getParameter("name");
          String age = request.getParameter("age");
          System.out.printf("姓名：" + name + "年龄" + age);
          return "请求成功"+"姓名：" + name + "年龄" + age;
      }
  }
  
  

  测试请求，成功

  

  这样的处理方法复杂有难以维护

   

SpringBoot方式

简单参数：在方法中设置参数名与形参变量名相同，定义形参接收参数

xxxxxxxxxx
package org.example.chuli;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class returnhello {
    @RequestMapping("/hello")
    public String qingqiu(String name,Integer age) {
        System.out.printf("姓名：" + name + "年龄" + age);
        return "请求成功"+"姓名：" + name + "年龄" + age;
    }
}

如果请求参数与方法形参不一致，可以使用注解@RequestParam进行映射

xxxxxxxxxx
 public String qingqiu(@RequestParam(name = "name") String username, Integer age) {
        System.out.printf("姓名：" + username + "年龄" + age);
        return "请求成功"+"姓名：" + username + "年龄" + age;
    }

实体参数

简单实体对象：请求参数名与形参对象属性名相同，定义一个 类 接收即可

xxxxxxxxxx
package org.example.chuli;

public class user {
    private String name;
    private int age;
    public user() {}

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "user{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

xxxxxxxxxx
 @RequestMapping("/shiti")
    public String qingqiu(user u) {
        System.out.printf(u.toString());
        return  "ok";
    }

注意：请求参数名要与形参参数名一致

复杂实体对象：请求参数名与形参对象属性名一致，按照对象层次关系即可接收嵌套属性参数

xxxxxxxxxx
@RequestMapping("/shiti")
    public String qingqiu(user u) {
        System.out.println(u.toString());
        return  "ok";
    }

xxxxxxxxxx
package org.example.chuli;

public class user {
    private String name;
    private int age;
    private Address address;
    public user() {}

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "user{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", " + address.toString() +
                '}';
    }
}

xxxxxxxxxx
package org.example.chuli;

public class Address {
    private String city;
    private String state;

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                ", state='" + state + '\'' +
                '}';
    }
}

请求格式样例：

xxxxxxxxxx
http://localhost:8080/shiti?name=里斯&age=30&address.city=河北省&address.state=唐山市

数组集合参数

数组参数：请亲参数名与形参数组名称相同，且请求参数有多个，定义一个数组类型的形参即可接收参数

xxxxxxxxxx
package org.example.chuli;

import java.util.Arrays;

public class hob {
    private String[] hobby;

    @Override
    public String toString() {
        return "hob{" +
                "hpbby=" + Arrays.toString(hobby) +
                '}';
    }

    public String[] getHobby() {
        return hobby;
    }

    public void setHobby(String[] hobby) {
        this.hobby = hobby;
    }
}

xxxxxxxxxx
@RequestMapping("/Array1")
    public String qingqiu(hob h) {
        System.out.println(h.toString());
        return  "ok";
    }

xxxxxxxxxx
//请求
http://localhost:8080/Array1?hobby=唱&hobby=跳&hobby=rap&hobby=篮球

日期参数

使用@DateTimeFormat注解完成日期参数格式转换

xxxxxxxxxx
 @RequestMapping("/timesave")
    public String times(@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime time) {
        System.out.println(time.toString());
        return  "ok";
    }

JSON参数

请求方式：POST 接收json数据一般使用对象接收，JSON数据的键名与形参对象的属性名相同。需要使用@RequestBody标识

xxxxxxxxxx
package org.example.chuli;

public class Address {//地址对象
    private String city;
    private String state;

}


package org.example.chuli;

public class user {//用户对象
    private String name;
    private int age;
    private Address address;
   
}

xxxxxxxxxx
    @RequestMapping("/json")
    public String qingqiu(user u) {
        System.out.println(u.toString());
        return  "ok";
    }

路径参数

通过请求URL直接传递的参数，使用{...}来表示该路径的参数，需要使用@PathVariavle获取路径参数

xxxxxxxxxx
@RequestMapping("/getPath/{p}")
public String path(@PathVariable String p) {
    System.out.println(p);
    return  "ok";
}

xxxxxxxxxx
http://localhost:8080/getPath/12

响应

HttpServletResponse

• 响应数据

  • @ResponseBody

    位置：方法注解，类注解

    位置：Controller方法/类上

    作用：将方法返回值直接响应，如果返回值是实体对象、集合，将会转换为JSON格式响应

    说明：@RestController=@Controller+@ResponseBody

    xxxxxxxxxx
    package org.example.chuli;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.ArrayList;
    
    @RestController
    public class xiangying {
        @RequestMapping("/string")
        public String string1() {
            return "string";
        }
    
        @RequestMapping("/class")
        public Address string2() {
            Address address = new Address();
            address.setState("河北省");
            address.setCity("唐山市");
    
            return address;
        }
        @RequestMapping("/list")
        public ArrayList<String> list() {
            ArrayList<String> list = new ArrayList<>();
            list.add("string");
            list.add("string");
            list.add("string");
            list.add("string");
            return list;
        }
    }
    
    

     

分层解耦

三层架构

• Controller：控制层，接受前端发送的请求，对请求进行处理，并响应数据

• Service：业务逻辑层，处理具体的业务逻辑。

• dao：数据访问层（Data Access Object）(持久层)，负责数据访问操作，包括数据的增删改查

分层解耦

• 内聚：软件中各个功能模块内部的功能联系。

• 耦合：衡量软件中各个层、模块之间的依赖，关联程度。

• 软件设计原则：高内聚低耦合

将使用的对象放在容器中，模块需要使用时，从容器中得到

• 控制反转：IOC(Inversion Of Control)。对象的创建控制权由程序自身转移到外部容器。

• 依赖注入：DI(Dependency Injection)。容器为应用程序提供运行时，所需的外部资源

• Bean对象：IOC容器中创建、管理的对象。

IOC&DI入门

在使用IOC的程序上加入注解：@Component 在使用IOC程序提供的资源上添加注解：@Autowired

xxxxxxxxxx
@Component
public class fenceng {
    @Autowired//在运行时，IOC容器会提供该类型的Bean对象 
    private String a;
}

IOC详解

要把某个对象交给IOC容器管理，需要在对应的类上加入对应注解

Bean组件扫描

• 前面四个注解标志的对象要想生效，还需要被组件扫描注解@ComponentScan扫描

• @ComponentScan注解虽然没有显示配置，默认已经包含在启动类声明在@SpringBootApplication中

   

DI详解

由于@Autowired默认是按照类型进行注入的，如果存在多个相同类型的bean，就会报错

解决方案：使用以下注解解决

• @Primary：需要哪个Bean生效，就在哪个Bean上面加上次注解

• @Qualifier：在Autowired上面使用此注解（Qualifier(value)）指定生效的bean。

• @Resource：不使用Autowired注解，使用此注解指定生效的Bean(Resource(name="beanname"))

总结

xxxxxxxxxx
@Autowired：默认按照类型自动装配。
如果同类型的bean存在多个，可以使用以下三种解决方案
@Primary
@Autowired+@Qualifier（"bean的名称"）
@Resource(name="bean的名称")

扩展：@Resource与@Autowired区别

• @Autowired是spring框架提供的注解，而@Resource是JDK提供的注解。

• @Autowired默认是按照类型注入，而@Resource默认是按照名称注入。

MySQL

MySQL相关笔记请参考本站mysql笔记

SpringBoot Mybatis

Mybatis简介

MyBatis 是一款优秀的持久层（数据访问层）框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

MyBatis中文网

Mybatis入门

使用Mybatis操作数据库

1. 创建SpringBoot工程，数据库表和实体类

2. 引入Mybatis依赖，配置Mybatis 在application.properties文件中配置数据库的连接信息

   xxxxxxxxxx
   spring.datasource.url=jdbc:mysql://localhost:3306/mybatis
   spring.datasource.username=root
   spring.datasource.password=123456
   

   定义一个持久层的接口，只需要定义接口，不需要重写实现类，在调用方法时

    

3. 编写SQL语句 案例：使用Mybatis查用户表中的所有数据

   xxxxxxxxxx
   //接口类
   package org.example.mybatis_demo;
   import org.apache.ibatis.annotations.Mapper;
   
   @Mapper//在运行时会自动生成该接口的实现类，并交给IOC容器管理
   public interface usermapper {
       @Select("select * from user")//指定操作和语句
       public List<user> selectAll();
   }
   

   xxxxxxxxxx
   //user类
   package org.example.mybatis_demo;
   
   public class user {
       private Integer id;
       private String name;
       private Integer age;
       public String gender;
   
       public user() {
       }
   
       public user(Integer id, String name, Integer age, String gender) {
           this.id = id;
           this.name = name;
           this.age = age;
           this.gender = gender;
       }
   
       public void setId(Integer id) {
           this.id = id;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public void setAge(Integer age) {
           this.age = age;
       }
   
       public void setGender(String gender) {
           this.gender = gender;
       }
   
       @Override
       public String toString() {
           return "user{" +
                   "id=" + id +
                   ", name='" + name + '\'' +
                   ", age=" + age +
                   ", gender='" + gender + '\'' +
                   '}';
       }
   }
   

   xxxxxxxxxx
   //测试类
   @Autowired
   private usermap userMapper;
   
   @Test
   void testSelectAll() {
       List<User> users = userMapper.selectAll();
       assertNotNull(users);
       users.forEach(System.out::println);
   }
   

    

JDBC介绍

使用Java语言操作关系型数据库的一套API

原始的JDBC程序操作繁琐，浪费计算机性能和资源

在Mybatis中将数据库连接信息配置到了单独的配置文件中，查询的结果会自动进行封装，利用数据库连接池技术避免频繁的连接和释放

数据库连接池

• 数据库连接池是一个容器，负责分配，管理数据库连接。

• 它允许应用程序的重复使用一个现有的数据库连接，而不是重新建立一个新的连接。

• 释放闲置时间超过最大限制时间的连接，避免因没有释放连接而引起的数据库连接遗漏。

数据库连接池的优点

• 资源重用

• 提升系统的响应速度

• 避免数据库连接遗漏

lombok

lombok可以简化编写实体类的代码，使得代码更加简洁

lombok是一个实用的Java类库，能通过注解的形式自动生成构造器，getter/setter方法，equals，hashcode，toString等方法，并可以自动化生成日志，简化Java开发，提高效率

lombox提供的部分注解

引入lombok依赖

xxxxxxxxxx
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <scope>provided</scope>
</dependency>

之前的实体类，代码臃肿

xxxxxxxxxx
package org.example.demo4;

public class User {
    private Integer id;
    private String name;
    private Integer age;
    private String gender;

    public User() {
    }

    public User(Integer id, String name, Integer age, String gender) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}

使用lombok简化的代码，简介，一目了然

xxxxxxxxxx
package org.example.demo4;

import lombok.Data;

@Data
public class User {
    private Integer id;
    private String name;
    private Integer age;
    private String gender;

}

Mybatis增删改查

注释配置SQL

本操作用到的数据库信息

xxxxxxxxxx
-- 部门管理
create table dept(
    id int unsigned primary key auto_increment comment '主键ID',
    name varchar(10) not null unique comment '部门名称',
    create_time datetime not null comment '创建时间',
    update_time datetime not null comment '修改时间'
) comment '部门表';

insert into dept (id, name, create_time, update_time) values(1,'学工部',now(),now()),(2,'教研部',now(),now()),(3,'咨询部',now(),now()), (4,'就业部',now(),now()),(5,'人事部',now(),now());



-- 员工管理
create table emp (
  id int unsigned primary key auto_increment comment 'ID',
  username varchar(20) not null unique comment '用户名',
  password varchar(32) default '123456' comment '密码',
  name varchar(10) not null comment '姓名',
  gender tinyint unsigned not null comment '性别, 说明: 1 男, 2 女',
  image varchar(300) comment '图像',
  job tinyint unsigned comment '职位, 说明: 1 班主任,2 讲师, 3 学工主管, 4 教研主管, 5 咨询师',
  entrydate date comment '入职时间',
  dept_id int unsigned comment '部门ID',
  create_time datetime not null comment '创建时间',
  update_time datetime not null comment '修改时间'
) comment '员工表';

INSERT INTO emp
    (id, username, password, name, gender, image, job, entrydate,dept_id, create_time, update_time) VALUES
    (1,'jinyong','123456','金庸',1,'1.jpg',4,'2000-01-01',2,now(),now()),
    (2,'zhangwuji','123456','张无忌',1,'2.jpg',2,'2015-01-01',2,now(),now()),
    (3,'yangxiao','123456','杨逍',1,'3.jpg',2,'2008-05-01',2,now(),now()),
    (4,'weiyixiao','123456','韦一笑',1,'4.jpg',2,'2007-01-01',2,now(),now()),
    (5,'changyuchun','123456','常遇春',1,'5.jpg',2,'2012-12-05',2,now(),now()),
    (6,'xiaozhao','123456','小昭',2,'6.jpg',3,'2013-09-05',1,now(),now()),
    (7,'jixiaofu','123456','纪晓芙',2,'7.jpg',1,'2005-08-01',1,now(),now()),
    (8,'zhouzhiruo','123456','周芷若',2,'8.jpg',1,'2014-11-09',1,now(),now()),
    (9,'dingminjun','123456','丁敏君',2,'9.jpg',1,'2011-03-11',1,now(),now()),
    (10,'zhaomin','123456','赵敏',2,'10.jpg',1,'2013-09-05',1,now(),now()),
    (11,'luzhangke','123456','鹿杖客',1,'11.jpg',5,'2007-02-01',3,now(),now()),
    (12,'hebiweng','123456','鹤笔翁',1,'12.jpg',5,'2008-08-18',3,now(),now()),
    (13,'fangdongbai','123456','方东白',1,'13.jpg',5,'2012-11-01',3,now(),now()),
    (14,'zhangsanfeng','123456','张三丰',1,'14.jpg',2,'2002-08-01',2,now(),now()),
    (15,'yulianzhou','123456','俞莲舟',1,'15.jpg',2,'2011-05-01',2,now(),now()),
    (16,'songyuanqiao','123456','宋远桥',1,'16.jpg',2,'2010-01-01',2,now(),now()),
    (17,'chenyouliang','123456','陈友谅',1,'17.jpg',NULL,'2015-03-21',NULL,now(),now());

参数占位符

• #{...}

  1. 执行SQL时，会将#{...}替换为?，生成预编译的SQL，会自动设置参数值

  2. 使用时机：参数传递，都是用#{...}

• ${...}

  1. 拼接SQL，直接将参数拼接在SQL语句中，存在SQL注入问题，有安全漏洞

  2. 使用时机：对表名，列表进行动态设置时使用，使用场景少

• 查询

  • 根据主键ID查询，用于页面回显

    xxxxxxxxxx
    //查询指定信息
    @Select("select * from emp where id=#{ids}")
    User shows(int ids);
    

    xxxxxxxxxx
    @Test
    void testselect(){
        User a1 = userMapper.shows(11);
        System.out.printf(a1.toString());
    }
    

    结果发现，创建时间，修改时间未自动封装

    xxxxxxxxxx
    (id=11, userName=luzhangke, passWord=123456, name=鹿杖客, gender=1, image=11.jpg, job=5, entryDate=2007-02-01, deptId=0, createTime=null, updateTime=null)2024-08-15T11:57:13.966+08:00 
    

    数据封装

    • 实体类和数据库表查询返回字段一致，Mybatis会自动封装。

    • 如果实体类和数据库表查询返回字段不一致，不会自动封装。

    方案1：给字段起别名，让别名与实体类的属性一致

    xxxxxxxxxx
    //查询指定信息
    @Select("select ID, USERNAME, PASSWORD, NAME, GENDER, IMAGE, JOB, ENTRYDATE, DEPT_ID, CREATE_TIME createTime, UPDATE_TIME updateTime from emp where id=#{ids}")
    User shows(int ids);
    

    方案2：使用@Results，@Result注解手动映射封装

    xxxxxxxxxx
    //查询指定信息
    @Results({
        @Result(column = "dept_id",property = "deptId"),//column = "映射的字段",property = "映射到。。。"
        @Result(column = "create_time",property = "createTime"),
        @Result(column = "update_time",property = "updateTime")
    
    })//一个Result注解映射一个字段
    @Select("select * from emp where id=#{ids}")
    User shows(int ids);
    

    ⭐方案3：开启Mybaits驼峰命名自动映射 前提：字段名必须是下划线命名，字段名必须严格遵循驼峰命名

    xxxxxxxxxx
    //在属性配置文件中开启
    mybatis.configuration.map-underscore-to-camel-case=true
    

     

  • 条件查询

    xxxxxxxxxx
    //条件查询接口
        @Select("select * from emp where name like '%${name}%' and gender =#{gender} and entrydate between #{begin} and #{end}")
        List<User> showsome(String name, short gender, LocalDate begin, LocalDate end);
    //name like '%${name}%'可以使用字符串拼接
    @Select("select * from emp where name like concat('%',#{name},'%') and gender =#{gender} and entrydate between #{begin} and #{end}")
    

    xxxxxxxxxx
    //测试方法
     @Test
        void testSelectsome() {
            List<User> users = userMapper.showsome("张",(short) 1,LocalDate.of(2010,1,1),LocalDate.of(2015,1,1));
            users.forEach(System.out::println);
        }
    

     

• 新增

  xxxxxxxxxx
  //新增数据方法 
  @Insert("INSERT INTO emp(username, name, gender, image, job, entrydate, dept_id, create_time, update_time) " +
              "VALUES (#{userName},#{name},#{gender},#{image},#{job},#{entryDate},#{deptId},#{createTime},#{updateTime})")
  void insert(User user);
  

  xxxxxxxxxx
  //测试方法
  @Test
  void testinsert(){
      User u =new User();
      u.setUserName("zhangsan");
      u.setName("张三");
      u.setGender((short) 1);
      u.setImage("1.png");
      u.setJob((short) 1);
      u.setEntryDate(LocalDate.of(2021,3,3));
      u.setDeptId((short) 1);
      u.setCreateTime(LocalDateTime.now());
      u.setUpdateTime(LocalDateTime.now());
  
      userMapper.insert(u);
  }
  

  新增数据后返回主键

  xxxxxxxxxx
  @Options(keyProperty = "id",useGeneratedKeys = true)//使用Options声明,插入完成后会将ID返回到对象的ID属性中
  @Insert("INSERT INTO emp(username, name, gender, image, job, entrydate, dept_id, create_time, update_time) " +
          "VALUES (#{userName},#{name},#{gender},#{image},#{job},#{entryDate},#{deptId},#{createTime},#{updateTime})")
  void insert(User user);
  

   

• 修改

  xxxxxxxxxx
  //更新接口
  @Update("UPDATE emp set username=#{userName},name=#{name},gender=#{gender},image=#{image},job=#{job},entrydate=#{entryDate},dept_id=#{deptId},update_time=#{updateTime} where id =#{id}")
  void update(User user);
  

  xxxxxxxxxx
  //测试方法
  @Test
  void testinsert(){
      User u =new User();
      u.setUserName("zhangsanfeng1");
      u.setName("张三风1");
      u.setGender((short) 1);
      u.setImage("1.png");
      u.setJob((short) 1);
      u.setEntryDate(LocalDate.of(2021,3,3));
      u.setDeptId((short) 1);
      u.setCreateTime(LocalDateTime.now());
      u.setUpdateTime(LocalDateTime.now());
  
      userMapper.insert(u);
      System.out.printf(u.getId().toString());
  }
  

   

• 删除

  • 根据主键ID删除

    xxxxxxxxxx
    @Delete("delete from emp where id =#{id}")//使用#{}作为占位符，获取传入的ID
    void deleteById(Integer id);//此操作有返回值，返回值为影响的数据行数
    //测试程序
    @Test
    void testdeleteById() {
        userMapper.deleteById(17);
    }
    

     

  • 根据主键ID批量删除 参考动态SQL的foreach

XML文件配置SQL语句

规范

1. XML映射文件的名称要与Mapper接口名称一致，并且将XML映射文件和Mapper接口放置在相同包下（同包同名）

2. XML映射文件的namespace属性为Mapper接口全类名一致

3. XML文件中的SQL语句的id与Mapper接口中的方法名一致，并保持返回类型一致

配置内容

xxxxxxxxxx
<?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="org.mybatis.example.BlogMapper">
  <select id="selectBlog" resultType="Blog">
    select * from Blog where id = #{id}
  </select>
</mapper>

这个插件可以快速定位接口与sql语句直接的关系

点击小鸟可完成快速跳转

使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。 因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。

选择何种方式来配置映射，以及认为是否应该要统一映射语句定义的形式，完全取决于你和你的团队。 换句话说，永远不要拘泥于一种方式，你可以很轻松的在基于注解和 XML 的语句映射方式间自由移植和切换。

Mybatis动态SQL

动态SQL是随着用户输入或外部条件的变化而变化的SQL语句

<if>

xxxxxxxxxx
<mapper namespace="org.example.demo4.usermap">
    <select id="showsome" resultType="org.example.demo4.User">
        select * from emp
        <where>//where标签可以自动去除语句中多余的and
        <if test="name!=null">
            name like concat('%',#{name},'%')
        </if>
        <if test="gender!=null">
            and gender =#{gender}
        </if>
        <if test="begin!=null and end!=null ">
            and entrydate between #{begin} and #{end}
        </if>
        </where>
    </select>
</mapper>

xxxxxxxxxx
<where></where>//where标签可以自动去除语句中多余的and、or
<set></set>//可以自动去除update语句中多余的逗号

<foreach>

foreach标签属性介绍

• collection：遍历的集合

• item：遍历出的元素

• separator：分隔符

• open：遍历之前拼接的符号

• close：遍历最后拼接的符号

   

需求：批量删除数据

xxxxxxxxxx
//接口
void deletesome(List<Integer> ids1);

xxxxxxxxxx
//xml删除语句
<delete id="deletesome">
    delete from emp where id in
    <foreach collection="ids1" item="id" separator="," open="(" close=")">#{id}</foreach>
</delete>

xxxxxxxxxx
//测试方法
@Test
void delectsometest() {
    List<Integer> ids = Arrays.asList(16, 18, 21);
    userMapper.deletesome(ids);
}

<sql>&&<include>

<sql>用于定义可重用的SQL语句片段

<include>：通过refid属性，引入SQL片段

xxxxxxxxxx
<sql id="sel"> select id, username, password, name, gender, image, job, entrydate, dept_id, create_time, update_time from emp</sql>
<select id="selectAll" resultType="org.example.demo4.User">
    <include refid="sel"></include>
</select>

案例：教学辅助系统

开发学习系统的部门管理和员工管理模块

体会前后端交互方式

准备

• 准备数据库表

• 引入相关依赖（web，mybatis，mysql驱动，lombok）

• 配置application.properties中引入mybatis的配置信息，准备对应的实体类

• 三层架构（mapper，server，controller）的基础结构

部门管理

• 查询部门列表

• 删除部门

• 新增部门

• 修改部门

• 前后端联调

员工管理

• 查询员工列表

• 删除员工

• 新增员工

• 修改员工

分页查询插件：PageHelper

xxxxxxxxxx
//引入依赖
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>2.1.0</version>
</dependency>

文件上传

指的是将本地图片，视频，音频等文件上传到服务器，供其他用户浏览或下载的过程

文件上传表单的三要素

xxxxxxxxxx
<form action="www.baidu.com/upload" method="post" enctype="multipart/form-data">
    <input type="text" name="username" id="">
    <input type="text" name="passworld" id="">
    <input type="file" name="files" id="">
    <input type="submit" value="">
</form>

服务端接收数据 普通数据依然正常接收，文件使用 MultipartFile 接收

存储方式

本地存储

将接受的文件转存到服务器磁盘

在MultipartFile中提供了一个transferTo方法，可以将接收到的文件转存到指定的磁盘目录中 在获取原始文件名时，可以使用MultipartFile中提供的getOriginalFilename()方法获取

为了防止文件名重复问题，可以使用UUID解决

上传文件的默认最大为1MB，可以通过配置属性文件修改允许上传的最大文件大小

xxxxxxxxxx
#单个文件限制大小
spring.servlet.multipart.max-file-size=10MB
#单个请求最大文件大小
spring.servlet.multipart.max-request-size=100MB

云存储

使用云服务提供商,提供的对象存储服务OSS

准备

1. 注册云服务账号

2. 开通对象存储服务OSS

3. 创建存储空间

4. 获取密钥

5. 参考官网文档进行开发

配置文件

参数配置化

可以将阿里云的配置信息配置到SpringBoot的配置文件中，通过外部配置的属性注入方式添加属性

用法@Value("${配置文件中的KEY}")

yml配置文件

后缀名可以是yml，也可以是yaml

书写格式KEU:VALUE，并按照层级进行书写

xxxxxxxxxx
serve:
    address:127.0.0.1
    port:8080

yml配置基本语法

1. 大小写敏感

2. 数值前面必须加空格，作为分隔符

3. 使用缩进表示层级关系，缩进是不允许使用tab，要使用空格（在IDEA中会自动将TAB转化为空格，可忽略）

4. 缩进空格数目不重要，相同层级缩进数量相同即可

5. #表示注释

xxxxxxxxxx
#定义对象/Map集合
user:
    name: tom
    age: 10
    address: shanghai
#定义数组/List/Set集合
hobby:
    - java
    - game
    - sport

@ConfigurationProperties

这个注解可以将配置文件中的数据注入到对象中，要求配置文件的属性名要和对象的属性名相同才能完成自动注入，再将该对象交给IOC容器管理即可，使用时再将此对象对象进行注入。

登录功能

基础登录

逻辑：使用输入的用户名和密码在数据库中查找，查找到结果即为登录成功，反之认为登录失败

xxxxxxxxxx
//colltroller
package org.example.learnsys.controller;

import lombok.extern.slf4j.Slf4j;
import org.example.learnsys.pojo.Emp;
import org.example.learnsys.pojo.Result;
import org.example.learnsys.server.imp.LoginServerImp;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
public class LoginColltroller {
    @Autowired
    private LoginServerImp loginServerImp;
    @PostMapping("/login")
    public Result login(@RequestBody Emp emp){
        Emp a =  loginServerImp.LoginCheck(emp);
        return a !=null? Result.success():Result.error("用户名或密码错误");


    }
}

xxxxxxxxxx
//server
package org.example.learnsys.server.imp;

import org.example.learnsys.mapper.LoginMapper;
import org.example.learnsys.pojo.Emp;
import org.example.learnsys.server.LoginServer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LoginServerImp implements LoginServer {
    @Autowired
    private LoginMapper loginMapper;
    @Override
    public Emp LoginCheck(Emp emp) {
        return loginMapper.loginCount(emp);
    }
}