Javaweb从入门到实战

最新推荐文章于 2024-05-10 17:58:24 发布

9ack!?

最新推荐文章于 2024-05-10 17:58:24 发布

阅读量5.2k

点赞数 9

文章标签： 1024程序员节

本文链接：https://blog.csdn.net/apple_52296856/article/details/127490502

版权

HTTP

Http请求

1. 请求行

请求行中的请求方式: Get, Post, HEAD, DELETE, PUT…
- get: 请求能够携带的参数比较少，大小有限制，会在浏览器URL地址栏显示数据内容，不安全，但高效
- post: 请求能够携带的参数没有限制，大小没限制，不会在浏览器URL地址栏显示数据内容，安全，但效率不如get

2. 消息头

Accept: 告诉浏览器，它所支持的数据类型
Accept-Encoding: 支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language: 告诉浏览器，它的语言环境
Cache-Control: 缓存控制
Connection: 告诉浏览器，请求完成是断开还是保持连接

Http响应

服务器–响应–客户端

百度:

Content-Type: text/html;charset=utf-8
Content-Encoding: gzip
Cache-Control: private
Connection: keep-alive

1.响应体

Accept: 告诉浏览器，它所支持的数据类型
Accept-Encoding: 支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language: 告诉浏览器，它的语言环境
Cache-Control: 缓存控制
Connection: 告诉浏览器，请求完成是断开还是保持连接
Refresh: 告诉客户端，多久刷新一次
Location: 让网页重新定位

2. 响应状态码

200: 请求响应成功
3xx: 请求重定向
 - 重定向：重定向到另外一个资源
4xx: 找不到资源
 - 资源不存在
5xx: 服务器代码错误  502: 网关错误

常用面试题

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

Maven

在Javaweb开发中，需要大量的jar包，我们需要手动导入
有什么工具能自动导入和配置jar包。

Maven就是用来解决这种问题的

Maven项目架构管理工具

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

有约束，不要去违反

Maven会规定好该如何去编写Java代码，必须按照这个规范来。

配置环境变量

M2_HOME maven目录下的bin 目录
MAVEN_HOME maven的目录
在系统的 PATH 中配置加入 $MAVEN_HOME/bin

配置阿里云镜像

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

在IDEA中使用Maven

启动IDEA
创建一个Maven项目
等待项目

POM文件

pom文件是maven的核心配置文件

Servlet

简介

是sun公司开发动态web的一门技术
Sun在这些API中提供一个接口叫做: Servlet。如果想开发一个Servlet程序，只需要完成两步
- 编写一个类，实现Servlet接口
- 把开发好的Java类部署到web服务器中

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

HelloServlet

Servlet接口在Sun公司有两个默认的实现类：HttpServlet, GenericServle

构建一个Maven项目，删掉里面的src目录，以后的学习就在这个项目里面新建Moudle；这个工程就是Maven的主工程。

关于Maven父子工程的理解：

父项目中有:

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

子项目中有:

<parent>
    <artifactId>javaweb-02-servlet</artifactId>
    <groupId>org.example</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>

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

Maven环境优化
1. 修改web.xml为最新的
2. 将maven的结构搭建完整

编写一个Servlet程序

编写一个普通类
实现Servlet接口，这里我们直接继承HttpServlet

public class HelloServlet extends HttpServlet {

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

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

编写Servlet的映射

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

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

配置Tomcat
启动测试

Servlet原理

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

这里缺一张图

Mapping问题

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

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

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

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

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

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

默认请求路径

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

可以自定义后缀实现请求映射

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>*.jack</url-pattern> <!-- *前不能加任何路径 -->
</servlet-mapping>

优先级问题

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

<servlet>
    <servlet-name>error</servlet-name>
    <servlet-class>com.jack.servlet.ErrorServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>error</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

ServletContext

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

共享数据

在某个Servlet 中保存的数据可以在另一个Servlet中访问

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // this.getInitParameter();
        // this.getServletConfig();
        ServletContext context = this.getServletContext();
        String username = "jack";
        context.setAttribute("username", username);  // 将一个数据保存在ServletContext中, 相当于插入了一个键值对, 这个值是Object类型的
        System.out.println("Hello");
    }
}

public class GetServlet extends HttpServlet {
    @Override
    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);
    }

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

<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.jack.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.jack.servlet.GetServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>getc</servlet-name>
    <url-pattern>/getc</url-pattern>
</servlet-mapping>

测试访问结果

先访问/hello将对应的键值对存入ServletContext里，然后再访问/getc即可得到结果:

获取初始化参数

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

public class ServletDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();

        String url = context.getInitParameter("url");
        resp.getWriter().print(url);
    }

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

请求转发

  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      ServletContext context = this.getServletContext();
      System.out.println("进入ServletDemo04");
      // RequestDispatcher dispatcher =  context.getRequestDispatcher("/gp");  // 转发的请求路径
      // dispatcher.forward(req, resp);  // 调用forward实现请求转发
      context.getRequestDispatcher("/gp").forward(req, resp);
  }

读取资源文件

Properties类

在java目录下新建properties文件
在resources目录下新建properties文件

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

思路：需要一个文件流

username=jack
password=123456

public class ServletDemo05 extends HttpServlet {
    @Override
    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().println(user+":"+pwd);
    }

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

HttpServletResponse

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

如果要获取客户端请求过来的参数: 找HttpServletRequest
如果要给客户端响应一些信息: 找HttpServletResopnse

简单分类

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

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

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

void setCharacterEncoding(String var1);
void setContentLength(int var1);
void setContentLengthLong(long var1);
void setContentType(String var1);

void setDateHeader(String var1, long var2);
void addDateHeader(String var1, long var2);
void setHeader(String var1, String var2);
void addHeader(String var1, String var2);
void setIntHeader(String var1, int var2);

响应状态码（记上面提到常用的即可）

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_INFORMATION = 203;
int SC_NO_CONTENT = 204;
int SC_RESET_CONTENT = 205;
int SC_PARTIAL_CONTENT = 206;
int SC_MULTIPLE_CHOICES = 300;
int SC_MOVED_PERMANENTLY = 301;
int SC_MOVED_TEMPORARILY = 302;
int SC_FOUND = 302;
int SC_SEE_OTHER = 303;
int SC_NOT_MODIFIED = 304;
int SC_USE_PROXY = 305;
int SC_TEMPORARY_REDIRECT = 307;
int SC_BAD_REQUEST = 400;
int SC_UNAUTHORIZED = 401;
int SC_PAYMENT_REQUIRED = 402;
int SC_FORBIDDEN = 403;
int SC_NOT_FOUND = 404;
int SC_METHOD_NOT_ALLOWED = 405;
int SC_NOT_ACCEPTABLE = 406;
int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
int SC_REQUEST_TIMEOUT = 408;
int SC_CONFLICT = 409;
int SC_GONE = 410;
int SC_LENGTH_REQUIRED = 411;
int SC_PRECONDITION_FAILED = 412;
int SC_REQUEST_ENTITY_TOO_LARGE = 413;
int SC_REQUEST_URI_TOO_LONG = 414;
int SC_UNSUPPORTED_MEDIA_TYPE = 415;
int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
int SC_EXPECTATION_FAILED = 417;
int SC_INTERNAL_SERVER_ERROR = 500;
int SC_NOT_IMPLEMENTED = 501;
int SC_BAD_GATEWAY = 502;
int SC_SERVICE_UNAVAILABLE = 503;
int SC_GATEWAY_TIMEOUT = 504;
int SC_HTTP_VERSION_NOT_SUPPORTED = 505;

常见应用

向浏览器输出消息

下载文件

要获取下载文件的路径
下载的文件名
设置想办法让浏览器能支持下载
获取下载文件的输入流
创建缓冲区
获取OutputStream对象
将FileOutputStream流写入到缓冲区
使用OutputStream将缓冲区的数据输入到客户端

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // 1. 要获取下载文件的路径
    String realPath = "/Users/macbook/WorkSpace/Learning/JavaWeb/javaweb-02-servlet/response/target/classes/1.jpeg";
    System.out.println("下载文件的路径: " + realPath);
    // 2. 下载的文件名
    String fileName = realPath.substring(realPath.lastIndexOf('/')+1);
    // 3. 设置想办法让浏览器能支持下载
    // 设置响应头, 如果fileName为中文，则需要改变编码URLEncoder.encode(fileName, "UTF-8")
    resp.setHeader("Content-Disposition","attachment;filename="+fileName);
    // 4. 获取下载文件的输入流
    FileInputStream in = new FileInputStream(realPath);
    // 5. 创建缓冲区
    byte[] buffer = new byte[1024];
    // 6. 获取OutputStream对象
    ServletOutputStream outputStream = resp.getOutputStream();
    // 7. 将FileOutputStream流写入到缓冲区
    int len;
    while((len = in.read(buffer))>0) {
        outputStream.write(buffer, 0, len);
    }
    in.close();
    outputStream.close();
    // 8. 使用OutputStream将缓冲区的数据输入到客户端
}

验证码功能

验证码怎么来的？

前段实现
后端实现，需要用到java的图片类，生成一个图片

public class ImageServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 如何让浏览器每5秒自动刷新一次
        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/jpeg");
        // 网站存在缓存，不让浏览器缓存
        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 num = random.nextInt(99999999) + "";
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 7-num.length(); ++i) {  // 用0补齐数字位数
            sb.append("0");
        }
        num = sb.toString() + num;
        return num;
    }

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

实现重定向

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

void sendRedirect(String var1) throws IOException;

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
/*
    resp.setHeader("Location", "r/img");
    resp.setStatus(HttpServletResponse.SC_MOVED_TEMPORARILY);
*/
    resp.sendRedirect("/response_war/img");  // 这里要注意加上Tomcat配置里面的上下文, 也可以向下面一样直接调用注册的Servlet
    // 这句话实际上完成的工作就是上面两句话的
//        resp.sendRedirect("img");
}

常见场景：

用户登录

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

相同点：

页面都会实现跳转

不同点：

请求转发的时候，URL不会发生变化 307
重定向的时候，URL会发生变化 302

HttpServletRequest

HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器；HTTP请求中的所有协议会被封装到HttpServletRequest，通过这个对象的方法，我们可以获得客户端的所有信息。

获取前端传递的参数，请求转发

@Override
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("======================");
    // 后台接收中文乱码问题
    System.out.println(username);
    System.out.println(password);
    System.out.println(Arrays.toString(hobbies));
    System.out.println("======================");

    // 请求转发的时候不需要带项目路径了，转发的时候会自动带上，转发的时候是按照当前地址为基准的
    // 重定向需要写项目路径，转发不需要
    req.getRequestDispatcher("/success.jsp").forward(req, resp);
}

Cookie, Session

会话

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

有状态会话：

保存会话的两种技术

cookie

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

session

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

常见：网站登录之后，下次不需要重新登录。

Cookie

从请求中拿到cookie信息
服务器响应给客户端cookie

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

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

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

删除Cookie

不设置有效期，关闭浏览器，自动失效；
设置有效期时间为0

Session （重点）

什么是Session:

服务器会给每一个用户（浏览器）创建一个Session对象
一个Session独占一个浏览器，只要浏览器没有关闭，这个Session就存在。
用户登录之后，整个网站都可以保持登录状态

Session和cookie的区别：

Cookie是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个）
Session把用户的数据写到用户独占的Session中，服务器端保存（保存重要的信息，减少服务器资源的使用）

使用场景：

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

使用Session：

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();
    // servlet在调用getSession的时候会创建一个新的Session

    // 给Session存东西
    session.setAttribute("name", new Person("我", 20));

    // 获取Session的ID
    String id = session.getId();

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

    // Session创建的时候做了什么事情
    Cookie cookie = new Cookie("JSESSIONID", id);
    resp.addCookie(cookie);
}

        // 得到Session
        HttpSession session = req.getSession();
        // servlet在调用getSession的时候会创建一个新的Session

        Person person = (Person) session.getAttribute("name");
        if(person != null)
            System.out.println(person.toString());
        else System.out.println("null");

				// 得到Session中的值
        session.removeAttribute("name");

        // 手动注销Session
        session.invalidate();

会话自动过期：web.xml配置

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

JSP

什么是JSP

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

最大特点：

写JSP就像在写HTML

区别：

HTML只给用户提供静态数据
JSP页面中可以嵌入JAVA代码，为用户提供动态数据

JSP原理

思路：JSP到底怎么执行的

代码层面没有任何问题

服务器内部工作

tomcat中有一个work目录；

IDEA中使用Tomcat在IDEA的Tomcate中生成一个work目录

实际上JSP会被tomcat也转换成一个java程序，所以浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet!

在启动Tomcat时命令行的提示信息里有一个CATALINA_BASE

在它对应的目录下找

就能发现这个页面对应的java程序了

查看这个Java程序，可以看到它集成了一个叫HttpJspBase的类

查看HttpJspBase的源代码，就可以发现这个HttpJspBase类实际上也是继承了HttpServlet

再回过头来看index.jsp

// 初始化
public void _jspInit()
  
// 销毁 
public void _jspDestroy()

// JSPService
public void _jspService(final HttpServletRequest request, final HttpServletResponse response)

在_jspService方法中会做下面这些事情

判断请求

内置了一些对象

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: 当前页
HttpServletRequest request;												// 请求
HttpServletResponse response											// 响应

输出页面前增加的代码

response.setContentType("text/html");							// 设置相应的页面类型
pageContext = _jspxFactory.getPageContext(this, request, response,
      null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;

以上的这些对象，我们可以在JSP页面中直接使用

在JSP页面中：

只要是JAVA代码就会原封不动地输出；

如果是HTML代码，就会被转换为
```
out.write("<html>\r\n");
```
这样的格式，输出到前端。

JSP基础语法

JSP作为Java技术的一种应用，它拥有一些自己扩充的语法（了解，知道既可），Java所有语法都支持

JSP表达式

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

JSP脚本片段

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

<%-- 在代码中嵌入HTML元素 --%>
<%
    for (int i = 0; i < 5; i++) {
%>
  <h1>Hello, World <%=i%> </h1>
<%
    }
%>

JSP声明

上面的这些东西都是在_jspService这个方法中执行的，有没有这样一种方法可以添加一些代码到这个方法之外呢，比如创造一个新的方法或者生命一个类里的全局变量呢？当然是可以了，把代码添加到用<%! %>包裹的块中即可实现。

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

JSP声明：会被编译到JSP生成的JAVA类中。其他的会被生成到_jspService方法中！

在JSP中嵌入Java代码即可！

<%代码块%>
<%=输出%>
<%!声明%>
<%-- 注释 --%>

JSP的注释，不会在客户端显示，HTML的会。

JSP指令

<%@page args... %>
<%@include file=""%>

9大内置对象

PageContext 存东西
Request 存东西
Response
Session 存东西
Application (ServletContext) 存东西
config (ServletConfig)
out
page
exception

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

request: 客户端向服务器发送请求，产生的数据，用户看完就没用了；

session: 客户端向服务器发送请求，产生的数据，用户用完一会儿还有用；

application: 客户端向服务器发送请求，产生的数据一个用户用完，其他用户还可能使用。

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

参考网址

<!--  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（Expression Language）表达式：${}

获取数据
执行运算
获取web开发的常用对象
~~调用Java方法，这个不常用~~

JSP标签

<jsp:include page="common/header.jsp"></jsp:include>
<jsp:forward page="jsptag2.jsp">
    <jsp:param name="name" value="jack"/>
    <jsp:param name="age" value="18"/>
</jsp:forward>

JSTL表达式

JSTL标签库的使用就是为了弥补HTML标签的不足；它自定义许多标签，可以供我们使用，便签的功能和Java代码一样！

格式化标签

SQL标签

XML标签

核心标签（掌握部分）

JSTL标签库使用步骤

引入对应的taglib
使用其中的方法

<form action="coreif.jsp" method="get">
  <%--
  EL表达式获取表单中的数据
  ${param.参数名}
  --%>
  <input type="text" name="username" value="${param.username}">
  <input type="submit" value="登陆">
</form>

<%--判断如果提交的用户名是管理员，则登陆成功--%>
<%--
<%
  if(request.getParameter("username").equals("admin")) {
    out.print("登陆成功");
  }
%>
--%>
<%--下面的标签和上面的java代码实现逻辑是相通的--%>
<c:if test="${param.username=='admin'}" var="isAdmin">
  <c:out value="登陆成功"/>
</c:if>
<c:out value="${isAdmin}"/>

<c:set var="score" value="100"/>

<%-- 有多个条目都满足，只输出第一个满足的 --%>
<c:choose>
  <c:when test="${score>=90}">
    你的成绩为优秀
  </c:when>
  <c:when test="${score>=80}">
    你的成绩为良好
  </c:when>
  <c:when test="${score>=70}">
    你的成绩为一般
  </c:when>
  <c:when test="${score>=60}">
    你的成绩为还行
  </c:when>
</c:choose>


<%
  ArrayList<String> peoples = new ArrayList<>();
  // 下标只能从0开始使用
  peoples.add(0,"张三");
  peoples.add(1,"李四");
  peoples.add(2,"王五");
  peoples.add(3,"赵六");
  peoples.add(4,"钱七");
  request.setAttribute("list", peoples);
%>

<%--
var, 每一次遍历出来的变量
items, 要遍历的对象
--%>
<c:forEach var="people" items="${list}">
  <c:out value="${people}"/> <br>
</c:forEach>

<hr>

<%--
begin, 起始下标
end, 终止下标(包含)
step, 步长
--%>
<c:forEach begin="1" end="3" step="2" var="people" items="${list}">
  <c:out value="${people}"/> <br>
</c:forEach>

c:forEach varStatus属性

current: 当前这次迭代的（集合中的）项
index: 当前这次迭代从 0 开始的迭代索引
count: 当前这次迭代从 1 开始的迭代计数
first: 用来表明当前这轮迭代是否为第一次迭代的标志
last: 用来表明当前这轮迭代是否为最后一次迭代的标志
begin: 属性值
end: 属性值
step: 属性值

例子：

<c:forEach items="${sessionScope.userList}" var="userItem" begin="1" end="10" step="3" varStatus="userStatus">
  XXX
</c:foreach>

实例解读： 对 session 对象存储的 userList 集合对象进行遍历，每次访问的项暂时存储在 userItem 变量中，从索引 1 开始至索引 10 进行访问，但不是依次访问，每隔 3 个元素访问一次。每次访问项的状态相关值由 userStatus 对象暂存。

<c:foreach> 的 varStatus 属性暂存项的相关状态属性，可由 EL 表达式引用。

${userStatus.index} 此项的索引，从0开始 
${userStatus.count} 此项的计数序号，从1开始 
${userStatus.first} 此项是否是第一项，布尔值 
${userStatus.last} 此项是否是最后一项，布尔值 
${userStatus.begin} 此次迭代的起始索引，对应<c:foreach>中begin属性值 
${userStatus.end} 此次迭代的终止索引，对应<c:foreach>中end属性值 
${userStatus.step} 此次迭代的跳跃步伐，对应<c:foreach>中step属性值

JavaBean

实体类

JavaBean有特定的写法：

必须要有一个无参构造；
属性必须私有化；
必须有对应的get/set方法；

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

ORM: 对象关系映射

表 -> 类
字段 -> 类的属性
行记录 -> 对象

People表

id	name	age	address
1	jack1	3	xi’an
2	jack2	18	xi’an
3	jack3	20	xi’an
4	jack4	25	xi’an

class People {
  private int id;
  private String name;
  private int age;
  private String address;
}
class A {
  new People(1, "jack1", 3 "xi'an");
}

MVC三层架构

什么是MVC: Model View Controller 模型、视图、控制器

Servlet和JSP都可以写Java代码；为了易于维护和使用，Servlet专注于处理请求以及控制视图跳转；JSP专注于显示数据。

早些年

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

servlet--CRUD-->数据库
弊端：程序十分臃肿，不利于维护  servlet的代码中：处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码
架构：没有什么是加一层解决不了的！
程序员
｜
JDBC
｜
Oracle Mysql Sqlserver

MVC三层架构

Model

业务处理：业务逻辑（Service）
数据持久层：CRUD – 增删改查（Dao）

View

展示数据
提供链接发起Servlet请求（a, form, img…）

Controller（Servlet）

接受用户的请求：(req: 请求参数、Session)
交给业务层处理对应的代码

控制视图的跳转

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

Filter (重点)

Filter: 过滤器，用来过滤网站的数据；

处理中文乱码
登陆验证…

Filter开发步骤：

导包

编写过滤器

要实现的是javax.servlet下的Filter接口

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 chain) throws IOException, ServletException {
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=UTF-8");

        System.out.println("CharacterEncodingFilter执行前...");
        chain.doFilter(request, response);  // 让我们的请求继续走，如果不写，程序到这里就被拦截停止
        System.out.println("CharacterEncodingFilter执行后...");
    }

    // 销毁: 服务器关闭的时候销毁
    public void destroy() {
        System.out.println("CharacterEncodingFilter销毁");
    }
}

在web.xml中配置Filter

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

监听器

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

编写一个监听器

实现监听器的接口

public class OnlineCountListener implements HttpSessionListener {

    // 创建session监听
    // 一旦一个session被创建，就会触发一次这个事件
    public void sessionCreated(HttpSessionEvent se) {
        System.out.println("Session被创建");
        ServletContext ctx = se.getSession().getServletContext();
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
        System.out.println(se.getSession().getId());
        if(onlineCount == null) {
            ctx.setAttribute("OnlineCount", 1);
        } else {
            ctx.setAttribute("OnlineCount", onlineCount+1);
        }
    }

    // 销毁session监听
    // 一旦一个session被销毁，就会触发一次这个事件
    public void sessionDestroyed(HttpSessionEvent se) {
        System.out.println("Session"+se.getSession().getId()+"被销毁");
        ServletContext ctx = se.getSession().getServletContext();
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
        if(onlineCount == 0) {
            ctx.setAttribute("OnlineCount", 0);
        } else {
            ctx.setAttribute("OnlineCount", onlineCount-1);
        }
        se.getSession().invalidate();
    }
    /*
    * Session 销毁:
    * 1. 手动销毁 getSession().invalidate();
    * 2. 自动销毁 在web.xml中配置session-config下的session-timeout
    * */
}

在web.xml中配置监听器

<listener>
  <listener-class>com.jack.listener.OnlineCountListener</listener-class>
</listener>

看情况是否使用

过滤器、监听器常见应用

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

public class TestPanel {
    public static void main(String[] args) {
        Frame frame = new Frame("国庆节快乐");  // 新建窗体
        Panel panel = new Panel(null);  // 面板

        frame.setLayout(null);  // 设置窗体的布局

        frame.setBounds(300, 300, 500, 500);  // 设置坐标
        frame.setBackground(new Color(0, 0, 255));  // 设置背景色
        panel.setBounds(50, 50, 300, 300);
        panel.setBackground(new Color(0, 255, 0));  // 设置背景色

        frame.add(panel);

        frame.setVisible(true);

        // 现在应用里面的关闭按钮没有用，我们需要配置监听器
        // 监听事件，监听关闭事件

        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                super.windowClosing(e);
            }
        });
    }
}

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

用户登录之后，向Session中放入用户的信息

进入主页时要判断用户是否已经登陆;

public class SysFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {}

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request1 = (HttpServletRequest) request;
        HttpServletResponse response1 = (HttpServletResponse) response;

        if(request1.getSession().getAttribute(Contanst.USER_SESSION) == null) {
            response1.sendRedirect("/error.jsp");
        }

        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {

    }
}

JDBC

什么是JDBC: JavaDataBaseConnector

连接数据库需要jar包的支持:

java.sql
javax.sql
mysql-connector-java 链接驱动（必须要导入）

实验环境搭建

CREATE TABLE USERS(
	id INT PRIMARY KEY,
	`name` varchar(40),
	`password` varchar(40),
	email varchar(60),
	birthday DATE
);

insert into users(id, `name`, `password`, email, birthday)
values(1, '张三', '123456', 'zs@qq.com', '2000-01-01');

insert into users(id, `name`, `password`, email, birthday)
values(2, '李四', '123456', 'ls@qq.com', '2000-01-01');

insert into users(id, `name`, `password`, email, birthday)
values(3, '王五', '123456', 'ww@qq.com', '2000-01-01');

导入数据库依赖

<dependencies>
    <!-- mysql驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.30</version>
    </dependency>
</dependencies>

IDEA中连接数据库

JDBC固定步骤

加载驱动
连接数据库
Statement
编写SQL （根据业务，不同的SQL）
执行SQL
关闭连接

public class TestJdbc {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 配置信息
        // useUnicode=true&characterEncoding=utf-8 解决中文乱码
        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();
        // 4. 编写SQL
        String sql = "select * from users";
        // 5. 执行SQL
        ResultSet rs = statement.executeQuery(sql);
        while(rs.next()) {
            System.out.println("id="+rs.getObject("id"));
            System.out.println("name="+rs.getObject("name"));
            System.out.println("password="+rs.getObject("password"));
            System.out.println("email="+rs.getObject("email"));
            System.out.println("birthday="+rs.getObject("birthday"));
        }
        // 6. 关闭连接，释放资源 (一定要做) 先开的最后关
        rs.close();
        connection.close();
        statement.close();
    }
}

事务

要么都成功，要么都失败

ACID原则：保证数据的安全。

开启事务
事务提交	commit()
事务回滚	rollback()
关闭事务

9ack!?

关注

9
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Javaweb从入门到实战

Http响应服务器–响应–客户端百度:1.响应体2. 响应状态码常用面试题当在浏览器中地址栏输入地址并键入回车的一瞬间到页面能展示回来，经历了什么？Maven就是用来解决这种问题的Maven的核心思想：约定大于配置Maven会规定好该如何去编写Java代码，必须按照这个规范来。在IDEA中使用Maven启动IDEA创建一个Maven项目等待项目POM文件pom文件是maven的核心配置文件把实现了Servlet接口的Java程序叫做ServletServlet接口在Sun公
复制链接

扫一扫