一、web技术介绍

jsp介绍：

  • 一种动态网页技术标准，

流程

jsp->java(servel)->class

特点

跨平台，动静分离，可重用组件，继承servlet，预编译

jsp工作原理

image-20200319112148058

（1） 客户端（如IE浏览器）向服务器（如Tomcat）发出请求（Request）。

（2） JSP服务器（如Tomcat）将JSP翻译成Servlet源代码（即.java代码）。

（3） 将产生的Java代码进行编译，使之成为.class文件，将.class文件加载到内存执行。

（4） 把执行结果（标准的HTML文本）作为响应（Response）发送至客户端由浏览器解释显示。

JSP开发方式

![image-20200319112218270](https://gitee.com/mingyuefusu/blogimages/raw/master/typora-user-images/image-20200319112218270.png

二、基础知识

URI

定位符

资源符

其中uri表示标签描述符

URI，通一资源标志符(Uniform Resource Identifier， URI)，表示的是web上每一种可用的资源，如 HTML文档、图像、视频片段、程序等都由一个URI进行定位的。

<2>URI的结构组成

URI通常由三部分组成：

①访问资源的命名机制；

②存放资源的主机名；

③资源自身的名称。

<3>URI举例

如：https://blog.csdn.net/qq_32595453/article/details/79516787

我们可以这样解释它：

①这是一个可以通过https协议访问的资源，

②位于主机 blog.csdn.net上，

③通过“/qq_32595453/article/details/79516787”可以对该资源进行唯一标识（注意，这个不一定是完整的路径）

URL

URL是URI的一个子集。它是Uniform Resource Locator的缩写，译为“统一资源定位 符”。

通俗地说，URL是Internet上描述信息资源的字符串，主要用在各种WWW客户程序和服务器程序上。

采用URL可以用一种统一的格式来描述各种信息资源，包括文件、服务器的地址和目录等。URL是URI概念的一种实现方式。

protocol :// hostname[:port] / path / [;parameters][?query]#fragment

①第一部分是协议(或称为服务方式)。

②第二部分是存有该资源的主机IP地址(有时也包括端口号)。

③第三部分是主机资源的具体地址，如目录和文件名等。

隐藏注释

  • <%– comment –%>

  • <!– 注释还可以使用java语句–>

  • <%//啥都看不到%>

变量声明

全局变量、定义方法

<%!    

public int a = 10; 
public String name;
public void init()&#123;
    name="ming";
&#125;

%>

输出

<%= “shuchu”+expression+””将其输出”” %>

脚本

<% 所有java语法 %>

常用指令

<%@ %>

page指令

<%@page language=”java” import=”java.util.Date”%>

<%@page contentType=”text/html” pageEconding=”UTF-8”%>

  • contentType浏览器解析编码

  • pageEconding 文件自身编码

image-20200320203042406

taglib指令

<%@taglib uri=”http://java.sun.com/jsp/jstl/core" prefix=”c”%>

<c:out value-“输出语句”</c:out>

include指令

两个界面合二为一

<%@ include file=”fliename” %>

JSP常用动作

作用

在客户端请求jsp页面时，利用jsp动作可以传递参数、动态的插入文件、重用javabean组件、把用户重定向到另外的页面

<jsp:param>

简介

可以用于<jsp:include>、<jsp:forward>和<jsp:plugin>动作体重，为其他动作提供附加信息

语法

<jsp:param name="paramName" value="param Value"/>
<!--
    name属性用于指定参数名称、不接受动态值
    value属性用于指定参数值，可以接受动态值
!-->
<%=request.getParameter("Xname")%></%>

六大动作：

<jsp:include><jsp:useBean><jsp:setProperty><jsp:getProperty><jsp:plugin/><jsp:forward>

<jsp:include>

简介

把指定文件插入正在生成的页面中，会生成两个class文件

语法

<jsp:include page="relatibe URL" flush="true"></jsp:include>
或者
<jsp:include page="fileName" flush="true">
    <jsp:param name="paramName" value="param Value"/>
</jsp:include>

    page属性指定资源的相对路径，接受动态值
    flush属性指定包含在目标资源之前是否刷新输出缓冲区，默认为false，不接受动态值

与include对比

特点
<%@include file=”文件名”%> JSP页面转换为servlet之前插入代码
<jsp:include page=”文件名” flush=”true”> 主页面被请求时，将其他页面的输出包含进来
区别 调用时间不同，<jsp:include>动作在请求期间，include在页面转换期间
结论 include指令执行时将被导入页面的p代码完全融入,两个页面融合成一个 Servlet;
<jsp: include>动作则在 Servlet中使用 include方法来结论引入被导入页面的内容
因此 Include指令执行时不需编译,速度快;<jsp: include>动作需要加载执行,速度慢

<jsp:useBean/>

作用

装载一个将在JSP页面中使用的javaBean，实现JavaBean组件重用

语法

<jsp:userBean id=”beanInstanceName” scope=”page | request | session | application” class=”package.class” type=”package.class” beanName=”package.class”/>

  • id ：指定JavaBean实例名称，不接受动态值，如果找到id和scope相同的备案实例，将使用
  • scope：指定bean作用域范围，不接受动态值
    • page：默认，在当前页面有效
    • request：在当前客户请求内有效
    • session：在当前httpSession内（会话作用域）
    • application：在任何相同的application的JSP页面都有效，整个应用程序范围内
  • class：指定bean的类路径和类名，不接受动态值，不能是抽象的
  • type：指定应用该对象的变量的类型，必须是bean类的名字、超类名字、该类所实现的接口名称之一。变量的名字由id属性指定
  • beanName：指定bean的名字，接受动态值，beanName属性必须与type属性结合使用，不能与class同时使用

例子

<jsp:useBean id=”time” class=”java.util.Date”/>

<%=time %>

或者

<jsp:useBean id=”time”type=”java. io. Serializable” beanName=”java util. Date”/>

<jsp:setProperty/>

作用

用来设置、修改已经实例化的bean中的属性值

语法

<jsp:setProperty name=”beanInstanceName” property=”*”|property=”propertyName” [param=”parameterName” | value =”value”]/>

  1. name属性:必需。它表示要设置哪个Bean的属性,不可接受动态值。

  2. property属性:必需。它表示要设置哪个属性。如果 property的值是
    表示所有名字和Bean属性名字匹配的请求参数都将被传递给相
    应属性的set方法。

  3. param属性:可选。它指定用哪个请求参数作为Bean属性的值。如果当
    前请求没有参数,则什么事情也不做,系统不会把null传递给Bean属性
    的set方法。因此,可以让Bean自己提供默认属性值,只有当请求参数
    明确指定了新值时才修改默认属性值。

  4. value属性:可选。该属性用来指定Bean属性的值。

<jsp:getProperty/>

作用

获取指定Bean属性的值，转换成字符串，然后输出

语法

<jsp:getProperty name=”beanInstanceName” property=”property”/>

name: 要获取属性的Bean的名称，不接受动态

property：指定要获取的Bean属性名，不接受动态

<jsp:forward/>

作用

引导客户端的请求到另一个页面或另一个Servlet,只能跳转本网站的

==<jsp:forward>动作只能在本网站内转向，而response对象的sendRedirect()方法可以转跳到任何页面。==

语法

<jsp:forward page=”relativeUrL” />

可以包含多个<jsp:param>子动作，用于向要引导进入的界面传递参数，当<jsp:forward>动作发生时，如果已经有文本写入输出流，而页面没有设置缓冲，则会抛出异常

<jsp:plugin/>

总结

  1. useBean类中使用getLoginName()方法接受数据，使用setLoginname传出数据，使用时，使用<jsp:useBean>的new对象名id，<jsp:setProperty>通过name对象的setX()方法给X赋值,<jsp:getProperty>通过name对象的getX()方法输出X

  2. 通过request.getParameter(“username”)直接获取post过来的值，再通过

    <jsp:forward page="success.jsp">

    <jsp:param name="user" value="<%=name%>"/>

    </jsp:forward>跳转

三、eclipse设置

默认编码

1.打开eclipse,找到windows–>preference。

2.进入preference后点击Web。

3.在Web下选择jsp files。

4.在右边找到encoding修改为自己希望的编码。

UTOOLS1589439621397.png

UTOOLS1589439633331.png

UTOOLS1589439643665.png

  • tomcat7
    • get:
      • 修改server.xml,更改默认get方式的编码（服务器托管模式,双击服务器),在端口列添加URIEncoding=”UTF-8”
      • name = new String(name.getBytes(“iso-8859-1”), “utf-8”);
    • post: request.setCharacterEncoding(“utf-8”);

报错

tomcat

好像要先运行java程序才能设置

UTOOLS1589435761739.png

javax.servlet.http.HttpServlet

JavaWeb: 报错信息The superclass “javax.servlet.http.HttpServlet” was not found on the Java Build Path:

​ 报错原因：Javaweb工程类中没有添加Tomcat运行时相关类导致。

​ 调试方法：

​ 对项目添加Tomcat运行时

​ 1、右击web工程–>属性或Build Path–>Java Build Path–>Libraries–>Add Libray–>Server Runtime–>Tomcat Server

​ 2、切换到Java Build Path界面中的Orader and Export，选择Tomcat。

1.右键 —-》 Properties —-> Java Build Path —-> Libraries —-> ClassPath —->Add Library —-> Server Runtime —-> Next —-> 选择tomcat —-> Finish

四、JSP常用内置对象

总览

==九大内置内置对象：request、response、out、session、application、config、pageContext、page和exception==

对象名称 所属类型 作用域 说明
request javax.servlet.http.HttpServletRequest request 提供对客户端HTTP请求数据的访问
response javax.servlet.http.HttpServletResponse page 响应信息，用来向客户端输出数据
session javax.servlet.http.HttpSession session 用来保存在服务器与一个客户端之间需要保存的数据，当客户端关闭网站的所有网页时，session变量会自动消失
out javax.servlet.jsp.JspWriter page 提供对输出流的访问
application javax.servlet.ServletContext application 应用程序上下文，允许JSP页面与包括在同一应用程序中的任何web组件共享信息
pagContext javax.servlet.jsp.PageContext page JSP页面本身的上下文，它提供了一组方法来管理具有不同作用域的属性
page javax.servlet.jsp.HttpJspPage page JSP页面对应的Servlet类实例
config javax.servlet.ServletConfig page 允许将初始化数据传递给一个JSP页面
exception java.lang.Throwable page 由指定的JSP“错误处理页面”访问的异常数据

out对象

基础知识

out对象调用print/newLine方法将数据输出到网页上，能控制管理输出缓冲区和输出流

方法

  1. print()/println()
  2. newLine()
  3. flush() 输出并清除缓冲区数据
  4. clearBuffer() 清除缓冲区
  5. getBufferSize() 获取缓冲区大小
  6. getRemaining() 获取剩余缓冲区空间
  7. isAutoFlush() 是自动刷新缓冲区返回1
  8. close() 关闭输出流

request对象

存储请求消息

方法

方法 说明
setAttribute(String name,Object obj) 用于设置request中的属性及其属性值
getAttribute(String name) 用于返回name指定的属性值，若不存在指定的属性，就返回null
removeAttribute(string name) 用于删除请求中的一个属性
getParameter(string name) 用于获取客户端传送给服务器端的参数值
getParameterNames() 用于获取客户端传送给服务器端的所有参数名字
getParameterValues(String name) 用于获取指定参数的所有值
getCookies() 用于返回客户端的所有Cookie对象，结果是一个Cookie数组
getCharacterEncoding() 返回请求中的字符编码方式
getRequestURI() 用于获取发送请求字符串的客户端地址
getRemoteAddr() 用于获取客户端IP地址
getRemoteHost 用于获取客户端名字
getSession([Boolean create]) 用于返回和请求相关的session。create参数是可选的，true时，若客户端没有创建session，就创建新的session
getServerName() 用于获取服务器的名字
getServletPath 用于获取客户端所请求的脚本文件的文件路径
getServerPort() 用于获取服务器的端口号
setCharacterEncoding(String charact) 指定请求编码，在getParameter()方法前使用，可以解决中文乱码问题

  1. String getParameter(String name)

    用于获取传过来参数的值，不存在则为null

    int age = Integer.parseInt(request.getParameter("username"));

  2. getParameterNames（）

    用于获取传过来的所有请求参数名称，得到Enumeration类的实例

  3. String[ ] getParameterValues(String name)

    用来获取传过来的参数的所有值，返回字符串数组,checkboxs

    String[] hobbies = request.getParameterValues("hobbies");
if(hobbies != null)&#123;
    for(String hobby : hobbys)&#123;
        out.print(hobby+ "&nbsp");
    &#125;
&#125;

  1. getAttribute(String name)

    获取request对象的指定属性的值，不存在返回null

  2. setAttribute(String name, Object obj)

    设置request对象中的属性及其属性值

  3. removeAttribute(String name)

    删除request对象中的指定属性及其属性值

  1. void setCharacterEncoding(“utf-8”)

    • 设置请求编码，tomcat7以前默认不是utf-8

  2. getRequestDispatcher(“b.jsp”).forward(request, response);

    • 请求转发的方式跳转 a->b，页面不会变！

    • 数据不会丢失

  3. getServerContext();

    • 获取项目的ServletContext对象

Vector

//定义
Vector errs = new Vector();
//添加
errs.addElement(new String("xxx"));
//输出
errsCount = errs.size();
String str = new String("");
for(int i=0; i<errsCount; i++)&#123;
    errOut += errs.elementAt(i).toString();
    errOut += "<br>";
&#125;

其他方法

getCharacterEncoding()

getContentLength()

getContentType()

getContextPath()

服务器地址

request.getLocalAddr()

服务器名称

request.getLocalName();

image-20200323181847734 image-20200323181905704 image-20200323181922669

response对象

响应对象

简介

  • 将服务器端相应数据发送到客户端
  • 与request组成接受、发送数据的对象
  • 重定向客户端请求
  • 实现动态的基础

基础方法

反了？？？

  • void addCookie(Cookie cookie)

  • void sendRedirect(String location)

    • 重定向、地址栏改变、第一次请求的数据数据丢失、请求2次
    • 服务器自己搞定
    • image-20200330121806398
    • request.getRequestDispatcher(“success.jsp”).forward(request,respond);
    • 请求转发、地址栏不变、第一次请求的数据不变、请求一次
      • 客户端发出第二次
      • image-20200330121818514

  • void setContentType(String type)

    设置服务端响应的编码

image-20200324001919238 image-20200324001935485 image-20200324001954095

setHeader(“refresh”, “1”) 设置指定名称和字符串的http文件头信息

setCharacterEncoding(“UTF-8”) 设置相应的字符编码方式

sendRedirect(“http://“) 重新定向客户端的请求

session对象

简介

  • 值客户端与服务器端的一次会话，从客户端连接到服务器开始，直到客户端与服务器断开连接为止，

  • 客户端第一次请求客户端时，服务端会产生一个session对象，保存该客户的信息

    每个session对象都会有一个唯一的sessionID（用于区分其他session）

    服务端产生一个cookie并发送个客户端，将cookie的name=JSESSIONID，value的服务器sessionID的值，

    sessionID与JESSIONID一一对应

  • 第一次访问时，服务器端产生一个sessionID并赋值给cookie的jessionID并发送给客户端。

与cookie

  • session：在服务器端，会话：开始到结束,保存的是Object

  • cookie

    • 客户端，不是内置对象：由服务端产生，发送给客户端保存

    • 本地缓存作用，提高访问服务端的效率，安全性较差，保存String

    • 服务端会自动new一个cookie(name=JSESSIONID)

    • Cookie: key=value

    • javax.servlet.http.Cookie

    • 方法

      • void setMaxage(init expiry) 最大有效期(秒)

    • String getName() 获取name

  • public Cookie(String name, String value)

    • 增加cookie

    • Cookie cookie = new Cookie(“name” ,”ming”);

    • response.addCookie(Cookie cookie);

    • 获取cookie(先跳转到客户端，转发、重定向)

      • Cookie[] cookies = request.getCookies(); 只能获取全部

      • for(Cookie cookie : cookies){

        ​ out.print(cookie.getName()+ “ “+ cookie.getValue());

        }

      • 除了自己设置的，还有name: JSESSIONID的cookie

方法

方法 说明
Object getAttribute(String attriname) 用于获取与指定名字相联系的属性，如果属性不存在，将会返回null
void setAttribute(String name,Object value) 用于设定指定名字的属性值，并且把它存储在session对象中
void removeAttribute(String attriname) 用于删除指定的属性（包含属性名、属性值）
Enumeration getAttributeNames() 用于返回session对象中存储的每一个属性对象，结果集是一个Enumeration类的实例
long getCreationTime() 用于返回session对象被创建时间，单位为毫秒
long getLastAccessedTime() 用于返回session对象最后发送请求的时间，单位为毫秒
String getId() 用于返回session对象在服务器端的编号
long setMaxInactiveInterval() 用于返回session对象的生存时间，单位为秒
boolean isNew() 用于判断目前session是否为新的session，若是则返回true，否则返回false
void invalidate() 用于销毁session对象，使得与其绑定的对象都无效

  1. void setAttribute(String name, Object value);

    ​ String.valueOf(number);

    Integer.parseInt(obj.toString());

  2. Object getAttribute(String name); 不存在返回null

  3. removeAttribute(String name) ;删除指定属性

  4. getAttributeName(); 返回session对象中所有属性的名称，结果是一个枚举类型的对象

  5. getLastAccessedTime(); 返回当前session对象相关的客户端最后发送请求的时间

  6. setMaxInactiveInterval(int interval); 设置有效时间

  7. invalidate(); 使session对象失效，存放在session对象中的所有对象都不能再访问

  8. isNew(); 判断是由为新session

  9. getCreateTime(); 返回session对象呗创建时间，单位毫秒

  10. getId(); 返回session对象的ID

  1. String getId(); 获取sessionID

  2. boolean isNew(); 是否是第一次访问

  3. void invalidate(); 使session失效

  4. setAttribute(String, Object);

  5. Object getAttribute();

  6. void setMaxInactiveInterval(秒) 设置最大有效非活动时间(不操作时间)

  7. int getMaxInactiveInterval();

  8. void removeAttribute();

pageContext对象

简介

  • 对jsp页面所有对象及命名空间的访问
  • 几种页面属性的访问
  • 允许向其他应用组件转发request对象
  • 创建和初始化都是由容器完成的

方法

  1. setAttribute(String name, Object attribute); 页面范围
  2. setAttribute(String name, Object obj, int scope); 指定范围
  3. getAttribute(String name, int scope); 获取指定范围内指定属性的值
  4. getAttribute(String name); 用于获取页面范围内指定属性的值
  5. getOut() 返回当前的out对象
  6. getPage() 返回当前的page对象
  7. getRequest()
  8. getResponse()
  9. getSession()
  10. getServletConfig()
  11. getException()
  12. getServletContext()
  13. findAttribute(String name); 按照页面、请求、会话、以及应用程序范围的顺序实现对指定属性的搜索，返回其属性值或null
  14. forward(java.lang.String relative UrlPath); 用于把页面重定向到另一个页面或servlet组件上
  15. removeAttribute(); 删除所有对象范围或特定对象范围中的指定属性及其属性值
  16. release（） 释放pageContext所占资源
  17. include(String relativeUrlPath) 当前位置包含另一文件

exception对象

简介

处理jsp文件在执行时的错误和异常

配合page指令一起使用，在page指令中errorPage属性指定某一个页面为出错误页面处理页面，把所有错误都在该错误页面处理，错误页面中的page指令isErrorPage属性为true

方法

  1. getMessage() 返回错误异常提示信息
  2. getlocalizedMessage() 获取本地化错误信息
  3. printStackTrace() 输出异常对象及其堆栈跟踪信息
  4. toString() 返回关于异常的简短描述信息

application对象

理解

保存web应用应用程序中共有的数据，可存放全局变量，服务器启动后创建application对象，有效期至服务器关闭

==与session区别==

一个用户对应一个session，一个应用程序中的jsp文件共享一个application对象

  • （1） 每个客户拥有自己的session对象，保存客户自有信息。如果有100个访问客户，就有100个session对象。所有客户共享同一个application对象，保存服务器运行期所有客户的共享信息，即使有100个访问客户也只有1个application对象。

  • （2） session对象生命期从客户打开浏览器与服务器建立连接开始，到客户关闭浏览器为止，在客户的多个请求期间持续有效。application对象生命期从服务器启动开始，到服务器关闭为止。

  • （3） 可以使用session对象存储某个客户在一个会话期间的数据，例如记录某个客户的姓名、密码等。使用application对象存储服务器运行期所有客户共享的变量，例如记录所有客户的访问次数等。

方法

（1） Object getAttribute(String attriname)：获取指定属性的值。

（2） void setAttribute(String attriname,Object attrivalue)：设置一个新属性并保存值。

（3） void removeAttribute(String attriname)：从application对象中删除指定的属性。

（4） Enumeration getAttributeNames()：获取application对象中所有属性的名称。

  1. getAttribute(String name);
  2. getAttributeNames(); 返回Enumeration类型
  3. getServerInfo(); 返回servlet容器名称和版本信息
  4. getContext(String uripath); 返回指定的webApplication的application对象
  5. getMimeType(String file); 返回指定文件的MIME类型
  6. getResource(String path); 返回指定资源的URL路径
  7. getServlet(String name); 返回application对象指定servlet
  8. setAttribute(String name, Object obj);
  9. removeAttribute(String name);
  10. log(String msg ); 指定信息写入Servlet日志文件
  11. application.getContextPath(); 获取相对路径
  12. application.getRealPath(); 获取绝对路径

request、session、application

application：全局作用域，生命周期从应用程序启动到结束

session：会话作用域，首次访问产生，关闭浏览器结束

request：请求作用于，客户端的一次请求，生命周期为一次请求或使用forward方式执行请求转发，也就是使用forward方式跳转多个jsp，这个页面可以使用，刷新后失效

config对象

page对象

相当于this

四大范围对象

pageContext page对象：当前页面有效

request 请求对象:同一次请求，request.getRequsetDispatcher(“ “).forword(request, response)

session 会话对象：同一次会话

application 全局对象：全局,不同浏览器也有效，重启服务器后无效

共有方法:

Object getAttribute(String name);

void setAttribute(String name, Object obj); 设置属性值(新增，修改);

void removeAttribute(String name);

五、数据库

JDBC

JDBC（Java DataBase Connectivity）是一种访问数据库的技术标准，它是一种能通过Java语言访问数据库的应用程序接口（JDBC API），由一组用Java语言编写的类和接口组成。对于访问一些使用结构化查询语言SQL的关系型数据库尤为有效。

连接数据库

编码

创建数据库

create database name default charset=utf8;    
create table name() default charset=utf8;

命令行

set character_set_results=gbk;

概念

image-20200331110543214

image-20200413170337942

java.sql.DriverManager：用来加载和注册不同的JDBC驱动程序，为创建连接数据库提供支持。

配置

  • 将mysql-connector-java-5.11.31-bin.jar放入WEB-INF/lib

  • Build Path libraries add External

    image-20200329155018835

验证

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%@page import="java.sql.*" %>



<%@page import="java.sql.DriverManager" %>
<%@page import="java.sql.ResultSet" %>
<%@page import="java.sql.Statement" %>
<%@page import="java.sql.Connection" %>





数据库


    
        <%
            Connection con = null;
            Statement stmt = null;
            ResultSet rs = null;
            Class.forName("com.mysql.jdbc.Driver");
            String url="jdbc:mysql://localhost:3306/blog?useUnicode=true&characterEncoding=UTF-8";
            con = DriverManager.getConnection(url, "root", "root");
            stmt = con.createStatement();
            String sql = "select * from cat";
            rs = stmt.executeQuery(sql);
            while(rs.next()){
        %>
        
        <%} 
            rs.close();
            stmt.close();
            con.close();
        %>
    

        

            id
            catname
            num
        

            <%=rs.getString("cat_id") %>
            <%=rs.getString("catname") %>
            <%=rs.getString("num") %>

SQL查询

SQL查询语句

select [all|distinct] column1[,column2]
from table1,table2
[where "conditions"]
[group by "column-list"]
[having "conditions"]
[order by "column-list" [asc|desc]]

jsp执行

  • Statement

    • 不带参数的SQL语句

  • PreparedStatement

    • 带有IN类型参数的预编译过的SQL语句

       PreparedStatement pstmt=con.prepareStatement("insert into book values(?,?,?,?)");
  pstmt.setString(1,"05-01-18-1");
  pstmt.setString(2,"《SQL Server 7.0设计实务》");
  pstmt.setString(3,"人民邮电出版社");
  pstmt.setDouble(4,55.6);
  pstmt.execute();
  pstmt.close();

  • CallableStatement

    • 执行数据库的存储过程

  • 继承

jsp发送执行查询语句

  1. Statement

    • Statement stmt = connection.createStatement(int type, int concurrency);
    • type
      • ResultSet.TYPE_INSENSITIVE右边上下滚动，数据库变化时，当前结果集不变
      • ResultSet.TYPE_SENSITIVE游标上下滚动，数据库变化时，当前的结果集随着变化
    • Concurrency参数
      • ResultSet.CONCUR_READ_ONLY不能用结果集更新数据库中的表
      • ResultSet.CONCUR_READ_UPDATEABLE可用结果集更新数据库中的表

  2. Statement常用方法

    createStatement()

    image-20200329184559937

  3. PreparedStatement

    prepareStatement() 无d

    • 预编译处理，SQL语句中包含一个或多个IN参数，提高SQL语句的速度,提高性能，安全（避免SQL注入）

    • IN参数用？代替

    • pstmt = connection.prepareStatement(“SELECT * FROM student WHERE 年龄>=? AND 性别=?”);

      pstmt.setInt(1,22);pstmt.setString(“nan”);

    • pstmt = connection.prepareStatment(sql);

      pstmt.setInt(1,333);pstmt.setString(2,”sdf”);

    • rs = pstmt.executeQuery();

  1. Callablestatement

    connection.prepareCall();

    • 存储过程（无返回值，用out参数替代）

      {call 存储过程名（参数列表）}

      image-20200331162251435

    • image-20200331162729778

      返回值

      image-20200331163228158

      image-20200331163428646

    • 存储函数（有返回值return）

      {？ = call 存储函数名(参数列表)}

      connection.prepareCall(“{call add TwoNum(?,?,?)}”);

    ​ image-20200331163825392

    image-20200331163723221

  2. ResultSet

getString(字段名|位置0)

image-20200329185553465

SQL更新

插入

insert into table_name(column_list)

values( )

更新

update table_name

set column_name = expression

where

删除

delete from table_name

where

获取的数据

ResultSet rs = statement.executeQuery(“select * from blog”);

1开始

  • rs.getInt()
  • rs.getString(1)
  • rs.getDate()

总结

总流程

  • 驱动Class.forName()
  • 连接DriverManager.gerConnection()
  • 操作数据库对象connection.createStatement()
  • 数据executeQuery()

image-20200413172830974

//1.加载驱动程序
Class.forName("com.mysql.jdbc.Driver ") 
//2.连接数据库
Connection con = DriverManager.getConnection
("jdbc:mysql://localhost:3306;DatabaseName=jspdb","root","123456")
//3.执行SQL(创建SQL语句，执行SQL语句)
Statement stmt = con.createStatement() 

ResultSet rst = stmt.executeQuery("select * from book;")

//返回修改多少条数据
ResultSet rst = stmt.executeUpdate("update table_name set age=1 where id=1 ");

//4.关闭连接
rst.close();    stmt.close();    con.close()

解析

  1. JDBC:java DataBase Connectivity可以为多种关系型数据库提供统一的访问方式

  2. JDBC API：

    1. Connection：连接,由DriverManager产生
    2. Statement（PreparedStatement）：增删改查，通过Connection产生
    3. CallableStatement：调用数据库中的 存储过程/存储函数
    4. Result：返回的结果集

  3. jdbc访问数据库过程

    1. 导入驱动，加载驱动类
    2. 建立连接
    3. 发送SQL
    4. 处理结果集

  4. 数据库驱动

    image-20200331114935247

未解之谜

package test;

import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.mysql.jdbc.Connection;
import com.mysql.jdbc.Statement;

public class DB &#123;
    public static void update() throws ClassNotFoundException, SQLException &#123;

        Connection con = null;
        Statement stmt = null;
        ResultSet rs = null;
        try &#123;
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://localhost:3306/blog?userUnicode=true&characterEncoding=UTF-8";
            con = (Connection) DriverManager.getConnection(url, "root", "root");
            stmt = (Statement) con.createStatement();
            String sql = "select * from cat";
            rs = stmt.executeQuery(sql);
            //int sum = stmt.executeUpdate(sql);
            while(rs.next())&#123;
                System.out.println(rs.getString("cat_id"));
            &#125;
        &#125;catch(ClassNotFoundException e) &#123;
            e.printStackTrace();
        &#125;catch(SQLException e )&#123;
            e.printStackTrace();
        &#125;catch(Exception e)&#123;
            e.printStackTrace();
        &#125;finally &#123;
            try &#123;
                if(rs!=null) rs.close();
                if(stmt!=null) stmt.close();
                if(con!=null) con.close();
            &#125;catch(SQLException e) &#123;
                e.printStackTrace();
            &#125;
        &#125;
    &#125;

    public static void main(String[] args) throws ClassNotFoundException, SQLException &#123;
        update();
        System.out.println("???3??");

    &#125;
&#125;

异常

ClassNotFoundException :Class.forName()

SQLException

Exception


    try&#123;
        ...
    &#125;catch(Exception e)&#123;
        ...
    &#125;finally&#123;
        ...
    &#125;

if(rs!==null) rs.close();

先打开后关闭

六、JavaBean

模式一

基础知识

概念

  • JavaBean是Java Web程序的重要组成部分，是一个可以重复使用的软件组件，是一个遵循特定写法的Java类，它封装了数据和业务逻辑，供JSP或Servlet调用，完成数据封装和数据处理功能。
  • 作用：主要负责表示业务数据或者处理事务的JavaBean，如访问数据库，执行查询操作的JavaBeans， 它们在运行时不需要任何可视的界面。在JSP 程序中所用的JavaBean一般以不可见的组件为主 (即处理内部事务，不输出)。

好处

“一次性编写，任何地方执行，任何地方重用”

自动生成修改获取方法

image-20200416105253870

实质：java类

package ch09
public class Login &#123;
    private String userName; //户名
    private String password; //密码
    public Login()&#123;

    &#125;
    public String getUserName()&#123;
        return username
    &#125;
    public void setUserName( String userName)&#123;
           this.userName = userName;
    &#125;
    public String getPassword()&#123;
        return password;
    &#125;

    public void setPassword(String password)&#123;
        this.password = password
    &#125;
&#125;

规范

编写JavaBean

设计JavaBean就是编写一个Java类，用Java语言编写JavaBean必须遵循以下规范：

  • （1） JavaBean是一个公共类。

  • （2） JavaBean类具有一个公共的无参的构造方法。

  • （3） JavaBean所有的属性定义为私有的。

  • （4） 在JavaBean中，需要对每个属性提供两个公共方法。假设属性名字是xxx，要提供的两个方法：

    • setXxx()：用来设置属性xxx的值。

    • getXxx()：用来获取属性xxx的值（若属性类型是boolean，则方法名为isXxx()）。

（5） 定义JavaBean时，通常放在一个命名的包下。

使用它

  • （1）<jsp:useBean>：声明并创建JavaBean对象实例。

    （2）<jsp:setProperty>：对JavaBean对象的指定属性设置值。

    （3）<jsp:getProperty>：获取JavaBean对象指定属性的值，并显示在网页上。

  • 声明JavaBean对象，需要使用<jsp:useBean>动作标签。语法格式为：

    <jsp:useBean id=”对象名”class=”类名”scope=”有效范围”/>

    l id属性：指定所要创建的对象名称。

    l class属性：用来指定JavaBean的类名，必须使用完全限定类名。

    l scope属性：指定所要创建对象的作用范围，包括page、request、session、application这4个取值，默认值是page。

  • <jsp:useBean id=”login” class=”ch09.Login”></jsp:useBean>

    • <jsp:setProperty name=”login” property=”password” value=”1234”>

    • <jsp:getProperty name=”login” property=”password”>

  • <% Login login = new Login(); %>

作用域

image-20200329203745466

JavaBean连接数据库

package sql;

import java.sql.*;
public class DBConnection&#123;
    private String driverName = "com.mysql.jdbc.Driver";
    private String url = "jdbc:mysql://localhost:3306/blog?useUnicode=true&characterEncoding=UTF8";
    private String username = "root";
    private String password = "root";
    public void setDriverName(String driverName)&#123;
        this.driverName = driverName;
    &#125;
    public String getDriverName()&#123;
        return this.driverName;
    &#125;
    public void setUrl(String url)&#123;
        this.url = url;
    &#125;
    public String getUrl()&#123;
        return this.url;
    &#125;
    public void setUserName(String username)&#123;
        this.username = username;
    &#125;
    public String getUserName()&#123;
        return this.username;
    &#125;
    public void setPassword(String password)&#123;
        this.password = password;
    &#125;
    public String getPassword()&#123;
        return this.password;
    &#125;
    public Connection getConnection()&#123;
        try&#123;
            Class.forName(driverName);
            return DriverManager.getConnection(url, username, password);
        &#125;catch(Exception e)&#123;
            e.printStackTrace();
            return null;
        &#125;
    &#125;

&#125;

七、servlet

==右击项目名–JavaEEtools–第二个==

模式二

servlet简介

class添加addlibary servlet runtime

介绍

  • Servlet作为J2EE的三大基础技术（JSP，Servlet和JavaBean）之一，是目前流行的开发企业Web应用的轻量级框架（Struts、Spring和Hibernate）的技术基础。Servlet是用Java语言编写的服务器端程序，它担当客户请求与服务器响应的中间层，属于JavaEE中间层技术，是由服务器端调用和执行的，可以处理客户端传来的HTTP请求，并返回一个响应。Servlet是按照Servlet自身规范编写的Java类，独立于平台，必须运行在支持Java技术的Web服务器中。Servlet容器是支持Servlet功能的Web服务器扩展，Servlet就是借助容器的请求∕响应机制与Web客户端进行交互。

  • 所有的Servlet容器必须支持HTTP协议。当用户发送HTTP请求访问Web服务器时，由Servlet容器根据Servlet配置来决定调用某个具体的Servlet来处理请求。容器调用Servlet时，还将代表请求与响应的两个对象传递给Servlet，Servlet利用请求对象来定位远程用户，获取HTTP POST参数及相关数据，进行相应的逻辑流程处理，然后借助响应对象发送数据给用户。一旦Servlet完成请求处理，容器会刷新响应，把控制交还给Web服务器。

  • 虽然用Servlet来生成Web页面十分复杂和繁琐，但Servlet的优势主要体现在它能利用Java语言的所有的优点，能访问Java平台提供的大量的API。故在Web应用中，Servlet主要用于流程的控制，页面生成则由其衍生技术JSP来完成。

  • Servlet由Servlet容器来负责Servlet实例的查找、创建以及整个生命周期的管理，Servlet整个生命周期分为四个阶段：加载、初始化、调用及销毁。这个生命周期是由javax.servlet.servlet.Servlet接口的init()、service()和destroy()方法所定义，Servlet具体生命周期如下。

    • Servlet容器加载Servlet类并实例化一个Servlet实例对象

    • Servlet容器调用该实例对象的init（）方法进行初始化

    • 如果Servlet容器收到对该Servlet的请求，则调用此实例对象的Servlet()处理请求并返回响应结果

    • Servlet容器卸载该Servlet前调用它的destroy()方法

接口

功能 类和接口
Servlet实现 javax.servlet.Servlet，javax.servlet.SingleThreadModel javax.servlet.GenericServlet，javax.servlet.http.Httpservlet
Servlet配置 javax.servlet.ServletConfig
Servlet异常 javax.servlet.ServletException，javax.servlet.UnavailableException
请求和响应 javax.servlet.ServletRequest，javax.servlet.ServletResponse javax.servlet.ServletInputStream，javax.servlet.ServletOutputStream javax.servlet.http.HttpServletRequest，javax.servlet.HttpServletResponse
会话跟踪 javax.servlet.http.HttpSession，javax.servlet.http.HttpSessionBindingListener javax.servlet.http.HttpSessionBindingEvent
Servlet上下文 javax.servlet.ServletContext
Servlet协作 javax.servlet.RequestDispatcher
其他 javax.servlet.http.Cookie，javax.servlet.http.HttoUtils ****

其中，javax.servlet.Servlet接口是Java Servlet API的核心，它定义了与Servlet生命周期对应的方法，如 Servlet加载及初始化时调用的init()方法；用于处理用户请求的service()方法；Servlet销毁时调用的destroy()方法等。所有的Servlet类都必须通过直接或间接（继承实现了Servlet接口的类）的方式来实现Servlet接口。

格式

WEB-INF/web.xml

  <servlet-name>ss</servlet-name>

​ sql.DBconnection.java

 
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.5">
    <display-name>helloServlet</display-name>
    <servlet>
        <servlet-name>helloServlet</servlet-name>
        <servlet-class>common.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>helloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

package…;
import…;
    import java.io.*;
    import javax.servlet.*;
    import javax.servlet.http.*;
public class Servlet 类名称 extends HttpServlet&#123;
    public void init()&#123;&#125;
    public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException &#123;&#125;

    public void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException &#123;&#125;

    public void service(HttpServletRequest request,HttpServletResponse response)&#123;&#125;

    public void destroy()&#123;&#125;
&#125;

生命周期

简介

servlet是HttpServlet的子类，服务器完成该子类的创建和初始化，sservlet的生命周期定义了一个servlet如何被加载，初始化，以及它怎样接受请求，响应请求，提供服务。

生命周期：

  • init（）：服务器初始化

    • 首次创建servlet才会调用init（）方法，不是每次请求都调用
    • 首次调用对用servlet的URL或再次启动服务器时，就会创建servlet
    • 当客户在请求servlet服务时，web服务器将启动一个新的线程，在这个线程中，调用service（）方法响应客户的请求

  • service()方法：初始化完毕，servlet对象调用该方法响应客户的请求

    • 每个请求，servlet都会调用该方法，并把servlet的请求对象和响应对象传递给service（）方法作为参数
      public void service(ServletRequest request, ServletResponse response)
    • request对象和response对象由servlet容器创建并传递给service（）方法，service（）方法会根据http请求的类型，调用相应的doGet（）或都Post（）等方法，service（）方法可以被调用多次

  • destory()方法：调用该方法销毁servlet对象

    • servlet被卸载时（tomcat停止），该方法自动调用，可以用来释放servlet占用的资源，如数据库连接，socket连接等。destory（）方法只会被调用一次

    技术特点

    1. 有效性
      1. 轻量java线程处理每一项请求，传统CGI中，n项请求同时指向一个CGI程序，该程序代码程序就会载入内存n次，但servlet时，可以存在n个线程，但只使用servlet类的一个副本
      2. 当CGI程序完成请求工作时，就会终止程序，难以缓存计算结果、保持数据库连接开放，并允许依赖于永久数据的其他优化操作，但完成响应后，servlet仍然保留在内存中，因此可以直接在请求之间存储任意复杂的数据
    2. 方便
      1. servlet包含扩展基础结构，能自动对HTML表单数据进行分析和解码、读取和设置http头，处理cookie、跟踪会话已经其他高级功能
    3. 强大
      1. servlet可以直接与web服务器对话，而常规的CGI程序无法做到，web服务器的通信更易于将相对url转换为具体的路径名，多个servlet之间可以共享数据，这跟易于实现数据库连接共享和类似资源共享优化操作，servlet还可以保留不同请求的信息，简化了会话跟踪和换出你早期计算结果的一些技术
    4. 可移植性
      1. 集合每种主要的web服务器都可以通过插件或直接支持servlet
    5. 安装性
    6. 便宜

servlet与jsp

区别

业务逻辑：servlet

有servlet后有jsp

  • 编程方式不同
    • servlet：java程序，jsp按照web规范编写的脚本语言
  • 编译方式不同
    • servlet每次修改需要编译才能运行，jsp是被jspContainer编译为servlet文件
  • 运行速度不同
    • jsp第一次访问需要编译成servlet，在次访问时，已经有对应的。class文件，不需要再次翻译和编译，在运行速度上servlet比jsp快

部署和应用

部署

/WEBJ-INF目录：

  1. servlet和web应用程序的初始化，通过配置文件，可以减少初始化值的硬编码

重定向和转发

介绍

  • 重定向功能
    • 重定向的功能是将用户从当前页面或者Servlet定向到另外一个JSP页面或者Servlet；
  • 转发的功能
    • 将用户对当前JSP页面或者Servlet对象的请求转发给另外一个JSP页面或者Servlet对象。
  • 在Servlet类中使用HttpServletResponse类 的 重 定 向 方 法sendRedirect()，以及RequestDispatcher类的转发方法forward()。
  • 两方法都能让浏览器获得另一个URL所指向的资源

区别

  1. requestDispatcher的forward（）方法只能将请求转发给同一个web应用中的组件，而httpservletresponse的sendRedirect（）方法不仅可以重定向到当前应用程序中的其他资源，还可以重定向到同一个站点的其他应用程序中的资源，甚至是使用绝对URL重定向到其他站点的资源
  2. sendRedirect（）方法重定向访问过程结束后，地址栏URL改变，变成目标URL，而requestDispatcher的forward（）方法的请求转发过程结束后，地址栏的URL不变
  3. sendRedirect()方法对浏览器的请求直接作出相应，相应的结果是告诉浏览器去重新发出对另一个URL的访问请求；而requestDispatcher.forward()方法是在服务器内部件请求转发给另一个资源，浏览器只知道发出请求并得到相应结果，不知道在服务器内部发生了转发行为
  4. requestDispatcher的forward（）方法的调用者和被调用者之间共享相同的request对象和response对象，他们属于同一个访问请求和响应过程，而sendRedirect()方法调用者与被调用者使用各自的request对象和response对象，他们属于两个独立的访问请求和响应过程
  5. 无论是RequestDispatcher的forward()方法，还是HttpServletResponse的sendRedirect()方法，在调用它们之前，都不能有内容已经被实际输出到了客户端。如果缓冲区中已经有了一些内容，这些内容将被从缓冲区中清除。
区别 转发forward() 重定向sendRedirect()
根目录 包含项目访问地址 没有项目访问地址
地址栏 不会发生变化 会发生变化
哪里跳转 服务器端进行的跳转 浏览器端进行的跳转
请求域中数据 不会丢失 会丢失

sevlet过滤器

简介

Servlet过滤器（Filter）是在服务器上运行的，且位于请求与响应中间起过滤功能的程序。它是一个Java组件，是能改变HTTP请求、响应及头信息中内容的可重用代码。其工作原理大致是：在Servlet作为过滤器使用时，它可以对客户的请求进行处理，处理完毕之后它会交给下一个过滤器处理，这个客户的请求在过滤器链中逐个处理，直到请求发送到目标为止。

因此，Filter主要功能在于它能通过某种拦截机制对请求进行预处理或对响应进行后处理，藉此修改或调整请求和响应的资源。Filter能作用于Web上的动态和静态资源，常用来完成诸如认证处理、日志、图像格式转换或加密等功能。开发者在以下情况下需要用到Filter：

  • 要在Servlet被调用之前访问资源；

  • 要在Servlet被调用之前检查request对象；

  • 要将request中的头信息和request数据封装成指定格式；

  • 要将response中的头信息和response数据封装成指定格式；

  • 要对servlet被调用之后进行拦截。

应用场景

自动登录、统一设置编码格式、访问权限控制、敏感字符过滤器

过滤器的创建与配置

过滤器Filter的创建必须实现javax.servlet.Filter接口并提供一个无参构造函数。由javax.servlet.Filter接口定义了三个方法：

  • void init（FilterConfig config）：Filter初始化时执行的方法；

  • void doFilter（ServletRequest request, ServletResponse response, FilterChain chain）：实现过滤功能，该方法就是对每个请求及响应增加额外的处理，并通过FilterChain对象的doFilter方法来调用下一个Filter，如是没有其它Filter，则调用最初的Servlet；

  • void destroy（）：Filter生命周期结束时，自动调用该方法。

由于JSP并不能较好的支持中文，输入中文提交后，会输出乱码，下面就通过Filter来实现将所有请求的编码方式设为“UTF-8”以支持中文的正确显示，主要代码如下所示（EncodingFilter.java）：

package common;
import java.io.IOException;
import javax.servlet.*;
public class EncodingFilter implements Filter &#123;    
    public EncodingFilter() &#123; 
    &#125;
    public void init(FilterConfig fConfig) throws ServletException &#123;
    &#125;
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException &#123;
        // 设置request的编码方式
        request.setCharacterEncoding("UTF-8");
        chain.doFilter(request, response);
    &#125;
    public void destroy() &#123;    
    &#125;
&#125;

Filter与Servlet类一样，也是放置在Web应用的classes包中。Filter处理类创建完毕后，也必须在web.xml文件中配置Filter。关键代码如下：

<filter>

       <filter-name>encoding</filter-name>

       <filter-class>common.EncodingFilter</filter-class>

</filter>

<filter-mapping>

       <filter-name>encoding</filter-name>

       <url-pattern>/*</url-pattern>    //  /*拦截所有请求

</filter-mapping>

Filter的配置主要包含两个部分：<filter>来配置Filter名称以及对应的Filter处理类；<Filter-mapping>来配置Filter与过滤的URL 模式。Servlet通常只配置一个URL ，而Filter可以同时拦截多个请求的URL，可以配置多个Filter拦截模式。示例中的encoding过滤器设置为对所有请求进行过滤。通过加载过滤器之后，前面示例中输入中文也能正常显示了。

MVC模式

MVC（Model-View-Controller，模型—视图—控制器模式）是软件工程中的一种软件架构模式。MVC模式将整个应用系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller），其目的就是实现一种动态的程序设计，能使程序的修改和扩展简化，并且使程序模块的重复利用成为可能。

MVC模式各组成部分的主要功能如下：

  • 模型（Model）：体现应用程序的功能，用于封装应用程序业务逻辑。模型有对数据直接访问的权力，如对数据库的访问。模型不依赖视图和控制器，也就是说，模型不关心它会被如何显示或是如何被操作，但是模型中数据的变化一般会通过一种机制被公布。模型必须提供一系列的功能性接口，以支持模型中功能的访问。

  • 视图（View）：主要用于描述模型。视图能够实现模型有目的的显示，允许一个模型对应多个视图。在视图中一般不包含应用程序上的业务逻辑，但模型中数据的变化必须在视图中得以体现。

  • 控制器（Controller）：用于控制应用程序的流程。控制器处理事件并做出响应，事件包括用户的行为和数据模型的改变。用户与视图交互时，可以通过控制器来更新模型状态，通知视图刷新显示。

MVC模式并不能自动保证每一个结构设计都是正确的，如何在一个系统的设计中使用MVC架构模式与系统使用的技术密切相关。MVC模式的优点体现在以下几下方面：

  • 首先，在MVC模式中，系统的业务逻辑由模型来实现，视图负责数据的呈现，实现了业务逻辑和表示的分离，因此，多个视图能共享一个模型。同一个模型可以被不同的视图重用，大大提高了代码的可重用性。

  • 其次，模型是自包含的，与控制器和视图保持相对独立，因此可以方便的更改应用程序的数据层和业务逻辑。而MVC的三个部分相互独立，改变其中一个并不会影响其他两个，所以依据这种设计思想能构造良好的松耦合的组件。

  • 此外，控制器提高了应用程序的灵活性和可配置性。控制器可以用来连接不同的模型和视图去完成用户的需求。

MVC的缺点是开发一个MVC架构的工程，将不得不考虑如何将MVC运用到应用程序中，这样会带来额外的工作，增加应用的复杂性。因此，MVC并不适合小型甚至中等规模的应用程序，但对于开发存在大量用户界面，并且逻辑复杂的大型应用程序，MVC将会使软件在健壮性、代码重用和结构方面上一个新的台阶。尽管在最初构建MVC框架时会花费一定的工作量，但从长远的角度来看，它会大大提高后期软件开发的效率。

model2

所谓模式2（Model 2）就是指基于MVC架构来构建Java Web应用的开发模式。在基于Model 2构建Java Web应用中，通常将Web应用的架构根据MVC模式划分为三个层次：

  1. 视图层

    视图层包括前端的HTML、XML、JSP及Applet等，主要充当用户的操作接口，负责数据的输入及结果的输出。该层的功能对应于MVC模式中的视图部分。

  2. 控制层

    控制层的主要工作是控制整个应用的流程。控制层将视图层提交的数据，交付给业务逻辑层处理，并将结果返回至视图层。控制层的角色是介于视图层和业务逻辑层之中，该层的功能相当于MVC模式中的控制器部分。

  3. 业务逻辑层

    业务逻辑层是应用的核心部分，它的主要功能包括：数据处理、数据的维护及业务逻辑的实现。该层的功能对应于MVC模式中的模型部分。

image-20200423105757667

在Model 2中，JSP负责数据显示逻辑，JavaBean负责业务逻辑，Servlet负责流程控制。并且Servlet不参加显示工作，只负责产生中间数据，并将这些数据以JavaBean的形式存储在session或其它对象中。这样的划分，使得Web应用的开发可以充分利用MVC模式的优点，使得视图层、控制层及业务逻辑层能并行开发，大在提高了Web应用开发的效率，也增加了Web应用的可重用性。

八、java

输入

scanner sc = new scanner(System.in);

String name = sc.next();空格分隔

sc.netLine()

九、考试内容

十、idea

image-20200426221626750

mavne项目

添加java资源目录

image-20211208121002149

image-20211208121520393

热部署

快捷键

sout 输出

psvm main()

调试

断点f7

web

image-20200426225127978

lib

UTOOLS1587914028325.png

十一、tomcat

server.xml 配置host，主机名

image-20200427183548275

  1. 访问
  2. 找本机host文件，
  3. 没有则到dos，变成ip

十二、bilibili

准备工作

依赖

<dependencies>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
  </dependency>
  <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
  <dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.3.3</version>
    <scope>provided</scope>
  </dependency>
  <!--mysql的驱动-->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
  </dependency>
  <!-- JSTL表达式的依赖 -->
  <dependency>
    <groupId>javax.servlet.jsp.jstl</groupId>
    <artifactId>jstl-api</artifactId>
    <version>1.2</version>
  </dependency>
  <!-- standard标签库 -->
  <dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
  </dependency>
  <!--单元测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <!--josn-->
    <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.68</version>
    </dependency>
</dependencies>

结构

UTOOLS1588510474637.png

image-20200430164803986

数据库公共类

package com.ming.dao;

import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

//操纵数据库基类
public class BaseDao &#123;
    private static String driver;;
    private static String url;
    private static String username;
    private static String password;

    //类加载的时候就初始化
    static&#123;
        Properties properties = new Properties();
        InputStream is = BaseDao.class.getClassLoader().getResourceAsStream("db.properties");
        try&#123;
            properties.load(is);
        &#125;catch(IOException e)&#123;
            e.printStackTrace();
        &#125;
        driver = properties.getProperty("driver");
        url = properties.getProperty("url");
        username = properties.getProperty("username");
        password = properties.getProperty("password");
    &#125;

    //获取数据库连接
    public static Connection getConnection() throws ClassNotFoundException &#123;
        Connection connection = null;
        try&#123;
            Class.forName(driver);
            connection = DriverManager.getConnection(url, username, password);
        &#125; catch (SQLException e) &#123;
            e.printStackTrace();
        &#125;
        return connection;

    &#125;

    //编写公共查询方法
    public static ResultSet executequery(Connection connection, String sql, Object[] params, ResultSet resultSet, PreparedStatement preparedStatement) throws SQLException &#123;
        preparedStatement = connection.prepareStatement(sql);
        for(int i = 0; i < params.length; i++)&#123;
            preparedStatement.setObject(i+1, params[i]);
        &#125;
        resultSet = preparedStatement.executeQuery();
        return resultSet;

    &#125;

    //编写公共修改方法
    public static int executeUpdate(Connection connection, String sql, Object[] params, PreparedStatement preparedStatement) throws SQLException &#123;
        preparedStatement = connection.prepareStatement(sql);
        for(int i = 0; i < params.length; i++)&#123;
            preparedStatement.setObject(i+1, params[i]);
        &#125;
        int updateRows = preparedStatement.executeUpdate();
        return updateRows;

    &#125;

    //释放资源
    public static boolean closeResource(Connection connection, PreparedStatement preparedStatement, ResultSet resultSet) throws SQLException &#123;
        boolean flag = true;
        if(resultSet != null)&#123;
            try&#123;
                resultSet.close();
                resultSet = null;
            &#125;catch (SQLException e)&#123;
                e.printStackTrace();
                flag = false;
            &#125;
        &#125;
        if(preparedStatement != null)&#123;
            try&#123;
                preparedStatement.close();
                preparedStatement = null;
            &#125;catch (SQLException e)&#123;
                e.printStackTrace();
                flag = false;
            &#125;
        &#125;
        if(connection != null)&#123;
            try&#123;
                connection.close();
                connection = null;
            &#125;catch (SQLException e)&#123;
                e.printStackTrace();
                flag = false;
            &#125;
        &#125;
        return flag;
    &#125;

&#125;

过滤器

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0"
         metadata-complete="true">

    <!--字符编码过滤器-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>com.ming.filter.CharacterEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>


</web-app>
package com.ming.filter;

import javax.servlet.*;
import java.io.IOException;

public class CharacterEncodingFilter implements Filter {
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("UTF-8");
        servletResponse.setCharacterEncoding("UTF-8");
        filterChain.doFilter(servletRequest, servletResponse);
    }

    public void destroy() {

    }
}

导入静态资源到web

jsp路径

${pageContext.request.contextPath}

UUID

String str = UUID.randomUUID().toString();

maven

maven由于他的约定大于配置，我们之后可以能遇到我们写的配置文件，无法被导出或者生效的问题，解决方案：

<!--在build中配置resources，来防止我们资源导出失败的问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

知识

读取配置文件

public QQ() &#123;
    Properties properties = new Properties();
    InputStream is = QQ.class.getClassLoader().getResourceAsStream("qq.properties");
    try &#123;
        properties.load(is);
    &#125; catch (IOException e) &#123;
        e.printStackTrace();
    &#125;
    response_type = properties.getProperty("response_type");
    client_id = properties.getProperty("client_id");
    redirect_uri = properties.getProperty("redirect_uri");
    state = properties.getProperty("state");
&#125;
rpm -e --nodeps