在未更新的期间，我已经学习完了javaweb以及部分ssm框架，并且完成了redis点评的项目实战，同时运用已经学习的知识对该项目实战业务进行了优化提升，在接下来的几天我会将期间完成的笔记全部发布。
由于我之前已经单独学过HTML+CSS+JS，故直接从vue开始，当然有部分遗忘的知识我在下方直接加上了。
一、遗忘部分
1、js和json转换
// js 对象——>json 字符串
// 通过JSON.stringify(js 对象)
const person = {
name: 'zhangsan',
age: 19,
gender: '男'
}
const personjson = JSON.stringify(person)
// json 字符串——>js 对象
// 通过JSON.parse(json 字符串)
const jsontest = '{
"name": "lisi",
"age": 20,
"gender": "女"
}'
const jstest = JSON.parse(jsontest)
2、js引入js
// 使用import导入
import { printlog } from "这个printlog的路径" ；
// 使用export导出
export function printlog (content) {
console.log(content) ；
}
二、Vue快速入门
Vue是一款用于构建用户界面的渐进式的JS框架（生态）。
1、基础结构
<body>
<!-- Vue 应用的挂载点 -->
<div id="app">
<!-- 双大括号语法：Vue 的模板插值，会显示 data 中的 message 值 -->
<h1>{{message}}</h1>
<h1>{{age}}</h1>
</div>
<!-- 使用 type="module" 表示这是一个 ES6 模块 -->
<script type="module">
// 从 CDN 导入 Vue 的 createApp 函数
// 'vue.esm-browser.js' 是专门用于浏览器的 ES 模块版本
import { createApp } from 'https://unpkg.com/vue@3/dist/vue.esm-browser.js'
// 创建 Vue 应用实例
createApp({
// data 选项：返回一个对象，包含应用的状态数据
data() {
return {
message: 'hello vue',// 定义 message 数据属性
age: 18
}
}
}).mount('#app') // 将应用挂载到 id="app" 的 DOM 元素上
</script>
</body>
2、常用指令
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
<style>
table {
text-align: center;
margin: 100px auto;
width: 500px;
border: 1px solid black;
/* 合并边框 */
border-collapse: collapse;
}
th {
background-color: #b4b2b2;
}
th,
td {
height: 40px;
width: 100px;
border: 1px solid black;
}
</style>
</head>
<body>
<div id="app">
<table>
<caption>学生列表</caption>
<tr>
<th>序号</th>
<th>姓名</th>
<th>年龄</th>
<th>性别</th>
<th>家乡</th>
</tr>
<!-- 形式为 v-for = "(当前数组的一个对象 , index) in 你的数组" :key = "你要以什么为唯一标识" -->
<tr v-for="(e , index) in arr" :key="e.id">
<td>{{index + 1}}</td>
<td>{{e.name}}</td>
<td>{{e.age}}</td>
<td>{{e.gender === 1 ? '男' : '女'}}</td>
<td>{{e.address}}</td>
</tr>
</table>
</div>
<script type="module">
import { createApp } from 'https://unpkg.com/vue@3/dist/vue.esm-browser.js'
createApp({
data() {
return {
arr: [
{ id: 1, name: '小米', age: 18, gender: 1, address: '广东省' },
{ id: 2, name: '小敏', age: 19, gender: 0, address: '广西省' },
{ id: 3, name: '小莫', age: 20, gender: 1, address: '山东省' },
{ id: 4, name: '小哈', age: 21, gender: 0, address: '江西省' },
{ id: 5, name: '小黎', age: 22, gender: 1, address: '浙江省' }
]
}
}
}).mount('#app')
</script>
</body>
</html>
期间还涉及部分vue和Ajax的知识，在此就不多赘述
三、springbootweb入门
如果遇到连接超时，即spring boot的官网连接不上的情况，可将spring boot官网的地址改为国内阿里云的地址
使用spring boot脚手架生成会默认引入两个起步依赖：spring-boot-starter-web（web应用开发）和spring-boot-starter-test（单元测试）
1、HTTP协议
HTTP协议，全称为超文本传输协议（HyperText Transfer Protocol），是互联网上应用最为广泛的一种网络传输协议。它定义了客户端（如浏览器）与服务器之间如何通信，用于传输网页、图片、视频、API数据等资源。即http协议定义客户端和服务器之间交流规则。
| 特性 | 描述 |
|---|---|
| 无状态 | 每次请求独立，服务器默认不保存客户端状态（通过Cookie/Session弥补） |
| 基于TCP | 默认端口80，HTTPS为443 |
| 请求/响应模型 | 客户端发起请求，服务器返回响应 |
| 灵活可扩展 | 支持多种数据格式（HTML、JSON、图片等），通过头部字段扩展功能 |
1.1、请求协议
// 1、请求行（方法+资源路径+http协议版本）
GET /index.html HTTP/1.1
// 2、请求头部分
Host: www.example.com
User-Agent: Mozilla/5.0
Accept: text/html
// 在请求头和请求体之间有一行空行
// 3、请求体部分
{"id":1,"name":"zs"}
-
方法（Method）：GET、POST、PUT、DELETE、HEAD、OPTIONS、PATCH等
| 方法 | 用途 | 是否含体 | 幂等性 |
|---|---|---|---|
| GET | 获取资源 | 否 | 是 |
| POST | 提交数据（如表单） | 是 | 否 |
| PUT | 替换资源 | 是 | 是 |
| DELETE | 删除资源 | 否 | 是 |
| PATCH | 局部更新资源 | 是 | 否 |
-
路径（Path）：如
/index.html -
协议版本：如
HTTP/1.1 -
头部（Headers）：键值对，如
Host,User-Agent,Content-Type
| 类别 | 头部名 | 示例值 | 作用说明 |
|---|---|---|---|
| 主机 | Host | www.example.com | 指定目标主机（HTTP/1.1 唯一必须） |
| 用户代理 | User-Agent | Mozilla/5.0 (Windows NT 10.0; Win64; x64) | 标识客户端软件（浏览器、爬虫、App） |
| 接受类型 | Accept | text/html,application/xhtml+xml,application/xml;q=0.9 | 告诉服务器客户端能接受的MIME 类型 |
| 编码 | Accept-Encoding | gzip, deflate, br | 支持的压缩算法（节省带宽） |
| 语言 | Accept-Language | zh-CN,zh;q=0.9,en;q=0.8 | 期望的自然语言 |
| 字符集 | Accept-Charset | utf-8 | 支持的字符编码（已不常用） |
| 连接控制 | Connection | keep-alive / close | 是否复用 TCP 连接（HTTP/1.1 默认 keep-alive） |
| 缓存 | Cache-Control | no-cache | 控制缓存行为 |
| 条件请求 | If-Modified-Since | Wed, 21 Oct 2015 07:28:00 GMT | 仅当资源自指定时间后修改过才返回 200 |
| 条件请求 | If-None-Match | "abc123" | 与 ETag 配合，实现缓存验证 |
| Cookie | Cookie | sessionid=abc123; theme=dark | 携带服务器之前通过 Set-Cookie 设置的状态信息 |
| 认证 | Authorization | Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9... | 携带令牌/用户名密码进行身份验证 |
-
体（Body）：主要用于POST/PUT请求，携带表单、JSON等数据
package org.example.request;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
// 请求处理类需要添加 @RestController 注解
@RestController
public class RequestController {
// 指定该方法的请求路径是 /request
@RequestMapping("/request")
public String request(HttpServletRequest request) {
// 从请求中获取请求方法的值
String method = request.getMethod();
System.out.println("请求方法：" + method);
// 从请求中获取请求路径的值
String path = request.getRequestURI();
System.out.println("请求路径：" + path);
// 从请求中获取请求的完整路径的值
String fullPath = request.getRequestURL().toString();
System.out.println("请求的完整路径：" + fullPath);
// 获取请求协议
String protocol = request.getProtocol();
System.out.println("请求协议：" + protocol);
// 获取请求参数
String name = request.getParameter("name");
System.out.println("参数 name 的值：" + name);
// 获取请求头
String accept = request.getHeader("Accept");
System.out.println("请求头 Accept 的值：" + accept);
return "ok";
}
}
1.2、响应协议
// 1、响应行
HTTP/1.1 200 OK
// 2、响应头
Content-Type: text/html
Content-Length: 1234
// 注意响应头和响应行之间有一行空格
// 3、响应体
<html>...</html>
-
状态码（Status Code）：
-
1xx：信息性（响应中）
-
2xx：成功（如200 OK）
-
3xx：重定向（如301 Moved Permanently）
-
4xx：客户端错误（如404 Not Found请求资源不存在）
-
5xx：服务器错误（如500 Internal Server Error我们编写的业务可能错误）
-
-
头部（Headers）：如
Content-Type,Set-Cookie,Cache-Control -
体（Body）：实际返回的内容，如HTML、JSON、图片等
package org.example.request;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.IOException;
// 响应处理类需要添加 @RestController 注解
@RestController
public class ResponseController {
// 指定该方法的请求路径是 /response
@RequestMapping("/response")
// 方式一：使用 HttpServletResponse 直接操作响应
// 参数 HttpServletResponse 用于接收响应信息
public void response(HttpServletResponse response) throws IOException {
// 1、设置响应状态码为 666
response.setStatus(666);
// 2、设置响应头为 name=zhangsan
response.setHeader("name", "zhangsan");
// 3、设置响应体为 h1 标题的 hello
response.getWriter().write("<h1>hello</h1>");
}
// 方式二：通过 spring 提供的 ResponseEntity 类操作响应
// 注意请求路径不可重复
@RequestMapping("/response2")
public ResponseEntity<String> response2() {
// 1、设置响应状态码为 666
// 2、设置响应头为 name=zhangsan
// 3、设置响应体为 h1 标题的 hello
return ResponseEntity
.status(666)
.header("name", "zhangsan")
.body("<h1>hello</h1>");
}
}
2、分层解耦
分层解耦依赖的是spring框架中的两个重要思想IoC和DI。
IoC 和 DI 是 Spring 框架的 核心思想，它们不是新技术，而是一种 设计思想，目的是 解耦。
| 术语 | 全称 | 中文 | 本质 | 一句话理解 |
|---|---|---|---|---|
| IoC | Inversion of Control | 控制反转 | 设计思想 | “你别主动 new 对象，交给容器来管。” |
| DI | Dependency Injection | 依赖注入 | 实现手段 | “容器把依赖‘送’进来，而不是你自己去‘拿’。” |
IoC 是思想，DI 是手段；Spring 通过 DI 实现了 IoC，让你不再 new 对象，专心写业务。
首先将你的实现类交给容器管理即进行控制反转IoC，在实现类中不需要自己new对象，而是使用@Component注解，之后将依赖注入，使用@Autowired，即可使用其中的方法
2.1、IOC
常见声明bean的注解：
| 注解 | 来源 | 只能打在 | 功能 | 是否支持 @ComponentScan | 是否支持 @Lazy/@Primary/@Scope |
|---|---|---|---|---|---|
@Component | Spring | 类 | 通用型 Bean | ✅ | ✅ |
@Service | Spring | 类 | 语义化 @Component | ✅ | ✅ |
@Repository | Spring | 类 | 语义化 + 持久化异常转换 | ✅ | ✅ |
@Controller | Spring | 类 | 语义化 + MVC 入口 | ✅ | ✅ |
@RestController | Spring | 类 | @Controller + @ResponseBody | ✅ | ✅ |
@Configuration + @Bean | Spring | 类 + 方法 | 第三方的类、需要复杂构造 | ❌（类本身会被扫描） | ✅（@Bean 方法上） |
// 1. 自己写的业务类 —— 语义化
@Service
@Primary
@Lazy
public class UserServiceImpl implements UserService { }
// 2. 自己写的 DAO —— 自动异常转换
@Repository
public class UserDaoImpl implements UserDao { }
// 3. REST 入口 —— 直接返回 JSON
@RestController
@RequestMapping("/users")
public class UserController { }
// 4. 第三方数据源 —— 无法用 @Component，用 @Bean
@Configuration
public class DataConfig {
@Bean
@ConfigurationProperties("spring.datasource")
public DataSource dataSource() {
return DruidDataSourceBuilder.create().build();
}
}
@Component 是根注解，后面 4 个只是它的语义化别名；真正“创造对象”的动作是 @Bean 方法。
-
@Component是根注解，其余都是它的语义化 specialization。 -
只有
@Bean能把“别人的类”变成 Bean；类注解只能打在自己代码里。 -
@Repository额外提供持久化异常转换；@RestController额外带上@ResponseBody。 -
配置类里
@Bean方法会被CGLIB 代理，保证单例与依赖解决；这是 Spring JavaConfig 的核心
注意声明bean的注解要想生效要在启动包（及创建项目后自动帮我们创建的Application）及其子包范围下才可生效
2.2、DI
| 注入点 | 示例 | 备注 |
|---|---|---|
| 字段 | @Autowired private UserService svc; | 反射直接写，启动最快；但不能 final，测试需反射工具。 |
| Setter | @Autowired public void setX(X x){..} | 传统 JavaBean 风格；可在 setter 里做额外赋值校验。 |
| 构造器 | public OrderService(@Autowired UserDao dao){..} | Spring 4.3+ 若只有一个构造器可省注解；字段可 final，最推荐（易单测、无循环依赖隐患）。 |
| 普通方法 | @Autowired public void inject(X x, Y y){..} | 任意名称、任意个数参数，Spring 都会把能解析的 Bean 传进来。 |
| 方法参数 | @Bean public Foo foo(@Autowired Bar b) | JavaConfig 里给 @Bean 方法传依赖。 |
补充：@Resource和@Autowired的依赖注入的区别
| 注解 | 先按什么找 | 找不到再按什么找 | 结论 |
|---|---|---|---|
@Autowired | 类型（byType） | 名称（byName）→ 需配合 @Qualifier | 默认类型优先 |
@Resource | 名称（byName）→ 默认取字段名 / setter 名 | 类型（byType） | 默认名称优先 |
@Service("fooService")
public class FooServiceImpl implements FooService { }
@Service("barService")
public class BarServiceImpl implements FooService { }
// 1. @Autowired 场景
@Autowired
private FooService fooService; // 先按类型 FooService 找→发现2个→再按字段名 fooService 匹配→找不到就抛 NoUniqueBeanDefinitionException
// 解决：@Qualifier("fooService") 或把变量名改成 fooServiceImpl / barServiceImpl
// 2. @Resource 场景
@Resource
private FooService barService; // 先按名称 barService 找→正好有一个 @Service("barService")→直接注入成功，不管类型
四、JDBC
JDBC（Java Database Connectivity）是 Java 提供的一套标准 API，用于连接和操作各种关系型数据库。它允许 Java 程序通过统一的接口与数据库进行交互，而不需要关心底层数据库的具体实现。
1、JDBC 的核心组成
接口规范：
-
为了项目代码的可移植性、可维护性，SUN公司从最初就制定了 Java 程序连接各种数据库的统一接口规范。这样的话，不管是连接哪一种 DBMS 软件，Java 代码可以保持一致性。
-
接口存储在
java.sql和javax.sql包下。
实现规范：
-
因为各个数据库厂商的 DBMS 软件各有不同，那么各自的内部如何通过 SQL 实现增、删、改、查等操作管理数据，只有这个数据库厂商自己更清楚，因此把接口规范的实现交给各个数据库厂商自己实现。
-
厂商将实现内容和过程封装成 jar 文件，我们程序员只需要将 jar 文件引入到项目中集成即可，就可以开发调用实现过程操作数据库了。
2、使用jdbc实现DML
以向maven工程中引入MySQL驱动为例
-
先在 Java 项目中引入 MySQL 的 JDBC 驱动依赖
-
准备要操作的库表
-
代码实现
2.1、引入依赖
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>8.3.0</version>
</dependency>
2.2、准备库表
CREATE TABLE student1 (
`id` varchar(20) NOT NULL COMMENT '学号',
`name` varchar(20) NOT NULL COMMENT '姓名',
`age` smallint NOT NULL COMMENT '年龄',
`gender` varchar(1) NOT NULL COMMENT '性别',
`major_class` varchar(20) NOT NULL COMMENT '专业',
PRIMARY KEY (`id`),
UNIQUE KEY `id` (`id`),
KEY `normalindex` (`age`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='学生表'
INSERT INTO student1 VALUES (
'1','张三',123,'男','计算机科学',
'2','李四',22,'女','电子工程',
'3','王五',15,'男','机械工程',
'4','赵六',18,'女','化学工程',
'5','孙七',25,'男','土木工程'
)
2.3、代码实现
实现将张三的年龄改为18
package jdbc;
import org.junit.jupiter.api.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class JDBCTest {
@Test
public void testUpdate() throws ClassNotFoundException, SQLException {
// 1、获取数据库连接
// 表示连接到 localhost 上的 MySQL 数据库实例，端口号为 3306，数据库名称为 test
// 用户名和密码分别为 root 和 123456
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "123456";
// 使用 DriverManager 类的 getConnection 方法获取数据库连接
Connection conn = DriverManager.getConnection(url, user, password);
// 2、注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 3、获取要执行的 SQL 语句的 Statement 对象
Statement stmt = conn.createStatement();
// 4、执行 SQL 语句(DML)
int count = stmt.executeUpdate("update student1 set age = 18 where id = '1'");
System.out.println("影响了 " + count + " 条记录");
// 5、关闭 Statement 对象和 Connection 对象，即关闭连接释放对象
stmt.close();
conn.close();
}
}
3、使用jdbc实现DQL
在完成上一步的DML语句的基础上来进行实现DQL语句
-
创建实体类
-
代码实现
3.1、创建实体类
该实体类中的参数和你要操作的表的列有关
package jdbc;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
// Data 注解：自动生成类的 getter、setter、equals、hashCode、toString 方法
// AllArgsConstructor 注解：自动生成包含所有参数的构造方法
// NoArgsConstructor 注解：自动生成无参数的构造方法
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private String id;
private String name;
private Integer age;
private String gender;
private String major_class;
}
3.2、代码实现
package jdbc;
import org.junit.jupiter.api.Test;
import java.sql.*;
public class JDBCTest {
@Test
public void testSelect() throws ClassNotFoundException, SQLException {
// 1、获取数据库连接
// 表示连接到 localhost 上的 MySQL 数据库实例，端口号为 3306，数据库名称为 test
// 用户名和密码分别为 root 和 123456
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "123456";
// 使用 DriverManager 类的 getConnection 方法获取数据库连接
Connection conn = DriverManager.getConnection(url, user, password);
// 2、注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 3、获取要执行的 SQL 语句的 Statement 对象
Statement stmt = conn.createStatement();
// 4、执行 SQL 语句(DQL)，注意此处是 executeQuery
ResultSet rs = stmt.executeQuery("select id,name,age,gender,major_class from student1 where id = '1'");
// 遍历 ResultSet 对象，将结果通过 User 类的带参构造封装起来
while (rs.next()) {
User result = new User(
rs.getString("id"),
rs.getString("name"),
rs.getInt("age"),
rs.getString("gender"),
rs.getString("major_class"));
System.out.println(result);
}
// 5、关闭 Statement 对象和 Connection 对象，即关闭连接释放对象
stmt.close();
conn.close();
}
}
当然以上代码也可以通过预编译sql实现
4、预编译SQL
预编译 SQL（PreparedStatement）是 JDBC 中防止 SQL 注入、提高性能、简化参数处理的核心武器。
提供基本模板：
package jdbc;
import org.junit.jupiter.api.Test;
import java.sql.*;
public class JDBCTest {
// 动态预编译SQL
@Test
public void testSelect() throws ClassNotFoundException, SQLException {
// 1、获取数据库连接
// 表示连接到 localhost 上的 MySQL 数据库实例，端口号为 3306，数据库名称为 test
// 用户名和密码分别为 root 和 123456
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "123456";
// 使用 DriverManager 类的 getConnection 方法获取数据库连接
Connection conn = DriverManager.getConnection(url, user, password);
// 2、注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 3、获取要执行的 SQL 语句的 Statement 对象
Statement stmt = conn.createStatement();
// 4、获取要执行的 SQL 语句的 PreparedStatement 对象
PreparedStatement ps = conn.prepareStatement("select id,name,age,gender,major_class from student1 where id = ?");
// 为 PreparedStatement 对象的第一个'?'设置参数
ps.setString(1, "1");
// 执行 SQL 语句(DQL)，注意此处是 executeQuery 方法，返回的是 ResultSet 对象
ResultSet rs = ps.executeQuery();
// 遍历 ResultSet 对象，将结果通过 User 类的带参构造封装起来
while (rs.next()) {
User result = new User(
rs.getString("id"),
rs.getString("name"),
rs.getInt("age"),
rs.getString("gender"),
rs.getString("major_class"));
System.out.println(result);
}
// 5、关闭 Statement 对象和 Connection 对象，即关闭连接释放对象
stmt.close();
conn.close();
}
}
| 方法 | 说明 |
|---|---|
setInt(index, value) | 整数 |
setString(index, value) | 字符串 |
setDouble(index, value) | 浮点 |
setDate(index, java.sql.Date) | 日期 |
setNull(index, Types.INTEGER) | 设 NULL |
索引从 1 开始，不是 0！
优点：
-
防止 SQL 注入
// ❌ 危险
String sql = "SELECT * FROM user WHERE name = '" + name + "'";
// ✅ 安全
String sql = "SELECT * FROM user WHERE name = ?";
ps.setString(1, name);
如果使用的是静态 SQL 会有 SQL 注入风险
现在模拟一个账号密码登录场景，通过查询用户输入的和数据库中已有的是否相同来判断是否可进入
如原静态 SQL 使用的是字符串拼接
select name,password from student1 where name='用户输入的名字' and password='用户输入的密码'
SQL 注入风险，输入的name随便，输入的密码：'or'1'='1
最终查询语句变为：
select name,password from student1 where name='随便' and password=''or'1'='1'
以上语句百分百成功，这便导致不存在的用户也可以进入，而使用了预编译SQL则不会导致这种问题的出现
String sql = "select name,password from student1 where name= ？ and password=？"
ps.setString(1, 用户输入的名字);
ps.setString(2, 用户输入的密码);
-
高性能
扫一扫
771
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
