javaweb学习笔记（参考b站狂神）未完结

javaweb

！！！遇到的问题

1.jsp不解析${}

<%@ page isELIgnored="false" %>

jsp中使用${} 展示数据，但是画面上并没有显示出对应数据，而是把 ${}当做文本显示了。
原因是有时候 jsp 默认会无视EL 表达式，需要手动设置 igNoreEL 为 false。

2.BootStrap

 <link rel="stylesheet" href="BootStrap/dist/css/bootstrap.min.css" />
    <script src="../js/jquery-1.11.3.min.js"></script>
    <script type="text/javascript" src="BootStrap/dist/js/bootstrap.min.js"></script>

3.解决乱码问题最快最有效方法

//编码
URLEncoder.encode("中文","utf-8");
//解码
URLDecoder.decode(cookie.getValue(),"UTF-8")

4.依赖

<!--    Servlet依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
      <scope>provided</scope>
    </dependency>
<!--    jsp依赖-->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
      <scope>provided</scope>
    </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>
<!--   hutool-all -->
    <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-all</artifactId>
      <version>5.8.0.M4</version>
    </dependency>
<!--    连接数据库-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.30</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>

1、maven

<!--    在build中配置resources，防止我们资源导出失败的问题-->
    <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>

2、Servlet

抽象定义：Java接收和相应请求时的规则

1. 创建项目

   
   

2. maven中添加Servlet、JSP的依赖

   <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
   <dependency>
       <groupId>javax.servlet</groupId>
       <artifactId>javax.servlet-api</artifactId>
       <version>4.0.1</version>
       <scope>provided</scope>
   </dependency>
   
   <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/jsp-api -->
   <dependency>
       <groupId>javax.servlet.jsp</groupId>
       <artifactId>jsp-api</artifactId>
       <version>2.2</version>
       <scope>provided</scope>
   </dependency>
   

3. 在src/main下创建java和resources

4. 在java中创建类

   public class HelloServlet extends HttpServlet {
       @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映射

6. 配置Tomcat

7. 启动

3、ServletContext

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

3.1、共享数据

getServletContext getAttribute

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

• 首先，需要将数据放在一个Servlet中

  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  //        this.getServletContext()  Servlet上下文
          ServletContext context = this.getServletContext();
  
          String username = "ztb";
          context.setAttribute("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);
      }
  

• 最后配置web.xml

  <servlet>
      <servlet-name>hello</servlet-name>
      <servlet-class>com.glztb.servlet.HelloServlet</servlet-class>
    </servlet>
  
    <servlet-mapping>
      <servlet-name>hello</servlet-name>
      <url-pattern>/hello</url-pattern>
    </servlet-mapping>
  
  <servlet>
      <servlet-name>getServlet</servlet-name>
      <servlet-class>com.glztb.servlet.GetServlet</servlet-class>
  </servlet>
  
  <servlet-mapping>
      <servlet-name>getServlet</servlet-name>
      <url-pattern>/getServlet</url-pattern>
  </servlet-mapping>
  

• 注意：测试结果时，先放进去才能拿出来，先hello后getServlet

3.2、获取初始化参数

getInitParameter

• 配置web应用初始化参数

  <context-param>
      <param-name>url</param-name>
      <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
  </context-param>
  

• 获取初始化参数

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

3.3、请求转发

getRequestDispatcher

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        System.out.println("进入");
        servletContext.getRequestDispatcher("/gp").forward(req,resp);
}

3.4、读取资源文件

Properties

• 在java目录下新建

  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
  
          Properties prop = new Properties();
          prop.load(is);
          String user = prop.getProperty("username");
          String pwd = prop.getProperty("password");
  
          resp.getWriter().print(user+","+pwd);
  
      }
  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          doGet(req, resp);
      }
  }
  

• 在resources目录下新建properties

  username = root
  password = 123456
  

发现：都被打包在 target/classes 路径下（类路径classpath）

4、HttpServletReponse

web服务器接收到客户端的http请求，对于这个请求，创建HttpServletRequest（代表请求）和HttpServletResponse（代表相应）

• 获取客户端请求过来的参数：HttpServletRequest
• 给客户端信息：HttpServletResponse

常见应用

4.1、向浏览器输出消息

4.2、下载文件

步骤：

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

//1.获取下载文件路径
        String realPath = "D:\\Code\\javaWeb\\javaweb-response\\target\\classes\\1.png";
        System.out.println("获取下载文件路径:"+realPath);

//2.下载的文件名是啥
        String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);

//3.设置想办法让浏览器能够支持(下载我们需要的东西),中文文件名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();

注意：以中文命名的文件——URLEncoder.encode( 文件名，“UTF-8”)

4.3、验证码功能

Graphics2D

Graphics2D类继承于Graphics类，提供了几何学、坐标转换、颜色管理及文本排列等更高级的控制。Graphics2D类是java平台渲染二维图形，文字及图片的基础类，提供较好的对绘制形状，填充形状、旋转形状、及定义颜色的支持。

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //如何让浏览器3s自动刷新一次
        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","no-cache");

        //把图片写给浏览器
        ImageIO.write(image, "jpg",resp.getOutputStream());
    }

    //生成随机数
    private String makeNum(){
        Random random = new Random();
        String s = random.nextInt(99999) + "";
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 5-s.length(); i++) {
            sb.append("0");
        }
       return sb.toString() + s;
    }

4.4、重定向

web资源A收到客户端B请求，A会通知客户端B去访问另外一个web资源C，这个过程叫重定向

常见场景：

• 用户登录

  <body>
  <%--  ${ pageContext.request.contextPath 代表当前项目 }--%>
  <form action="${pageContext.request.contextPath}/login" method="get">
      用户名：<input type="text" name="username"><br>
      密码：<input type="password" name="password"><br>
      <input type="submit">
  </form>
  </body>
  

  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      //获取到username、password
          String username = req.getParameter("username");
          String password = req.getParameter("password");
  
          System.out.println(username+":"+password);
  	//重定向到demo页面
          resp.sendRedirect("/javaweb_response_war/demo.jsp");
  }
  

  注意

  1. ${ pageContext.request.contextPath 代表当前项目

  2. resp.sendRedirect(“/javaweb_response_war/demo.jsp”)在目标路径（/demo.jsp）前需要加当前项目路径（/javaweb_response_war）

  3. 浏览器乱码可以在 .jsp 中加

     <%@ page contentType=“text/html;charset=UTF-8”%>

  4. 当jsp不解析${}时，<%@ page isELIgnored=“false” %>

• 测试：

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

  重定向和转发的区别

  相同点：

  • 页面都会实现跳转

  不同点：

  • 请求转发的时候，url不会产生变化
  • 重定向，url地址会发生变化

5、HttpServletRequest

获取参数，请求转发

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");

        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobbies = req.getParameterValues("hobbies");

        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbies));

    //后端跳
        //通过请求转发    这里的 / 表示当前web应用
        req.getRequestDispatcher("/demo.jsp").forward(req,resp);
}

//前端跳页面
pageContext.forward("页面路径")

6、Cookie\Session

6.1、会话

会话：

用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程就是会话

有状态会话：

客户端访问服务端，服务端给客户端一个小饼干，客户端下次访问服务端时拿着小饼干，服务端就知道曾经来过，称之为状态会话

6.2、保存会话的两种技术

cookie

• 客户端技术（相应，请求）

session

• 服务端技术，利用这个技术，可以保存用户的会话信息。可以将信息或数据放在session中

常见：网站登录，第二次访问直接登录

6.3、Cookie

1. req.getCookies() 从请求中拿到cookie信息
2. resp.addCookie(cookie) 服务器响应给客户端cookie

Cookie[] cookies = req.getCookies();//获得cookie
cookie.getName();
cookie.getValue();
new cookie("name","value");
cookie.setMaxAge(24*60*60);//设置cookie有效期

cookie细节

• 一个Cookie只能保存一个信息
• 一个web站点可以给浏览器发送多个cookie，最多存放20个Cookie
• Cookie大小限制4kb
• 300个Cookie是浏览器上限

删除Cookie

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

• 设置有效期时间为0

6.4、Session(重点)

什么是Session

• 服务器会给每一位用户（浏览器）创建一个Session对象
• 一个Session独占一个浏览器，只要浏览器不关闭它就存在

Session和Cookie区别：

• Cookie是把用户的数据写给浏览器，浏览器保存
• Session是把用户的数据写到用户独占Session中，服务器保存（保存重要的信息，减少服务器资源的浪费）
• Session对象由服务器创建；

使用场景：

• 保存一个登录用户的信息
• 购物车信息
• 在整个网站中经常会使用的数据，我们将它保存在Session中

使用Session：

package com.glztb.session;

import com.glztb.pojo.Person;

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

public class SessionDemo01 extends HttpServlet {
    @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.setAttribute("name",new Person("ztb",22));

        String sessionID = session.getId();

        //判断Session是否是新创建的
        if(session.isNew()){
            resp.getWriter().write("session创建成功，ID："+sessionID);
        }else{
            resp.getWriter().write("session已经在服务器中存在了ID:"+sessionID);
        }
    }

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

//获取session
        HttpSession session = req.getSession();
        Person person = (Person) session.getAttribute("name");

        resp.getWriter().write(person.toString());

//获取session
HttpSession session = req.getSession();
//移除
session.removeAttribute("name");
//手动注销
session.invalidate();

会话自动过期

<!--  设置Session默认的失效时间-->
  <session-config>
<!--    设置1分钟后Session自动失效，以分钟为单位-->
    <session-timeout>1</session-timeout>
  </session-config>

7、JSP

7.1、JSP基础语法

1. JSP表达式<%= %>

2. jsp脚本片段<% %>

3. 在代码镶嵌html元素

   <%
       for (int i = 0; i < 10; i++) {
   %>  
           <h2>Hello World!</h2>
   <% 
       }
   %>
   

4. jsp声明:会被编译到JSP生成Java的类中，其他的（除了jsp声明），会被生成到_jspService方法中

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

7.2、JSP指令

<%--组合页面 @include：将页面合二为一 ; jsp:include（常用,低耦合）：拼接页面--%>

<%@include file=""%>
<jsp:include page="">

7.3、9大内置对象

• PageContext 存东西
• Request 存东西
• Response
• Session 存东西
• Application[ServletContext] 存东西
• config[ServletConfig]
• out
• page
• exception

pageContext.setAttribute("name1","1号");//保存的数据只在一个页面中有效
request.setAttribute("name2","2号");//保存的数据只在一次请求中有效，请求转发会携带数据
session.setAttribute("name3","3号");//保存的数据只在一次会话中有效，从打开到关闭浏览器
application.setAttribute("name4","4号");//保存的数据只在服务器中有效，从打开到关闭服务器

应用场景

requst：客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻，用户看完没用的

session：客户端向服务器发送请求，产生的数据，用户用完一会还有用，比如：购物车

application：客户端向服务器发送请求，产生的数据，一个用户用完其他用户可能使用，比如：聊天数据

7.4、JSP标签、JSTL标签、EL表达式

EL表达式：${}

• 获取数据
• 执行运算
• 获取web开发的常用对象

 <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/jsp-api -->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
      <scope>provided</scope>
    </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>

jsp标签

<!-- 页面转发 -->
<jsp:forward page="Student.jsp">
    <!-- 携带参数 -->
    <jsp:param name="name" value="glztb"/>
    <jsp:param name="age" value="18"/>
</jsp:forward>

<!-- 在Student.jsp中获取参数 -->
<%=request.getParameter("name")%>
<%=request.getParameter("age")%>

JSTL标签

• 掌握部分(核心标签)

  <!-- 引入JSTL核心标签库 -->
  <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
  

  <!-- 例：登陆权限管理 -->
  <c:if test="${param.username=='admin'}" var = "isAdmin">
      <c:out value="管理员欢迎你"/>
  </c:if>
  <c:out value="${isAdmin}"/>
  

  

• 了解（格式化标签、SQL标签、XML 标签）

8、JDBC

步骤总结：

1. 加载驱动
2. 连接数据库DriverManager
3. 获得执行sql的对象 Statement
4. 获得返回的结果集
5. 释放连接

8.1、第一个JDBC程序

//1. 加载驱动
Class.forName("com.mysql.jdbc.Drive");
//2. 用户信息和URL
String url = "jdbc:mysql://localhost:3306/jdbcstudy？ 		      useUnicode=true&characterEncoding=utf8&useSSL=true";
String username = "root";
String password = "123456"

//3. 连接成功，数据库对象 Connection 代表数据库
Connection connection = DriverManager.getConnection(url,username,password);
//4. 执行SQL对象 Statement 执行sql对象
Statement statement = connection.createStatement();

//5. 执行SQL的对象去执行SQL，可能存在结果，查看返回结果
String sql = "SELECT * FROM users";
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("pwd"+resultSet.getObject("PASSWORD");
    System.out.println("email"+resultSet.getObject("email");
    System.out.println("birth"+resultSet.getObject("birthday");
}
                      
//6.释放连接                       
resultSet.close();
statement.close();
connetion.close();                             

DriverManager

Class.forName("com.mysql.jdbc.Drive");//固定写法，加载驱动
Connection connection = DriverManager.getConnection(url,username,password);
//connection 代表数据库
//数据库设置自动提交
connection.setAutoConnit();
//事务提交
connection.commit();
//事务回滚
connection.rollback();

URL

 String url = "jdbc:mysql://localhost:3306/jdbcstudy？ 		             useUnicode=true&characterEncoding=utf8&useSSL=true";
     
//mysql -- 3306
//jdbc:mysql://localhost:3306/jdbcstudy？
//协议://主机地址:端口号/数据库名?参数1&参数2&参数3
    
//orale -- 1521
//jdbc:oracle:thin:@localhost:1521:sid

Statement 执行SQL对象 prepareStatement执行

String sql = "SELECT * FROM users";//编写SQL

statement.executeQuery();//查询操作，返回ResultSet
statement.execute();//执行任何SQL
statement.executeUpdate();//更新、插入、删除。都是用这个，返回一个受影响的行数

ResultSet 查询的结果集：封装了所有的查询结果

获得指定的数据类型

resultSet.getObject();//在不知道列类型的情况下使用
//知道列类型就使用指定类型
resultSet.getString();
resultSet.getInt();
resultSet.getFloat();
resultSet.getDate();
resultSet.getObject();

遍历，指针

resultSet.beforeFirst();//移动到最前面
resultSet.afterLast();//移动到最后面
resultSet.next();//移动到下一个数据
resultSet.previous();//移动到前一行
resultSet.absolute(row);//移动到指定行

释放资源

resultSet.close();
statement.close();
connetion.close();
//耗资源，用完关掉

8.2、statement对象

statement对象的executeUpdate方法用于向数据库发送增删改，返回整数（几行数据发生改变）

statement对象的executeQuery方法用于向数据库发送查询语句，返回ResultSet对象

代码实现

1. 提取工具类

   • 新建文件db.properties

     driver = com.mysql.cj.jdbc.Driver
     url = jdbc:mysql://localhost:3306/glztb?useUnicode=true&useSSL=true&chacaterEncoding=utf-8&serverTimezone=GMT
     user = root
     pwd = 123456
     

   • 新建utils.JDBCUtils

     public class JDBCUtil {
     
         static String driver = null;
         static String url = null;
         static String user = null;
         static String pwd = null;
     
         static{
             try {
                 InputStream in = JDBCUtil.class.getClassLoader().getResourceAsStream("db.properties");
                 Properties properties = new Properties();
                 properties.load(in);
                 driver =  properties.getProperty("driver");
                 url =  properties.getProperty("url");
                 user =  properties.getProperty("user");
                 pwd =  properties.getProperty("pwd");
                 Class.forName(driver);
             } catch (ClassNotFoundException | IOException e) {
                 e.printStackTrace();
             }
         }
         public static Connection getConnection() throws SQLException {
             return DriverManager.getConnection(url,user,pwd);
         }
         public static void freed(ResultSet res, Statement sta, Connection conn) throws SQLException {
             if(res!=null){
                 res.close();
             }
             if(res!=null){
                 sta.close();
             }
             if(res!=null){
                 conn.close();
             }
         }
     

   • 以登录为例 通过查询用户名返回密码

     public String getPasswordByUsername(String username) throws SQLException {
             Connection connection = null;   //数据库
             PreparedStatement st = null;    //执行sql
             ResultSet res = null;           //返回结果集
     
             connection = JDBCUtil.getConnection();
             //与Statement不同的是，PreparedStatement中的 sql 的变量可以用"?"占位符，类似C语言的%d
             String sql = "select * from user where `username` = ?;";
             st = connection.prepareStatement(sql);//这个操作就是预执行
             st.setString(1,username);  // 知道类型直接可以set类型,不知道类型的话可以setObject()
     
             res = st.executeQuery();//执行sql
             String password = "";
             if (res.next()) {
                 password = res.getString("password");
             }
             JDBCUtil.freed(res, st, connection);
             return password;
         }
     

2. 增删改方法executeUpdate

3. 查询方法executeQuery

8.3、PreparedStatement对象

与Statement不同的是，PreparedStatement中的 sql 的变量可以用"?"占位符，类似C语言的%d

String sql = "select * from user where `username` = ?;";
st = connection.prepareStatement(sql);//这个操作就是预执行
st.setString(1,username);  // 知道类型直接可以set类型,不知道类型的话可以setObject()

8.4、使用IDEA连接数据库

连接成功后选择数据库

9、MVC

Model

• 业务处理：业务逻辑（Service）
• 数据持久层：CRUD（Dao）

View

• 显示数据
• 提供链接链接发起Servlet请求（a，form，img）

Controller（Service）

• 接收用户的请求

• 交给业务层处理相对应代码

• 控制视图的跳转

  登录-->接收用户的登录请求-->处理用户请求（获取参数）-->交给业务层处理登陆业务（判断用户名密码是否正确：事务）-->Dao层查询用户名和密码是否正确-->数据库
  

10、Filter(重点)

过滤器，用来过滤网站的数据

request.setCharacterEncoding("utf-8");
response.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=utf-8");

每一个servlet都写是不是很麻烦 ？ 对于这样的问题 我们就可以使用filter啦

• 首先，实现 Filter接口，重写三个方法注意不要导错包(javax.servlet)

  public class CharacterEncodingFilter implements Filter {
      //初始化
      public void init(FilterConfig filterConfig) throws ServletException {
          System.out.println("随着web服务器的启动而启动");
      }
  
      public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
          request.setCharacterEncoding("utf-8");
          response.setCharacterEncoding("utf-8");
          response.setContentType("text/html;charset=utf-8");
          System.out.println("执行前");
          chain.doFilter(request,response);
          System.out.println("执行后");
      }
  
      //销毁
      public void destroy() {
          System.out.println("随着web服务器的销毁而销毁");
      }
  }
  

• 其次，配置web.xml注意*代表所有

   <filter>
      <filter-name>CharacterEncodingFilter</filter-name>
      <filter-class>com.glztb.fiter.CharacterEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
      <filter-name>CharacterEncodingFilter</filter-name>
      <url-pattern>/servlet/*</url-pattern>
    </filter-mapping>
  

11、监听器

实现一个监听器接口

1. 编写监听器实现接口

   public class OnlineCountListener implements HttpSessionListener {
       @Override
       //创建session监听
       public void sessionCreated(HttpSessionEvent se) {
           ServletContext sct = se.getSession().getServletContext();
           Integer onlineCount = (Integer) sct.getAttribute("OnlineCount");
   
           if (onlineCount==null){
               onlineCount = new Integer(1);
           }else{
               int count = onlineCount.intValue();
               onlineCount = new Integer(count++);
           }
   
           sct.setAttribute("OnlineCount",onlineCount);
       }
   
       @Override
       //销毁session监听
       public void sessionDestroyed(HttpSessionEvent se) {
           ServletContext sct = se.getSession().getServletContext();
           Integer onlineCount = (Integer) sct.getAttribute("OnlineCount");
   
           if (onlineCount==null){
               onlineCount = new Integer(1);
           }else{
               int count = onlineCount.intValue();
               onlineCount = new Integer(count--);
           }
   
           sct.setAttribute("OnlineCount",onlineCount);
       }
   }
   

2. web.xml配置监听器

   <!--  注册监听器-->
     <listener>
       <listener-class>com.glztb.listener.OnlineCountListener</listener-class>
     </listener>
   

sion().getServletContext();
Integer onlineCount = (Integer) sct.getAttribute(“OnlineCount”);

       if (onlineCount==null){
           onlineCount = new Integer(1);
       }else{
           int count = onlineCount.intValue();
           onlineCount = new Integer(count++);
       }

       sct.setAttribute("OnlineCount",onlineCount);
   }

   @Override
   //销毁session监听
   public void sessionDestroyed(HttpSessionEvent se) {
       ServletContext sct = se.getSession().getServletContext();
       Integer onlineCount = (Integer) sct.getAttribute("OnlineCount");

       if (onlineCount==null){
           onlineCount = new Integer(1);
       }else{
           int count = onlineCount.intValue();
           onlineCount = new Integer(count--);
       }

       sct.setAttribute("OnlineCount",onlineCount);
   }

}

2. web.xml配置监听器

```xml
<!--  注册监听器-->
  <listener>
    <listener-class>com.glztb.listener.OnlineCountListener</listener-class>
  </listener>