前言

第一部分html超文本标记语言：表单必考
第二部分JavaScript弱类型语言：document对象（事件和html5不考）
第三部分servlet：配置方法，生命周期，四大作用域，过滤器filter
第四部分jsp：三种指令标签，page作用域，request属性范围，session属性范围，了解隐式对象，知道mvc概念，重点掌握其优点（Java bean不考）
第五部分jstl：el表达式（jstl不考）
第六部分structs2：编写action文件，配置文件structs.xml，如何操作
第七部分spring：五个模块（重点ioc，自动生成类，减少函数依赖，aop需要了解但是不考），注解，配置，springmvc掌握工作流程
第八部分hibernate：（hibernate和mybatis都是orm，前者不需要sql语句，后者需要熟练使用sql语句）：持久化，orm（把对象和关系进行映射），不需要会用hibernate做项目，要知道宏观概念
第九部分mybatis：持久化，如何实现（建库建表，配置文件，映射（要会写映射查询语句））（一对一一对多动态sql不考）
第十部分ssm框架：开发步骤（写实体类entity，写mapper.xml，写mapper.java，services.java, controller.java）

选择题（30分，十五题，每题两分）
简答题（30分，六题，每题五分）
程序设计（40分，五题，每题8分）（前三题填空题，每题8分，四个空）（第一题是表单，第二题Servlet（数据获取），第三题structs框架，第四题spring（mvc：注解，调用），mybatis（ssm）

Javaee 学习

一、Html&CSS{::nomarkdown}{:/}

概念：
1. 超文本标记语言（本身是文字，呈现出来的最终效果超越了文本；由标签组成，每个标签有其固定的含义和确定的页面展示效果）
  不是编程语言，而是一种标记语言
2. 专业词汇：
  标签(tag)：由尖括号包围的关键词
  属性(attribute)：对标签特征进行设置的一种方式
  文本(text)：双标签中的文字
  元素(element)：开始标签+文本+结束标签
基础结构：
1. 文档声明
2. 根标签 html：之间的文本描述网页
3. 一级子标签：
  头标签 head：定义不直接展示在页面主体上，但又重要的内容（字符集、CSS 引入、Js 引入、其他）
  体标签 body：定义要展示到页面主体的内容
一些细节：
1. 有且仅有一个根标签
2. 双标签和单标签都要正确关闭
3. 标签可以嵌套但不能交叉嵌套
4. 注释（不能嵌套）：<!–
  –>
5. 属性必须有值，值必须加引号且 ht5中不区分单双引号，属性名和值相同时可以省略
6. 标签不严格区分大小写，但是不能混用
7. 不允许自定义标签名
常见标签：
1. 标题：h1-h6；
  段落：p
2. 换行：br、hr（带分割线）
3. 列表标签：
  列表标签：ol（有序）、ul（无序）
  列表项标签：li
4. 超链接标签：<a href=”” target=””>名称</a>
  href：定义要跳转的目标资源的地址：完整URL、相对路径、绝对路径
  target：定义目标资源的打开方式：
  _self（在当前窗口打开）、_blank（开启新窗口）
5. 图片标签：<img src=”” title=”” alt=”” />
  src：定义图片的路径
  title：定义鼠标悬停时提示的文字
  alt：定义图片加载失败时提示的文字
6. 表格：<table border=n width =x或x%></table>
  border：边框粗细；width：表格宽度（像素或百分比）
  1. 表头：thead
  2. 表体：tbody
  3. 表尾：tfoot
    1. tr：表中的一行；td：行中的单元格；th：自带加粗的行中的单元格
7. 表单：form，用于搜集不同类型的用户输入，两个关键属性为 action 和 method
  （action使用一个URL指定表单处理程序的位置；
  method 属性有两种值：get（默认）和post，分别对应servlet里的doGet和odPost方法）
  <form name=”” action=”例如html_form_action.asp” method=””>
  1. 输入：
    - 文本：<input type=”text’ name=”” />
    - 密码：<input type=”password” name-“” />
    - 单选按钮：<input type=”radio” name=”” value=”” />
    - 复选框：<input type=”checkbox” name=”” />
    - 按钮：<input type=”button” value=”” />
    - 下拉列表：<select>
    - 多行文本：<textarea>
      name 属性必须有，name 属性是 Servlet 中 request.getParamer(“name”)的 key；
  2. action 属性和确认按钮：<input type=”submit” value=”” />
Web 浏览器作用是读取 HTML 文档并以网页的形式显示出来，使用标签来解释页面的内容；浏览器按顺序阅读网页文件，对书写错误的标记不指出错误，且不停止解释执行过程
HTML 属性：为 HTML元素提供附加信息
1. id属性：HTML 全局属性，唯一，可作为链接锚
2. style 属性：用于改变 HTML 元素的样式
HTML事件：窗口事件、表单元素事件、键盘事件、鼠标事件

二、JavaScript{::nomarkdown}{:/}

概念：
1. 是一种弱类型语言（声明时不确定类型，赋值时才确定类型），基于对象和事件驱动的脚本语言；无需编译，只需解释就可以执行
2. 引入方式：
  - 内嵌式：一般放在 head 中，通过一对 script 标签定义脚本代码
  - 引入外部脚本文件：一般放在 head 中，通过一对 script 标签引入外部 js 文件
3. 基本语法：
  1. 变量、函数、运算符区分大小写
  2. 变量是弱类型的；
  3. 标识符：以字母、下划线或$开通，没有长度限制
  4. 五种原始数据类型：Number、String、Boolean、Undefined、Null
  5. 引用数据类型：Object（各种对象和数组）
  6. 类型存储位置。变量保存到栈内存中值与值之间独立存在；对象保存到堆内存中，两个变量保存同一个对象引用，修改一个影响另一个
  7. 变量声明：
    - 声明变量不需要定义类型，JS 是动态确定类型；
    - 声明方式为变量赋值和利用保留字var声明；
    - 变量可以重复声明
  8. 变量定义：
    - 省略关键词：定义的为全局变量，如何位置可以访问，不建议使用，如 num = 10;
    - 使用 var 关键词：无块级作用域，定义在块级作用域中的变量，外界也可以访问，如 var num = 10;
    - 使用let关键词：有块级作用域，如 let num = 10;
    - 使用 const 关键词：有块级作用域，为常量，如 const num = 10;
  9. 输出：
    - console.log(“输出内容”)：向控制台输出一个内容
    - alert(“输出内容)：控制浏览器弹出一个警告框
    - document.write(“输出内容”)：页面输出一个内容
  10. 运算符：
    - 算术：+ - * / % （/0结果为 Infinity；%0结果为 NaN）
    - 复合算数：++ – += *= /= %=
    - 关系：> < >= <= != ！== == ===（==值相同，===值和类型相同；!=与!==类似）
    - 逻辑：|| &&
    - 条件：
    - 位
  11. 流程控制：
    - 条件判断：if 中非空字符串为 true；switch
    - 循环语句：while、do…while、for
  12. 数组：
    1. 创建数组：
      - 利用数组字面量：var arr=[1,2,3];
      - 利用 new Array：
        new arr = new Array();
        new arr = new Array(3);
    2. 数组方法：
      - 数组末尾添加多个元素：arr.push(元素)
      - 数组末尾删除并返回最后一个数组：arr.pop();
      - 数组开头添加元素：arr.unshift(元素)；
      - 删除并返回数组第一个元素：arr.shift();
      - splice()：删除数组中的指定元素，并将删除的元素作为返回值返回
      - filter：
      - sort：
      - join：
      - forEach：
      - concat：
  13. 函数：函数定义放在XHTML文档的头部
    1. 函数的定义方式：
      - function add(a,b){
        return a+b;
        }
        函数无需定义返回值，可以直接返回
      - var add = function(a,b){return a+b;}
      - （不推荐）var add = new Function(‘a’,’b’,return a+b);
    2. 全局函数：
      - isNaN:检查某个值是否为数字
        -parseInt/parseFloat:解析字符串为整数/浮点数
4. 创建对象和修改对象：
  1. 对象一般通过 new 表达式进行创建
  2. 访问对象通过”对象.属性”的格式进行
  3. 对象字面量：使用对象字面量可以在创建对象时直接指定对象中的属性
    1
    2
    3
    4
    5
    6
    7
    var obj = {
    name:"尼克",
    age:"29",
    gender:"男",
    eat:function(foor){
    console.log(this.age+"岁"+this.name+"正在吃"+food)}
    }
    删除对象的属性：delete 对象.属性名
5. 浏览器对象BOM：
6. 文档对象模型DOM：提供与网页内容交互的方法和接口
  document对象标识整个网页的文档对象：
  - 获取页面元素的三种方式：
    1. 根据元素 id 值获取指定元素document.getElementById(idStr);
    2. 根据标签属性获取多个元素： document.getElementsByTagName(tagStr);
    3. 根据 class 属性获取多个元素：document.getElementsByClassName(classStr);
      (4. 根据 name 属性获取多个元素：document.getElementByName(nameStr);)
      两个读写属性：
      1. value：取/改表单输入框内容，如：
      1
      var name = document.getElementById("username").value;
      2. innerHTML：读写标签内部的文本（非表单），如：
      1
      2
      var str = document.getElementById("info").innerHTML;//所得为“你好”
      (<div id="info">你好</div>)
  - 输出：document.write();//页面输出一个内容
  - 获取表单：document.forms[][].value //所有表单的集合，再访问内部控件
7. 事件

三、Servlet{::nomarkdown}{:/}

概述：Servlet 是用Java编写的服务器端程序，主要功能在于交互式地浏览和修改数据，生成动态Web内容。
广义的 Servlet 是指任何实现了这个 Servlet 接口的类。
Servlet 可以获取请求并处理各种复杂的客户端请求,是一个普通的 Java Class，是 JavaWeb 开发中最重要的组件，唯一一个可以用来接收客户端请求，并对请求作出处理的组件，Java Class 要能够被称之为 Servlet，必须继承 javax.servlet.http.HttpServlet
创建 Servlet 步骤：
1. 新建 Java Class 文件，继承 javax.servlet.http.HttpServlet
2. 重写父类的 doGet 和 doPost 方法：
  - @Override
    protected void doGet(HttpServletRequest req,HttpServletResponse resp)throws ServletException,IOExceotion{}
  - @Override
    protected void doPost(HttpServletRequest req,HttpServletResponse resp)throws ServletException,IOException{}

配置 Servlet：Servlet 配置是为了告诉 Java Web 容器软件（Tomcat），什么类型的请求应该交给哪些Servlet处理，所有Servlet的配置都需要编写在web.xml

在 Web.xml 文件配置所有研发完毕的 Servlet 组件:

<!– 配置Servlet组件，告诉Tomcat Web容器，Servlet组件的名字和位置[全名（类名+包名）]
-->
<servlet>
    <servlet-name>起别名</servlet-name>
    <servlet-class>servlet类的完整路径</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>别名</servlet-name>
    <url-pattern>/别名</url-pattern>

注解

Servlet 获取数据：

获取表单数据：

1 2	String name = request.getParameter("Username");//对应一个输入 String[] hobbies = request.getParamerValues("hobbies");//对应多个输入

服务器内部传值：

1 2	requestsetAttribute("msg","OK"); request.getRequestPatcher("result.jsp").forward(request,response);//跳转页面

Servlet 生命周期：Servlet的运行过程与生命周期由 Servlet容器控制
1. 客户端发送请求后，服务器加载 Servlet
2. 服务器创建 Servlet 类的实例
3. 调用 Servlet 实例的 init（）方法
4. 收到请求
5. 调用 service（）方法
6. service（）方法处理请求并将输出结果返回客户端
7. Servlet 等待下一个请求或由服务器卸载
8. 有请求返回4，没有则 Servlet 在服务器调用 destroy（）方法后被卸载
Servlet 生命周期中的方法：
- init()方法：服务器构造 Servlet 实例后调用，执行 Servlet 初始化
- service()方法[doGet()][doPost()]：每次接受请求后执行，分析用户的请求，根据请求类型调用不同的处理方法
- destroy()方法：完成所有服务调用后，卸载 Servlet 时调用，释放获得的资源
Servlet 四大作用域
作用域：生命周期；用途
- pageContext:当前 JSP 页面;Jsp页面内使用
- request:一次请求内;请求转发传值
- session:浏览器一次会话内;登录、保存用户信息
- application:整个Web应用;全局变量、在线人数等
过滤器 filter：
1. 主要用于对用户请求进行预处理，以及对服务器响应进行后处理，可以认为是 Servlet 的一种‘加强版’
2. 三个方法：
  - init()：完成 filter 初始化
  - doFilter()：完成实际的过滤操作
  - destroy()：Serclet在销毁前调用，释放资源

四、JSP{::nomarkdown}{:/}

概述：
1. JSP 是一种动态网页技术标准，是指在 HTML 网页中嵌入 Java 脚本语言，然后由应用服务器中的 JSP 引擎编译和运行，之后将生成的整个页面返回给客户端
三种指令标签：JSP 指令用于告诉 JSP 引擎如何处理页面
1. page 指令：格式:<%@ page 属性=”” %> ：用于定义 JSP 页面的各种属性
  属性：
- contentType：设置输出类型和编码
- import：导入 Java 包(page 指令中唯一可以重复的属性)
- language：定义 JSP 页面使用的脚本语言
- isErrorPage：是否是错误界面
- session：是否需要使用内置的 session 对象
  如：
  1
  2
  <%@page contentType="text/html;charset=UTF-8" language="java" %>
  <%@page import="java.util.*" %>
1. include 指令：<%@ include file=””> ：用于包括转换阶段的一个文件，引入其他 JSP 页面
2. taglib 指令：<%@ taglib%> :声明一个在页面中使用的标签库，包含自定义操作
JSP 页面中的pageEncoding 和 contentype 两种属性的区别：
前者是 JSP 文件本身的编码，后者的charset是指服务器发送给客户端时的内容编码
JSP 要经历两次的“编码”：
1. 第一阶段是 JSP 编译成.java，根据pageEncoding 的设定读取 JSP，将其由指定的编码方案翻译成统一的 UTF-8 JAVA 源码（pageEncoding 设定错了或没有设定，出来中文乱码）
2. 由 javac 的 JAVA 源码至 java byteCode 的编译，用 UTF-8
3. Tomcat 载入和执行上一步来的 JAVA 二进制码，使用的是 contentType
隐式对象：由 JSP 规范提供，不用编写者实例化；通过 Web 容器实现和管理；所有 JSP 界面均可使用；只在脚本元素的表达式或代码段中才可使用
1. 输入输出对象：requset 对象、response 对象、out 对象
2. 通信控制对象：PageContext 对象、session 对象、application 对象
3. Servlet 对象：Page 对象、config 对象
4. 错误处理对象：exception 对象
四大作用域
1. pageScope：当前页面有效；当前页面打开到关闭这段时间
2. requestScope：当前请求中有效；HTTP 请求开始到结束这段时间
3. sessionScope：当前会话中有效；客户端浏览器开启 HTTP 会话到关闭浏览器这段时间（只要是与此用户相关的页面都可以访问）
4. applicationScope：在 WEB 应用程序中有效；服务器启动到停止这段时间
MVC 模式：MVC 将交互式应用分成模型(Model)、视图(View)和控制器(controller)
- 优点：耦合性低、代码重用性高、部署快、可维护性高、有利于软件工程化管理、灵活性和可控制性高、组件松耦合

五、JStl 与 EL 表达式{::nomarkdown}{:/}

EL 表达式：
1. 概述：用于实现 JSP 页面无脚本环境，用于替代表达式脚本，代表一个值，可以用于结果的显示，方便获取指定变量的值的同时，还可以自动类型转换
2. 基本语法格式：${}
  “.”称为点操作符，符号左边可以是对象，也可以是隐式对象，右边可以是对象属性，也可以是映射键
  操作数组使用[]，同时所有点操作符可以操作的对象都可以用其代替
3. 作用：EL 会自动从四个作用域按顺序查找变量：pageScope、requestScope、sessionScope、applicationScope(优先级从高到低)
  1. 直接写${name}会从四个作用域依次找，写作用域可以避免冲突：${requestScope.name}
  2. 获取对象属性：
    1. 取基本值：
      1
      2
      3
      4
      //Servlet 存值:
      request.setAttribute("name","Tom");
      //JSP 取值：
      ${requestScope.name}
    2. 取表单参数：
      1
      2
      3
      4
      //HTML 表单获取值并传值：
      <input type="text" name="name" />
      //JSP 取值
      ${param.name}

六、Struts{::nomarkdown}{:/}

MVC
1. 概念：MVC 是 Model（模型）-View（视图）-Controller（控制器）的缩写，是一种非常经典的软件设计模式

Struts：实现了 MVC 的各项特性，是一种非常典型的 MVC 框架

与 Struts2紧密相关的两个概念：
- Action：由开发人员编写的类，负责 Web 应用程序中实现页面跳转的具体逻辑
- Interceptor：拦截器是动态拦截 Action 时调用的对象

搭建 Struts2开发环境的步骤

创建 javaweb 工程
加入开发 Struts2 应用需要使用到的 jar 文件

在 web.xml 中加入 Struts MVC 框架启动配置：

<filter>
    filter-name>StrutsPrepareAndExecuteFilter</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>StrutsPrepareAndExecuteFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

创建 action 文件

//一个基本的 action 文件示例，如LoginAction：
public class LoginAction{
    private String username;
    private String password;
    //setter,Struts会自动注入表单获取的值
    public void setUsername(String username){
        this.username = username;
    }
    public void setPassword(String password){
        this.password = password;
    }
    //主方法execute，return 的内容与jsp 文件在 struts.xml 中result元素的 name 要一致
    public String execute(){
        if("admin".equals(username) && "123".equals(password)){
            return "success"
        }else{
            return "error"
        }
    }
}

编写 Struts2 的配置文件

<struts>
    <!--配置 package 元素：
        name 属性随便取
        namepace自己取但是会决定 url 路径：/项目名/namespace/xx.action；
        extends 固定写struts-default
    -->
    <package name="primer" namespace="/primer" extends="struts-default">
        <!--配置 action 元素：
            name属性随便取
            class属性填 Action 的完整类名
            method 默认 execute
        -->
        <action name="LoginAction" class="com.example.LoginAction"
            <!--配置 result 元素：
                name 属性与 Action 返回值一致
                type默认 dispatcher（JSP 转发）之间填要跳转的文件名.jsp    
            -->  
            <result name="success" type="dispatcher>/success.jsp</result>
            <result name="error" type="dispatcher">/error.jsp</result>
        </action>
    </package>
</struts>

创建 jsp 文件

七、Spring{::nomarkdown}{:/}

Spring：是个 java 企业级应用的开源开发框架，主要用来开发 Web 应用，是一个轻量级的控制反转（IOC）和面向切面（AOP）的容器框架

Spring 体系结构：

Core Container（核心容器）:

core 模块：通过框架的基本组成部分，包含 IOC 和依赖注入功能
Ioc：

IOC (控制反转):不是一种技术，是一种设计思想，将设计好的对象交给容器控制，而不是传统的在对象内部直接控制

            //正向  
            UserService service = new UserService();  
            //反转  
            @Autowired
            UserService service;
            ```  
            2. DI（依赖注入）: IOC 的另一种表述形式，即组件以一种预先定义好的方式（如 setter 方法）接受来自如容器的资源注入
            3. IOC 容器：负责对象的创建、初始化等一系列工作，**被创建或被管理的对象在 IOC 容器中统称为 Bean** 
                1. BeanFactory：IOC 容器的基本实现,主要功能是为依赖注入（DI）提供支持
                2. ApplicationContext：提供更多高级特性，是 BeanFactory 的子接口，几乎所有的应用场合都直接使用 ApplicationContext 而非底层的 BeanFactory  
                最常被使用的 ApplicationContext 接口实现：  
                    - FileSystemXmlApplicationContext：从 XML 文件中加载已被定义的 bean，需要提供给构造器 XML 文件的完整路径
                    - ClassPathXmlApplicationContext:从 XML 文件中加载已被定义的 bean，不需要提供 XML 的完整路径
        - Beans 模块：提供 BeanFactory
        - Context 模块：访问定义和配置的任何对象的媒介，ApplicationContext 接口是其重点
        - SpEL 模块：表达式语言
    2. Context
    3. AOP（面向切面编程）
    4. DAO（数据库访问层）
    5. Web 层
2. 配置 Bean：基于 xml 文件的像方式；基于注解的方式  
    1. 在 xml 文件中通过 bean 节点配 置 bean

1
2
3

2. 依赖注入：属性注入、构造器注入、工厂方法注入（很少使用不推荐）
    1. 属性注入：通过 setter 方法注入 Bean 的属性值或依赖的对象  
    属性注入使用&#60;property>元素，使用 name 属性指定 Bean 的属性名称，value 属性或&#60;value>子节点指定属性值

1 2	2. 构造方法注入：通过构造方法注入 Bean 的属性值或依赖的对象构造器注入在 <constructor-arg>元素李声明属性，其中没有 name 属性

1	3. 引用其他 Bean：通过<ref>元素或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用

```

Spring 常用注解：
- @Controller：声明控制器类；用于标记在一个类上，使用它标记的类就是一个 SpringMVC Controller 对象
- @RestController：控制器+JSON 返回；用于类或方法上，用来处理请求地址映射的注解
- @RequestMapping：URL映射
- @GetMapping/@PostMapping：HTTP 方法映射
- @RequestParam：获取请求参数
- @PathVariable：获取路径变量
- @RequestBody：映射 JSON 请求体
- @ResponseBody：返回 JSON 数据
- @Autowired：依赖注入
SpringMVC 工作流程：
1. 浏览器发送请求到 DispatcherServlet(前端控制器)
2. DispatcherServlet 找 HandlerMapping（处理器映射）
3. Controller（控制器）执行业务，返回视图名
4. ViewResolver（视图解析器）找到 JSP 页面
5. 渲染 JSP，返回给浏览器
  请求->前端控制器->处理器映射->控制器->模型和视图->视图解析器->视图->响应

八、Mybatis{::nomarkdown}{:/}

持久层：在系统逻辑层上，专注于实现数据持久化的一个相对独立的领域
一个完善的持久层：代码的可重用性高，能完成所有数据库的访问操作；支持多种数据库平台‘具有相对独立性。持久层的实现发生变化时，不影响上层的实现
持久化：
- 狭义：指将域对象永久保存至数据库
- 广义：包括与数据库相关的各种操作
  - 保存：将域对象永久保存至数据库中；
  - 更新：更新数据库中域对象的状态；
  - 删除：从数据库中删除一个域对象；
  - 加载：根据特定OID，将一个域对象从数据库加载至内存；
  - 查询：根据特定的查询条件，将符合查询条件的一个或多个域对象从数据库加载至内存
概念：MyBatis 是一个数据持久层（ORM）框架。把实体类和 SQL 语句之间建立了映射关系，是一种半自动化的 ORM 实现。
使用 MyBatis 操作数据库
1. 创建数据库和表
2. 配置文件
3. 映射

目录

前言