使用JDBC操纵数据库

使用JDBC操纵数据库

JDBC： Java数据库毗连技术(Java DataBase Connectivity)，能实现Java程序对各种数据库的访问。
由一组使用Java语言编写的类和接口(JDBC API)组成，它们位于java.sql以及javax.sql中。
1. JDBC访问数据库步骤

   

• Class.forName() 加载驱动
  
• DriverManager 获取Connection毗连
  
• 创建Statement 执行SQL语句
  
• 返回ResultSet查询效果
  
• 释放资源
  

1. try {
2.     //1.加载驱动
3.     Class.forName("com.mysql.cj.jdbc.Driver");
4.     //加载数据库路径
5.     String url = "jdbc:mysql://127.0.0.1:3306/smbms?useSSL = false";
6.     //加载账号
7.     String uname = "root";
8.     //加载密码
9.     String upwd = "1234";
10.     //2.DriverManager创建conn对象
11.     conn = DriverManager.getConnection(url,uname,upwd);
12.     //3.通过Connection创建Statement对象,用于执行SQL语句
13.     state = conn.createStatement();
14.     //4.准备sql语句
15.     String sql = "select id,userCode,userName,userPassword,creationDate from smbms_user where id = 1";
16.     //5.使用Statement执行SQL语句，并返回结果
17.     rs = state.executeQuery(sql);
18.     //6.处理resultSet遍历集合
19.     while(rs.next()){
20.         user = new User();
21.         user.setId(rs.getInt("id"));
22.         user.setUserCode(rs.getString("userCode"));
23.         user.setUserName(rs.getString("userName"));
24.         user.setUserPassword(rs.getString("userPassword"));
25.         user.setCreationDate(rs.getDate("creationDate"));
26.     }
27.     return user;
28. }catch(Exception e){
29.     e.printStackTrace();
30. }finally {
31.     //4.释放资源
32.     try {
33.         state.close();
34.         conn.close();
35.     } catch (SQLException e) {
36.         e.printStackTrace();
37.     }
38. }

复制代码

2. Statement与PreparedStatement区别

• Statement由方法createStatement()创建，该对象用于发送简朴的SQL语句
  
• PreparedStatement由方法prepareStatement()创建，该对象用于发送带有一个或者多个输入参数的SQL语句
  
  
  
  • SQL语句使用“?”作为数据占位符
    
  • 使用setXxx()方法设置数据
    
  
  
• PreparedStatement-----预编译
  

1. if (getConnection()){
2.     String sql = "select * from smbms_user where userCode = ? and userPassword = ?";
3.     //预编译sql语句
4.     ps = conn.prepareStatement(sql);
5.     ps.setString(1,userCode);
6.     ps.setString(2,userPassword);
7.     rs = ps.executeQuery();
8.     while(rs.next()){
9.         user = new User();
10.         user.setUserName(rs.getString("userName"));
11.         user.setUserPassword(rs.getString("userPassword"));
12.     }
13. return user;

复制代码

3. JDBC的内容

• JDBC API ：界说了一系列的接口和类，集成在java.sql和javax.sql包中
  
• DriverManager：管理各种不同的JDBC驱动
  
• JDBC 驱动：负责毗连不同类型的数据库
  

优点：
不必为不同的数据库专门编写不同的程序，而只需要加载不同的数据库驱动即可。
4. JDBC封装

4.1 为什么举行JDBC封装

• 将相似功能的代码抽取封装成方法，镌汰代码冗余
  
• 因为不同的数据库会有不同的实现，对数据库的操纵一样平常抽取成接口，在以后的开发中可以降低耦合
  
• 隔离业务逻辑代码和数据访问代码
  
• 隔离不同数据库的实现
  

4.2 实现JDBC封装

步骤：
   

• 将所有增编削查操纵抽取成接口
  
• 界说实体类传输数据
  
• 将通用的操纵（打开、关闭毗连等）封装到工具类
  
• 数据库工具类BaseDao：增、删、改、查的通用方法
  

1. package com.company.dao;
3. import java.io.IOException;
4. import java.io.InputStream;
5. import java.sql.*;
6. import java.util.Properties;
8. public class BaseDao {
9.     public  static String driver;
10.     public  static String url;
11.     public  static String uname;
12.     public  static String upwd;
13.     static {
14.         //加载流对象
15.         Properties properties = new Properties();
16.         InputStream is = BaseDao.class.getClassLoader().getResourceAsStream("com/company/dao/jdbc.properties");
17.         try {
18.             properties.load(is);
19.             driver = properties.getProperty("driver");
20.             url = properties.getProperty("url");
21.             uname = properties.getProperty("uname");
22.             upwd = properties.getProperty("upwd");
23.         } catch (IOException e) {
24.             e.printStackTrace();
25.         }
26.     }
27.     //创建数据库连接
28.     public Connection conn = null;
29.     public PreparedStatement ps = null;
30.     //连接数据库
31.     public void getConnection() throws Exception{
32.         //加载数据库驱动
33.         Class.forName(driver);
34.         //定义连接对象
35.         conn = DriverManager.getConnection(url,uname,upwd);
36.     }
38.     //关闭连接
39.     public void closeConnection(){
40.         try {
41.             conn.close();
42.             ps.close();
43.         } catch (SQLException e) {
44.             e.printStackTrace();
45.         }
46.     }
47.     //封装查询
48.     public ResultSet selectSql(String sql,Object[] objs) throws SQLException {
49.         ResultSet rs = null;
50.         if (conn != null) {
51.             ps = conn.prepareStatement(sql);
52.             for (int i = 0; i < objs.length; i++) {
53.                 ps.setObject((i+1),objs[i]);
54.             }
55.             rs = ps.executeQuery();
56.         }
57.         return rs;
58.     }
59.     //封装增删改方法（共用）
60.     public  int sql(String sql,Object[] objs) throws SQLException {
61.         int j = 0;
62.         if (conn != null){
63.             ps = conn.prepareStatement(sql);
64.             for (int i = 0;i < objs.length;i++){
65.                 ps.setObject((i+1),objs[i]);
66.             }
67.             j = ps.executeUpdate();
68.         }
69.         return j;
70.     }
71. }

复制代码

4.3 什么是DAO

Data Access Object(数据存取对象) ： 位于业务逻辑和持久化数据之间，实现对持久化数据的访问
DAO起着转换器的作用，将数据在实体类和数据库记录之间举行转换。
DAO模式的组成：

• DAO接口
  
• DAO实现类
  
• 实体类
  
• 数据库毗连和关闭工具类
  

优势：

• 隔离了数据访问代码和业务逻辑代码
  
• 隔离了不同数据库实现
  

4.4 配置数据库访问参数

属性文件：

• 后缀为.properties
  
• 数据格式为“键=值”
  
• 使用“＃”来注释
  
• Java中提供了Properties类来读取配置文件
  

1. mysql.driver = com.mysql.cj.jdbc.Driver
2. mysql.url = jdbc:mysql://127.0.0.1:3306/smbms?useSSL = false
3. mysql.uname = root
4. mysql.upwd = 1234

复制代码

4.5 配置数据库毗连池使用之JNDI的方式

JNDI:
JNDI就是（java Naming and Directory Inteface）java名称目次接口。
JNDI的作用：就是将资源引入到服务器中。可以将JNDI当成一个仓库。将Java对象放入到JNDI中去。
如果我们一开始就有已经创建好了多个connection对象，放在一个公共地方，当有一个毗连数据库的哀求，就从这个公共地方中取出一个connection，操纵数据库，操纵完成数据库，不关闭connection，而是放入到公共仓库中去，这就出现了数据库毗连池的东西，就是存放多个Connection对象的地方。
使用JNDI配置数据库的毗连池：

• 非全局的JNDI配置：
         导入要链接数据库的jar包文件。
      在JNDI中配置数据库的毗连池：在WEB项目中的的META-INF中创建一个context.xml文件。用于设置数据库的毗连池信息
     
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Context>
  3. <!--       其中Resource标签就是配置资源，他的属性值如下：
  4. |- name：表示以后要查找的名称。通过此名称可以找到DataSource，此名称任意更换，但是程序中最终要查找的就是此名称，
  5.         为了不与其他的名称混淆，所以使用jdbc/oracle，现在配置的是一个jdbc的关于oracle的命名服务。
  6. |- auth：由容器进行授权及管理，指的用户名和密码是否可以在容器上生效，可以使用Container
  7. |- type：此名称所代表的类型，现在为javax.sql.DataSource（不用变）
  8. |- maxActive：表示一个数据库在此服务器上所能打开的最大连接数
  9. |- maxIdle：表示一个数据库在此服务器上维持的最小连接数
  10. |- maxWait：最大等待时间。10000毫秒
  11. |- username：数据库连接的用户名
  12. |- password：数据库连接的密码
  13. |- driverClassName：数据库连接的驱动程序
  14. |- url：数据库连接的地址
  15. -->
  16. <!--配置Oracle数据库的JNDI数据源-->
  17. <Resource
  18.      name="jdbc/oracle"
  19.      auth="Container"
  20.      type="javax.sql.DataSource"
  21.      maxActive="100"
  22.      maxIdle="30"
  23.      maxWait="10000"
  24.      username="lead_oams"
  25.      password="p"
  26.      driverClassName="oracle.jdbc.driver.OracleDriver"
  27.      url="jdbc:oracle:thin:@192.168.1.229:1521:lead"/>
  29. <!--配置MySQL数据库的JNDI数据源-->
  30. <Resource
  31.      name="jdbc/mysql"
  32.      auth="Container"
  33.      type="javax.sql.DataSource"
  34.      maxActive="100"
  35.      maxIdle="30"
  36.      maxWait="10000"
  37.      username="root"
  38.      password="root"
  39.      driverClassName="com.mysql.jdbc.Driver"
  40.      url="jdbc:mysql://127.0.0.1:3306/smbms?useSSL=false"/>
  42. <!--配置SQLServer数据库的JNDI数据源-->
  43. <Resource
  44.      name="jdbc/sqlserver"
  45.      auth="Container"
  46.      type="javax.sql.DataSource"
  47.      maxActive="100"
  48.      maxIdle="30"
  49.      maxWait="10000"
  50.      username="sa"
  51.      password="123456"
  52.      driverClassName="com.microsoft.sqlserver.jdbc.SQLServerDriver"
  53.      url="jdbc:sqlserver://192.168.1.51:1433;DatabaseName=demo"/>
  54. </Context>

  复制代码
     在web.xml文件中举行配置( 可有可无)：如果有的话：
     
  1. <resource-ref>
  2. <description>my DB Connection</description>
  3. <res-ref-name><span style="font-family: Arial, Helvetica, sans-serif;">jdbc/sqlserver</span><span style="font-family: Arial, Helvetica, sans-serif;"></res-ref-name> 这个名字要与context.xml中的name一样</span>
  4. <res-type>javax.sql.DataSource</res-type>
  5. <res-auth>Container</res-auth>
  6. </resource-ref>

  复制代码
     如果使用Spring的情况下：在applicationContext.xml或者自己的Spring的配置文件中：导入JNDI的配置信息
     
  1. //获得content.xml中JNDI配置的数据库的连接池信息。jndi-name必须与JNDI中的name值一样
  2. <jee:jndi-lookup id="dataSource"  jndi-name="jdbc/sqlserver" />
  3. //使用JdbcTemplate操作数据库。
  4. <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  5.   <property name="dataSource" ref="dataSource" />
  6. </bean>

  复制代码
     在java文件中使用IOC得到jdbcTemplate对象。最后使用JdbcTemplate操纵数据库
      如果不使用Spring的话：可以在java文件中使用：
     
  1. Context initContext = new InitialContext();
  2. Context envContext  = (Context)initContext.lookup("java:/comp/env");//固定，不需要修改
  3. DataSource ds = (DataSource)envContext.lookup(jdbc/sqlserver);

  复制代码
• 全局的JNDI：
         在tomcat的安装目次下的conf下的server.xml文件中的GlobalNamingResources标签下到场（一局部JNDI在context.xml文件中的resource配置信息）。
      在Web项目中的META-INF下的context中配置
     
  1. //global中的名字要与server.xml中的名称一样，而这里的name表示当前要使用名称。
  2. <ResourceLink name="jdbc/sqlserver" global="jdbc/sqlserver" type="javax.sql.DataSource"/>

  复制代码

5. 单例模式

系统运行期间，有且仅有一个实例。

• 一个类只有一个实例——最基本的要求
  
  
  
  • 只提供私有构造器
    
  
  
• 它必须自行创建这个实例
  
  
  
  • 界说了静态的该类私有对象
    
  
  
• 它必须自行向整个系统提供这个实例
  
  
  
  • 提供一个静态的公有方法，返回创建或者获取本身的静态私有对象
    
  
  

在整个程序运行期间，有且仅有一个实例。若违反这一点，所计划的类就不是单例类。
5.1 懒汉模式

在类加载时不创建实例，采用延迟加载的方式，在运行调用时创建实例。
特点：
线程不安全、延迟加载（lazy loading）

1. public class ConfigManager1 {
3.     private static ConfigManager1 configManager1 = null;
5.     private static Properties properties = new Properties();
7.     public ConfigManager1(){
8.         try {
9.             InputStream is = ConfigManager1.class.getClassLoader().getResourceAsStream("jdbc.properties");
10.             //将字节流转换为properties对象
11.             properties.load(is);
12.         } catch (IOException e) {
13.             throw new RuntimeException(e);
14.         }
15.     }
16.     public synchronized static ConfigManager1 getConfigManager1(){
17.         if(configManager1==null){
18.             configManager1 = new ConfigManager1();
19.         }
20.         return configManager1;
21.     }
22.     public  String getString(String key){
23.         return properties.getProperty(key);
24.     }
25. }

复制代码

BaseDao:

1. //1.加载数据库驱动
2. Class.forName(ConfigManager.getString("mysql.driver"));
3. conn = DriverManager.getConnection(
4.     ConfigManager.getString("mysql.url"),
5.     ConfigManager.getString("mysql.uname"),
6.     ConfigManager.getString("mysql.upwd")
7. );

复制代码

5.2 饿汉模式

在类加载的时间，就完成初始化。
特点：线程安全、不具备延迟加载特性
单例模式懒汉模式饿汉模式概念在类加载时不创建实例，采用延迟加载的方式，在运行调用时创建实例在类加载的时间，就完成初始化特点类加载速度快，但是运行时获取对象的速度较慢。——时间换空间”类加载较慢，但获取对象速度快。——“空间换时间”延迟加载(lazy loading)具备不具备线程安全线程不安全线程安全

1. public class ConfigManager1 {
3.     private static ConfigManager1 configManager1 = null;
5.     private static Properties properties = new Properties();
7.     public ConfigManager1(){
8.         try {
9.             InputStream is = ConfigManager1.class.getClassLoader().getResourceAsStream("jdbc.properties");
10.             //将字节流转换为properties对象
11.             properties.load(is);
12.         } catch (IOException e) {
13.             throw new RuntimeException(e);
14.         }
15.     }
16.     public synchronized static ConfigManager1 getConfigManager1(){
17.         if(configManager1==null){
18.             configManager1 = new ConfigManager1();
19.         }
20.         return configManager1;
21.     }
22.     public  String getString(String key){
23.         return properties.getProperty(key);
24.     }
25. }

复制代码

BaseDao:

1. //1.加载数据库驱动
2. Class.forName(ConfigManager1.getConfigManager1().getString("mysql.driver"));
3. conn = DriverManager.getConnection(
4.     ConfigManager1.getConfigManager1().getString("mysql.url"),
5.     ConfigManager1.getConfigManager1().getString("mysql.uname"),
6.     ConfigManager1.getConfigManager1().getString("mysql.upwd")
7. );

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。