JavaWeb学习笔记

JavaWeb

• Web： world wide web，全球广域网，也称万维网
• javaWeb：是用java技术来解决web互联网领域的技术栈

JavaWeb网站的工作原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j8gYOt2n-1657806743189)(C:\Users\Admin\AppData\Roaming\Typora\typora-user-images\1655897277412.png)]

核心技术栈：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b7pTKckW-1657806743190)(C:\Users\Admin\AppData\Roaming\Typora\typora-user-images\1655897423573.png)]

//起始索引
Declare @pageNum,@counts
select * from tb_name limit (@pageNum -1)*@counts,@pageNum*@counts

---

SQL数据库（略）

JDBC

//1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2、获取连接对象
String url = "jdbc:mysql://127.0.0.1:3306/db1?useSSL=false";
String username = "root";
String password = "1234";
Connection connection = DriverManager.getConnection(url,username,password);
//3、定义SQL
String sql = "update account set money = 2000 where id = 1";
//4、获取执行sql的对象
Statement statement = connection.createStatement();
//5、执行sql
int count = statement.executeUpdate(sql);
//6、处理结果
//System.out.println(count);
//7、释放资源
statement.close();
connection.close();

JDBC概念：

• JDBK就是使用Java语言操作关系型数据库的一套API
• 全称：（Java DataBase Connectivity） Java数据库连接

JDBC本质：

• 官方（sun公司）定义的一套操作所有关系型数据库的规则，既接口
• 各个数据库厂商去实现这套借口，提供数据库驱动jar包
• 我们可以使用这套借口（JDBC）变成，真正执行的代码是驱动jar包中的实现类

JDBC好处：

• 各数据库厂商使用相同的接口，java代码不需要针对不同数据库分别开发
• 可随时替换底层数据库，访问数据库的java代码基本不变

1、注册驱动

Class.forNama("com.mysql.jdbc.Driver");

2、获取连接

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

3、定义sql语句

String sql = "Update account set balance = balance + 10000000";

4、获取执行SQL对象

Statement statement = connection.createStatement();

5、执行sql语句

int i = statement.executeUpdate(sql);//返回受影响的行数

6、释放资源

//先创建的后释放，根据依赖程度释放，最轻依赖的最先释放，最重依赖的最后释放
statement.close();
connection.close();

先实例化驱动对象Class.forName(“com.mysql.jdbc.DriverManager”);

创建连接信息Connection connection =DriverManager.getConnection(url,username,password);

创建sql语句String sql = “要执行的sql语句”;

//SQL执行对象由连接对象connection创建

创建SQL执行对象Statement statement = connection.CreateStatement();

执行sql语句：statement.executeUpdate(sql);

返回处理结果

释放资源:statement.close(); connection.close();

JDBC API详解

• DriverManager
• Connection
• Statement
• ResultSet
• PreparedStatement

DriverManager

• DriverManager（驱动管理类）作用：

  • 注册驱动

    • //此处使用反射创建了一个Driver类
      //初始化Driver时，会根据Driver中的静态代码块，注册驱动类
      Class.forName("com.mysql.jdbc.Driver");
      
      //Driver类
      public class Driver extends NonRegisteringDriver implements java.sql.Driver{
               
          public Driver throws SQLException{
               
              
          }
          //静态代码块，当类初始化时执行
          Static{
               
          try{
               
              //通过DriverManager类中的registerDriver()方法来注册驱动
              DriverManager.registerDriver(new Driver());
          }catch(SQLException var1){
               
              throw new RuntimeException("Can't register driver");
              
          }
      }
      }
      

    • 提示

      • MySQL 5之后的驱动包，可以省略注册驱动的步骤(即class.forName(“com.mysql.jdbc.Driver”))
      • 自动加载jar包中META-INF/services/java.sql.Driver文件中的驱动类

  • 获取数据库连接

    • //static Connection
      //getConnection(String url,String username,String password);
      //语法：jdbc:mysql://ip地址:端口号/数据库名?参数值对1&参数值对...
      //示例:jdbc:mysql://127.0.0.1:3306/db1?useSSL=false
      //细节：
      //	  如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：
      //		jdbc:mysql:///数据库名?参数值对1&参数值对2...
      //	  配置useSSL=false参数，禁用安全连接方式，解决警告提示
      

    • user:用户名

    • password：密码

Connection

• Connection（数据库连接对象）作用：

  • 获取执行SQL的对象

    • 普通执行SQL对象

      • Statement cteateStatement()
        

    • 预编译SQL的执行SQL对象：防止SQL注入

      • PreparedStatement prepareStatement(sql)
        

    • 执行存储过程的对象

      • CallableStatemtn prepareCall(sql)
        

  • 管理事务

    • MySQL事务管理

      • //开启事务：BEGIN：/START TRANSACTION;
        //提交事务：COMMIT;
        //回滚事务：ROLLBACK;
        MySQL默认自动提交事务
        

    • JDBC事务管理：Connection接口中定义了3个对应的方法

      • //boolean autoCommit:true为自动提交事务；false为手动提交事务，即为开启事务
        //开启事务：setAutoCommit(boolean autoCommit)
        //提交事务：commit()
        //回滚事务：rollback()
        

    class.forName("com.mysql.jdbc.Driver");
    String url = "jdbc:mysql://localhost:3306/db_name?useSSL=false";
    String username = "root";
    String password = "1234"
    Connection connection = DriverManager.getConnection(url,username,password);
    String sql1 = "select * from tb_name where name = '张三'";
    String sql2 = "Update tb_name set name = '李四' where id = 1"
    Statement statement = connection.CreateStatement();
    try{
           
        //开启事务,false开启事务
        connection.setAutoCommit(false);
        //count1、count2分别接收sql1执行对象、sql2执行对象返回的影响行数
        int count1 = statement.executeUpdate(sql1);
        int count2 = statement.executeUpdate(sql2);
        //处理结果
        System.out.println(count1);
        System.out.println(count2);
    }catch(Exception throwables){
           
        connection.rollback();
    }
    
    //提交事务
    
    //释放资源,先创建的后释放，解耦操作
    statement.close();
    connection.close();
    

Statement

• Statement作用：

  • 执行SQL语句

    • int executeUpdate(sql);//执行DML、DDL语句
      //返回值：（1）DML语句影响的行数 （2）DDL语句执行后，执行成功也
      /*注：
          DML(Database Manipulation Language) 数据操作语句
          DDL(Database Definition Language)	数据定义语句
          DQL(Database Query Language) 数据查询语句
      */
      

    • ResultSet executeQuery(sql);//执行DQL语句
      //返回值：ResultSet结果集对象
      

  public class JDBCDemo04_Statement{
       
      /*
      	执行DML语句
      */
      @Test
      public void testDML(){
       
          Class.forName("com.mysql.jdbc.Driver");
          String url ="mysql:jdbc://localhost:3306/db_name?useSSL=false";
          String username = "root";
          String password = "1234";
          Connection connection = DriverManager.getConnection(url,username,password);
          Statement statement = connection.createStatement();
          String sql1 ="update account set money = 2000 where id =1";
          String sql2 ="";
          try{
       
              //开启事务
              connection.setAutoCommit(false);
              int count1 = statement.executeUpdate(sql1);
              int count2 = statement.executeUpdate(sql2);
              //System.out.println(count1);
              //System.out.println(count2);
              if(count1 > 0){
       //DML语句结果判断,DDL时无需判断大于0
                  System.out.println("修改成功");
              }else{
       
                  System.out.println("修改失败");
              }
              connection.commit();   
          }catch(Exception SQLExceptions){
       
              statement.executeUpdate();
          //提交事务
          	connection.rollback();
          }
          
     }
  }
  

ResultSet

• ResultSet（结果集对象）作用

  • 封装了DQL查询语句的结果

    • //执行DQL语句，返回ResultSet对象
      ResultSet statement.executeQuery(sql);
      

  • 获取查询结果

    • //将光标从当前位置向前移动一行
      //判断当前行是否为有效行
      boolean next();
      //返回值true：有效行，当前行有数据
      //返回值false：无效行，当前行没有数据
      

    • //获取数据
      //xxx getXxx(参数)
      //xxx:数据类型；如：int getInt(参数);String getString(参数)
      /*参数：
      	  int :列的编号，从1开始
      	  String：列的名称
      	  例如：一张表字段为 id,name,money
      	  此时执行:resultSet.next();光标从结果集第一行下移一行，指向数据行第一行
      	  result.getInt(1);  //获取第一行的第一列的数据
      	  result.getString(2);//获取第一行的第二列的数据
      	  result.getDouble(3);//获取第一行的第三列数据
      
      */
      

    • //循环判断游标是否是最后一行末尾
      while(resultSet.next()){
               
          //获取数据
          //resultSet.getXxx(参数);
      }
      

  public class JDBCDemo_ResultSet{
       
      /*
      	ResultAPI
      	执行DQL语句
      */
      @test
      public void testDQL() throuws Exception{
       
          ClassForname("com.mysql.jdbc.Driver");
          String url = "jdbc:mysql://localhost:3306/db_name?useSSL=false";
          String username = "root";
          String password = "1234";
          Connection connection = DriverManager.getConnection(url,username,password);
          Statement statement = connection.createStatement();
          String sql = "select * from account";
          
          try{
       
              connection.setAutoCommit(false);
              ResultSet resultSet = statement.executeQuery(sql);
              while(rs.next()){
       
                  //获取数据 getXxx()
                  
                  int id = resultSet.getInt(1);
                  //通过列名获取id：int id =resultSet.getInt("id");
                  
                  String name = resultSet.getString(2);
                  //通过列名获取name：String name = resultSet.getString("name");
                  
                  double money = resultSet.getDouble(3);
                  //通过列名获取money：Double money = resultSet.getDouble("money");
                  
                  System.out.println(id);
                  System.out.println(name);
                  System.out.println(money);
              }
              connection.commit();
          }catch(Exception DQLExceptions){
       
              connection.rollback();
          }
          resultSet.close();  //最后创建最后释放
          statement.close();  
          connection.close(); //最先创建最后释放
          
      }
  }
  

ResultSet案列

• 需求：查询account账户表数据，封装为Account对象中，并且存储到ArrayList集合中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yRxB54Rk-1657806743191)(C:\Users\Admin\AppData\Roaming\Typora\typora-user-images\1655913297640.png)]

//创建一个实体类，用于接收account中每条记录的数据，封装成为一个对象
public class Account{
   
    private int id;
    private String name;
    private double money;
    account(){
   
        
    }
    //id的get/set方法
    public void getId(){
   
        return id;
    }
    public void setId(int id){
   
        this.id = id;
    }
    //name的get/set方法
    public void getName(){
   
        return name;
    }
    public void setName(String name){
   
        this.name = name;
    }
    //money的get/set方法
    public void getMoney(){
   
        return money;
    }
    public void setMoney(double money){
   
        this.money = money;
    }
    //重写toString()方法，为了方便输出查看account独享
    @Override
    public String toString(){
   
        return "Account{" +
            "id=" + id +
            ",name=" + name +
            ",money=" + money +
            "}";
    }
}


//将account对象存入ArrayList集合中
public class JDBC_Demo{
   
    public void testJDBC() throuws Exception{
   
        Class.forName("com.mysql.jdbc.Driver");
        String url = "jdbc:mysql://localhost:3306/db_name?useSSL=false";
        String username = "root";
        String password = "1234";
        Connection connection = DriverManager.getConnection(url,username,password);
        Statement statement = connection.createStatement();
        String sql = "select * from account";
        try{
   
            connection.setAutoCommit(false);
            ResultSet resultSet = Statement.executeQuery(sql);
        	List<Account> list = new ArrayList<>();
            Account account = new Account();
            int id;
            String name;
            double money;
            while(resultSet.next()){
   
                id = resultSet.getInt("id");
                name = resultSet.getString("name");
                money = resultSet.getDouble("money");
                account.setId(id);
                account.setName(name);
                account.setMoney(money);
                list.add(account);
            }
            
        }catch(Exception JDBCException){
   
            connection.rollback;
        }
        resultSet.close();
        statement.close();
        connection.close();
    }
}

PreparedStatement

• 继承于Statement

• PreparedStatement作用：

  • 预编译SQL语句并执行：预防SQL注入问题

• SQL注入

  • SQL注入是通过操作输入来修改实现定义好的SQL语句，用以达到执行代码对服务器进行攻击的方法。

• 获取PreparedStatement对象

  • //SQL语句中的参数值，使用？占位符替代
    String sql = "select * from user where username = ? and password = ?";
    
    //通过Connection对象获取，并传入对应的sql语句
    //connection.preparedStatement(sql);
    PreparedStatement ps = connection.prepareStatement(sql);
    

• 设置参数值

  • /*
    PreparedStatement对象:setXxx(参数1，参数2)：给？赋值
    Xxx：数据类型；如setInt（参数1，参数2）
    参数：
    	参数1： ？的位置编号，从1开始
    	参数2： ？的值
    */
    

• 执行SQL

  • executeUpdate();//executeQuery():不需要再传递sql
    

//根据前端登录页面接收的数据进行数据库操作
//id username password
public class JDBCPreparedStatement_Demo{
   
    public void testJDBC() throuws Exception{
   
        Class.forName("com.mysql.jdbc.Driver");
        String url = "mysql:jdbc://localhost:3306/db_name?useSSL=false";
        String username = "root";
        String password = "1234";
        Connection connection = DriverManager.getConnection(url,username,password);
        
        //接收用户输入的用户名和密码
        String name = "zhangsan";
        String pwd = "123456";
        
        //创建查询语句
        //使用statement执行对象，需要进行字符串拼接，容易被SQL注入
        //String sql = "select * from tb_user where username = "+ name 
        //    			+" and password = "+ pwd;
        
        //创建查询语句
        //使用PreparedStatement执行对象，不用字符串拼接，使用问号占位符，不容易被SQL注入
  		String sql = "select * from tb_user where username = ? and password = ?";
        
        //因为是预编译SQL执行对象，在创建时需要将SQL语句传递给该对象
        PreparedStatement ps = connection.prepareStatement(sql);
        //设置问号占位符的取值
        //向第一个问号传递String类型的变量name
        ps.setString(1,name);
        //向第二个问号传递String类型的变量pwd
        ps.setString(2,pwd);
        try{
   
            connection.setAutoCommit(false);
            //因为PreparedStatement对象已经预编译了sql语句，因此不必再传递sql语句
            ResultSet resultSet = ps.executeQuery();
            if(resultSet.next()){
   
                System.out.println("登陆成功");
            }else{
   
                System.out.println("登陆失败"); 
            }
            connection.commit();
        }catch(Exception e){
   
            connection.rollback();
        }
        resultSet.close();
        preparedStetement.close();
        connection.close();
    }
}

• PreparedStatement原理

  • 预编译SQL，性能更好
  • 防止SQL注入：将敏感字符进行转义
  • 1、在获取PreparedStatement对象时，将sql语句发送给mysql服务器进行检查、编译(这些步骤很耗时)
  • 2、执行时就不用再进行这些步骤了，速度更快
  • 3、如果sql模板一样，则只需要进行一次检查、编译

• PreparedStatement预编译功能开启：useServerPrepStmts=true

• 配置MySQL执行日志(重启mysql服务后生效)

  • #以下内容为mysql的配置信息，添加到my.ini,重启mysql服务即可
    log-output-FILE
    general-log=1
    general_log_file="D:\mysql.log"
    slow-query-log=1
    slow_query_log_file="D:\mysql_slow.log"
    long_query_time=2
    

• public class JDBCPreparedStatement_Demo2{
       
      public void testJDBC() throuws Exception{
       
          Class.forName("com.mysql.jdbc.Driver");
          String url = "jdbc:mysql://localhost:3306/db_name?"+
                          "useSSL=false&useServerPrepStmts=true";
          String username = "root";
          String password = "1234";
          Connection connection = DriverManager.getConnection(url,username,password);
          String sql = "select * from account where name = ?";
          PreparedStatement ps = connection.prepareStatement(sql);
          ps.setString(1,"zhangsan");
          try{
       
              connection.setAutoCommit(false);
              ResultSet resultSet = ps.executeQuery();
              connection.commit();
              if(resultSet.next()){
       
                System.out.println("查询成功");  
              }else{
       
                 System.out.println("查询失败");
              }
          }catch(Exception e1){
       
              connection.rollback();
          }
          resultSet.close();
          ps.close();
          connection.close();
      }
  }
  

数据库连接池

• 数据库连接池简介

  • 数据库连接池是个容器，负责分配、管理数据库连接（Connection）

  • 它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个

  • 释放空闲空间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏

  • 优点：

    • 资源重用
    • 提升系统响应速度
    • 避免数据库连接遗漏

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VoVJlnq9-1657806743191)(C:\Users\Admin\AppData\Roaming\Typora\typora-user-images\1655950463667.png)]

• Druid数据库连接池

• 数据库连接池实现

  • 标准接口：DataSource

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

    • 功能：获取连接

    • Connection getConnection()
      

  • 常见的数据库连接池

    • DBCP
    • C3P0
    • Druid

  • Druid（德鲁伊）

    • Druid连接池是阿里巴巴开源的数据库连接池项目
    • 功能强大， 性能优秀，是Java语言最好的数据库连接池之一

• Druid使用步骤

  • 1、导入jar包druid-1.1.12.jar
  • 2、定义配置文件
  • 3、加载配置文件
  • 4、获取数据库连接池对象
  • 5、获取连接

public class DruidDemo{
   
    /*
    	Druid数据库连接池演示
    	使用
    		System.out.println(System.getProperty("user.dir"));
    	打印当前了路径
    */
    public static void main(Sring[] args) throws Exception{
   
        
       //1.导入jar包
       //2.定义配置文件
       //3.加载配置文件
        Properties prop = new Properties();
        prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
       //4.获取数据库连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
            
       //5.获取连接
        Connection connection = dataSource.getConnection();
        
        //打印Druid连接对象，查看是否连接成功
        //System.out.println(connection);
        
    }
}

driverClassName = com.mysql.jdbc.Driver
url = jdbc:mysql://localhost/db_name?useSSL=false&useServerPrepStmt=true
username=root
password=1234
#初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
#最大等待时间
maxWait=3000

练习

• 完成商品品牌数据的增删改查操作

  • 查询：查询所有数据
  • 添加：添加品牌
  • 修改：根据id修改
  • 删除：根据id删除

  准备环境：

  • 数据库表tb_brand
  • 实体类Brand
  • 测试用例

练习1，查询数据并打印

• 创建一张表tb_brand

  • #创建一张表
    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(brand_name,company_name,ordered,description,status)
    	values('三只松鼠','三只松鼠股份有限公司',5,'好吃不上火'),
    		  ('华为','华为技术有限公司',100,'华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界',1),
    		  ('小米','小米科技有限公司',50,'are you ok',1);
    #查看是否成功
    select * from tb_brand
    

• 创建一个properties配置文件

  • #druid.properties
    driverClassName=com.mysql.cj.jdbc.Driver
    url=jdbc:mysql//localhost:3306/test?useSSL=false&useServerPreStmt=true
    username=root
    password=123456
    #初始化连接数量
    initialSize=5
    #最大连接数量
    maxActive=10
    #最大等待时间
    maxWait=3000
    

• 给Brand表创建一个实体类

  • public class Brand{
           
        private Integer id;
        private String brandName;
        private String companyName;
        private Integer ordered;
        private String description;
        private Integer status;
        //set/get方法
        public void setId(int id){
           this.id=id;    }
        public Int getId(){
           return id;}
        public void setBrandName(String brandName){
              this.brandName = brandName;    }
        public String getBrandName(){
                   return brandName;    }
        public void setCompanyName(String companyName){
            this.companyName=companyName;}
        public String getCompanyName(){
           return companyName;}
        public void setOrdered(int ordered){
           this.ordered = ordered'}
        public int getOrdered(){
            return ordered;}
        public void setDescription(String description){
           this.description=description;}
        public String getDescription(){
            return description; }
        public void setStatus(int status){
           this.status=status; }
        public int getStatus(){
           return status; }
        //重写toString()方法
        @Override
        public String toString(){
           
            return "Brand{" +
                "brandName=" + brandName + '\'' +
                ",companyName=" + companyName + '\'' +
                ",ordered=" + ordered +
                ",description='" + description + '\'' +
                "'status='" + status +
                '}';
        }
    }
    

• 创建一个类，专门用来加载数据库

  • public class DBConfig{
           
        Properties properties = new Properties();
        properties.load(new FileInputStream("src/com/example/druid.properties"));
    }
    

• 创建一个BrandTest类，增加一个selectAllBrand方法

  • public class BrandTest{
           
        
        public void selectAllBrand(){
           
            //加载配置文件
            Properties properties = new Properties();
            properties.load(new FileInputStream("src/com/example/druid.properties"));
            //读取配置文件并创建dataSource
            DataSource dataSource =
                	DruidDataSourceFactory.createDataSource(properties);
            //由dataSource创建connection
            Connection connection = dataSource.getConnection();
            //创建sql语句
            String sql = "select * from tb_brand";
            
            //由connection创建prepStmtSQL执行对象
            //并对sql语句进行预编译
            PreparedStatement ps = connection.prepareStatement(sql);
            
            ResultSet resultSet = ps.executeQuery();
            ArrayList<Brand> list = new ArrayList<>();
            Brand brand = new Brand();
            //定义几个基本类型的参数用于接收字段数据
            int id;
            String brandName;
            String companyname;
            int ordered;
            String description;
            int status;
            
            while(rs.next()){
           
                brand.setId(rs.getInt("id"));
                brand.setBrandName(rs.getString("brand_name"));
                brand.setCompanyName(rs.getString("company_naem"));
                brand.setOrdered(rs.getInt("ordered"));
                brand.setDescription(rs.getString("description"));
                brand.setStatus(rs.getInt("status"));
                list.add(brand);
            }
            System.out.println(list.toString());
            resultSet.close();
            ps.close();
            connection.close();
                
        }
    }
    

*练习2，添加数据并打

##创建一个druid的properties配置文件druid.properties
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/tb_brand?useSSL=false&useServerPrepStmt=true
username=root
password=123456
#初始化连接数量
initialSize=5
#最大连接数量
maxSize=10
#最大等待时间
maxWait=3000

//创建一个DBUtil类，用于加载配置文件
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Properties;

public class DBUtil{
   
    //创建一个用于获取连接的方法getDBConnection()
    public Connection getDBConnection() throws Exception{
   
        Properties properties = new Properties();
        properties.load(new FileInputStream("src/com/util/druid.properties"));
        //根据配置文件创建数据源
        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
        //使用数据源创建连接
        Conenction connection = dataSource.getConnection();
        return connection;
    }
    //创建一个用于获取SQL执行对象的方法getPreparedStatement(Connection conn,String sql)
    
    public PreparedStatement getPreparedStatement(Connection conn,String sql){
   
    	return connection.prepareStatement(sql);
	}
    
}

//创建一个Brand实体类，用于接收数据，与数据库表一一对应
public class Brand{
   
    //主键
    private Integer id;
    //品牌名
    private String brandMame;
    //公司名
    private String companyName;
    //排序字段
    private Integer ordered;
    //描述
    private String description;
    //状态
    private Integer status;

    //id的get/set方法
    //略
    //重写toString()方法
    @Override
    public String toString(){
   
        return "Account{" +
            "id=" + id +
            ",name=" + name +
            ",money=" + money +
            "}";
    }
}

//创建一个BrandTest类，用于操作Brand对象
import com.entiey.Brand;
import com.util.DBUtil;
import corg.junit.jupiter.api.Test;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

public BrandTest{
   
    //创建一些公共类，避免在方法中重复创建，消耗内存
    DBUtil dbutil = new DBUtil();
    //以下变量，可用于多个方法中，因此先创建好
    Connection connection;
    PreparedStatement preparedStatement;
    ResultSet resultSet;
    ArrayList<Brand> list;
    Brand brand;
    String sql;
    int count;
    @Test
    public void testSelectAll() throws Exception{
   
        //创建预编译SQL执行对象前线创建connection与sql语句
        connection = dbutil.getConnection();
        sql = "select * from tb_brand";
        preparedStatement = getPreparedStatement(connection,sql);
        //执行SQL并返回结果集给resultSet
        resultSet = preparedStatement.executeQuery();
        //此时初始化用于接收查询结果的Brand对象与接收Brand对象的ArrayList对象
        list = new ArrayList<>();
        brand = new Brand();
        while(resultSet.next()){
   
            
        }
        
    }
}

Maven

• Maven是专门用于管理和构建Java项目的工具，它的主要功能有：
  • 提供了一套标准化的项目结构
  • 提供了一套标准化的构建流程（编译、测试、打包，发布……）
  • 提供了一套依赖管理机制
• 依赖管理
  • 依赖管理其实就是管理你项目所依赖的第三方资源（jar包，插件……）

Mybatis

• 两个配置文件

  • mybatis-config.xml 存放数据库的连接信息

  • POJOMapper.xml 存放对POJO进行操作的sql语句信息

  • 启动类中加载mybatis-config配置文件

    • String resource = "mybatis-config.xml";
      InputStream inputStream =        Resources.getResourceAsStream(resource);
      SqlSessionFactory ssf = new SqlSessionFactoryBuilder.build(inputStream);
      SqlSession ss = ssf.openSession();
      UserMapper userMapper =sqlSession.getMapper(UserMapper.class);
      List<User> users = userMapper.selectAll();
      System.out.println(users);
      sqlSession.close();
      

  • 通过SqlSession对象

  //根据数据库中的表创建一个实体类
  public class User{
       
      private Integer id;
      private String username;
      private String password;
      private String gender;
      private String addr;
      
      //get/set方法
      //略
      @override
      //重写toString()方法
      //略
  }
  

  <!--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>
       <typeAliases>
          <!--将指定包的路径省略，且包内的pojo类名不群分大小写-->
        	<package name = "com.dong.pojo"/>
      </typeAliases>
  	<environments default="devlopment">
          <environment id = "development">
          	<transactionManager type="JDBC"/>
              <dataSource type = "POOLED">'
              	<!--数据库连接信息-->
                  <property name="driver" value="com.mysql.jdbc.Driver"</