Introducción a Java Web

inserte la descripción de la imagen aquí

Debes concentrarte en aprender cuando marques

Tomcat + HTTP + Servlet
Solicitud + Respuesta
JSP
Cookie + Sesión
Filtro + Oyente
Caso integral

Prueba de jugo

@test
class addtest(){
    
    
    
}
用断言判定结果是否正确
    Assert.assertEquals(期望的结果,程序运算的结果)不一样就会抛出黄色警告
@Before
被Before修饰的方法会在test方法执行前被自动执行
@After
被After修饰的方法会在测试方法执行后自动执行,用于释放资源

reflexión

El alma del diseño de cuadros

anotación

La esencia es una interfaz, que hereda la interfaz de Anotación por defecto

Formato de anotación personalizado: nombre de anotación @interfaz pública { }

Atributo: Método abstracto en interfaz
Requisitos:

El tipo de valor de retorno del atributo tiene los siguientes valores
1. tipo de datos básicos
2. Cadena
3. enumerar
4. anotación
5. una matriz de los tipos de datos anteriores
El atributo está definido y se le debe asignar un valor al usarlo.
1. Si usa la palabra clave predeterminada para dar el valor de inicialización predeterminado al definir una propiedad, no puede asignar un valor a la propiedad al usar anotaciones
2. Si solo se necesita asignar un atributo y el nombre del atributo es valor, el valor se puede omitir y el valor se puede definir directamente
3. Al asignar una matriz, el valor se envuelve con {}, si la matriz tiene solo un valor, se omite {}

1. JDBC

JDBC es un conjunto de API que utilizan el lenguaje Java para operar bases de datos relacionales

1. Introducción

Un conjunto de API para operar bases de datos relacionales en lenguaje java Conectividad completa de base de datos java Conexión de datos Java

El mismo conjunto de código opera diferentes bases de datos relacionales, JDBC es un conjunto de interfaces estándar para conectar varias bases de datos.

inserte la descripción de la imagen aquí

2. Inicio rápido

Agregue el paquete jar al proyecto de idea: https://blog.csdn.net/weixin_44031029/article/details/109284132

Primero agregue el paquete del controlador jar al archivo del proyecto actual y luego cámbielo a un módulo parcial

// 8.0版本后的jar驱动文件,mysql5之后这行代码可以不写
Class.forName("com.mysql.cj.jdbc.Driver");
//之前
Class.forName("com.mysql.jdbc.Driver");

/*---------------------------JDBC操作数据库步骤-----------------------*/ 
package com.mypro.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

/*
JDBC快速入门
 */
public class JDBCDemo {
    
    
    public static void main(String[] args) throws Exception {
    
    
        //1. 注册驱动  jar包版本用的是Class.forName("com.mysql.jdbc.Driver");,8.0版本之后的要用下面这个
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获取连接
        String url = "jdbc:mysql://localhost:3306/heima";
        String username = "root";
        String password = "123456";
        //定义mysql路径,用户名和密码,方便登录
        Connection conn = DriverManager.getConnection(url, username, password);

        //3.定义SQL
        String sql = "update account set money = 2000 where id = 1";

        //4.获取执行sql的对象statement
        Statement stmt = conn.createStatement();

        //5.执行sql的对象statement
        int count = stmt.executeUpdate(sql);

        //6.处理结果
        System.out.println(count);

        //7.释放资源
        stmt.close();
        conn.close();
    }
}

3. Explicación detallada de la API

1.Administrador de controladores

registrar conductor
Obtener conexión a la base de datos

En el castaño de arriba, hay tres parámetros al obtener la ruta, url (ruta de conexión), usuario (nombre de usuario), contraseña (contraseña). Aquí hay una explicación de url

// url 连接路径
/* 
语法: jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2...
示例: jdbc:mysql://localhost:3306/heima  ip地址可以用localhost替代
细节:
1.如果连接的是本机的mysql服务器,并且mysql服务默认端口是3306,则url可以简写为: jdbc:mysql:///数据库名称?参数键值对
2.配置useSSL=false参数,禁止安全连接方式,解决警告提示
*/
//localhost代替ip地址
String url = "jdbc:mysql://localhost:3306/heima";
//本地mysql简写
String url = "jdbc:mysql:///heima";
//加上键值对
String url = "jdbc:mysql:///heima?useSSL=false";

2. Conexión

Objeto de conexión de base de datos, función:

Obtener el objeto que ejecuta SQL
asuntos de gestión

// 普通执行SQL对象 !!
Statement createStatement()
//预编译SQL的执行SQL对象,防止SQL注入 !!
preparedStatement prepareStatement(sql)
//执行存储过程的对象
CallableStatement prepareCall(sql)
    
    
// 事务管理
//Mysql事务管理   默认自动提交
开启事务:begin/start transaction
提交事务:commit
回滚事务:rollback
//JDBC事务管理:Connection接口中定义了三个对应方法
//开启事务
setAutoCommit(boolean autoCommit): true为自动提交事务,false手动
//提交事务
commit()
//回滚事务
rollback()
    
/*-------------------------------处理事务案例----------------------------------*/
package com.mypro.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCDemo3_Connection {
    
    
    public static void main(String[] args) throws Exception {
    
    
        //1. 注册驱动  jar包版本用的是Class.forName("com.mysql.jdbc.Driver");,8.0版本之后的要用下面这个
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获取连接
        String url = "jdbc:mysql://localhost:3306/heima";
        String username = "root";
        String password = "123456";
        //定义mysql路径,用户名和密码,方便登录
        Connection conn = DriverManager.getConnection(url, username, password);

        //3.定义SQL
        String sql1 = "update account set money = 4000 where id = 1";
        String sql2 = "update account set money = 2000 where id = 2";

        //4.获取执行sql的对象statement
        Statement stmt = conn.createStatement();
//------------------------- 事务管理----------------------------------
        try {
    
    
            //开启事务
            conn.setAutoCommit(false);
            //5.执行sql的对象statement
            int count1 = stmt.executeUpdate(sql1);
            int count2 = stmt.executeUpdate(sql2);

            //6.处理结果
            System.out.println(count1);
            System.out.println(count2);

            //提交事务
            conn.commit();
        } catch (Exception e) {
    
    
            conn.rollback();
            throw new RuntimeException(e);
        }

        //7.释放资源
        stmt.close();
        conn.close();
    }
}

3. Declaración

efecto:Se utiliza para ejecutar sentencias sql

//执行SQL语句
int executeUpdate(sql):执行DML、DDL语句
    //返回值：1.DML语句影响的行数 2.DDL语句执行后，执行成功也可能返回0
ResultSet executeQuery（sql）执行DQL语句
    返回值 ： ResultSet结果集对象

4.ResultSet (objeto de conjunto de resultados)

Función: 1. Encapsula los resultados de las declaraciones de consulta DQL

ResultSet stmt.executeQuery(sql):执行SQL语句,返回ResultSet对象


//获取查询结果
Boolean next:(1)将光标从当前位置向前移动一行 (2)判断当前行是否为有效行
    返回值:
true 有效行,当前行有数据    false 无效行,当前行没数据

xxx getXxx(参数):获取数据
    xxx:数据类型;如int getInt(参数) String getString(参数)
参数:
int 列的编号,从1开始   String列的名称

Pasos para el uso:

Mueva el cursor hacia abajo una línea y juzgue si hay datos en la nueva línea: siguiente()
Obtener datos: getXxx (parámetro)

inserte la descripción de la imagen aquí

//循环判断游标是否是最后一行末尾
while(rs.next()){
    
    
//获取数据
 rs.getXxx(参数);
}
//----------------------------------------案例--------------------------------
 /**
     * 执行DQL,查询account账户表数据,封装为Account对象中,并且存储到ArrayList集合中
     * 1.定义实体类Account
     * 2.查询数据,封装到Account对象中
     * 3.将Account对象存入到ArrayList集合中
     *
     *
     * @throws Exception
     */

        @Test
        public void testResultSet2() throws Exception {
    
    
            Class.forName("com.mysql.cj.jdbc.Driver");
            //2.获取连接
            String url = "jdbc:mysql://localhost:3306/heima";
            String username = "root";
            String password = "123456";
            //定义mysql路径,用户名和密码,方便登录
            Connection conn = DriverManager.getConnection(url, username, password);

            //3.定义SQL
            String sql = "select * from account";

            //4.获取statement对象
            Statement stmt = conn.createStatement();

            //5.执行sql
            ResultSet rs = stmt.executeQuery(sql);


            //创建一个集合
            List<Account> list = new ArrayList<>();
            //6.处理结果,遍历rs中的所有数据
            //6.1光标向下一行并且判断是否有数据
            //因为get中有方法的重载,所以可以直接写字段名
            while (rs.next()) {
    
    
                //每循环一遍创建一个对象,将下面的数据放入对象中,然后存入集合
                Account account = new Account();

                //6.2获取数据 getXxx
                int id = rs.getInt("id");
                String name = rs.getString("name");
                double money = rs.getDouble("money");

                //给对象赋值
                account.setId(id);
                account.setName(name);
                account.setMoney(money);

                //将对象存入集合
                list.add(account);
            }

            System.out.println(list);
            //7.释放资源
            rs.close();
            stmt.close();
            conn.close();
        }
}

5. PreparedStatement (el objeto que ejecuta la declaración SQL)

Heredado de declaración, función:

Precompile y ejecute sentencias SQL: evite problemas de inyección de SQL

Inyección SQL: modifique la declaración SQL predefinida manipulando la entrada para lograr el método de ejecución de código para atacar el servidor

//1.获取preparedStatement对象
//SQL语句中的参数值,使用?占位符替代
String sql = "select * from user where username = ? and password = ?";

//通过Connection对象获取,并传入对应的sql语句
PreparedStatement pst = conn.prepareStatement(sql);
//2.设置参数值
PreparedStatement 对象:setXxx(参数1,参数2):给?赋值
    Xxx:数据类型;如setInt(参数1,参数2)
    参数:
		参数1:?的位置编号,从1开始
        参数2:?/的值
//3.执行SQL
executeUpdate(); / executeQuery()  不需要在传递sql

inserte la descripción de la imagen aquí

4. Grupo de conexiones de base de datos

1. Introducción

El grupo de conexiones de la base de datos es un contenedor responsable de asignar y administrar las conexiones de la base de datos.
Permite que una aplicación reutilice una conexión de base de datos existente en lugar de restablecer una nueva
Libere la conexión de la base de datos cuyo espacio de tiempo exceda el tiempo de inactividad máximo para evitar la omisión de la conexión de la base de datos causada por no liberar la conexión de la base de datos 2

beneficio:

reutilización de recursos
Mejorar la velocidad de respuesta del sistema
Evite las conexiones perdidas de la base de datos

Interfaz estándar: fuente de datos

La interfaz estándar del grupo de conexión de base de datos oficial, que es implementada por organizaciones de terceros
Función: obtener conexión Conexión getConnection()

Grupos de conexiones de bases de datos comunes: DBCP, C3P0, Druid

Druid: es un proyecto de grupo de conexión de base de datos de código abierto de Alibaba. Tiene funciones potentes y un rendimiento excelente. Es uno de los mejores grupos de conexión de base de datos en lenguaje java.

2. Pasos de uso de Driud

Importar el paquete jar druid-1.1.12jar
Definir archivos de configuración
cargar archivo de configuración
Obtener el objeto del grupo de conexiones de la base de datos
obtener conexión

Configurar archivo driud

Descargue el paquete driud.jar: https://blog.csdn.net/YyjYsj/article/details/108854572
Coloque el paquete jar en el mismo archivo que su propio proyecto
1. Debido a que desea colocar varios paquetes jar, puede crear una carpeta para los paquetes
2. $[Falló la transferencia de la imagen del enlace externo, el sitio de origen puede tener un mecanismo anti-leeching, se recomienda guardar la imagen y subirla directamente (img-a8tNq7oD-1663729783236)(D:\Typora\image-20220713210118129.png)]$

Cargue el archivo de configuración: escriba un archivo druid.properties en el directorio src

1. inserte la descripción de la imagen aquí

#配置文件中的内容
driverClassName=com.mysql.cj.jdbc.Driver #自己SQL文件的注册驱动
# mysql的连接,根据自己本机来设置
url=jdbc:mysql:///heima?useSSL=false&useServerPrepStmts=true 
username=root
password=123456
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
#最大等待时间
maxWait=3000

Implementación de código en la clase Java

package com.mypro.druid;

import com.alibaba.druid.pool.DataSourceClosedException;
import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.util.Properties;

/**
 * Druid数据库连接池演示
 */
public class DruidDemo {
        
        
    public static void main(String[] args) throws Exception {
        
        
        // 1.导入jar包
        //2.定义配置文件
        //3.加载配置文件
        Properties prop = new Properties();
        //本地的druid.properties文件目录
        prop.load(new FileInputStream("D:/idea-2022/mypro/MyWeb_test/src/druid.properties"));
        //4.获取连接池对象
 DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        //5.获取数据库连接 Connection
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        System.out.println(System.getProperty("user.dir"));
    }
}

5. Realice el caso de agregar, eliminar, modificar y verificar datos de marca

1. Preparación de la base de datos MySQL

# 创建品牌信息table
create table tb_brand
(
    id           int primary key auto_increment,
    brand_name   varchar(20),
    company_name varchar(20),
    ordered      int,
    description  varchar(100),
    status       int
);
insert into tb_brand
values (null, '三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
       (null, '华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人,每个家庭,每个组织,构建万物互联的智能世界', 1),
       (null, '小米', '小米科技有限公司', 50, 'are you ok', 1);

2. Creación de clase de marca en idea

package com.mypro.pojo;

/**
 * 品牌信息
 * <p>
 * 实体类中,基本数据类型建议使用其对应的包装类型
 */
public class Brand {
    
    
    //主键
    private Integer id;
    //品牌名称
    private String brandName;
    //企业名称
    private String companyName;
    //排序字段
    private Integer ordered;
    //描述信息
    private String description;
    //状态 0禁用 1启用  用Integer而不用int是因为int有默认值0,可能对业务产生影响,Integer默认值是null
    private Integer status;

    public Integer getId() {
    
    
        return id;
    }

    public void setId(Integer id) {
    
    
        this.id = id;
    }

    public String getBrandName() {
    
    
        return brandName;
    }

    public void setBrandName(String brandName) {
    
    
        this.brandName = brandName;
    }

    public String getCompanyName() {
    
    
        return companyName;
    }

    public void setCompanyName(String companyName) {
    
    
        this.companyName = companyName;
    }

    public Integer getOrdered() {
    
    
        return ordered;
    }

    public void setOrdered(Integer ordered) {
    
    
        this.ordered = ordered;
    }

    public String getDescription() {
    
    
        return description;
    }

    public void setDescription(String description) {
    
    
        this.description = description;
    }

    public Integer getStatus() {
    
    
        return status;
    }

    public void setStatus(Integer status) {
    
    
        this.status = status;
    }

    @Override
    public String toString() {
    
    
        return "Brand{" +
                "id=" + id +
                ", brandName='" + brandName + '\'' +
                ", companyName='" + companyName + '\'' +
                ", ordered=" + ordered +
                ", description='" + description + '\'' +
                ", status=" + status +
                '}';
    }
}

3. Consulta todos los datos

obtener conexión
Defina SQL: seleccione * de tb_brand;
Obtener el objeto PreparedStatement
Configuración de parámetros: no es necesario
Ejecutar SQL
Resultados del procesamiento: coloque cada objeto en la Lista de colección
liberar recursos

/**
     * 查询所有
     * 1. SQL: select * from tb_brand;
     * 2. 是否需要参数,这里不需要
     * 3. 结果存入 : brands<list>
     *
     * @throws Exception
     */
    @Test
    public void testSelectAll() throws Exception {
    
    
        //注册驱动连接java和MySql
        Class.forName("com.mysql.cj.jdbc.Driver");

        String url = "jdbc:mysql:///heima";
        String username = "root";
        String password = "123456";
        //1.获取Connecion
        Connection conn = DriverManager.getConnection(url, username, password);
        //2.定义sql查找语句
        String sql = "select * from tb_brand;";
        //3.获取执行sql对象的statement对象
        PreparedStatement preparedStatement = conn.prepareStatement(sql);
        //4.执行sql
        ResultSet rs = preparedStatement.executeQuery();
        //创建一个集合存储对象
        List<Brand> brands = new ArrayList<>();
        Brand brand = null;
        //游标判断,是否找到数据,一个一个检索
        while (rs.next()) {
    
    

            brand = new Brand();

            //获取数据
            int id = rs.getInt("id");
            String brandName = rs.getString("brand_name");
            String comName = rs.getString("company_name");
            int order = rs.getInt("ordered");
            String description = rs.getString("description");
            int status = rs.getInt("status");

            brand.setId(id);
            brand.setBrandName(brandName);
            brand.setCompanyName(comName);
            brand.setOrdered(order);
            brand.setDescription(description);
            brand.setStatus(status);
            //装载集合
            brands.add(brand);
        }
        System.out.println(brands);
        //资源释放
        rs.close();
        preparedStatement.close();
        conn.close();
    }

4. Agregar datos

/**
     * 添加
     * 1. SQL: insert into tb_brand(brand_name,company_name,ordered,description,status)
     * values(?,?,?,?,?); 问号个数与表中参数个数一样
     * 2. 是否需要参数,需要,除了id的所有参数  id由数据库自动生成,设置auto_increment;
     * 3. 结果 : boolean
     *
     * @throws Exception
     */
    @Test
    public void testAdd() throws Exception {
    
    
        //接受页面提交的参数
        String brandName = "香飘飘";
        String companyName = "香飘飘";
        int ordered = 1;
        String description = "绕地球一圈";
        int status = 1;

        //注册驱动连接java和MySql
        Class.forName("com.mysql.cj.jdbc.Driver");

        String url = "jdbc:mysql:///heima";
        String username = "root";
        String password = "123456";
        //1.获取Connecion
        Connection conn = DriverManager.getConnection(url, username, password);
        //2.定义sql查找语句
        String sql = "insert into tb_brand(brand_name,company_name,ordered,description,status)values(?,?,?,?,?);";
        //3.获取执行sql对象的statement对象
        PreparedStatement preparedStatement = conn.prepareStatement(sql);

        //4.设置参数
        preparedStatement.setString(1, brandName);
        preparedStatement.setString(2, companyName);
        preparedStatement.setInt(3, ordered);
        preparedStatement.setString(4, description);
        preparedStatement.setInt(5, status);
        //5.执行sql executeUpdate方法返回的是受影响的行数
        int count = preparedStatement.executeUpdate();
        //6.处理结果
        if (count > 0) {
    
    
            System.out.println("处理成功");
        } else {
    
    
            System.out.println("处理失败");
        }
        //7.资源释放
        preparedStatement.close();
        conn.close();
    }

5. Modificar datos

/**
     * 修改
     * 1. SQL:
       update tb_brand
        set brand_name = ?,
        company_name = ?,
        ordered = ?,
        description = ?,
        status = ?
       where id = ?
     * <p>
     * <p>
     * 2. 是否需要参数,需要,除了id的所有参数  id由数据库自动生成,设置auto_increment;
     * 3. 结果 : boolean
     *
     * @throws Exception
     */
    @Test
    public void testUpdate() throws Exception {
    
    
        //修改页面提交的参数
        String brandName = "香飘飘";
        String companyName = "香飘飘";
        int ordered = 1000;
        String description = "绕地球3圈";
        int status = 1;
        int id = 4;

        //注册驱动连接java和MySql
        Class.forName("com.mysql.cj.jdbc.Driver");

        String url = "jdbc:mysql:///heima";
        String username = "root";
        String password = "123456";
        //1.获取Connecion
        Connection conn = DriverManager.getConnection(url, username, password);
        //2.定义sql查找语句
        String sql = "update tb_brand\n" +
                "            set brand_name = ?,\n" +
                "            company_name = ?,\n" +
                "            ordered = ?,\n" +
                "            description = ?,\n" +
                "            status = ?\n" +
                "     where id = ?";
        //3.获取执行sql对象的statement对象
        PreparedStatement preparedStatement = conn.prepareStatement(sql);
        //4.设置参数
        preparedStatement.setString(1, brandName);
        preparedStatement.setString(2, companyName);
        preparedStatement.setInt(3, ordered);
        preparedStatement.setString(4, description);
        preparedStatement.setInt(5, status);
        preparedStatement.setInt(6, id);
        //5.执行sql executeUpdate方法返回的是受影响的行数
        int count = preparedStatement.executeUpdate();
        //6.处理结果
        System.out.println(count > 0);
        //7.资源释放
        preparedStatement.close();
        conn.close();
    }

6. Operación de eliminación

 /**
     * 删除操作
     * 1. SQL: delete from tb_brand where id = ?;
     * 2. 是否需要参数,需要,id的参数
     * 3. 结果 : boolean
     *
     * @throws Exception
     */
    @Test
    public void testDeleteById() throws Exception {
    
    
        //修改页面提交的参数
        int id = 4;
        //注册驱动连接java和MySql
        Class.forName("com.mysql.cj.jdbc.Driver");
        String url = "jdbc:mysql:///heima";
        String username = "root";
        String password = "123456";
        //1.获取Connecion
        Connection conn = DriverManager.getConnection(url, username, password);
        //2.定义sql语句
        String sql ="delete from tb_brand where id = ?";
        //3.获取执行sql对象的statement对象
        PreparedStatement preparedStatement = conn.prepareStatement(sql);
        //4.设置参数
        preparedStatement.setInt(1, id);
        //5.执行sql executeUpdate方法返回的是受影响的行数
        int count = preparedStatement.executeUpdate();
        //6.处理结果
        System.out.println(count > 0);
        //7.资源释放
        preparedStatement.close();
        conn.close();

    }

2. Experto

1. Introducción a Maven

Maven es una herramienta especialmente utilizada para gestionar y construir proyectos Java, sus principales funciones son
- Proporciona una estructura de proyecto estandarizada.
- Proporciona un proceso de compilación estandarizado (compilar, probar, empaquetar, liberar)
- Proporciona un conjunto de mecanismos de gestión de dependencias.

inserte la descripción de la imagen aquí

Maven es una herramienta de gestión y construcción de proyectos basada en el concepto del modelo de objeto del proyecto (POM), que gestiona la construcción, la presentación de informes y la documentación del proyecto a través de una pequeña pieza de información de descripción.

efecto:

Estructura de proyecto estandarizada
Proceso de construcción estandarizado
Cómoda gestión de dependencias

inserte la descripción de la imagen aquí

2. Configuración de instalación de Maven

https://blog.csdn.net/qq_38190185/article/details/115921070

3. Uso básico de Maven

Comandos comunes

compilar compilar
limpiar
prueba prueba
paquete de embalaje
instalar instalar

4. Experto en implementación de IDEA

Configuración de IDEAMaven: https://blog.csdn.net/hgnuxc_1993/article/details/125427590

1. Coordenadas expertas

Cuales son las coordenadas:
- Las coordenadas en Maven son identificadores únicos para recursos
- Use coordenadas para definir el proyecto o introduzca las dependencias necesarias en el proyecto
Los componentes principales de las coordenadas Maven
- groupId: define el nombre de la organización a la que pertenece el proyecto Maven actual (generalmente nombre de dominio invertido, como com.heima)
- artefactoId define el nombre del proyecto Maven actual (generalmente el nombre del módulo, como pedido-servicio, bienes-servicio)
- versión: define el número de versión actual del proyecto

2. IDEA crea un proyecto Maven

Cree un módulo y seleccione un nuevo proyecto (proyecto java predeterminado idea2022)
Seleccione el siguiente sistema Maven de compilación, finalice la creación.
Puede configurar la identificación de la empresa en la configuración avanzada
Después de que la creación sea exitosa, el proyecto Java se puede escribir

3. Importar proyecto Maven externo

inserte la descripción de la imagen aquí

5. Gestión de la dependencia

Pasos importa el paquete jar usando las coordenadas

Escribir etiquetas en pom.xml
Usar coordenadas de importación en etiquetas
Defina el ID de grupo, ID de artefacto, varsion de las coordenadas
Haga clic en el botón Actualizar para que las coordenadas surtan efecto.

1. Ámbito de dependencia

XML

Concepto: lenguaje de marcado extensible, las etiquetas son personalizadas

1. Función

Almacenamiento de datos
1. archivo de configuración
2. transmisión en la red

La diferencia entre xml y html

las etiquetas xml son personalizadas, las etiquetas html están predefinidas
La sintaxis de xml es estricta, mientras que la sintaxis de html es flexible.
xml es para almacenar datos, html es para mostrar datos

2. Gramática

gramática básica

El nombre del sufijo del documento xml.xml
La primera línea de xml debe definirse como una declaración de documento
Hay una y solo una etiqueta raíz en el documento xml
Los valores de los atributos deben ir entre comillas (simples o dobles)
Las pestañas deben estar bien cerradas
los nombres de las etiquetas xml distinguen entre mayúsculas y minúsculas

inserte la descripción de la imagen aquí

Restricciones: estipular las reglas de escritura de los documentos xml
Como usuarios del marco (programadores):
1. Pueden introducir documentos de restricciones en xml
2. Pueden leer y comprender fácilmente los documentos de restricciones

Manipular documentos xml

Análisis (lectura): leer los datos del documento en la memoria
Escribir: guarda los datos en la memoria en el documento xml.Almacenamiento persistente

La forma de analizar xml:

DOM: cargue el documento de lenguaje de marcado en la memoria a la vez y forme un cliente de árbol dom en la memoria
1. Ventajas: fácil de operar, puede agregar, eliminar, modificar y verificar documentos
2. Desventajas: ocupan memoria
SAX: lectura línea por línea, terminal móvil controlado por eventos
1. Pros: no ocupa memoria
2. Desventajas: solo puede leer, no puede agregar, eliminar, modificar

Maven crea un proyecto web

1. Usa el esqueleto – Maven Archetype para crear –> encuentra esto

inserte la descripción de la imagen aquí

Elimine el contenido redundante en pom.xml, dejando solo:

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

<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>org.example</groupId>
  <artifactId>Tomcat-demo1</artifactId>
  <version>1.0-SNAPSHOT</version>
<!--  打包方式 打成war包-->
  <packaging>war</packaging>

</project>

Crear proyecto de java y recursos en el archivo principal

2. No usa el esqueleto

Cree un proyecto Maven directamente y configure el método de empaquetado para pom.xml como war–>war
Haga clic en Archivo -> Estructura del proyecto
Buscar faceta–>configurar proyecto web
Después de generar el proyecto web, recuerde arrastrarlo al directorio principal bajo src

Maven integra Tomcat local

1. Importación manual

Agregar configuración normalmente

2. Importación del complemento Maven

Configurar el complemento en pom.xml

<build>
        <plugins>
            <!--            tomcat插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
            </plugin>
        </plugins>
    </build>

inserte la descripción de la imagen aquí

Web

1. Revisión de contenido relacionado con la web

Arquitectura de software
1. C/S: cliente/servidor
2. B/S: navegador/servidor
Clasificación de recursos
1. Recursos estáticos: después de que todos los usuarios visiten, los resultados son los mismos, llamados recursos estáticos, los recursos estáticos pueden ser analizados directamente por navegadores como html, css, js
2. Recursos dinámicos: después de que cada usuario visite el mismo recurso, el resultado puede ser diferente, lo que se denomina recurso dinámico. Después de acceder al recurso dinámico, primero debe convertirse en un recurso estático y luego devolverse al navegador. Como servlet/jsp, php, asp…
Tres elementos de la comunicación en red
1. IP: la identificación única de los equipos electrónicos en la red
2. Puerto: la identificación única de la aplicación en la computadora 0~65536
3. Protocolo de transmisión: especifica las reglas para la transmisión de datos
  1. acuerdo básico
    1. protocolo de seguridad tcp, apretón de manos de tres vías. La velocidad es ligeramente más lenta
    2. protocolo inseguro udp rápido

2. Instalación y configuración de Tomcat

Apache Foundation, un servidor javaEE de tamaño pequeño y mediano, solo admite una pequeña cantidad de código abierto servlet/jsp estándar JavaEE, gratuito

Descarga del sitio web oficial: https://tomcat.apache.org/
Descomprima el paquete comprimido en un directorio personalizado (no aparecen chinos ni espacios en el archivo del directorio)
Abra el directorio bin descomprimido, haga clic en startup.bat para comenzar
1. Si flashback: problema de configuración del entorno Java
2. Caracteres confusos: abra el archivo logging.properties en D:\Tomcat\apache-tomcat-10.0.22\conf y reemplace java.util.logging.ConsoleHandler.encoding = UTF-8 con java.util.logging.ConsoleHandler.encoding = GBK
Ingrese en la URL del navegador: http://127.0.0.1:8080, si aparece un gato, significa que Tomcat está instalado y configurado correctamente
Ingrese en la ventana negra: ipconfig para ver su dirección IP actual
Error de inicio de Tomcat
1. Cuando es posible iniciar el puerto 8080 está ocupado, la solución
  1. Violencia, encuentre el programa que ocupa el puerto y ciérrelo directamente. Ingrese netstat -ano para encontrar el número de puerto actualmente ocupado y finalice el proceso directamente en el administrador de tareas.
  2. Sea amable, cambie un puerto de arranque al reiniciar:
Apagado de Tomcat:
1. Apagado normal: ctrl+c
2. Forzar cierre, haga clic en la x
configuración
1. Cómo implementar el proyecto
  1. Coloque directamente el proyecto en la interfaz del directorio de aplicaciones web.
    1. Implementación simplificada: marque el proyecto en un paquete de guerra, luego coloque el paquete de guerra en el directorio de aplicaciones web y descomprímalo automáticamente

servlet

1. La interfaz Servlet no se puede crear en la idea

El paquete Servlet no está construido originalmente en Java y debe importarse desde Tomcat. En circunstancias normales, no habrá ningún paquete Servlet. A menos que la configuración del archivo de ruta no se actualice cuando se cambie la versión de Tomcat, no se puede usar. Haga clic en Ejecutar -> Editar configuración -> Configuración, desplegar y encontrar la biblioteca

inserte la descripción de la imagen aquí

Si hay estos dos archivos en él, significa que la interfaz Servlet se puede usar normalmente

Concepto: un pequeño programa que se ejecuta en el lado del servidor

inserte la descripción de la imagen aquí

Servlet es una interfaz que define las reglas para que los navegadores accedan a las clases Java (reconocimiento Tomcat).
En el futuro, personalizaremos una clase para implementar la interfaz Servlet y anular los métodos.

2. Inicio rápido

Crear un proyecto javaEE
Defina una clase que implemente la interfaz Servlet
1. ```
public class ServletDemo1 implements Servlet
```
Implementar el método abstracto en la interfaz.

Configuración de servlets

Servlet3.0版本之前:
<!--配置Servlet  -->
    <servlet>
        <servlet-name>demo1</servlet-name>
        //文件的路径名
        <servlet-class>mypro.ServletDeom1</servlet-class>
    </servlet>
<!--    设置映射-->
    <servlet-mapping>
        <servlet-name>demo1</servlet-name>
        <url-pattern>/demo1</url-pattern>
    </servlet-mapping>
Servlet3.0版本之后-----利用注解进行配置
创建时不用勾选creat web.xml选项,在实现Servlet的类中添加@WebServlet("/demo");
demo----Servlet的名称,资源路径,输入这个路径后,调用接口中的service方法

Ejecute el servlet, ejecútelo de nuevo y ejecute el método de servicio una vez

Ciclo de vida del servlet:

Creado: Ejecutar el método init, solo una vez

Por defecto, cuando se accede por primera vez, pero también puedes configurar tú mismo su tiempo de ejecución

<servlet>
        <servlet-name>demo1</servlet-name>
        <servlet-class>crz.mypro.ServletDemo1</servlet-class>
        <!--指定Servlet的创建时机
            在<servlet>标签下修改
               1.第一次被访问时,创建<load-on-startup>的值为负数
               2.在服务器启动时,创建<load-on-startup>的值为0或正整数

           Servlet的init方法,只执行一次,说明一个Servlet在内存中只存在一个对象,Servlet是单例
            多个用户同时访问时,可能存在线程安全问题
            解决:尽量不要在Servlet中定义成员变量.及时定义了成员变量,也不要对修改值
        -->
        <load-on-startup>-5</load-on-startup>
    </servlet>

Proporcionar servicio: ejecutar el método de servicio, ejecutar varias veces
Destroyed: Ejecuta el método destroy, solo una vez
1. Ejecutado cuando se destruye el Servlet, cuando se cierra el servidor, se destruye el Servlet
2. El método de destrucción solo se ejecutará cuando el servidor se apague normalmente.
3. Ejecutado antes de que se destruya el Servlet para liberar recursos

3. Arquitectura de servlets

inserte la descripción de la imagen aquí

1. Objeto de solicitud

Dos parámetros en la fuerza de servicio:

public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
    
    
        System.out.println("service.....");
    }

El principio de objeto de solicitud y objeto de respuesta.
1. Los objetos de solicitud y respuesta son creados por el servidor.
2. El objeto de solicitud se usa para obtener el mensaje de solicitud, y el objeto de respuesta se usa para establecer el mensaje correspondiente
solicitud de arquitectura de herencia de objetos
1. ServletRequest -- interfaz
2. HttpServletRequest -- interfaz
función de solicitud
1. obtener mensaje de solicitud
  1. Obtener datos de línea de solicitud
    1. GET/directorio virtual/ruta del Servlet/nombre=zhang;
      1. Obtenga el método de solicitud: GET String getMethod();
      2. (*) Obtener el directorio virtual: String getContextPath();
      3. Obtenga la ruta del Servlet: String getServletPath();
      4. Obtener parámetros de solicitud de método: String getQueryString();
      5. (*) Obtener URI de solicitud:/directorio virtual/ruta de Servlet Sting getRequestURI();StringBuffer getRequestURL();
        
        URL: Localizador Uniforme de Recursos: http://localhost:8080/Mytom/demo1 República Popular China
        
        Identificador uniforme de recursos URI: /Mytom/demo1 Republic
      6. Obtenga el número de versión: Sting getProtocol()
      7. Obtenga la dirección IP del cliente: String getRemoteAddr();
  2. Obtener datos de encabezado de solicitud
    1. (*)String getHeader(String name): Obtenga el valor del encabezado de la solicitud a través del nombre del encabezado de la solicitud
    2. Enumeración getHeaderNames(): Obtener los nombres de todos los encabezados de solicitud
  3. Obtener datos del cuerpo de la solicitud

package crz.mypro;

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/demo1")
public class RequestDemo1 extends HttpServlet {
    
    
    /**
     * Request获取请求行数据
     */
    //1.获取请求方式:GET

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
    
        //1.获取请求方式
        String method = req.getMethod();
        System.out.println(method);
        //2.获取虚拟目录
        String contextPath = req.getContextPath();
        System.out.println(contextPath);
        //3.获取Servlet路径
        String servletPath = req.getServletPath();
        System.out.println(servletPath);
        //4.获取get方式请求参数
        String queryString = req.getQueryString();
        System.out.println(queryString);
        //5.获取请求URI
        String requestURI = req.getRequestURI();
        StringBuffer requestURL = req.getRequestURL();
        System.out.println(requestURI);
        System.out.println(requestURL);
        //6.获取协议及版本
        String protocol = req.getProtocol();
        System.out.println(protocol);
        //7.获取客户机ip地址
        String remoteAddr = req.getRemoteAddr();
        System.out.println(remoteAddr);
    }
}

inserte la descripción de la imagen aquí

solicitudOtras características

1. Formas de obtener parámetros de solicitud

inserte la descripción de la imagen aquí

package crz.mypro;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;
// -----------------------获取请求头数据--------------------------------
@WebServlet("/demo2")
public class RequestDemo2 extends HttpServlet {
    
    

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
    
        //1.获取所有请求头的值
        Enumeration<String> headerNames = req.getHeaderNames();
        while (headerNames.hasMoreElements()) {
    
    
            String name = headerNames.nextElement();
            String value = req.getHeader(name);
            System.out.println(name + "---" + value);
        }
    }
}

inserte la descripción de la imagen aquí

  protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
    
        //post获取请求参数

        //1.根据参数获取参数值(用于input表单)
           String username = req.getParameter("username");
           System.out.println("post");
      //post方式获取中文参数乱码解决方式---->设置流的编码
      		req.setCharacterEncoding("utf-8")
           System.out.println(username);
      
      //2.获取参数值数组(获取表单值)
       String[] hobbies = req.getParameterValues("hobby");
        for (String hobby : hobbies) {
    
    
            System.out.println(hobby);
        }
      
       //3.获取所有请求的参数名称(获取键值对)但只能获得一个值
        Enumeration<String> parameterNames = req.getParameterNames();
        //往后迭代,如果还有数据,则返回true
        while (parameterNames.hasMoreElements()) {
    
    
            String name = parameterNames.nextElement();
            System.out.println(name);
            String value = req.getParameter(name);
            System.out.println(value);
            System.out.println("---------------------");
        }
    }
username
zhangsan
---------------------
password
123
---------------------
hobby
game
---------------------

      //4.获取所有参数的map集合
        Map<String, String[]> parameterMap = req.getParameterMap();
        //遍历
        Set<String> keySet = parameterMap.keySet();
        for (String name : keySet) {
    
    

            //获取键值
            String[] values = parameterMap.get(name);
            System.out.println(name);
            for (String value : values) {
    
    
                System.out.println(value);
            }
        }
username
zhangsan
------------
password
123
-------------
hobby
game
study

2. Solicitud de reenvío

paso:

Obtenga el objeto del reenviador de solicitudes a través del objeto de solicitud: RequestDispatcher getRequestDispatcher(String path)
Use el objeto RequestDispatcher para reenviar: reenviar (solicitud de ServletRequest, respuesta de ServletResponse)

Características:

La ruta de la barra de direcciones del navegador no cambia
Solo se puede reenviar a los recursos internos del navegador actual
el reenvío es una solicitud

3. Compartir datos

Objeto de dominio: un objeto con un alcance, que puede compartir datos dentro del alcance.dominio
de solicitud: representa el alcance de una solicitud, y generalmente se usa para compartir datos entre múltiples recursos para el reenvío de solicitudes.Método
:

void setAttribute(String name, Object obj) almacena datos
El objeto getAttribute(String name) obtiene el valor por clave
void removeAttribute(String name) elimina pares clave-valor por clave

4. Obtener ServletContext

2. Objeto de respuesta

Función: establecer el mensaje correspondiente
1. Establecer la línea correspondiente
  1. Formato: HTTP/1.1 200 bien
  2. Establecer código de estado: setStatus (int sc)
2. Establezca el encabezado de respuesta: setHeader (nombre de cadena, valor de cadena)
3. Establecer el cuerpo correspondiente
  1. obtener flujo de salida
    1. Flujo de salida de caracteres: printWriter()
    2. Flujo de salida de bytes: servletOutputStream getOutputStream()
  2. Use el flujo de salida para enviar datos al navegador del cliente
caso:
1. Redirección completa: Salto de recursos
2. Código:
  1. ```
  //设置状态码为302
  response.setStatus(302);
  //设置响应头,及告诉服务器要跳转的资源路径
  response.setHeader("跳转的文件路径");
  //简单的重定向方法
  response.sendRedirectn ("跳转的文件路径")
```
3. Funciones de redirección:
  1. cambios en la barra de direcciones
  2. La redirección puede acceder a recursos en otros sitios (servidores)
  3. El redireccionamiento son dos solicitudes. El objeto de solicitud no se puede usar para compartir datos.
4. Funciones de reenvío:
  1. La ruta de la barra de direcciones de reenvío permanece sin cambios
  2. El reenvío solo puede acceder a los recursos del servidor actual
  3. El reenvío es una solicitud, puede usar el objeto de solicitud para compartir datos
5. ruta de escritura
  1. camino relativo
    1. No comience con / y comience con . Como .index/html
    2. Regla: busque la relación de posición relativa entre el recurso actual y el recurso de destino
      1. ./:Directorio actual
      2. .../: Retrocede un directorio
  2. camino absoluto
    1. Una ruta que comience con / como http://localhost/day/sldfjk
    2. Reglas: determine para quién es la ruta definida
      1. Para navegadores de clientes: debe agregar un directorio virtual
        
        Obtenga dinámicamente el directorio virtual: request.getContextPath()
      2. Para uso del servidor: no es necesario agregar un directorio virtual
        
        ruta de reenvío
El servidor envía datos de caracteres al navegador.
1. ```
		//或者简单的设置编码----解决乱码问题
        resp.setContentType("text/html;charset=utf-8");
        //获取字符输出流
        PrintWriter pw = resp.getWriter();
        //输出数据
        pw.write("你好呀 abc");
```
2. problema distorsionado
  1. PrintWriter pw = resp.getWriter(); La codificación predeterminada del flujo obtenido es ISO-8859-1
  2. Establecer la codificación predeterminada para esta transmisión
  3. Le dice al navegador qué codificación usar para el cuerpo

El servidor envía datos de bytes al navegador.

//或者简单的设置编码----解决乱码问题
        resp.setContentType("text/html;charset=utf-8");
        //获取字符输出流
        PrintWriter pw = resp.getWriter();
		pw.write("你好".getBytes("utf-8"));//利用getBytes方法返回字节数组

código de verificación:

Objeto ServletContext

concepto:

protocolo HTTP

1. Solicitar mensaje

El Protocolo de transferencia de hipertexto
define
las características del cliente y del servidor:

Protocolo avanzado basado en TCP/IP
Número de puerto predeterminado: 80
Basado en el modelo de solicitud/respuesta: una solicitud corresponde a una respuesta
Sin estado: cada solicitud es independiente entre sí y no puede intercambiar datos

Solicitar formato de datos del mensaje

línea de solicitud
1. Método de solicitud URL de solicitud Protocolo de solicitud/versión
  GET /login.html HTTP/1.1
2. Método de solicitud: hay 7 métodos de solicitud en el protocolo HTTP, dos de los cuales se usan comúnmente
  1. OBTENER: el parámetro está en la línea de solicitud, la URL solicitada después de la URL tiene un límite de longitud y no es segura
  2. POST: la URL solicitada por los parámetros en el cuerpo de la solicitud no tiene límite de longitud y es relativamente segura
Encabezado de solicitud: el navegador del cliente le dice al servidor alguna información
1. Nombre del encabezado de la solicitud: valor del encabezado de la solicitud
  1. User-Agent: El navegador le dice al servidor que visito la información de la versión del navegador que usa
    1. Obtenga la información del encabezado en el lado del servidor para resolver problemas de compatibilidad del navegador
  2. Referencia: http://localhost/…
    1. Dígale al servidor, ¿de dónde vengo yo (la solicitud actual)?
    2. efecto:
      1. Anti-sanguijuela
      2. trabajo de encuesta de cantidad
solicitar línea en blanco (espacio)
1. El encabezado de la solicitud utilizado para dividir la solicitud POST y el cuerpo de la solicitud
cuerpo de solicitud (cuerpo)
1. Encapsula los parámetros de solicitud del mensaje de solicitud POST

formato de cadena

Host: localhost:8080
sec-ch-ua: ".Not/A)Brand";v="99", "Google Chrome";v="103", "Chromium";v="103"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36

2. Mensaje de respuesta

Formato de datos enviados desde el servidor al cliente :

Fila correspondiente
1. Composición: protocolo/versión código de estado de respuesta código de estado descripción
2. Código de estado de respuesta: el servidor le dice al navegador del cliente el estado de esta solicitud y respuesta
  1. Los códigos de estado son todos de 3 dígitos
  2. Clasificación:
    1. 1xx: el servidor ha recibido el mensaje del cliente, pero no ha completado la aceptación. Después de esperar un período de tiempo, enviará códigos de estado múltiple 1xx
    2. 2xx: El éxito representa 200
    3. 3xx: Redirección: representa 302 (redirección) 204 (caché de acceso)
    4. 4xx: error del cliente
      1. Ruta 404 no encontrada
      2. 405 No existe un método correspondiente para el método de solicitud
    5. 5xx: error del lado del servidor significa 500 Hay una excepción dentro del servidor
encabezado de respuesta
1. Tipo de contenido: el servidor le dice al cliente el formato de datos y el formato de codificación del cuerpo de respuesta
2. Disposición de contenido: el servidor le dice al cliente en qué formato abrir los datos del cuerpo de respuesta
  1. en línea: valor predeterminado, abrir en la página actual
  2. archivo adjunto: nombre de archivo = xxx: abre el cuerpo de la respuesta como un archivo adjunto.
línea en blanco correspondiente
cuerpo de respuesta
1. La página html mostrada

tecnología conversacional

Galleta
Sesión

Sesión: una sesión contiene múltiples solicitudes y respuestas
- Una sesión: el navegador envía una solicitud al recurso del servidor por primera vez y la sesión se establece hasta que una de las partes se desconecta
Función: múltiples solicitudes dentro del alcance de otra sesión, compartiendo datos
Forma:
- Tecnología de sesión de cliente: Cookie
- Tecnología de sesión de servicio: Sesión

1.Cookie

Concepto: tecnología de sesión de cliente, guardando datos para el cliente

Inicio rápido:

Crear objeto de cookie, enlazar datos
1. Cookie nueva (nombre de cadena, valor de cadena)
Enviar objeto de cookie
1. respuesta.addCookie(Cookie cookie)
Obtener la cookie y obtener el objeto
1. Cookie[] solicitud.getCookies()

Principio de implementación: basado en la implementación de cookie de encabezado de respuesta y encabezado de solicitud

Detalles de las cookies:

¿Se pueden enviar varias cookies a la vez?
1. Sí, cree múltiples objetos Cookie, use la respuesta para llamar al método addCookie varias veces para enviar cookies
¿Cuánto tiempo se guardan las cookies en el navegador?
1. De forma predeterminada, los datos de las cookies se destruyen cuando se cierra el navegador.
2. almacenamiento persistente
  1. setMaxage(int segundos)
    1. Número positivo: escribe los datos de la cookie en el archivo del disco duro Almacenamiento persistente, tiempo de supervivencia de la cookie
    2. Número negativo: valor predeterminado. Los datos se borran después de cerrar el navegador.
    3. Cero: eliminar información de cookies
¿Pueden las cookies salvar a los chinos?
1. El chino es compatible después de tomcat8, pero el chino no era compatible antes
¿Problema para compartir cookies?
1. Suponiendo que se implementen varios proyectos web en un servidor tomcat, ¿se pueden compartir las cookies entre estos proyectos web?
  1. Las cookies no se pueden compartir por defecto
  2. setPath(String path): establece el alcance de la adquisición de cookies. De forma predeterminada, establece el directorio virtual actual
    1. Si desea compartir, puede establecer la ruta en "/"
2. ¿Problema de uso compartido de cookies entre diferentes servidores tomcat?
  1. setDomain(String path): si el nombre de dominio de primer nivel se configura para que sea el mismo, las cookies se pueden compartir entre varios servidores
    1. setDomain(“.baidu.com”), luego se pueden compartir las cookies en tieba.baidu.com y news.baidu.com
Las características y funciones de las cookies
1. La cookie almacena datos en el navegador del cliente.
2. Los navegadores tienen un límite en el tamaño de una sola cookie (4kb) y un límite en el número total de cookies bajo el mismo nombre de dominio
3. efecto:
  1. Las cookies se utilizan generalmente para almacenar una pequeña cantidad de datos menos sensibles.
  2. Completar la identificación del servidor del cliente sin iniciar sesión
==Caso:==Recordar la hora de la última visita
1. necesidad:
  1. Para visitar un Servlet, si es la primera visita, solicite: Hola, bienvenido a su primera visita
  2. Si no es la primera visita, solicite: bienvenido de nuevo, la hora de su última visita es: cadena de tiempo
2. analizar
  1. Se puede implementar con cookies
  2. El Servlet en el servidor determina si hay una cookie llamada LastTime
    1. Sí: no es la primera visita
      1. Datos de respuesta: Bienvenido de nuevo, su última visita fue:…
      2. Copiar cookie:lastTime = …
    2. No: primera visita
      1. Datos de respuesta: Hola, bienvenido a visitar por primera vez
      2. escribir de nuevo cookie la última vez:…

2.Sesión

Concepto: tecnología de sesión del lado del servidor, compartir datos entre múltiples solicitudes en una sesión y guardar datos en objetos en el lado del servidor.
Inicio rápido:
1. Obtenga el objeto HttpSession
  1.HttpSession session = request.getSession();
  1. 使用HttpSession对象:
    3.Object getAttribute(String name)
    2.void setAttribute(String name,Object value)
    void removeAttribute(String name)
Principio: La implementación de la Sesión depende de la Cookie, y el objeto de la Sesión a identificar se identifica a través del encabezado de la solicitud
detalle
1. Cuando se cierra el cliente, no se cierra el servidor, ¿se obtiene el doble de sesión?
  1. no por defecto
  2. Si necesita ser igual, puede crear una cookie, la clave es Jsessionid, establecer el tiempo máximo de supervivencia y dejar que la cookie persista para guardar la cookie c
    = nueva cookie ("Jsessionid", session.getId())
    c .setMaxAge(60*60)
    resp.addCookie ©
2. No se cierra el cliente, después de cerrar el servidor, ¿se obtiene el doble de sesión?
  1. No es lo mismo, pero para asegurarse de que los datos no se pierdan. Tomcat completa automáticamente las siguientes tareas
    1. Pasivación de la sesión: antes de que el servidor se apague normalmente, el objeto de la sesión se serializa en el disco duro
    2. Activación de sesión: después de que se inicie el servidor, simplemente convierta el archivo de sesión en un objeto de sesión en la memoria
3. ¿Cuándo se destruye la sesión?
  1. servidor caido
  2. El objeto de sesión llama a invalidate();
  3. El tiempo de caducidad de sesión predeterminado es de 30 minutos,
    modificación de configuración opcional
```
<session-config>
    <session-timeout>30</session-timeout>
</session-config>
```
Las características de la sesión.
1. sesión se utiliza para almacenar los datos de múltiples solicitudes para una sesión, que existe en el lado del servidor
2. La sesión puede almacenar cualquier tipo de datos, datos de cualquier tamaño
La diferencia entre sesión y cookie.
1. La sesión almacena datos en el lado del servidor y cookies en el lado del cliente
2. No hay límite de tamaño de datos para el almacenamiento de sesiones, pero las cookies tienen
3. Los datos de la sesión están seguros, mientras que las cookies son relativamente inseguras

Caso de código de verificación

necesidad:

Acceda a la página de inicio de sesión login.jsp con captcha
El usuario ingresa el nombre de usuario, la contraseña y el código de verificación
1. Si el nombre de usuario y el código de verificación se ingresan incorrectamente, se redirigirá a la página de inicio de sesión y se le solicitará: nombre de usuario o contraseña incorrectos
2. Si el código de verificación se ingresa incorrectamente, se redirigirá a la página de inicio de sesión y se le solicitará: error de código de verificación
3. Si toda la entrada es correcta, salte a la página de inicio success.jsp, muestre: nombre de usuario, bienvenido
analizar:

JSP

Concepto: páginas del servidor java páginas del lado del servidor java
1. Se puede entender como una página especial, en la que se pueden especificar y definir tanto etiquetas html como código java.
2. Para una escritura más fácil!!!
principio:
1. Es esencialmente un Servlet: HTTPServlet está implementado en el código fuente y hay un método JSPservice
Script JSP: la forma de definir el código Java
1. <% java code%> z en el método Servicio. Lo que se puede definir en el método de servicio, el script puede definir lo que es similar a las variables locales
2. <%! El código Java definido por java code%> es similar a las variables globales en la posición de miembro de la clase Java después de la conversión JSP
3. <% = java code%> = El código java definido se enviará a la página, lo que se puede definir en la declaración de salida, lo que se puede definir en el script
Objetos integrados de JSP
1. Objetos que se pueden usar directamente sin obtener y crear en páginas jsp
2. jsp tiene un total de 9 objetos incorporados
  1. pedido
  2. respuesta
  3. out: objeto de flujo de salida de caracteres, que puede enviar datos a la página, similar a response.getWriter()
3. inserte la descripción de la imagen aquí
instrucción
1. Función: se utiliza para configurar páginas JSP e importar archivos de recursos
2. Formato: <%@ nombre de instrucción nombre de atributo 1 = valor de atributo 1 nombre de atributo 2 = nombre de atributo 2 … %>
3. Clasificación:
  1. página: configurar la página JSP
  2. include : el archivo de recursos incluido en la página Importar la página
  3. taglib: importar recursos
nota
1. <%–> Contenido del comentario <–%>

modelo de desarrollo MVC

MVC:
1. Model, model.javaBean completa operaciones comerciales específicas, como: consultar la base de datos, encapsular objetos
2. Ver, ver.JSP mostrar datos
3. Controlador, controlador.Servlet obtiene la entrada del usuario, llama al modelo y entrega los datos a la vista para su procesamiento
ventaja:
1. Acoplamiento bajo, fácil mantenimiento y propicio para la división del trabajo y la cooperación.
2. Alta reutilización
Desventajas: complica la estructura del proyecto y requiere altos requisitos para los desarrolladores

EL expresión

Concepto: Lenguaje de Expresión Lenguaje de Expresión
Rol: reemplazar y simplificar la escritura de código java en páginas jsp
Sintaxis: ${expresión}
Nota: jsp admite expresiones EL de forma predeterminada. Si quieres ignorar la expresión el
1. Establezca la directiva de página en jsp: isElignored="true" para ignorar todas las expresiones el en la página jsp actual
2. ${expression}: ignorar la expresión el actual
Uso:

Pasos para usar:
Almacene los datos que desea enviar al front-end en la sesión de solicitud (comúnmente utilizado)
Reenviar a la página principal
En la página jsp de front-end, se usa ${nombre de datos}

request.setAttribute("brands",brands);
request.getRequestDispatcher("xxx.jsp").forword(request,response);

formato de fecha

http://c.biancheng.net/view/878.html

Filtrar

Ajax

Ajax es una tecnología que puede actualizar algunas páginas web sin recargar toda la página web. Las páginas web tradicionales deben recargar toda la página web si es necesario actualizar el contenido.

inserte la descripción de la imagen aquí

efecto:

Intercambio de datos con el servidor: a través de ajax, puede enviar una solicitud al servidor y obtener los datos a los que responde el servidor
1. Usando ajax para comunicarse con el servidor, puede usar html+ajax para reemplazar la página jsp
Interacción asíncrona: tecnología que puede intercambiar datos con el servidor y actualizar algunas páginas web sin recargar toda la página

Implementación de código nativo (entender)

Implementación de código Jquery

---------------使用$.ajax()发送异步请求---------------------
<script>
function fun(){
      
      
//使用$.ajax()发送异步请求
$.ajax({
      
      
	url:"ajaxServlet", //请求路径
	type:"POST", //默认是GET
	//请求参数,键值对形式——JSON对象
	data:{
      
      "username":"jack","age":23},
	//相应成功后的回调函数
	success:function(data) {
      
      
		alert(data)
    },
    error:function(){
      
      
    	alert("出错了...")
    },
    //设置接受到的相应数据的格式
    dataType:"text"
 });
}
</script>
------------------------使用$.get发送请求----------------------
$.get(url,[data],[callback],[type])
	url:请求路径
	data;请求参数
	callback:回调函数
	type:响应结果的类型

El código nativo implementa ajax

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>欢迎注册</title>
    <link href="css/register.css" rel="stylesheet">
</head>
<body>

<div class="form-div">
    <div class="reg-content">
        <h1>欢迎注册</h1>
        <span>已有帐号？</span> <a href="login.html">登录</a>
    </div>
    <form id="reg-form" action="#" method="get">

        <table>

            <tr>
                <td>用户名</td>
                <td class="inputs">
                    <input name="username" type="text" id="username">
                    <br>
                    <span id="username_err" class="err_msg" style="display: none">用户名已存在</span>
                </td>

            </tr>

            <tr>
                <td>密码</td>
                <td class="inputs">
                    <input name="password" type="password" id="password">
                    <br>
                    <span id="password_err" class="err_msg" style="display: none">密码格式有误</span>
                </td>
            </tr>


            <tr>
                <td>验证码</td>
                <td class="inputs">
                    <input name="checkCode" type="text" id="checkCode">
                    <img src="imgs/a.jpg">
                    <a href="#" id="changeImg">看不清？</a>
                </td>
            </tr>

        </table>

        <div class="buttons">
            <input value="注 册" type="submit" id="reg_btn">
        </div>
        <br class="clear">
    </form>

</div>
-----------------------------------案例实现--------------------------------------
<script>
    //1.给用户名输入框绑定失去焦点的事件
    document.getElementById("username").onblur = function () {
      
      
        //获取用户名的值
        var username = this.value;
        //2发送ajax请求
        //21.创建ajax对象
        var xhttp;
        if (window.XMLHttpRequest) {
      
      
            xhttp = new XMLHttpRequest();
        } else {
      
      
            // code for IE6, IE5
            xhttp = new ActiveXObject("Microsoft.XMLHTTP");
        }
        //2.2发送请求  路径写全路径,便于前后端分工协作 全路径:浏览器打开ajaxServlet接口的路径
        xhttp.open("GET", "http://localhost:8080/Brand_demo/selectUserServlet?username=" + username);
        xhttp.send();

        //2.3获取响应
        xhttp.onreadystatechange = function () {
      
      
            if (this.readyState == 4 && this.status == 200) {
      
      
                // alert(this.responseText);
                //字符串判断,如果文本是true则说明用户名存在...
                if (this.responseText == "true") {
      
      
                    //用户名存在 显示提示信息  将显示信息的display属性设置一下
                    document.getElementById("username_err").style.display = 'block';
                } else {
      
      
                    //不存在  清除提示信息
                    document.getElementById("username_err").style.display = 'none';
                }
            }
        };
    }
</script>
</body>
</html>

código de fondo

package com.crz.web;

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

@WebServlet("/selectUserServlet")
public class selectUserServlet extends HttpServlet {
    
    
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
    
        System.out.println("GET...");
        //1.接收用户名
        String username = request.getParameter("username");
        //2.调用service查询user对象
        boolean flag = true;
        //3.响应样式
        response.getWriter().write("" + flag);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
    
        System.out.println("Post...");
        this.doGet(request, response);
    }
}

El framework axios implementa ajax

Inicio rápido

Importar el archivo js de axios

Use axios para enviar solicitudes y obtener resultados de respuesta

axios({
      
      
 method:"get",
 url:"http://localhost:8080/Brand_demo/selectUserServlet?username=xxxx"
}).then(function(resp){
      
      
 alert(resp.data);
})

el caso

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<script src="js/axios-0.18.0.js"></script>
<script>
    //1.get
    // axios({
      
      
    //     method:"get",
    //     url:"http://localhost:8080/Brand_demo/axiosServlet?username=123"
    // }).then(function (resp){
      
      
    //     alert(resp.data);
    // })

    //post
    axios({
      
      
        method: "post",
        url: "http://localhost:8080/Brand_demo/axiosServlet",
        data: "username=123"
    }).then(function (resp) {
      
      
        alert(resp.data);
    })
</script>
</body>
</html>

Uso de alias para simplificar aún más el código

inserte la descripción de la imagen aquí

JSON

Fastjson es una biblioteca JSON de alto rendimiento y completamente funcional escrita en lenguaje Java proporcionada por Alibaba. Actualmente es la biblioteca JSON más rápida en lenguaje Java. Puede realizar conversiones mutuas entre objetos Java y cadenas JSON.

usar:

importar coordenadas

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.13</version>
        </dependency>

objeto java a JSON

        String jsonString = JSON.toJSONString(user);

Cadena JSON a objeto Java

        User u = JSON.parseObject("{\"id\":1,\"password\":\"123\",\"username\":\"zhangsan\"}", User.class);

Mi zapato

1. Qué es Mybatis

Un excelente marco de capa de persistencia para simplificar el desarrollo de JDBC

capa de persistencia

La capa de código responsable de guardar los datos en la base de datos.
Arquitectura JavaEE de tres niveles: capa de presentación, capa empresarial, capa de persistencia

solicitud:

Consultar todos los datos en la tabla de usuario

Crear tabla de usuario y agregar datos
Crear un módulo, importar coordenadas

Escriba el archivo de configuración principal de mybatis --> reemplace la información de conexión para resolver el problema codificado

 <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--                数据库的连接信息-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>

Escriba el archivo de asignación de SQL -> gestión unificada de la declaración sql, resuelva el problema de la codificación dura

codificación

Definir la clase pojo

Cargue el archivo de configuración principal y obtenga SqlSessionFactory

 //1.加载mybatis的核心配置文件 获取SqlSessionFactory  路径就是resources中的mybatis-config.xml
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

Obtenga el objeto SqlSession y ejecute la instrucción sql

 	 //2.获取SqlSessionFactory对象,用它执行sql
     SqlSession sqlSession = sqlSessionFactory.openSession();
   	 //3.1获取UserMapper接口的代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
     List<User> users = userMapper.selectAll();
     System.out.println(users);

liberar recursos
1. ```
 sqlSession.close();
```

2.Desarrollo de agentes mapeadores

Objetivo:

Resuelva la codificación dura de forma nativa.
Simplifique el SQL posterior a la ejecución

paso:

Defina la interfaz de Mapper con el mismo nombre que el archivo de asignación de SQL y coloque la interfaz de Mapper y el archivo de asignación en el mismo directorio.
1. Cree un directorio igual que el asignador en el archivo de recursos, llamado:com/crz/mapper
Establezca el atributo de espacio de nombres del archivo de asignación de SQL en el nombre completo de la interfaz del asignador
Defina el método en la interfaz de Mapper, el nombre del método es el id de la instrucción SQL en el archivo de asignación de SQL y mantenga el tipo de parámetro y el tipo de valor de retorno consistentes
codificación
1. Obtenga el objeto proxy de la interfaz Mapper a través del método getMapper de SqlSession
2. Llame al método correspondiente para completar la ejecución de sql

Detalles: si el nombre de la interfaz del asignador y el nombre del archivo de asignación de SQL son iguales y están en el mismo directorio, puede utilizar el análisis de paquetes para simplificar la carga del archivo de asignación de SQL.

Mybatis necesita varios pasos para completar la operación:

Escribir métodos de interfaz

La interfaz xxxMapper en el archivo del mapeador

package com.crz.mapper;

import com.crz.pojo.Brand;

import java.util.List;

/**
 * 查询所有
 */
public interface BrandMapper {
        
        
    public List<Brand> selectAll();
}

escribir SQL

archivo xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
namespace:名称空间

-->
<mapper namespace="com.crz.mapper.BrandMapper">


    <select id="selectAll" resultType="com.crz.pojo.Brand">
        select *
        from tb_brand;
    </select>
</mapper>

método de ejecución

package com.crz.test;

import com.crz.mapper.BrandMapper;
import com.crz.pojo.Brand;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MyBatisTest {
        
        
    @Test
    public void testSelectAll() throws IOException {
        
        
        //1.获取SqlSessionFactory
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //2.获取sqlSessionFactory对象参数true(自动提交事务)false(手动提交事务)
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //3.获取Mapepr接口的代理对象
        BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
        //4.执行方法
        List<Brand> brands = brandMapper.selectAll();
        System.out.println(brands);

        //5.释放资源
        sqlSession.close();

    }
}

3. Archivo de configuración principal de Mybatis

archivo de configuración mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--    简化mapper文件中的resultType 设置完后默认user类名就可以使用,不分辨大小写-->
    <typeAliases>
        <package name="com.crz.pojo.User"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!-- 数据源 -->
            <dataSource type="POOLED">
                <!--数据库的连接信息-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>
    <!--   映射源文件  加载sql映射文件-->
    <mappers>
        <!--        加载sql映射文件-->
        <!--        <mapper resource="com/crz/mapper/UserMapper.xml"/>-->
        <!--        Mapper代理方式  简化代码,只用一行就能扫描吗mapper包下文件所有的mapper.xml文件,适用于mapper.xml多的情况下使用 -->
        <package name="com.crz.mapper"/>
    </mappers>
</configuration>

4. El archivo de configuración se agrega, elimina, modifica y verifica

1. Comprobar:

1. Verificar todo

seleccione * del nombre de la tabla;

2. Ver detalles

inserte la descripción de la imagen aquí

Idea: cuando haga clic para ver los detalles, salte a la página de visualización de detalles de la marca en la que se hizo clic actualmente --> busque el elemento en el que se hizo clic por id y luego devuelva un objeto de marca

3. Consulta de condiciones múltiples

inserte la descripción de la imagen aquí

Análisis de ideas: consulte el estado actual: establezca una variable de estado, si 0 es un estado, 1 es otro..., consulte el nombre de la empresa, utilice como consulta aproximada, el contenido de la base de datos puede aparecer en el cuadro de entrada, nombre de la marca , igual que arriba, porque es una consulta de múltiples condiciones, por lo que debe usar y conectarse

inserte la descripción de la imagen aquí

4. Consulta dinámica de múltiples condiciones

Sitio web chino dinámico SQL_MyBatis

De acuerdo con la consulta de múltiples condiciones mencionada anteriormente, el usuario no necesariamente tiene que ingresar todas las condiciones de consulta, y solo puede buscar a través de un elemento determinado. La instrucción SQL cambia a medida que cambian los datos de entrada del usuario

inserte la descripción de la imagen aquí

5. Consulta dinámica de condición única

inserte la descripción de la imagen aquí

2. Agregar

1. Agregar marca

inserte la descripción de la imagen aquí

2. Agregar devolución de clave principal

inserte la descripción de la imagen aquí

Necesita agregar dos parámetros useGeneratedKeys="true" keyProperty="id"

<insert id="add" useGeneratedKeys="true" keyProperty="id">
        insert into tb_brand (brandName, companyName, ordered, description, status)
        values (#{
    
    brandName}, #{
    
    companyName}, #{
    
    ordered}, #{
    
    description}, #{
    
    status});
    </insert>

3. Modificar

1. Modificar todos los campos

inserte la descripción de la imagen aquí

2. Modificar campos dinámicos

<update id="update">
        update tb_brand
        <set>
            <if test="brandName != null and brandName != ''">
                brandName = #{brandName},
            </if>
            <if test="companyName != null and companyName != ''">
                companyName = #{companyName},
            </if>
            <if test="ordered != null and ordered != ''">
                ordered = #{ordered},
            </if>
            <if test="description != null and description != ''">
                description = #{description},
            </if>
            <if test="status != null">
                status = #{status}
            </if>
        </set>
        where id = ${id};
    </update>

4. Eliminar

Idea: obtenga la identificación de la marca actual cuando haga clic en eliminar y luego elimine los datos correspondientes a la identificación de fondo Lógicamente eliminar: cambiar el estado

1. Eliminar un

Obtenga la identificación de la marca que hizo clic en el botón Eliminar y luego elimine la marca correspondiente a la identificación -> ejecute la declaración SQL de eliminación

2. Eliminar lote

inserte la descripción de la imagen aquí

Encapsule los números de serie seleccionados en una matriz de identificación, recorra después de una recepción única y elimine en lotes de acuerdo con la identificación de cada número de serie

5. La anotación completa las adiciones, eliminaciones, modificaciones y verificaciones

manejo de caracteres especiales

        例如想要实现  select * from tb_brand where id < #{id}; 此时<无法被识别
        解决方案: 1.转义字符: &lt (小于号)
                 2.CDATA区: <![CDATA[ 需要转义的内容  ]]> 输入CD自动生成

Paso de parámetros Mybatis

Se pueden recibir varios parámetros en el método de interfaz de Mybatis, y la capa inferior de Mybatis realiza diferentes métodos de encapsulación y procesamiento para estos parámetros.

parámetro único
1. Tipo POJO: se puede usar directamente para garantizar que el nombre del atributo sea coherente con el nombre del marcador de posición del parámetro correspondiente
2. Colección de mapas: se puede usar directamente, el nombre de la clave es consistente con el nombre del marcador de posición del parámetro
3. Colección: encapsulada como una colección de mapas
  1. map.put(“arg0”,conjunto de colecciones);
  2. map.put(“colección”,conjunto de colección);
4. Lista: encapsulada como una colección de mapas
  1. map.put(“arg0”,conjunto de colecciones);
  2. map.put(“colección”, Conjunto de listas);
  3. map.put(“Lista”, Conjunto de listas);
5. Matriz: encapsulada como una colección de mapas
  1. mapa.put("arg0", matriz);
  2. map.put("matriz", matriz);
6. otros tipos
múltiples parámetros:

Mybatis proporciona la clase ParamNameResolver para la encapsulación de parámetros

Por ejemplo, los parámetros de nombre de usuario y contraseña anteriores tienen dos nombres de parámetros predeterminados antes de agregar anotaciones: arg0 param1, arg1 param2,
por lo que puede usar la anotación @param para cambiar el nombre de la variable

JSTL

Reemplace el código java en la página jsp, si es para

Importar coordenadas:

		<dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId> standard</artifactId>
            <version>1.1.2</version>
        </dependency>

inserte la descripción de la imagen aquí

arquitectura MVC

Un patrón de desarrollo en capas

M: Modelo, modelo de negocio, negocio de procesamiento
V: Ver, ver, pantalla de interfaz
C: controlador, controlador, solicitudes de procesamiento, modelos de llamadas y vistas

beneficio:

La acusación de soltero no se afecta entre sí.
Favorece la división del trabajo y la cooperación.
Facilita la reutilización de componentes.

Arquitectura de tres niveles

inserte la descripción de la imagen aquí

Configuración del proyecto (recursos) + resumen de funciones

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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>org.example</groupId>
    <artifactId>Brand_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--        mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.10</version>
        </dependency>

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

        <!--        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>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!--        standard-->
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!--            tomcat插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
            </plugin>
        </plugins>
    </build>

</project>

Configuración del entorno

inserte la descripción de la imagen aquí

-----------------BrandMapepr.xml-------------------
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
namespace:名称空间

-->
<mapper namespace="com.crz.mapper.BrandMapper">
    
</mapper>

---------------------mybatis-config.xml-------------------------
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--    简化mapper文件中的resultType 设置完后默认user类名就可以使用,不分辨大小写-->
    <typeAliases>
        <!--  设置别名      -->
<!--        <typeAlias alias="brand" type="com.crz.pojo.Brand"/>-->
                <package name="com.crz.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--                数据库的连接信息-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>
    <!--        加载sql映射文件-->
    <mappers>
        <!--        加载sql映射文件-->
        <!--        <mapper resource="com/crz/mapper/UserMapper.xml"/>-->
        <!--        Mapper代理方式  简化代码,只用一行就能扫描吗mapper包下文件所有的mapper.xml文件,适用于mapper.xml多的情况下使用 -->
        <package name="com.crz.mapper"/>
    </mappers>
</configuration>

buscando función

Cree un archivo xml para el mapeo de Mapper

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
namespace:名称空间

-->
<mapper namespace="com.crz.mapper.BrandMapper">

</mapper>

Escriba la interfaz de Mapper para encontrar todos los métodos (anotaciones)

Presentar la clase de herramienta SqlSessionFactoryUtils

package com.crz.util;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class SqlSessionFactoryUtils {
        
        

    private static SqlSessionFactory sqlSessionFactory;

    static {
        
        
        //静态代码块会随着类的加载而自动执行，且只执行一次

        try {
        
        
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
        
        
            e.printStackTrace();
        }
    }


    public static SqlSessionFactory getSqlSessionFactory(){
        
        
        return sqlSessionFactory;
    }
}

Escriba el servicio, ejecute el método selectAll y obtenga el conjunto de resultados

package com.crz.service;

import com.crz.mapper.BrandMapper;
import com.crz.pojo.Brand;
import com.crz.util.SqlSessionFactoryUtils;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import java.util.List;

public class BrandService {
        
        
    SqlSessionFactory factory = SqlSessionFactoryUtils.getSqlSessionFactory();

    /**
     * 查询所有
     * @return
     */
    public List<Brand> selectAll() {
        
        
        //调用BrandMapper.selected

        //2.获取SqlSession
        SqlSession sqlSession = factory.openSession();
        //3.获取BrandMapper
        BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
        //4.调用方法
        List<Brand> brands = mapper.selectedAll();
        sqlSession.close();
        return brands;
    }
}

La interfaz SelectAllServlet realiza la interacción de datos de front-end y back-end (el servlet se puede optimizar) y almacena datos en el campo de solicitud y los pasa a la interfaz de front-end

package com.crz.web;

import com.crz.pojo.Brand;
import com.crz.service.BrandService;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
import java.util.List;

@WebServlet("/selectAllServlet")
public class selectAllServlet extends HttpServlet {
        
        
    BrandService service = new BrandService();

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        
        //1.调用BrandService完成查询 执行sql语句后返回一个brand对象
        List<Brand> brands = service.selectAll();
        //2.存入request域中
        request.setAttribute("brands", brands);
        //3.转发到brand.jsp中
        request.getRequestDispatcher("/brand.jsp").forward(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        
        this.doGet(request, response);
    }
}

La página de inicio obtiene el contenido de la solicitud y muestra los datos

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<input type="button" value="新增"><br>
<hr>
<table border="1" cellspacing="0" width="80%">
    <tr>
        <th>序号</th>
        <th>品牌名称</th>
        <th>企业名称</th>
        <th>排序</th>
        <th>品牌介绍</th>
        <th>状态</th>
        <th>操作</th>
    </tr>

    <c:forEach items="${brands}" var="brand" varStatus="status">
        <tr align="center">
            <td>${status.count}</td>
            <td>${brand.brandName}</td>
            <td>${brand.companyName}</td>
            <td>${brand.ordered}</td>
            <td>${brand.description}</td>
            <c:if test="${brand.status == 1}">
                <td>禁用</td>
            </c:if>
            <td><a href="#">修改</a> <a href="#">删除</a></td>
        </tr>
    </c:forEach>
</table>

<hr>
<c:forEach begin="1" end="10" step="1" var="i">
    <a href="#">${i}</a>
</c:forEach>
</body>
</html>

Añadir función

Genere la declaración sql void add (Brand brand) en el archivo Mapper.xml a través de la interfaz de Mapper;
Escriba la declaración de adición insertada en... declaración

Implemente el método de agregar declaración en brandService Tenga en cuenta que la transacción debe enviarse

public void add(Brand brand){
        
        
        SqlSession sqlSession = factory.openSession();
        BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
        mapper.add(brand);
        //提交事务  增删改需要提交事务,将处理过的数据重新上传
        sqlSession.commit();
        //释放资源
        sqlSession.close();
    }

Después de hacer clic en Agregar información en la página brand.jsp, salta a la página addBrand.jsp.Esta página es un formulario que recopila información diversa sobre cómo agregar una marca y finalmente envía la información en el formulario a addServlet para su procesamiento.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>添加品牌</title>
</head>
<body>
<h3>添加品牌</h3>
<form action="/Brand_demo/addServlet" method="post">
    品牌名称:<input name="brandName"><br>
    企业名称:<input name="companyName"><br>
    排序:<input name="ordered"><br>
    描述信息:<textarea rows="5" cols="20" name="description"></textarea><br>
    状态:
    <input type="radio" name="status" value="0">禁用
    <input type="radio" name="status" value="1">启用<br>
    <input type="submit" value="提交">
</form>
</body>
</html>

addServlet procesa el contenido del formulario -> encapsula la información enviada por el formulario en un objeto de marca y lo reenvía a todas las consultas para actualizar los últimos datos de fondo después de agregar

package com.crz.web;
import com.crz.pojo.Brand;
import com.crz.service.BrandService;

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

@WebServlet("/addServlet")  // 关键部分
public class addServlet extends HttpServlet {
        
        
    BrandService service = new BrandService();
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        
        //处理中文乱码问题
        request.setCharacterEncoding("utf-8");

        Brand brand = new Brand();
        //1.接收表单提交的数据,封装成一个brand对象
        String brandName = request.getParameter("brandName");
        String companyName = request.getParameter("companyName");
        String ordered = request.getParameter("ordered");
        String description = request.getParameter("description");
        String status = request.getParameter("status");

        //2.封装数据
        brand.setBrandName(brandName);
        brand.setCompanyName(companyName);
        brand.setOrdered(Integer.valueOf(ordered));
        brand.setDescription(description);
        brand.setStatus(Integer.valueOf(status));
        //3.调用方法 完成添加
        service.add(brand);
        //4.转发到查询所有
        request.getRequestDispatcher("/selectAllServlet").forward(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        
        this.doGet(request, response);
    }
}

modificar función

Después de que el usuario haga clic en el enlace de modificación, irá a la página para modificar la marca, y la información de la marca actual se repetirá en la página.Después de hacer clic en el enlace de modificación, saltará a la
interfaz selectByIdServlet y encontrará este objeto a través de la identificación de la marca actualmente presionada para modificar

package com.crz.web;

import com.crz.pojo.Brand;
import com.crz.service.BrandService;

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

@WebServlet("/updateServlet")
public class updateServlet extends HttpServlet {
      
      
    BrandService service = new BrandService();

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      
      
        //处理中文乱码问题
        request.setCharacterEncoding("utf-8");

        Brand brand = new Brand();
        //1.接收表单提交的数据,封装成一个brand对象
        String id = request.getParameter("id");
        String brandName = request.getParameter("brandName");
        String companyName = request.getParameter("companyName");
        String ordered = request.getParameter("ordered");
        String description = request.getParameter("description");
        String status = request.getParameter("status");

        //2.封装数据
        brand.setId(Integer.valueOf(id));
        brand.setBrandName(brandName);
        brand.setCompanyName(companyName);
        brand.setOrdered(Integer.valueOf(ordered));
        brand.setDescription(description);
        brand.setStatus(Integer.valueOf(status));
        //3.调用方法 完成添加
        service.update(brand);
        //4.转发到查询所有
        request.getRequestDispatcher("/selectAllServlet").forward(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      
      
        this.doGet(request, response);
    }
}

El objeto encontrado por id se envía al front-end jsp y se repite en la página. Debido a que necesitamos saber qué objeto modificar, necesitamos obtener el valor de id de la marca correspondiente. Aquí necesitamos usar el campo oculto para guarde el valor de identificación para la recepción en segundo plano Después de hacer clic en enviar, los datos se pasan a updateServlet para su procesamiento

<form action="/Brand_demo/updateServlet" method="post">

    <%--    隐藏域 用与保存id,方便修改信息时id读取--%>
    <input type="hidden" name="id" value="${brand.id}">
    品牌名称:<input name="brandName" value="${brand.brandName}"><br>
    企业名称:<input name="companyName" value="${brand.companyName}"><br>
    排序:<input name="ordered" value="${brand.ordered}"><br>
    描述信息:<textarea rows="5" cols="20" name="description">${
        
        brand.description}</textarea><br>
    状态:
    <c:if test="${brand.status == 0}">
        <input type="radio" name="status" value="0" checked>禁用
        <input type="radio" name="status" value="1">启用<br>
    </c:if>
    <c:if test="${brand.status == 1}">
        <input type="radio" name="status" value="0">禁用
        <input type="radio" name="status" value="1" checked>启用<br>
    </c:if>

    <input type="submit" value="提交">
</form>

Modifique el valor en update.jsp y devuélvalo al backend para su procesamiento (lo mismo que agregar, pero el nombre del método es diferente)

Escriba la actualización de la interfaz de actualización (marca de la marca) y escriba la instrucción sql en el archivo de asignación

<update id="update">
        update tb_brand
        <set>
            <if test="id != null">
                id = #{id},
            </if>
            <if test="brandName != null and brandName != ''">
                brandName = #{brandName},
            </if>
            <if test="companyName != null and companyName != ''">
                companyName = #{companyName},
            </if>
            <if test="ordered != null and ordered != ''">
                ordered = #{ordered},
            </if>
            <if test="description != null and description != ''">
                description = #{description},
            </if>
            <if test="status != null">
                status = #{status}
            </if>
        </set>
        where id = ${id};
    </update>

El método de actualización implementado en la capa de Servicio es similar a agregar

public void update(Brand brand) {
      
      
        SqlSession sqlSession = factory.openSession();
        BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
        mapper.update(brand);
        sqlSession.commit();
        sqlSession.close();
    }

updateServlet implementa la última actualización y muestra los datos más recientes, y actualiza los datos llamando de nuevo a la interfaz selectAllServlet

package com.crz.web;

import com.crz.pojo.Brand;
import com.crz.service.BrandService;

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

@WebServlet("/updateServlet")
public class updateServlet extends HttpServlet {
      
      
    BrandService service = new BrandService();

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      
      
        //处理中文乱码问题
        request.setCharacterEncoding("utf-8");

        Brand brand = new Brand();
        //1.接收表单提交的数据,封装成一个brand对象
        String id = request.getParameter("id");
        String brandName = request.getParameter("brandName");
        String companyName = request.getParameter("companyName");
        String ordered = request.getParameter("ordered");
        String description = request.getParameter("description");
        String status = request.getParameter("status");

        //2.封装数据
        brand.setId(Integer.valueOf(id));
        brand.setBrandName(brandName);
        brand.setCompanyName(companyName);
        brand.setOrdered(Integer.valueOf(ordered));
        brand.setDescription(description);
        brand.setStatus(Integer.valueOf(status));
        //3.调用方法 完成添加
        service.update(brand);
        //4.转发到查询所有
        request.getRequestDispatcher("/selectAllServlet").forward(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      
      
        this.doGet(request, response);
    }
}

Disposición de puntos de conocimiento de JavaWeb

Introducción a Java Web

Prueba de jugo

reflexión

anotación

1. JDBC

1. Introducción

2. Inicio rápido

3. Explicación detallada de la API

1.Administrador de controladores

2. Conexión

3. Declaración

4.ResultSet (objeto de conjunto de resultados)

5. PreparedStatement (el objeto que ejecuta la declaración SQL)

4. Grupo de conexiones de base de datos

1. Introducción

2. Pasos de uso de Driud

Configurar archivo driud

5. Realice el caso de agregar, eliminar, modificar y verificar datos de marca

1. Preparación de la base de datos MySQL

2. Creación de clase de marca en idea

3. Consulta todos los datos

4. Agregar datos

5. Modificar datos

6. Operación de eliminación

2. Experto

1. Introducción a Maven

2. Configuración de instalación de Maven

3. Uso básico de Maven

4. Experto en implementación de IDEA

1. Coordenadas expertas

2. IDEA crea un proyecto Maven

3. Importar proyecto Maven externo

5. Gestión de la dependencia

1. Ámbito de dependencia

XML

1. Función

2. Gramática

Maven crea un proyecto web

1. Usa el esqueleto – Maven Archetype para crear –> encuentra esto

2. No usa el esqueleto

Maven integra Tomcat local

1. Importación manual

2. Importación del complemento Maven

Web

1. Revisión de contenido relacionado con la web

2. Instalación y configuración de Tomcat

servlet

1. La interfaz Servlet no se puede crear en la idea

2. Inicio rápido

3. Arquitectura de servlets

1. Objeto de solicitud

solicitudOtras características

1. Formas de obtener parámetros de solicitud

2. Solicitud de reenvío

3. Compartir datos

4. Obtener ServletContext

2. Objeto de respuesta

protocolo HTTP

1. Solicitar mensaje

2. Mensaje de respuesta

tecnología conversacional

1.Cookie

2.Sesión

Caso de código de verificación

JSP

modelo de desarrollo MVC

EL expresión

formato de fecha

Filtrar

Ajax

El código nativo implementa ajax

El framework axios implementa ajax

Inicio rápido

el caso

Uso de alias para simplificar aún más el código

JSON

Mi zapato

1. Qué es Mybatis

capa de persistencia