JavaWeb学习——黑马程序员
编辑时间：2023/10/27
来源：黑马程序员
web开发
前端：HTML 、CSS 、JavaScript、 Vue 、Element 、Nginx
后端：Maven SpringBoot 、MySql 、SpringBoot Mybatis、 SpringBoot Web
web前端开发
HTML
JS
Vue
Ajax
1.Ajax概念
Asynchronous JavaScript And XML ，异步的JavaScript和XML
作用：
数据交换：通过ajax可以给ie服务器发生请求，并且过去服务器响应的数据
异步交互：可以给不加载的整个页面的情况下，与服务器交换数据并且更新部分网页的技术，如：搜索联想，用户名是否可以校验等。
2.同步异步交互概念
3.原生的Ajax
打开开发者工具快捷键：F12
XHR框：查看所有异步请求
Axios入门
Axios请求方式别名
前端工程化
前端工程化-环境准备
1.前后端混合开发
2.前后端分离开发
3.YApi 生成接口
添加项目——>添加分类——>添加接口
4.实际的前端工程开发
模块化（js css)
组件化（UI结构 样式 行为）
规范化（目录结构 编码 接口）
自动化（构建 部署 测试）
5.前端工程化
环境准备
vue-cil
- 介绍：Vue-cil是Vue官方提供的一个脚手架，用于快速生成一个Vue项目模板。
- Vue-cil提供了如下的功能：
统一的目录结构
本地测试
热部署
单元测试
基础打包上线 - 依赖环境：NodeJS
vue
1.vue项目创建
2.vue目录结构
3.vue项目启动
终端：npm run server
或者在package json文件里运行
注意:vue 端口号修改处 vue.config.js
4.vue项目开发流程
Element
Vue路由
打包部署
前端vue文件打包
1.所部署的服务器nginx
2.若nginx双击没有反应：
打开任务管理器（快捷键ctrl+shift+esc）
cmd命令查看占用端口的资源
netstat -ano | findStr 80
3.改nginx端口号
4.查看任务管理器是否启用进程
5.输入网址 localhost:端口号
成功部署如下。
Maven
1.maven介绍
maven是apache旗下的一个开源的项目，是管理构建Java的工具。
apache软件基金会是目前世界上最大最受欢迎的开源软件基金会，也是一个专门为支持开源软件而生的非营利性组织，访问apache网址：
https://www.apache.org/index.html#projects-list
2.maven 的作用
作用一：依赖管理：方便快捷的管理项目依赖的资源（jar包）避免冲突问题。
依赖设置
在建立好maven模块的pom.xml文件建立依赖
<dependencies>
<dependency>
<!-- <groupId>包</groupId>-->
<!-- <artifactId>项目</artifactId>-->
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.4</version>
</dependency>
</dependencies>
作用二：统一的项目结构：统一项目结构，提供标准。
项目构建：标准化平台的自动化项目的构建方式。
编译：运行maven面板的compile生成target文件
打包：运行maven面板的package生成target文件
3.maven的概述
中央仓库地址：https://repo1.maven.org/maven2/
pom.xml里的maven坐标
<groupId>org.example</groupId>
<artifactId>untitled</artifactId>
<version>1.0-SNAPSHOT</version>
4.maven安装
地址：https://maven.apache.org/download.cgi
阿里云
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>certral</mirrorOf>
</mirror>
</mirrors>
5.maven安装检测
cmd 输入mvn -v
6.配置maven环境（当前工程）
7.配置maven环境（全局环境）
file–close project–
生成的包结构
8.Maven坐标
9.导入Maven项目
移除maven文件
注意：磁盘里面没有删除。
10.依赖管理
<dependencies>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>
</dependencies>
11依赖传递
图表显示依赖关系
12解除依赖
13依赖范围
打包插件
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.4.1</version>
<configuration>
<descriptorRefs><descriptorRef>jar-with-dependencies</descriptorRef></descriptorRefs>
</configuration>
<executions>
<execution>
<id>make-assembly</id><phase>package</phase>
<goals><goal>single</goal></goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
打包好的jar包在target文件夹
14生命周期
操作方式1
测试依赖
<!-- 依赖配置-->
<dependencies>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.10</version>
<!-- <scope>test</scope>-->
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
测试代码：
package com.itheima.test;
import org.junit.Test;
public class DemoTest {
@Test
public void test1(){
System.out.println("T1");
}
@Test
public void test2(){
System.out.println("T2");
}
@Test
public void test3(){
System.out.println("T3");
}
}
测试效果图
maven面板的操作：
如果要过test执行后面的操作，添加小闪片：
操作方式2
在所在的cmd窗口执行mvn命令
小结
web后端开发
0.spring入门
官网：spring.io
Spring发展到现在已经形成了一种开发生态圈，Spring提供了若干子项目，每个项目用于完成特定的功能。
Spring Boot：帮助我们快速的构建开发框架，简化开发，提高效率。
01SpringBootWeb入门
需求：使用SpringBoot开发一个web应用，浏览器发起请求之后/hrllo后，给浏览器返回“HelloWord”
步骤
需要联网下载
留下需要的文件
如果找不到插件，加入版本号这一行如：
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.7.4</version>
</plugin>
</plugins>
</build>
创建的请求类
package com.itheima.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
//请求处理类
@RestController
public class HelloController {
@RequestMapping("/hello")
public String hello(){
System.out.println("Hello World~");
return "Hello World~";
}
}
查看日志是8080端口
浏览器：
控制台：
02HTTP协议概述
HTTP
概念：Hyper Test Transfer Protocol ,超文本概述规定了浏览器和服务器之间数据传输的规则。
特点：
- 基于TCP协议：面向连接ei，安全
- 基于请求-响应模型的：一次请求对应一次响应
- HTTP协议是无状态的协议：对于事物处理没有记忆能力。每次请求-响应都是独立的。
缺点：多次请求间不能共享数据
优点：速度快
03HTTP请求协议
04HTTP响应协议
05HTTP-协议解析
06Tomcat介绍
Tomcat简介
- Tomcat是Apache软件基金会的一个核心的项目，是一个开源免费的轻量级Web服务器，支持Servlet /JSP邵亮javaEE规范。
- Java EE：Java Enterprise Edition ,java企业版，和Java企业级开发的技术规范总和。包含13项技术规范：JDBC JNDI EJB RMI JSP Serverlet XML JavaIDL JTS JTA JavaMail JAF
- Tomcat也称为web容器 Servlet容器 Servlet程序需要依赖Tomcat才能运行
- 官网：https://tomcat.apachee.org
javase:java标准版
javame：Java小型版
javaee:java企业版
小结
web服务器 - 对HTTP协议操作进程封装，简化web程序开发
- 部署web项目，对外提供网上信息浏览
Tomcat - 一个轻量级的web服务器，支持servlet，jsp等少量javaee规范
- 也被称为web容器，servlet容器
07Tomcat基本使用
安装-卸载-启动（bin/startup.bat）-终止(bin/shutdown.bat)-部署(应用复制到webapps目录)
下载：https://tomcat.apache.org/download-90.cgi
08SpringBootWeb-入门解析
可以知道我们多使用的是内勤啊的tomcat，外部tomcat一般很少使用
https://start.spring.io/
知识总结
1.起步依赖
- spring-boot-starter-web
- spring-boot-starter-test
2.内嵌tomcat服务器 - 基于springboot并发的web应用程序，内置了tomcat服务器，当启动类运行时，会自动启动内嵌的tomcat服务器
请求响应
0请求响应概述
1请求postman工具
前后端分离开发
Postman
postman是一款跟强大的我也测试与发送网页HTTP请求的Chrome插件
作用：常用于接口测试
2 简单参数和实体
简单参数
原始方式：在原始的web程序中，获取请求参数，需要通过HttpServletRequest对象手动获取
在main的java包里创建RequestController类
package com.itheima.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
//测试请求参数接收
@RestController
public class RequestController {
// 原始方式
@RequestMapping("/simpleParam")
public String simpleParam(HttpServletRequest request){
// 获取请求参数
String name=request.getParameter("name");
String ageStr=request.getParameter("age");
int age=Integer.parseInt(ageStr);
System.out.println(name+":"+age);
return "OK";
}
}
启动它的springboot类，在postman里面建立get请求，效果如图
springboot方式
package com.itheima.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
//测试请求参数接收
@RestController
public class RequestController {
// 原始方式
// @RequestMapping("/simpleParam")
// public String simpleParam(HttpServletRequest request){
获取请求参数
// String name=request.getParameter("name");
// String ageStr=request.getParameter("age");
// int age=Integer.parseInt(ageStr);
// System.out.println(name+":"+age);
// return "OK";
// }
//
//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(String name,Integer age){
// 获取请求参数
System.out.println(name+":"+age);
return "OK";
}
}
当参数对应不上，返回内容，不会报错，返回为null
参数不一致解决方案
package com.itheima.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
//测试请求参数接收
@RestController
public class RequestController {
// 原始方式
// @RequestMapping("/simpleParam")
// public String simpleParam(HttpServletRequest request){
获取请求参数
// String name=request.getParameter("name");
// String ageStr=request.getParameter("age");
// int age=Integer.parseInt(ageStr);
// System.out.println(name+":"+age);
// return "OK";
// }
//
//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name="name",required=false) String u, Integer age){
// 获取请求参数
System.out.println(u+":"+age);
return "OK";
}
}
小结
- 原始方式
Controller方法形参中声明HttpServletRequest对象
调用对象的getParameter（参数名） - SpringBoot中接收简单参数
请求参数名与方法形参变量名相同
会自动进行类型转换 - @RequestParam注解
方法形参名称与请求参数名称不匹配，通过该注解完成映射
该注解的required属性默认是true，代表请求参数必须传值
实体参数
简单实体对象：请求参数名与形参对象属性名相同，定义POJO接收即可
如下：
package com.itheima.controller;
import com.itheima.pojo.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
//测试请求参数接收
@RestController
public class RequestController {
// 原始方式
// @RequestMapping("/simpleParam")
// public String simpleParam(HttpServletRequest request){
获取请求参数
// String name=request.getParameter("name");
// String ageStr=request.getParameter("age");
// int age=Integer.parseInt(ageStr);
// System.out.println(name+":"+age);
// return "OK";
// }
//
//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name="name") String u, Integer age){
// 获取请求参数
System.out.println(u+":"+age);
return "OK";
}
//实体参数
@RequestMapping("/simplePojo")
public String simplePojo(User user){
System.out.println(user);
return "OR";
}
}
package com.itheima.pojo;
public class User {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public String toString(){
return "User{"+
"anme='"+name+'\''+
",age="+age+
';';
}
public void setAge(Integer age) {
this.age = age;
}
}
package com.itheima.controller;
import com.itheima.pojo.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
//测试请求参数接收
@RestController
public class RequestController {
// 原始方式
// @RequestMapping("/simpleParam")
// public String simpleParam(HttpServletRequest request){
获取请求参数
// String name=request.getParameter("name");
// String ageStr=request.getParameter("age");
// int age=Integer.parseInt(ageStr);
// System.out.println(name+":"+age);
// return "OK";
// }
//
//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name="name") String u, Integer age){
// 获取请求参数
System.out.println(u+":"+age);
return "OK";
}
//实体参数
@RequestMapping("/simplePojo")
public String simplePojo(User user){
System.out.println(user);
return "OR";
}
//实体参数
@RequestMapping("/complexPojo")
public String complexPojo(User user){
System.out.println(user);
return "OR";
}
}
package com.itheima.pojo;
public class User {
private String name;
private Integer age;
private Address address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", address=" + address +
'}';
}
}
package com.itheima.pojo;
public class Address {
private String province;
private String city;
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
@Override
public String toString() {
return "Address{" +
"province='" + province + '\'' +
", city='" + city + '\'' +
'}';
}
}
小结
实体参数：请求参数名与形参对象属性名相同，即可直接通过POJO接收
3数组集合参数
element官网：https://element.eleme.cn/#/zh-CN/component/installation
数组参数封装
package com.itheima.controller;
import com.itheima.pojo.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
//测试请求参数接收
@RestController
public class RequestController {
// 原始方式
// @RequestMapping("/simpleParam")
// public String simpleParam(HttpServletRequest request){
获取请求参数
// String name=request.getParameter("name");
// String ageStr=request.getParameter("age");
// int age=Integer.parseInt(ageStr);
// System.out.println(name+":"+age);
// return "OK";
// }
//
//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name="name") String u, Integer age){
// 获取请求参数
System.out.println(u+":"+age);
return "OK";
}
//实体参数
@RequestMapping("/simplePojo")
public String simplePojo(User user){
System.out.println(user);
return "OR";
}
//实体参数
@RequestMapping("/complexPojo")
public String complexPojo(User user){
System.out.println(user);
return "OR";
}
//数组参数
@RequestMapping("/arrayParam")
public String arrayParam(String[] hobby){
System.out.println(Arrays.toString(hobby));
return "OR";
}
}
集合参数封装
package com.itheima.controller;
import com.itheima.pojo.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.List;
//测试请求参数接收
@RestController
public class RequestController {
// 原始方式
// @RequestMapping("/simpleParam")
// public String simpleParam(HttpServletRequest request){
获取请求参数
// String name=request.getParameter("name");
// String ageStr=request.getParameter("age");
// int age=Integer.parseInt(ageStr);
// System.out.println(name+":"+age);
// return "OK";
// }
//
//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name="name") String u, Integer age){
// 获取请求参数
System.out.println(u+":"+age);
return "OK";
}
//实体参数
@RequestMapping("/simplePojo")
public String simplePojo(User user){
System.out.println(user);
return "OR";
}
//实体参数
@RequestMapping("/complexPojo")
public String complexPojo(User user){
System.out.println(user);
return "OR";
}
//数组参数
@RequestMapping("/arrayParam")
public String arrayParam(String[] hobby){
System.out.println(Arrays.toString(hobby));
return "OR";
}
//集合参数
@RequestMapping("/listParam")
public String listParam(@RequestParam List<String> hobby){
System.out.println(hobby);
return "OR";
}
}
小结
数组：请求参数名与形参中数组变量名相同，可以直接使用数组封装
集合：请求参数名与形参中集合变量名相同，可以通过@RequestParam绑定参数关系
日期参数
package com.itheima.controller;
import com.itheima.pojo.User;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
//测试请求参数接收
@RestController
public class RequestController {
// 原始方式
// @RequestMapping("/simpleParam")
// public String simpleParam(HttpServletRequest request){
获取请求参数
// String name=request.getParameter("name");
// String ageStr=request.getParameter("age");
// int age=Integer.parseInt(ageStr);
// System.out.println(name+":"+age);
// return "OK";
// }
//
//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name="name") String u, Integer age){
// 获取请求参数
System.out.println(u+":"+age);
return "OK";
}
//实体参数
@RequestMapping("/simplePojo")
public String simplePojo(User user){
System.out.println(user);
return "OR";
}
//实体参数
@RequestMapping("/complexPojo")
public String complexPojo(User user){
System.out.println(user);
return "OR";
}
//数组参数
@RequestMapping("/arrayParam")
public String arrayParam(String[] hobby){
System.out.println(Arrays.toString(hobby));
return "OR";
}
//集合参数
@RequestMapping("/listParam")
public String listParam(@RequestParam List<String> hobby){
System.out.println(hobby);
return "OR";
}
//时间参数
@RequestMapping("/dateParam")
public String dateParam(@DateTimeFormat(pattern ="yyyy-MM-dd HH:mm:ss") LocalDateTime updateTime){
System.out.println(updateTime);
return "Ok";
}
}
Json参数
package com.itheima.controller;
import com.itheima.pojo.User;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
//测试请求参数接收
@RestController
public class RequestController {
// 原始方式
// @RequestMapping("/simpleParam")
// public String simpleParam(HttpServletRequest request){
获取请求参数
// String name=request.getParameter("name");
// String ageStr=request.getParameter("age");
// int age=Integer.parseInt(ageStr);
// System.out.println(name+":"+age);
// return "OK";
// }
//
//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name="name") String u, Integer age){
// 获取请求参数
System.out.println(u+":"+age);
return "OK";
}
//实体参数
@RequestMapping("/simplePojo")
public String simplePojo(User user){
System.out.println(user);
return "OR";
}
//实体参数
@RequestMapping("/complexPojo")
public String complexPojo(User user){
System.out.println(user);
return "OR";
}
//数组参数
@RequestMapping("/arrayParam")
public String arrayParam(String[] hobby){
System.out.println(Arrays.toString(hobby));
return "OR";
}
//集合参数
@RequestMapping("/listParam")
public String listParam(@RequestParam List<String> hobby){
System.out.println(hobby);
return "OR";
}
//时间参数
@RequestMapping("/dateParam")
public String dateParam(@DateTimeFormat(pattern ="yyyy-MM-dd HH:mm:ss") LocalDateTime updateTime){
System.out.println(updateTime);
return "Ok";
}
//json参数
@RequestMapping("/jsonParam")
public String jsonParam(@RequestBody User user){
System.out.println(user);
return "Ok";
}
}
package com.itheima.pojo;
public class User {
private String name;
private Integer age;
private Address address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", address=" + address +
'}';
}
}
package com.itheima.pojo;
public class Address {
private String province;
private String city;
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
@Override
public String toString() {
return "Address{" +
"province='" + province + '\'' +
", city='" + city + '\'' +
'}';
}
}
路径参数
单个路径参数
package com.itheima.controller;
import com.itheima.pojo.User;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
//测试请求参数接收
@RestController
public class RequestController {
// 原始方式
// @RequestMapping("/simpleParam")
// public String simpleParam(HttpServletRequest request){
获取请求参数
// String name=request.getParameter("name");
// String ageStr=request.getParameter("age");
// int age=Integer.parseInt(ageStr);
// System.out.println(name+":"+age);
// return "OK";
// }
//
//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name="name") String u, Integer age){
// 获取请求参数
System.out.println(u+":"+age);
return "OK";
}
//实体参数
@RequestMapping("/simplePojo")
public String simplePojo(User user){
System.out.println(user);
return "OR";
}
//实体参数
@RequestMapping("/complexPojo")
public String complexPojo(User user){
System.out.println(user);
return "OR";
}
//数组参数
@RequestMapping("/arrayParam")
public String arrayParam(String[] hobby){
System.out.println(Arrays.toString(hobby));
return "OR";
}
//集合参数
@RequestMapping("/listParam")
public String listParam(@RequestParam List<String> hobby){
System.out.println(hobby);
return "OR";
}
//时间参数
@RequestMapping("/dateParam")
public String dateParam(@DateTimeFormat(pattern ="yyyy-MM-dd HH:mm:ss") LocalDateTime updateTime){
System.out.println(updateTime);
return "Ok";
}
//json参数
@RequestMapping("/jsonParam")
public String jsonParam(@RequestBody User user){
System.out.println(user);
return "Ok";
}
//path参数
@RequestMapping("/path/{id}")
public String pathParam(@PathVariable Integer id){
System.out.println(id);
return "Ok";
}
}
多个路径参数
package com.itheima.controller;
import com.itheima.pojo.User;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
//测试请求参数接收
@RestController
public class RequestController {
// 原始方式
// @RequestMapping("/simpleParam")
// public String simpleParam(HttpServletRequest request){
获取请求参数
// String name=request.getParameter("name");
// String ageStr=request.getParameter("age");
// int age=Integer.parseInt(ageStr);
// System.out.println(name+":"+age);
// return "OK";
// }
//
//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name="name") String u, Integer age){
// 获取请求参数
System.out.println(u+":"+age);
return "OK";
}
//实体参数
@RequestMapping("/simplePojo")
public String simplePojo(User user){
System.out.println(user);
return "OR";
}
//实体参数
@RequestMapping("/complexPojo")
public String complexPojo(User user){
System.out.println(user);
return "OR";
}
//数组参数
@RequestMapping("/arrayParam")
public String arrayParam(String[] hobby){
System.out.println(Arrays.toString(hobby));
return "OR";
}
//集合参数
@RequestMapping("/listParam")
public String listParam(@RequestParam List<String> hobby){
System.out.println(hobby);
return "OR";
}
//时间参数
@RequestMapping("/dateParam")
public String dateParam(@DateTimeFormat(pattern ="yyyy-MM-dd HH:mm:ss") LocalDateTime updateTime){
System.out.println(updateTime);
return "Ok";
}
//json参数
@RequestMapping("/jsonParam")
public String jsonParam(@RequestBody User user){
System.out.println(user);
return "Ok";
}
//path参数
@RequestMapping("/path/{id}")
public String pathParam(@PathVariable Integer id){
System.out.println(id);
return "Ok";
}
// more path
@RequestMapping("/path/{id}/{name}")
public String pathParam2(@PathVariable Integer id,@PathVariable String name){
System.out.println(id);
System.out.println(name);
return "Ok";
}
}
总结
- 简单参数
定义方法形参 秦秋参数名与形参变量名一致
如果不一致，通过@RequestParam手动映射 - 实体参数
请求参数名，与实体对象的属性名一致，会自动接收封装 - 数组集合参数
数组：请求参数名与数组名一致，直接封装
集合：请求参数名与集合名一致，@RequestParam绑定关系 - 日期参数
@DataTimeFormat - JSON参数
@RequestBody - 路径参数
@PathVariable
Response&统一响应结果
小结
- @ResponseBody
位置：Controller类上/方法上
作用：将方法返回值直接响应，若返回值类型是实体对象/集合，转JSON格式响应 - 统一响应结果
Result（code，msg，data）
响应案例
三层架构
三层架构概念
contorller:控制层，接受前端发送的请求，对请求进行处理，并响应数据
service:业务逻辑层，处理具体的业务逻辑
dao:数据访问层（Data Access Object）（持久层），负责数据访问操作，包括数据的增删改查
分层解耦
内聚：软件中各个功能模块内部的功能联系。
耦合：衡量软件中各个层/模块之间的依赖，关联的程度
软件设计原则：高内聚低耦合
IOC&DI入门
IOC详解
元注解：注解的注解
小结
声明bean的注解
- @Component ，@Controller，@Service，@Repository
- @SpringBootApplication具有包的扫描作用，默认扫描当前及其子包
DI详解
小结
依赖注入的注解
- @Autowired：莫问按照类型自动装配
- 如果是同类型的bean存在多个：
1.@Primary
2.@Autowired+@Qualifier(“bean的名称”)
3.@Resource(name="bean的名称’’
@Resource与@Autowired的区别
- @Autowired是spring框架提供的注解，而@Resource是JDK提供的注解
- @Autowired默认是按照类型注入，而@Resource默认是按照名称注入
Mysql
mysql课程介绍
什么是数据库？
数据库：DataBase（DB），是存储和管理数据的仓库
数据库管理系统：DataBase Management System（DBMS），操纵和管理数据库的大型软件。
SQL:Structured Query Language ，操作关系型数据库的编程语言，定义了一套操作关系型数据库统一标准。
**数据库产品 **
课程安排
Mysql概述_安装
MySQL安装
其他相关信息联系：
mysql企业开发使用方式
可以用VMwere虚拟软件虚拟服务器
dos窗口：
mysql -u用户名 -p密码 [ -h数据库服务器地址 -p端口号]
例子：
数据模型&SQL简介
M有SQL数据模型
关系型数据库RDMS：建立在关系模型基础上，有多张相互连接的二维表组成的数据库。
特点：
- 使用表存储数据，格式统一，便于维护
- 使用SQL语言操作，标准统一，可用于复杂查询
SQL简介
SQL：一门操作关系数据库的编程语言，定义操作所有关系型数据库的统一标准。
SQL分类
小结
DDL-数据库操作
DDL
DDL-图形化操作
MySQL客户端工具
MySQL客户端工具有：SQLyog Navicat DataGrip 等
DataGrip
介绍：DataGrip是jetBrains旗下的一款数据仓库管理工具，是管理和开发MySQL，Oracle，PostgreSQL的理想解决方案
官网：https://www.jetbrains.com/zh-cn/datagrip/
安装：参考资料中提供的《DataGrip安装手册》
tips
步骤
解压——创建项目——下载驱动——测试链接——展现所有的数据库
查询之前的控制台
DDL-表结构操作-创建
-- 注释
show databases ;
-- 创建数据库
create database db02;
use db02;
create table tb_user_1(
id int primary key comment'ID 唯一标识',
username varchar(20) not null comment '用户名',
name varchar(10) comment'姓名',
age int comment '年龄',
gender char(1) default '男' comment '姓名'
)comment '用户表';
DDL-表结构操作-数据类型
MySQL数据类型：
主要分为三类,数据类型，字符串类型，日期时间类型。
DDL-表结构操作-案例
DDL-表结构-查询修改删除
知识回顾
DML-添加数据insert
DML
DML英文全称Data Manipulation Language（数据操作语言），用来对数据仓库中的表的数据记录进行增删改操作
添加数据 INSERT
注意事项：
DML-修改数据update
DML-删除数据delete
知识回顾
DQL-基本查询
DQL
- DQL英文全称Data Query Language （数据查询语言），用来查询数据库表中的记录
- 关键字：SELECT
基本查询
DQL-条件查询
DQL-聚合函数
DQL-分组查询
DQL-排序查询
DQL-分页查询
DQL-案例
案例1
select *from the_emp where name likre '%张%' and gender=1 and entrydate between '2000-01-01' and '2015-12-31' order by update_time desc limit 0,10;
案例2
注意：导入Apache ECharts组件库显示报表多元分析统计
Apache Echarts组件库的连接：https://echarts.apache.org/zh/index.html
-- 案例1 根据需求，完成员工性别信息的统计 -count（*）
-- if（条件表达式，true取值，false取值）
select if(gender=1,'男性员工','女性员工') 性别,count(*) from tb_emp group by gender;
-- 案例2 根据需求，王超员工职位的信息统计
-- case 表达式 when 值1 then 结果1 when 值2 then 结果2... else ... end
select (case job when 1 then '班主任' when 2 then '讲师' when 3 then '学工主管' when 4 then '校验主管' else '未分配职位' end ) 职位 job,count(*) from tb_emp group by job;
知识回顾
多表设计-一对多
外键约束
多表设计-一对一&多对多
一对一
多对多
多表设计-案例-关系分析
多表设计-案例-表结构
多表查询-概述
多表查询：指从多张表中查询数据
笛卡尔积：笛卡尔乘积就是指在数学中，两个集合（A集合和B集合）的所有组合情况
分类
连接查询
内连接：相当于查询A、B交集的部分数据
外连接：
1.左外连接：查询左表所有的数据（包括两张表的交集部分数据）
2.右外连接：查询右表所有数据（包括两张表交集部分数据）
子查询
多表查询-内连接
内连接
隐式内连接
select 字段列表 from 表1,表2 where 条件...;
显示内连接
select 字段列表 from 表1 [inner] join 表2 on 连接条件;
例子：
多表查询-外连接
外连接
左外连接
select 字段列表 from 表1 left [outer] join 表2 on 链接条件...;
右外连接
select 字段列表 from 表1 right [outer] join 表2 on 连接条件...;
例子
多表查询-子查询1
概述：
- 介绍：SQL中嵌套select语句，称为嵌套语句，又称子查询。
- 形式：
select *from t1 where column1=（select column1）from t2...)
- 子查询外部的语句可以是insert/update/delete/select 的任何一个，最常见的是select
子查询分类
变量子查询：子查询返回的结果为单个值
列子查询：子查询返回的结果为一列
行子查询：子查询返回的结果为一行
表子查询：子查询返回结果为多行多列
标量子查询
- 子查询返回的结果是单个值（数字、字符串、日期等），最简单的形式
- 常用的条件 ：= > >= <> <=
例子
列子查询
- 子查询返回的结果是一列（可以是多行）
- 常用的 ：in 、not in等
例子
多表查询-子查询2
行子查询
- 子查询返回的结果为一行（可以是多列）
- 常用的操作符：=、<>、in、not in
例子
表子查询
- 子查询返回的结果是多行多列，常作为临时表
- 常用的操作符为in
例子
多表查询-案例1
-- 查询价格低于元的菜品名称，价格机器菜品的分类名称
-- 表：dish category
-- SQL:
select d.name ,d.price,c.name
from dish d,category c
where d.category_id=c.id and d.price <10;
--2.查询所有价格在10元到50员之间且状态为‘起售’的彩屏，展示出彩屏的名称，价格及其菜品的分类名称（及时菜品没有恩磊，也需要将菜品查询出来）
-- 表：dish category
-- SQL:
select d.name,d.price,c.name
from dish d
left join category c on d.category_id=c.id
where d.price between 10 and 50 and d.status =1;
--3.查询每个分类喜爱最贵的菜品，显示分类的名称，最贵的菜品的价格
-- table:dish category
-- SQL：
select c.name,max(d.price)
from dish d,category c
where d.category_id=c.id
group by c.name
-- 4.查询个分类下菜品的状态为起售，并且该分类下菜品的总数量大于等于3分类的名称
--table：dish category
--SQL:
select c.name,count(*)
from dish d,category c
where d.category_id=c.id and d.state=1
group by c.name having count(*) >=3;
--5.查询出商务套餐A 中包含了哪些菜品（展示出套餐名称，价格，包含的菜品名称，价格，份数）
--table：setmeal setmeal dish ，dish
--SQL：
select s.name,s.price,d.name,d.price,sd.copies
from setmeal s，setmeal_dish sd，dish d
where s.id=sd.setmeal_id
and sd.dish_id=d.id
and s.name='商务套餐A';
--6.查询出低于菜品平均价格的菜品信息（展示出菜品名称，菜品价格）
--table:dish
--SQL:
select *from dish where price < (select avg(price) from dish);
事务-介绍与操作
介绍
概念：事务是一组操作的集合，它是一个不可分割的工作单位。事务会把所有的操作作为一个整体一起向系统提交撤销操作请求，即这些操作要么同时成功，要么同时失败。
注意
默认MySQL的事务是自动提交的，也就是说，当执行一条DML语句，MySQL会立即隐式的提交事务。
事务控制
- 开启事务：start transaction ;/begin
- 提交事务：commit;
- 回滚事务：rollback
例子
-- 开启事务
start transaction;
--删除部门
delete from tb_dept where id=3;
delete from tb_emp where dept_id=3;
-- 提交事务：commit;
commit;
-- 回滚事务：rollback
rollback;
事务-四大特性（ACID）
- 原子性（Atomicity）：事务是不可分割的最小单元，要么全部成功，要么全部失败
- 一致性（Consistency）：事务完成时，必须使所有数据都保持一致状态
- 隔离性 （Isolation）：数据库系统提供的隔离机制，保证事务在不受外部并发操作影响的独立环境下运行。
- 持久性（Durability）：事务一旦提交或回滚，它对数据库中的数据改变是永久的
索引-介绍
概念
索引（index）是帮助数据库高效获取数据的数据结构。
优缺点
优点：
- 提高数据处查询的效率，降低数据库的IO成本
- 通过索引列对数据进行排序、降低数据排序的成本，降低CPU 的消耗
缺点:
- 索引会占用存储空间
- 索引会大大提高查询效率，同时却也降低了insert、update、delete等效率
索引-结构
MySQL数据库中默认的索引结构是B+tree
索引-操作语法
语法
例子
Mybatis
入门课程介绍
- Mybatis是一款优秀的持久层框架，用于简化JDBC的开发
- Mybatis本事Apache的一个开源的项目iBatis，2010这个项目由apache迁移到google code，改名为Mybatis，2013年11月迁移到Github
- 官网：https://mybatis.org/mybatis-3/zh/index.html
快速入门程序
步骤：使用Mybatis查询所有用户数据
步骤
认识数据库的一些参数
创建工程
导入依赖认识
生成pojo.User.java
在resource文件夹下的application.properties链接数据库
#配置数据库的连接信息——四要素
#驱动类名称
Spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#连接数据库的url
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis
#链接数据库的用户名
spring.datasource.username=root
#链接数据库的密码
spring.datasource.password=123456
创建Mapper接口包装语句
package com.itheima.mapper;
import com.itheima.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;
public interface UserMapper {
@Mapper //在运行时，会自动生成该接口的实现类对象（代理对象），并且将该对象交给IOC容器管理
//查询全部用户信息
@Select("select * from user;")
public List<User> list();
}
测试类
package com.itheima;
import com.itheima.mapper.UserMapper;
import com.itheima.pojo.User;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
//@RunWith(SpringRunner.class)
@SpringBootTest //Springboot整合单位测试的注解
public class SpringbootMybatisQuickstart02ApplicationTests {
@Autowired(required = false)
//@Resource
private UserMapper userMapper;
@Test
public void testListUser() {
List<User> userList=userMapper.list();
userList.stream().forEach(user ->{
System.out.println(user);
});
}
}
回顾
配置SQL提示
显示上下文——注入语言设置——mysql
JDBC
JDBC:(java DataBase Connectiity)，就是使用Java语言操作关系型数据库的一套API。
本质
- sun公司官方定义的一套操作所有关系型数据库的规范，即接口
- 各个数据库厂商去实现这套接口，提供数据库驱动jar包
- 我们可以使用这套接口（JDBC）编程，真正执行代码是驱动jar包中的实现类
例子
jdbc程序
jdbc和mybatis
mybatis
数据库连接池
切换连接池
小结
数据库连接池
- 是一个容器，负责分配、管理数据库链接（Connection）
- 优势：资源复用，提升系统响应程度
- 接口：DataSource
- 产品：C3P0,DBCP,Druid、Hikari
lombok工具包介绍
lombok依赖
<!-- lombok-->
<dependency>
<groupId>org.prjectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
lombok依赖后，可以用依赖注入解决get/set hashcode equal方法
//@Getter
//@Setter
//@ToString
//@EqualsAndHashCode
//可以归结为@Data
@Data //getset hashcode equals方法
@NoArgsConstructor
@AllArgsConstructor
基础操作-环境准备
1758
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
