来千峰的第七周

最新推荐文章于 2024-08-13 10:09:13 发布

2301_76975449

最新推荐文章于 2024-08-13 10:09:13 发布

阅读量55

点赞数

文章标签：数据库 mysql sql

本文链接：https://blog.csdn.net/2301_76975449/article/details/130170399

版权

第三十天

外键的约束

使用外键使两个毫不相关的两个表产生关系

外键：使用本表中的一个字段作为外键去和别的表产生关系

有外键的表叫做副表

连表查询

select emp.emp_name, dept.dept_name  # 查什么
from emp, dept  #从哪查
where emp.dept_id = dept.dept_id and emp.emp_name = "erbei" #查询的条件

多表联查：


    常规写法：   select * from emp, dept where emp.dept_id = dept.dept_id

内连接和外连接

内连接

也是牵涉多表联查，只不过换了一种写法而已

SELECT column_name(s)  查什么
FROM table_name1    从哪查  表1
INNER JOIN table_name2   关联 表2
ON table_name1.column_name=table_name2.column_name

注释：INNER JOIN 与 JOIN 是相同的。

内连接：   select * from emp inner join dept on emp.dept_id = dept.dept_id

外连接【开发中用的很少】

#左外连接 和右外连接
#LEFT JOIN 关键字会从左表 (table_name1) 那里返回所有的行，即使在右表 (table_name2) 中没有匹配的行。   没有匹配的行就是null

#RIGHT JOIN 关键字会右表 (table_name2) 那里返回所有的行，即使在左表 (table_name1) 中没有匹配的行。没有匹配的行就是null；

左外连接： select * from emp left outer join dept on emp.dept_id = dept.dept_id

开发中如何使用多表联查

一对多或者多对一的查询

select teacher.t_name, student.s_name  #查什么
from teacher, student     #从哪查
where teacher.t_id = student.teacher_id and teacher.t_name = "老邢";        #teacher.t_id = student.teacher_id 让两个表的外键产生关系   where 条件 ；

多对多的场景

场景：
    学生和课程的关系   学生要选课   课要被选
    一个学生对应着多门的课程
    一个课程可以被多个学生选择

#有三张表就意味着着必须使用三表联查
#需求：  司马懿选了哪些课程
select stu.s_name, course.c_name   #查什么
from stu, stu_course, course       #从哪查
where stu.s_id = stu_course.s_id and stu_course.c_id = course.c_id and stu.s_name = "司马懿";  #两个表的外键都与中间表所对应的字段关联起来      and 条件；

内连接的写法：

select s.s_name, c.c_name   #查什么
from stu s                 #从哪查   表一
inner join stu_course sc    # 关联的表   中间表
on s.s_id  = sc.s_id      #中间表与表一 对应的字段
inner join course c        # 关联的表   表二
on sc.c_id = c.c_id        #中间表与表二 对应的字段
where s.s_name = "司马懿";    # 条件

第三十一天

1.安装数据库可视化工具  navicat   SQLyog  workbench
2.数据库中的视图【了解】
3.总结
	DDL   database defined Language  数据库定义语言   建表 建库 等
	DML	  数据库操作语言   增删改
	DQL   数据库查询语言   查询
	DCL   数据库控制语言    权限
	DTL   数据库事务语言    事务
4.JDBC

JDBC

连接数据库的驱动

全称： Java database connectivity java连接数据库

使用Java代码去连接数据库，然后对数据库中的数据进行增删改查！！！

1.加载驱动

如何下载jar包？

1.百度 https://mvnrepository.com/
2.在搜索框中输入mysql
3.找到版本  5.1.47  版本jar包点进去

将下载好的jar导入到咱们的工程中

1.在src文件夹下面新建一个lib文件
2.将下载好的jar包复制到lib文件夹下面
3.鼠标点上这个jar包，右键add as Libaray... 即可

package com.qf.a_mysql;

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

public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载mysql的驱动
        //Driver驱动是mysql厂商提供的
        Class.forName("com.mysql.jdbc.Driver");
        //连接数据库的时候需要跑哪些东西
        //http://ww.baidu.com
        //主机： 是一个url   jdbc:mysql://localhost:3306/java2304
        //用户名: root
        //密码:  123456
        //2.准备连接数据库的一些参数
        String url = "jdbc:mysql://localhost:3306/java2304?useSSL=false";
        String user = "root";
        String password = "123456";

        //static Connection	getConnection(String url, String user, String password)
        //3.尝试建立与给定数据库URL的连接。

        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println(connection);
        //Connection 与特定数据库的连接（会话） 执行SQL语句并在连接的上下文中返回结果
        //4.关闭连接的资源
        connection.close();
    }
}

以上是连接数据库的操作

对数据库中表中的数据进行增删改查

对数据库中表中的数据进行添加操作

package com.qf.b_mysql;

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

public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.准备连接数据库的参数
        String url = "jdbc:mysql://localhost:3306/java2304?useSSL=false";
        String user = "root";
        String password = "123456";
        //3.获取连接数据库的对象
        Connection connection = DriverManager.getConnection(url, user, password);
        //代码走到这一步，代码没有报错，就证明连接数据库已经成功
        //Statement	createStatement()
        //创建一个 Statement对象，用于将SQL语句发送到数据库。去执行
        //4.创建搬运工对象 Statement对象  将SQL语句发送到数据库。去执行
        Statement statement = connection.createStatement();

        //5.写sql语句
        String sql = "insert into work(name, age, info) values('老邢', 89, '爱吃猪头肉')";

        //6.使用statement对象去执行sql语
        //int	executeUpdate(String sql)
        //执行给定的SQL语句，这可能是 INSERT ， UPDATE ，或 DELETE语句，
        // 或者不返回任何内容，如SQL DDL语句的SQL语句。
        int i = statement.executeUpdate(sql);
        System.out.println(i);
        //7.关闭资源
        statement.close();
        connection.close();


    }
}

查询数据库中所有的数据

查询出来的数据就是单纯打印一下吗？并不是的，你要将查询出来的数据赋值给一个类对象，然后存到集合中

package com.qf.c_mysql;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
public class Demo1 {
    public static void main(String[] args) throws Exception{
        Class.forName("com.mysql.jdbc.Driver");
        String url = "jdbc:mysql://localhost:3306/java2304?useSSL=false";
        String user = "root";
        String password = "123456";
        Connection connection = DriverManager.getConnection(url, user, password);
        Statement statement = connection.createStatement();
        String sql = "select * from work";
        //ResultSet	executeQuery(String sql)
        //执行给定的SQL语句，该语句返回单个 ResultSet对象。  结果集
        ResultSet resultSet = statement.executeQuery(sql);
        //一个ResultSet对象，其中包含给定查询产生的数据  就是数据库中的数据
        //表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。
        System.out.println(resultSet);
        /*
        resultSet
          id  name  age  info         《=======
          2   张三   89   大事年表       =====
          3   李四   78  傲上矜下
          4   扫描    78  你撒解决
         */
        //ResultSet对象保持一个光标指向其当前的数据行。
        // 最初，光标位于第一行之前。 next方法将光标移动到下一行，
        // 并且由于在ResultSet对象中没有更多行时返回false ，
        // 因此可以在while循环中使用循环来遍历结果集。
        List<Work> works = new ArrayList<>();
        while (resultSet.next()) {
            //通过字段的值获取当前字段的数据
            //int id = resultSet.getInt("id");
            int id = resultSet.getInt(1);
            String name = resultSet.getString("name");
            int age = resultSet.getInt("age");
            String info = resultSet.getString("info");

            Work work = new Work(id, name, age, info);
            works.add(work);


        }
        System.out.println(works);
        resultSet.close();
        statement.close();
        connection.close();

    }
}

第三十二天

预处理的搬运工对象

Connection对象下面的方法
PreparedStatement prepareStatement(String sql)
                         throws SQLException
创建一个PreparedStatement对象，用于将参数化的SQL语句发送到数据库。
具有或不具有IN参数的SQL语句可以预编译并存储在PreparedStatement对象中。 然后可以使用该对象多次有效地执行此语句。

注意：此方法针对从预编译中受益的参数化SQL语句进行了优化。 如果驱动程序支持预编译，则方法prepareStatement将将该语句发送到数据库进行预编译。 有些驱动程序可能不支持预编译。 在这种情况下，在执行PreparedStatement对象之前，该语句可能不会发送到数据库。 这对用户没有直接影响; 然而，它确实影响了哪些方法抛出某些SQLException对象。

静态的SQL语句： insert into work (name, age, info) values("狗蛋", 12, "asjj"); Statement

参数化的SQL语句: insert into work (name, age, info) values(?, ?, ?); PreparedStament

案例：

package com.qf.a_mysql;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class Demo2 {
    public static void main(String[] args) throws Exception{
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        String url = "jdbc:mysql://localhost:3306/java2304?useSSL=false";
        String user = "root";
        String password = "123456";

        Connection connection = DriverManager.getConnection(url, user, password);
        String sql = "update work set name = ?, age = ?, info = ? where id = ?";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setObject(1, "亚索");
        preparedStatement.setObject(2, 39);
        preparedStatement.setObject(3, "给我击飞");
        preparedStatement.setObject(4, 6);
        int i = preparedStatement.executeUpdate();
        System.out.println(i);
        preparedStatement.close();
        connection.close();

    }
}

封装一个工具类

封装一个工具类
	1.导包 mysql的jar包
	2.在src新建配置文件  db.properties   写的是连接数据库相关的参数
	3.再写一个JdbcUtil类
		两个   返回值Connectio对象     close资源

文件：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/java2304?useSSL=false
user=root
password=123456

1.获取connection对象

2.关闭资源

package com.qf.utils;
import java.io.FileInputStream;
import java.sql.*;
import java.util.Properties;

/**
 * 1.获取Connection对象
 * 2.关闭资源
 */
public class JdbcUtil {
    private static String url = null;
    private static String user =null;
    private static String password = null;
    static {
        try {
        //只要JdbcUtil类加载了，就会执行静态代码块中的代码
        //读取配置文件中的信息：properties文件
        //Properties类表示一组持久的属性。 Properties可以保存到流中或从流中加载。
        // 属性列表中的每个键及其对应的值都是一个字符串。
            Properties properties = new Properties();
            properties.load(new FileInputStream("src/db.properties"));
            //数据都在properties 对象中
            String diver = properties.getProperty("driver");
            url = properties.getProperty("url");
            user = properties.getProperty("user");
            password = properties.getProperty("password");
            Class.forName(diver);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection () {

        Connection connection = null;
        try {
            connection = DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return  connection;
    }

    //关闭资源
    //增删改  需要关闭两个   查 关闭三个
    public static void close (Connection connection) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static void close (Statement statement, Connection connection) {
        try {
            statement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
    public static void close (ResultSet resultSet, Statement statement, Connection connection) {
        try {
            resultSet.close();
            statement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
}

SQL注入【了解】

在使用SQL的时候，会有漏洞。是sql机制问题

delete from emp where id = 6 or 1=1 一旦or 1=1 条件就没有用了

搬运工对象Statement 是无法防止这个SQL注入的

预处理搬运工对象是可以防止SQL注入

JavaBean规范

JavaBean 是实体类 Work类写实体的类的时候一定要规范

1.私有化成员变量

2.一定要提供一个无参构造方法

3.一定要提供set和get方法

4.每个类都要单独成为一个文件

BeanUtils 类

BeanUtils类是动态的对属性进行赋值和取值的，之前使用set方法和get方法对属性进行赋值和取值

1.下载两个   beanutils和logging  jar包

package com.qf.d_beanutils;

import com.qf.c_mysql.Work;
import org.apache.commons.beanutils.BeanUtils;

import java.lang.reflect.InvocationTargetException;

public class Demo1 {
    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        //setProperty  设置属性
        //第一个参数: Object bean   属性所在的类对象
        //第二个参数:  String name  属性的名字
        //第三个参数: Object value   属性的值
        //static void	setProperty(Object bean, String name, Object value)
        Work work = new Work();
        BeanUtils.setProperty(work, "name", "大黄");
        //static String	getProperty(Object bean, String name)
        String name = BeanUtils.getProperty(work, "name");
        System.out.println(name);
    }
}

元数据【重点】

metadata

关于sql参数的元数据

关于resultSet元数据

关于sql参数的元数据

package com.qf.e_metadata;

import com.qf.utils.JdbcUtil;

import java.sql.Connection;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class Demo1 {
    public static void main(String[] args) throws SQLException {
        Connection connection = JdbcUtil.getConnection();
        String sql = "insert into work (name, age, info) values(?,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //获取sql的参数（？）有几个  借助于参数元数据
        //借助于U预处理搬运工对象获取 参数元数据对象
        ParameterMetaData parameterMetaData = preparedStatement.getParameterMetaData();
        int parameterCount = parameterMetaData.getParameterCount();//得到参数的个数
        System.out.println(parameterCount);//3
        //要个数有啥用
        Object[] objs = {"狗蛋", 12, "嘻嘻按时间计算"};//数组 用来对?进行赋值的
        for (int i = 1; i <= parameterCount; i++) {
            /**
             *  preparedStatement.setObject(1, "狗蛋");
             *  preparedStatement.setObject(2, 12);
             *  preparedStatement.setObject(3, “嘻嘻按时间计算”);
             */
            //对？进行赋值
            preparedStatement.setObject(i, objs[i - 1]);
        }


    }

}

关于结果集的元数据

package com.qf.e_metadata;

import com.qf.utils.JdbcUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;

public class Demo3 {
    public static void main(String[] args) throws Exception{
        Connection connection = JdbcUtil.getConnection();
        String sql = "select * from work";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        ResultSet resultSet = preparedStatement.executeQuery();
        //通过结果集对象获取结果集元数据
        ResultSetMetaData metaData = resultSet.getMetaData();
        //ResultSetMetaData  结果集元数据中存的有字段的个数  和字段名字 等
        /**
         * id  name  age  info
         * 1   狗蛋   12  才能决定书
         * 2   老邢   89   挖掘机
         */
        //getColumnCount  字段的个数
        int columnCount = metaData.getColumnCount();
        System.out.println(columnCount);
        //获取字段的名字
//        String id = metaData.getColumnName(1);
//        System.out.println(id);
//        String name = metaData.getColumnName(2);
//        System.out.println(name);
//        String age = metaData.getColumnName(3);
//        System.out.println(age);
//        String info = metaData.getColumnName(4);
//        System.out.println(info);
        for (int i = 1; i <= columnCount ; i++) {
            String columnName = metaData.getColumnName(i);
            System.out.println(columnName);
        }
        //要字段的名字干嘛？

        
        //今天我要看到 这个双层循环执行流程
        /**
         * id  name  age  info
         * 1   狗蛋   12  才能决定书
         * 2   老邢   89   挖掘机 ===>
         *  最外层循环进来 
         *      进入for循环
         *          i=1 1<=4  getColumnName(1); => id  getObject(id);  1 i++
         *          i=2 2<=4  getColumnName(2); =->name getObject(name);狗蛋 i++
         *          i=3 
         *          i=4 
         *    再次回到外层循环
         *      进入for循环
         *          i=1 1<=4  getColumnName(1); id getObject(id);  2
         */
        while (resultSet.next()) {//行
            for (int i = 1; i <= columnCount ; i++) {//列
                String columnName = metaData.getColumnName(i);
                Object object = resultSet.getObject(columnName);
                System.out.println(object);
            }
        }



    }
}

第三十三天

封装BaseDao

BaseDao 自己要封装的一个类，

这个类对数据库的数据进行增删改查的

在这个类中只需要写两个方法一个是增删改一个查

1.先复制JdbcUtil这个工具类到咱们的utils文件夹中
2.复制db.properties到src文件夹下面
3.在src下面新建lib文件夹 将mysqljar包导入当前工程中

package com.qf.utils;

import org.apache.commons.beanutils.BeanUtils;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class BaseDao {
	//增删改的
    public int update (String sql , Object[] obj) {
        Connection connection = JdbcUtil.getConnection();
        PreparedStatement preparedStatement= null;
        try {
            preparedStatement = connection.prepareStatement(sql);
            int parameterCount = preparedStatement.getParameterMetaData().getParameterCount();
            if (obj != null && obj.length==parameterCount) {
            for (int i = 1; i <= parameterCount ; i++) {
                preparedStatement.setObject(i,obj[i-1]);
                }
            }
            int i = preparedStatement.executeUpdate();
            return i;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JdbcUtil.close(preparedStatement,connection);
        }
        return 0;
    }
    
    //查
    public <T> List<T> query (String sql , Object[] obj , Class<T> cls) {
        //1.连接数据库
        Connection connection = JdbcUtil.getConnection();
        PreparedStatement preparedStatement =null;
        ResultSet resultSet = null;
        try {
            //2.通过connection对象  创建预处理搬运工
            preparedStatement = connection.prepareStatement(sql);
            //3.创建 参数元数据得到 字段的个数
            int parameterCount = preparedStatement.getParameterMetaData().getParameterCount();
            //4.给？赋值
            if (obj != null && obj.length==parameterCount) {
                for (int i = 1; i <= parameterCount; i++) {
                    preparedStatement.setObject(i,obj[i-1]);
                }
            }
            //5.执行sql语句  返回resultSet 结果集对象
            resultSet = preparedStatement.executeQuery();
            //12.创建一个集合
            List<T> list = new ArrayList<>();
            //6.通过结果集对象创建 集合元数据
            ResultSetMetaData metaData = resultSet.getMetaData();
            //7.获取集合元数据的个数
            int columnCount = metaData.getColumnCount();
            //8.遍历数据
            while (resultSet.next()) {
                //13.通过反射获取 类对象
                T t = cls.getConstructor(null).newInstance(null);
                for (int i = 1; i <= columnCount ; i++) {
                    //9.获取集合元数据的字段
                    String columnName = metaData.getColumnName(i);
                    //10.获取集合元数据的数据
                    Object value = resultSet.getObject(columnName);
                    //11.用Beanutils 来把获取的值赋到一个集合类中
                    BeanUtils.setProperty(t,columnName,value);
                }
                //14.把t中的数据添加到list集合中
                list.add(t);
            }
           return list.size() != 0 ? list : null ;
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }finally {
            //15.关闭数据
            JdbcUtil.close(resultSet , preparedStatement , connection);
        }
        return null;
    }
}

第三十四天

连接池

为什么使用连接池

想要对数据进行增删改查，首先第一步先连接数据库。获取Connection对象

连接池和Connection对象有关！！！

之前获取connection 对象咋获取的？ Connection connection = DriverManager.getConnection(url, muser, passsword);

如果每次进行增删改查的时候，都要先连接数据库，然后再关闭数据库。数据库压力比较大

采用一种连接池一种方式：

创建Connection对象以后，用完以后不要关闭资源。把它放到连接池中，在做其他的增删改查的时候

直接从池子中取即可。不用再重复的关闭和重复连接了

连接池需要考虑哪些因素

连接池目的就是管理Connection对象的

连接池：

驱动

url

user

password

池子有初始化的容量

最大的容量

等待时间

常见连接池：

1.C3P0 2.DBCP 3.Druid （德鲁伊）

Java代码中使用

步骤：

1.导包 druid的jar

2.在src下面的去新建一个druid.properties配置文件

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/java2304?useSSL=false
username=root
password=123456

initialSize=5
maxActive=10
maxWait=2000

3.书写druid连接池的核心类

package com.qf.a_test;

import com.alibaba.druid.pool.DruidDataSourceFactory;

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

public class PersonDao {
    public static void main(String[] args) throws Exception {
        //1.读取druid.properties 文件
        Properties properties = new Properties();
        //2.以流的形式进行操作
        properties.load(new FileInputStream("src/druid.properties"));
        //3.创建Druid的核心类
        //durid数据源的工厂
        //dataSource 数据源中干了获取配置文件的的数据并赋值给数据源
        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
        //4.获取连接数据库的对象
        Connection connection = dataSource.getConnection();


    }
}

去将之前封装的JdbcUtil类换成连接池的写法

package com.qf.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

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

/**
 * 1.获取Connection对象
 * 2.关闭资源
 */
public class JdbcUtil {
    private static DataSource dataSource = null;
    static {
        try {
        //只要JdbcUtil类加载了，就会执行静态代码块中的代码
        //读取配置文件中的信息：properties文件
        //Properties类表示一组持久的属性。 Properties可以保存到流中或从流中加载。
        // 属性列表中的每个键及其对应的值都是一个字符串。
            Properties properties = new Properties();
            properties.load(new FileInputStream("src/druid.properties"));
            dataSource = DruidDataSourceFactory.createDataSource(properties);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection () {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return  connection;
    }

    //关闭资源
    //增删改  需要关闭两个   查 关闭三个
    public static void close (Connection connection) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static void close (Statement statement, Connection connection) {
        try {
            statement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
    public static void close (ResultSet resultSet, Statement statement, Connection connection) {
        try {
            resultSet.close();
            statement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
}

JDBC中的事务

牵涉到增删改

回顾sql语句：

set autocommit = 0;
sql语句1
sql语句2
sql语句3
rollback; 回滚命令 or  commit;执行命令

sql：  update user set balance = balance - 100 where id = 2
sql:   update user set balance = balance + 100 where id = 1

package com.qf.b_shiwu;

import com.qf.utils.JdbcUtil;

import java.sql.Connection;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class Demo1 {
    //事务在Java  中的写法
    public static void main(String[] args) {
        Connection connection = JdbcUtil.getConnection();


        try {
            connection.setAutoCommit(false);//1.关闭自动提交
            String sql = "update person set salary=salary-100 where id = ?";
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setObject(1,4);
            int i = preparedStatement.executeUpdate();
            System.out.println(i);
            int i2 = 10/0;//出现异常下面的代码不在执行，直接catch 回滚方法

            String sql1 = "update person set salary=salary+100 where id = ?";
            PreparedStatement preparedStatement1 = connection.prepareStatement(sql1);
            preparedStatement1.setObject(1,5);
            int i1 = preparedStatement1.executeUpdate();
            System.out.println(i1);
            connection.commit();//提交方法
        } catch (Exception throwables) {
            System.out.println("交易异常,请重新交易");
            try {

                connection.rollback();//回滚方法
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }


    }
}

DBUtils框架

是轻量级持久层框架，就是对数据库的数据增删改查（CURD）

就类似于咱们自己封装的BaseDao,比咱们封装的更牛

apache组织创建的一个框架。现在没有市场，然后没人维护。不安全了

1.导包 dbUtils.jar

2.直接核心类即可

增删改：

package com.qf.c_dbutils;

import com.qf.utils.JdbcUtil;
import org.apache.commons.dbutils.QueryRunner;

import java.sql.Connection;
import java.sql.SQLException;

//做增删改的框架
public class Update {
    //增
    public static void main(String[] args) throws SQLException {

        //1.连接数据库
        Connection connection = JdbcUtil.getConnection();
        //2.DBUtils核心类
        QueryRunner queryRunner = new QueryRunner();
        //3.sql语句
        String sql = "insert into person5 (id,name) values (?,?)";
//        int i = queryRunner.update(connection, sql, 11, "猫咪");
//        System.out.println(i);



        //删
        String sql2 = "delete from person5 where id in (?,?,?)";
//        int update = queryRunner.update(connection, sql2, 1, 4, 5);
//        System.out.println(update);

        //改
        String sql3 = "update person5 set name = ? where id=?";
        int update = queryRunner.update(connection, sql3, "亚索", 10);
        System.out.println(update);

    }
}

查询：

package com.qf.c_dbutils;

import com.qf.utils.JdbcUtil;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.sql.Connection;
import java.util.List;

public class Query {
    public static void main(String[] args) throws Exception{
        //1.连接数据库
        Connection connection = JdbcUtil.getConnection();
        //2.DBUtils核心类
        QueryRunner queryRunner = new QueryRunner();
        //3.sql语句
//        String sql = "select * from person4 ";
//         //查所有数据
//        List<Person4> query = queryRunner.query(connection, sql, new BeanListHandler<Person4>(Person4.class));
//        System.out.println(query);
        //查一个数据
        String sql = "select * from person4 where id = ?";
        Person4 query = queryRunner.query(connection, sql, 8, new BeanHandler<Person4>(Person4.class));
        System.out.println(query);
    }
}

前端

1.什么是网页

就是在浏览器中通过一个url访问在浏览器上面展示一个页面

页面： html , CSS, JavaScript

html：就是一个网页架子写出来很丑

CSS: 让网页架子好看一点

JavaScript: 让网页动态效果的

2.什么html

HTML 是用来描述网页的一种标记语言。

HTML 指的是超文本标记语言 (Hyper Text Markup Language)

HTML 不是一种编程语言，而是一种标记语言 (markup language)

标记语言是一套标记标签 (markup tag) 就是在学标签

HTML 使用标记标签来描述网页

3.入门案例

<marquee scrollamount="150" direction="right">
    <font size='7' color='green'>这个是一个页面</font>
</marquee>html

标签的语法格式:

双边标签:
    <开始标签 属性="属性值" 属性="属性值"> 内容 </结束标签>
单边标签:
    <标签/>

https://www.w3school.com.cn/html/html_jianjie.asp

2301_76975449

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
来千峰的第七周

就是在浏览器中通过一个url访问在浏览器上面展示一个页面页面： html , CSS, JavaScripthtml：就是一个网页架子写出来很丑CSS: 让网页架子好看一点JavaScript: 让网页动态效果的。
复制链接

扫一扫