BFU-javaweb期末复习提纲（含期末原题，防挂必看）
全文PDF版本下载链接
servlet
知识点区分：
MVC 概念及结构
三层MVC结构
从服务器内部看：
- 控制器controller：描述文件之间的跳转
- 视图层viewer：浏览器端表现请求表单展现处理结果
- 模型层model：处理具体业务逻辑、存取数据库
开发部署一个servlet过程
- 服务器端建立编译servlet .java文件
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
//需要继承 javax.servlet.http.HttpServlet
public class HelloWorld1 extends HttpServlet {
//重写doGet方法，处理浏览器的请求
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException {
//指定输出的编码格式，输出中文
response.setCharacterEncoding("gbk");
PrintWriter out = response.getWriter();
out.println("Hello World1，你好");
}
}
- 配置服务器配置文件 web.xml
//服务器启动时默认打开的页面
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
• 注册Servlet，命名为HelloWorld1，建立注册名和java类的对应关系
<servlet>
<description></description>
<servlet-name>HelloWorld1</servlet-name>
<servlet-class>test.HelloWorld1</servlet-class>//此处应为完整类路径
</servlet>
• 建立URL名称和Servlet的对应关系
<servlet-mapping>
<servlet-name>HelloWorld1</servlet-name>
<url-pattern>/HelloWorld1</url-pattern>
</servlet-mapping>
注意xml文件中
- 严格区分大小写
- 先servlet 后mapping
- mapping中访问服务要用url模式
-
浏览器端请求该servlet
浏览器栏输入http://localhost:2008/ServletTest/Helloworld1
xml配置文件
在xml中进行如下参数的配置
<servlet>
<servlet-name>ServletTest</servlet-name>
<servlet-class>test. ServletTest</servlet-class>
<init-param>
<param-name>user</param-name>
<param-value>root</param-value>
</init-param>
</servlet>
定义了一个user为root，在servlet中进行如下的读取：
public void init(ServletConfig config) throws ServletException {
super.init(config);
String value=config.getInitParameter("user");
System.out.println(value);
}
上面的初始化参数只能由该包下的servlet读取，类似于局部变量，定义全局可以在xml进行如下配置：
<context-param>
<param-name>url</param-name>
<param-value>jdbc:mysql://127.0.0.1:3306/support</param-value>
</context-param>
在servlet中进行读取：
public void init(ServletConfig config) throws ServletException {
super.init(config);
String url=config.getServletContext(). getInitParameter("url");
System.out.println(url);
}
servlet生命周期
- servlet第一次被请求时，servlet容器建立实例，调用init方法，初始化仅此一次
- 客户端有请求时，容器自动组装 servletRequest 对象，产生servletResponse 对象，一起传递给servlet的service方法。其中request负责接受用户请求的数据，response负责响应用户，展现结果。
- 调用service方法处理业务逻辑，执行doget 和 dopost 方法。
- 不使用destroy方法进行释放
request 与 response 主要方法的用法
HTML表单提交的get以及post方法
客户端请求包括：请求行、头、数据体
服务器接收到请求后，返回HTTP响应每个响应：状态行、头、数据体：
常见状态
• 404 所请求的文件不存在
• 500 服务器程序出错
• 200 OK 成功
• 302 重定向
• 304 服务端执行了get，但文件未变化
• 数据体用于浏览器显示
HTML表单标记
标签不区分大小写
主标记：<form></form>
输入框类型：<input type=“”。。。。。>
• type 类型:
• text 文本
• passwowrd 口令方式
• checkbox 多选框 name相同
• radio 单选按钮 name相同
• image 图片
• hidden 隐藏表单 发送数据
• submit 提交按钮 向服务器提交表单
• reset 复位按钮 将表单充置为初始状态
• name 名称
• id 标识
• maxlength 最大字符数
• size 输入域宽度
• value 域的初始值
• button 按钮 用javascript响应
下拉框：<select> </select>：
参数：multiple可同时选取多行 name名称 size可见项目数
每个项目用<option>标记
selected表示初始被选中
多行文本域框：<textarea> </textarea>：
参数 ：cols宽度 rows高度 name名称
<form method="POST" action= " " enctype= " " >
method表单传输方法
• GET方法将表单信息在URL后传输
• POST方法将表单信息作为信息体传输
action为表单处理方式，通常为一个URL，可以是相对路径、绝对路径、servlet路径
enctype为编码方式
登录示例：
<form name="f1" id="f1" action="FormTest" method="get">
<table>
<tr>
<td>Login:</td>
<td><input type="text" name="login" id="login"></td>
</tr>
<tr>
<td>Password:</td>
<td><input type="password" name="password" id="password"></td>
</tr>
<tr>
<td colspan="2"><input type="submit" value="提交"></td>
</tr>
</table>
</form>
xml配置方式：
public class SimpleForm extends HttpServlet {
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException {
//指定输出的编码格式，输出中文
response.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=UTF-8");
String user=request.getParameter("login");
String pwd=request.getParameter("password");
PrintWriter out = response.getWriter();
out.println("用户 "+user+"，你好，你的密码是 :"+pwd);
}
}
get方法及post 方法：
地址、安全、数据量
地址：
两个方法都是请求另一个URL，并提交数据
• 使用Get请求时，需声明
<FORM ACTION= " http://localhost/ServletTest/HelloWorld1" >默认为Get方法
• 使用Post请求时，需声明
<FORM ACTION="http://localhost/ServletTest/HelloWorld1" METHOD="POST">
Get发送的数据和请求的地址一起显示在地址栏
http://localhost:8080/ServletTest/GetNameandSchool?name=wxy&school=bjfu
Post请求的数据会隐藏在请求报文的body部分在地址
http://localhost:8080/ServletTest/GetHelloForm
数据传输的保密性上
• Get方法弱
• Post方法强
数据传输的数量上
• Get方法弱，url之后不能多于256个字符
• Post方法强
JSP
JSP脚本元素、指令、标准动作
- jsp基本思想：
• Web页面大部分使用常规的HTML
• 用特殊的标签将servlet代码标记出来
• 每个JSP页面最终转换成servlet(仅执行一次)
• 请求页面时实际被调用的是servlet
-
JSP处理过程
- 客户浏览器给服务器发送一个HTTP请求；
- Web服务器识别出这是一个JSP网页的请求，并且将该请求传递给JSP引擎。通过使用URL或.jsp文件来完成；
- JSP引擎从磁盘中载入JSP文件，然后将它们转化为servlet。这种转化只是简单地将所有模板文本改用println()语句，并且将所有的JSP元素转化成Java代码；
- JSP引擎将servlet编译成可执行类，并且将原始请求传递给servlet引擎；
- Web服务器的某组件将会调用servlet引擎，然后载入并执行servlet类。在执行的过程中，servlet产生HTML格式的输出并将其内嵌与HTTP的response上交给Web服务器；
- Web服务器以静态HTML网页的形式将HTTP的response返回给浏览器；
- 最终，Web浏览器处理HTTP response中动态产生的HTML网页，就好像在处理静态网页一样；
-
脚本元素
- 声明变量<%! int i = 0; %> !代表全局变量 不使用！代表局部变量 - 表达式 <%= 表达式 %> - 定义函数 <%! 函数定义 %> - 代码段 <% 代码 %> - 注释 <%-- 注释 --%> 不发送客户端，只在jsp源文件看到 -
指令- 用来设置整个JSP页面相关的属性，如网页的编码方式和脚本语言
向当前页中插入一个文件的内容 <%@ include file="相对URL" %> 定义JSP页面的全局属性 <%@ page... ...%> page指令属性说明: 1．language="java" 声明脚本语言的种类，目前只能用"java"。 2. import="{package.class | package.* },..." 需要导入的Java包的列表，这些包作用于程序段，表达式，以及声明。多个包用逗号隔开。下面的包在JSP编译时已经导入了，所以就不需要再指明了： java.lang.* javax.servlet.* javax.servlet.jsp.*javax.servlet.http.* 3．errorPage="relativeURL" 设置处理异常事件的JSP文件。 4．isErrorPage="true | false" 设置此页是否为出错页，如果被设置为true, 就能使用exception对象 5. pageEncoding="gb2312" 设置编码是中文编码，显示中文不会出现乱码。网页默认的编码是ISO-8859-1 • “<%@ page %>”指令作用于整个JSP页面，包括静态的包含文件。但是不能作用于被动态包含进来的文件，比如通过“<jsp:include>”包含的文件。 • 可以在一个页面中用上多个“<%@ page %>”指令，但是其中的属性只能用一次，import属性例外，可以多用几次。 •“<%@ page %>”指令无论放在JSP的文件的哪个地方，它的作用范围都是整个JSP页面。建议把它放在JSP文件的顶部。 引入外部定制标签库taglib <%@ taglib ... ...%> -
标准动作
- forward 转发 <jsp:forward page=“绝对URL或相对URL" />
- include 引入动态页面 <jsp:include page= “相对URL" flush="true" /
include指令与include动作区别对比简答：
（1）<%@include%> ： ——3分
• 在翻译阶段（将JSP页面转换成servlet的阶段）读入指定的页面中的内容，并将这些内容和原来的页面融合在一起，是一种静态引入；
• 引入的页面可以只包含静态内容（例如HTML），也可以是一个普通的JSP页面。融合后的完整页面再被整体的转换为一个servlet。
• 主页和被引入的页面共享所有的页面作用域数据。
• include指令的一个常见用法是引入应用程序的所有页面都需要的公共声明。
• 文件在页面转换前插入到JSP页面中
• 文件能够含有影响整个页面的JSP内容（例如import语句，声明等）
• 被包含文件更改后，需要手动地更新使用它的页面。（因为已经静态生成了servlet）
（2）<jsp: include>： ——3分
• 指令用于在运行时引入另外的资源，是在请求处理阶段而不是在翻译阶段执行的，是一种动态引入；
• 并不是要引入指定页面的实际内容，它将引入执行该引入页面后所产生的应答，指定任何能够产生文本应答的web资源。
• 这些资源可以访问请求作用域内的所有对象，以及所有的请求参数。但不能访问任何页面作用域属性，或是在主页面中声明的脚本变量
• URL的输出在请求时被插入到JSP页面中
• 不能含有影响整个页面的JSP内容
• 被包含文件改变后不需更改使用它的页面
页面转发与重定向对比简答：
① 重定向的URL可以是任意地址，转发的URL只能在同一个Web应用内；
② 重定向后浏览器地址栏会发生改变，转发后浏览器地址栏不发生改变；
③ 重定向中浏览器向服务器发送了两次请求，转发只发送了一次请求；
④ 重定向可能会跳转到不同容器中，不能共享request里面的数据，转发是在同一个web容器中传递request，可以共享request里面的数据；
⑤ 重定向的两次跳转之间可能会发生信息丢失，转发两次跳转不会发生信息丢失。
JSP内置对象
• request，请求对象，服务器端接收从客户端传来的参数,该request对象封装了用户提交的信息，通过调用该对象相应方法可以获取封装的信息。
• response，响应对象，服务器对客户的请求做出动态的响应
• pageContext，页面上下文对象，用该对象可以访问页面中的共享数据。
• session，会话对象，服务器创建与销毁
• application，应用程序对象，存储在服务器端，如网站计数器，访问该网站所有用户共有的
• out，输出对象，向客户端输出数据
• config，配置对象，获得servlet初始化参数
• page，页面对象
• exception，例外对象
- session：服务器创建销毁
从一个客户打开浏览器并连接到服务器开始，到客户关闭浏览器离开这个服务器结束，被称为一个会话。
JavaBean
-
要求
必须具备空参的构造函数：显式定义这样一个构造函数或者省略类所有的构造函数即可
类变量必须是私有的：使用特定的存取函数对字段直接访问——属性
-
好处
可以封装表单各种元素的读取
便于表单各种元素在不同JSP和Servlet中共享
隐藏了Java语法
将请求参数与Java对象关联起来更加容易(bean属性)
使得在多个请求或servlets/JSP间共享对象得到简化
-
jsp中访问javaBean
• 创建Bean实例 <jsp:useBean…>
• <jsp:useBean id="beanName“ class="package.Class" />
• 读取Bean属性的值 <jsp:getProperty…>
• <jsp:getProperty name="beanName“ property="propertyName" />
• 设置Bean属性的值 <jsp:setProperty…>
• <jsp:setProperty name="name“ property="property“ value="value" />
• 把表单参数和Bean属性进行绑定 <jsp:setProperty…>
• <jsp:setProperty name="name" property="property " param=" param " />
Bean的作用域
- 作用域解释如下。
application：服务器启动到停止这段时间。
session：HTTP会话开始到结束这段时间。
request：HTTP请求开始到结束这段时间。
page：当前页面从打开到关闭这段时间。
在应用Bean时可以指明Bean的共享范围
• <jsp:useBean id="…" class="…" scope="…" />
• page----默认值
Bean只能应用在本JSP文件中
• application
Bean可以为同一Web应用中的所有用户共享
• session
Bean可以为用户访问会话过程所共享(不关闭浏览器窗口的情况下)，不同用户不能共享
• request
Bean只在当前请求过程中有效,请求过程可以连续跨越多个页面
jsp表单参数与javabean属性绑定
一次性把所有表单参数和Bean属性绑定
• <jsp:setProperty name=“name” property="*" />
• 前提条件是：表单参数名称和Bean属性名称要完全一致，大小写也要一致
jsp+servlet+bean的MVC实现
- 步骤
1. 定义用以表示数据的bean
2. 使用一个servlet处理请求
• servlet读取请求参数，检查数据的缺失或异常等
3. 填充bean
• 该servlet调用业务逻辑（与具体应用相关的代码）或数据访问代码得到最终的结果。得出的结果与bean绑定。
4. 将bean存储在request、session或servlet的上下文中,方便共享
• 该servlet调用请求、会话或servlet上下文对象的setAttribute存储bean。
5. 将请求转发到JSP页面
• 该servlet确定哪个JSP页面适合于处理当前的情形，并使用RequestDispatcher的forward方法将控制转移到那个页面。
6. 从bean中提取数据
• JSP页面使用jsp:useBean和与第4步匹配的位置访问之前存储的bean，然后使用jsp:getProperty输出bean的属性。
• JSP页面并不创建或修改bean；它只是提取并显示由servlet创建的数据。
- 处理示例
- schoolForm.jsp:表单提交给控制文件DoSchoolServlet.java
<FORM ACTION="DoSchoolServlet" method="post" >
- DoSchoolServlet.java
1. 设置请求的编码格式，以兼容中文
request.setCharacterEncoding("utf-8");
2. 读取用户请求
String n=request.getParameter("name");
3. 创建数据Bean实例，并设置Bean属性
SchoolBean schoolbean=new SchoolBean();
schoolbean.setName(n);
4. 存储Bean，目的是和其他文件共享该Bean
request.setAttribute("resultinfo", schoolbean);
5. 流程判断，以确定不同的转发结果地址
forwardUrl="/goodInfo.jsp";
6. 实现转发
RequestDispatcherdispatcher=request.getRequestDispatcher(forwardUrl);
dispatcher.forward(request, response);
页面的转发对客户来说是透明的。初始的Servlet的URL是浏览器唯一知道的URL。
错题：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HkiRvQY9-1647413956475)(C:\Users\Thinkpad\AppData\Roaming\Typora\typora-user-images\image-20220112190445674.png)]
JDBC
JDBC介绍
- 作用
JDBC本质上是一系列的应用程序接口(API)
通过JAVA语言访问任何结构化数据库
通过JDBC API写出的程序,能够将SQL语句发送到相应的任何一种数据库
由java.sql和javax.sql包组成
import java.sql.*;
import javax.sql.*;
简单地说，JDBC能完成下列三件事：
(1) 同一个数据库建立连接；
(2) 向数据库发送SQL语句；
(3) 处理数据库返回的结果。
用JDBC 连接数据库的步骤
- 注册驱动程序 (只做一次)
1. 放置JDBC包或配置ODBC
2. 在程序中加载驱动器——Class.forName(“数据库驱动器名称”)
不同数据库，驱动程序名称不同, 例如SQLServer
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
MySQL数据源
Class.forName("com.mysql.jdbc.Driver");
例如ODBC数据源
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
- 建立连接(Connection对象)
- 声明Connection对象
Connection conn=null;
- 通过驱动程序建立连接
方式1：
import java.sql.*;
import javax.sql.*;
conn = DriverManager.getConnection(url, user, password);
url格式：
JDBC:子协议:子名称: //主机IP地址:端口;数据库名;属性名=属性值; …
其他参数如：useUnicode=true&characterEncoding=GBK。
eg连接SQLserver:
String dburl="jdbc:sqlserver://localhost:1433;databaseName=txdatabase";
conn=DriverManager.getConnection(dburl, ”sa”，“123”);
eg连接MySQL:
String url="jdbc:mysql://localhost:3306/loginuser";
conn=DriverManager.getConnection(dburl, ”sa”, 123”);
方式2：
conn = DriverManager.getConnection(url);
此时，user,password用“属性名=属性值”方式放置在url字符串中或者表示没有用户名和密码
String dburl="jdbc:sqlserver://localhost:1433;databaseName=txdatabase;user=sa;password=123";
conn=DriverManager.getConnection(dburl);
-
创建命令对象(Statement/PreparedStatement对象)并执行SQL语句
statement对象：
Statement st = conn.createStatement();
st.executeQuery(sql语句);
preparedstatement对象：
import java.sql.*;
import javax.sql.*;
String sql = “select * from table_name where col_name=? ” ;
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, “col_value”);
ps.executeQuery();
例如：
String sql=“select * from bankaccount where bankid=? and balance>?”;
ps = conn.preparedStatement(sql);
ps.setString(1, userid);
ps.setInt(2, 100);
ps.executeQuery();
-
处理执行结果(ResultSet对象)
• 对查询的结果集进行读取 1. 获取Statement对象st执行查询的结果集 ResultSet rs = st.executeQuery(sql); 2. 获取PreparedStatement对象ps执行查询的结果集 ResultSet rs = ps.executeQuery(); • 依次处理结果集中的每条记录 While(rs.next()){ //获得当前记录中指定列名的数据 rs.getString(“col_name1”); rs.getInt(“col_name2”); //… } -
释放资源
-
释放ResultSet, Statement,Connection.
-
数据库连接（Connection）是非常稀有的资源，用完后必须马上释放，如果
Connection不能及时正确的关闭将导致系统宕机。Connection的使用原则是尽
量晚创建，尽量早的释放。 -
释放资源的函数
public static void dbClose(Connection conn, PreparedStatement ps,ResultSet rs) throws SQLException { rs.close(); ps.close(); conn.close(); }
查询结果集处理
插入更新删除
使用Statement对象执行不带参数的SQL语句
conn = getConnection();
Statement st = conn.createStatement();
String sql=“delete或insert或update语句”;
int i = st.executeUpdate(sql); //执行SQL语句
使用PreparedStatement对象执行带参数的SQL语句
conn = getConnection();
String sql=“delete或insert或update语句”;//参数用?代替
PreparedStatement ps = conn.prepareStatement(sql);//准备语句
ps.setString(1,username);//用变量username绑定Sql语句中的第1个参数
ps.setInt(2,age);//整型数据使用setInt
int i=ps.executeUpdate();//执行SQL语句
查询，返回查询结果集
使用Statement对象执行不带参数的SQL语句
conn = getConnection();
Statement st = conn.createStatement();
String sql=“select语句”;
ResultSet rs= st.executeQuery(sql); //执行SQL语句
使用PreparedStatement对象执行带参数的SQL语句
conn = getConnection();
String sql=“select语句”;//参数用?代替
PreparedStatement ps = conn.prepareStatement(sql);//准备语句
ps.setString(1,username);//用变量username绑定Sql语句中的第1个参数
ps.setInt(2,age);//整型数据使用setInt
ResultSet rs=ps.executeQuery();//执行SQL语句
MyBatis
MyBatis相对JDBC的优点
mybatis特点：
- 一个基于Java的持久层框架；
- 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索；
- 将接口和Java的POJOs（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。
mybatis主要思想：将程序中的大量sql语句剥离出来，配置在配置文件中，实现sql的灵活配置。
好处：将sql与程序代码分离，可以在不修改程序代码的情况下，直接在配置文件中修改sql。
mybatis与jdbc相比的优点：
- 优化获取和释放
解决了数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能的问题。
解决方法：统一从DataSource里面获取数据库连接，将DataSource的具体实现通过让用户配置来应对变化。在SqlMapConfig.xml中配置数据链接池，使用连接池管理数据库链接。 - SQL统一管理，对数据库进行存取操作
使用JDBC对数据库进行操作时，SQL查询语句分布在各个Java类中，可读性差，不利于维护，当我们修改Java类中的SQL语句时要重新进行编译。
Mybatis可以把SQL语句放在配置文件中统一进行管理，以后修改配置文件，也不需要重新编译部署。
解决方法：将Sql语句配置在XXXXmapper.xml文件中与java代码分离。 - 传入参数映射和生成动态SQL语句
在查询中可能需要根据一些属性进行组合查询，比如进行商品查询，可以根据商品名称进行查询，也可以根据发货地进行询，或者两者组合查询。如果使用JDBC进行查询，这样就需要写多条SQL语句，且无法灵活应对用户多变的查询需求。 - 能够对结果集进行映射
在使用JDBC进行查询时，返回一个结果集ResultSet, 要从结果集中取出结果封装为需要的类型。在Mybatis中可以设置将结果直接映射为自己需要的类型，比如：JavaBean对象、一个Map、一个List等等。
解决方法： Mybatis自动将sql执行结果映射至java对象，通过statement中的resultType定义输出结果的类型。
MyBatis基本配置文件及映射器基本使用方法
持久化类po：
package com.mybatis.po;
/**
*springtest数据库中user表的持久化类
*/
public class MyUser {
private Integer uid;//主键
private String uname;
private String usex;
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public String getUsex() {
return usex;
}
public void setUsex(String usex) {
this.usex = usex;
}
@Override
public String toString() {
return "User [uid=" + uid +",uname=" + uname + ",usex=" + usex +"]";
}
}
映射文件mapper：
<?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.mybatis.mapper.UserMapper">
根元素namespace属性，该属性值通常设置为“包名+SQL映射文件名”
<!-- 根据uid查询一个用户信息 -->
<select id="selectUserById" parameterType="Integer"
resultType="com.mybatis.po.MyUser">
select * from user where uid = #{uid}
</select>
<!-- 查询所有用户信息 -->
<select id="selectAllUser" resultType="com.mybatis.po.MyUser">
select * from user
</select>
<!-- 添加一个用户 ，#{uname}为com.mybatis.po.MyUser的属性值 -->
<insert id="addUser" parameterType="com.mybatis.po.MyUser">
insert into user (uname,usex) values(#{uname},#{usex})
</insert>
<!-- 修改一个用户 -->
<update id="updateUser" parameterType="com.mybatis.po.MyUser">
update user set uname =
#{uname},usex = #{usex} where uid = #{uid}
</update>
<!-- 删除一个用户 -->
<delete id="deleteUser" parameterType="Integer">
delete from user where uid = #{uid}
</delete>
</mapper>
核心配置文件mybatis-config.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>
<!-- 配置环境，Mybatis可以配置多个环境，default指向默认的环境id。每个SqlSessionFactory对应一个环境 -->
<environments default="development">
<environment id="development">
<!-- 使用JDBC的事务管理器transactionmanager
•JDBC – 这个配置直接简单使用了 JDBC 的提交和回滚设置。 它依赖于从数据源得 到的连接来管理事务范围。
•MANAGED – 这个配置几乎没做什么。它从来不提交或回滚一个连接。而它会让 容器来管理事务的整个生命周期(比如 Spring 或 JEE 应用服务器的上下文)
-->
<transactionManager type="JDBC"/>
<!-- datasource数据源
UNPOOLED – 这个数据源的实现是每次被请求时简单打开和关闭连接。
POOLED – 这是 JDBC 连接对象的数据源连接池的实现,用来避免创建新的连接实例时必要的初始连接和认证时间。这是一种当前 Web 应用程序用来快速响应请求很流行的方 法。
JNDI – 这个数据源的实现是为了使用如 Spring 或应用服务器这类的容器, 容器可以集中或在外部配置数据源,然后放置一个 JNDI 上下文的引用
-->
<dataSource type="POOLED">
<!-- MySQL数据库驱动 -->
<property name="driver" value="com.mysql.jdbc.Driver"/>
<!-- 连接数据库的URL -->
<property name="url" value="jdbc:mysql://localhost:3306/java web?characterEncoding=utf8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<mappers> mappers映射器
<!-- 映射文件的位置 -->
<mapper resource="com/mybatis/mapper/UserMapper.xml"/>
</mappers>
</configuration>
properties：
TypeAliases：
environments：
mappers：
需要告诉 MyBatis 到哪里去找到 SQL 映射语句。即告诉 MyBatis 到哪里去找映射文件。
映射器中resultMap的用法
id的值是唯一标识符；
parameterType接收一个Integer类型的参数并赋值给uid；
resultType（resultMap）返回一个MyUser类型的对象，结果集自动映射到MyUser属性。
insert特有属性：
keyProperty：将插入或更新操作时的返回值赋值给PO类的某个属性，通常会设置为主键对应的属性。如果是联合主键，可以在多个值之间用逗号隔开；
keyColumn：该属性用于设置第几列是主键，当主键列不是表中的第一列时需要设置。如果是联合主键时，可以在多个值之间用逗号隔开;
useGeneratedKeys：该属性将使MyBatis使用JDBC的getGeneratedKeys()方法获取由数据库内部生产的主键，如MySQL、SQL Server等自动递增的字段，其默认值为false。
#{}可以防止SQL注入
表名只能用${}
resultMap是MyBatis中最重要最强大的元素，使用resultMap可以解决两大问题：
- POJO属性名和表结构字段名不一致的问题（有些情况下也不是标准的驼峰格式）；
- 完成高级查询，比如一对一，一对多，多对多
<resultMap type="" id="">
<constructor><!-- 类在实例化时，用来注入结果到构造方法 -->
<idArg/><!-- ID参数，结果为ID -->
<arg/><!-- 注入到构造方法的一个普通结果 -->
</constructor>
<id/><!-- 用于表示哪个列是主键 -->
<result/><!-- 注入到字段或JavaBean属性的普通结果 -->
<association property=""/><!-- 用于一对一关联 -->
<collection property=""/><!-- 用于一对多、多对多关联 -->
<discriminator javaType=""><!-- 使用结果值来决定使用哪个结果映射 -->
<case value=“”/> <!-- 基于某些值的结果映射，也称鉴别器 -->
</discriminator>
</resultMap>
一对一关联查询及各种对应关系
通 过 元素的子元素 处理这种一对一级联关系 。 在元素中，通常使用以下属性。
property：指定映射到实体类的对象属性。
column： 指定表中对应的字段（即查询返回的列名）。
javaType：指定映射到实体对象属性的类型。
select： 指定引入嵌套查询的子SQL语句，该属性用于关联映射中的嵌套查询。
基于数据访问接口的数据查询
<!-- 配置数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url"value="jdbc:mysql://localhost:3306/ springtest?characterEncoding=utf8" />
<property name="username" value="root" />
<property name="password" value="root" />
</bean>
<!-- 配置MyBatis工厂，同时指定数据源，并与MyBatis完美整合 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!-- configLocation的属性值为MyBatis的核心配置文件 -->
<property name="configLocation" value="classpath:com/mybatis/mybatis-config.xml"/>
</bean>
使用Spring管理MyBatis的数据操作接口的方式有多种。其中，最常用最简洁的一种是基于MapperScannerConfigurer的整合。该方式需要在Spring的配置文件中加入以下内容：
<!--Mapper代理开发，使用Spring自动扫描MyBatis的接口并装配（Spring将指定包中所有被@Mapper注解标注的接口自动装配为MyBatis的映射接口） -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- mybatis-spring组件的扫描器。com.dao只需要接口（接口方法与SQL映射文件中相同）-->
<property name="basePackage" value="com.dao"/>
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
</bean>
错题：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jgZ7lmW3-1647413956482)(C:\Users\Thinkpad\AppData\Roaming\Typora\typora-user-images\image-20220112192131777.png)]
spring
Spring是一个控制反转（Ioc）和面向切面编程（AOP）的轻量级的容器，为软件开发提供全方位支持的应用程序框架。
依赖注入与控制反转概念
当某个Java对象（调用者，例如吃面包的人）需要调用另一个Java对象（被调用者，即被依赖对象，例如面包）时
传统编程模式会增加调用之间的耦合性，不利于后期代码维护。
在Spring框架：
对象的实例不再由调用者来创建，而是由Spring容器（例如面包店）来创建。
Spring容器负责控制程序之间的关系（例如面包店负责控制吃面包的人与面包的关系），而不是调用者的程序直接控制。这样控制权由调用者转移到Spring容器，控制权发生了反转，这就是控制反转。
从Spring容器角度来看，Spring容器负责将被依赖对象赋值给调用者的成员变量，相当于为调用者注入它所依赖的实例，这就是依赖注入。
实现IoC和DI的基础：Java的反射机制
Spring容器
• Spring容器是生成Bean实例的工厂，并管理容器中的Bean。
• 在基于Spring的JavaEE应用中，所有组件都被当成Bean处理，包括数据源，Hibernate的SessionFactory和事务管理器。
• 在 Spring 容器读取 Bean 配置创建 Bean 实例前, 必须对它进行实例化. 只有在容器实例化后, 才可以从 IOC 容器里获取 Bean 实例并使用.
Spring 提供了两种类型的 IOC 容器实现
• BeanFactory: IOC 容器的基本实现，是 Spring 框架的基础设施，面向 Spring本身；
• ApplicationContext: 提供了更多的高级特性. 是 BeanFactory 的子接口.ApplicationContext 面向使用 Spring 框架的开发者，几乎所有的应用场合都直接使用 ApplicationContext 而非底层的 BeanFactory
• 无论使用何种方式, 配置文件是相同的.
创建ApplicationContext接口实例通常有三种方法：
ClassPathXmlApplicationContext：从类路径下加载配置文件
FileSystemXmlApplicationContext: 从文件系统中加载配置文件
通过Web服务器实例化ApplicationContext容器
Spring 支持 3 种依赖注入的方式
• 构造方法注入
• 属性（setter）注入
• 工厂方法注入（很少使用，不推荐）
• Setter方法与构造方法注入的对比：
• setter注入的缺点是无法准确表达哪些属性是必须的，哪些是可选的；
• 构造方法注入的优势是通过构造强制依赖关系，不可能实例化不完全的或无法使用的bean
Bean的多种装配方式
- 基于XML的装配
- 基于注解的装配
- 自动装配
构造方法、属性
由前面可以知道Spring提供了两种基于XML配置的装配方式：
构造方法注入和属性setter方法注入。
注解装配（常见注解）
基于注解的装配——常见注解
Spring Bean的装配方式
（1） @Component ：描述Spring中的Bean，是一个泛化概念，仅仅表示一个组件，可以作用在任何层次；
（2） @Repository：描述数据访问dao层的Bean，功能与@Component相同；
（3） @Service：描述业务service层的Bean,功能与@Component相同；
（4） @Controller：描述控制web层的Bean，功能与@Component相同；
（5） @Autowired：用于标注属性变量，属性的set方法以及构造方法，配合对应的注解处理器完成Bean的自动配置，默认按照 Bean 的类型进行装配；
（6） @Resource：作用与@Autowired一样。其区别在于@Autowired默认按照Bean的类型装配，@Resource默认按照 Bean 的实例名称进行装配。@Resource中有两个重要属性：name和type，如果指定name，则按实例名称进行装配;如果指定type属性，则按 Bean类型进行装配；如果都不指定，则先按实例名称装配，若不能匹配，再按照Bean 类型进行装配;如果都无法匹配，则抛出异常NoSuchBeanDefinitionException；
（7） @Qualifier：与@Autowired注解配合使用，会将默认的按类型装配修改为按Bean 的实例名称装配， Bean 的实例名称由@Qualifier注解的参数指定。
引用值：
方式1：按照【类型】注入
@Autowired
方式2：按照【名称】注入1
@Autowired
@Qualifier(“名称”)
方式3：按照【名称】注入2
@Resource(“名称”)
代码示例
Spring Bean的作用域
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lEkES9Lc-1647413956483)(C:\Users\Thinkpad\AppData\Roaming\Typora\typora-user-images\image-20220111194620772.png)]
SpringAOP基本概念
面向切面编程
AOP基本原则：
在不增加代码的基础上增加新的功能
springMVC
Spring MVC与其他MVC的比较区别
Spring MVC核心组件
Spring MVC主要由DispatcherServlet、处理器映射、处理器(控制器)、视图解析器、视图组成
两个核心：
• 处理器映射（HandlerMapping）：选择使用哪个控制器来处理请求 ——在web.xml中声明
• 视图解析器（ ViewResolver ） ： 选 择 结 果 应 该 如 何 渲 染 —— 默认在servlet.xml中声明
视图解析器用法
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
id="internalResourceViewResolver">
<!-- 前缀 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 后缀 -->
<property name="suffix" value=".jsp" />
</bean>
springmvc工作原理
(1) Http请求：客户端请求提交到DispatcherServlet。
(2) 寻 找 处 理 器 ： 由 DispatcherServlet 控制器查询一个或多个HandlerMapping，找到处理请求的Controller。
(3) 调用处理器：DispatcherServlet将请求提交到Controller。
(4)(5)调用业务处理和返回结果：Controller调用业务逻辑处理后，返回ModelAndView。
(6)(7) 处 理 视 图 映 射 并 返 回 模 型 ： DispatcherServlet 查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图。
(8) Http响应：视图负责将结果显示到客户端。
5483
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
