JavaWeb

文章目录

JavaWeb

1.基本概念

1.1前言

静态web

技术栈：html,css
数据始终不会发生改变

动态web

技术栈：Sevlet/JSP, ASP , PHP
不同时间，不同事件，数据有所不同和改变

1.2 动态web

缺点：

加入动态web资源出现错误需要停机维护

优点：

可以动态更新web页面
可以与数据库交互

2.web服务器

ASP：

微软研发，最早在国内流行
HTML中加入大量VB脚本
代码混乱，维护困难

PHP：

代码简单，开发速度快，功能强大，跨平台
局限性：无法承载高并发

JSP/Servlet

B/S：浏览器/服务器

C/S：客户端/服务器

基于JAVA语言
可以承载三高（高并发，高可用，高性能）问题带来的影响

web服务器

服务器是一种被动操作，用来处理用户的请求和响应

IIS

windows系统自带的服务器

Tomcat

Tomcat实际上运行JSP/Servlet

工作3–5年后可以尝试手写tomcat服务器

3.Tomcat

3.1安装

tomcat官网：https://tomcat.apache.org/

文件夹信息：

3.2 配置

可以配置启动端口号

tomcat：8080
http:80
https:443
mysql:3306

可以配置启动主机名称

默认主机名为：localhost -> 127.0.0.1
默认网站应用存放的位置为：webapps

网站是怎样访问的

输入一个域名
先查找本地host配置文件下有没有这个域名映射
- 有，可以直接访问
- 没有，访问本地DNS服务器，如果本地服务器也没有则会询问根服务器，然后根据域名，层层递归查询，找到则返回域名对应的IP地址
- DNS域名服务器详解：https://blog.csdn.net/weixin_40470303/article/details/80642190

3.3 网站怎么发布

网站应该有的结构

--webapps : tomcat服务器的web目录
    -Root
    -exmaple : 网站的目录名
        -static : 存放静态文件
            -css
            -js
            -img
        -WEB-INF
        	-classes : java程序
            -lib : web应用依赖的jar包
            -web.xml : 网站的配置文件
        -index.html 默认的首页
    ......

4.HTTP

4.1 什么是HTTP

HTTP : 超文本传输协议，通常运行在应用层

4.2 历史

http1.0 : 客户端与web服务器连接后，只能获得一个web资源
http2.0：在1.0的基础上推出了长连接（即一次连接可以传输多次）

4.3 Http请求

请求行

请求网址:https://www.baidu.com/home/pcweb/data/mancardhtml?id=1&isPull=&indextype=manht&_req_seqid=0xf5d85f62000d2fc3&asyn=1&t=1590305654161&sid=1463_31325_21097_31605_22158
请求方法:GET
远程地址:183.232.231.172:443
状态码:
200
版本:HTTP/1.1
Referrer 政策:unsafe-url

以上的请求方式：GET
请求方式：
- GET ：能够携带的数据较少，会在浏览器显示
- POST : 没有大小限制，不会在浏览器显示，较为安全，但不高效

消息头

4.4 Http响应

响应体

响应状态码

200：响应成功

3XX：重定向

4XX：资源不存在

5XX：服务器（500）/网关（502）错误

面试题：

从你在浏览器输入域名并回车到看到页面经历了什么？

5.Maven

5.1 Maven项目架构管理工具

约定大于配置

1.在javaweb开发中，需要导入大量jar包

2.Maven帮助我们自动导入需要的jar包

5.2 建立本地仓库

<localRepository>D:\Enviroment\apache-maven-3.6.3\maven-repo</localRepository>

5.3 阿里云镜像

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

5.4 配置环境变量

Path变量

系统变量

5.5 在IDEA中使用Maven

1.创建一个Maven项目

2.命名和存放地址

3.创建一个空的Maven项目

IDEA中标记文件夹

4.配置Tomcat

为什么会出现警告：

我们访问网站，需要指定一个文件（即虚拟路径映射）

配置完成后启动：

5.target文件夹

6.porm文件

<?xml version="1.0" encoding="UTF-8"?>

<!--Maven版本头文件-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <!--项目信息-->
  <groupId>mrh</groupId>
  <artifactId>javaweb-maven01</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>javaweb-maven01 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <!--项目默认编码-->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <!--项目依赖-->
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>javaweb-maven01</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

由于Maven约定大于配置，我们之后写的配置文件可能存在无法导出的问题

解决方案：

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

Maven 架构树

6.Servlet

6.1 简介

Servlet是开发动态web的技术
Servlet小程序
- 编写一个类，实现Servlet接口
- 将java类部署到web服务器中

原博客：http://www.cnblogs.com/wangjiming/

Servlet UML关系图

从图中，可以看出：

1.抽象类HttpServlet继承抽象类GenericServlet，其有两个比较关键的方法，doGet()和doPost()

2.GenericServlet实现接口Servlet,ServletConfig,Serializable

3.MyServlet(用户自定义Servlet类)继承HttpServlet，重写抽象类HttpServlet的doGet()和doPost()方法

####Servlet在容器中的执行过程

Servlet只有放在容器中，方可执行，且Servlet容器种类较多，如Tomcat,WebLogic等。下图为简单的请求响应模型。

分析：

1.浏览器向服务器发出GET请求(请求服务器ServletA)

2.服务器上的容器逻辑接收到该url,根据该url判断为Servlet请求，此时容器逻辑将产生两个对象：请求对象(HttpServletRequest)和响应对象(HttpServletResponce)

3.容器逻辑根据url找到目标Servlet(本示例目标Servlet为ServletA),且创建一个线程A

4.容器逻辑将刚才创建的请求对象和响应对象传递给线程A

5.容器逻辑调用Servlet的service()方法

6.service()方法根据请求类型(本示例为GET请求)调用doGet()(本示例调用doGet())或doPost()方法

7.doGet()执行完后，将结果返回给容器逻辑

8.线程A被销毁或被放在线程池中

注意：

1.在容器中的每个Servlet原则上只有一个实例

2.每个请求对应一个线程

3.多个线程可作用于同一个Servlet(这是造成Servlet线程不安全的根本原因)

4.每个线程一旦执行完任务，就被销毁或放在线程池中等待回收

Servlet在JavaWeb中扮演的角色

Servlet在JavaWeb中，扮演两个角色：页面角色和控制器角色。

有了jsp等动态页面技术后，Servlet更侧重于控制器角色，jsp+servlert+model 形成基本的三层架构

Servlet在容器中的生命周期

分析：

第一步：容器先加载Servlet类

第二步：容器实例化Servlet(Servlet无参构造函数执行)

第三步：执行init()方法（在Servlet生命周期中，只执行一次，且在service()方法执行前执行）

第四步：执行service()方法，处理客户请求，doPost()或doGet()

第五步：执行destroy()，销毁线程

6.2 HelloServlet

1.构建一个普通的Maven项目，删掉原来的scr文件夹,在项目中建立一个Modoul,这个工程就是Maven的主工程

2.Maven的父子工程：

父项目中：

<modules>
    <module>hello</module>
</modules>

子项目中：

<parent>
    <artifactId>helloServlet</artifactId>
    <groupId>org.example</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>

6.3 Servlet重定向与转发

重定向和转发的区别：

相同：

页面都会实现跳转

不同：

转发不会改变地址栏的URL
重定向后，URL会改变

登陆页面

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<html>
<body>
<h2>Hello World!</h2>

<%--这里提交的路径，需要找的项目的路径--%>

<form action="/s01/redirect", method="post">
    用户名：<input type="text" name="username"> <br>
    密码：<input type="password" name="password"> <br>
    爱好：
    <input type="checkbox" name="hobby" value="girl">女孩
    <input type="checkbox" name="hobby" value="movie">电影
    <input type="checkbox" name="hobby" value="game">游戏
    <br>
    <button type="submit">提交</button>
</form>

</body>
</html>

####重定向

public class RedirectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username =  req.getParameter("username");
        String password =  req.getParameter("password");
        String[] hobbies = req.getParameterValues("hobby");

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

		//需要加上项目路径
        resp.sendRedirect("/s01/dispatcher");
    }

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

public class DispatcherServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username =  req.getParameter("username");
        String password =  req.getParameter("password");
        String[] hobbies = req.getParameterValues("hobby");

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


        //重定向与转发不同的是，重定向默认相对地址为当前项目，所以不需要再加上项目路径
        req.getRequestDispatcher("/success.jsp").forward(req,resp);
    }

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

7.Cookie和Session

7.1 会话

会话：用户从打开浏览器浏览页面到关闭浏览器的过程称之为会话。
有状态会话：
- cookie：服务器给客户端一个信件，客户端下次访问时带上信件就行了
- session：服务器登记过你的信息，下次再来服务器会自动匹配

7.2 保存会话的两种技术

1.cookie

1.从请求中拿到cookie信息

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

一个cookie只能保存一个信息
一个web站点可以给客户端发送多个cookie
cookie大小限制为4kb
不设置cookie有效期，关闭浏览器时，自动失效

 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决中文乱码
        //设置编码
        resp.setCharacterEncoding("UTF-8");
        //通知解码
        resp.setHeader("Content-Type", "text/html;charset=UTF-8");

        Cookie[] cookies = req.getCookies();

        PrintWriter out = resp.getWriter();

        //存在cookie
        if(cookies!=null){
            out.write("上次访问时间为： ");

            for (int i = 0; i < cookies.length; i++) {
                if(cookies[i].getName().equals("lastLoginTime")){
                    //获取cookie值
                    String t = cookies[i].getValue();
                    System.out.println(t);
                    Date date = new Date(Long.parseLong(t));
                    out.write(date.toString());
                }
            }

        }else {
            //不存在cookie
            out.write("第一次访问");
        }

        //服务端更新客户端的cookie
        Cookie cookie = new Cookie("lastLoginTime",System.currentTimeMillis()+"");
        //设置存活周期
        cookie.setMaxAge(24*60);

        resp.addCookie(cookie);

    }

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

2.session

服务器会给每一个用户（浏览器）创建一个session对象
只要浏览器不关闭就一直存在
主要用于存储用户信息
客户端只保存Session的ID

第一次创建Session的时候，服务端会在HTTP协议中告诉客户端，需要在 Cookie 里面记录一个Session ID，以后每次请求把这个会话ID发送到服务器，我就知道你是谁了。

public class Session01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决乱码
        resp.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=utf-8");

        //得到session
        HttpSession session = req.getSession();

        //向session存信息
       session.setAttribute("name", "mrh");

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

        //判断session是不是新创建的
        if(session.isNew()){
            resp.getWriter().write("session创建成功："+ id);
        }else {
            resp.getWriter().write("sessiom已经存在："+id);
        }
    }

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

手动注销Session

//手动注销Session
session。removeAttribute("name");
session.invalidate();

**设置Session有效期 : 配置web.xml

<session-config>
    <!--15分钟自动失效-->
	<session-timeout>15</session-timeout>
</session-config>

Session使用场景：

保存一个登陆用户的信息
购物车信息
经常在网站中会使用的数据

Session和Cookie的区别

Cookie是将用户的数据写给用户浏览器，由浏览器保存
Session把用户的数据写至用户独占Session中，有服务端保存
Session对象由服务端创建

8.JSP

8.1 什么是JSP

Java Servlet Page : 是一种动态Web技术

最大特点：

可以写HTML代码
可以嵌入java代码，为用户提供动态数据

8.2 JSP原理

浏览器向服务端发送请求，其实都是在访问Servlet

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

java代码不变，html代码会转换成以下形式：

out.write("<html>\r\n");

JSP本质是一个Servlet

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JTjhZZmp-1591181512815)(C:%5CUsers%5CAdministrator%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20200529153250610.png)]

8.3 九大内置对象与四大作用域

PageContext （存数据）
Request （存数据）
Response
Session （存数据）
Application [ServletContext] （存数据）
config [ServletConfig]
out
page
exception

四大作用域

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Demo01</title>
</head>
<body>

<%--
    脚本中的代码会原封不动的生成到java中，这里必须保证java语法的正确性
--%>

<%
    pageContext.setAttribute("name01","mrh01"); //只在一个页面有效
    request.setAttribute("name02","mrh02"); //只在一次请求中有效
    session.setAttribute("name03","mrh03"); //再一次会话中有效
    application.setAttribute("name04","mrh04"); //在服务器中有效（从打开服务器到关闭服务器）
%>

<%
    String name01 = pageContext.findAttribute("name01").toString();
    String name02 = pageContext.findAttribute("name02").toString();
    String name03 = pageContext.findAttribute("name03").toString();
    String name04 = pageContext.findAttribute("name04").toString();
%>

<%--使用EL表达式取值--%>
<h1>取出的值为：</h1>
<h3><%=name01%></h3>
<h3>${name02}</h3>
<h3>${name03}</h3>
<h3>${name04}</h3>


</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Demo02</title>
</head>
<body>
<h1>取出的值为：</h1>
<h3>${name01}</h3>
<h3>${name02}</h3>
<h3>${name03}</h3>
<h3>${name04}</h3>
</body>
</html>

name01和name02过期，只取出name03和name04的值

问题：如果从Demo01页面转发转到Demo02页面会访问那些数据

请求数据会跟随转发到最终的页面

9.JavaBean

实体类

写法：

必须要有一个无参构造
属性是优化
有对应的get和set函数
一般用于和数据库数据做映射（ORM）

ORM：对象关系映射

name	age	address
m1	10	贵州
m2	18	贵州
m3	30	贵州

class people{
	private String name;
    private int age;
    private String address;
}

10.三层架构MVC

两层构架：

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

弊端：控制层要做大多的事情，使得代码过臃肿，不利于维护

三层架构：

Model

业务处理（Service）
数据持久化（Dao）

View

展示数据
提供请求通道

Controller

接收请求
交给业务处处理
控制视图跳转

以登陆为例

登陆-->接收用户登陆请求-->处理请求（获取登陆信息）-->交给业务层处理-->Dao层查询用户信息是否正确-->数据库

11.Filter(过滤器)

用于过滤网站数据

filterDemo

package com.mrh.filter;

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

/**
 * CharacterFilter
 * 2020/6/2 18:15
 * 主要用于将字符编码同一变为UTF-8
 * @Author m
 **/
public class CharacterFilter implements Filter {
    //初始化
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    /**
     *
     * @param request
     * @param response
     * @param filterChain
     * @throws IOException
     * @throws ServletException
     * Chain : 链
     *
     */
    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("你好Fasfsafasfasf");
        System.out.println("CharacterFilter执行前...");
        filterChain.doFilter(request,response); // 让请求往前走，否则程序会倍拦截在这
        System.out.println("CharacterFilter执行后...");

    }

    public void destroy() {
        System.out.println("CharacterFilter销毁");
    }
}

servletDemo

package com.mrh.servlet;



import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * ShowServlet
 * 2020/6/2 18:31
 *
 * @Author m
 **/
public class ShowServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        /*//设置编码
        resp.setCharacterEncoding("UTF-8");
        //通知解码
        resp.setHeader("Content-Type", "text/html;charset=UTF-8");*/
        resp.getWriter().write("你好！！！");
    }

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

web.xml

<servlet>
        <servlet-name>Show</servlet-name>
        <servlet-class>com.mrh.servlet.ShowServlet</servlet-class>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>Show</servlet-name>
        <url-pattern>/show</url-pattern>
    </servlet-mapping>

    <servlet-mapping>
        <servlet-name>Show</servlet-name>
        <url-pattern>/filter/show</url-pattern>
    </servlet-mapping>


    <filter>
        <filter-name>CharacterFilter</filter-name>
        <filter-class>com.mrh.filter.CharacterFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>CharacterFilter</filter-name>
        <!--表示filter下的所有请求都经过过滤器-->
        <url-pattern>/filter/*</url-pattern>
    </filter-mapping>

12.JDBC

导入架包

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

连接模板

jdbc直接连接----不推荐

    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //配置信息
        String url = "jdbc:mysql://localhost:3306/db_food?useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "991024";

        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");

        //2.连接数据库，代表数据库
        Connection con = DriverManager.getConnection(url,username,password);

        //3.创建SQL发送载体
        Statement statement = con.createStatement();

        //4.编写SQL
        String sql = "select * from user";

        //5.执行查询语句，返回一个结果集
        ResultSet res = statement.executeQuery(sql);

        while (res.next()){
            System.out.print("id "+res.getObject("id")+" ");
            System.out.print("username "+res.getObject("username")+" ");
            System.out.print("password "+res.getObject("password")+" ");
            System.out.print("email "+res.getObject("email")+" ");
            System.out.println("rank "+res.getObject("rank")+" ");
        }

        //6.关闭连接，释放资源，先打开的要后关闭
        res.close();
        statement.close();
        con.close();

    }

事务

ACID 原则，即原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability），这四种原则保证在事务过程当中数据的安全性

public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //配置信息
        String url = "jdbc:mysql://localhost:3306/shop?useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "991024";

        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");

        //2.连接数据库，代表数据库
        Connection con = DriverManager.getConnection(url,username,password);

        //3.创建SQL发送载体
        Statement statement = con.createStatement();

        //4.编写SQL
        String sql1 = "update account set money = money-100 where name = 'A';";
        String sql2 = "update account set money = money+100 where name = 'B';";


        //5.执行语句，返回一个结果集
        //开启事务,false表示开启,不开启如果遇到错误可能会时数据异常
        //con.setAutoCommit(false);

        con.prepareStatement(sql1).executeUpdate();

        //制造错误,让语句无法执行
        int i = 1/0;

        con.prepareStatement(sql2).executeUpdate();

        //提交数据
        //con.commit();

        //6.关闭连接，释放资源，先打开的要后关闭
        statement.close();
        con.close();

    }

Junit单元测试

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

@Test注解只在方法上有效，可以直接运行

13.如何搭建一个maven web项目

新建一个maven web项目
配置Tomcat
测试项目是否能运行

导入现阶段可能会用到的jar包

<dependencies>
    <!--servlet依赖-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
    </dependency>
    <!--jsp依赖-->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2</version>
    </dependency>
    <!--jsp语法依赖-->
    <dependency>
        <groupId>javax.servlet.jsp.jstl</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <!--jsp标签依赖-->
    <dependency>
        <groupId>taglibs</groupId>
        <artifactId>standard</artifactId>
        <version>1.1.2</version>
    </dependency>
    <!--数据库连接依赖-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <!--单元测试依赖-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

</dependencies>

创建项目包结构
编写实体类
- 表-类的映射

编写基础公共类

数据库配置文件

url = jdbc:mysql://localhost:3306?useUnicode=true&characterEncoding=utf-8
username = root
password = 991024
Driver = com.mysql.jdbc.Driver

编写基础数据库连接类

package com.mrh.dao;

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

/**
 * @ClassName BaseDao
 * @Description TODO
 * @Author m
 * @Version 1.0
 */
public class BaseDao {

    private static String  driver;
    private static String  url;
    private static String  username;
    private static String  password;
    private static Connection con = null;
    private static PreparedStatement preparedStatement = null;
    private static ResultSet res = null;

    public static Connection getCon() {
        return con;
    }

    public static PreparedStatement getPreparedStatement() {
        return preparedStatement;
    }

    public static ResultSet getRes() {
        return res;
    }
    
    //静态代码块，类加载的时候就初始化了
    static {
        Properties properties = new Properties();
        //通过类加载器读取对应资源
        InputStream inputStream = BaseDao.class.getClassLoader().getResourceAsStream("db.properties");

        try {
            properties.load(inputStream);
        }catch (Exception e){
            e.printStackTrace();
        }

        driver = properties.getProperty("driver");
        url = properties.getProperty("url");
        username = properties.getProperty("username");
        password = properties.getProperty("password");

    }

    //数据库连接
    public static void connection(){
        try{
            Class.forName(driver);
            con = DriverManager.getConnection(url,username,password);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    //关闭数据库连接
    public static void close(){
        if(res != null){
            try{
                res.close();
            } catch (SQLException throwable) {
                throwable.printStackTrace();
            }
        }
        if(preparedStatement != null){
            try{
                preparedStatement.close();
            } catch (SQLException throwable) {
                throwable.printStackTrace();
            }
        }
        if(con != null){
            try{
                con.close();
            } catch (SQLException throwable) {
                throwable.printStackTrace();
            }
        }
    }

    //查询公共类
    public static ResultSet query(String sql, Object[] parm) throws SQLException {
        preparedStatement = con.prepareStatement(sql);
        for (int i = 0; i < parm.length; i++) {
            preparedStatement.setObject(i+1,parm[i]);
        }
        res = preparedStatement.executeQuery();
        return res;
    }

    //update公共类
    public static int update(String sql, Object[] parm) throws SQLException {
        preparedStatement = con.prepareStatement(sql);
        for (int i = 0; i < parm.length; i++) {
            preparedStatement.setObject(i+1,parm[i]);
        }
        return preparedStatement.executeUpdate();
    }

}

导入各种静态资源

posted @ 2020-06-03 18:53 IzuruKamuku 阅读(98) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Cynicism-m

JavaWeb

JavaWeb

文章目录

1.基本概念

1.1前言

1.2 动态web

2.web服务器

ASP：

PHP：

JSP/Servlet

web服务器

IIS

Tomcat

3.Tomcat

3.1安装

3.2 配置

3.3 网站怎么发布

4.HTTP

4.1 什么是HTTP

4.2 历史

4.3 Http请求

请求行

消息头

4.4 Http响应

响应体

响应状态码

5.Maven

5.1 Maven项目架构管理工具

5.2 建立本地仓库

5.3 阿里云镜像

5.4 配置环境变量

5.5 在IDEA中使用Maven

1.创建一个Maven项目

2.命名和存放地址

3.创建一个空的Maven项目

4.配置Tomcat

5.target文件夹

6.porm文件

6.Servlet

6.1 简介

Servlet UML关系图

Servlet在JavaWeb中扮演的角色

Servlet在容器中的生命周期

6.2 HelloServlet

6.3 Servlet重定向与转发

登陆页面

转发

7.Cookie和Session

7.1 会话

7.2 保存会话的两种技术

1.cookie

2.session

8.JSP

8.1 什么是JSP

8.2 JSP原理

8.3 九大内置对象与四大作用域

四大作用域

9.JavaBean

10.三层架构MVC

11.Filter(过滤器)

12.JDBC

导入架包

连接模板

事务

13.如何搭建一个maven web项目

公告