导图社区 java_web
- 4
- 0
- 0
- 举报
java_web
这是一篇关于java web考试复习的内容，梳理了Java Web技术体系中的关键知识点，包括前端技术、Java Web基础、服务器端技术等多个方面。
编辑于2025-07-03 00:03:03- 期末考试
- 前端技术
- java_web
- 相似推荐
- 大纲
java web
判断题（5T）
1-3T（1.3节）
1.3.1 Http的特点 （1）简单快速：客户向服务器请求服务时，只需请求方法和路径（GET、HEAD、POST） （2）灵活 （3）无连接：一次一连接 （4）无状态：不保存状态，需要重传，支持B/S（浏览器服务器）和C/S结构（客户端服务器）
1.3.2 Http常用的请求方法 （1）GET和POST方法 （2）利用？来分割URL和传输数据，GET提交的数据会放在URL之后，参数之间用&相连 （3）POST方法是把提交的数据放在HTTP包的Body中 （4）GET方法利用Request.QueryString来获得变量的值/POST利用Request.Form （5）GET会存在安全隐患
1.3.3 HTTP的状态 （1）无状态协议 （2）引入Cookie对象对登录的信息进行保存 （3）持久连接与管线化（只要一端没用明确提出断开连接，就会保持TCP的连接状态，管线化是指在没有响应其他的时候也可以继续发送请求） （4）Cookie的状态管理（用来保存用户状态）
1.3.4 Http的工作原理 （1）请求/响应模型——请求报文=请求的方法+URL+协议+请求头部+请求数据 （2）响应=协议+成功/错误代码+服务器信息+响应头部+响应数据 （3）建立过程先是客户端（一般是浏览器）向服务器的HTTP端口（默认80）建立一个TCP套接字（例如：http://www.baidu.com）然后客户端向服务器发送一个请求报文，服务器接受请求并返回http响应，后续释放/保持TCP连接，最后客户端浏览器解析HTML的内容
1.3.5 Http报文 （1）请求报文（客户端），响应报文（服务器端） （2）报文分为报文首部和报文主体（两者之间存在空行） 第一部分：状态行，由 HTTP 版本号、状态码、状态消息三部分组成。在第一行中，HTTP/1.1表明 HTTP 版本为 1.1，状态码为 200，状态消息为 OK。 第二部分：消息报头，用来说明客户端要使用的一些附加信息。第二行和第三行为消息报头，Date 是生成响应的日期和时间，Content-Type 指定了 MIME 类型的 HTML（text/html），编码类型是UTF-8。 第三部分：空行，消息报头后面的空行是必需的。 第四部分：响应正文，服务器返回给客户端的文本信息。
1.3.6 http状态码 （1）状态码由三位数字组成，第一个数字定义了响应的类别（1xx/2xx/3xx/4xx/5xx） （2）1xx指示信息，表示请求已接收，继续处理；2xx成功，表示成功接收；3xx重定向，完成请求必须进行更进一步的操作；4xx客户端错误，表示请求有语法错误或请求无法实现；5xx表示服务器端错误，服务器未能实现合法的请求 （3）常见状态码：200 400 401 403 404 500 503
4T（Maven）
3.2 Maven简介 1.概念：是一个项目管理和综合工具，可以为开发人员构建一个完整的生命周期框架 2.好处： （1）构建项目过程标准化、项目结构模块化 （2）Maven的依赖管理特性使得引入JAR包这项工作变得简便，只需在pom.xml文件中添加相应的JAR包坐标，Maven就能从仓库中找到并导入 3.原理： （1）利用坐标标识java构件 （2）maven会自动加载依赖包的依赖 4.Maven仓库 分为本地仓库和远程仓库，一般先在本地仓库查找，找不到再找远程仓库
3.3 Maven的配置 （1）在官网下载maven安装文件 （2）确定下载安装路径 （3）建立环境变量（MAVEN_HOME）并给刚刚下载安装的路径 （4）编辑环境变量，配置%MAVEN_HOME%\bin\； （5）可以利用mvn-v检查是否安装成功
3.5 搭建Java Web项目框架 （1）新建工程，然后选取Maven，勾选相应选项 （2）填写信息后一直next （3）.... （4）.... （5）在web.xml文件中添加相应代码 （6）要在pom.xml当作添加依赖
5T（html概念）
5.1 HTML简介 超文本标记语言，不是编程语言，是一种标记语言、标记标签。互联网的网页都是用HTML格式的文本编写的
5.2 HTML的标签，元素和属性 一个HTML网页文件由若干个元素组成，元素则由开始标签、结束标签、属性和元素内容4部分构成。
5.2.1 标签的概念 html标记标签通常称为html标签 （1）html标签由尖括号包围，例如：<html></html>，这表示一个html文件 （2）两种使用形式，一种是成对标签，开始标签和结束标签，例如：<开始标签>网页的内容</结束标签>；另一种是单独出现标签。如果第一种形式当中没用内容，可以不需要开始标签和结束标签，例如<br/>
5.2.2 元素的概念 （1）元素通常包含开始标签、内容、其他元素和一个结束标签 （2）有的时候可以忽略结束标签，例如<p>第一段 （3）有的时候会忽略开始标签，例如，html、head和body等元素允许忽略开始标签 （4）有一些元素可以没用内容，因此不需要结束标签，例如换行标签<br><br> （5）元素可以进行嵌套，但是嵌套得严格对称，例如<p>this is<em>HTML!<em><p>
5.2.3 属性的概念 （1）html元素附加的信息 （2）html可以设置<元素属性 ="值">内容</元素> （3）属性可以在元素中添加信息 （4）属性一般描述于开始标签 （5）属性总是以名称/值对的形式出现，例如，a="b"
5.3 常用的标签
5.3.1 基础标签 <h1>至<h6>是标题标签，<h1>定义为最大的标题，<h6>定义为最小的标题 <!- ->为注释标签，这个可以用来在源代码中插入注释，注释不会被浏览器显示出来
5.3.2 格式标签
5.3.3 图像标签 （1）<img>图像标签，用来定义图像的，相关的属性值为，src表示图像的地址，alt规定图像的替代文本，width和hight表示图像的宽带和高度 （2）<map>标签定义图像映射，指带有可单击区域的一幅图像 （3）<area>定义图像映射中的区域，area元素永远嵌套在map元素内部，area元素可定义图像映射中的区域
5.3.4 链接标签 html可以使用超链接与网络上的另一个文档相连，可以使用<a>标签创建链接，使用<link>标签可以定义两个链接文档之间的关系，而<nav>标签可以定义导航链接部分 （1）<a>当中的href属性表示链接的目标URL，target属性表示当target值为_blank时打开的链接窗口为新窗口 （2）隔壁
5.3.5 表单标签
5.3.6 框架标签
单选
1-4T（第二章）
Tomcat
各个文件夹目录说明如下：
bin：存放启动和关闭tomcat的脚本文件
conf：存放配置文件
lib：存放jar包
logs：存放日志文件
temp：存放临时文件
webapps：存放web应用
work：工作目录
startup.bat文件是启动文件，启动后不要随便关闭，关闭后相当于关闭了tomcat服务器
tomcat虚拟目录映射：如果不将开发编译好的java_web项目放到webapps子目录下，可以进行虚拟目录映射，也就是将项目目录映射为可供浏览器访问的目录。 例如项目的实际目录为d:/uname,可以打开conf目录下的的server.xml文件找到<Host>标签，在<Host></Host>之间添加<Context path="/uname" docBase="d:\uname"/> path：应用的真实路径 docBase：代表网络访问的虚拟目录名
可以通过配置将index.html设置为默认主页，此时url不需要有index.html也能访问到该页面。例如：完整的url是http://localhost:8080/demo/index.html简化后为http://localhost:8080/demo/ web.xml应放在WebContent\WEB-INF目录下 部署描述符的根元素是web-app，在元素当中有些符号需要简单说明一下：问号(?)表示子元素可选，而且只能出现一次；星号（*）表示子元素可在部署描述符中出现0次或者多次 <distributable/>可以使用distributable元素告诉Servlet/JSP容器，Web容器中部署的应用程序适合在分布式环境下运行
Servlet
简介：Servlet是运行在Web服务器上的小型Java程序，一般是把实现了Servlet接口的Java类称为Servlet。这里是通过HTTP协议来接收和响应Web客户端的请求。 Servlet在Web当中就相当于是一个业务处理的角色
Servlet主要执行以下任务： （1）读取客户端发送的显示数据。包括HTML表单，或者是applet或自定义的HTTP客户端程序的表单 （2）读取客户端发送的隐式数据，包括Cookies、媒体类型和浏览器能理解的压缩格式 （3）处理数据并生成结果 （4）发送显示数据（文档）到客户端，包括文本文件（HTML或XML）、Excel文件、二进制文件 （5）发送隐式的HTTP响应到客户端，设置Cookies和缓存参数
Servlet接口常见的抽象方法：init()方法、service方法（这里会创建两个对象，一个是ServletRequest请求对象和一个ServletResponse响应对象）destroy方法，getServletInfo方法（返回Servlet的描述信息），getServletConfig方法
servlet的初始化：通过ppt上的例子可知，第一次访问servlet的时候，servlet实例对象才会被创建，不管多少次的访问都是只有一个实例对象。
在进行初始化的过程中，实际上是会分配一个内存的，因此需要进行释放，这里释放是等Tomcat关闭后进行释放的，调用父类当中的destroy方法，对其进行重写即可
实现Servlet的三种方式： （1）实现Servlet接口 （2）继承GenericServlet抽象类 （3）继承HttpServlet抽象类
需要注意的是（2）和（3）本身是已经实现了Servlet接口的，因此与（1）相比是间接实现了接口，（1）在使用的时候需要将接口当中的所有方法都实现，尽管有些方法用不上，所以一般不会使用（1），而（2）是不常用，由于大多数web应用都通过http和客户端交互，所以（3）比较常用
（3）当中常用的方法为doGet()方法和doPost()方法，由于本身实现了该接口，因此也包含init和destroy这两个生命周期函数和service方法，但是需要注意的是这个地方不要重新service方法，如果重写了之后则只会调用重写之后的service方法，而原先的doGet方法和doPost方法会被覆盖，无法被调用。
标签<servlet>可定义Servlet，指定Servlet的名称和实际路径，其子标签<servlet-class>指定了该Servlet的完整路径，<servlet-name>指定了Servlet的自定义名称，<servlet-mapping>可以用来指定Servlet名称与访问该Servelt的URL路径——其中也包含两个标签<servlet-name>和<url-pattern>,指定了名称和URL的访问路径
servlet的URL路径映射： （1）多重映射，指的是一个servlet可以被多个URL路径给访问，实现方法就是在servlet标签当中多创建一个或多个<servlet-mapping>，然后对<url-pattern>使用不同的值 （2）如果是希望一个目录下的所有任意路径都能访问同一个Servlet，这时可以通过通配符来表示 （a）*.扩展名，例如*.action （b）/*，例如，/aaa/*可以匹配以/aaa开头的所有URL，但是两种格式不能混着用。
HttpServletRequest对象（后续简称为request对象） http的报文当中有很多请求信息，比如说请求头、请求行（当请求报文到达Tomcat服务器后，服务器要对其进行解析和保存）request对象是由服务器创建的，一个请求处理完以后，当中所保存的信息便没有用了，所以其生命周期是一个请求内的。一般来说服务器接收到一个请求就会创建一个request对象来保存这些请求信息。
获得客户端的信息的方法
获取客户端请求头的方法
获取客户端请求参数（客户端提交的数据）
HttpServletResponse对象（后续简称为response对象） 用来保存响应报文的信息，一般来说response对象与request对象是成双成对出现，生命周期一样。response对象中封装了向客户端发送数据、发送响应头、发送响应状态码的方法
（1）根据课本当中的例子可以知道，setHeader方法与addHeader方法的区别是，两者都可以添加响应信息，但是当出现相同键名时，前者会覆盖之前的值，后者并不会 （2）由于response对象可以手动设置返回的状态码，因此在我们访问一些网站的时候，有可能这个网站不存在，也有可能是这个网站的开发者手动设置这个URL无法进行访问，将网页隐藏起来。
请求转发与重定向
请求重定向： 是客户端请求第一个web资源，当第一个web资源收到客户端请求后，再通知客户端去访问另外一个web资源。第一个web资源将会发送302状态码以及location响应头给客户端，客户端自动会向location响应头中的URL发出第二次请求。所以整个重定向周期，客户端一共发送两次相对独立的请求，所以表面上浏览器地址栏中的信息会发生改变，然后请求参数数据在第二个web资源当中将会丢失，不能再用request.getParameter()方法获取
请求转发： 是客户端先请求一个web资源，当第一个web资源收到客户端请求后，再通知服务器去调用另外一个web资源进行处理。对于客户端而言，它只是发出了一次请求，所以表面上浏览器地址栏中的信息不会发生改变，此外请求参数数据在第二个web资源中也不会丢失，仍然可以用request.getParameter方法获取。
这个地方如果进行测试的话，调用out.write()，会发现一直无输出，因为刚开始输出到了缓冲区，并未真正输出，当后续遇到请求转发时，将会清空缓冲区
Cookie对象 服务器端的应用程序把每个用户的数据以Cookie对象的形式写到用户各自的浏览器，当用户再次访问该应用程序时就会携带用户各自的数据，从而浏览器就能处理用户的各自数据
cookie对象的创建是键值对 Cookie cookie = new Cookie("uname","zhangsan"); 然后服务器端程序需要用response对象的addCookie方法向客户端发送Cookie，存入客户端浏览器 response.addCookie(cookie); 一次发送多个Cookie，则多个键值对需要用分号进行隔开
Cookie的常用方法
setMaxAge(),用于设置Cookie在客户端的生存时间 正常情况下是设置成正整数，设置为0时表示删除该Cookie对象，默认为-1
setPath()，用于设置Cookie的有效目录路径，当客户端再次访问服务器其他资源时，根据访问路径来决定是否带着Cookie到服务器。此时就需要考虑到Set-Cookie响应头字段当中的Path部分，删除的时候，path必须一致，否则无法进行删除
getName()
getValue()
一个Cookie只能标识一种信息，至少会包含由一个标识该信息的名称和设置值。一个web站点可以给一个web浏览器发送多个Cookie，同时一个web浏览器也可以存储多个web站点所提供的Cookie。一般来说一个浏览器只允许存放300个Cookie，每个站点最多存放20个Cookie
Session对象 Session是会话的意思，一次会话包括多次请求与响应 例如：打开浏览器——访问web网站——在此期间多次点击超链接——访问该web站点的多个资源——最后关闭浏览器。 这是由服务器所创建的，并且保存在服务器上的，对客户端而言其不可见，而每一个Session对象都有一个属于自己的JSESSIONID，可以通过Cookie把Session对象的JSESSIONID发送给客户端，因此当下一个请求里添加了这个JSESSIONID后就能识别出是哪个客户请求的了。
常用的方法 创建、存储、设置时间、失效
与Cookie对象的区别 cookie是把用户的数据写给用户的浏览器 session则是把用户的数据写到用户独占的session中
ServletContext对象的作用（用于多个用户的数据传输）： 不仅仅是用来不同用户访问服务器的数据共享，同时也可以用来保存服务器的全局配置信息（在一个服务器启动时便会创建这么一个对象，到服务器结束也只有这么一个对象） 与之类似的还有一个是ServletConfig就是用来保存局部配置信息的
5T（第七章）jsp的四个脚本
jsp： 将Java代码嵌入到HTML页面中，通过JSP引擎在服务器端动态生成网页内容 作用：替换显示页面部分的Servlet，使用****.jsp文件替换****.java 一般是在web目录下新建*.jsp文件（与WEB-INF平级） <% %>标签来编写java代码 <% Java代码 %>
jsp是简化的Servlet 所有写的标签和代码都是用流做的一个打印（用out输出流做的一个打印）
例： <% int a =10; System.out.println(a) ;//打印在控制台（后端） out.println(a); //打印在客户端界面（前端） %>
4个脚本
普通脚本：<% %>的两个要求 （1）普通脚本可以使用所有的java语法，除了定义函数 （2）脚本与脚本之间不可嵌套，脚本与HTML标签不可嵌套
例： <% int a =10; System.out.println(a) ;//打印在控制台（后端） out.println(a); //打印在客户端界面（前端） <% System.out.println("嘿嘿嘿"); //不能嵌套 %> %>
声明变量：一个声明语句可以声明一个或多个变量及方法，在jsp文件当中，需要先声明这些变量和方法然后才能进行使用，声明语句格式如下： <%!declaration; [declaration;]+....%> <%!定义变量，函数%> 例：<%!String a =" study";%> <%! int b =100;%>
这里有个问题，这个地方声明的b和上面声明的a是有点区别的，上面的a只能在service当中使用，因为是局部变量，而b是一个全局变量，当每次请求a时都会从10开始使用，但是b是一直在发生变化的。
表达式：一个JSP表达式中包含的脚本语言表达式，会先被转换为String，然后插入表达式出现的地方。表达式的语法格式为：<%= 表达式%> 这个效果和<%out.println();%>一样。 例如：<%="<P>YBH</P>"%> <——><% out.println("<P>YBH</P>"); %>
JSP注释： <%--注释--%>：JSP注释，注释内容不会被发送至浏览器 <! -注释 ->：HTML注释，通过浏览器查看网页源代码时可以看见注释内容
论述题
IOC和AOP
Spring 框架中的 IOC（控制反转）和 AOP（面向切面编程）是两个重要的概念。请简述 IOC 和 AOP 的基本概念，并说明它们在 Spring 框架中是如何协同工作的，以及这种协同工作在实际开发中带来了哪些好处。
IOC 是一种设计思想，将对象的创建和管理交给 Spring 容器，通过依赖注入的方式实现对象之间的解耦。AOP 则是一种编程范式，通过切面将横切关注点（如日志、事务）与业务逻辑分离，实现代码复用和模块化。 在 Spring 中，IOC 容器负责创建和管理业务对象（如 Service、DAO）以及切面对象。AOP 利用 IOC 容器提供的对象，在不修改业务逻辑代码的前提下，通过代理技术（如 JDK 动态代理或 CGLIB）在业务方法执行时织入切面逻辑。 IOC管理Bean生命周期，为AOP提供可代理对象；AOP增强IOC管理的Bean功能，共同实现「核心业务与辅助功能」的双重解耦。 它们的协同工作使开发人员可以专注于业务逻辑的实现，而将通用功能（如日志记录、事务管理）集中到切面中。这样不仅提高了代码的可维护性和可读性，还降低了模块间的耦合度，便于后期的扩展和修改。
xml文件
web.xml：这是Java Web应用的部署描述符文件，用于配置Web应用程序的各个方面，如Servlet、JSP、过滤器、监听器等。在文档中，它被用于配置Servlet的映射和默认页面等。 conf.xml：在MyBatis框架中，这是用于配置数据库连接信息的文件，如数据库URL、用户名、密码等。它还用于注册SQL映射文件，使得MyBatis能够执行数据库操作。 settings.xml：这是Maven的配置文件，用于配置本地仓库路径、远程仓库地址、镜像设置等内容。在文档中，它被提及是在介绍如何在IDEA中配置Maven属性时。 pom.xml：这是Maven项目的项目对象模型文件，用于定义项目的基本信息、依赖项、构建配置等。文档中提到在使用Maven搭建Java Web项目框架时需要编辑此文件，添加必要的依赖。 这些文件在Java Web开发中扮演着重要的角色，分别用于项目的配置、构建和依赖管理。例如，web.xml用于定义Web应用的结构和行为，conf.xml用于配置MyBatis的数据库连接，settings.xml和pom.xml则与Maven的项目管理和构建过程密切相关。
http的特点及其连接方式
论述题： HTTP协议具有无状态的特点，即服务器不会保存客户端请求的上下文信息。在这种情况下，如何通过技术手段实现用户的登录状态保持和持久连接？请结合HTTP的工作原理进行阐述。
答案： HTTP协议本身是无状态的，这意味着服务器在处理完一个请求后，不会保留任何与该请求相关的状态信息。因此，对于需要保持登录信息的场景，通常采用Cookie技术。当用户首次登录时，服务器会生成一个包含用户身份信息的Cookie，并将其作为HTTP响应的一部分发送给客户端。客户端浏览器在后续的请求中会自动将该Cookie包含在请求头中，发送回服务器。服务器通过解析Cookie中的信息，识别用户的身份，从而实现登录状态的保持。这种机制允许在多个HTTP请求之间共享状态信息，模拟出“有状态”的会话。 对于持久连接，HTTP/1.1版本引入了持久连接的概念。在请求头部中，可以设置Connection: keep-alive，这样服务器在处理完一个请求后，不会立即关闭TCP连接，而是保持该连接处于打开状态，允许在同一个连接上执行多个请求和响应的交互。这种方式减少了频繁建立和断开连接的开销，提高了通信效率。管线化（Pipelining）也是HTTP/1.1的一个特性，它允许客户端在同一个连接上发送多个请求，而无需等待每个请求的响应，这进一步优化了资源使用和提升了用户体验。通过这些技术手段，即使在HTTP协议无状态的框架下，也能有效地实现用户会话管理和资源的高效利用。
一、HTTP无状态特性的解决方案：Cookie机制
HTTP协议的无状态性导致服务器无法识别连续请求的用户身份。为实现登录状态保持，采用 Cookie技术： 首次登录流程：用户提交登录请求后，服务器生成唯一会话标识（如Session ID）； 通过响应头 Set-Cookie: JSESSIONID=abc123 返回标识（见图1.11）； 浏览器自动存储该Cookie至本地。 后续请求流程：浏览器在每次请求中自动附加 Cookie: JSESSIONID=abc123 请求头（见图1.12）； 服务器解析Cookie识别用户身份，实现会话连续性。 关键作用：Cookie在无状态协议中模拟“有状态”会话，避免重复登录。
二、HTTP无连接性的优化：持久连接与管线化
HTTP/1.1 针对频繁建立连接的缺陷引入优化机制： 持久连接（Keep-Alive）：通过 Connection: Keep-Alive 头部复用单TCP连接处理多个请求（见图1.9）； 优势：减少TCP三次握手开销，提升资源加载效率（如网页同时加载HTML/CSS/JS）。 管线化（Pipelining）：客户端无需等待响应即可连续发送多个请求（见图1.10）； 优势：降低网络延迟，显著提升传输效率。 协同效果：二者共同解决无连接导致的性能瓶颈，形成高效通信链路。
三、技术协同与总结
Cookie机制突破无状态限制，实现跨请求身份识别； 持久连接+管线化解决无连接性能问题，减少网络延迟； 整体效果：在HTTP无状态/无连接框架下，构建高效、连贯的用户体验（如电商购物车保持、多资源页面快速加载）
简述servlet idea mybatis http maven之间的关系
HTTP 是 Web 通信基础协议（文档1第1章），定义了客户端（浏览器）与服务器（如 Tomcat）的请求/响应交互模型。Servlet 作为 Java 组件（文档2第2章），直接处理 HTTP 请求（如 doGet/doPost 方法），生成动态响应内容。
IDEA 是集成开发环境（文档1第3章），提供 Maven 集成支持。开发者通过 IDEA 创建 Maven 项目框架（文档1图3.9），配置依赖（如 Servlet API、MyBatis）和插件（如 Tomcat），简化项目搭建与部署流程。
Maven 是项目管理工具（文档1第3章），通过 pom.xml 定义项目结构、依赖库（如 javax.servlet-api）和构建流程。它管理 MyBatis 等框架的版本（文档2第4.5节），确保依赖一致性，并通过本地/远程仓库自动下载所需 JAR 包。
MyBatis 是持久层框架（文档2第4.5节），替代原生 JDBC 操作数据库。它在 Maven 项目中通过依赖引入（如 mybatis-3.4.6.jar），通过 XML 或注解配置 SQL 映射（文档2图4.20）。Servlet 调用 MyBatis 执行 SQL，处理业务逻辑（如查询商品列表），并将结果返回 HTTP 响应。（数据库与 MyBatis：数据持久层 数据库（如 MySQL）存储结构化数据（文档4第4.1节），通过 SQL 操作数据。 MyBatis 替代原生 JDBC：通过 XML 或注解配置 SQL 映射（文档4图4.20），简化数据库操作：）
关系总结： HTTP 协议驱动 Servlet 处理请求；IDEA 提供开发环境，集成 Maven 构建项目；Maven 管理依赖（Servlet、MyBatis）和生命周期；MyBatis 封装数据库操作供 Servlet 调用。四者协同实现从请求接收（HTTP）→ 业务处理（Servlet）→ 数据操作（MyBatis）→ 响应返回（HTTP）的完整 Web 应用流程。
关系总结： HTTP 驱动通信 → Servlet 处理业务 → MyBatis 桥接数据库 → 数据库存储数据 → Maven 统一依赖 → IDEA 集成全流程。四者形成 "协议→逻辑→数据→工具" 的闭环，高效支撑 Java Web 应用开发。
三层架构
根据三层架构可知，需要创建基本的业务层，控制层，dao层进行前后端的调用过程。
web层
与客户端交互，包括获取用户请求，传递数据，封装数据，展示数据。
service层
复杂的业务处理，包括各种实际的逻辑运算。
dao层
与数据库进行交互，与数据库相关的代码在此处实现
程序补全
前四章
第一章源代码
import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.InetAddress; import java.net.ServerSocket; import java.net.Socket; public class SimpleTomcat { public static void main(String[] args) throws IOException { ServerSocket serverSocket = null; int port = 8050; // 创建ServerSocket绑定到本地8050端口 serverSocket = new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1")); while(true) { Socket socket = null; InputStream input = null; OutputStream output = null; try { // 等待客户端连接 socket = serverSocket.accept(); // 获取输入输出流 input = socket.getInputStream(); output = socket.getOutputStream(); // 获取并输出浏览器请求 dorequest(input); // 构建响应消息 String responseMessage = "<h1>Hello world, I am a simple server</h1>"; // 发送响应到浏览器 output.write(responseMessage.getBytes()); } finally { // 关闭socket连接 if(socket != null) socket.close(); } } } /** * 解析并输出浏览器发送的请求 */ public static void dorequest(InputStream input) { StringBuffer request = new StringBuffer(2048); int i; byte[] buffer = new byte[2048]; try { // 从输入流读取请求数据 i = input.read(buffer); } catch(IOException e) { e.printStackTrace(); i = -1; } // 将字节数据转为字符串 for(int j = 0; j < i; j++) { request.append((char) buffer[j]); } // 在控制台输出请求内容 System.out.print(request.toString()); } }
第二章源代码
一、Tomcat 配置文件
1. 虚拟目录映射配置 (server.xml)
<!-- 教材2.2.3节 完整配置 --> <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true"> <!-- 其他配置 --> <Context path="/uname" docBase="d:\uname"/> </Host>
2. web.xml 默认首页配置
<!-- 教材2.2.4节 完整配置 --> <web-app> <!-- 其他配置 --> <welcome-file-list> <welcome-file>index.html</welcome-file> <welcome-file>index.htm</welcome-file> <welcome-file>index.jsp</welcome-file> <welcome-file>default.html</welcome-file> <welcome-file>default.htm</welcome-file> <welcome-file>default.jsp</welcome-file> </welcome-file-list> </web-app>
二、Servlet 基础类
1. 实现 Servlet 接口 (完整类)
// 教材2.3.2节 完整类代码 package com.lifeng.servlet; import javax.servlet.*; import javax.servlet.annotation.WebServlet; import java.io.IOException; import java.io.PrintWriter; @WebServlet("/simpletest") public class SimpleServlet implements Servlet { private ServletConfig config; @Override public void init(ServletConfig config) throws ServletException { this.config = config; System.out.println("Servlet初始化..."); } @Override public ServletConfig getServletConfig() { return config; } @Override public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { res.setContentType("text/html;charset=UTF-8"); // 设置内容类型 PrintWriter out = res.getWriter(); // 获取输出流 out.println("<html>"); out.println("<head><title>第一个Servlet</title></head>"); out.println("<body>"); out.println("<h1>My First Servlet</h1>"); out.println("</body></html>"); out.close(); //关闭 } @Override public String getServletInfo() { return "SimpleServlet Demo"; } @Override public void destroy() { System.out.println("Servlet销毁..."); } }
2. HttpServlet 实现类 (完整类)
// 教材2.3.4节 完整类代码 package com.lifeng.servlet; import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; import java.io.PrintWriter; @WebServlet("/httpDemo") public class HttpDemoServlet extends HttpServlet { // 继承 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { resp.setContentType("text/html;charset=UTF-8"); PrintWriter out = resp.getWriter(); out.println("<html><body>"); out.println("<h1>GET请求处理</h1>"); out.println("</body></html>"); } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { resp.setContentType("text/html;charset=UTF-8"); PrintWriter out = resp.getWriter(); out.println("<html><body>"); out.println("<h1>POST请求处理</h1>"); out.println("</body></html>"); } }
三、Servlet 生命周期类
1. 生命周期演示类
// 教材2.4.3节 完整类代码 package com.lifeng.servlet; import javax.servlet.*; import javax.servlet.annotation.WebServlet; import java.io.IOException; @WebServlet(urlPatterns = "/myservlet", loadOnStartup = 1) public class MyServlet implements Servlet { public MyServlet() { System.out.println("调用MyServlet构造方法..."); } @Override public void init(ServletConfig config) throws ServletException { System.out.println("调用MyServlet.init方法..."); } @Override public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { System.out.println("调用MyServlet.service方法..."); } @Override public void destroy() { System.out.println("调用MyServlet.destroy方法..."); } @Override public ServletConfig getServletConfig() { return null; } @Override public String getServletInfo() { return null; } }
2. 带 service 方法的 Servlet
// 教材2.5.1节 完整类代码 package com.lifeng.servlet; import javax.servlet.*; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; @WebServlet("/servletMethod") public class ServletMethod implements Servlet { @Override public void init(ServletConfig config) throws ServletException {} @Override public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { System.out.println("访问ServletMethod.service方法..."); // 不调用父类service方法 // super.service(req, res); // 直接输出响应 res.setContentType("text/html;charset=UTF-8"); res.getWriter().print("直接通过service方法处理请求"); } @Override public void destroy() {} @Override public ServletConfig getServletConfig() { return null; } @Override public String getServletInfo() { return null; } }
四、请求与响应处理类
1. HttpServletRequest 使用
// 教材2.5.2节 完整方法代码 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 获取请求参数 String username = req.getParameter("username"); String[] hobbies = req.getParameterValues("hobby"); // 获取客户端信息 String ip = req.getRemoteAddr(); String method = req.getMethod(); String contextPath = req.getContextPath(); // 获取请求头 String userAgent = req.getHeader("User-Agent"); // 设置响应 resp.setContentType("text/html;charset=UTF-8"); PrintWriter out = resp.getWriter(); out.println("<html><body>"); out.println("<p>用户名: " + username + "</p>"); out.println("<p>IP地址: " + ip + "</p>"); out.println("<p>浏览器: " + userAgent + "</p>"); out.println("</body></html>"); }
2. 文件下载处理
// 教材2.5.3节 完整方法代码 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 设置响应头 resp.setContentType("image/jpeg"); resp.setHeader("Content-Disposition", "attachment;filename=test.jpg"); // 获取文件输入流 String realPath = getServletContext().getRealPath("/images/test.jpg"); FileInputStream in = new FileInputStream(realPath); // 获取响应输出流 ServletOutputStream out = resp.getOutputStream(); // 复制文件内容 byte[] buffer = new byte[1024]; int len; while ((len = in.read(buffer)) > 0) { out.write(buffer, 0, len); } in.close(); out.flush(); }
五、会话管理类
1. Cookie 操作
// 教材2.5.5节 完整代码 // 写入Cookie protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 创建Cookie Cookie cookie = new Cookie("lastLoginTime", "2023-06-01"); // 设置有效期7天 cookie.setMaxAge(60 * 60 * 24 * 7); // 设置路径 cookie.setPath(req.getContextPath()); // 添加Cookie resp.addCookie(cookie); resp.getWriter().print("Cookie已设置"); } // 读取Cookie protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { Cookie[] cookies = req.getCookies(); if (cookies != null) { for (Cookie c : cookies) { if ("lastLoginTime".equals(c.getName())) { String value = c.getValue(); resp.getWriter().print("上次登录时间: " + value); } } } }
2. Session 操作
// 教材2.5.6节 完整代码 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 获取Session HttpSession session = req.getSession(); // 存储数据 session.setAttribute("user", new User("张三", "zhangsan@example.com")); // 设置超时时间30分钟 session.setMaxInactiveInterval(30 * 60); resp.getWriter().print("Session已设置"); } protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { HttpSession session = req.getSession(false); if (session != null) { User user = (User) session.getAttribute("user"); if (user != null) { resp.getWriter().print("当前用户: " + user.getName()); } } }
六、路径映射配置
1. web.xml 中的 Servlet 配置
<!-- 教材2.3.2节和2.3.5节 完整配置 --> <web-app> <!-- Servlet定义 --> <servlet> <servlet-name>SimpleServlet</servlet-name> <servlet-class>com.lifeng.servlet.SimpleServlet</servlet-class> <!-- 初始化参数 --> <init-param> <param-name>encoding</param-name> <param-value>UTF-8</param-value> </init-param> </servlet> <!-- 多重映射 --> <servlet-mapping> <servlet-name>SimpleServlet</servlet-name> <url-pattern>/simpletest</url-pattern> <url-pattern>/simpletest2</url-pattern> <!-- 第二映射路径 --> </servlet-mapping> <!-- 通配符映射 --> <servlet> <servlet-name>AdminServlet</servlet-name> <servlet-class>com.lifeng.servlet.AdminServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>AdminServlet</servlet-name> <url-pattern>/admin/*</url-pattern> <!-- 通配符--> </servlet-mapping> <!-- 默认Servlet --> <servlet> <servlet-name>DefaultServlet</servlet-name> <servlet-class>com.lifeng.servlet.DefaultServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>DefaultServlet</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app>
七、请求转发与重定向
1. 请求转发
// 教材2.5.4节 完整代码 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 设置请求属性 req.setAttribute("message", "来自源Servlet的数据"); // 获取请求转发器 RequestDispatcher dispatcher = req.getRequestDispatcher("/targetServlet"); // 执行转发 dispatcher.forward(req, resp); }
2. 请求重定向
// 教材2.5.4节 完整代码 protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 重定向到新位置 resp.sendRedirect(req.getContextPath() + "/newLocation"); }
八、全局对象使用
1. ServletContext 使用
// 教材2.5.7节 完整代码 public class GlobalServlet extends HttpServlet { protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 获取ServletContext ServletContext context = getServletContext(); // 设置全局属性 context.setAttribute("visitorCount", 1000); // 获取全局属性 Integer count = (Integer) context.getAttribute("visitorCount"); // 获取初始化参数 String dbUrl = context.getInitParameter("dbUrl"); } }
2. ServletConfig 使用
// 教材2.5.8节 完整代码 public class ConfigServlet extends HttpServlet { public void init(ServletConfig config) throws ServletException { super.init(config); // 获取私有配置 String privateConfig = config.getInitParameter("privateConfig"); } protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 使用ServletConfig String value = getServletConfig().getInitParameter("paramName"); resp.getWriter().print("配置值: " + value); } }
九、数据库初始化脚本
-- 教材2.3.2节相关 完整SQL DROP DATABASE IF EXISTS mybatis; CREATE DATABASE mybatis; USE mybatis; CREATE TABLE book( id INT PRIMARY KEY AUTO_INCREMENT, bookname VARCHAR(20), price FLOAT ); INSERT INTO book(bookname, price) VALUES('数据库', 88.5), ('计算机概念', 68.2);
十、HTML 表单示例
<!-- 教材2.5.1节 完整表单 --> <!DOCTYPE html> <html> <head> <title>Servlet方法测试</title> </head> <body> <form action="/TestServlet/servletMethod" method="get"> <input type="submit" value="GET提交"> </form> <form action="/TestServlet/servletMethod" method="post"> <input type="submit" value="POST提交"> </form> </body> </html>
第四章
jdbc操作数据库
一、数据库查询操作 (GetBookServlet)
package com.lifeng.servlet; import javax.servlet.*; import javax.servlet.annotation.WebServlet; import javax.servlet.http.*; import java.io.IOException; import java.io.PrintWriter; import java.sql.*; @WebServlet("/getbook") public class GetBookServlet extends HttpServlet { protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 设置编码 req.setCharacterEncoding("UTF-8"); resp.setContentType("text/html;charset=UTF-8"); PrintWriter out = resp.getWriter(); out.println("<html><body>"); out.println("<h2>图书列表</h2>"); out.println("<a href='addbook.html'>添加新书</a><br>"); out.println("<table border='1'>"); out.println("<tr><th>编号</th><th>书名</th><th>作者</th><th>价格</th><th>操作</th></tr>"); Connection conn = null; PreparedStatement pstmt = null; ResultSet rs = null; try { // 1. 加载驱动 Class.forName("com.mysql.jdbc.Driver"); // 2. 获取连接 conn = DriverManager.getConnection( "jdbc:mysql://localhost:3306/bookstore", "root", "root" ); // 3. 执行查询 String sql = "SELECT * FROM book"; pstmt = conn.prepareStatement(sql); rs = pstmt.executeQuery(); // 4. 处理结果 while (rs.next()) { int id = rs.getInt("Bookid"); String title = rs.getString("Title"); String author = rs.getString("Author"); double price = rs.getDouble("Price"); out.println("<tr>"); out.println("<td>" + id + "</td>"); out.println("<td>" + title + "</td>"); out.println("<td>" + author + "</td>"); out.println("<td>" + price + "</td>"); out.println("<td><a href='edit?id=" + id + "'>修改</a> | "); out.println("<a href='delete?id=" + id + "'>删除</a></td>"); out.println("</tr>"); } } catch (ClassNotFoundException | SQLException e) { e.printStackTrace(); } finally { // 5. 关闭资源 try { if (rs != null) rs.close(); if (pstmt != null) pstmt.close(); if (conn != null) conn.close(); } catch (SQLException e) { e.printStackTrace(); } } out.println("</table></body></html>"); out.close(); } }
二、数据库添加操作 (AddBookServlet)
package com.lifeng.servlet; import javax.servlet.*; import javax.servlet.annotation.WebServlet; import javax.servlet.http.*; import java.io.IOException; import java.sql.*; @WebServlet("/addbook") public class AddBookServlet extends HttpServlet { protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 获取参数 String title = req.getParameter("title"); String author = req.getParameter("author"); double price = Double.parseDouble(req.getParameter("price")); Connection conn = null; PreparedStatement pstmt = null; try { // 1. 加载驱动 Class.forName("com.mysql.jdbc.Driver"); // 2. 获取连接 conn = DriverManager.getConnection( "jdbc:mysql://localhost:3306/bookstore", "root", "root" ); // 3. 执行插入 String sql = "INSERT INTO book (Title, Author, Price) VALUES (?,?,?)"; pstmt = conn.prepareStatement(sql); pstmt.setString(1, title); pstmt.setString(2, author); pstmt.setDouble(3, price); // 4. 执行更新 int count = pstmt.executeUpdate(); // 5. 重定向 if (count > 0) { resp.sendRedirect("getbook"); } } catch (ClassNotFoundException | SQLException e) { e.printStackTrace(); } finally { // 6. 关闭资源 try { if (pstmt != null) pstmt.close(); if (conn != null) conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } }
三、数据库修改操作 （EditServlet.java + UpdateServlet.java）
// EditServlet.java（显示编辑页面） package com.lifeng.servlet; import javax.servlet.*; import javax.servlet.annotation.WebServlet; import javax.servlet.http.*; import java.io.IOException; import java.io.PrintWriter; import java.sql.*; @WebServlet("/edit") public class EditServlet extends HttpServlet { protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { int id = Integer.parseInt(req.getParameter("id")); Connection conn = null; PreparedStatement pstmt = null; ResultSet rs = null; PrintWriter out = resp.getWriter(); resp.setContentType("text/html;charset=UTF-8"); out.println("<html><body>"); out.println("<h2>修改图书</h2>"); out.println("<form action='update' method='post'>"); try { Class.forName("com.mysql.jdbc.Driver"); conn = DriverManager.getConnection( "jdbc:mysql://localhost:3306/bookstore", "root", "root" ); String sql = "SELECT * FROM book WHERE Bookid=?"; pstmt = conn.prepareStatement(sql); pstmt.setInt(1, id); rs = pstmt.executeQuery(); if (rs.next()) { out.println("<input type='hidden' name='id' value='" + id + "'>"); out.println("书名: <input type='text' name='title' value='" + rs.getString("Title") + "'><br>"); out.println("作者: <input type='text' name='author' value='" + rs.getString("Author") + "'><br>"); out.println("价格: <input type='text' name='price' value='" + rs.getDouble("Price") + "'><br>"); } } catch (Exception e) { e.printStackTrace(); } finally { try { if (rs != null) rs.close(); if (pstmt != null) pstmt.close(); if (conn != null) conn.close(); } catch (SQLException e) { e.printStackTrace(); } } out.println("<input type='submit' value='修改'>"); out.println("</form></body></html>"); out.close(); } } // UpdateServlet.java（执行更新操作） package com.lifeng.servlet; import javax.servlet.*; import javax.servlet.annotation.WebServlet; import javax.servlet.http.*; import java.io.IOException; import java.sql.*; @WebServlet("/update") public class UpdateServlet extends HttpServlet { protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { int id = Integer.parseInt(req.getParameter("id")); String title = req.getParameter("title"); String author = req.getParameter("author"); double price = Double.parseDouble(req.getParameter("price")); Connection conn = null; PreparedStatement pstmt = null; try { Class.forName("com.mysql.jdbc.Driver"); conn = DriverManager.getConnection( "jdbc:mysql://localhost:3306/bookstore", "root", "root" ); String sql = "UPDATE book SET Title=?, Author=?, Price=? WHERE Bookid=?"; pstmt = conn.prepareStatement(sql); pstmt.setString(1, title); pstmt.setString(2, author); pstmt.setDouble(3, price); pstmt.setInt(4, id); int count = pstmt.executeUpdate(); resp.sendRedirect("getbook"); } catch (ClassNotFoundException | SQLException e) { e.printStackTrace(); } finally { try { if (pstmt != null) pstmt.close(); if (conn != null) conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } }
四、数据库删除操作 (DeleteBookServlet)
package com.lifeng.servlet; import javax.servlet.*; import javax.servlet.annotation.WebServlet; import javax.servlet.http.*; import java.io.IOException; import java.sql.*; @WebServlet("/delete") public class DeleteServlet extends HttpServlet { protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { int id = Integer.parseInt(req.getParameter("id")); Connection conn = null; PreparedStatement pstmt = null; try { Class.forName("com.mysql.jdbc.Driver"); conn = DriverManager.getConnection( "jdbc:mysql://localhost:3306/bookstore", "root", "root" ); String sql = "DELETE FROM book WHERE Bookid=?"; pstmt = conn.prepareStatement(sql); pstmt.setInt(1, id); int count = pstmt.executeUpdate(); resp.sendRedirect("getbook"); } catch (ClassNotFoundException | SQLException e) { e.printStackTrace(); } finally { try { if (pstmt != null) pstmt.close(); if (conn != null) conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } }
五、HTML 表单 (addbook.html)
<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>添加新书</title> </head> <body> <h2>添加新书</h2> <form action="addbook" method="post"> 书名: <input type="text" name="title"><br> 作者: <input type="text" name="author"><br> 价格: <input type="text" name="price"><br> <input type="submit" value="添加"> </form> </body> </html>
六、Maven 依赖配置 (pom.xml)
<dependencies> <!-- MySQL驱动 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.40</version> </dependency> <!-- Servlet API --> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.1.0</version> <scope>provided</scope> </dependency> <!-- JSTL标签库 --> <dependency> <groupId>javax.servlet.jsp.jstl</groupId> <artifactId>jstl-api</artifactId> <version>1.2</version> </dependency> </dependencies>
前四章里面的myBatics
源代码
MyBatis配置文件：conf.xml
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <!-- 配置数据库连接信息 --> <dataSource type="POOLED"> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/> <property name="username" value="root"/> <property name="password" value="root"/> </dataSource> </environment> </environments> <mappers> <!-- 注册SQL映射文件 --> <mapper resource="com/ssm/chapter4/mapping/userMapper.xml"/> </mappers> </configuration>
实体类：Book.java
package com.ssm.chapter4.domain; public class Book { private int id; private String bookname; private float price; // Getter和Setter方法 public int getId() { return id; } public void setId(int id) { this.id = id; } public String getBookname() { return bookname; } public void setBookname(String bookname) { this.bookname = bookname; } public float getPrice() { return price; } public void setPrice(float price) { this.price = price; } @Override public String toString() { return "Book {" + "id=" + id + ", bookname='" + bookname + '\'' + ", price=" + price + '}'; } }
SQL映射文件：userMapper.xml
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.ssm.chapter4.mapping.userMapper"> <!-- 查询操作 --> <select id="getBook" parameterType="int" resultType="com.ssm.chapter4.domain.Book"> SELECT * FROM users WHERE id = #{id} </select> <!-- 增加操作 --> <insert id="addBook" parameterType="com.ssm.chapter4.domain.Book"> INSERT INTO book VALUES(#{id}, #{bookname}, #{price}) </insert> <!-- 删除操作 --> <delete id="deleteBook" parameterType="int"> DELETE FROM book WHERE id = #{id} </delete> <!-- 修改操作 --> <update id="updateBook" parameterType="com.ssm.chapter4.domain.Book"> UPDATE book SET bookname = #{bookname}, price = #{price} WHERE id = #{id} </update> </mapper>
测试类：Test.java
package com.ssm.chapter4.test; import com.ssm.chapter4.domain.Book; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import java.io.IOException; import java.io.InputStream; public class Test { public static void main(String[] args) throws IOException { // 1. 初始化MyBatis String resource = "conf.xml"; InputStream is = Test.class.getClassLoader().getResourceAsStream(resource); SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is); SqlSession session = sessionFactory.openSession(); // 2. 查询操作 String statement = "com.ssm.chapter4.mapping.userMapper.getBook"; Book book = session.selectOne(statement, 1);//查询单条操作 System.out.println("查询结果: " + book); // 3. 增加操作 Book newBook = new Book(); newBook.setId(5); newBook.setBookname("大话数据结构"); newBook.setPrice(48.5f); session.insert("com.ssm.chapter4.mapping.userMapper.addBook", Book); session.commit(); // 必须提交事务 System.out.println("新增书本成功"); // 4. 删除操作 int deleteId = 3; session.delete("com.ssm.chapter4.mapping.userMapper.deleteBook", id); session.commit(); // 必须提交事务 System.out.println("删除ID=" + deleteId + "的书本"); // 5. 更新操作 Book updateBook = new Book(); updateBook.setId(2); updateBook.setBookname("新版计算机概念"); updateBook.setPrice(75.0f); session.update("com.ssm.chapter4.mapping.userMapper.updateBook", updateBook); session.commit(); // 必须提交事务 System.out.println("更新书本成功"); // 关闭会话 session.close(); } }
数据库初始化脚本
DROP DATABASE IF EXISTS mybatis; CREATE DATABASE mybatis; USE mybatis; CREATE TABLE users( id INT PRIMARY KEY AUTO_INCREMENT, bookname VARCHAR(20), price FLOAT ); INSERT INTO users(bookname, price) VALUES('数据库', 88.5), ('计算机概念', 68.2);
填空
第六章（2个）课本原话
一个完整的 JavaScript 实现应该由不同的三个部分组成：_______、_______ 和 BOM。 答案：ECMAScript、DOM 课本原话："一个完整的 JavaScript 实现应该由不同的三个部分组成：ECMAScript、DOM 和 BOM。"
原型对象上的所有属性和方法，都会被对象______所______。 答案：实例、共享 课本原话："原型对象上的所有属性和方法，都会被对象实例所共享。"
题干："原型链的基本思路是利用原型让一个______继承另一个______的属性和方法。" 标准答案：引用类型、引用类型
JSON
JSON 中的对象与 JavaScript 对象相比：一是没有______，二是没有末尾的______。 答案：声明变量、分号 课本原话："与 JavaScript 的对象相比，JSON 有两个地方不同：一是没有声明变量；二是没有末尾的分号，并且 JSON 中的对象的所有属性必须加双引号。"
JSON 数据结构可以解析为______的 JavaScript 对象，与 XML 数据结构要解析成______但从中提取数据极为麻烦相比，JSON 的优势更加明显。 答案：有用、DOM 文档 课本原话："JSON 数据结构可以解析为有用的 JavaScript 对象。与 XML 数据结构要解析成DOM 文档但从中提取数据极为麻烦相比，JSON 可以解析为 JavaScript 对象的优势更加明显。"
"JSON中的对象的所有属性必须加______。" 答案：双引号 依据：JSON章节6.4.1节明确定义（教材原文强制要求）
XHR
题干： "设置自定义请求头部必须在调用______之后、______之前。" 答案：open、send
GET 请求中，查询字符串的每个参数名称和值必须使用______进行编码，且名称和值之间用______分隔。 答案：encodeURIComponent()、& 课本原话："查询字符串中每个参数的名称和值都必须使用 encodeURIComponent() 进行编码...所有的名称和值都必须用 & 分隔开。"
HTML中5.3节常用标签（2个） 基础标签、格式标签、图像标签 链接标签、表单标签、框架标签
<form>标签的______属性用于定义一个URL，单击"提交"按钮时会向这个URL发送数据；______属性用于设置向actionURL发送数据的HTTP方法（默认值为get）。 答案：action、method 原文出处（5.3.5节表5.5）： "| action | 定义一个URL。单击"提交"按钮时，会向这个URL发送数据 | | method | 用于向actionURL发送数据的HTTP方法，默认值为get |
<img>标签的______属性说明图像的地址；______属性规定图像的替代文本。 答案：src、alt 原文出处（5.3.3节）： "① src 说明图像的地址。 ② alt 规定图像的替代文本。"
<a>标签的______属性表示链接的目标URL；当______属性值为"_blank"时，会打开新窗口。 答案： href、target 原文出处（5.3.4节）： "其 href 属性表示链接的目标URL，target 属性表示当target值为blank时打开的链接窗口为新窗口。"
基础标签部分
JavaScript和HTML的交互方式
在 HTML 文件中嵌入 JavaScript 需要使用______标签，并且可以通过<script>标签的不同属性决定调用方法。使用______属性能够引用存储在某个单独文件中的某段 JavaScript 代码；使用______属性则表示文档中的脚本语言是 JavaScript； 对于外部文件，文件应以______为扩展名。 答案：<script></script>；src；language；.js 或 js 原文出处（教材原话整合）： "在 HTML 文件中嵌入 JavaScript 需要使用<script></script>标签，并且可以通过<script>标签的不同属性决定调用方法。 使用src属性能够引用存储在某个单独文件中的某段 JavaScript 代码； 使用language属性则表示文档中的脚本语言是 JavaScript； 包含 JavaScript 源代码的文件应以js为扩展名。" （整合自以下原文片段：） 6.2节开头："在 HTML 文件中嵌入 JavaScript 需要使用<script></script>标签" 正文："如果使用 src 属性...引用存储在单独文件中的 JavaScript 代码" 正文："如果使用 language 属性...表示文档中的脚本语言是 JavaScript" 表6.1："src...文件应以.js 为扩展名"
"在HTML文件中嵌入JavaScript需要使用______标签（空1），并且可以通过<script>标签的______决定调用方法（空2）。如果使用src属性，则开发者能够引用存储在某个______中的JavaScript代码（空3），文件应以______为扩展名（空4）。" <script></script>；不同属性；单独文件；.js 第二张图首句："需要使用<script></script>标签"；第二张图："通过<script>标签的不同属性决定调用方法"； 第一张图："引用存储在某个单独文件中的某段JavaScript代码"； 第一张图表6.1："包含JavaScript源代码的文件...应以.js为扩展名"
如果使用 src 属性，则开发者能够引用存储在某个单独文件中的某段 JavaScript 代码，并将文件加载到单独的 Web 页面中。如果使用language 属性，则表示文档中的脚本语言是JavaScript，开发者可以直接在 HTML文档中编写 JavaScript 脚本程序。<script>标签的功能描述见表 6.1。
第一章1.3.2（2个空）
HTTP常用的两种请求方法是______方法和_______方法 答案：GET方法和POST方法
通过 GET 方法提交的数据会放在______之后，以"?"分割 URL 和传输数据；而 POST 方法则是把提交的数据放在______中。 答案：URL、HTTP 包的 Body 原文出处： "（1）通过 GET 方法提交的数据会放在 URL 之后，以“?”分割 URL 和传输数据... POST 方法则是把提交的数据放在 HTTP 包的 Body 中。"
GET 方法需要使用______来取得变量的值，而 POST 方法则可通过______来获取变量的值。 答案：Request.QueryString、Request.Form 原文出处： "（3）GET 方法需要使用 Request.QueryString 来取得变量的值，而 POST 方法则可通过 Request.Form 来获取变量的值。"
浮动主题