精华内容
下载资源
问答
  • Java数据库连接技术

    2014-04-15 14:15:27
    Java数据库连接
  • 数据库连接初始化过程,往往已经创建了若干数据库连接置于池备用。此时连接的初始化工作均已完成。对于业务请求处理而言,直接利用现有可用连接,避免了数据库连接初始化和释放过程的时间开销,从而缩减了...
  • Java-数据库连接技术

    千次阅读 多人点赞 2021-02-06 10:43:57
    池(Pool)技术在一定程度上可以明显优化服务器应用程序的性能,提高程序执行效率和降低系统资源开销。数据库连接池负责分配、管理和释放数据库连接,它允许应用程序重复使用一个...常见的数据库连接技术有C3P0,Druid
     

    Java-数据库连接池技术

    数据库连接池技术

    基本概念:

    Java中定义的接口—DataSource接口提供激活框架与数据的任意集合的抽象。

    常用的数据库连接池技术

    C3P0

    步骤:

    代码:

    Druid:由阿里巴巴提供

    步骤:

    代码:


    池(Pool)技术在一定程度上可以明显优化服务器应用程序的性能,提高程序执行效率和降低系统资源开销。数据库连接池负责分配、管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是再重新建立一个;

    数据库连接池技术

    基本概念:

    数据库连接池:其实就是一个容器(集合),存放数据库连接的容器。 当系统初始化好后,容器被创建,容器中会申请一些连接对象,当用户来访问数据库时,从容器中获取连接对象,用户访问完之后,会将连接对象归还给容器。        

    使用池化技术的好处:1. 节约资源     2. 用户访问高效   3.提高程序性能和降低系统资源开销

    Java中定义的接口—DataSource接口提供激活框架与数据的任意集合的抽象。

    常用方法:

            获取连接:getConnection()

            归还连接:Connection.close()。如果连接对象Connection是从连接池中获取的,那么调用Connection.close()方法,则不会再关闭连接了。而是归还连接

    常用的数据库连接池技术

    C3P0

             步骤:

                1. 导入jar包 (两个)

                      c3p0-0.9.5.2.jar、mchange-commons-java-0.2.12.jar ,

                2. 定义配置文件:

                     名称: c3p0.properties 或者 c3p0-config.xml

                     路径:直接将文件放在src目录下即可。

                3. 创建核心对象 数据库连接池对象 ComboPooledDataSource

                4. 获取连接: getConnection

            代码:

    <c3p0-config>
      <!-- 使用默认的配置读取连接池对象 -->
      <default-config>
      	<!--  连接参数 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db4</property>
        <property name="user">root</property>
        <property name="password">root</property>
        
        <!-- 连接池参数 -->
        <!--初始化申请的连接数量-->
        <property name="initialPoolSize">5</property>
        <!--最大的连接数量-->
        <property name="maxPoolSize">10</property>
        <!--超时时间-->
        <property name="checkoutTimeout">3000</property>
      </default-config>
    
    </c3p0-config>
    public static void main(String[]args)throws SQLException{
    	//1.获取数据库连接池对象
    	DataSource ds=new ComboPooledDataSource();
    	//2.获取连接对象
    	Connection conn=ds.getConnection();
    	//3.打印
    	System.out.println(conn);
    	//4.归还资源
    	conn.close();
    }
     

    Druid:由阿里巴巴提供

         步骤:

                  1. 导入jar包 druid-1.0.9.jar

                  2. 定义配置文件:

                        是properties形式的

                        可以叫任意名称,可以放在任意目录下

                  3. 加载配置文件。Properties

                  4. 获取数据库连接池对象:通过工厂来来获取  DruidDataSourceFactory

                  5. 获取连接:getConnection

       代码:

    driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql:///db3
    username=root
    password=root
    # 初始化连接数量
    initialSize=5
    # 最大连接数
    maxActive=10
    # 最大等待时间
    maxWait=3000
     public static void main(String[] args) throws Exception {
        //1.导入jar包
        //2.定义配置文件
        //3.加载配置文件
        Properties pro = new Properties();
        InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);
        //4.获取连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        //5.获取连接
        Connection conn = ds.getConnection();
        System.out.println(conn);
    
    }

     创作不易,如果本篇博客对您有一定的帮助,大家记得留言+点赞哦。 

    展开全文
  • JDBC(Java Database Connectivity) 数据库连接技术

    万次阅读 热门讨论 2020-07-27 17:48:00
    JavaWeb~02.JDBC(Java Database Connectivity) 数据库连接技术 本文是上一篇文章的后续,详情点击该链接~ JDBC        是一种用于执行SQL语句的Java API,为多种关系数据库提供...

    JavaWeb~02.JDBC(Java Database Connectivity) 数据库连接技术

    JDBC

           是一种用于执行SQL语句的Java API,为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。有了JDBC,程序员只需用JDBC API写一个程序,就可访问所有数据库。

    本文数据库表

    在这里插入图片描述

    【声明:本文数据库内的所有内容纯属学习所用,如有雷同,纯属巧合!】

    JDBC查询所有信息操作

    public class Test{
        public static void main(String[] args) throws ClassNotFoundException, SQLException {
            String driver = "com.mysql.cj.jdbc.Driver";
            String url = "jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai";
            String username = "root";
            String pwd = "root";
            //加载一个Driver驱动
            Class.forName(driver);
            //创建数据库的连接
            Connection connection = DriverManager.getConnection(url,username,pwd);
            //创建SQL命令发送器
            Statement statement = connection.createStatement();
            //向数据库发送sql语句然后返回参数
            String sql = "select * from student";
            ResultSet resultSet = statement.executeQuery(sql);
            //遍历输出内容
            while(resultSet.next()){
                //getInt后面的参数值和数据库里面的字段相对应
                //字段的类型也要对应
                Integer son = resultSet.getInt("son");
                String realname = resultSet.getString("realname");
                String password = resultSet.getString("password");
                String classname = resultSet.getString("classname");
                Double score = resultSet.getDouble("score");
                System.out.println("["+ son + " " + realname + " " + password + " " +
                        classname + " " + score + "]");
            }
            //回收资源
            connection.close();
            statement.close();
            resultSet.close();
        }
    }
    
    JDBC访问数据库的步骤:

           加载一个Driver驱动

           创建数据库连接(Connection)

           创建SQL命令发送器Statement

           通过Statement发送SQL命令并得到结果

           处理结果(select语句)

           关闭数据库资源ResultSet Statement Connection

    加载Driver驱动

           使用反射加载驱动,其实就是获得一个类的字节码,在获得类的字节码的过程中,一定会加载类进入内存,一旦进入内存会执行代码中的静态代码块,一执行代码块,就会自动的向DriverManager中注册一个驱动

            mysql8 之前的数据库驱动名 com.mysql.jdbc.Driver

            mysql8 开始的数据库驱动 com.mysql.cj.jdbc.Driver

    通过DriverManager获得链接

            url                             同一资源定位符

           协议                            jdbc:mysql:

            ip地址                       127.0.0.1/localhost

            url                             同一资源定位符

            端口号                      3306

            具体的资源路径       mybatis

            mysql8之前:             jdbc:mysql://127.0.0.1:3306/mybatis

            mysql8开始:             jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai

           useSSL=false            不使用SSL加密机制

           &useUnicode=true     使用unicode字符集

           &characterEncoding=utf8       使用utf8作为通信字符集

           &serverTimezone=Asia/Shanghai       确定时区为 Asia/Shanghai

           其中的mybatis指的是数据库名,可以根据需求修改

    刚才的操作呢,是JDBC非常原始的一个操作,我们写起来会感觉非常的麻烦。假如我们要写多个查询的操作,难道我们也要重复写很多遍嘛?所以,这个时候,我们就需要对刚才的操作进行微微调整。
    public class Test{
        public static void main(String[] args){
            Connection connection = null;
            Statement statement = null;
            ResultSet resultSet = null;
            try {
                //创建数据库连接
                connection = Util.getConnection();
                //创建SQL命令发送器
                statement = connection.createStatement();
                //向数据库发送sql语句然后返回参数
                String sql = "select * from student";
                resultSet = statement.executeQuery(sql);
                //遍历输出内容
                while (resultSet.next()) {
                    //getInt后面的参数值和数据库里面的字段相对应
                    //字段的类型也要对应
                    Integer son = resultSet.getInt("son");
                    String realname = resultSet.getString("realname");
                    String password = resultSet.getString("password");
                    String classname = resultSet.getString("classname");
                    Double score = resultSet.getDouble("score");
                    Student student = new Student(son, realname, password, classname, score);
                    System.out.println(student.toString());
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                Util.CloseAll(connection,statement,resultSet);
            }
        }
    }
    //创建工具类
    class Util{
        private static String driver = "com.mysql.cj.jdbc.Driver";
        private static String url = "jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai";
        private static String username = "root";
        private static String pwd = "root";
        //将前面的操作封装在一个方法里面,这样就可以重复调用了
        public static Connection getConnection(){
            Connection connection = null;
            try {
                //加载一个Driver驱动
                Class.forName(driver);
                //创建数据库的连接
                connection = DriverManager.getConnection(url,username,pwd);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            return connection;
        }
    
        public static void CloseAll(Connection connection,Statement statement,ResultSet resultSet){
            if(connection != null){
                try {
                    connection.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(statement != null){
                try {
                    statement.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(resultSet != null){
                try {
                    resultSet.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }
    //创建学生类
    class Student implements Serializable {
        private Integer son;
        private String realname;
        private String password;
        private String classname;
        private Double score;
    
        public Student(Integer son, String realname, String password, String classname, Double score) {
            this.son = son;
            this.realname = realname;
            this.password = password;
            this.classname = classname;
            this.score = score;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "son=" + son +
                    ", realname='" + realname + '\'' +
                    ", password='" + password + '\'' +
                    ", classname='" + classname + '\'' +
                    ", score=" + score +
                    '}';
        }
    
        public Student() {
            super();
        }
    }
    

           这样一来的话,我们后面不管写多少次JDBC的操作,都可以省略很多行代码了~

    JDBC常见异常

           Exception in thread "main"java.lang.ClassNotFoundException: com.mysql.jdbc2.Driver

           原因:没有添加jar包或者com.mysql.jdbc2.Driver路径错误

           Exception in thread "main" java.sql.SQLException: No suitable driver found for jbdc:mysql://127.0.0.1:3306/stumgr

           url错误

           Exception in thread "main" java.sql.SQLException: Access denied for user 'root'@'localhost' (using password: YES)

           原因:用户名或者密码错误

           Exception in thread "main" com.mysql.jdbc.exceptions .jdbc4.MySQLIntegrityConstraintViolationException:Duplicate entry '90' for key 'PRIMARY'

           原因:主键冲突

    JDBC增删查改操作

    需求:新增学生信息

        public static void Insert(String sql){
            Connection connection = null;
            Statement statement = null;
            try {
                //创建数据库连接
                connection = Util.getConnection();
                //创建SQL命令发送器
                statement = connection.createStatement();
                int n = statement.executeUpdate(sql);
                //返回结果
                String str = n > 0 ? "新增成功!" : "新增失败!";
                System.out.println(str);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }finally {
                Util.CloseAll(connection,statement,null);
            }
        }
    

    需求:根据学号修改密码

    public static void main(String[] args){
    			//问号 占位符
            Update("update student set password = ? where son = ?","123456",666666);
        }
        //修改学生信息
        public static void Update(String sql,String password,Integer son){
            Connection connection = null;
            PreparedStatement preparedStatement = null;
            try{
                //建立数据库连接
                connection = Util.getConnection();
                //创建SQL命令发送器
                preparedStatement = connection.prepareStatement(sql);
                //返回结果   前面的数字表示第几个问号
                preparedStatement.setString(1,password);
                preparedStatement.setInt(2,son);
                int n = preparedStatement.executeUpdate();
                String str = n > 0 ? "修改成功!" : "修改失败!";
                System.out.println(str);
            }catch (SQLException sqlException){
                sqlException.printStackTrace();
            }finally {
                Util.CloseAll(connection,preparedStatement,null);
            }
        }
    

    需求:根据学号删除学生信息

     public static void Del(String sql,Integer son){
            Connection connection = null;
            PreparedStatement preparedStatement = null;
            try{
                //建立数据库连接
                connection = Util.getConnection();
                //创建SQL命令发送器
                preparedStatement = connection.prepareStatement(sql);
                preparedStatement.setInt(1,son);
                int n = preparedStatement.executeUpdate();
                String str = n > 0 ? "删除成功!" : "删除失败!";
                System.out.println(str);
            }catch (SQLException sqlException){
                sqlException.printStackTrace();
            }finally {
                Util.CloseAll(connection,preparedStatement,null);
            }
        }
    

    需求:通过学生的学号和密码实现登录

      public static void Login(Integer son,String password){
            Connection connection = null;
            PreparedStatement preparedStatement = null;
            ResultSet resultSet = null;
            Student student = null;
            String sql = "select * from student where son = ? and password = ?";
            try{
                //建立数据库连接
                connection = Util.getConnection();
                //创建SQL命令发送器
                preparedStatement = connection.prepareStatement(sql);
                preparedStatement.setInt(1,son);
                preparedStatement.setString(2,password);
                resultSet = preparedStatement.executeQuery();
                //判断是否为空
                if(resultSet.next()){
                    String realname = resultSet.getString("realname");
                    String classname = resultSet.getString("classname");
                    Double score = resultSet.getDouble("score");
                    student = new Student(son,realname,password,classname,score);
                }
                String str = student != null ? "登录成功!" : "登录失败!";
                System.out.println(str);
            }catch (SQLException sqlException){
                sqlException.printStackTrace();
            }finally {
                Util.CloseAll(connection,preparedStatement,resultSet);
            }
        }
    

           从上述操作中,我们还发现一个弊端。就是很多代码都重复了很多遍,那么,我们就再来完善一下工具类~

     //用于增删改
        public static int executeUpdate(String sql,Object [] params) {
            Connection conn = null;
            PreparedStatement pstmt = null;
            int n = 0;//添加失败
            try {
                //建立和数据库的连接
                conn = getConnection();
                //创建一个SQL命令发送器
    
                pstmt = conn.prepareStatement(sql);
                //准备好SQL语句,通过SQL命令发送器发送给数据库,并得到结果
                for (int i = 0; i <params.length ; i++) {
                    pstmt.setObject(i+1, params[i]);
                }
                n = pstmt.executeUpdate();
                System.out.println(n);
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                //关闭资源
                CloseAll(conn,pstmt,null);
            }
            return n;
        }
    
        //用于查询
        public static <T> List<T> baseQuery(T t, String sql, Object ... args){
            // 获取list集合中要装的对象的字节码
            Class aClass = t.getClass();
            Connection connection = null;
            PreparedStatement statement = null;
            ResultSet set = null;
            List<T> list = null;
            try {
                connection = Util.getConnection();
                statement = connection.prepareStatement(sql);
                // 设置参数的过程
                for (int i = 0; i < args.length; i++) {
                    statement.setObject(i + 1, args[i]);
                }
                set = statement.executeQuery();
                // 获取全部的字段
                Field[] fs = aClass.getDeclaredFields();
                // 先设置属性可以访问
                for(Field f:fs){
                    f.setAccessible(true);
                }
                list=new ArrayList<>();
                while(set.next()){
                    // 创建对象
                    T  element = (T)aClass.newInstance();
                    // 从结果集的一条数据中取出每个字段的信息,放入element对象上去
                    // 遍历fs 通过属性名 去结果集中获取数据
                    for(Field f:fs){
                        String name = f.getName();
                        Object value=null;
                        // 判断实体类属性的数据类型,选择对应的get方法
                        if(f.getType()==int.class){
                            value = set.getInt(name);
                        }else if(f.getType()==double.class){
                            value = set.getDouble(name);
                        }else if(f.getType()==boolean.class){
                            value = set.getBoolean(name);
                        }else{
                            value= set.getObject(name);
                        }
                        f.set(element,value);
                    }
                    list.add(element);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                CloseAll(connection,statement,set);
            }
            return list;
        }
    

    完善了刚刚的工具类以后,我们就来修改下前面的登录操作~

    注意:在此之前!记得Student类要补上 get set 方法
        public static void Login(Integer son,String password){
            String sql = "select * from student where son = ? and password = ?";
            List<Student> list = Util.baseQuery(new Student(),sql,son,password);
            String str = list.isEmpty() != true ? "登陆成功!" : "登陆失败!";
            System.out.println(str);
        }
    

           这里我们可以看到,代码已经明显简洁很多了~那么,增删改呢?

    需求:增加操作完善

        public static void main(String[] args){
            Object[]objects = {653221,"张桥","998554","机电工程学院",566,"alvin"};
            Insert("insert into student value(?,?,?,?,?,?)",objects);
        }
    
        //新增学生信息
        public static void Insert(String sql,Object []object){
            int n = Util.executeUpdate(sql,object);
            String str = n > 0 ? "新增成功!" : "新增失败!";
            System.out.println(str);
        }
    
           修改和删除就不在这里啰嗦了~

    使用JDBC结合Socket实现远程登录

    Student还是刚才那个Student,数据库表也依然是刚刚的数据库表

    public class Student implements Serializable {
        private Integer son;
        private String realname;
        private String password;
        private String classname;
        private Double score;
    }//get set那些就不写在文章里面了,但是实际操作需要添加。
    

    完整的Util

    public class Util {
        private static String driver = "com.mysql.cj.jdbc.Driver";
        private static String url = "jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai";
        private static String username = "root";
        private static String pwd = "root";
        //将前面的操作封装在一个方法里面,这样就可以重复调用了
        public static Connection getConnection(){
            Connection connection = null;
            try {
                //加载一个Driver驱动
                Class.forName(driver);
                //创建数据库的连接
                connection = DriverManager.getConnection(url,username,pwd);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            return connection;
        }
    
        public static void CloseAll(Connection connection, Statement statement, ResultSet resultSet){
            if(connection != null){
                try {
                    connection.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(statement != null){
                try {
                    statement.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(resultSet != null){
                try {
                    resultSet.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
        //用于增删改
        public static int executeUpdate(String sql,Object [] params) {
            Connection conn = null;
            PreparedStatement pstmt = null;
            int n = 0;//添加失败
            try {
                //2.建立和数据库的连接
                conn = getConnection();
                //3.创建一个SQL命令发送器
    
                pstmt = conn.prepareStatement(sql);
                //4.准备好SQL语句,通过SQL命令发送器发送给数据库,并得到结果
                for (int i = 0; i <params.length ; i++) {
                    pstmt.setObject(i+1, params[i]);
                }
                n = pstmt.executeUpdate();
                //System.out.println(n);
    
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                //6.关闭资源
                CloseAll(conn,pstmt,null);
            }
            return n;
        }
    
        //用于查询
        public static <T> List<T> baseQuery(T t, String sql, Object ... args){
            // 获取list集合中要装的对象的字节码
            Class aClass = t.getClass();
            Connection connection = null;
            PreparedStatement statement = null;
            ResultSet set = null;
            List<T> list = null;
            try {
                connection = Util.getConnection();
                statement = connection.prepareStatement(sql);
                // 设置参数的过程
                for (int i = 0; i < args.length; i++) {
                    statement.setObject(i + 1, args[i]);
                }
                set = statement.executeQuery();
                // 获取全部的字段
                Field[] fs = aClass.getDeclaredFields();
                // 先设置属性可以访问
                for(Field f:fs){
                    f.setAccessible(true);
                }
                list=new ArrayList<>();
                while(set.next()){
                    // 创建对象
                    T  element = (T)aClass.newInstance();
                    // 从结果集的一条数据中取出每个字段的信息,放入element对象上去
                    // 遍历fs 通过属性名 去结果集中获取数据
                    for(Field f:fs){
                        String name = f.getName();
                        Object value=null;
                        // 判断实体类属性的数据类型,选择对应的get方法
                        if(f.getType()==int.class){
                            value = set.getInt(name);
                        }else if(f.getType()==double.class){
                            value = set.getDouble(name);
                        }else if(f.getType()==boolean.class){
                            value = set.getBoolean(name);
                        }else{
                            value= set.getObject(name);
                        }
                        f.set(element,value);
                    }
                    list.add(element);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                CloseAll(connection,statement,set);
            }
            return list;
        }
    }
    

    在这里插入图片描述

    ClientTest客户端

    public class ClientTest {
        public static void main(String[] args) throws IOException {
            System.out.println("----------这里是客户端----------");
            Socket client = new Socket("127.0.0.1",8888);
            //获取输出流
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(client.getOutputStream());
            //获得用户输入的数据
            Student student = Login();
            //发送给服务器,让服务器判断是否登陆成功
            objectOutputStream.writeObject(student);
            //接收服务器发过来的反馈
            DataInputStream dataInputStream = new DataInputStream(client.getInputStream());
            System.out.println(dataInputStream.readUTF());
            //关闭
            client.close();
            objectOutputStream.close();
            dataInputStream.close();
        }
        public static Student Login(){
            Scanner scanner = new Scanner(System.in);
            System.out.print("请输入学号: ");
            int son = scanner.nextInt();
            System.out.print("请输入密码: ");
            String password = scanner.next();
            return new Student(son,null,password,null,null);
        }
    }
    

    ServerTest服务器端

    public class ServerTest {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            System.out.println("----------这里是服务器端----------");
            //创建ServerSocket对象
            ServerSocket serverSocket = new ServerSocket(8888);
            //监听客户端是否链接
            Socket server = serverSocket.accept();
            //获得客户端发送过来的数据
            ObjectInputStream objectInputStream = new ObjectInputStream(server.getInputStream());
            Student student = (Student) objectInputStream.readObject();
            //输入sql语句,进入数据库内查询
            String sql = "select * from student where son = ? and password = ?";
            List<Student> list = Util.baseQuery(new Student(),sql,student.getSon(),student.getPassword());
            //判断是否登陆成功,然后告诉客户端
            String str = list.isEmpty() != true ? "登陆成功!" : "登陆失败!";
            //发送结果给客户端
            DataOutputStream dataOutputStream = new DataOutputStream(server.getOutputStream());
            dataOutputStream.writeUTF(str);
            //关闭
            server.close();
            objectInputStream.close();
            dataOutputStream.close();
        }
    }
    
    展开全文
  • java与数据库连接的jdbc技术

    千次阅读 2014-05-14 22:31:01
    JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为 多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。JDBC为数据库开发人员提供 了一个标准的API...
    JDBC是Sun公司制定的一个可以用Java语言连接数据库的技术。
    一、JDBC基础知识        
        JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为
    	多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。JDBC为数据库开发人员提供
    	了一个标准的API,据此可以构建更高级的工具和接口,使数据库开发人员能够用纯 Java API 编写数据
    	库应用程序,并且可跨平台运行,并且不受数据库供应商的限制。
    
    1、跨平台运行:这是继承了Java语言的“一次编译,到处运行”的特点;
    
    2、不受数据库供应商的限制:巧妙在于JDBC设有两种接口,一个是面向应用程序层,其作用是使得开发人员
       通过SQL调用数据库和处理结果,而不需要考虑数据库的提供商;另一个是驱动程序层,处理与具体驱动程
       序的交互,JDBC驱动程序可以利用JDBC API创建Java程序和数据源之间的桥梁。应用程序只需要编写一次,
       便可以移到各种驱动程序上运行。Sun提供了一个驱动管理器,数据库供应商——如MySQL、Oracle,提供的
       驱动程序满足驱动管理器的要求就可以被识别,就可以正常工作。所以JDBC不受数据库供应商的限制。
    
     JDBC API可以作为连接Java应用程序与各种关系数据库的纽带,在带来方便的同时也有负面影响,以下是
     JDBC的优、缺点。
     优点如下:
       (1).操作便捷:JDBC使得开发人员不需要再使用复杂的驱动器调用命令和函数;
       (2).可移植性强:JDBC支持不同的关系数据库,所以可以使同一个应用程序支持多个数据库的访问,只要加载
           相应的驱动程序即可;
       (3).通用性好:JDBC-ODBC桥接驱动器将JDBC函数换成ODBC;
       (4).面向对象:可以将常用的JDBC数据库连接封装成一个类,在使用的时候直接调用即可。
    缺点如下:
       (1).访问数据记录的速度受到一定程度的影响;
       (2).更改数据源困难:JDBC可支持多种数据库,各种数据库之间的操作必有不同,这就给更改数据源带来了很大
           的麻烦
    
    二、JDBC连接数据库的流程及其原理
         1、在开发环境中加载指定数据库的驱动程序。例如,接下来的实验中,使用的数据库是MySQL,所以需要去
           下载MySQL支持JDBC的驱动程序(最新的是:mysql-connector-java-5.1.18-bin.jar);而开发环境是
            MyEclipse,将下载得到的驱动程序加载进开发环境中。
    
          2、在Java程序中加载驱动程序。在Java程序中,可以通过 “Class.forName(“指定数据库的驱动程序”)”
            方式来加载添加到开发环境中的驱动程序,例如加载MySQL的数据驱动程序的代码为: 
           //  注册数据库驱动;固定写法
    	   Class.forName("com.mysql.jdbc.Driver");
    
    
          3、创建数据连接对象:通过DriverManager类创建数据库连接对象Connection。DriverManager类作用于
             Java程序和JDBC驱动程序之间,用于检查所加载的驱动程序是否可以建立连接,然后通过它的getConnection
             方法,根据数据库的URL、用户名和密码,创建一个JDBC Connection 对象。
             如:Connection connection =  DriverManager.geiConnection(“连接数据库的URL", "用户名", "密码”)。
             其中,URL=协议名+IP地址(域名)+端口+数据库名称;用户名和密码是指登录数据库时所使用的用户名和密码。
             具体示例创建MySQL的数据库连接代码如下:
    		// 打开数据库连接;数据库连接——java.sql.Connection.java
           Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/shopping","root","root");
    
          4、创建Statement对象:Statement 类的主要是用于执行静态 SQL 语句并返回它所生成结果的对象。
             通过Connection 对象的 createStatement()方法可以创建一个Statement对象。
    		 具体示例创建Statement对象代码如下: 
            //  操作数据库中的数据
    		//  获取操作数据库数据的对象——java.sql.Statement
    		    Statement stat = conn.createStatement();
    
          5、调用Statement对象的相关方法执行相对应的 SQL 语句:通过execuUpdate()方法用来数据的更新,
             包括插入和删除等操作:
    		 例如,向manager表中插入一条数据的代码:
    		 
    		  (1). //  定义要操作数据库的sql语句
    		  String sql = "insert into manager(username , password , gender , age) values('小猫' , '懒虫' , '女' , 18)";
    		 //  执行sql语句——增、删、改:执行insert语句
    		  stat.execute(sql);
    
    		  
    
    		  (2).//通过execuUpdate()方法用来数据的更新,用于向manager中插入数据
               statement.excuteUpdate( "INSERT INTO managert(usename, age, gender,address, phone, score,regno)" 
    	        + " VALUES ('Tom1', 32, '女', 'china','15294266276','3000','622412199222318736' ) ") ;
    		   
             通过调用Statement对象的executeQuery()方法进行数据的查询,而查询结果会得到 ResulSet对象,
             ResulSet表示执行查询数据库后返回的数据的集合,ResulSet对象具有可以指向当前数据行的指针。
             通过该对象的next()方法,使得指针指向下一行,然后将数据以列号或者字段名取出。
             如果当next()方法返回null,则表示下一行中没有数据存在。
    		 使用示例代码如下:
    		 (1).//  定义要执行的查询sql语句
    		  sql = "select * from manager";
    		 // 执行查询语句,查询时要返回查询结果的,查询结果存放在java.sql.ResultSet中
    		 ResultSet rs = stat.executeQuery(sql);
    		
    		 (2).ResultSet resultSel = executeQuery( "select * from manager" );
          6、关闭数据库连接:使用完数据库或者不需要访问数据库时,通过Connection的close() 方法及时关闭
             数据连接。
            具体代码如下:
             //  关闭连接
    		stat.close();
    		conn.close();

    展开全文
  • java 数据库连接

    2012-03-09 17:19:58
    java mysql 数据库连接教程 帮你学好数据库连接 技术
  • java数据库连接技术(JDBC)

    千次阅读 多人点赞 2020-07-17 22:37:19
    import java.sql.Statement; import javax.naming.spi.DirStateFactory.Result; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; public...

    代码详解

    package jdbcDemo;
    
    import java.sql.Statement;
    
    import javax.naming.spi.DirStateFactory.Result;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class ConnectJdbc {
    	
    	Connection conn =null;
    	public static void main(String[] args) throws Exception {
    		ConnectJdbc  cj = new ConnectJdbc();
    		cj.getCon();
    		
    		//新增表
    		//cj.addTable();
    		
    		//删除表
    //		cj.deleteTable();
    		
    //		查询
    		cj.queryData();
    		
    		//删除
    		//cj.deleteData(4456);
    		
    		//更新
    		//cj.updateData(4456);
    		
    		//新增
    		//cj.addData(4467, "Jake",5000);
    		cj.closeCon();
    		
    		
    	}
    	
    	
    	
    	//连接数据库
    	public Connection getCon() throws Exception {
    
    		//加载驱动
    		Class.forName("oracle.jdbc.OracleDriver");
    		//获得连接
    		//参数1  数据库地址
    		//参数2 数据库用户名
    		//参数3 密码
    		conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl",
    				"scott","root");
    		return conn;
    		
    	}
    	
    	//关闭数据库连接
    	public void closeCon() throws Exception {
    		conn.close();
    	}
    	
    	//新增表
    	public void addTable() throws Exception {
    		// 创建Statement对象   此对象帮我们执行sql
    		Statement st = conn.createStatement();
    		//写sql
    		String sql = "create table utable(name varchar(20),pwd char(6))";
    		//执行新增表语句,返回值为0
    		int rs = st.executeUpdate(sql);	
    		System.out.println(rs);
    		if(rs==0) {
    			System.out.println("创建用户表成功");
    		}
    	}
    	
    	//删除表
    	public void deleteTable() throws Exception {
    		// 创建Statement对象   此对象帮我们执行sql
    		Statement st = conn.createStatement();
    		//写sql
    		String sql = "drop table utable";
    		//执行删除表语句,返回值为0
    		int rs = st.executeUpdate(sql);	
    		System.out.println(rs);
    		if(rs==0) {
    			System.out.println("用户表删除成功");
    		}
    	}
    	
    	//查询
    	public void queryData() throws Exception {
    		
    		// 创建Statement对象   此对象帮我们执行sql
    		Statement st = conn.createStatement();
    		
    		//写sql
    		String sql = "select * from emp";
    		
    		//查询,返回结果集,存放返回的数据集合
    		ResultSet rs = st.executeQuery(sql);	
    		while(rs.next()) {
    			//取出一个字段,由于表中的empno为number,所以调用getInt()
    			//由于ename为varchar2,所以调用getString()
    			System.out.println(rs.getInt("empno")+" "+rs.getString("ename"));
    		}
    	}
    	
    	
    	//删除
    	public void deleteData(int id) throws Exception {
    		
    		// 创建Statement对象   此对象帮我们执行sql
    		Statement st = conn.createStatement();
    		//写sql
    		String sql = "delete from emp where empno="+id;
    		//删除,返回值为删除的行数
    		int rs = st.executeUpdate(sql);	
    		if(rs>0) {
    			System.out.println("删除成功");
    		}
    	}
    	
    	//更新
    	public void updateData(int id) throws SQLException {
    		// 创建Statement对象   此对象帮我们执行sql
    		Statement st = conn.createStatement();
    		//写sql
    		
    		
    		String sql = "update emp set sal=5000 where empno="+id;
    		//更新的行数
    		int rs = st.executeUpdate(sql);	
    		if(rs>0) {
    			System.out.println("更新成功");
    		}
    		
    	}
    	
    	//新增
    	public void addData(int empno,String ename,double salary) throws Exception {
    		// 创建Statement对象   此对象帮我们执行sql
    		Statement st = conn.createStatement();	
    		//写sql
    		String sql = "insert into emp(empno,ename,sal) values("+empno+",'"+ename+"',"+salary+")";
    		//新增的行数
    		int rs = st.executeUpdate(sql);	
    		if(rs>0) {
    			System.out.println("新增成功");
    		}
    	}
    	
    	
    }
    

    JDBC

    JDBC 数据库连接技术
    java database connectivity

    在这里插入图片描述使用数据库连接技术,需要jar包
    java 可以连接不同的数据库,但连接不同的数据库需要不同的jar包
    在这里插入图片描述在这里插入图片描述在这里插入图片描述

    eclipse导入jar包

    1.在java项目中连接JDBC
    1.新建java project项目,在该项目下建个文件夹,我的是jar,然后把jar包放入该文件夹下

    在这里插入图片描述2.把jar包导入java项目
    在这里插入图片描述导入成功
    在这里插入图片描述2.在web项目中,导入jar包

    在这里插入图片描述add to path后生成这个refered libraries文件夹
    在这里插入图片描述

    展开全文
  • Java线程池与数据库连接池区别

    千次阅读 2017-08-02 17:54:02
    线程池与数据库连接池的区别看到了MyCat参数设置时注意到了连接池的设置,突然发现好几个池化的概念,就顺手搜了一下
  • Java数据库连接 JDBC技术: 1.注册和加载驱动器 ; 2.数据库建立连接; 3.发送SQL语句; 4.处理结果; 5.关闭连接;
  • JDBC 核心技术解析 文章目录JDBC 核心技术解析数据库连接池1. JDBC数据库连接池的必要性2....主程序(如servlet、beans)建立数据库连接 进行sql操作 断开数据库连接 这种模式开发,存在的问题: 普通的JDBC数
  •  在Java语言,JDBC(Java DataBase Connection)是应用程序与数据库沟通的桥梁,  即Java语言通过JDBC技术访问数据库。JDBC是一种“开放”的方案,它为数据库应用开发人员﹑数据库前台工具开发人员提供了一种...
  • 文章目录JDBC 核心技术解析获取数据库连接1. 要素一:Driver接口实现类1.1 Driver接口介绍1.2 加载注册JDBC驱动2. 要素二:URL3. 要素三:用户名和密码4. 数据库连接方式举例4.1 连接方式一4.2 连接方式二4.3 连接...
  • Java数据库连接技术

    千次阅读 2004-06-16 15:21:00
    它的原理是,运行过程,同时打开着一定数量的数据库连接,形成数据连接池,当需要用到数据连接时,就从中取出一个连接,完成某些SQL操作后,系统自动回收,以供其它用户(或进程)调用。 我们知道,java标准的...
  • Java与数据库连接各框架的概念

    千次阅读 2019-11-22 00:49:47
    Java数据库连接,(Java Database Connectivity,简称JDBC)是Java语言用来规范客户端程序如何来访问数据库的应用程序接口,提供了诸如查询和更新数据库数据的方法。我们通常说的JDBC是面向关系型数据库的。 ...
  • java课程的技术,网页制作,并且连接数据库连接池),数据的管理
  • Java语言主流数据库连接池对比开发配置实战

    万次阅读 多人点赞 2017-03-27 16:08:59
    Java主流开源数据库连接池Druid 、TomcatJDBC 、DBCP 、C3P0、BoneCP性能,功能比较分析,Spring集成配置和JNDI配置方式
  • 一、前言很多项目数据库相关的配置文件内容都是以明文的形式展示的,这存在一定的安全隐患。开发和维护项目时,不仅要关注项目的性能,同时也要注重其安全性。二、实现思路我们都知道项目启动时,Spring ...
  • 基于Java数据库连接池的研究实现,谢俊,陈明,介绍了基于Java的数据库的访问机制,对实际应用出现的问题进行了分析,提出了数据库连接技术的解决方案,分析了连接池的工作原理,�
  • 在Java语言,JDBC(Java DataBase Connection)是应用程序与数据库沟通的桥梁,即Java语言通过JDBC技术访问数据库。JDBC是一种“开放”的方案,它为数据库应用开发人员﹑数据库前台工具开发人员提供了一种标准的...
  • Proxool是一种Java数据库连接技术。方便易用,便于发现连接泄漏的情况
  • Java面向对象程序设计 JDBC数据库连接技术 软件技术专业教学资源库 Connection 接口 第一部分 JDBC驱动由数据库厂商提供 个人开发测试可以使用JDBC-ODBC桥连方式 生产型开发推荐使用纯Java驱动方式 DB ...
  • Java程序数据库连接,数据源配置,数据库连接Java程序,用到的数据库一定要配置数据源吗? 一般写小程序直接程序里设置连接就可以了,而大的系统一般要配置数据源 数据源是要配置到中间件服务器的...
  • java数据库连接

    千次阅读 2007-12-05 10:01:00
    java数据库连接 JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准,据此可以...
  • JAVA之JDBC数据库连接池(超详细介绍)

    千次阅读 多人点赞 2020-07-09 16:34:50
    JDBC数据库连接池一、JDBC数据库连接池的必要性二、数据库连接技术三、多种开源的数据库连接池3.1 C3P0数据库连接池3.2 DBCP数据库连接池3.3 Druid(德鲁伊)数据库连接池 一、JDBC数据库连接池的必要性 1、使用...
  • JAVA连接MySQL数据库的一篇技术文献
  • java数据库连接池实现原理

    万次阅读 多人点赞 2014-05-10 10:53:53
     数据库连接是一种关键的有限的昂贵的资源,这一点多用户的网页应用程序体现得尤为突出。 一个数据库连接对象均对应一个物理数据库连接,每次操作都打开一个物理连接,使用完都关闭连接,这样造成系统的 性能...
  • JDBC 数据库连接技术简介

    千次阅读 多人点赞 2019-10-29 13:32:21
    介绍数据库连接技术 JDBC。
  • java获取数据库连接对象

    千次阅读 2016-11-06 13:29:25
    javaweb连接数据库

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 283,607
精华内容 113,442
关键字:

在java中与数据库连接的技术是

java 订阅