JDBC快速入门

JDBC

1. 概念: java数据库连接 Java语言操作数据库
   • 本质: 用统一的代码操作所有关系数据库的规则(接口),每个数据库厂商提供实现接口,提供数据库驱动jar,我们使用这套接口进行编程,真正执行的代码是驱动jar包中的实现类;
   • Person接口 Worker实现类 Person p=new Worker() p.eat();
   • 以接口类型调用方法真正执行的是驱动jar包中实现类的实现方法
2. 快速入门
   1. 导入jar包
   2. 注册驱动
   3. 获取数据库连接对象
   4. 定义sql
   5. 获取执行sql的对象
   6. 执行sql
   7. 处理结果
   8. 释放资源

• ClassLoader 类加载器 获取文件路径

ClassLoader classLoader=JDBCUtils.class.getClassLoader();
URL url=classLoader.getResource("jdbc.properties");
String path=url.getPath();

• SQL注入问题: 在拼接sql时,有一些sql的特殊关键词参与字符串的拼接,会造成安全问题

• JDBC管理事务

1. 开启事务
   conn.setAutoCommit(false);
2. 执行sql语句完成后提交事务
   conn.commit()
3. 异常回滚
   if(conn!=null){conn.rollback();}

• 数据库连接池
  1. 实现接口:DataSource javax.sql
  2. 方法:
     • 获取连接:getConnection()
     • 归还连接:Connection.close()
  3. 连接池技术
     • C3P0:
       1. 导入jar包(两个)
       2. 定义配置文件
          • 名称:c3p0.properties或c3p0-config.xml
          • 路径:放在src目录下即可,自动读取
       3. 创建核心对象:ComboPooleDataSource
       4. 获取连接:getConnection
       5. 归还连接:conn.close()

DataSource ds=new ComboPoolDataSource();
Connection conn=ds.getConnection();
conn.close();

• Druid

  1. 导入jar包(一个)
     2. 定义配置文件
     • 名称:任意
     • 路径:任意
     3. 加载配置文件
        Properties pro=new Properties()
        InputStream is=类名.class.getClaaLoader.getResourceAsStream("文件名")
        pro.load(is);
     4. 获取连接池对象:
        DataSource ds
        =DruidDataSourceFactory.createDataSource(pro)
     5. 归还连接:conn.close()

  JdbcTemplate

* 步骤
   1. 导入jar包(5个)
      1. commons-logging-1.2
      2. spring-beans-5.1.5.RELEASE
      3. spring-core-5.1.5.RELEASE
      4. spring-jdbc-5.1.5.RELEASE
      5. spring-tx-5.1.5.RELEASE
  2. 创建jdbcTemplate对象.依赖于DataSource
     `JdbcTemplate template =new JdbcTemplate(ds)`
  3. 调用JdbcTemplate的方法完成CRUD的操作
          
      1. update():执行增、删、改语句
        ```java
            String sql="update emp set ename=? where id=?";
            int a=template.update(sql,"小明",1001);
       
        ```
        ---
      2. queryForMap():查询结果将封装为map集合
         * 注意:这个方法查询的结果集长度只能是1
         ```java
            String sql="select * from emp where id=?"
            Map<String,Object> map=template.queryForMap(sql,1001);
            System.out.println(map);
         ```
         ---
       3. queryForList():查询结果将结果`封装为List集合
          * 注意:将每条记录封装为一个Map集合,再将Map集合装载到List集合中
          ```java
                String sql="select * from emp";
                List<Map<String,Object>> list=template.queryForList(sql);
                for(Map<String,Object> stringObjectMap:list){
                System.out.println(stringObjectMap);
                }
            ``` 
          ---
       4. queryForObject():查询结果封装为对象
        ```java
            String sql ="select count(id) from emp";
            Long total=template.queryForObject(sql,Long.class);
            System.out.println(total);
     ```
        ---
       5. query():查询结果封装为JavaBean对象
       
        ```java
            
            
            String sql="select * from emp";
            ---List<Emp> list=template.query(sql,new BeanPropertyRowMapper<Emp>(Emp.class));
            注意:此处不能转化null,要将基本数据类型转化为封装类
            ---List<Emp> list=template.query(sql,new BeanPropertyRowMapper<Emp>(){
            @Override
            public Emp mapRow(ResultSet rs,int i)throws SQLException{
            Emp emp=new Emp();
            int id=rs.getInt("id");
            String ename=rs.getString("ename");
            emp.setId(id);
            emp.setEname(ename);
            return emp;
            }
            });
            
            
           for(Emp emp:list){
           System.out.println(emp);
           }
           

        ```
        ---