devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JavaEE入门级别最全教程4--初学者必看_javaee教程

作者：IT小白 | 2024-06-02 19:52:17

赞

踩

javaee教程

健康万岁，商业无罪，大家好我是Laity也是你们的J哥。

一、JavaWeb介绍

使用Java技术来解决相关web互联网领域的技术栈(其实就是开发网站)

Java 的 api齐全，历史悠久。(后台开发工程师主要数据库和JavaWeb程序的开发)

二、数据库

2.1 Mysql

2.1.1 数据库

DB

2.1.2 数据库管理系统

管理数据库的大型软件（MYSQL就是DBMS）

2.1.3 SQL

操作数据库的编程语言(操作市面上所有的关系型数据库)

  • 关系型数据库

    • Mysql

    • Oracle

    • SQLite

    • SQL Server

  • 非关系型数据库

    • MangoDb

2.1.4 Mysql安装

MySQL :: Download MySQL Community Server (Archived Versions) Mysql5.7.24

解压即可 -- 配置环境遍历 -- 系统变量 --

新建 MYSQL_HOME = D:...

Path -- %MYSQL_HOME%\bin

在安装目录创建一个 my.ini

  1.  [mysql]
  2.  default-character-set=utf8
  3.  ​
  4.  [mysqld]
  5.  character-set-server=utf8
  6.  default-storage-engine=INNODB
  7.  sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,EEROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION

2.1.5 初始化Mysql

cmd中管理员窗口

  mysqld --initialize-insecure

c/windows/system32/cmd.exe

2.1.6 注册Mysql的服务

cmd

 mysqld -install

2.1.7 启动Mysql服务

  1.  net start mysql   // 启动服务
  2.  net stop mysql  // 停止服务

2.1.8 查看本机服务（windows）

 services.msc

2.1.9 修改默认账户密码

 mysqladmin -uroot password 1234

2.1.10 登录参数

  1.  mysql -u用户名 -p密码 -h要连接的mysql服务器的ip地址(默认127.0.0.1) -P端口(默认3306)
  2.  mysql -ulaity -pLaity123? -h39.106.227.23 -P3306

2.1.11 cmd导入数据

  1.  首先创建数据库
  2.  create database mynewblog
  3.  ​
  4.  把上传上去的sql导入到数据库中
  5.  传:将sql文件上传到root下
  6.  ​
  7.  按照下面的三个步骤，快速导入这个sql文件
  8.  ​
  9.  mysql>use mynewblog;
  10.  mysql>set names utf8;
  11.  mysql>source /root/database.sql;
  12.  ​
  13.   
  14.  ​
  15.  然后屏幕上就会不断的滚，最后提示导入成功。
  16.  ​
  17.  最后，记得将database.sql删除
  18.  ​
  19.  确定数据表是否创建成功，即数据文件是否导入成功。
  20.  执行命令 show tables；查看数据库下的表。
  21.  ​
  22.  删除数据库
  23.  drop database <数据库名>;
  24.  ​
  25.  如果遇到 Unknown collation: 'utf8mb4_0900_ai_ci'
  26.  • 把文件中的所有的utf8mb4_0900_ai_ci替换为utf8_general_ci
  27.  • 以及utf8mb4替换为utf8
  28.  否则会报 COLLATION 'utf8_general_ci' is not valid for CHARACTER SET 'utf8mb4'
  1. -- 向表中插入数据
  2. CREATE TABLE 表名 {
  3. 	id ...
  4. 	username ...
  5. 	password ...
  6. };
  7. INSERT INTO 表名(id,username,password) value(1,"Laity", 123456);

2.1.12 约束

概念:

  • 约束是作用于表中列上的规则，用于限制加入表的数据。

  • 约束的存在保证了数据库中数据的正确性、有效性和完整性。

约束的分类:

约束名称描述关键字
非空约束保证列中所有数据不能有null值NOT NULL
唯一约束保证列中所有数据各个不同UNIQUE
主键约束主键是一行数据的唯一标识，要求非空且唯一PRIMARY KEY
检查约束保证列中的值满足某一条件CHECK
默认约束保存数据时，未指定值则采用默认值DEFAULT
外键约束外键用来让两个表的数据之间建立连接，保证数据的唯一性和完整性FOREIGN KEY

MYSQL不支持检查约束

auto_increment ：当列时数字类型并且 唯一约束

2.1.13 详解外键约束

概念: 外键用来让两个表的数据之间建立链接，保证数据的一致性和完整性

  1. -- 创建表时添加外键约束
  2. create table 表名 {
  3.      列名 数据类型
  4.      ...
  5.      [constraint] [外键名称] foreign key(外键名) references 主表(主表列名)
  6.  };
  7.  ​
  8. -- 建完表后添加外键约束
  9. alter table 表名 add constraint 外键名称 foreign key (外键字段名称) references 主表名称(主表列名称);
  10.  ​
  11. -- 删除外键
  12. alter table 表名 drop foreign key 外键名称

2.1.14 数据库设计

  • 一对多

  • 一对一

  • 多对多

2.1.15 多表查询

  • 笛卡尔积：取A,B集合所有组合情况

  • 多表查询：从多张表查询数据

    • 连接查询

      • 内连接：相当于查询A B交集数据

      • 外连接：

        • 左外连接：相当于查询A表所有数据和交集部分数据

        • 右外连接：相当于查询B表所有数据和交集部分数据

    • 子查询

连接查询

内连接

  1.  -- 隐示内连接
  2.  select 字段列表 from 表1，表2... where 条件;
  3.  ​
  4.  -- 显示内连接
  5.  select 字段列表 from 表1 [inner] join 表2 on 条件;
  6.  ​
  7.  -- 内连接相当于查询A B表交集数据

外连接

  1.  -- 左外连接
  2.  select 字段列表 from 表1 left [inner] join 表2 on 条件;
  3.  ​
  4.  -- 右外连接
  5.  select 字段列表 from 表1 right [inner] join 表2 on 条件;
  6.  ​
  7.  ​
  8.  -- 左外连接：相当于查询A表所有数据和交集部分数据
  9.  -- 右外连接：相当于查询B表所有数据和交集部分数据

子查询

  1.  -- 概念：查询中嵌套查询，称嵌套查询为子查询
  2.  -- 子查询根据查询结果不同，作用不同:
  3.  -- 单行单列：作为条件值，使用 = != > < 等进行条件判断
  4.  select 字段列表 from 表 where 字段名 = (子查询);
  5.  -- 多行单列：作为条件值，使用in等关键字进行条件判断
  6.  select 字段列表 from 表 where 字段名 in (子查询);
  7.  -- 多行多列：作为虚拟表
  8.  select 字段列表 from (子查询) where 条件;

2.1.16 事务

  1.  -- 事务： 广泛应用于银行系统和订单系统等     表的引擎类型必须是  innodb类型才可以使用事务，这也是MySQL默认引擎
  2.  所谓事务，它是一个操作系统,要么都执行,要么都不执行，是不可分割的单位。
  3.  事务四大特征：(ACID)
  4.      1.原子性(A)  :整个事务中的所有操作要么成功要么不成功
  5.      2.一致性(C)  ：最终执行的结果是一样的   中间出了问题也不会出现数据丢了的情况
  6.      3.隔离性(I)  ：当事务开启之后：一个事务所做的修改在最终提交前，对其它事务是不可见的(一个sql的执行不会影响到另外一个sql)
  7.      4.持久性(D)  :一旦事务提交 commit,则其所做的修改会永久保存到数据库 (此时即使数据库系统崩溃，修改的数据也不会丢失)
  8.  -- 事务开启 ：begin; / start transaction;  中间：sql语句    事务提交 ，结束： commit;   回滚事务：放弃缓存中变更的数据： rollback;

2.2 JDBC

概念：通过Java代码操作关系型数据库的一套API

2.2.1 JDBC驱动jar包下载

  • MySQL :: Download Connector/J

  • 操作系统选择Platform Independent，下方列表中的两条记录，后缀tar.gz的是Linux版本，.zip的是windows版本。我用的是5.1.48

img

  • 这里下载windows版本的jdbc驱动，版本为8.0.18

img

  • 跳过登录，直接点击红框里的内容，进行下载

2.2.2 JDBC 快速入门

  1. 创建工程，导入驱动jar包

  2. 注册驱动

    1. Class.forName(“com.mysql.jdbc.Driver”);

  3. 获取连接

    1. Connection conn = DriverManager.getConnection(url,username,password);

  4. 定义SQL语句

    1. String sql = “update...”;

  5. 获取SQL对象

    1. Statement stmt = conn.createStatement();

  6. 执行SQL

    1. stmt.executeUpdate(sql);

  7. 处理返回结果

  8. 释放资源

 
  1. package com.SqlJDBC.JDBCdemo1;
  2.  ​
  3.  import java.sql.Connection;
  4.  import java.sql.DriverManager;
  5.  import java.sql.SQLException;
  6.  import java.sql.Statement;
  7.  ​
  8.  /**
  9.   * @author : Laity
  10.   * @Project: JavaLaity
  11.   * @Package com.SqlJDBC.JDBCdemo1
  12.   * @date Date : 2021年12月10日 14:05
  13.   * @Description: Java语言操作数据库(JDBC快速入门)
  14.   */
  15.  public class JDBCTest {
  16.      public static void main(String[] args) throws ClassNotFoundException, SQLException {
  17.          // 1. 注册驱动 可以省略不写
  18.          Class.forName("com.mysql.jdbc.Driver");
  19.          // 2. 获取连接 三个参数url username password
  20.          // 2.1 jdbc:mysql:// 固定语法
  21.          // 2.2 简写 jdbc:mysql:///
  22.          String url = "jdbc:mysql://127.0.0.1:3306/java";  // ?useSSL=false
  23.          String username = "root";
  24.          String password = "wang9264";
  25.          Connection conn = DriverManager.getConnection(url, username, password);
  26.          // 3. 定义一个SQL语句
  27.          String sql = "update account set money = 2000 where id = 1";
  28.          // 4. 获取执行sql的对象，Statement
  29.          Statement stmt = conn.createStatement();
  30.  ​
  31.          // 5.执行sql
  32.          int count = stmt.executeUpdate(sql);  // 受影响的行数
  33.  ​
  34.          // 6.处理结果
  35.          System.out.println(count);
  36.  ​
  37.          // 7.释放资源
  38.          stmt.close();
  39.          conn.close();
  40.      }
  41.  }

2.2.3 JDBC API详解

JDBC API 详解 ： DriverManager

  1.  package com.SqlJDBC.JDBCdemo1;
  2.  ​
  3.  import java.sql.Connection;
  4.  import java.sql.DriverManager;
  5.  import java.sql.SQLException;
  6.  import java.sql.Statement;
  7.  ​
  8.  /**
  9.   * @author : Laity
  10.   * @Project: JavaLaity
  11.   * @Package com.SqlJDBC.JDBCdemo1
  12.   * @date Date : 2021年12月10日 14:05
  13.   * @Description: Java语言操作数据库(JDBC API 详解 ： DriverManager)
  14.   */
  15.  public class JDBCTest2_DriverManager {
  16.      public static void main(String[] args) throws ClassNotFoundException, SQLException {
  17.          // 1. 注册驱动 可以省略不写
  18.          // Class.forName("com.mysql.jdbc.Driver");
  19.          // 2. 获取连接 三个参数url username password
  20.          // 2.1 jdbc:mysql:// 固定语法
  21.          // 2.2 简写 jdbc:mysql:///
  22.          String url = "jdbc:mysql:///java?useSSL=false";
  23.          String username = "root";
  24.          String password = "wang9264";
  25.          Connection conn = DriverManager.getConnection(url, username, password);
  26.          // 3. 定义一个SQL语句
  27.          String sql = "update account set money = 2000 where id = 1";
  28.          // 4. 获取执行sql的对象，Statement
  29.          Statement stmt = conn.createStatement();
  30.  ​
  31.          // 5.执行sql
  32.          int count = stmt.executeUpdate(sql);  // 受影响的行数
  33.  ​
  34.          // 6.处理结果
  35.          System.out.println(count);
  36.  ​
  37.          // 7.释放资源
  38.          stmt.close();
  39.          conn.close();
  40.      }
  41.  }

JDBC API 详解 ： Connection（事务）

 
  1. package com.SqlJDBC.JDBCdemo1;
  2.  ​
  3.  import java.sql.Connection;
  4.  import java.sql.DriverManager;
  5.  import java.sql.SQLException;
  6.  import java.sql.Statement;
  7.  ​
  8.  /**
  9.   * @author : Laity
  10.   * @Project: JavaLaity
  11.   * @Package com.SqlJDBC.JDBCdemo1
  12.   * @date Date : 2021年12月10日 14:05
  13.   * @Description: Java语言操作数据库(JDBC API 详解 ： Connection)
  14.   */
  15.  public class JDBCTest3_Connection {
  16.      public static void main(String[] args) throws ClassNotFoundException, SQLException {
  17.          // 1. 注册驱动 可以省略不写
  18.          // Class.forName("com.mysql.jdbc.Driver");
  19.          // 2. 获取连接 三个参数url username password
  20.          // 2.1 jdbc:mysql:// 固定语法
  21.          // 2.2 简写 jdbc:mysql:///
  22.          String url = "jdbc:mysql:///java?useSSL=false";
  23.          String username = "root";
  24.          String password = "wang9264";
  25.          Connection conn = DriverManager.getConnection(url, username, password);
  26.          // 3. 定义一个SQL语句
  27.          String sql1 = "update account set money = 3000 where id = 1";
  28.          String sql2 = "update account set money = 3000 where id = 2";
  29.          // 4. 获取执行sql的对象，Statement
  30.          Statement stmt = conn.createStatement();
  31.  ​
  32.          // 开启事务
  33.          conn.setAutoCommit(false);
  34.          try {
  35.              // 5.执行sql
  36.              int count1 = stmt.executeUpdate(sql1);  // 受影响的行数
  37.              // 6.处理结果
  38.              System.out.println(count1);
  39.              int count2 = stmt.executeUpdate(sql2);  // 受影响的行数
  40.              System.out.println(count2);
  41.              // 提交事务
  42.              conn.commit();
  43.          } catch (Exception throwables) {
  44.              // 回滚事务
  45.              conn.rollback();
  46.  ​
  47.              throwables.printStackTrace();
  48.          }
  49.  ​
  50.          // 7.释放资源
  51.          stmt.close();
  52.          conn.close();
  53.      }
  54.  }

JDBC API 详解 ： Statement

 
  1. package com.SqlJDBC.JDBCdemo1;
  2.  ​
  3.  import java.sql.Connection;
  4.  import java.sql.DriverManager;
  5.  import java.sql.Statement;
  6.  ​
  7.  /**
  8.   * @author : Laity
  9.   * @Project: JavaLaity
  10.   * @Package com.SqlJDBC.JDBCdemo1
  11.   * @date Date : 2021年12月10日 14:05
  12.   * @Description: Java语言操作数据库(JDBC API 详解 ： Statement)
  13.   */
  14.  public class JDBCTest4_Statement {
  15.      public static void main(String[] args) throws Exception {
  16.          // testDML();
  17.          testDDL();
  18.      }
  19.  ​
  20.      /**
  21.       * 执行DML语句
  22.       *
  23.       * @throws Exception
  24.       */
  25.      public static void testDML() throws Exception {
  26.          String url = "jdbc:mysql:///java?useSSL=false";
  27.          String username = "root";
  28.          String password = "wang9264";
  29.          Connection conn = DriverManager.getConnection(url, username, password);
  30.          // 3. 定义一个SQL语句
  31.          String sql1 = "update account set money = 3000 where id = 1";
  32.          // 4. 获取执行sql的对象，Statement
  33.          Statement stmt = conn.createStatement();
  34.  ​
  35.          // 5.执行sql
  36.          int count1 = stmt.executeUpdate(sql1);  // 执行完DML， 受影响的行数
  37.          // 6.处理结果
  38.          if (count1 > 0) {
  39.              System.out.println("修改成功~");
  40.          } else {
  41.              System.out.println("修改失败~");
  42.          }
  43.  ​
  44.          // 7.释放资源
  45.          stmt.close();
  46.          conn.close();
  47.      }
  48.  ​
  49.      /**
  50.       * 执行DDL语句
  51.       *
  52.       * @throws Exception
  53.       */
  54.      public static void testDDL() throws Exception {
  55.          String url = "jdbc:mysql:///java?useSSL=false";
  56.          String username = "root";
  57.          String password = "wang9264";
  58.          Connection conn = DriverManager.getConnection(url, username, password);
  59.          String sql1 = "create databases javadb";
  60.          Statement stmt = conn.createStatement();
  61.          // 5.执行sql
  62.          int count1 = stmt.executeUpdate(sql1);  // 执行完DDL， 受影响的行数
  63.          // 6.处理结果
  64.          if (count1 > 0) {
  65.              System.out.println("修改成功~");
  66.          } else {
  67.              System.out.println("修改失败~");
  68.          }
  69.  ​
  70.          // 7.释放资源
  71.          stmt.close();
  72.          conn.close();
  73.      }
  74.  }

JDBC API 详解 ： ResultSet

 
  1. package com.SqlJDBC.JDBCdemo1;
  2.  ​
  3.  import java.sql.Connection;
  4.  import java.sql.DriverManager;
  5.  import java.sql.ResultSet;
  6.  import java.sql.Statement;
  7.  ​
  8.  /**
  9.   * @author : Laity
  10.   * @Project: JavaLaity
  11.   * @Package com.SqlJDBC.JDBCdemo1
  12.   * @date Date : 2021年12月10日 14:05
  13.   * @Description: Java语言操作数据库(JDBC API 详解 ： ResultSet)
  14.   */
  15.  public class JDBCTest5_ResultSet {
  16.      public static void main(String[] args) throws Exception {
  17.          // testDML();
  18.          testResult();
  19.      }
  20.  ​
  21.      /**
  22.       * 执行Result语句  DQL查询语句
  23.       *
  24.       * @throws Exception
  25.       */
  26.      public static void testResult() throws Exception {
  27.          String url = "jdbc:mysql:///java?useSSL=false";
  28.          String username = "root";
  29.          String password = "wang9264";
  30.          Connection conn = DriverManager.getConnection(url, username, password);
  31.          String sql = "select * from account";
  32.  ​
  33.          Statement stmt = conn.createStatement();
  34.  ​
  35.          ResultSet rs = stmt.executeQuery(sql);
  36.          // 遍历结果
  37.          // 光标向下移动一行，并且判断当前行是否有数据
  38.          while (rs.next()) {
  39.              // 获取数据
  40.              int id = rs.getInt(1);  // 也可写名称 id
  41.              String name = rs.getString(2);  // name
  42.              double money = rs.getDouble(3); // money
  43.              System.out.println(id);
  44.              System.out.println(name);
  45.              System.out.println(money);
  46.  ​
  47.              System.out.println("-----------------------");
  48.          }
  49.          // 释放资源
  50.          rs.close();
  51.          stmt.close();
  52.          conn.close();
  53.      }
  54.  }

JDBC API 详解 ： PrepareStaement

  • 作用

    • 预防sql注入

  • sql注入

    • 就是通过操作输入来修改事先定义好的sql语句，用以达到执行代码对服务器进行公鸡的方法。

  1. -- 正常
  2.  select * from tb_user where username = "zhangsan" and password="123";
  3.  -- ' or '1' = '1
  4.  select * from tb_user where username='fafafadfaf' and password ='' or '1' = '1'
  5.  -- 怎么防止sql注入
  6.  -- 就是将敏感字符进行转义
  7.  -- String url = "jdbc:mysql:///java?useSSL=false&useServerPrepStmts=true";  // useServerPrepStmts=true开启预编译功能
  1.  // sql注入案例
  2.  package com.SqlJDBC.JDBCdemo1;
  3.  ​
  4.  import java.sql.Connection;
  5.  import java.sql.DriverManager;
  6.  import java.sql.ResultSet;
  7.  import java.sql.Statement;
  8.  ​
  9.  /**
  10.   * @author : Laity
  11.   * @Project: JavaLaity
  12.   * @Package com.SqlJDBC.JDBCdemo1
  13.   * @date Date : 2021年12月10日 14:05
  14.   * @Description: Java语言操作数据库(JDBC API 详解 ： SQL注入)
  15.   */
  16.  public class JDBCTest6_UserLogin {
  17.      public static void main(String[] args) throws Exception {
  18.          testUserLogin();
  19.          testLogin_Inject();
  20.      }
  21.  ​
  22.      /**
  23.       * 用户登录
  24.       *
  25.       * @throws Exception
  26.       */
  27.      public static void testUserLogin() throws Exception {
  28.          String url = "jdbc:mysql:///java?useSSL=false";
  29.          String username = "root";
  30.          String password = "wang9264";
  31.          Connection conn = DriverManager.getConnection(url, username, password);
  32.          // 接收输入的用户名和密码
  33.          String name = "laity";
  34.          String pwd = "123";
  35.          String sql = "select * from tb_user where username='" + name + "' and password ='" + pwd + "'";
  36.  ​
  37.          Statement stmt = conn.createStatement();
  38.          ResultSet rs = stmt.executeQuery(sql);
  39.          // 判断登录成功与否
  40.          if (rs.next()) {
  41.              System.out.println("登录成功");
  42.          } else {
  43.              System.out.println("登录失败");
  44.          }
  45.          // 释放资源
  46.          rs.close();
  47.          stmt.close();
  48.          conn.close();
  49.      }
  50.  ​
  51.      /**
  52.       * 用户登录注入
  53.       *
  54.       * @throws Exception
  55.       */
  56.      public static void testLogin_Inject() throws Exception {
  57.          String url = "jdbc:mysql:///java?useSSL=false";
  58.          String username = "root";
  59.          String password = "wang9264";
  60.          Connection conn = DriverManager.getConnection(url, username, password);
  61.          // 接收输入的用户名和密码
  62.          String name = "fafafadfaf";
  63.          String pwd = "' or '1' = '1";
  64.          String sql = "select * from tb_user where username='" + name + "' and password ='" + pwd + "'";
  65.  ​
  66.          Statement stmt = conn.createStatement();
  67.          ResultSet rs = stmt.executeQuery(sql);
  68.          // 判断登录成功与否
  69.          if (rs.next()) {
  70.              System.out.println("登录成功");
  71.          } else {
  72.              System.out.println("登录失败");
  73.          }
  74.          // 释放资源
  75.          rs.close();
  76.          stmt.close();
  77.          conn.close();
  78.      }
  79.  }
  1.  // 通过prepareStaement解决sql注入问题
  2.  package com.SqlJDBC.JDBCdemo1;
  3.  ​
  4.  import java.sql.*;
  5.  ​
  6.  /**
  7.   * @author : Laity
  8.   * @Project: JavaLaity
  9.   * @Package com.SqlJDBC.JDBCdemo1
  10.   * @date Date : 2021年12月10日 14:05
  11.   * @Description: Java语言操作数据库(JDBC API 详解 ： SQL注入)
  12.   */
  13.  public class JDBCTest7_ProparedStatement {
  14.      public static void main(String[] args) throws Exception {
  15.          testLogin_Inject();
  16.      }
  17.      /**
  18.       * 用户登录注入
  19.       *
  20.       * @throws Exception
  21.       */
  22.      public static void testLogin_Inject() throws Exception {
  23.          String url = "jdbc:mysql:///java?useSSL=false&useServerPrepStmts=true";  // useServerPrepStmts=true开启预编译功能
  24.          String username = "root";
  25.          String password = "wang9264";
  26.          Connection conn = DriverManager.getConnection(url, username, password);
  27.          // 接收输入的用户名和密码
  28.          String name = "fafafadfaf";
  29.          String pwd = "' or '1' = '1";
  30.          String sql = "select * from tb_user where username= ? and password = ? ";
  31.          PreparedStatement pstmt = conn.prepareStatement(sql);
  32.          pstmt.setString(1, name);
  33.          pstmt.setString(2, pwd);
  34.  ​
  35.          System.out.println(sql);
  36.          ResultSet rs = pstmt.executeQuery();
  37.          // 判断登录成功与否
  38.          if (rs.next()) {
  39.              System.out.println("登录成功");
  40.          } else {
  41.              System.out.println("登录失败");
  42.          }
  43.          // 释放资源
  44.          rs.close();
  45.          pstmt.close();
  46.          conn.close();
  47.      }
  48.  }

2.2.4 数据库连接池

概念：一个容器，负责发配、管理数据库连接(Connection)

  • 好处

    • 资源重用

    • 提升系统响应速度

    • 避免数据库连接漏洞

数据库连接池实现

  • 标准接口: DataSource

    • 官方(SUN)提供的数据库连接池标准接口，由第三方组织实现此接口。

    • 功能：获取连接

 Connection getConnection();

  • 常见的数据库连接池：

    • DBCP

    • C3P0

    • Druid

  • Druid(德鲁伊)

    • Druid连接池是阿里巴巴开源的数据库连接池项目。

    • 功能强大，性能优秀，是Java语言最好的数据库连接池之一。

Druid使用

  • 下载（1.1.12）

  • Druid配置文件的配置

    • 导入jar包后，将配置文件复制到项目下的src文件夹中

  • 复制好后双击打开配置文件修改配里面的参数就可以使用了。

  • 基础配置文件

  1.  driverClassName=com.mysql.jdbc.Driver
  2.  url=jdbc:mysql:///java?useSSL=false&useServerPrepStmts=true
  3.  username=root
  4.  password=wang9264
  5.  # 初始化连接数量
  6.  initialSize=5
  7.  # 最大连接数量
  8.  maxActive=10
  9.  # 最大等待时间  ms
  10.  maxWait=3000

可参考本人博客  Druid详细配置

  1.  package com.SqlJDBC.druid;
  2.  ​
  3.  import com.alibaba.druid.pool.DruidDataSourceFactory;
  4.  ​
  5.  import javax.sql.DataSource;
  6.  import java.io.FileInputStream;
  7.  import java.sql.Connection;
  8.  import java.util.Properties;
  9.  ​
  10.  /**
  11.   * @author : Laity
  12.   * @Project: JavaLaity
  13.   * @Package com.SqlJDBC.druid
  14.   * @date Date : 2021年12月10日 21:59
  15.   * @Description: Druid数据库连接池的使用
  16.   */
  17.  public class DruidDemo {
  18.      public static void main(String[] args) throws Exception {
  19.          System.out.println(System.getProperty("user.dir"));  // 打印当前所在路径
  20.          // 1.导入jar包
  21.  ​
  22.          // 2.定义配置文件
  23.  ​
  24.          // 3.加载配置文件
  25.          Properties prop = new Properties();
  26.          prop.load(new FileInputStream("FrontEndDirection/src/druid.properties"));
  27.  ​
  28.          // 4.获取连接池对象
  29.          DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  30.  ​
  31.          // 5.获取数据库连接 Connection
  32.          Connection connection = dataSource.getConnection();
  33.          System.out.println(connection);
  34.      }
  35.  }

注意：在实体类中，基本数据类型建议使用其对应的包装类型

2.3 Maven

  • Maven是专门管理和构建Java项目的工具，它的主要功能有：

    • 提供一套标准化的项目结构（eclipse、idea通用代码）

    • 提供一套标准化的构建流程（编译、测试、打包、发布......）

    • 提供一套依赖管理机制（jar包、插件等）

2.3.1 Maven 安装配置

  • 说明:当项目中使用坐标引入对应依赖jar包后，首先会查找本地仓库中是否有对应的jar包：

    • 如果有，则在项目中之间引用；

    • 如果没有，则会去中央仓库中下载对应的jar包到本地仓库。

  • 下载仓库地址: maven下载

  • 配置环境变量:

紧接着在path中设置：

  • 然后运行:mvn -version 当出现下面内容说明环境变量配置成功

  • 配置本地仓库： 修改conf/settings.xml中的<localReponsitory>为一个指定目录

  • 配置阿里云的私服：修改conf/settings.xml中的 <mirrors>标签，为其添加如下子标签：（下载速度很快）

  1.  <mirror>
  2.      <id>alimaven</id>
  3.      <mirrorOf>central</mirrorOf>
  4.      <name>aliyun maven</name>
  5.      <url>http://maven.aliyun.com/nexus/content/groups/public</url>
  6.  </mirror>

2.3.2 Maven的基本使用

2.3.2.1 Maven的常用命令

  • compile：编译

  • clean：清理

  • test：测试

  • package：打包（生成jar包）

    • windows java -jar xxx 运行

    • liunx nohup java -jar xxx.jar &

    • 如果想停止jar运行，ps -ef查看进程(进程多的话也可以加上grep)，找到对应的java进程，kill掉。

    • jar xvf test.jar 解压包

  • install：安装（将jar包存储到本地仓库中）

2.3.2.2 Maven的生命周期

  • Maven构建项目生命周期描述的是 一次构建过程经历 一共经历了多少个事件

  • Maven对项目构建的生命周期划为3套

    • clean：清理工作

    • default：核心工作，例如编译，测试，打包，安装等

    • site：产生报告，发布站点等

  • 同一生命周期内，执行后面的命令，前面的所有命令会自动执行（complie->clean->test->package->install）

2.3.2.3 IDEA 配置 Maven环境

  1. 选择IDEA中File --> Settings

  2. 搜索 maven

  3. 设置IDEA 使用本地安装的 Maven，并修改配置文件路径

2.3.2.4 Maven坐标详情

  • Maven中的坐标是 资源的唯一标识

  • 使用坐标来定义项目或者引入项目中需要的依赖

  • Maven坐标的主要组成

    • groupld：定义当前Maven项目隶属组织的名称（通常是域名反写，例如：com.itlaity）

    • artifactld：定义当前Maven项目的名称（通常是模块的名称，例如：order-server、goods-server）

    • version：定义当前项目版本号

2.3.2.5 创建Maven项目

参考：IntelliJ IDEA 15 创建maven项目 - Tom1997 - 博客园

2.3.2.5 IDEA 导入Maven项目

2.3.2.6 Maven插件

配置Maven-Helper插件

  1. 选择IDEA中 File ->Settings

  2. 选择 Plugins

  3. 搜索 Maven，现在第一个 Maven Helper，点击install安装即可

  4. 重启IDEA

2.3.3 依赖管理

使用坐标导入jar包

  1. 在pom.xml 中编写 <dependencies>标签

  2. 在<dependencies> 标签中 使用<dependency> 引入坐标

  3. 定义坐标的 groupld，artifatld，version

  4. 点击刷新按钮，使坐标生效。

  1.      <!--导入mysql 驱动 jar包-->
  2.      <dependencies>
  3.          <dependency>
  4.              <groupId>mysql</groupId>
  5.              <artifactId>mysql-connector-java</artifactId>
  6.              <version>5.1.48</version>
  7.          </dependency>
  8.  ​
  9.          <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
  10.          <dependency>
  11.              <groupId>com.alibaba</groupId>
  12.              <artifactId>druid</artifactId>
  13.              <version>1.1.12</version>
  14.          </dependency>
  15.      </dependencies>

2.4 MyBatis

  • Mybatis 是一款优秀的持久层框架，用于简化 JDBC开发，它支持定制化 SQL、存储过程以及高级映射。

    • 持久层就是负责将数据保存到数据库的那一层代码。

    • JavaEE三层架构：表现层、业务层、持久层。

    • 表现层:页面展示的。

    • 业务层：使用来做逻辑处理的。

  • MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。

  • 英文网

  • 中文网

  • mybatis-spring

2.4.1 MyBatis快速入门

pom.xml内容

  1.  <?xml version="1.0" encoding="UTF-8"?>
  2.  <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.      <modelVersion>4.0.0</modelVersion>
  6.  ​
  7.  ​
  8.      <!--当前项目的坐标-->
  9.      <groupId>com.itlaity</groupId>
  10.      <artifactId>maven-demo</artifactId>
  11.      <version>1.0-SNAPSHOT</version>
  12.  ​
  13.      <properties>
  14.          <maven.compiler.source>8</maven.compiler.source>
  15.          <maven.compiler.target>8</maven.compiler.target>
  16.      </properties>
  17.  ​
  18.      <!--导入mysql 驱动 jar包-->
  19.      <dependencies>
  20.          <dependency>
  21.              <groupId>mysql</groupId>
  22.              <artifactId>mysql-connector-java</artifactId>
  23.              <version>5.1.48</version>
  24.          </dependency>
  25.  ​
  26.          <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
  27.          <dependency>
  28.              <groupId>com.alibaba</groupId>
  29.              <artifactId>druid</artifactId>
  30.              <version>1.1.12</version>
  31.          </dependency>
  32.          <!--单元测试的坐标-->
  33.          <dependency>
  34.              <groupId>junit</groupId>
  35.              <artifactId>junit</artifactId>
  36.              <version>4.13</version>
  37.              <scope>test</scope>
  38.          </dependency>
  39.          <!-- mybatis 依赖 -->
  40.          <dependency>
  41.              <groupId>org.mybatis</groupId>
  42.              <artifactId>mybatis</artifactId>
  43.              <version>3.5.5</version>
  44.          </dependency>
  45.  ​
  46.          <!-- 添加日志支持 -->
  47.          <!-- log4j日志系统 -->
  48.          <dependency>
  49.              <groupId>log4j</groupId>
  50.              <artifactId>log4j</artifactId>
  51.              <version>1.2.17</version>
  52.          </dependency>
  53.          <!-- simple logg facade for java（slf4-api.jar）日志接口 和 log4j具体日志系统之间的适配器 -->
  54.          <dependency>
  55.              <groupId>org.slf4j</groupId>
  56.              <artifactId>slf4j-api</artifactId>
  57.              <version>1.7.20</version>
  58.          </dependency>
  59.          <!-- 添加logback-classic依赖 -->
  60.          <dependency>
  61.              <groupId>ch.qos.logback</groupId>
  62.              <artifactId>logback-classic</artifactId>
  63.              <version>1.2.3</version>
  64.          </dependency>
  65.  ​
  66.          <!-- 安装logback-core 依赖-->
  67.          <dependency>
  68.              <groupId>ch.qos.logback</groupId>
  69.              <artifactId>logback-core</artifactId>
  70.              <version>1.2.3</version>
  71.          </dependency>
  72.      </dependencies>
  73.  </project>

放到src/main/resources/ 的日志配置文件logback.xml

  1.  <?xml version="1.0" encoding="UTF-8"?>
  2.  <!-- 级别从高到低 OFF 、 FATAL 、 ERROR 、 WARN 、 INFO 、 DEBUG 、 TRACE 、 ALL -->
  3.  <!-- 日志输出规则 根据当前ROOT 级别，日志输出时，级别高于root默认的级别时 会输出 -->
  4.  <!-- 以下 每个配置的 filter 是过滤掉输出文件里面，会出现高级别文件，依然出现低级别的日志信息，通过filter 过滤只记录本级别的日志 -->
  5.  <!-- scan 当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。 -->
  6.  <!-- scanPeriod 设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
  7.  <!-- debug 当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
  8.  <configuration scan="true" scanPeriod="60 seconds"
  9.      debug="false">
  10.      <!-- 动态日志级别 -->
  11.      <jmxConfigurator />
  12.      <!-- 定义日志文件 输出位置 -->
  13.      <property name="log_dir" value="../logs" />
  14.      <!-- <property name="log_dir" value="/home/data/logs/src" /> -->
  15.      <!-- 日志最大的历史 30天 -->
  16.      <property name="maxHistory" value="30" />
  17.      <!-- ConsoleAppender 控制台输出日志 -->
  18.      <appender name="console"    class="ch.qos.logback.core.ConsoleAppender">
  19.          <encoder>
  20.              <pattern>
  21.                  <!-- 设置日志输出格式 -->
  22.                  [%d{yyyy-MM-dd HH:mm:ss.SSS}][%logger:%line]%-5level -- %msg%n
  23.              </pattern>
  24.          </encoder>
  25.      </appender>
  26.  ​
  27.      <logger name="com.itlaity" level="DEBUG" additivity="false">
  28.          <appender-ref ref="console"/>
  29.      </logger>
  30.  ​
  31.      <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 RollingFileAppender -->
  32.      <appender name="file"   class="ch.qos.logback.core.rolling.RollingFileAppender">
  33.          <!-- 过滤器，只记录WARN级别的日志 -->
  34.          <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
  35.              <level>ERROR,INFO,WARN,DEBUG</level>
  36.          </filter>
  37.          <!-- 最常用的滚动策略，它根据时间来制定滚动策略.既负责滚动也负责出发滚动 -->
  38.          <rollingPolicy  class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  39.              <!--日志输出位置 可相对、和绝对路径 -->
  40.              <fileNamePattern>
  41.                  ${log_dir}/%d{yyyy-MM-dd}/logback.log
  42.              </fileNamePattern>
  43.              <maxHistory>${maxHistory}</maxHistory>
  44.          </rollingPolicy>
  45.          <encoder>
  46.              <pattern>
  47.                  <!-- 设置日志输出格式 -->
  48.                  [%d{yyyy-MM-dd HH:mm:ss.SSS}][%logger:%line]%-5level -- %msg%n
  49.              </pattern>
  50.          </encoder>
  51.      </appender>
  52.      <root>
  53.          <!-- 打印TRACE级别日志及以上级别日志 -->
  54.          <level value="DEBUG" />
  55.          <!-- 控制台输出 -->
  56.          <appender-ref ref="console" />
  57.          <!-- 文件输出 -->
  58.          <appender-ref ref="file" />
  59.      </root>
  60.  </configuration>

彩色日志bogback.xml(了解)

  1.  <?xml version="1.0" encoding="UTF-8"?>
  2.  <configuration scan="true" scanPeriod="60 seconds" debug="false">
  3.      <property name="APP_NAME" value="MY_APP_NAME" />
  4.      <property name="LOG_DIR" value="logs" />
  5.      <property name="FILE_LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS}  %-5level [%thread] %logger{15} - %msg%n" />
  6.      <!-- 彩色日志格式 -->
  7.      <property name="CONSOLE_LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} %highlight(%-5level) %boldYellow([%thread])  %cyan(%logger{15}) %msg%n"/>
  8.   
  9.      <contextName>${APP_NAME}</contextName>
  10.   
  11.      <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
  12.          <encoder>
  13.              <pattern>${CONSOLE_LOG_PATTERN}</pattern>
  14.          </encoder>
  15.      </appender>
  16.   
  17.      <appender name="FILE" class="ch.qos.logback.core.FileAppender">
  18.          <file>${LOG_DIR}/logFile.log</file>
  19.          <append>true</append>
  20.          <encoder>
  21.              <pattern>${FILE_LOG_PATTERN}</pattern>
  22.          </encoder>
  23.      </appender>
  24.   
  25.      <appender name="RollingFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
  26.          <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  27.              <fileNamePattern>${LOG_DIR}/dayLogFile.%d{yyyy-MM-dd}.log</fileNamePattern>
  28.              <maxHistory>30</maxHistory>
  29.          </rollingPolicy>
  30.          <encoder>
  31.              <pattern>${FILE_LOG_PATTERN}</pattern>
  32.          </encoder>
  33.      </appender>
  34.   
  35.      <!-- 使用root的appender-ref -->
  36.      <logger name="com.example.Logger1" level="DEBUG" additivity="true">
  37.      </logger>
  38.   
  39.      <!-- 不使用root的appender-ref -->
  40.      <logger name="com.example.Logger2" level="DEBUG" additivity="false">
  41.      </logger>
  42.   
  43.      <logger name="com.example.Logger3" level="DEBUG" additivity="false">
  44.          <appender-ref ref="STDOUT"/>
  45.      </logger>
  46.   
  47.      <root level="DEBUG">
  48.          <appender-ref ref="STDOUT" />
  49.          <appender-ref ref="FILE" />
  50.          <appender-ref ref="RollingFile" />
  51.      </root>
  52.  </configuration>

放到src/main/resources/ 的mybatis-config.xml

  1.  <?xml version="1.0" encoding="UTF-8" ?>
  2.  <!DOCTYPE configuration
  3.          PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.          "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5.  <configuration>
  6.      <environments default="development">
  7.          <environment id="development">
  8.              <transactionManager type="JDBC"/>
  9.              <dataSource type="POOLED">
  10.                  <!--数据库连接信息-->
  11.                  <property name="driver" value="com.mysql.jdbc.Driver"/>
  12.                  <property name="url" value="jdbc:mysql:///java?useSSL=false"/>
  13.                  <property name="username" value="root"/>
  14.                  <property name="password" value="wang9264"/>
  15.              </dataSource>
  16.          </environment>
  17.      </environments>
  18.      <mappers>
  19.          <!--加载sql映射文件  自建-->
  20.          <mapper resource="UserMapper.xml"/>
  21.      </mappers>
  22.  </configuration>

放到src/main/resources/ 的映射的 SQL 语句文件

注意文件名称一定是有标识性的 例如：对用户表进行操作 UserMapper.xml等

  1.  <?xml version="1.0" encoding="UTF-8" ?>
  2.  <!DOCTYPE mapper
  3.          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5.  ​
  6.  <!--
  7.  namespace:名称空间
  8.  resultType:对应你建立的包名
  9.  id：唯一标识不能重复
  10.  -->
  11.  <mapper namespace="test">
  12.      <select id="selectAll" resultType="com.itlaity.pojo.User">
  13.          select * from mybatis_user;
  14.      </select>
  15.  </mapper>

开始写代码src\main\java\com\itlaity\pojo\User.java

  1.  package com.itlaity.pojo;
  2.  ​
  3.  /**
  4.   * @author : Laity
  5.   * @Project: JavaLaity
  6.   * @Package com.itlaity
  7.   * @date Date : 2021年12月12日 1:37
  8.   * @Description: 实体类
  9.   */
  10.  ​
  11.  // 按住atl+鼠标左键 整列编辑
  12.  public class User {
  13.      private Integer id;
  14.      private String username;
  15.      private String password;
  16.      private char gender;
  17.      private String addr;
  18.  ​
  19.      // 添加get和set方法
  20.  ​
  21.      /**
  22.       * 在java中，为了保证数据的安全性，
  23.       * 我们会把数据定义为private等（私有、封装），
  24.       * 如果想要调用就会用到set()方法与get方法或者构造函数方法。
  25.       * 这里说的是第一种方法，set()与get()
  26.       */
  27.      public Integer getId() {
  28.          return id;
  29.      }
  30.  ​
  31.      public void setId(Integer id) {
  32.          this.id = id;
  33.      }
  34.  ​
  35.      public String getUsername() {
  36.          return username;
  37.      }
  38.  ​
  39.      public void setUsername(String username) {
  40.          this.username = username;
  41.      }
  42.  ​
  43.      public String getPassword() {
  44.          return password;
  45.      }
  46.  ​
  47.      public void setPassword(String password) {
  48.          this.password = password;
  49.      }
  50.  ​
  51.      public char getGender() {
  52.          return gender;
  53.      }
  54.  ​
  55.      public void setGender(char gender) {
  56.          this.gender = gender;
  57.      }
  58.  ​
  59.      public String getAddr() {
  60.          return addr;
  61.      }
  62.  ​
  63.      public void setAddr(String addr) {
  64.          this.addr = addr;
  65.      }
  66.  ​
  67.      @Override
  68.      public String toString() {
  69.          return "User{" +
  70.                  "id=" + id +
  71.                  ", username='" + username + '\'' +
  72.                  ", password='" + password + '\'' +
  73.                  ", gender=" + gender +
  74.                  ", addr='" + addr + '\'' +
  75.                  '}';
  76.      }
  77.  }

测试类src\main\java\com\itlaity\MyBatisDemo.java

  1.  package com.itlaity;
  2.  ​
  3.  import com.itlaity.pojo.User;
  4.  import org.apache.ibatis.io.Resources;
  5.  import org.apache.ibatis.session.SqlSession;
  6.  import org.apache.ibatis.session.SqlSessionFactory;
  7.  import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  8.  ​
  9.  import java.io.InputStream;
  10.  import java.util.List;
  11.  ​
  12.  /**
  13.   * @author : Laity
  14.   * @Project: JavaLaity
  15.   * @Package com.itlaity
  16.   * @date Date : 2021年12月12日 1:55
  17.   * @Description: 测试类
  18.   */
  19.  public class MyBatisDemo {
  20.      public static void main(String[] args) throws Exception {
  21.          // 1. 加载mybatis的核心配置文件，获取 SqlSessionFactory类的对象
  22.          String resource = "mybatis-config.xml";
  23.          // 返回字节输入流
  24.          InputStream inputStream = Resources.getResourceAsStream(resource);
  25.          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  26.  ​
  27.          // 2. 获取 SqlSession对象 执行sql语句
  28.          SqlSession sqlSession = sqlSessionFactory.openSession();
  29.  ​
  30.          // 3. 执行sql
  31.          List<User> users = sqlSession.selectList("test.selectAll");
  32.  ​
  33.          System.out.println(users);
  34.  ​
  35.          // 释放资源
  36.          sqlSession.close();
  37.      }
  38.  }

如果你认为麻烦

同学我送你一句话: 今朝有酒，今朝醉。明日愁来，明日愁。

2.4.2 Mapper代理开发

  • 解决原生方法中的硬编码

  • 简化后期执行SQL

设置SQL映射文件的namespace

  • 定义一个与sql映射文件同名的mapper接口，并且将Mapper接口和sql映射文件放置在同一目录下(创建目录用 / 来创建)

  • 属性为Mapper接口权限定名

  • 在mapper接口中定义方法，方法名就是SQL映射文件中sql语句的id，并保持参数类型和返回值类型一致

    •  List<User> selectAll();

  • 编码

    • 通过SqlSession的getMapper方法获取 Mapper接口的代理对象

    • 调用对应方法完成sql执行

  1.  <?xml version="1.0" encoding="UTF-8" ?>
  2.  <!DOCTYPE mapper
  3.          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5.  ​
  6.  <!--
  7.  namespace:名称空间
  8.  resultType:对应你建立的包名
  9.  id：唯一标识不能重复
  10.  -->
  11.  <!--设置SQL映射文件的namespace属性为Mapper接口权限定名-->
  12.  <mapper namespace="com.itlaity.mapper.UserMapper">
  13.      <select id="selectAll" resultType="com.itlaity.pojo.User">
  14.          select *
  15.          from mybatis_user;
  16.      </select>
  17.  </mapper>

2.4.3 特殊字符处理

  1.  // 在编写sql语句中
  2.  参数占位符
  3.      1.#{} ：执行sql时，会将#{}占位符替换成 ？，将来自动设置参数值
  4.      2.${} ：拼sql，会存在sql注入问题。
  5.  ​
  6.  parameterType：
  7.      用于设置参数类型，该参数可以省略。
  8.      
  9.  < 是写不了的 怎么解决呢
  10.      1.转义字符
  11.      2.CDATA区

2.4.4 注解完成增删改查

  • 增（insert）

    • 注意默认开启事务:需要手动提交事务 sqlSession.commit();

    • 或者在获取 SqlSession时 添加参数 true

    • 主键返回：在数据添加成功后，需要获取插入数据库的主键的值

    • 只需在sql语句中参加两个属性: useGeneratedKeys 和 KeyProperty

    • 返回结果 void

  • 修改（updata）

    • 修改全部字段 上面的JDBC就已经学过

    • 修改动态字段 书写动态SQL语句

      • <set><if></if> where id = #{id}</set>

  • 删除（delete）

    • 删除一个

      • delete from 表 where id = #{id}

    • 删除多个

      •  void deleteByids(@Param("ids") int[] ids)  // @Param("ids")注解改变map集合的默认key的名称

      • delete from 表 where id in <foreach collection="ids" item="id" separator="," open="("  close=")">  #{id} </foreach>

  • 结论 ：大多数参数都封装为Map集合，可以使用@Param 注解，替换Map集合中默认的arg键名 param键名。

2.4.5 动态SQL

  1.  // 在编写sql语句中（多条件查询）
  2.  动态sql(搜索添加一个需要三个参数，但用户只输入1个参数)
  3.      1.我们需加条件判断即可
  4.      2.<if test="参数 != null and 参数!= '' "> 执行要求参数 </if>
  5.      3.问题: 第一个条件不需要逻辑运算符
  6.          1. 解决方案 ：恒等式 1=1/ <where> 替换 where 关键字
  7.  // 单条件查询
  8.  <choose> <!--相当于 switch--> 
  9.      <when> <!--相当于 case-->
  10.      </when>
  11.      <otherwise><!--default-->
  12.          1 = 1    
  13.      </otherwise>
  14.  </choose>

2.4.6 注解开发

  • 查询：@Select

  • 添加：@Insert

  • 修改：@Updata

  • 删除：@Delete

  • 提示：注解完成简单功能，配置文件完成复杂功能。

  1.  // 在maaper接口中写
  2.  @select("sql语句")
  3.  User selectById();
  4.  // UserMapper.xml中就不需要写了

​​​​​​接JavaEE入门级别最全教程1--初学者必看


接JavaEE入门级别最全教程2--初学者必看

接JavaEE入门级别最全教程3--初学者必看

JavaWeb结束之后会学习基础的HTML等等  这里的技术栈J哥以前就发表过文章

也可以看我的另一个博客

感谢大家的观看！！！

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号