目录
第60天 - - Servlet+jdbc、Request对象
1.EL表达式语言（Expression Language）
一.JSTL（JavaServer Pages Standard Tag Library）
3.var a = function(){} 与 function a(){}的区别
1.Maven工程有四个src，分开了正式编码与测试，它们不会冲突吗？
5.project.build.sourceEncoding
二.面向切面编程AOP（Aspect Object Pragramming）
3.通过ClassPathXmlApplicationContext接受变量与接口的区别
4.当一个对象的作用域是多实例时，在第二次获取该对象时，上一个对象是否被销毁。
1.为什么最终通知（After）总是在后置通知（AfterReturning）之后。
2. classpath*:config/jdbc.properties中冒号前部分什么意思？
4. SqlSessionFactoryBean与SqlSessionFactoryBuilder区别
第98天 - - Spring+MyBatis+Ajax：静态原型
2.日期格式的设置（不使用注解，需要一个JsonValueProcessor实现类）
2.@ResponseBody注解与ResponseEntity类
第102天 - - SpringBoot+thymeleaf
1.在template文件夹中创建html文件，会自动创建至webapp中
第103天 - - 知识整合：SpringBoot+MyBatis+BootStrap+Jquery+Thymeleaf
1.在控制中的方法参数上添加@RequestBody之后，无法访问
6.控制器方法参数为两个对象时，url传递不同对象的属性。会自动封装吗？
第58天 - - Servlet
一.目标
1.Tomcat
2.Web工程创建
3.Serverlet
二.知识点
1.Tomcat
1.目录
2.backup->server.xml 配置字符编码
3.一般项目路径结构图
|-- webapp #站点根目录（war可视为webapp压缩包）
|-- META-INF #META-INF（存放工程、元文件信息。自动生成）
| -- MANIFEST.MF # 配置清单文件
|-- WEB-INF # WEB-INF 目录（安全目录，客户端无法访问）
| |-- classes # class文件目录
| | |-- *.class # 程序需要的 class 文件
| | `-- *.xml # 程序需要的 xml 文件
| |-- lib # 库文件夹
| | `-- *.jar # 程序需要的 jar 包
| `-- web.xml # Web应用程序的部署描述文件
|-- <userdir> # 自定义的目录
|-- <userfiles> # 自定义的资源文件
2.Web工程创建
3.Servlet
1.Servlet：
Server Applet（服务器端应用程序）
2.Servlet使用
步骤：
1.定义一个类继承HttpServlet类
2.在该类上加上@WebServlet(value="监听的路径")注释
//当指定路径超链接跳转，则触发相应的方法（doGet、doPost）
N.扩展
1.Tomact与Apache
Tomact虽然是由Apache开发，但是不能将Tomact和Apache HTTP服务器混淆。
Apache：为HTML页面服务。
Tomcat：运行JSP页面和Servlet。
1.Tomcat是Apache服务器的扩展（Servlet容器）
2.运行Tomcat时，作为一个与Apache独立的进程单独运行
2.404、500、505
404：找不到网页（路径只输入文件夹时，只会默认执行index.html）
500：内部服务器错误。
505：HTTP版本不受支持
……
4.Tomact启动时的JVM_BIND
服务器端口被占用
5.JSP与HTML的区别
HTML：
1.HyperText Markup Language（文本标记语言），静态web页面。
2.解释性语言，不需指定编译工具。
3.请求直接交给Web服务器处理。
4.没有<% %>
JSP：（属于servlet的一个变种，可实现所有html任务）
1.Java Server Page（Java服务端页面），动态web页面。
2.需要经过JDK编译后把内容发给客户端显示。
3.先由Web服务器处理，转交WEB Container（Web容器）从数据库取出数据。
4.使用<% %>就可以写Java代码,可逻辑控制页面。
缺点：
1.增大服务器压力。
2.前、后端未脱离，拖慢开发进度。
3.依赖java运行环境。
4.复用性较低。
第59天 - - Servlet请求、响应处理
一.目标
1.Servlet生命周期
2.Servlet方法使用
3.Servlet请求处理
二.知识点
1.Servlet版本（服务器端应用程序）
Tomact：JavaWeb服务器（容器）
版本：
2.5：servlet配置方式只支持xml配置方式
3.0开始：新增注解配置方式（简化xml配置方式）（还是保留xml配置）。
2.Servlet生命周期
1.实例化servlet
2.调用init方法初始化servlet（创建请求、响应对象）
3.调用service方法（传递请求、响应对象作为参数）
4.service()激活doGet或doPost方法（或其他方法）完成请求、响应对象的处理。
5.调用destroy方法销毁servlet。
更多客户端请求，Server创建新的请求和响应对象，但不在调用init()（一般Servlet只初始化一次（只有一个对象））。Server不需要Servlet（关闭）时，调用destory()。
3.web工程执行流程
1.启动服务器（部署工程）
2.请求到达程序中首先进入web.xml文件
3.分为XML配置与注解配置（注解更简便）
基于xml配置：
在xml文件获得请求的访问地址（servlet地址）
基于注解：
服务器再启动程序的时候就完成servlet地址配置
4.进入servlet完成请求处理（接着就是执行Servlet生命周期）
4.Servlet实现
步骤：
1.编写一个类继承HttpServlet
2.重写doGet和doPost方法
3.在对应的方法中添加请求处理功能
5.Servlet请求、响应对象处理
request请求对象处理：（HttpServletRequest）
在servlet中获得浏览器发送到服务器的请求信息（该对象保存了用户、浏览器数据等各种信息）
请求数据获取（web页面name属性）：请求对象.getPatameter("属性名");
response响应对象处理：（HttpServletResponse）
提供了两个响应流：（不能同时使用两个流）
PrintWriter out = response.getWriter()：获取字符流。
ServletOutputStream out = response.getOutputStream()：获取字节流
编码处理：
N.扩展
1.servlet的配置
xml方式：
1.配置服务器应用程序类所在地址（路径）
<servlet>
<servlet-name>该配置名字</servlet-name>
<servlet-class>需要访问的类路径</servlet-class>
</servlet>
2.配置映射
<servlet-mapping>
<servlet-name>服务器配置名字（关联）</servlet-name>
<url-pattern>超链接、form表单的连接地址</url-pattern>
</servlet-mapping>
注解方式：
使用@WebServlet注解进行配置。（不需要再在web.xml中配置该Servlet）
常用属性：
asyncSupported： boolean 指定servlet是否支持异步操作模式。
displayName： String 指定Servlet显示名称。
initParams： WebInitParam[] 配置初始化参数
loadOnStartup： int
标记容器是否在应用启动时就加载这个Servlet。默认不配置或数值为负数：表示客户端第一次请求Servlet时再加载；0或正数，表示启动应用就加载。（数值越小，优先级越高）
name： String 指定Servlet名称。
通过getServletName()可获取Servlet名。（不指定则为完整类名）
urlPatterns/value String[] 两个属性作用相同。配置映射
常用规则：
/* 或 /：拦截所有。
*.do：拦截指定后缀。
/user/test：拦截路径。
（非法（启动会报错）：/user/*.do、/*.do、test*.do）
注意：
1.使用注解配置时，<web-app></web-app>根元素中不能配置属性metadata-complete="true"（通知Web容器是否寻找注解，默认false（扫描注解）），否则无法加载Servlet。
2.注解配置了Servlet，那么web.xml中不能再配置相同映射的Servlet。
第60天 - - Servlet+jdbc、Request对象
一.目标
1.Servlet+jdbc
2.Request对象
3.作用域
4.会话
二.知识点
1.Servlet+JDBC
步骤：
1.导入jar包到WEB-INF/lib中
2.创建工程包结构
bean
servlet
conf
dao（因为servlet不能有太多的非逻辑操作）
xxxDao：（接口：声明规范实现类需要实现的方法）
impl：（在impl包下，拥有实现类）
xxxDaoImpl：（实现类：实现连接数据库操作，满足需求）
util
2.Request、Response对象
跳转方式：
1.请求转发（默认）
请求转发会产生请求传递现象，所以地址栏中会保存原有的请求路径。
语法：
请求对象.getRequestDispatcher(网页或servlet地址).forward(请求对象,响应对象); //适用查询
2.重定向（避免了重复提交）
而重定向会将地址栏信息重新指定到一个新的地址，避免重复提交的现象
语法：
响应对象.sendRedirect(网页或servlet地址); //适用增、删、改
3.作用域
1.request作用域：两者之间（转发的可以传递，重定向的不可以）
2.Session作用域：在一次浏览器访问，或限定时间有效
3.Application作用域：服务器对象，在tomcat启动时有效
4.Page作用域：只有该页面有用
……（共八种）
方法：
setAttribute()：绑定数据到相应对象中
4.会话
在一次浏览器使用过程中所实现的数据传递方式。（默认存储时间30分钟，关闭浏览器则清空会话）
对象：（通过请求对象获取会话）
HttpSession session = 请求对象.getSession();
N.扩展
1.保存web项目，自动更新
底部菜单栏：Project->Build Automatically。（选中，每次保存Tomact则会进行自动刷新）
2.序列化的相关问题
1.为什么实体类要实现serializable接口
实现序列化接口之后，对象可以变成字节流写入文件或在网络上传输
2.一般实现了序列化接口的类都需要定义静态常量：serialVersionUID。为什么。
初步了解：序列化时为了保持版本兼容性（版本升级时反序列化仍保持对象的唯一性）
第61天 - - Session、Cookie
一.目标
1.Session（会话）
2.Cookie
二.知识点
1.会话
1.会话（通过请求创建）
在web程序中用于保存数据操作，数据有效范围在一次浏览器操作过程中、默认存储时间为1800秒有效
2.会话实现
当浏览器对服务器产生请求后，会话就随之产生了。（随着请求而产生）
1.HttpSession s = request.getSession();
2.s.setAttribute(key,value); 数据绑定（key-value键值对存储）
3.s.getAttribute(key); 数据获取（key通过键获取）
3.Session方法
ID： getId()
是否创建： isNew()（在请求时就已经创建，所以是false）
创建时间： getCreationTime();
最后访问时间： getLastAccessedTime();
有效时间： getMaxInactiveInterval();
设置有效时间： setMaxInactiveInterval(int);（秒）
2.Cookie（本地存储，通过响应对象创建）
Response向客户端浏览器颁发一个Cookie，客户端将Cookie存储在本地，在下次请求时把请求的网址与Cookie一起提交给服务器。
语法：（不支持中文）
设置Cookie：
1.value只能传具体的值（不能是object）。
2.value不支持中文，使用字符转换器（将该utf-8字符转为unicode编码）
Cookie ck = new Cookie(ket,URLEncoder.encode(value,"utf-8"));
设值Cookie有效时间：（0：删除、负数：浏览器关闭）
sk.setMaxAge(秒);
通过响应对象，保存Cookie至浏览器
resp.addCookie(ck);
获取：（通过请求request获得）（只传递了key与value）
Cookie[] cks = req.getCookies(); //之后通过循环遍历所有cookie
通过方法转换URL码
URLDecoder.decoder(cokValue,"utf-8"); //将unicode转为utf-8
N.扩展
1.空字符串内容比较
"".equals(空的对象); //因为空的对象是不能调用方法的
第62天 - - JSP
一.目标
1.了解JSP
2.掌握JSP执行原理
3.掌握JSP核心组件
二.知识点
1.JSP
Java Server Pages（Java服务器页面），根本是简化的Servlet设计。动态网页技术，可在传统HTML文件中插入Java程序和JSP标记（tag），从而形成JSP文件。
相关（相似）：*.php、*.asp、*.htm、*.xhtml、…
2.JSP执行原理（内置对象）
PageContext pageContext：
取得JSP页面的任何范围的参数（out、reponse…），JSP页面可直接使用。
HttpSession session：会话，作用域为客户浏览器开启至关闭（可设置时间）
ServletContext application：服务器对象，所有用户共享该对象
ServletConfig config：服务器配置信息
JspWriter out：管理输出缓冲区（输出完毕，需及时关闭）
Object page：JSP本身，在JSP页面内才合法，类似java中的this
HttpServletRequest request：请求，作用域为一次请求
HttpServletResponse response：响应，作用域为该JSP页面
Throwable exception：针对错误网页，捕捉一般网页中未捕捉的异常。
3.JSP核心组件
a.JSP指令：（控制JSP编译器如何去生成servlet）
包含指令：（把另一个文件完全包含入当前文件中（就象粘贴））
<%@ include file="somefile.jsp"%>
页面指令：
<%@ page language="java" contentType="text/html;charset=utf-8" pageEncoding="utf-8" import="java.util.*,java.io.*"%>
import：导包（可有多个）
contentType：规定生成内容的类型。
标签库指令：
<%@ taglib prefix="myprefix" uri="taglib/mytag.tld"%>
b.jsp脚本
声明标签语法：（Java Servlet类体重放入一个变量）
<%! int serverinstanceVariable = 1;%>
脚本标签语法：
<% java代码 %>
表达式标签语法：（在网页中输出内容。简化了out（输出流）的作用）
<%=值 %>
第63天 - - EL表达式
一.目标
1.了解EL表达式
二.知识点
1.EL表达式语言（Expression Language）
a.作用：
1.简化JSP表达式
2.自动转变类型
如果字符串为数字，与int型相加，则会自动转换：${"30"+10} //为40
3.只能通过内置对象取值（只读）
b.语法：
${表达式}
运算符：（存取数据）
“.”：
1.一般情况等同于“[]”运算符
${sessionScope.user.sex} 等于 ${sessionScope.user["sex"]}
“[ ]”：
1.属性命中包含特殊字符时，需使用该运算符
${user["My-Name"]}
2.可以动态获取变量的值。（“.”运算符不可以）
${sessionScope.user[data]} //传入变量
c.内置对象：（在后面加上Scope）
按获取变量优先级排序：（与范围有关）
pageScope 、requestScope、sessionScope、applicationScope
EL隐含对象11个
servletContext PageContext：表示此JSP的PageContext
pageScope：相当于pageContext.getAttribute("xxx");
requestScope：相当于request.getAttribute("xxx");
sessionScope：相当于session.getAttribute("xxx");
applicationScope：相当于application.getAttribute("xxx");
param：是Map，适用于单值参数。request.getParameter("xxx");
paramValues：是Map，多值参数。request.getParameterValues("xxx");
header：是Map，对应请求头。request.getHeader("");
headerValues：是Map，多个头值。request.getHeaders("");
cookie：是Map获取cookie。${cookie.JSESSIONID.value}
initParam：获取web.xml中<context-param>内的参数。$(initParam.xxx)
如同ServletContext.getInitParameter(String name);通过键获得值。
pageContext：可以获得JSP九大内置对象。${pageContext.request}
d.例：
先假定有名为n的session
JSP表达式方式：
<%
String str = (String)reg.getSession().getAttribute("n");
%>
<%=str %>
EL表达式：
session中保存的内容：${sessionScope.n}
第64天 - - JSTL
一.JSTL（JavaServer Pages Standard Tag Library）
1.作用：
a.JSP标准标签库
b.对EL表达式的扩展（JSTL依赖EL）
c.标签语言（不属于内置标签，需要导包）
d.万物皆对象，JSP中的标签也是对象
2.JSTL标签库：
core：核心标签库（重点）
fmt：格式化标签库
sql：数据库标签库（过时）
xml：XML标签库（过时）
3.JSTL实现步骤：
a.导入jar包库
b.在jsp中添加jstl的配置（头page下面）
通过头实现引入
<% tarlib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> //核心库
uri：标签库的路径（不一定真实存在的网址，但是可以让JSP找到标签库）
prefix：标签的前缀名称（一般都是用“c”）
suffix：后缀
二.JSTL常用标签（结合EL表达式语言使用）
1.core：（核心库：4种类型，共13个标签）
表达式控制标签：out、set、remove、catch
流程控制标签：if、choose、when、otherwise
循环标签：forEach、forTokens
URL操作标签：import、url、redirect
<c:choose>
例：（相当于if…else…）
<c:choose>
<c:when test="${1==1}">
真的结果
</c:when>
<c:otherwise>
假的结果
</c:otherwise>
</c:choose>
<c:if>
例：
<c:if test="${条件表达式}">（EL表达式：算出true或false）
条件成立执行的代码
</c:if>
属性：test（相当于if的“()”括号）
<c:forEach>
迭代标签：（可实现：for循环、foreach）
例：（for普通循环输出1-5的数）
<c:forEach begin="1" end="5" var="a">
${a}
</c:forEach>
（加上items，foreach遍历集合）（变量直接获得属性名，而不是方法）
<c:forEach var="u" items="list">
用户名：${u.name} 密码：${u.pwd}
</c:forEach>
属性：
begin：开始的值
end：结束的值
var：变量
items：集合
varStatus：获取循环状态，例：varStatus="vs"
count：int，遍历的个数
index：int，索引
first：boolean，是否第一个元素
last：boolean，是否最后一个元素
current：object，当前项目
<c:out>
完成界面中输出数据。（与EL表达式一样（更麻烦））
例：
<c:out value="${a}"></c:out>
属性：
value：输出的内容
default：当value中的之不存在时，输出default中的值
<c:set>
在界面中定义变量
例：
<c:set property="" var="" value=""/>
属性：
property\var：定义变量名称（普通变量）。类型\变量（对象类型）
value：值
scope：指定定义变量的对象（默认pageContext）
2.fmt：（格式化库）
1.导入格式化标签库
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
2.格式化标签
<fmt:formatDate>：格式化时间
<fmt:formatDate value="${时间对象}" pattern="yyyy-MM-dd HH:mm:ss">
<fmt:formatNumber>：格式化数字
<fmt:formatNumber value="${数字}" pattern="0.00">
N.疑问
1.URL与URI的区别
URL：统一资源定位器（Uniform Resource Locator）
强调的是给资源定位，包含的信息更多。（用地址标记了网络资源，同时给出了地址）
URI：统一资源标识符（Uniform Resource Identifier）
强调的是给资源命名。（只是标记一个网络资源）
第65天 - - 监听器、过滤器
一.Servlet过滤器（Filter）
用户在访问某个目标资源之前，对访问的请求和响应进行拦截。实现URL级别的权限访问控制、过滤敏感词汇，压缩响应信息等。（属于tomact服务器提供）
1.原理：
a.web服务器在调用web资源的service方法之前，都会先调用Filter的doFilter()。
b.所以再调用目标代码之前，让一段代码执行：
调用目标资源：
使用filterChain对象的doFilter()，使web服务器调用service()（通过过滤）。
否则将会拦截该次请求（不访问资源）。
2.步骤：
a.编写Java类，实现Filter接口（javax.servlet.Filter）
b.重写初始化init()、执行（过滤）doFilter()、销毁方法destory()。
c.在过滤方法（doFilter）之中，设定规则。
过滤非静态页面请求：
a.将请求对象（ServletRequest）强转为HttpServletRequest
b.获得请求对象的统一资源定位符。（结尾为.html或demo/则不拦截）
c.通过filterChain对象doFilter()方法，跳转至请求的地址。
d.过滤器配置（与Servlet配置类似）
<url-pattern>/*</url-pattern> //过滤所有
<url-pattern>/vip/*</url-pattern> //过滤指定文件夹
<url-pattern>login</url-pattern> //过滤指定文件、servlet
过滤网：
多个过滤器，按上下顺序执行。
<dispatcher></dispatcher>：指定Filter对调用资源的方式进行拦截。
REQUEST：通过RequestDispatcher的include()或forward()，则不调用过滤。
INCLUDE：通过RequestDispatcher的include()，调用过滤。
FORWARD：通过RequestDispatcher的forward()，调用过滤。
ERROR：通过声明异常处理机制调用时，调用过滤。
二.监听器（Listener）
监听某些对象的动作，做出相应的响应处理。常用与统计在线人数和在线用户。
1.监听的事件
对象的创建和销毁监听器
对象中属性的创建、消除、改变监听器
session中的某个对象的状态变化的监听器
2.监听的内置对象：
ServletContext对象监听器：ServletContextListener
contextDestroyed(ServletContextEvent e)
contextInitialized(ServletContextEvent e)
HttpSession对象监听器：HttpSessionListener
sessionCreated(HttpSessionEvent e)、sessionDestroyed(HtpSessionEvent e)
ServletRequest对象监听器：ServletRequestListener
（属性的监听只需加上Attribute，例：ServletRequestAttributeListener）
3.配置：（不需要配置url，因为是监听后执行操作）
<listener>
<listener-class>Listener路径</listener-class>
</listener>
N.扩展
1.session的销毁
session属于服务器对象。浏览器关闭时，服务器是不知道的，所以无法销毁session，只能等待session的失效时间。
关闭浏览器时，会删除cookie，进程（内存）中cookie保存了session的id。所以下次打开浏览器时，session无法找打上次的id，就会新建一个session。而上一个session对象还是存在进程中。
2.热重启
服务器重启时，将用户数据备份
3.过滤器、监听器、拦截器
第66天 - - 分页
一.Oracle数据库分页
1.关键字
oracle无法使用limit分页。
添加伪列：（rownum）
伪列只能where查询小于等于的，所以先将所有数据添加伪列，再将包含伪列的结果集再次查询：（第2页，每页5条数据）
select * from (select empno,ename,job,sal,rownum r from EMP) where r>(2-1)*5 and r<(2*5)+1;
2.思路
a.添加伪列，查询数据库数据。
b.根据页数、每页显示数据的数量，查询出结果集。
c.将结果集封装至实体对象集合中，再存储于request对象中。
d.在动态页面遍历实体对象集合。
dao中需要得出的数据：数据库所有数据数量、根据页数得到相应的结果集。
服务器中应该接收：当前页数、下次跳转的页数。
二.MySql分页
1.获得数据库需要查询的数据总行数（计算共有多少页）
count()：select count(*) from users
2.通过limit函数分页查询数据
limit：select * from users limit pageNo,rowsCount
三.前端分页
1.将数据库数据全部查询出来
2.之后通过jsp表达式、el、jstl等动态的显示
不足：
1.数据是死的，数据库变动之后网页无法及时的变动
2.只是一种伪分页、障眼法，数据过多会导致页面卡顿
N.扩展
1.数据库驱动的加载
将数据库驱动包直接放在Tomact的lib文件夹下，创建工程时会直接将该驱动加载。
第67天 - - JQuery
一.JQuery
1.简介：
a.快速、简洁的JavaScript框架。封装JavaScript常用的功能代码。
b.独特链式语法、清晰的多功能接口、灵活的css选择器。
2.配置步骤：
a.在网页中引入框架库（js文件引入到工程，1.4.2版本（较成熟））。
b.网页中通过标签加载js库
<script type="text/javascript" src="路径"></script>
3.JQuery语法
<script>
//JQuery编辑操作开始 - - 入口
$(document).ready(function(){
$(selector).action()//基础语法
alert("Hello World");//也可使用原js脚本
});
//简化
$({
jquery脚本
});
</script>
美元符号（$）：定义JQuery
选择器（selector）：“查询”、“查找”HTML元素
action()：执行对元素的操作
二.JQuery内置功能
1.核心：（孰轻孰重，属于前端的东西）
2.选择器：
a.元素选择器：
html选择器：$(html标签) 如：$("p")
id选择器：$(id名称) 如：$("#id")
class选择器：$(class名称 ) 如：$(".class")
本对象：$(this)
指定1：$("p#demo")//id="demo"的<p>元素
指定2：$("ul li:first")//每个<ul>的第一个li元素
指定3：$("div#intro .head")//id="intro"的<div>中所有class="head"的元素
b.属性选择器：
$("[href]")：选取带有href属性的元素
$("[href='#']")：选取href值等于"#"的元素
!=（不等于）、$=（以什么结尾）
3.事件：（监听）
JQuery是为事件处理特别设计的。
$(document).ready(function)：单文档完成加载时
$(selector).click(function)：绑定元素点击事件
$(selector).dblclick(function)：双击事件
$(selector).focus(function)：获得焦点事件
$(selector).mouseover(function)：鼠标悬停事件
4.dom操作
a.设置、获取（方法的回调函数：参1：当前元素下标，参2：原值（初值））
val()：该元素的值（value）
html()：该标签html内容（包括HTML标记）
text()：文本内容
attr()：值：attr("属性","值")。多个设置使用：attr({"属性":"值","属性":"值"})
b.添加、删除
append()：结尾插入内容
prepend()：开头插入内容
after()：元素之后插入内容
before()：元素之前插入内容
remove()：删除被选元素（及其子元素）
扩展：$("p").remove(".tialic");//删除class="tialic"的所有<p>元素
empty()：删除被选元素中子元素
c.CSS
css()：设置、返回该表样式
5.工具操作
迭代工具：$.each(参1,参2)
参数1：需要迭代的数据
参数2：迭代函数
function(k,v){
k：下标
v：值
}
6.JQuery效果
hide()、show()、toggle()：隐藏、显示、显示或隐藏。
参1：slow、fast、毫秒，参2：完成后执行的方法
slideUp()、slideDown()、slideToggle()：上滑、下滑、上滑或下滑
参1：slow、fast、毫秒，参2：完成后执行的方法
fadeIn()、fadeOut()、fadeToggle()：淡入、淡出、淡入或淡出
参1：slow、fast、毫秒，参2：完成后执行的方法
fadeTo()：渐变为给定的不透明度（0-1）
参1（必选）：slow、fast、毫秒，参2（必选）：透明度，参3：方法
animate({params},speed,callback)：自定义动画（params多属性使用“,”逗号分隔）
{params}：形成动画的CSS属性，speed：时长，callback：方法
stop(stopAll,goToEnd)：停止动画
stopAll：是否清除之后队列的动画，goToEnd：是否立即完成当前动画
JQuery方法链接：将动画效果连接。先变红，然后向上滑动，然后向下滑动
$("#p1").css("color","red").slideUp(2000).slideDown(2000);
……
N.扩展
1.使用谷歌或微软的JQuery（优势）
（Google）谷歌CDN：http://ajax.googleapis.com/ajax/libs/jquery/1.8.0/jquery.min.js
（Microsoft）微软CDN：http://ajax.aspnetcdn.com/ajax/JQuery/jquery-1.8.0.js
许多用户在访问其他站点时，已经从谷歌或微软加载过JQuery。所以再次访问其他站点时，会从缓存中加载JQuery，这样可以减少加载时间。
2.代替$符号
var jq = JQuery.noConflict();//使用“jq”代替$符号
3.var a = function(){} 与 function a(){}的区别
var a = function(){}：
页面编译时只会做声明明，不会执行方法之中的代码。
没执行function时，a是undefined的
function a(){}：
页面编译时已经执行了之中的代码
没执行之内的代码时，a已经是一个function了。
4.ul>li什么意思
1.层次选择器，表示ul下面直接的li（也就是说下面一层的）
2.与“ul li”的区别就是，“ul li”是ul下面的所有li。
第68天 - - JQuery.AJAX
一.ajax
1.ajax简介：
1.Asynchronous Javascript And XML（异步javascript和xml技术）
2.一种创建交互式网页应用的网页开发技术
3.在无需重新加载整个网页的情况下，能够更新部分网页的技术。
（传统网页必须重载整个网页页面）
2.ajax基于现有的Internet标准：
1.XMLHttpRequest对象（异步的与服务器交换数据）
2.JavaScript/DOM（信息显示/交互）
3.CSS（给数据定义样式）
4.XML（作为转换数据的格式）
3.JQuery.ajax
1.JQuery提供多个与AJAX有关的方法，通过JQuery AJAX方法，能够使用HTTP Get和HTTP Post 从远程服务器上请求文本、HTML、XML或JSON。
2.同时能够把这些外部数据直接载入网页的被选中元素中。
3.编写常规的AJAX代码并不容易（不同浏览器，实现不相同），使用JQuery则只需要一些简单的代码，就可以实现AJAX功能。
二.Ajax处理
1.JQuery框架AJAX的实现
1.load()方法
从服务器加载数据，并把返回的数据放入被选元素中。
语法：$(selector).load(URL,data,callback);
URL：必选，希望加载的URL
data：可选，与请求一同发送的查询字符串键/值对集合。
cllback：可选，方法完成后所执行的函数名称。
1.responseTxt（调用成功的结果内容）
2.statusTXT（调用状态）
3.xhr（XMLHttpRequest对象）
2.get()方法
通过HTTP GET请求从服务器上请求数据
语法：$.get(URL,callback);（共四个参数：URL、data、callback、dataType）
URL：必选，请求的URL
callback：请求成功后执行的函数名
1.被请求页面的内容。
2.请求的状态。
3.post()方法
通过HTTP POST请求向服务器提交数据。
语法：$.post(URL,data,callback);
URL：请求的URL
data：连同请求发送的数据（键值对，多条使用“{}”包括、“,”分割）
callback：请求成功后执行的函数名
1.被请求页面的内容。
2.请求的状态。（success、notmodified、error、timeout、parsererror）
例：
$.post("try/ajax/demo_test_post.php",{
name:"菜鸟教程",
url:"htpp://www.runoob.com"
},
function(data,status){
alert("数据：\n"+data+"\n状态："+status)
});
4.ajax()
用于执行AJAX（异步HTTP）请求，所有JQuery AJAX方法都使用ajax()方法（通常用于其他方法不能完成的请求）。
参数：
async：请求是否异步处理
url：请求的URL，默认是当前页面
data：规定要发送到服务器的数据
success(result,status,xhr)：请求成功时运行的函数。
type：post、get（默认get）
……
例：
$.ajax({
url：异步请求路径, //相似form表单的action。但属于异步
data:"key = value&key=value..",
//success表示服务器成功响应后需要处理的内容（成功自动触发）
success:function(参数){ //回调函数，请求成功时自动执行函数
页面处理脚本。（可通过参数获得响应对象）
}
});
N.扩展
1.get、post
1.传输数据大小限制不同：get小，post没有限制
2.传输速度不同：get简单且快
3.包含未知字符的用户输入时，post更稳定
第69天 - - JSON
一.JSON
1.JSON简介
JSON（JavaScript Object Notation，JS对象简谱），轻量级的数据交换格式。
2.JSON语法规则
JS语言中，一切都是对象，所以任何类型都可以通过JSON来表示。JSON对象中可以保存数组或另一个JSON对象
对象：键值对（JSON是js对象的字符串表示）
{key1:value1,key2:value2,…} //（{"键":"值"}）
数据：由逗号分隔
花括号：保存对象
方括号：保存数组
例：
myObj = {
"name":"runoob",
"alexa":10000,
"sites":{"site1":"value1","site2":"value2"},
"sites2":["value1","value2","value3"]
};
3.JSON使用
1.“.”、“[]”获取并修改值，使用delete删除JSON对象
例：
“.”：MyObj.sites.site1 = "newValue";
“[]”：MyObj.sites["site1"]="newValue";
delete：delete MyObj.sites["site1"];
2.JSON.parse()：（推荐）
用于服务端交换数据（接受数据时一般是字符串），可使用JSON.parse()方法将数据转换为JavaScript对象。
JSON不能存储Date类型数据，需要先把Date对象转为字符串，之后在转为Date对象。
语法：
JSON.parse(text[,reviver])
text：有效的JSON字符串
reviver：可选，转换结果的函数，将为对象的每个成员调用此函数。
例：第二个参数reviver，一个转换结果的函数，对象的每个成员会调用。
var text = '{"name":"Runoob","initDate":"2013-12-14","site":"value3"}'
var obj = JSON.parse(text,function(key,value){
if(key == "initDate"){
return new Date(value);
}else{
return value;
}
})
document.getElementById("demo").innerHTML = obj.name + "创建日期："+obj.initDate;
2.js方法eval()：
使用的是JavaScript的编译器，可解析JSON文本，必须将文本包含在括号内。
与JSON.parse()类似，但是会解析函数。（这样会存在安全问题）
var text= {"name":"function(){return 100;}"};
var obj = eval('('+text+')');//obj.name为：100。
3.JSON.stringify()
将JavaScript对象转化为字符串（数组也可以）。
语法：JSON.stringify(value[,replacer[,spance]])
value：必须，一个有效的JSON对象
replacer：可选，分为函数与数组
函数：调用该函数，传入每个成员的键和值，使用返回值。
数组：仅转化该数组中有键值的成员（value为数组则忽视）
spance：添加缩进、换行、空格（\t、\n），可为数字（空格的个数）
其他：
1.不能存储日期对象，会自动转为字符串
2.不允许包含函数，会自动删除键与值
例：
var obj = {"name":"runoob"}
JSON.stringify(obj);//结果为{"name":"runoob"}
3.ajax服务器操作
只传输字符串（或XML）。（对象开销太大，不能传输）
数组字符串装换为数组：使用json（可直接将json字符串转换为js可识别）
N.扩展
1.JS的for-in语法
for(x in 对象){
x.属性 //遍历对象属性
}
2.JSON.parse()与eval()
都可以用来解析JSON格式的字符串。
eval()：
1.属于js自带，在解析字符串时，会执行该字符串中的代码（函数）。
JSON.parse：
1.属于JSON对象中的方法，JSON中不允许包含函数。
2.“\\\\”才表示平常的“\”。（因为是对字符串的真实含义进行解析）
3.方法参数中的“[,[,]]”
表示可选参数，例：
//value是必须值，replacer、space为可选
JSON.stringify(value[, replacer[, space]])
第70天 - - MyBatis基础配置
一.框架
应用框架（每个企业都可以用）
MyBatis、Spring、SpringMVC、SpringBoot
SSH：Struts、Spring、Hibernate（已被淘汰）
SSM：Spring、SpringMVC、MyBatis
微服务端（大数据开发-分布式开发）
自定义框架
只有自己公司用（自己研发）
二.MyBatis
原名：ibatis》Apache
现名：MyBatis》google（谷歌更名为MyBatis）
简介：
属于一种持久化（ORM（ObjectRelationalMapping）对象实体映射）框架，该框架传承与Hibernate框架而来
Hibernate：
世界上第一款java操作数据库的框架，好用但是对服务器开销太高，所以出现了MyBatis（轻量级）。
持久化：
数据库不会断开，连接一直存在，只要修改第一次连接时的对象，数据库中的数据也会修改。（映射）
配置：（重点）
1.导入框架jar包
log4j（记录数据库信息）、MyBatis、mysql、Junit（单元测试）
2.添加数据库配置文件 - - jdbc.properties
3.MyBatis框架核心配置文件（mybatis-config.xml）配置
<!-- 头信息 -->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- mybatis核心配置-->
<configuration>
<!-- 1.JDBC配置 -->
<properties resource="jdbc.properties"></properties>
<!--
2.配置挂载设配：挂载数据库
default：模式（开发者模式：development）
-->
<environments default="development">
<!-- 2.1挂载数据库 -->
<environment id="development">
<!--
2.1.1配置事物管理器
（事物：只要有一个错误就都不执行）
-->
<transactionManager type="JDBC">
</transactionManager>
<!-- 2.1.2配置源数据（只支持POOLED） -->
<dataSource type="POOLED">
<!-- 2.1.2.1数据库配置，使用EL表达式获得值 -->
<property name="driver" value="#{driver}"/>
<property name="url" value="#{url}">
<property name="username" value="#{user}">
<property name="password" value="#{pwd}">
</dataSource>
</environment>
</environments>
<!-- 3.这里在编写完成映射文件后，还要配置映射文件 -->
<mappers>
<mapper resource="com/ljl/dao/usersdaomapper.xml"/>
</mappers>
</configuration>
4.添加工程架构
dao、bean、test、
5.添加实体类
6.添加mybatis映射文件（xxxdaomapper.xml），完成映射配置
mybatis映射配置是基于接口方式（面向接口编程）
<!--
映射文件配置
namespace：映射文件路径（底层采用反射方式）
-->
<mapper namespace="com.ljl.dao">
<!-- 添加crud操作 -->
<!--
增
id：该SQL语句标志符，类似方法名
parameterType：参数类型 传入到当前语句的类型
-->
<insert id="save" parameterType="com.ljl.bean.Users">
INSERT INTO USERS(U_NAME,U_ID) VALUES(#{u_name},#{u_id})
</insert>
</mapper>
7.调用mybatis执行数据库操作
//1.获得配置文件加载
InputStream is = Resources.getResourceAsStream("mybaits-config.xml");
//2.通过配置文件，创建会话工厂
SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(is);
//3.通过工厂获得会话对象
SqlSession session = ssf.openSession();
//4.执行数据库操作
//4.实例化学生对象
Users u = new Users()
u.setXXX();
u.setXXX();
//5.执行数据库操作
session.insert("save",u);
//6.提交事务
session.commit();
//7.关闭会话
session.close();
N.扩展
1.Oracle与MySql的区别
序列、分页、数据架构完全不一样。
MySql：（数据库可以有多个）
表是装在数据库里面的。
2.xml配置路径
C:\Users\Administrator\Desktop\jar包、js\lib\org\apache\ibatis\builder
第71天 - - MyBatis
一.目标
1.掌握myBatisCRUD操作
2.
二.MyBatis的CRUD操作
1.定位
后台数据库
2.MyBatis运行结构图
N.扩展
1.结果集映射
数据库字段名与对应实体类属性名不同时，需要配置结果集映射。
语法：
<resultMap id="" type="">
<result column="" property=""/>
<association property="" resultMap=""></association>
……
</resultMap>
id：该映射id名
type：实体类类型（反射方式：需要写类全路径）
子标签：<result>（普通属性配置）
column：数据库字段
property：实体类属性名
子标签：<association>（外键配置（对象类型配置））
多表连接查询时，将另一个表（外键表）的数据封装。
property：实体类属性名
resultMap：封装了的关联表，映射的id名（一般是外键查出来的表）
第72天 - - MyBatis动态标签、映射器
一.目标
1.MyBatis动态标签
2.映射器
二.MyBatis动态标签
<where></where>：
代替sql语法的where，更加简化，结构跟鲜明。MyBatis会自动编译，减少语法的编写。
<if></if>：
与JSTL标签类似。test属性中只需直接写判断就好
<bind/>：
变量定义
<sql></sql>：
动态sql标签，用于实现SQL语句拼接操作。
二.映射器（Dao接口）
1.编写方法（方法名需与xxxdaomapper.xml中CRUD操作标签的id名一致）
2.映射器的实现（基于接口实现）
实现原理：
在接口中定义对应的方法，通过为该方法添加注解来实现sql语句的指定。
例：（插入用户）//注解只针对简单sql语句
@insert("SQL语句")
public void insert(Users u); //可以传入参数
3.使用方式
UsersDao ud = session.getMapper(UsersDao.class);//通过类描述得到映射器
ud.save();//调用接口中方法
4.映射文件（xxxdaomapper.xml）的配置与映射器（dao接口）的关系。
<mapper>标签中配置namespace，值应该准确定位匹配的映射器（接口）。
数据库操作标签的id必须在映射器中声明相应方法。
3.映射方式
如果实体类中属性与数据库中字段名不同，则需要配置映射
1.在映射器中配置映射：（不合理，会造成冗余）
@Results({
@Result(column="数据库字段名",property="实体类属性名"),
@Result(column="数据库字段名",property="实体类属性名")
})
2.在映射文件中配置映射，再在映射器中关联（合理，可复用）
@ResultMap("映射文件中映射ResultMap的id")
N.扩展
1.传递多个参数
a.添加注解：@Param("")
dao层：
public void list(@Param("userName")String name,@Param("userArea")String area);
配置映射：
<select id="list" parameterType="java.lang.String" resultType="Bean">
select t.* from tableName t where t.name=#{userName} and t.area=#{userArea}
</select>
第73天 - - 测试前准备
一.目标
1.验证码
2.MD5码
3.页面包含
4.ER图
二.知识点
1.
2.MD5码
加密的字符串比较：将常规的字符串加密，在与已经加密的字符串比较。
3.页面包含
<!-- 引入头页面begin -->
<jsp:include page="网页路径">
在网页中，放别的网页的内容
<!-- end -->
4.ER图
实体关系图
项目流程：
需求分析
需求文档
静态原型
设计
概要设计
E-R图：实体关系图（看起来更直观）
先生成逻辑表
再生成物理表
UML图：用例图（有什么模块）
详细设计
将E-R图生成对应的表
将UML图生成对应的模块
编码
数据库设计文档
数据字典（决定程序员能做什么，所有数据库表的具体信息）
由数据字典生成sql文件
详细设计文档
N.扩展
1.样式设置优先级
例：color:#FFF !important; //添加“!important”：设置为最高优先级
2.NOW()、CURDATE()、CURTIME()
函数返回当前日期：2008-12-29 16:25:46、2018-12-29、16:25:46
3.DATE_SUB()
从日期减去指定的时间间隔
语法：
DATE_SUB(date,INTERVAL expr TYPE)
date：合法的日期表达式
expr：添加的时间间隔
TYPE：类型（DAY、MONTH、YEAR、WEEK…）
第88天 - - 第三阶段-Maven
一.后期课程介绍（新老师：珊姐）
1.框架
SSM：SpringMVC+Spring+MyBatis
1.Maven（管理）
2.Spring
3.SpringMVC
4.SpringMVC+Spring+MyBatis整合
5.SpringBoot
SSH：SpringMVC+Spring+Hibernate（持久层Hibernate自己去了解）
2.课程目标
1.熟悉Maven项目管理工具的使用，使用maven管理javase项目与javaee项目
2.熟练使用ssm框架实现项目的开发
3.二阶段JavaEE技术
jsp、servlet
mybatis
前端：
jquery
json
ajax
二阶段开发模式：MVC
model：（model层）
业务模型层，负责操作数据库与业务逻辑（service）的处理（mybatis+service类）
view：（视图层）
负责数据的展示（jsp）
controller：（控制层）
负责前后端的交互（servlet）
MVC优势：将项目划分为不同的层来实现，且通过不同的技术实现。
1.代码结构更为清晰
2.提高代码的复用性
3.解耦合（代码之间的关联度越低越好）
二.Maven
1.Maven简介
1.Maven项目管理工具
通过一小段描述信息进行项目的构建、打包、发布、文档等的管理。
必定有pom.xml（project object model）
2.Maven下载、安装、配置
1.下载：
软件开发习惯：不使用最新版本（确保不出问题）
maven.apache.org -> Download.cgi -> ->解压（E:maven）
2.解压安装：（不要解压到中文目录下）
解压后的目录结构
bin：可执行应用
boot：类加载程序
conf：settings配置文件，配置maven相关信息
lib：maven相关jar包
3.安装配置maven：
a.新建环境变量
计算机>属性>高级系统设置>高级>环境变量>
创建一个系统变量（变量名：MAVEN_HOME、变量值：maven解压路径）
b.上一步基础上：环境变量path添加值（%MAVEN_HOME%\bin）（“;”分隔）。
c.测试：开始>运行>输入cmd（dom命令）>mvn -version（中间有空格）。
4.STS（编译工具）中配置
a.配置安装路径（installation）
window>preferences>maven>installation>add>Directory指定maven解压路径
b.配置用户配置文件（User Settings）
上一步基础上：User Settings > Global Settings > Browser > 选择xml文件：E:\maven\apache-maven-3.3.9-bin\apache-maven-3.3.9\conf\settings.xml
c.（可选）改变本地仓库路径需在maven的settings.xml中更改
3.Maven使用
本地仓库：（local\repo）一个仓库，用户存储jar包（可从中央仓库下载）
帮助管理jar包，避免jar包不兼容.
a.创建Maven工程
new>maven project>勾选create a simple project>next
项目相关信息：（前面4个（必填））
group id：组织id（com.newer）
artifact id：项目名称（maven_01）
version：版本（0.0.1-SNAPSHOT）
0：（第一个）大版本号
0：（第二个）分支版本号
1.：小版本号
snapshot：快照版本，正在开发
其他：alpha（内侧）、beta（公测）、release（稳定版本）
packaging：打包的格式
JavaSE工程打成jar包
JavaEE工程打成war
b.JavaSE工程目录结构
src/main/java 用于存放正式的java文件
src/main/resources 用于存放正式的配置文件
src/test/java 用于存放测试的Java文件
src/test/resources 用于存放测试的配置文件
pom.xml文件 这是maven工程的标配
c.使用maven进行jar包的管理
在pom.xml文件中填写配置信息进行jar包的管理。
例：
<!-- 通过maven进行jar包的管理（依赖注入、以来管理） -->
<dependencies> <!-- 在project标签中配置依赖注入 -->
<dependency> <!-- 多个jar包则配置对个dependency -->
<!-- 某类型（项目）的jar包文件夹-->
<groupId>mysql</groupId>
<!-- jar包子文件夹 -->
<artifactId>mysql-connector-java</artifactId>
<!-- jar包版本文件夹 -->
<version>5.1.4</version>
</dependency>
</dependencies>
http://mvnrepository.com中央仓库，输入关键字查找相应的jar包，选择相应的版本。
导入jar包时，会把该包依赖的jar包也导入进来。（只能导入本地仓库有的jar。没有的，配置依赖后则会自动从中央仓库下载）
4.作业
1.建立一个maven工程，通过maven进行ja包的管理（mysql、junit、mybatis的jar）
2.使用mybatis做一个表的查询操作，通过测试类中测试，并将查询的数据输出到控制台即可
N.疑问
1.Maven工程有四个src，分开了正式编码与测试，它们不会冲突吗？
2.本地仓库找需要的jar包
1.本地仓库路径（D://local/repo）
2.通过groupid+artifactid+version去找相应的jar
3.依赖注入之后无法自动下载jar包，还是报错。
1.网络不好或其他原因下载失败，则只会下载“lastUpdate”文件。
2.重新下载需删除该“lastUpdate”再重新下载。（或直接删除该版本文件夹）
4.知识点回顾
1.maven是什么
a.项目管理工具，管理项目的构建。
b.通过pom.xml的配置信息管理jar包、打包、发布。
2.本地仓库的概念
在本机上用于存放jar包的文件夹
3.基于maven创建javase工程以及目录的分析
new>maven project> create a simple project>填写基本信息
gorup id、artifact id、version、packaging：jar
工程的目录结构：
src/main/java
src/main/resource
src/teset/java
src/resr/resource
5.通过maven进行jar包的管理
在pom.xml文件中配置
<dependencies>
<dependency>
<groupId>jar包文件夹</groupId>
<artifactId>jar包子文件夹</artifactId>
<version>jar包版本文件夹</version>
</dependency>
</dependencies>
第89天 - - Maven
一.本地仓库与中央仓库，jar加载的顺序
1.本地仓库、中央仓库
本地仓库：就是本地一个文件夹
中央仓库：远程仓库
2.jia加载的顺序
1.本地仓库加载jar包。（如果本地仓库没有，则先去中央仓库下载）
2.加载到工程中
3.中央仓库的配置
默认的中央仓库：
http://repo1.maven.org/maven2/
自定义中央仓库的配置：（推荐，更快、更明了）
pom.xml中配置中央仓库：
<repositories>
<!-- 配置中央仓库，多个：继续添加repository -->
<repository>
<!-- id取一个唯一标志符 -->
<id>mvnrepository</id>
<!-- 新的中央仓库路径 -->
<url>http://mvnrepository.com</url>
</repository>
</repositories>
二.基于Maven创建JavaEE工程
1.创建JavaEE工程
1.new>maven project> create a simple project>
2.填写基本信息：
groupid、artifact、version、packaging（选择war）
3.将JavaEE中的WEB-INF文件夹（与之中的web.xml）copy至src>main>webapp。
2.依赖信息（dependency）中的scope标签
指定jar包的作用范围。例：
<scope>compiler</scope> 默认。用于项目的编译，会打包。
<scope>test</scope> 只用于测试，不会打包。
<scope>provied</scope> 用于项目的运行，不会打包（说明服务器自带，不需要）
3.给maven工程配置服务器
1.jetty服务器、Tomact区别
jetty服务器：
1.jetty是基于handler实现的（扩展提供接口，只需管实现接口）
2.jetty可以按需加载（需要什么就加载什么（可减少内存占用））
3.适用于大量的、长时间连接，（用于web聊天）
4.更易于做扩展，对JavaEE新的点支持会更好
Tomact服务器
1.Tomact是基于容器实现（做扩展需要了解Tomact体系架构、实现过程）
2.适用于频繁的、短时间连接
3.Tomact对javaEE支持更全面。
2.如何使用jetty服务器（当一个插件来配置）
<build>
<!-- 配置插件信息 -->
<plugins>
<plugin>
<!-- 插件路径、版本信息 -->
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<version>9.2.8.v20150217</version>
<!-- 插件配置信息 -->
<configuration>
<httpConnector>
<port>8080</port>
</hrrpConnector>
<!-- 设置为0不自动扫描（不自动加载）-->
<scanIntervalSeconds>0</scanIntervalSeconds>
<!-- 手动回车重新加载服务器 -->
<reload>manual</reload>
<!-- 指定项目的访问路径 -->
<webApp>
<!-- 上下文路径：“${}”获取配置文件中自定义属性 -->
<contextPath>/${project.artifactId}</contextPath>
</webApp>
</configuration>
</plugin>
…
</plugins>
</build>
项目右键》Run As》Maven Build…》在goals中输入jetty:run
访问项目：localhost：8080/项目名/资源的访问路径
N.疑问
1.JavaEE三剑客
servlet、jsp、jstl
2.JDK版本问题
（以前使用build path将jdk修改为1.8，但是更新项目之后，又会变为默认的1.5。web项目需要支持1.7或以上，所以需要配置jdk版本（配置之后需更新））
通过插件修改jdk的版本（在build标签中配置）
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>utf-8</encoding>
</configuration>
</plugin>
3. 更新Maven项目
项目》右键》maven》update project》勾选相应信息（Force Update of snapshots/release）
4. pom.xml中配置属性值
配置属性值：（pom.xml的project根标签中）
<!-- 定义属性值 -->
<properties>
<!-- 子标签名是自定义的 -->
<jdk.version></jdk.version>
<charset>utf-8</charset>
<properties>
引用属性值：
${标签名称}：${jdk.version}
5.project.build.sourceEncoding
例：（项目编译的源代码，设置为UTF-8）
<project.build.sourceEncoding>utf-8</project.build.sourceEncoding>
6.在maven中如何调试代码
打断点》debug》先导源代码》运行项目
7.#{}与${}
例：roleName = "zs";
#{}：拿到的是字符串（#{roleName}等于"zs"）
${}：拿到的是具体的值（${roleName}等于zs）
8.相对路径
../：可以返回上一级
例：../dao/usermapper.xml
第90天 - - Spring框架
一.Spring框架
1.核心：
控制反转（IOC）、面向切面编程（AOP）、依赖注入
2.什么是框架
框架中封装了实现指定功能的代码，提高开发效率。
3.什么是Spring框架
1.spring框架是一个高度灵活、轻量级（jar包大小）的框架。
2.是一种无侵入式的设计方式。（侵入式：捆绑式，耦合度很高）
3.开发的目的是降低企业级项目开发的复杂度。
4.Spring框架功能模块
AOP（面向切面编程）：
实现特定的功能（可理解为类似过滤器：降低耦合，提高可维护）
DAO（Data Access/Integration）：
数据访问模块，操作数据库，集成MyBatis框架，实现对事物的控制。（提供了一个工具类JDBCTemplate用于操作数据库）
Web：
提供集成SpringMVC框架的支持
Core Container：（核心容器）
提供控制反转、依赖注入，是Spring框架中的核心部分。其他功能是建立在该模块的基础上。
Test：
提供对单元测试功能
spring框架的模块图
5.Spring框架作用（Spring中部分重要内容）
1.控制反转、依赖注入（Core Container）
2.面向切面编程、用于实现通用的功能（AOP）
3.操作数据库、实现事物支持、集成MyBatis（Data Access）
4.提供对集成springMVC框架的支持（Web）
二.Spring核心容器：Core Container
1.程序中的容器
容器适用于装东西。
web服务器也是一个容器：
1.用于存放servlet。
2.管理对象。（如servlet类对象创建）
3.调用指定的方法。（doPost、doGet）
Spring中的核心容器：（与web类似，但主要用于管理自定义对象）
1.可用于管理对象（对象创建、销毁）
2.可用于调用指定的方法。
2.通过程序体现Spring容器管理对象
目的：提高程序可维护性、可扩张性、降低程序的耦合度。
1.导入相关jar包
核心容器jar包：5个（每个都配套有三个，只需主要的哪一个）
beans、context、context-support、core、expression
2.由容器创建对象
创建对象的工作交给Spring的核心容器去实现，就叫做控制反转（IOC）
以前：User user = new User();
Spring：通过配置文件获得ApplicationContext对象，getBean()获得自定义对象。
3.创建一个普通的java类
例：Dog类，设置属性name，方法shout()。
4.定义一个Spring的配置文件
配置文件命名自定义：（一般叫做：applicationContext.xml）
Spring声明的实体对象，一般叫做“bean组件”
<!-- 第一行：beans模块的命名空间，可理解为存放该模块的xsd文件夹 -->
<beans xmlns="http://www.springframework.org/schema/beans"
<!-- 第二行：标签满足w3c的标准 -->
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
<!-- 第三部分：约束文件xsd文件的路径 -->
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframwork.org/schema/beans/spring-beans.xsd">
<!-- bean组件：需要交给spring容器管理的对象 -->
<!-- id属性时对象的名字，唯一标识符。class值定类的全路径 -->
<bean id="dog" class="com.newer.bean.Dog"></bean>
</beans>
5.写测试类
a.先获取Spring容器对象本身
ApplicationContext ac = new ClassPathXmlApplicationContext("配置文件");
b.获取容器中管理的对象（通过bean的id获取）
Dog dog = (Dog)ac.getBean("dog");
c.通过对象调用类中的方法
dog.shout();
Spring容器创建对象：默认还是用无参构造方法创建的对象。
有参构造方法需要使用依赖注入。
第91天 - - 网络爬虫（）
一.网络爬虫
IO、
线程（线程池）、同步
Collections.synchronizedList(new ArrayList<>()) //可创建同步线程
线程池：
创建于销毁线程非常占用资源，线程池可避免反复的创建、销毁。需要用的时候从线程池中取出，使用完之后放回。
固定数量线程池：
ExecuteService es = Execute.newFixedThreadPool(4);
es.execute(线程);
不固定数量线程池
DOM
解析HTML（Jsoup）
List、
JSON（XML）
JSON-lib
GSON
fastjson
Jackson
面相对象（封装）
class Film{
}
N.疑问
1.
2.
第92天 - - spring依赖注入
一.Spring容器管理对象的机制
1.管理对象（定制bean组件）
1.bean组件作用域：（scope属性）
单实例：（singleton）
1.默认，容器初始化时创建。
2.多次访问同一个类，均是第一次实例化的对象。
3.可设置为第一次访问时创建：lazy-init="true"
例：<bean id="dog" class="com.newer.bean.Dog" lazy-init="true">
多实例：（prototype）
1.每次访问时创建对象
2.设置为多实例：scope="prototype"
例：<bean id="dog" class="" scope="prototype"></bean>
2.bean组件初始化、销毁资源调用的方法设置
初始化：init-method="方法名"
销毁：destroy-method="方法名"
单实例时：关闭spring容器会调用destroy-method。
多实例时：spring容器不负责销毁，由程序员销毁
例：
<bean id="dog" class="com.newer.bean.Dog" init-method="方法名" destory-method="方法名">
3.spring容器的关闭
ApplicationContext为接口，没有close方法。
1.通过实现类接受实现类对象。（不使用引用转型）
2.实现类对象调用close方法。
例：
ClassPathXmlApplicationContext ac;
ac= new ClassPathXmlApplicationContext("spring配置文件全路径");
二.依赖注入（Dependency Injection）
1.概念
概念：通过容器，初始化对象中的属性值。
方式：手动注入、自动注入
2.手动注入
a.setter方法注入：（通过反射来执行setter、必须包含无参构造方法）
在<bean>标签中添加子标签<property>
1.普通属性：
<property name="属性名" value="属性值"></property>
2.对象属性：
<property name="属性名" ref="bean组件id">
ref：为引用对象（组件）的id
3.List类型属性：
<property name="属性名" >
<list>
<!-- 基本类型与String型的赋值方式 -->
<value>主球<value>
<value>篮球</value>
<!-- 对象类型（初始化bean组件的属性值） -->
<ref bean="bean组件id"></ref>
</list>
</property>
4.Map类型属性：
<map>
<!-- 初始化基本类型的值 -->
<entry key="语文" value="99">
<entry key="英语" value="50">
<!-- 初始化bean组件类型的值 -->
<entry key="键名" value-ref="bean组件id"></>
</map>
b.构造器注入：（通过有参的构造方法初始化对象中的属性值）
会根据参数的个数、类型、名字等属性，自动匹配（重载）有参构造方法
1.先定义有参、无参的构造方法。
2.<bean>标签中添加<constructor-arg>
constructor-arg标签的属性：
index：索引，指定注入的属性
type：类型，该属性对应的类型
ref：引用的依赖类型
value：基本数据类型使用value
name：参数名
例：（其他的与property标签类似）
<constructor-arg name="参数名" value="值"></constructor-arg>
2.自动注入：
容器自己在容器中寻找合适的值初始化对象中的属性（用的不多）
autowire：自动注入，只能注入bean组件类型的值。
byType：按类型匹配：有多个类型则会报错
<bean id="boy" class="com.newer.bean.Dog" autowire="byType"></bean>
byName：按名字匹配：通过bean组件id，去匹配实体类中的属性名
<bean id="boy" class="com.newer.bean.Dog" autowire="byName"></bean>
N.疑问
1.依赖注入原则（可理解为内功心法）
例：
程序员、电脑：程序员依赖电脑，电脑被程序员依赖。
a.上层模块不依赖底层模块,他们都应该依赖抽象
b.抽象不应该依赖细节，细节应该依赖于抽象
2.八大基本类型该如何依赖注入
会自动辨别
3.lazy-init开启（true）的优缺点
优点：
避免大量数据过早的存在内存之中。
缺点：
服务器启动时，不会第一时间报错。
第93天 - - spring依赖注入注解、AOP
一.注解
1.使用注解配置IOC、DI
a.导jar包：AOP模块
导入context包时， AOP模块jar包已经依赖导入进来了。
如需通过按名字匹配：需导入注解的相关jar包（javax.annotation）
b.修改配置文件的头信息（不同的模块使用了不同的约束文件（sxd））
头信息中添加属性：
xmlns:context="http://www.springframework.org/schema/context"
头信息属性（xsi:schemaLocation）中添加值：
http://www.springframewoek.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
c.使用<context:conpoent-scan>：（自动扫描标签）
会自动扫描指定的包下的：所有子类、子包下的子类中有配置注解的类。
标签前缀需要增加“context: ”（类似jstl的“c”）
<!-- 可多个一起配置 -->
<context:compoent-scan
base-package="com.newer.dao.impl,com.newer.service.impl">
</context:compoent-scan>
<!-- 也可多个分开配置 -->
<context:compoent-scan base-package=" com.newer.controller.impl">
</context:compoent-scan>
一般实体类不交给Spring容器管理（因为会不断的创建）
d.写注解
在类上方添加管理对象相应注解
例：
@Repository(value="userDao") //默认的为首字母小写。
在属性上方添加管理属性的相应注解：（同类型有多个时，使用@Resource）
@AutoWired或@Resource(name="")
2.通过容器管理对象的注解
a.声明bean组件：（相当于配置文件中：<bean>，一般分别用于各实现类上）
目前版本没有具体的作区分，但是为了规范，应该对应层来配置注解：
@Controller(value="")：将控制层的类声明为bean组件
@Service(value="")：业务层
@Repository(value="")：dao层（持久层）
@Compoent(value="")：其他的，则用该注解声明bean组件
以上value：相当于id
b.对象多实例的配置：（类上方配置，默认为singleton（单实例））
@Scope(value="prototype")
3.依赖注入的相关注解
a.属性的注解（相当于配置文件中：<property>、<constructor-arg>）
@Resource(name="")：按名字匹配
需导jar包：（maven的pom.xml的相关jar包配置）
<dependency>
<groupId>javax.annotation</groupId>
<artifactId>jsr250-api</artifactId>
<version>1.0</version>
</dependency>
@Autowired：（默认）按类型匹配 // springframework.beans.factory包中
b.初始化、销毁资源方法的注解配置
@PostConstructor：初始化资源方法的配置
@PreDestroy：销毁
销毁方法配置，只在单实例对象中有用。（多实例：会自动销毁（但不会调用配置了的销毁方法，spring已经自动销毁了））
c.延迟加载的注解
@lazy(true) //该类被调用时在加载。（默认为false）
二.面向切面编程AOP（Aspect Object Pragramming）
1.AOP的应用（是一种思想）
在同一个项目或者不同的项目中，我们经常会在多处实现相同的功能，为了解决代码的复用性，那么就出现了AOP机制。
a.面向切面的编程实想：将流程中的某一个通用功能封装。（看成一个切面）
b.解决代码复用，避免代码冗余。
例：（各种地方都有用到AOP机制）
Servlet中的过滤器、SpringMVC中的拦截器、Spring框架中的通知。
2.Spring中AOP的术语
a.切面程序：公共程序所在的类。
1.bean组件中的方法。
2.返回值类型为空。（环绕通知需返回值，否则目标程序无法接受到返回值）
3.参数类型与通知类型相关。
通知参数类型：
前置：(JoinPoint jp)
后置：(JoinPoint jp,Object ret)
最终：(JoinPoint jp)
异常：(JoinPoint jp,Throwable e)
环绕：(ProceedingJoinPoint pjp)
b.切入点：目标程序。（需要切入的地方）
1. bean组件中的方法。
2.参数类型与返回值类型不限（都可以）。
c.通知类型：切面程序在切入点程序执行的位置。
1.前置通知：切面程序在切入点程序执行之前执行。
2.后置通知：切入点程序成功执行并返回结果之后。
3.最终通知：最终，相当于finally。（无论是否异常，都执行）
4.异常通知：切入点程序抛出异常时执行。
5.环绕通知：是以上4个配合所实现的（proceed()：手动执行目标程序）。
3.通过通知实现AOP机制：（前置通知实现打印日志的功能）
a.导入jar包
AOP：spring-aspects
log4j：log4j（还需properties配置文件）
b.编写切面程序（方法）（切入点方法执行时，所执行的方法）
//获取日志对象
Logger log = logger.getLogger(本类类名.class);
//打印日志
log.info("切面程序开始执行");
log.info(jp.getSignature()); //获取目标方法的反射对象
log.info(jp.getTarger().getClass().getName());//目标类名
log.info(jp.getArgs()[0]); //目标方法参数（第一个）
log.info("切面程序执行结束");
c.通过配置文件来指定通知类型。
1.切面程序、切入点程序都应该声明为bean组件。
2.配置applicationContext.xml头信息：
头信息添加属性：
xmlns:aop="http://www.springframework.org/schema/aop"
头信息属性（xsi:schemaLocation）添加值中：
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
3.指定切面程序
<aop:config>
<!-- 指定切面程序所在类 -->
<aop:aspect ref="beforeAspect">
<!-- 指定切入点程序 -->
<!-- 切入点表达式（execution：按函数匹配） -->
<aop:pointcut expression="execution(返回值 全路径.方法(参数))"
id="targetPoint" />
<!-- 通知类型，前置通知 -->
<aop:before method="切面方法名 " pointcut-ref="targetPoint" />
</aop:aspect>
</aop:config>
N.疑问
1.spring的核心机制
IOC、AOP
IOC：分的细的话才会分出IOC与DI
2.日志
为了避免出错之后，可以再来查找出错具体原因。
3.通过ClassPathXmlApplicationContext接受变量与接口的区别
既然只有ClassPathXmlApplicationContext可以直接调用关闭方法（close），为何还要使用引用转型来接受Spring容器对象呢？都使用实现类不是更直接吗？
4.当一个对象的作用域是多实例时，在第二次获取该对象时，上一个对象是否被销毁。
n.错误汇总
a.注解、xml中，同时声明了bean组件，按类型匹配（@Autowired）报错
b.触发切面程序的几点：
1.（待确定）面向切面编程（AOP）中，只有非本类调用该切入点方法，才会触发切面程序。（例：A类作为切入点程序，自己调用自己的方法，不会触发切面程序）
2.（待确定）被配置了注解的方法也不会触发切面程序。（例：初始化@PostConstruct）
3.只能通过获取的spring容器中bean组件对象来调用指定切入点程序时，才会触发切面程序。
d.配置切面、切入点程序时，<aop:pointcut><aop:pointcut>标签中间不能有空格（可直接使用单标签<aop:pointcut />）。
e.环绕通知通过pjp.proceed()方法执行指定目标程序之后，还需返回该方法（pjp.proceed()）的返回值。
第94天 - - AOP注解、切入点表达式
一.切入点表达式
1. expression指定目标函数
execution：（按函数匹配）
//指定类中具体的方法，参数类型为单个的任何类型
expression="expression(* com.newer.dao.impl.UserDaoImpl.save(*))"
//指定类中所有的方法
expression="expression(* com.newer.dao.impl.UserDaoImpl.*(*))"
//如果想要任何参数（无论个数、顺序、类型），那么使用“..”
expression="expression(* com.newer.dao.impl.UserDaoImpl.save(..))"
//impl包中所有类、所有方法
expression="expression(* com.newer.dao.impl.*.*(..))"
within：（按类匹配：作用在指定的类中的所有方法，不需要指定返回值）
//匹配该类所有方法
within(com.newer.dao.impl.UserDaoImpl)
//匹配 com下的 所有子包下的 所有类
within(com..*)
bean：（按bean的id匹配：该类中所有方法都会触发切面程序）
bean("id")
二.注解实现AOP的配置
1.声明bean组件的注解
@Controller、@Service、@Repository、@Component
2.指定切面程序的注解
@Aspect：切面程序的注解（用于指定一个bean组件为切面程序）
3.指定通知类型的注解（写在方法上）
@Before(value="切入点表达式")，例：
@Before(value=" expression(* com.newer.dao.impl.UserDaoImpl.save(*))")
@AfterReturning(pointcut="切入点表达式",returning="")
@AfterThrowing(pointcut="",throwing="")
@After(value="切入点表达式")
@Around(value="切入点表达式")
4.使用注解实现AOP的配置
a.导jar包、修改配置文件的头信息
b.开启自动扫描
<context:component-scan base-package="com.newer"></context:component>
c.开启动态代理（才能实现切面程序配置）
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
d.在类上和方法上添加注解
N.疑问
1.为什么最终通知（After）总是在后置通知（AfterReturning）之后。
最终（After）通知其实才是后置通知：无论是否异常都执行的通知。
AfterReturning通知也叫返回通知：是在方法正常执行且返回值之后在执行的。
也许是老师上课方式不同所以讲解出现了错误。
第95天 - - Spring+MyBatis
一.学习规划（新老师：全利剑）
1.IOC
bean：类交给Spring容器管理之后，称之为一个bean。
（定义bean推荐使用java注解与配置方式，但是xml也不能完全抛弃）
1.基于XML配置
2.基于Java注解方式
3.基于Java配置方式
DI：当各bean之间有依赖关系时，通过依赖注入来给它们赋值
1.setter方法注入
2.构造方法注入
2.常用注解：
装配bean：
@Service
@Component
@Controller
@Repository
注入bean：
@Autowired //通过类型注入
可借助注解指定名字：@Qualifier
@Resource //通过名字注入
基于Java配置：
@Configuration //相当于xml配置文件
@Bean //用在方法上，表示该方法返回一个bean
二.Spring+MyBatis、事务
1.步骤
1.创建spring工程》选择maven简单版
2.修改pom.xml配置文件。将spring改为5.0.7版本、
2.Java配置
1.普通的类加载@Configuration（变成配置类）
@Configuration
@ComponentScan("com.newer") //扫描com.newer包下所有使用
@ImportResource("classpath:config/include.xml")
N.疑问
1.SQL的“*”使用
a. count(*)是效率最低的。
b.最好count(1)。//表示第一列，且不关心第一列是什么（就是结果集总行数）
2. classpath*:config/jdbc.properties中冒号前部分什么意思？
classpath：
从classpath路径下加载文件，但是只能加载找到的第一个。
classpath*：
从classpath路径下加载文件，可以加载找到的所有所有，但是效率差一些。
3.不需要配置mybatis了吗？
mybatis已经在xml中通过spring配置文件配置了。
4. SqlSessionFactoryBean与SqlSessionFactoryBuilder区别
a.SqlSessionFactoryBuilder：
1.MyBatis中创建SqlSessionFactory，进而创建SqlSession。
2.获得SqlSession之后，可通过该对象执行映射语句，
b.SqlSessionFactoryBean：
1.MyBatis开发的MyBatis-Spring，为了满足MyBatis整合Spring的需求。
2.代替SqlSessionFactoryBuilder创建SqlSessionFactory
3.可使用两种方法使用SqlSession
a.SqlSessionTemplate（实现了SqlSession接口类）
线程安全的
与Spring的事务进行了关联
b.SqlSessionSupport（抽象的支持类）
用来提供SqlSession，调用getSqlSession()会获得SqlSessionTemplate
需要使用一个SqlSessionFactory或SqlSessionTemplate属性来设置。
5.配置文件简介
第96天 - - 事务、SpringMVC
一.事务
1.简介
a.防止出现脏数据，防止数据库出现问题
事务就是对一系列的数据库操作（比如插入多条数据）进行统一的提交或回滚，如果插入成功，那么一起成功，如果中间一条出现异常，那么回滚之前的所有操作。
b.处理事务
JDBC
通过Connection对象进行事务管理。默认自动提交事务，可以手动关闭，通过commit方法进行提交，rollback方法进行回顾。
Hibernate
通过Transaction进行事务管理，处理方法与JDBC类似
Spring
使用TransactionManager进行管理，也可通过Spring注入来完成。
c.其他
事务加在服务层上。
隔离级别只对当前连接有效。（MySql中的窗口、JDBC中的Connection对象）
2.四大特点（ACID）
原子性
要么全部成功，要么全部失败回滚。
一致性
一个事务执行之前，执行之后的一致。
例：两人共5000存款，无论如何互相转账，还是5000元。
隔离性
多个用户并发操作数据库时，不能被相互干扰。
持久性
数据一旦提交对数据库的改变就是永久的。用户提交数据后，即使数据库出现错误，也要保证事务执行。
3.事务四种隔离级别（级别越高，执行效率越低）
Serializable（串行化）：可避免脏读、不可重复读、幻读
Repeatable read（可重复读）：可避免脏读、不可重复读
Read committed（读已提交）：可避免脏读
Read uncommitted（读未提交）：最低级别，不能避免任何情况
4.脏读、不可重复读、幻读
原文路径：https://www.cnblogs.com/fjdingsd/p/5273008.html
脏读：
一个事务处理过程中，读取了另一个未提交的事务中的数据。
例：一个事务未提交，另一个事务则读取该数据，且对该数据进行了增加操作。虽然看到了该数据确实增加了，但是他还是会回滚回去。
不可重复读：
一个事务多次查询，因为被另一个事务的增删操作，却看到了不同的数据。也就是说读取了前一事务提交之后的数据。
幻读：
事务非独立执行时发生的一种情况。读取了前一事务提交之后的数据（与不可重复读不同的是，幻读是针对一整批数据）。
例：修改整批数据某字段从“1”成为“2”。修改完之后，有插入了一条为“1”的数据，造成幻读。
二.spring MVC
原文路径：https://www.cnblogs.com/baiduligang/p/4247164.html
1.重要的类与接口
DispatcherServlet接口：前置控制器
配置在web.xml中（也可使用java类配置），拦截匹配的请求，Servlet拦截规则需自己定义（如果创建的是Maven工程，配置与规则都已经自动功能生成。规则就是拦截所有（<url-pattern>/</url-pattern>））。
HandlerMapping接口：处理请求的映射器
实现类：
SimpleUrlHandlerMapping 通过配置文件，把一个URL映射到Controller
DefaultAnnotationHandlerMapping 通过注解，把URL映射到Controller
HandlerAdapter接口：处理请求的映射器
实现类：
AnnotationMethodHandlerAdapter 通过注解，吧URL映射到Controller
Controller接口：控制器（由于使用了@Controller注解，所以不需要）
@Controller：负责注册一个bean组件至Spring上下文之中
HandlerInterceptor接口：拦截器
程序员实现该类，来完成拦截操作
ViewResolver接口：视图
实现类：
UrlBasedViewResolver 通过配置文件，将视图交给一个View处理
InternalResourceViewResolver 与上面的实现类相同，加入了JSTL支持
内部资源解析器（视图名称解析器）
View接口
实现类：
JstlView
LocalResolver接口
HandlerExceptionResolver接口：异常处理
实现类：
SimpleMappingExceptionResolver
ModelAndView类
2.常用的注解
原文地址：https://www.cnblogs.com/sunniest/p/4555801.html
@Controller
负责注册一个bean到Spring上下文（容器）中
@RequestMapping
为控制器指定可以处理那些URL请求
@RequestBody
读取Request请求的body部分数据
1.使用系统默认配置的HttpMessageConverter进行解析
2.然后把相应的数据绑定到要返回的对象上
3.在把HttpMessageConverter返回的对象数据绑定到controller中方法的参数上
@ResponseBody
用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区
@ModelAttribute
方法上使用：
在调用目标处理方法前，会先逐个调用在方法级上标注了@ModelAttribute的方法
方法入参前使用：（不太理解）
可以从隐含对象中获取隐含的模型数据中获取对象，再将请求参数一一绑定到对象中，再传入入参将方法入参对象添加到模型中
@RequestParam
在处理方法入参前使用，可以把请求参数传递给请求方法。（获取请求参数）
@PathVariable
绑定URL占位符到入参
@ExceptionHandler
注解到方法上，出现异常时会执行该方法
@ControllerAdvice
使一个Controller成为全局的异常处理类，类中用@ExceptionHandler方法注解的方法可以处理所有Controller发生的异常
3.一些使用的到的功能
详细见：第100天：SpringMVC_cnblogs工程
（这些方法都与老师讲解的方法有所不同）
a.使用@InitBinder来处理Date类型的参数。（还是使用注解的方式更简便）
在Controller的一个方法上添加，在调用目标处理方法时，会先调用配置了该注解的方法，进行Date类型的转换。（参数需要ServletRequestDataBinder类）
b.向前台传递参数
在配置了@RequestMapping注解的方法参数中，需声明Map集合。
之后在方法体中使用put方法为该Map添加数据。
在网页中使用EL表达式可直接从Request域中通过“键”取出“值”。
c.使用ajax获取控制器方法中返回的数据
在配置了@RequestMapping注解的方法参数中，添加PrintWriter参数
通过PrintWriter对象调用writer("输出的字符串")方法
异步的回调函数获取输出的值。（异步获取的中文会是乱码，且网页会有警告）
d.重定向至另一个控制器中的方法
方法返回值格式为：
return "redirect:/另一个方法匹配的路径";
4.Spring MVC核心流程图
5.Spring MVC使用
a.配置DispatcherServlet（前置控制器）
1.是一个servlet，可以配置多个。
2.配置在web.xml文件中，拦截匹配的请求，根据某某规则（根据使用了那个HandlerMapping接口的实现类的不同而不同）分发到目标Controller（我们写的Action）来处理。
-----------------------------博客学习内容↑---------------------------------
-----------------------------老师上课内容，自己总结↓---------------------------------
1.实现方式
a.基于Servlet实现
DispatcherServlet：前端控制器
b.两种方式配置前端控制器：
1.基于Java注解
2.基于web.xml配置
2.基于Spring MVC开发应用程序：
a.环境准备
1.配置pom.xml（copy老师配置文件）
2.java类进行配置
配置Spring MVC：
@EnableWebMVC（启用MVC）
配置SPring：
@Configuration（表示该类是一个配置类）
@ComponentScan("包路径")（自动扫描注解：@service、@Controller…）
@ImportResource("classpath:config/include.xml")（xml配置文件导入）
配置视图解析器：
@Bean //将返回值声明为bean组件
public ViewResolver viewResolver() {
//将试图交给View处理，且提供JSTL支持
InternalResourceViewResolver viewResolver =
new InternalResourceViewResolver();
viewResolver.setPrefix("/WEB-INF/view/");
viewResolver.setSuffix(".jsp");
viewResolver.setViewClass(JstlView.class);
return viewResolver;
}
3.DispatcherServlet配置（实现WebApplicationInitializer接口）
//重写方法
public void onStartup(ServletContext servletContext) throws ServletException {
//加载Spring Web Application配置
AnnotationConfigWebApplicationContext actx =
new AnnotationConfigWebApplicationContext();
actx.register(AppConfig.class); //加载配置文件
actx.setServletContext(servletContext);
actx.refresh();
//创建和注册DispatcherServlet（前置控制器）
DispatcherServlet dispatchServlet = new DispatcherServlet(actx);
ServletRegistration.Dynamic registration =
servletContext.addServlet("dospatchServlet",dispatchServlet);
registration.setLoadOnStartup(1); //随服务器启动
registration.addMapping("/");//匹配所有路径
System.out.println("服务器初始完成");
}
b.应用层面开发
1.DAO
数据操作层（使用MyBatis映射器）
2.Service
实现功能操作
3.Controller（控制器）
声明一个类为控制器
@Controller
控制器方法的访问地址
@RequestMapping：定义请求路径
例：在方法、类上添加注解
@RequestMapping("/hi")
htpp://localhost:8080/app/hi
@RequestMapping({"/hi","hello"})
htpp://localhost:8080/app/hi
htpp://localhost:8080/app/hello
4.视图显示（jsp显示）
c.运行：
pom.xml》右键》Run As》Maven build》在Goals中添加：tomcat7:run
4.SpringMVC流程图
N.疑问
1.如果将表单method设置为post，则会出现乱码。
设置字符编码（推荐：添加过滤器Filter）
2.自动装箱
如果参数名与实体类的属性名相同，spring会自动将这些参数的值分别封装至该对象参数中。
例：
URL：localhost:8080/app?name=小刘&pwd=123
方法：
@RequestMaping("test")
public void test(Person p){} //对象有name、pwd属性
3.配置中<mvc:annotation-driver>做了什么
它会自动注册bean组件：
DefaultAnnotationHandlerMapping
AnnotationMethodHandlerAdapter
才可以使用spring内置的json转换
第97天 - - Spring+MyBatis：静态原型
一.回顾
1.步骤
a.编写控制器
@Controller注解
b.编写视图页面
/WEB-INF/view/hello.jsp
c.编写appConfig配置类
@EnableWebMvc //开启springmvc
@ComponentScan //开启自动扫描，扫描能够声明为bean组件的注解
@configuration //
2.环境搭建
spring MVC搭建
基于注解配置：（默认使用web.xml）
配置视图解析器
或：
基于webn.xml配置
前端控制器配置（WebInitialization）
dispatcher
3.控制器
a.请求的映射地址
@RequestMapping：指定请求地址
在该注解中，还可指定请求方式，指定多个请求地址
1）普通URL
@RequestMapping("/list")
http://localhost:8080/app/list
2）基于路径变量方式：（需要使用注解：@PathVariable）
e.g：
@RequestMapping("del/{id}")
public String del(@PathVariable("id")Integer empno)
http://localhost:8080/app/del/23 //后面的其实是变量
以前：http://localhost:8080/app/del?empno=23
二.新的知识点
1.@PathVariable
在参数中添加该注解。匹配URL中的键值对。
例：
@RequestMapping("del/{id}")
public String del(@PathVariable("id")Integer empno)
例子URL：
http://localhost:8081/app/del/23
比较以前传值方式：
http://localhost:8081/app/del?empno=23
2.转发或重定向至另一个控制器的方法
转发：（redirect:）
return "redirect:index"; //跳转至映射为index的控制器
重定向：（forward:）
return "forward:index"; //重定向至映射为index的控制器
3.使用Filter过滤器设置字符编码
如果没有设置，使用post方法向服务器传送数据时，就会出现乱码。
N.疑问
1.无法访问webapp下文件
其一：
使用了java配置类与web.xml同时配置DispatcherServlet，导致无法访问。（也许是覆盖了）
第98天 - - Spring+MyBatis+Ajax：静态原型
1.加载静态页面的配置。
如果没有配置，则无法读取到静态页面（例：html、css、js等）
配置：（在xml中）
<!-- 配置静态资源(js,css,html,images) -->
<mvc:resources location="/css/" mapping="/css/**"></mvc:resources>
<mvc:resources location="/js/" mapping="/js/**"></mvc:resources>
<!-- http://localhost:8081/app/app/index.html -->
<mvc:resources location="/app/" mapping="/appx/**"></mvc:resources>
location：资源的路径
mapping：访问的路径
一个“*”：只能访问下一层的子目录
多个“*”：访问若干子目录
2.控制器方法中，请求参数获取
@RequestMapping("/m")
publicvoid list(@RequestParam("namex")String name){}
请求的路径：http://localhost:8080/app/m?namex=xx
N.疑问
1.异步：url提交属性
参数与controller控制类参数不匹配，则无法进入该方法。
2.日期格式的设置（不使用注解，需要一个JsonValueProcessor实现类）
// 实例化json配置类
JsonConfig config = new JsonConfig();
//通过JsonValueProcessor接口的实现类，设置Date格式
config.registerJsonValueProcessor(Date.class,
new JsonDateValueProcessor("yyyy-MM-dd"));
// 将集合数据装换成json格式数据
JSONArray ja = JSONArray.fromObject(empList,config);
—————第五次测试（第99天）—————
第100天 - - 上节课基础：返回JSON对象
一.
1.日期格式化
@JsonFormat(pattern="yyyy-MM-dd")
Date对象格式化输出
@DateTimeFormat(pattern="yyyy-MM-dd")
页面的字符串，转换为Date对象
2.@ResponseBody注解与ResponseEntity类
@ResponseBody
以数据形式返回（直接返回一个结果，而不是跳转页面）
如果响应类型是ResponseEntity，那么不写该注解也没关系。
ResponseEntity
可以定义返回的HttpHeaders与HttpStatus
例：
@RequestMapping("/json")
@ResponseBody
public ResponseEntity getJSON(){ //ResponseEntity可以指定泛型
ResponseEntity res = new ResponseEntity("data","状态码");
}
其他：
也可在类上添加注解
@RestController //声明一个类中的方法为：返回一个结果
3.需要预习的前端框架
H-HI
http://www.h-ui.net/
bootstrap:
http://www.bootcss.com/
N.疑问
1.配置了ResponseBody之后
网页再次使用JSON.parse()解析异步成功之后返回的JSON对象，则会出错。而且修改静态页面之后还是不行（也许是缓冲原因）。
例：（编程中出现的情况）
1.添加按钮调用的function之中使用了JSON.parse()。然后出错。
2.修改静态页面之后，添加按钮还是出错（浏览器上显示的网页每刷新）
3.但是修改按钮却是刷新之后的页面（添加、刷新是同一个页面）。
解决：清空网站缓冲信息。（清楚历史记录）
2.导入包出错（路径是对的但是还是出错）
上方工具栏选择project》clean…》选择项目》点击clean
3.@JsonFormat日期显示不对
比正常时间慢8个小时
TimeZone参数默认值为：GMT（标准时区），所以会造成慢8个小时。
改为北京时间：
@JsonFormat(pattern="yyyy-MM-dd",timezone="GMT+8")
第101天 - - SpringBoot、微服务
一.SpringBoot
原文路径：https://blog.csdn.net/u012702547/article/details/53740047
学习项目路径：第101天 - SpringBoot、微服务（18.06.26）\博客学习：SpringBoot
1.核心功能
a.独立运行的Spring项目
可以以jar包的形式来运行项目（便利）：通过java-jar xx.jar类运行。
b.内嵌Servlet容器
内嵌了Tomcat、Jetty等web容器，无需再以war包的形式部署项目
c.提供starter简化Maven
使用Spring或者SpringBoot的时候需要配置大量的依赖，而这些依赖很多都是固定的。这里SpringBoot通过Starter能够帮助我们简化Maven配置
d.自动配置Spring
e.准生成的应用监控
f.无代码生成和XML配置
2.项目创建
new》Spring Starter Project》输入相关信息：（第一次创建会下载依赖）
Name/Artifact：工程名字
Group/Package：组织名字/包名
Version：表示该工程的版本
Packaging：该工程是jar（javaSE）还是war（web项目）
3.工程结构
a.入口类：（ArtifactID+Application命名的java类）
类上有注解：@SpringBootApplication（开启SpringBoot自动配置）
组合了的注解：
@SpringBootConfiguration
表名这个类是一个配置类。
使用了该注解之后，系统会去入口类的同级包以及下级包去扫描实体类，因此建议放在GroupID的包中。
@EnableAutoConfiguration
让SpringBoot根据类路径中的jar包依赖为当前项目自动配置
@ComponentScan
自动扫描注解
关闭特定自动配置
@ComponentScan在源代码中配置了一个过滤器，如果我们只想扫描特定的类而不是全部类，那么就可以关闭自动配置：
@SpringBootApplication(exclude=DataSourceAutoConfigruation.class)
b.配置文件
1.分为：（存放在src/main/resources路径下）
properties文件（一般使用properties文件）
yml文件（yaml语言的配置文件）
2.修改默认配置
修改路径：server.servlet.context-path=/helloboot
修改端口：server.port=8081
3.获取配置文件中的值
配置文件中添加自定义属性：book.author="罗贯中"
在java类的属性上添加注解：@Value(value="${book.author}")。
4.类型安全的配置（例子）
创建book.properties
设置属性
book.author=曹雪芹
book.name=红楼梦
book.price=28
创建BookBean.java
添加注解：
@Component //设置为一个bean组件
@ConfigurationProperties(prefix="book")//设置前缀
@PropertySource("classpath:book.properties") //匹配配置文件
添加属性：（且生成get、set方法）
private String author;
private String name;
private String price;
在控制器类（Controller）中
设置属性：
@Autowired //按类型自动匹配bean
BookBean bookbean;
5.日志配置（相比于Spring中的配置简化了许多）
在application.properties
loggin.file=/home/sang/workspace/log.log //日志输出位置
loggin.level.org.springframework.web=debug //日志打印级别
6.profile配置
略：不太理解
c.运行项目
运行时，可直接运行main方法，但是部署至web服务器上后就很不方便。需要把项目打jar包。
例：（打包为demo.jar）
用docs命令运行：java -jar demo.jar
二.微服务
1.特性
a.每个服务可独立运行在自己的进程中
b.一些列独立运行的微服务共同构建了整个系统
c.每个服务为独立的业务开发，一个服务一般完成某个特定的功能。（订单、用户…）
d.微服务之间通过一些轻量级的通信机制进行通信。（REST API、RPC等调用）
2.优劣势
优势：
1.易于开发和维护
只需关心该模块的代码就可以了，代码量和逻辑复杂度都会降低。
2.启动较快
单个模块的启动肯定会比启动单体架构的整个项目要快
3.局部修改，容易部署
哪个模块出现了bug只需修改那个模块，重启那个模块就好。
4.技术栈不受限
某个模块使用的技术可以更换，更换成本较低（如：java改为js）
5.按需伸缩（自由伸缩）
单体架构扩展时需考虑和其他模块冲突，而微服务不必考虑其他模块。
劣势：
1.运维要求较高
模块出现异常找到不容易，无法使用debug一步一步跟踪，对运维人员要求高。
2.分布式的复杂性
微服务是必会用到分布式的，而分布式是具有一定复杂性的。
3.接口调整成本高
如：多个模块依赖某一个模块，如果这某个模块进行修改了的话，那多个模块需调整接口
4.重复劳动
单体架构：
如果某个业务被多个模块共同使用，我们可以抽象为一个工具类，被所有模块直接调用。
微服务：
该微服务的工具类是不能被其他微服务直接调用，所以只能在每个微服务上都建一个工具类。
-----------------------分割线（↑博客学习内容------↓老师上课内容笔记）-----------------------
一.微服务
a.以业务服务为向导（服务一个或一组相对较小且独立的功能单元）
b.一个大应用由多个服务模块组成，每一个模块单独作为一个服务部署
c.对外开放API
d.简洁、易于部署、运行方便、轻量、非阻塞（并行）。
2.SpringBoot
a.介绍：
1.避免了出现大量的配置
2.内置tomcat、jetty等web容器，不需要部署WAR
3.提供一系列“starter”来简化Maven配置
4.是基于spring给程序员减负的（不需要管jar包（内部自动依赖））。
b.SpringBoot工程创建
1.可在官网上提供向导创建
网址：https://start.spring.io
2.在本地使用工具创建（STS、IDEA）
1.new》Spring Starter Project //需要网络，通过官网创建
2.填写相应配置（类似Maven）》next》选择需要的功能（jar包）
devTools：热部署，保存会自动重新启动服务器。
3.第一次创建需要联网下载jar包
c.命名规律：
spring-boot-*.jar
d.模块
spring-boot-starter
核心
二.SpringBoot程序创建
1.在官网提供向导创建
a.网址：
https://start.spring.io
b.创建
创建工程（类似Maven）
勾选需要的jar包
2.使用工具创建（STS、IDEA等工具）
1.new》SpringBoot》Spring Starter Project（还是会通过访问网址创建）
2.创建工程（类似maven）》next》在core下拉框中选择需要jar包。
选择dev：则会自动编译
3. 联网创建好Boot工程
3.工程结构
a.启动类（com.xxx）
Application.java //初始化spring环境（即是启动类也是spring配置类）
需要使用：@SpringBootApplication注解（组合注解）
@Configuration
@ComponentScan
@EnableAutoConfiguration
运行：项目右键》run as…
b.静态资源（不推荐使用jsp）
存放位置：（main/resource）
static：存放css、js、image
templates：放html模板
模板引擎：Thymeleaf、FreeMarker…
c.其他同SpringMVC规范
com.xxx.xxx.dao
com.xxx.xxx.pojo/
com.xxx.xxx.service
4.测试：
Junit
@RunWith(SpringRunner.class) //使用了什么工具来测试
SPringRunner类（相当于Junit，只是名字短一点）
@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_P)
//标识该类是一个测试类，设置测试环境（Ioc，web环境）
例：（方法之中）
//注入其实例
@Autowired
TestRestTemplate restTemplate;
@Test
public void testHello(){
ResponseEntity<String> res = restTemplate
}
5.配置文件
Spring Boot添加端口、上下文路径
main/resource 配置文件支持（两个任选其一）
application.properties（修改内置的参数变量）
server.port=8888 //修改端口号
application.yml
server
servlet:
context-path:/app
port:8888
N.疑问
1.如果jar包下载出错
查询出错jar包：
项目右键》Run As》mvaen build》在Goals中输入compile
项目右键》update》勾选Force UpDate
2.SpringBoot与SpringMVC的区别
SpringBoot：
将Spring、SpringMVC等基础框架整合起来，提供默认的配置与支持，提供可插拔的设计（也就是starter），方便开发者使用的一系列技术。
它的基础其实就是Spring的IOC、AOP，IOC提供了依赖注入的容器，AOP解决了面向切面编程的问题，其他的高级功能都是在这些基础上扩展的。
SpringMVC：
基于Servlet的一个MVC框架
最初利用“工厂模式”（DI）、“代理模式”（AOP）解耦应用组件，开发出了Spring的MVC框架用于web应用。之后发现每次都要配置许多依赖、写许多样板代码，从而出现了懒人整合包（Starter），也就是SpringBoot
第102天 - - SpringBoot+thymeleaf
一.Thymeleaf开发引擎
1.步骤
1.新建SpringBoot项目时，选择Thymeleaf模板（属于第三方提供）
2.将BootStrap前端框架放入resource》static》css之中
3.resource》template中新建html》html中导入命名空间
<html xmln="http://www:thymeleaf">
4.安装插件Thymeleaf（提示功能）》项目右键》选择Thymeleaf添加
5.使用：
//引入css标签（@表示上下文路径）
<link th:href="@{/css/bootstrap.min.css}" ref="textstyle">
//使用th:text中的值替换标签中的文本值
<div th:text="'Hello'+${name}+'!'"></div>
……
2.标签（详情：该天文件夹中》“基本表达式.txt”）
th:text 替换文本内容
th:utext 替换html（可渲染（解析）值中出现的标签）
th:if、th:unless 条件判断（第二个是取反（如果不是））
th:switch、th:case 有多项选择时可使用
th:each 遍历
简化：<td th:each="m:${mList}">
正规：<td td:each="m,iterStat:${mList}"> //迭代变量,迭代状态:被迭代集合
th:block 不使用html标签，又想在代码外部加层条件时
<th:block></th:block>
……
3.操作
a.文本操作
连接：+
替换：||（例：|The name is ${name}|）
b.数学操作
二元操作：+、-、*、/、%
一元操作：-（负） //这儿不太理解
c.布尔操作
二元：!、not
一元：and、or
d.比较操作
>(gt)、<(lt)、>=(ge)、<=(le)、==(eq)、!= (ne
e.条件
if-then：(if)?(then)
if-then-else：(if)?(then):(else)
Default：(value)?:(defaultvalue)
f.无操作
使用“_”来禁止转义
4.标准表达式（与EL表达式相似）
简单表达式：
变量表达式：（获取后台（Request）、session、application等数据）
${…}
可用值表达式：（从可用值中查找属性）
*{…}
例：
<!-- 上层是object，则查找该对象的ename属性 -->
<div th:object="${emp}">
<div th:text="*{ename}"></div>
</div>
<!-- 以上，等价于： -->
<div th:text="${emp.ename}"></div>
消息表达式:（国际化时使用）
#{…}
#：也可使用内置对象
<td th:text="#dates.format(content.createDate,'yyyy-MM-dd')"></td>
链接表达式：（配合link、src、href使用的语法）
@{…}
片段表达式：（引入公共部分代码片段）
~{…}
N.疑问
1.在template文件夹中创建html文件，会自动创建至webapp中
因为创建的时候，创建页面上方显示的创建路径为webapp中。
解决：删除掉webapp之后就可以了。它就会默认创建到template文件中。
第103天 - - 知识整合：SpringBoot+MyBatis+BootStrap+Jquery+Thymeleaf
N.疑问
1.th:value
该标签有value属性：（input、select…）
给value属性添加/替换值
该标签没有value属性（a、span…）
设置为一个自定义属性，名为value。但是Jquery就不能通过val()方法获得这个value属性的值，需通过attr("value");来获得。
2.异步提交时，alert()一直弹框
使用了失去焦点blur()事件，每次一点alert()弹框的确定，又会失去焦点从而再次触发事件。
N1.（扩展）正则表达式-初步了解
1.非打印字符
\f：换页符
\n：换行符
\r：回车符
\s：空白字符（换页、换行、回车…，等价于[\f\n\r\t\v]）
\S：非空白字符
\t：制表符
\v：垂直制表符
2.特殊字符（需要转义的字符（包括了限定符、定位符等））
$：结尾
^：开始。如果在方括号“[]”中使用，则表示不匹配（取反）
()：子表达式的开始和结束（就是说，在之中写子表达式）
+：一次或多次
?：零次或一次
*：零次或多次
.：除换行符“\n”的任意字符
[：中括号表达式开始
{：限定符表达式开始
\：转义
|：两项之间二选一
3.限定符
+：一次或多次
?：一次或零次
*：零次或多次
{n}：只匹配n次
{n,}：匹配至少n次
{n,m}：最少n次，最多m次
4.定位符
^：开始
$：结束
\b：字边界
例：qwerqwer
\bq：匹配一次（第一个q）
q\b：没有（无论哪个q的后面都不是边界）
\B：非字边界
测试时出现的情况（自边界）：符号也算是边界，例：<h1>
n.其他
贪婪：（尽可能的多匹配）
+、*
非贪婪：（在+、*、?后面加上?）
例：<h1></h1>
<.*?>：匹配两次（<h1>、</h1>）
<.*>：匹配一次（<h1></h1>）
第104天 - - AOP事务、AOP日志
一.AOP事务
1.使用
@Transactional //在服务层使用该注解
例：
@Transactional(readOnly=false,isolation=Isolation.READ_COMMITTED,propagation=PROpagation.REQUIRED)
public int addEmp(){
…
}
理解：
配置事务：
连续添加两条一样的记录，如果第二条出错，第一条也不会提交。
没配置事务：
第二条出错了，但是第一条没出错还是会提交第一条。
二.日志
a.步骤
1.定义一个切面
@Aspect
2.定义切入点（控制器的某个方法）
@Pointcut("execution (* com.newer.controller.*.*(..))") //切入点表达式
3.通知
@Before 前置通知
@After 后置通知
@AfterReturning 返回通知
@Around 环绕通知
@AfterThrowing 异常通知
b.切面优先级
@Order(1)
前置通知：值越小优先级越高
后置通知：值越小优先级越低
理解：先执行的后结束，一层一层套着的。
2.
N.疑问
1.
2.
第105天 - - RESTFUL
一.RESTFUL风格
REST：Representational State Transfer（表述性状态传送）
只是一种风格，虽然不算是标准，但是也接近与一种规范了。
二.RESTFul风格的使用（案例）
控制器使用了:
@RestController（组合注解：@ResponseBody+@Controller）注解。
@RequestBody（将请求的参数作为主体发送到服务端（JSON对象））
@PathVariable（路径变量）
理解：
简洁的路径请求（URL）。更具不同的注解，浏览器使用不同方式发送请求，则会匹配到不同的控制器方法（虽然路径都一样）。
1.GET(select)
/emp/ 得到所有的员工信息
/emp/1 得到编号为1的员工
2.POST(insert)
/emp/ 新增员工
3.PUT(update)
/emp/1 修改员工
4.DELETE(delete)
/emp/ 删除所有员工
/emp/1 删除某个员工
N.疑问
1.在控制中的方法参数上添加@RequestBody之后，无法访问
2.
第106天 - -项目学习
一.
1.什么是跨域
域：
zonghang.bankcomm.com
hr.bankcomm.com
euif.bancomm.com
…等（bankcomm.com就是域）
跨域：
域不一样
www.baidu.com
www.google.com
加密不一样
http://hr.bankcomm.com
https://zonghang.bankcomm.com
端口不一样
解决跨域（如：不同域的session拿不到）
老师提供了工具类。
前端：ajax添加xhrFields
2.验证码
通过工具类与控制器，获得验证码并通过流输出至网页上。
3.开发和部署区别
开发：
编程
部署：
把开发好的东西放在tomact（以后会有其他的）里面去。自己写的class文件、jsp文件复制到服务器里面去，
tomact默认的文件：docs
静态页面（自己的tomcat）和dao层、服务层（在spring的tomcat）有可能不在一个tomcat里面。
4.前后端分离
静态资源与服务端分开部署
静态资源：tomcat》C:\Tomcat8.0\webapps（端口8080）
服务端：STS工作区间（端口号设置为8086）
注意：静态资源需要访问服务器时需要加上端口号：localhost:8086/…/…
N.疑问
1.点击验证码，却不能实现局部刷新
浏览器会对同一url的图片进行缓存，减少向服务器端的请求次数，提高浏览性能。
添加一个随机数（Math.random()、时间戳..等都可以），告诉浏览器该次图片已经失效，需要一个新的图片。
这样才能实现点击更换验证码后实现局部刷新，否则只有刷新页面才能更换验证码图片。
2.无法实现跨域
ajax中配置了：（还是无法实现跨域）
xhrFields:{
withCredentials:true
}
原因：（项目路径：第106天）
获得验证码图片时，访问的是
http://127.0.0.1:8086/api/imagecod //session中设验证码，且返回图片
而使用ajax获得session中的验证码字符串时，访问的是
http://localhost:8086/hospital/login //获取session中验证码
所以，无法再localhost获得127.0.0.1中的session。（域不一样）
3.js调用父页面方法
parent.父页面方法();
4.layer关闭子窗口方法
使用了layer打开新的窗口，则无法使用window.close()关闭。
方法1：
layer_close(); //关闭自身
方法2：（2种是同效果）
//关闭自身
var index = parent.layer.getFrameIndex(window.name); //得到当前iframe层索引
parent.layer.close(index); //再执行关闭，强制关闭弹窗
5.Integer整形转为BigInteger
new BigInteger(Integer变量.toString()); //BigInteger构造方法只能转换String型
6.控制器方法参数为两个对象时，url传递不同对象的属性。会自动封装吗？
无论两个对象的属性名是否相同，都会为他们封装进去。
第111天 - - 工厂项目
第一天.入场
1.SVN服务器搭建
选一人安装SVN作为服务器
服务器：
VisualSVN-Server-3.8.1-x64安装：下一步》下一步..
开启：我的电脑》右键管理》visualSVN点击打开
Users：创建用户
Groups：组，可以有多个组，组里可设置用户
Repositories：资源
great：创建资源
客户端：
装好后，任意地方右键checkOut（下载）、update（更新）、commit（提交）
目录：
ncms
01doc
05项目计划
10需求阶段：需求规格说明书
20设计阶段：数据库设计
30编码阶段：技术
40测试阶段
周报
培训
50上线阶段
02code
Office_Project_Pro_2007_Win32_ChnSimp安装（需要光驱）
那么使用excel
2. 按照项目周期定义目录结构
SVN中一个目录放代码，一个放文档
文档目录结构
概要设计
模块、数据库、包
详细设计：
类、方法、逻辑
集成测试：
系统压力测试
UAT测试
测式报告
调试bug（测到理想为止）
部署上线
WCM精确到人的项目周期计划
界面设计：
3.项目选题确认及技术攻关
文件上传、富文本编辑器（CKEditor）、树型菜单
周一 至 周三：熟悉需求：需求作业、任务分解
技术攻关
二.数据库-知识点记录
1.数据库-触发器
a.作用
1.安全性
2.审计
3.实现复杂数据的完整性规则
…
b.语法：（执行该语句，为“tb_name”添加触发器）
CREATE TRIGGER trigger_name trigger_time trigger_event ON tb_name FOR EACH ROW trigger_stmt ;
trigger_name：创建的触发器的名称
trigger_time：触发时机
BEFORE：在事件触发之前
AFTER：事件触发之后
trigger_event：触发事件
INSERT：建立的触发器添加数据时触发
DELETE：删除时触发
UPDATE：修改时触发
tb_name：表的名字，在什么表上建立触发器
trigger_stmt：触发器的程序体。
可以是SQL语句：
或用BEGIN和END包含的多条语句：
BEGIN INSERT INTO 表1 VALUE(1,2,3) END
例：
CREATE TRIGGER t1 //创建触发器，并指定触发器名字
BEFORE INSERT ON USER //指定触发时机、类型，触发的表
FOR EACH ROW //任一条记录上的操作满足触发事件都触发
BEGIN //BEGIN和END之间可包含多条语句
INSERT INTO user_order VALUES(3,5,now(),"5号员工订阅了3号事项");
END
删除触发器：
drop trigger 触发器名称
查询触发器：
-- mysql 的 ；
select * from information_schema.triggers ;
-- oracle 的；
select * from user_triggers
2.指定定界符
作用：
mysql默认使用“;”作为执行语句，与触发器中需要的分行起冲突，需要将其改为其他定界符。
语法：
DELIMITER || //将定界符“;”改为“||”
使用之后需要将其改回“;”：DELIMITER;
3.MySql创建存储过程
存储过程：可以有多个返回值
语法（其一）：
CREATE PROCEDURE test(in a int)
BEGIN INSERT INTO test VALUES(a);
END
删除：DROP PROCEDURE IF EXIST 存储过程名
N.疑问
总结：
经过一段时间的学习，对于学习自然也有了一点自己的理解，这里就给大家分享一下。
首先，想要学习的有效率，我们肯定是需要规律的学习时间的，那么该如何选择学习时间呢。这时我们要知道，一整天的时间，理论上排除睡觉时间，有16个小时是可用的，但实际情况却完全不是这样，之中肯定会有许多打断你的事情。所以按照自己的生活习惯来给自己的学习生活做一个规划。这里的建议就是把学习时间分为几段来进行，当自己每完成一段时就会有一种完成任务的感觉，这种感觉会使自己的学习状态不至于那么枯燥。
还有就是尽量不要选择晚上学习。晚上学习进入了状态的话，为了攻克一个难点而熬夜到凌晨一、二点，或许你会有“我好努力啊！”这种感觉，不过这样却不是高效率的一种办法。睡觉前大量的用脑，会让你的脑袋又紧张有疲惫，会影响自己的睡眠质量，从而造成隔天的学习状态的不集中。而且睡觉前长时间盯着电脑屏幕，也会在睡醒后造成眼睛的酸肿。当然，如果你喜欢，也习惯了晚上学习，也不注重发际线、脸上的痘痘的话，那就按照自己的学习方式也未尝不可。
接着就是上课上所需要注意的几个点了，认真听讲、课前预习、课后回顾、保持好的学习状态，这几个词、句就算已经用的烂大街了，不过它们依然对你上课能学到什么程度起到关键的作用。
老师讲课的时候一定要做笔记，就算老师课后会分享他的上课过程。可以根据自己的喜好选择用笔记本或则直接使用电脑来记录上课内容，不过个人更加推荐使用电脑的word文档。word文档的基础操作并不复杂，大小标题结构也非常清晰，再加上记录笔记的同时也可以锻炼打字速度，一举多得何乐而不为？自认为其中最终要的一点还在于可以集中自己的精神。上课如果无所事事，看着老师在台上晃来晃去，晃得久了，如果没有着坚强的意志力，上课期间都有着较好的状态这种情况几乎是很难保持的。而现在你只需要动一动自己的手指，跟着老师的进度，把每一个知识点敲下来。相信你对上课内容的理解也会更进一步的。
老师讲课时认真听讲是作为一个学生最基本的义务，也是学生最基本需要达到的要求。而要真的学到东西，绝对不只是上课听讲就可以做的到的。你必须在课后花上足够的时间才能达到基本的预期。对于课后、生活上的学习，这里就有许多自己进步期间所领悟到的一些思想，这些思想也只是基于自己的环境所得出的，也许并不能适合你的学习方式，但是也可以做一个基本的参考。自己一直相信是有天赋这个东西的，但是他绝对不在我们身边，因为能成为自己周边的人，那么天赋的差距也并不会太大。所以不要去管天赋，记住努力就好了。学习中有可能会出现“为什么他们都知道”这种想法，从而产生怀疑自己的状态。请相信那些什么都知道的人，也是经历过这种心情的，压下这种怀疑自己的心情，去敲自己的代码吧。
人的精力是有限的，一个人的时间就这么多，每天每人也就24个小时，在一方面取得了成就，在另一方面就必然会不太顺心，既然长大了就要去学会取舍。也不要去羡慕那些游戏又厉害，学习也厉害的人，这都是假象，（除非你的生活除了学习就是适当的游戏）。
进步时提醒自己前面还有很多比自己厉害的人，失败时告诉自己没有什么人可以不经历失败就成功。谦虚使人进步，骄傲使人落后。等大部分名言，他们之所以是名言，不是一个或两个人说它是名言它就是名言了。如果有些名言用在自己身上有空子可以钻的话，毕竟他不是为你而写，请取出自己需要的东西就好。
学习状态，沉下心，不急躁。遇到不会的难点，你可以放弃，也可以选择死磕，但是请一定记住自己是在学习。放弃，那么去学习其他对自己有帮助的东西就好。死磕的话，请做好看到不会的语法、专业名词、或者哪怕是一个单词就去百度百科或查阅资料，直到你认为可以了的程度。这种死磕方法可以应付大多稍微超过自己能力范围的知识点。无论什么都需要积累，今天你知道了这些，下次在遇到会有一种惊喜的感觉。
手机真的是科技发展的伟大发明，如果使用的好，他可以取代很多传统的学习方式，你可以在碎片时间背背单词、看看新闻、查阅一下资料、下载几本与专业有关的书籍等等，前提是你不玩手机游戏。带来好处的同时，也给生活带来了些许困扰，这里也可以给出几点建议：上厕所不带手机、上床睡觉不带手机。
终于到最后一点了，没想到一口气居然写了怎么多，真是头皮发麻啊！那么就来聊一下压力吧。压力太大感到自己头都要炸了，或则感到自己能力不够，快要放弃了的时候。那么就先小小的放弃一段时间吧，先做10个俯卧撑、仰卧起坐、深蹲，然后踱步一分钟，在做一组。洗个澡。好了，满血复活。