狂神说Java个人笔记-JavaWeb

3.Tomcat

3.1安装Tomcat

3.2Tomcat启动和配置

3.3配置

高难度面试题：

请你谈谈网站是如何进行访问的！

1.输入一个域名：回车

2.检查本机的C:WindowsSystem32driversetchosts配置文件下有没有这个域名映射；

1.有：直接返回对应的ip地址，这个地址中，有我们需要访问的web程序，可以直接访问

127.0.0.1 www.zhaodong.com

2.没有：去DNS服务器找找到的话就返回，找不到就返回找不到

3。可以配置一下环境变量

3.4发布一个web网站

不会就先模仿，将自己写的网站，放到服务器Tomcat中指定的web应用文件夹webapps下，就可以访问了

网站应该有的结构

-- webapps: Tomcat服务器的web目录
      -ROOT
        -kuangstudy：网站的目录名
        -Web-INF
        -classes：java程序
        -lib：web应用所依赖的jar包
        -web.xml：网站配置文件
    -index.html 默认的首页
    
​

4.HTTP

4.1什么是HTTP

HTTP（超文本传输协议）是一个简单的请求-响应协议，它通常运行在TCP之上。

• 文本：html，字符串

• 超文本：图片，音乐，视频定位，地图。。。。

• 80

HTTPS：安全的

• 443

4.2两个时代

HTTP/1.0:客户端可以与web服务器连接后，只能获得一个web资源，断开连接

HTTP/1.1：客户端可以与web服务器连接后，可以获得多个web资源。

4.3HTTP请求

客户端----发请求----服务器

百度：

Request URL:https://www.baidu.com/   请求地址
Request Method:GET   get方法/post方法
Status Code:200 OK   状态码：200
Remote Address:182.61.200.7:443

1.请求行

• 请求行终的请求方式：GET

• 请求方式：Get，Post ，HEAD，DELETE，PUT，TRACT...

  • get:请求能够携带的参数比较少，大小有限制，会在浏览器的URL地址栏显示数据内容，不安全，但高效

  • post：请求能够携带的参数没有限制，大小没有限制，不会在浏览器的URL地址栏显示数据内容，安全，但不高效。

2.消息头

Accept： 告诉浏览器，它所支持的数据类型
Accept-Encoding: 告诉浏览器，它所支持的编码格式    GBK UTF-8 GB2312
Accept-Language：告诉浏览器，它的语言环境
    cache-Control：缓冲控制
    connection：告诉浏览器，请求完成是断开还是保持连接
    Host：主机..../.

 

4.4HTTP响应

服务器---响应----客户端

百度：

Cache-Control:private 缓冲控制
Connection:keep-alive   连接
Content-Encoding:gzip   编码
Content-Type:text/html;charset=utf-8  类型
​

1.响应体

Accept： 告诉浏览器，它所支持的数据类型
Accept-Encoding: 告诉浏览器，它所支持的编码格式    GBK UTF-8 GB2312
Accept-Language：告诉浏览器，它的语言环境
    cache-Control：缓冲控制
    connection：告诉浏览器，请求完成是断开还是保持连接
    Host：主机..../.
    Refrush:告诉客户端，多久刷新一次
    Location：让网页重新定位；
        

2.响应状态码

200：请求响应成功 200

3**：请求重定向

• 重定向：你重新道我给你信位置去；

4xx：找不到资源；404

5xx：服务器代码错误 500 502网关错误

常见面试题：

当你的浏览器中地址栏输入地址并回车的一瞬间到页面能够展示回来，经历了什么？

5.Maven

我为什么要学习这个技术？

1. 在JavaWeb中，需要使用大量的jar包，我们手动去导入；

2. 如何个够让一个东西自动帮我导入和配置这个jar包。

3. 由此，Maven诞生了！

5.1Maven项目架构管理工具

我们目前来救是方便导入jar包的！

Maven的核心思想：约定大于配置

• 有约束，不要去违反。

• Maven会规定好你该如何去编写我们java代码，必须按照这个规范

5.2下载安装Maven

下载完成后，解压即可；

电脑上的所有环境都放在一个文件夹下，方便管理

5.3配置环境变量

在我们的系统环境变量中

配置如下配置：

• M2_HOME maven 目录下的bin目录

• MAVEN_HOME maven的目录

• 在系统的path中配置%MAVEN_HOME%in

5.4阿里云镜像

• 镜像：mirrors

<mirror> <id>alimaven</id> <name>aliyun maven</name> <url>http://maven.aliyun.com/nexus/content/groups/public/</url> <mirrorOf>central</mirrorOf> </mirror>

 

5.5本地仓库

• 建立本地仓库

• <localRepository>/path/to/local/repo</localRepository> -->

5.6在idea中使用Maven

1. 启动idea

2. 创建一个maven项目

解决警告问题

必须要的配置：为什么会有这个问题：我们访问一个网站，需要制定一个文件夹名字

 

 

5.7标记文件夹目录

Maven的注意事项：

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

5.8maven中遇到的问题

idea中每次都要重复配置Maven

6.Servlet

6.1Servlet简介

• Servlet就是sun公司开发动态web的一门技术

• sun公司在这些API中提供一个接口叫作：Servlet，如果你想开发一个Servlet程序，只需要完成两个小步骤：

  • 编写一个类，实现Servlet接口

  • 把开发好的java类部署道web服务器中。

把实现了Servlet接口的java程序叫做Servlet

6.2HelloServlet

Servlet接口Sun公司有两个默认的实现类：HttpServlet，GenericServlet

1.构建一个普通的maven项目，删掉里面的src目录。以后我们的学习就在这个项目里面建立Moudel；这个空的工程就是Maven的主工程；

2.关于Maven父子工程的理解

父项目中会有一个

<modules>
        <module>servlet-01</module>
    </modules>

子项目中会有一个

 <parent>
        <artifactId>javaweb-02-servlet</artifactId>
        <groupId>com.dong</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

父项目中的java子项目可以直接使用

son extends parents

web配置文件更改

<?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_3_1.xsd"
  version="3.1">

3.Maveb环境优化

1.修改web。xml为最新的

2.将maven的结构搭建完整

4.编写一个Servlet程序

1.编写一个普通类

2.实现Servlet接口，这里我们直接继承HTTPServlet

public class HelloServlet extends HttpServlet {
    //由于get或者post只是请求实现的不同的方式，可以互相调用，业务逻辑都一样
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter writer = resp.getWriter();//响应流
        writer.print("Hello,Servlet");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

5.编写Servlet的映射

为什么需要映射：我们写的是java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们要在web服务中注册我们写的Servlet，还需给他一个浏览器能够访问的路径；

<!--    注册Servlet-->
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.dong.servlet.HelloServlet</servlet-class>
    </servlet>
<!--    servlet的请求路径-->
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

6.配置Tomcat

注意：配置项目发布的路径就可以了

7.启动测试

6.3Servlet原理

Servlet是由Web服务器调用，web服务器在收到浏览器请求之后，

6.4Mapping问题

1. 一个Servlet可以指定一个映射路径

   <servlet-mapping>
       <servlet-name>hello</servlet-name>
       <url-pattern>/hello</url-pattern>
   </servlet-mapping>

2. 一个Servlet可以指定多个映射路径

   <servlet-mapping>
       <servlet-name>hello</servlet-name>
       <url-pattern>/hello</url-pattern>
   </servlet-mapping>
   
   <servlet-mapping>
       <servlet-name>hello</servlet-name>
       <url-pattern>/hello1</url-pattern>
   </servlet-mapping>
   <servlet-mapping>
       <servlet-name>hello</servlet-name>
       <url-pattern>/hello2</url-pattern>
   </servlet-mapping>
   <servlet-mapping>
       <servlet-name>hello</servlet-name>
       <url-pattern>/hello3</url-pattern>
   </servlet-mapping>
   <servlet-mapping>
       <servlet-name>hello</servlet-name>
       <url-pattern>/hello4</url-pattern>
   </servlet-mapping>

3. 一个Servlet可以指定通用映射路径

   <servlet-mapping>
       <servlet-name>hello</servlet-name>
       <url-pattern>/hello/*</url-pattern>
   </servlet-mapping>

4. 默认请求路径

   <servlet-mapping>
       <servlet-name>hello</servlet-name>
       <url-pattern>/*</url-pattern>
   </servlet-mapping>

5. 指定一些后缀或者前缀等待.....

<!--    可以自定义后缀实现请求映射
注意点：*前面不能加项目映射的路径-->
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

6.优先级问题

指定了固有的映射路径优先级最高，如果找不到就会走默认的处理请求；

6.5ServletContext

web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用

1.共享数据

在这个Servlet保存的数据，可以在另一个Servlet拿到

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
   //this.getInitParameter() 初始化参数
   //this.getServletConfig() Servlet配置
   //this.getServletContext() Servlet 上下文
    ServletContext context = this.getServletContext();
    String username="赵东";
    context.setAttribute("username",username);//将一个数据保存在了ServletContext中，名字为：username，值username

}

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();
    String username = (String) context.getAttribute("username");
    resp.setContentType("text/html");
    resp.setCharacterEncoding("utf-8");
    resp.getWriter().print("名字"+username);
}

<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.dong.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet>
    <servlet-name>getc</servlet-name>
    <servlet-class>com.dong.servlet.GetServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>getc</servlet-name>
    <url-pattern>/getc</url-pattern>
</servlet-mapping>

2.获取初始化参数

<!--    配置一些web应用初始化参数-->
    <context-param>
        <param-name>url</param-name>
        <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();
    String url=context.getInitParameter("url");
    resp.getWriter().print(url);
}

3.请求转发

ServletContext context = this.getServletContext();
System.out.println("进入了ServletDemo04");
//RequestDispatcher requestDispatcher = context.getRequestDispatcher("/demo");//转发的请求
//requestDispatcher.forward(req,resp);//调用forward实现请求转发
context.getRequestDispatcher("/demo").forward(req,resp);

请求转发与重定向区别

4.读取资源文件

Properties

• 在java目录下新建properties

• 在resources目录下新建properties

发现：都被打包到了同一个路径下：classes，我们俗称这个路径为类路径

思路：需要一个文件流

username=root
password=123456

 

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    InputStream in = this.getServletContext().getResourceAsStream("/target/classes/db.properties");
    Properties properties = new Properties();
    properties.load(in);
    String user = properties.getProperty("username");
    String pwd = properties.getProperty("password");
    resp.getWriter().print(user+":"+pwd);
}

6.6HttpServletResponse

web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HTTPServletRequest对象，代表响应的一个HTTPServletResponse；

• 如果要获取客户端请求过来的参数：找HttpServletRequest

• 如果要给客户端响应一些信息：赵HTTPServletResponse

1.简单分类

• 负责向浏览器发送数据的方法

• ServletOutputStream getOutputStream() throws IOException;
  PrintWriter getWriter() throws IOException;

• 负责向浏览器发送响应头的方法

• void setCharacterEncoding(String var1);
  void setContentLength(int var1);
  void setContentLengthLong(long var1);
  void setContentType(String var1);响应的状态码

• int SC_CONTINUE = 100;
  int SC_SWITCHING_PROTOCOLS = 101;
  int SC_OK = 200;
  int SC_CREATED = 201;
  int SC_ACCEPTED = 202;
  int SC_NON_AUTHORITATIVE_INRMATION = 203;
  int SC_NO_CONTENT = 204;
  int SC_RESET_CONTENT = 205;
  int SC_PARTIAL_CONTENT = 206;

  2.下载文件

  1.向浏览器输出消息

  2.下载文件

   1. 要获取下载文件的路径
  
   	 2. 下载的文件名是啥？
        	 3. 设置想办法让浏览器能够支持下载我们需要的东西
            	 4. 获取下载文件的输入流
        	 5. 创建缓冲区
             	 6. 获取OutputStream对象
                  	 7. 将FileOutputStream流写入到buffer缓冲区
                      	 8. 使用OutputStream将缓冲区中的数据输出到客户端！ 

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // 1. 要获取下载文件的路径
    String realPath="D:\IDEA\javaweb-02-servlet\response\src\main\resources\1.jpg";
    System.out.println("下载文件的路径："+realPath);
    // 2. 下载的文件名是啥？
    String fileName=realPath.substring(realPath.lastIndexOf("\")+1);
    // 3. 设置想办法让浏览器能够支持(Content-Disposition)下载我们需要的东西,中文文件名URLEncoder.encode编码，否则可能乱麻
    resp.setHeader("Content-Disposition","attachment;filename="+ URLEncoder.encode(fileName,"UTF-8"));
    // 4. 获取下载文件的输入流
    FileInputStream in = new FileInputStream(realPath);
    // 5. 创建缓冲区
    int len=0;
    byte[] buffer= new byte[1024];
    // 6. 获取OutputStream对象
    ServletOutputStream out = resp.getOutputStream();
    // 7. 将FileOutputStream流写入到buffer缓冲区,使用OutputStream将缓冲区中的数据输出到客户端！
    while ((len=in.read(buffer))>0){
        out.write(buffer,0,len);
    }
    in.close();
    out.close();
}

3.验证码功能

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //如何让浏览器3秒自动刷新一次
    resp.setHeader("refresh", "3");
    //在内存中创建一个图片
    BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
    //得到图片
    Graphics2D g = (Graphics2D) image.getGraphics();//笔
    //设置图片的北京颜色
    g.setColor(Color.white);
    g.fillRect(0, 0, 80, 20);
    //给图片写数据
    g.setColor(Color.BLUE);
    g.setFont(new Font(null, Font.BOLD, 20));
    g.drawString(makeNum(), 0, 20);
    //告诉浏览器，这个请求用图片的方式打开
    resp.setContentType("image/jpg");
    //网站存在缓冲，布让浏览器缓冲
    resp.setDateHeader("expires",-1);
    resp.setHeader("Cache-Control","no-cache");
    resp.setHeader("Pragma","no1-cache");
    //把图片写给浏览器
    ImageIO.write(image,"jpg",resp.getOutputStream());
}

    //生成随机数
    private String makeNum () {
        Random random = new Random();
        String num = random.nextInt(9999999) + "";
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 7 - num.length(); i++) {
            sb.append("0");

        }
        num = sb.toString() + num;
        return num;
    }

4.实现重定向

  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//       resp.setHeader("Location","/down");
//       resp.setStatus(302);
        resp.sendRedirect("/down");//重定向
    }

面试题：请你聊聊重定向和转发的区别？

相同点：

• 页面都会实现跳转

不同点

• 请求转发的时候，url不会产生变化

• 重定向的时候，url地址栏会产生变化

用户登陆：

void sendRedirect(String var1) throws IOException;

6.7HttPServletRequest

HttPServletRequest代表客户端的请求，用户通过Http协议访问服务器，HTTP请求中的所有信息会被封装到HttPServletRequest，通过HttPServletRequest的方法，获得客户端的所有信息。

1.获取前端传递的参数

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String username = req.getParameter("username");
    String password = req.getParameter("password");
    String[] hobbys = req.getParameterValues("hobbys");
    System.out.println("===========================");
    System.out.println(username);
    System.out.println(password);
    System.out.println(Arrays.toString(hobbys));
    System.out.println("============================");
    //通过请求转发
    req.getRequestDispatcher("/success.jsp").forward(req,resp);
    resp.setCharacterEncoding("utf-8");
}

7.Cookie、Session

7.1会话

会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器这个过程可以称之为会话。

有状态会话：一个同学来过教室，下次再来教室，我们会知道这个同学，曾经来过

一个网站怎么证明你来过？

客户端 服务端

1.服务端给客户端一个信件，客户端下次访问服务端带上信件就可以了；cookie

2.服务器登记你来过了，下次你来的时候我来匹配你；session

7.2保存会话的两种技术

cookie

• 客户端技术（通过响应，请求）

session

• 服务器技术，利用这个技术，可以保存用户的会话信息？我们可以把信息或者数据放在Session中！

常见问题：网站登录之后，下次不用再登录了，第二次就直接上去了

7.3Cookie

1.请求中拿到cookie信息

2.服务器响应给客户端cookie

Cookie[] cookies=req.getCookiles();//获得cookie
cookie.getName();//获得cookie中的key
cookie.getValue();//获得cookie中的value
new Cookie("lastLoginTime",System.currentTimeMillis()+"");//新建一个cookie
cookie.setMaxAge(24*60*60);//设置cookie的有效期
resp.addCookie(cookie);//响应给客户端一个cookie

cookie:一般会保存在本地的 用户目录下 appdata

一个网站cookie是否存在上限！

• 一个cookie只能保存一个信息

• 一个web站点可以给浏览器发送多个cookie，最多存放20个cookie

• cookie大小有限制4kb

• 300个cookie浏览器上限

删除cookie：

• 不设置有效期，关闭浏览器，自动失效；

• 设置有效期时间为0；

7.4Session（重点）

什么是Session：

• 服务器会给每一个用户（浏览器）创建一个Session对象

• 一个Session独占一个浏览器，只要浏览器没有关闭，这个Session就存在

• 用户登陆之后，整个网站它都可以访问！-->保存用户的信息

Session和cookie的区别

• Cookie是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个）

• Session把用户的数据写到用户独占Session中，服务器端保存（保存重要的信息，减少服务器资源的浪费）

• session由服务器创建

使用场景：

• 保存一个登陆用户的信息；

• 购物车信息；

• 在整个网站中经常会使用的数据，我们将它保存在session中

   @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        resp.setCharacterEncoding("UTF-8");
        resp.setContentType("Text/html;charset=utf-8");
        //得到session
        HttpSession session = req.getSession();
        //给session中存东西
        session.setAttribute("name","赵东");
        //获取session的id
        String sessionId = session.getId();
        //判断session是不是新创建
        if (session.isNew()){
            resp.getWriter().write("session创建成功，ID："+sessionId);
        }else {
            resp.getWriter().write("session已经在服务器中存在了，ID："+sessionId);
        }
        //Session创建的时候做了什么事情
//        Cookie cookie = new Cookie("JSESSIONID", sessionId);
//        resp.addCookie(cookie);
    }

8.JSP

8.1什么是jsp

Java Server Pages：Java服务器端页面，也和Servlet一样，用于动态web技术！

最大的特点：

• 写jsp就像在写HTML

• 区别：

  • HTML只给用户提供静态的数据

  • JSP页面中可以嵌入java代码，为用户提供动态数据

8.2JSP原理

思路：jsp到底怎么执行的

浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet！

JSP最终也会被转换成为一个java类！

JSP本质上就是一个Servlet

//初始化
public void _JspInit(){
}
//销毁
public void _jspDestroy(){
}
//JSPService
public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response){}

final javax.servlet.jsp.PageContext pageContext;//页面上下文
javax.servlet.http.HttpSession session=null; //session
final javax.servlet.ServletContext application;//applicationContext
final javax.servlet.ServletConfig config;//config
javax.servlet.jsp.JspWriter out = null;//out
final java.lang.Object page = this;//page：当前
javax.servlet.jsp.JspWriter _jspx_out = null; //请求
javax.servlet.jsp.PageContext _jspx_page_context = null;//响应

3.输出页面前增加的代码

response.setContentType("text/html; charset=UTF-8");
pageContext = _jspxFactory.getPageContext(this, request, response,
         null, false, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
out = pageContext.getOut();
_jspx_out = out;

4.以上这些对象我们可以在jsp中随便使用

在jsp页面中：

只要是java代码就会原封不动的输出

如果是html代码，就会转换为

out.wtire("<html>
");

这样的格式，输出到前端！

8.3jsp基础语法

任何语言都有自己的语法，JAVA中有。JSP作为java技术的一种应用，它拥有一些自己扩充的语法（了解知道即可），java所有语法都支持！

jsp表达式

<%--jsp表达式
作用：将程序的输出，输出到客户端
<%= 变量或者表达式%>--%>
<%= new java.util.Date()%>

jsp脚本片段

<%--jsp脚本片段--%>
<%
    int sum=0;
    for (int i = 0; i <=100 ; i++) {
        sum+=i;
    }
    out.println("<h1>Sum="+sum+"</h1>");
%>

<%--脚本再实现，在代码嵌入HTML元素--%>
<%
    for (int i = 0; i <5 ; i++) {
%>
<h1>hello,world</h1>
<%
    }
%>

jsp声明

<%!
    static{
        System.out.println("Loading Servlet!");
    }
    private  int globalVar =0;
    public  void kuang(){
        System.out.println("进入了方法狂！");
    }
%>

JSP声明：会被编译到JSP生成java的类中！其他的，会被生成道JSPService方法中

在jsp，嵌入java代码即可

<%%>脚本片段
<%=%>输出变量或者表达式
<%!%>声明
<%--注释--%>

jsp的注释，不会在客户端显示，html会显示

8.4jsp指令

在xml文件里配置

<!--   自定义配置错误页面-->
    <error-page>
        <error-code>500</error-code>
        <location>/error/500.jsp</location>
    </error-page>

8.5 9大内置对象

• PageContext 存东西

• Request 存东西

• Response

• Session 存东西

• Application [ServletContext] 存东西

• conifg [ServletConfig]

• out

• page

• exception

<%--内置对象--%>
<%
    pageContext.setAttribute("name1","赵东1号");//保存的数据只在一个页面中有效
    request.setAttribute("name2","赵东2号");//保存的数据只在一次请求中有效，请求转发会携带这个数据
    session.setAttribute("name3","赵东3号");//保存的数据只在一次会话中有效，从打开浏览器道关闭浏览器
    application.setAttribute("name4","赵东4号");//保存的数据只在服务器中有效，从打开服务器道关闭服务器
%>
<%--脚本片段中的代码，会被原封不动生成道JSP.java
要求：这里的代码：必须保证Java语法的正确性
--%>
<%
    //从pageContext取出，我们通过寻找的方式来
    //从底层到高层（作用域）：
    String name1=(String) pageContext.findAttribute("name1");
    String name2=(String) pageContext.findAttribute("name2");
    String name3=(String) pageContext.findAttribute("name3");
    String name4=(String) pageContext.findAttribute("name4");
    String name5=(String) pageContext.findAttribute("name5");
%>
<%--使用el表达式输出 ${}}--%>
<h1>取出的值为：</h1>
<h3>${name1}</h3>
<h3>${name2}</h3>
<h3>${name3}</h3>
<h3>${name4}</h3>
<h3><%=name5%></h3>

8.6jsp标签、jstl标签

<!--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>

EL表达式： ${}

• 获取数据

• 执行运算

• 获取web开发的常用对象

9.JavaBean

实体类

JavaBean有特定的写法：

• 必须要有一个无参构造

• 属性必须私有化

• 必须有对应的get/set方法

一般用来和数据库的字段做映射 ORM

ORM：对象关系映射

• 表-->类

• 字段-->属性

• 行记录-->对象

id	name	age	address
1	赵东1号	3	山西
2	赵东2号	18	山西
3	赵东3号	26	山西

class People{
    private int id;
    private String name;
    private String adress
}

10.MVC三层架构

什么是mvc： Model view Controller 模型、视图、控制器

10.1早些年

 

用户直接访问控制层，控制层就可以直接操作数据库；

 

11.Filter

1.Filter：过滤器，用来过滤网站的数据；

• 处理中文乱码

• 登陆验证

写过滤器：

1.导包

2.编写过滤器

public class CharacterEncodingFilter implements Filter {
    //初始化：web服务器启动，就已经初始化了，随时等待过滤对象出现！
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("CharacterEncodingFilter 初始化");
        
    }
    //Chain:链
    /*
    * 1.过滤中的所有代码，在过滤特定请求的时候都会执行
    * 2.必须要让过滤器继续同行
    * chain.doFilter(request,response);
    * */
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=UTF-8");
        System.out.println("CharacterEncodingFilter执行前");
        filterChain.doFilter(request,response);//让我们的请求继续走，如果不写，程序到这就被拦截停止！
        System.out.println("CharacterEncodingFilter执行后");
    }
    //销毁：web服务器关闭的时候，过滤会销毁
    public void destroy() {
        System.out.println("CharacterEncodingFilter销毁");
    }
}

3.在web.xml中配置Filter

 <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>com.dong.filter.CharacterEncodingFilter</filter-class>
    </filter>
<!--    只要是/servlet的任何请求，都会经过这个过滤器-->
<!--  <url-pattern>/*</url-pattern>  -->
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/servlet/*</url-pattern>
    </filter-mapping>

12.监听器

实现一个监听器的接口；（有N种）

1.编写一个监听器

实现监听器的接口...

2.xml中配置监听器

3.看情况是否使用

13.过滤器、监听器常见应用

监听器：GUI编程中经常使用；

用户登录之后才能进入主页！用户注销后就不能进入主页

14.JDBC

JDBC（Java database connect）：Java连接数据库！

需要jar包的支持：

• java.sql

• javax.sql

• mysql-conneter-java...连接驱动（必须要导入）

1.创建SQL（表和内容）

CREATE TABLE `jdbc`.`users`(
		`id` int(4) UNSIGNED ZEROFILL not NULL auto_increment COMMENT '学号',
		`name` VARCHAR(40),
		`password` VARCHAR(40),
		email varchar(60),
		birthday DATE,
		PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT charset=utf8;

INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(1,'张三','123456','555@qq.com','2000-01-01');
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(2,'李四','123456','333@qq.com','2000-01-01');
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(3,'王五','123456','222@qq.com','2000-01-01');

2.在xml导入SQL -jar包依赖

<dependencies>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
</dependencies>

3.在idea中连接数据库

4.编写jdbc

固定步骤：

1.加载驱动

2.连接数据库，代表数据库

3.向数据库发送SQL的对象Statement：CRUD

4.编写sql（根据业务，不同的SQL）

5.执行SQL

6.关闭连接

public class TestJdbc {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //获取配置信息
        String url="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
        String username="root";
        String password="123456";
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        //3.向数据库发送sql的对象statement：CRUD
        Statement statement = connection.createStatement();
        ////PreparedStatement preparedStatement = connection.prepareStatement(sql);预编译，先编写SQL，在这个时候把sql放进去
        //4.编写sql语句
        String sql="select * from users";
        //5.查询sql语句，返回result结果集
        ResultSet resultSet = statement.executeQuery(sql);
        while (resultSet.next()){
            System.out.println("id"+resultSet.getObject("id"));
            System.out.println("name"+resultSet.getObject("name"));
            System.out.println("password"+resultSet.getObject("password"));
            System.out.println("email"+resultSet.getObject("email"));
            System.out.println("birthday"+resultSet.getObject("birthday"));


        }
        //6.查询结束，关闭资源
        resultSet.close();
        statement.close();
        connection.close();
    }
}

 //受影响的行数，增删改都用executeUpdate(sql)
        int i = statement.executeUpdate(sql);

预编译sql

public class TestJdbc2 {
    public static void main(String[] args) throws Exception {
        //获取配置信息
        String url="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
        String username="root";
        String password="123456";
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库
​
        Connection connection = DriverManager.getConnection(url, username, password);
        //3.编写sql语句
        String sql="insert into users(id, name, password, email, birthday) values(?,?,?,?,?)";
        //4.预编译
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setInt(1,4);//给第一个?占位符赋值为1
        preparedStatement.setString(2,"赵六");
        preparedStatement.setString(3,"123456");
        preparedStatement.setString(4,"1395950933@qq.com");
        preparedStatement.setDate(5,new Date(new java.util.Date().getTime()));
        //5.执行SQL
        int i = preparedStatement.executeUpdate();
        if(i>0){
            System.out.println("插入成功！");
        }
        //6.关闭数据库
        preparedStatement.close();
        connection.close();
    }
}

事务

 

Junit单元测试

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>