精华内容
下载资源
问答
  • java 自定义封装jdbc dao类

    千次阅读 2015-12-06 21:38:59
    手动封装jdbc和dao层,体会其中的优点与不足。 注:本次采用的mysql数据库记得添加数据库的驱动包。 Dbhelper类:对jdbc进行封装,采用单例模式,不用每次都去连接数据库,释放连接,影响性能,对sql语句进行封装...

    手动封装jdbc和dao层,体会其中的优点与不足。

    注:本次采用的mysql数据库记得添加数据库的驱动包。


    Dbhelper类:对jdbc进行封装,采用单例模式,不用每次都去连接数据库,释放连接,影响性能,对sql语句进行封装,利用列表数组动态添加数据,

    不需要一个一个设置,操作时只需传sql 语句和列表数组,前提是?与数组中的参数要一一对应。返回结果封装:对于执行操作,结果只有成功与失败;

    对于查询数据会封装进一个List<Map<String,String>>,同时释放结果集,提高系统的性能,方便用户操作。

    不足的是,数据库的信息是硬编码,不利于扩展


    package com.lzw.db1.db;
    
    
    
    import java.sql.*;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    
    /**
     * 该类是一个单例模式
     * jdbc封装类
     */
    public class DbHelper {
        private static DbHelper dbHelper = null;
        private static Connection connection = null;
        private static final String DRIVEN = "com.mysql.jdbc.Driver";
        private static final String URL = "jdbc:mysql://127.0.0.1:3306/book";
        private static final String USERNAME = "root";
        private static final String PASSWORD = "";
    
        private DbHelper() {
            if (connection == null) {
               getConnection();
            }
        }
    
        /**
         * 获取数据库连接
         */
        private void getConnection(){
    
            try {
    
                Class.forName(DRIVEN);
                connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
                System.out.println("数据库连接成功!");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }
    
        }
    
        /**
         * 获取实例,
         * @return
         */
        public static DbHelper getInstance() {
            if (dbHelper == null) {
                dbHelper = new DbHelper();
            }
            return dbHelper;
        }
    
        /**
         *
         * @param sql sql语句
         * @param list 注入数据
         * @return
         */
        public boolean excute(String sql, List<String> list) {
            boolean is = false;
            PreparedStatement preparedStatement = null;
            try {
                preparedStatement = connection.prepareStatement(sql);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            if (list != null)
                for (int i = 0; i < list.size(); i++) {
                    try {
                        preparedStatement.setString(i + 1, list.get(i));
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            try {
                int row = preparedStatement.executeUpdate();
                if (row > 0) {
                    is = true;
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                if (preparedStatement != null) {
                    try {
                        preparedStatement.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
            return is;
    
        }
    
        /**
         *
         * @param sql  sql语句
         * @param list 注入数据
         * @return
         */
    
        public List<Map<String, String>> query(String sql, List<String> list) {
            List<Map<String, String>> resultlist = null;
            ResultSet resultSet = null;
            ResultSetMetaData resultSetMetaData = null;
            PreparedStatement preparedStatement = null;
    
    
            try {
                preparedStatement = connection.prepareStatement(sql);
                if (list != null)
                    for (int i = 0; i < list.size(); i++) {
    
                        preparedStatement.setString(i + 1, list.get(i));
    
                    }
                resultSet = preparedStatement.executeQuery();
                resultSetMetaData = resultSet.getMetaData();
                resultlist = new ArrayList<Map<String, String>>();
                while (resultSet.next()) {
                    Map<String, String> map = new HashMap<String, String>();
                    for (int i = 0; i < resultSetMetaData.getColumnCount(); i++) {
                        //列示从1开始的
                        map.put(resultSetMetaData.getColumnName(i+1), resultSet.getString(i+1));
                    }
                    resultlist.add(map);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
    
                try {
                    if (resultSet != null)
                        resultSet.close();
                    if(preparedStatement!=null)
                        preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
    
    
            }
            return resultlist;
    
        }
    }
    

    UserDao:user表基本操作的封装


    package com.lzw.db1.dao;
    
    import com.lzw.db1.bean.User;
    import com.lzw.db1.db.DbHelper;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    /**
     * Created by Administrator on 2015/12/6.
     */
    public class UserDao {
        DbHelper dbHelper=null;
        public UserDao(){
            dbHelper=DbHelper.getInstance();
        }
    
        public User find(String id){
            String sql = "SELECT * FROM user where id=?";
            List<String> list = new ArrayList<String>();
            list.add(id);
            List<Map<String,String>> listresult=dbHelper.query(sql, list);
            if(listresult==null||listresult.size()==0){
                return  null;
            }else {
                User user=new User();
                user.setId(listresult.get(0).get("id"));
                user.setName(listresult.get(0).get("name"));
                user.setPassword(listresult.get(0).get("password"));
                return user;
            }
    
        }
        public boolean add(User user){
            String sql = "insert into user values(NULL ,?,?,UNIX_TIMESTAMP())";
            List<String> list = new ArrayList<String>();
            list.add(user.getName());
            list.add(user.getPassword());
            return  dbHelper.excute(sql,list);
        }
    
        public boolean update(User user){
            if(user==null||user.getId()==null){
                return false;
            }
            String sql = "update user set name=?,password=? where id=?";
            List<String> list = new ArrayList<String>();
            list.add(user.getName());
            list.add(user.getPassword());
            list.add(user.getId());
            return  dbHelper.excute(sql,list);
        }
    
        public boolean delete(String id){
    
            String sql = "delete from user where id=?";
            List<String> list = new ArrayList<String>();
            list.add(id);
           return dbHelper.excute(sql,list);
    
        }
    
    
    
    }
    




    展开全文
  • JavaJDBC查询结果封装到对象

    千次阅读 2018-03-15 14:06:52
    /*方式一:获取到的每列数据,使用setXXX()方法手动封装到User对象中 User u = new User(); u.setUid(rs.getInt("uid")); u.setUsername(rs.getString("username")); u.setPassword(rs.getString(...

    有任何问题加群讨论,还可以领取精美学习资料噢~

    群号:733899823

    加群时请备注CSDN~

    工程目录结构如下:

    User类:

    package com.xiao.pojo;
    
    /**
     * @author 笑笑
     * @Date   2018年3月15日上午9:20:28
     *	
     */
    public class User {
    	
    	private int uid = 0;
    	private String username = null;
    	private String password = null;
    	private int age = 0;
    	private String gender = null;
    	private String email = null;
    	
    	//空参构造器
    	public User() {
    	}
    	//有参构造器
    	public User(int uid, String username, String password, int age, String gender, String email) {
    		this.uid = uid;
    		this.username = username;
    		this.password = password;
    		this.age = age;
    		this.gender = gender;
    		this.email = email;
    	}
    	public int getUid() {
    		return uid;
    	}
    	public void setUid(int uid) {
    		this.uid = uid;
    	}
    	public String getUsername() {
    		return username;
    	}
    	public void setUsername(String username) {
    		this.username = username;
    	}
    	public String getPassword() {
    		return password;
    	}
    	public void setPassword(String password) {
    		this.password = password;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getGender() {
    		return gender;
    	}
    	public void setGender(String gender) {
    		this.gender = gender;
    	}
    	public String getEmail() {
    		return email;
    	}
    	public void setEmail(String email) {
    		this.email = email;
    	}
    	//重写toString
    	@Override
    	public String toString() {
    		return "User [uid=" + uid + ", username=" + username + ", password=" + password + ", age=" + age + ", gender="
    				+ gender + ", email=" + email + "]";
    	}
    
    	
    }

    封装测试类-JDBC_02.java:

    package com.xiao.jdbc;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.util.ArrayList;
    import java.util.List;
    import org.junit.Test;
    
    import com.xiao.pojo.User;
    import com.xiao.utils.JDBCUtils_01;
    
    /**
     * @author 笑笑
     * @Date   2018年3月15日下午1:15:20
     *	
     */
    public class JDBC_02 {
    	
    	//把结果集封装到对象
    	@Test
    	public void test() throws Exception{
    		//使用工具类注册并获取连接
    		Connection cn = JDBCUtils_01.getConnection();
    		//书写SQL语句
    		String sql = "select * from user_tb";
    		//获取SQL语句预编译对象
    		PreparedStatement ps = cn.prepareStatement(sql);
    		//执行SQL语句
    		ResultSet rs = ps.executeQuery();
    		//创建对象集合
    		List<User> list = new ArrayList<>();
    		//处理结果集
    		while(rs.next()){
    			/*方式一:获取到的每列数据,使用setXXX()方法手动封装到User对象中
    			User u = new User();
    			u.setUid(rs.getInt("uid"));
    			u.setUsername(rs.getString("username"));
    			u.setPassword(rs.getString("password"));
    			u.setAge(rs.getInt("age"));
    			u.setGender(rs.getString("gender"));
    			u.setEmail(rs.getString("email"));*/
    			//方式二:用有参构造器封装
    			User u = new User(
    					   rs.getInt("uid"),rs.getString("username"),
    					   rs.getString("password"),rs.getInt("age"),
    					   rs.getString("gender"),rs.getString("email")
    					);
    			//将封装的对象放入到集合中
    			list.add(u);
    		}
    		//增强for遍历对象集合
    		for (User user : list) {
    			System.out.println(user);
    		}
    		//释放资源
    		JDBCUtils_01.relase(cn, ps, rs);
    	}
    	
    }
    

    工具类-JDBCUtils_01.java:

    package com.xiao.utils;
    
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.Statement;
    /**
     * @author 笑笑
     * @Date   2018年3月15日上午10:55:16
     *	
     */
    public class JDBCUtils_01 {
    	//注册并获取数据库连接
    	public static Connection getConnection() throws Exception{
    		//1.注册驱动
    		Class.forName("com.mysql.jdbc.Driver");
    		//2.声明数据库连接信息,获取数据库连接
    		String url = "jdbc:mysql://localhost:3306/all_db";
    		String username = "root";
    		String password = "root";
    		Connection cn =  DriverManager.getConnection(url, username, password);
    		return cn;
    	}
    	//释放资源
    	public static void relase(Connection cn,Statement st,ResultSet rs) throws Exception{
    		if(rs!=null){									    
    			rs.close();
    		}
    		if(st!=null){
    			st.close();
    		}
    		if(cn!=null){
    			cn.close();
    		}			
    	}
    
    }
    


     

    展开全文
  • 在上一篇中数据库连接池虽然已经对JDBC的连接和释放做了优化,避免了资源的浪费,但在数据的操作上并未做出任何的改善,特别是在查询封装数据时更为麻烦。 举个例子,获取封装一个学生信息表,则需要将数据每一行中...

    @[TOC](Spring JDBC(JDBCTemplate))

    数据库连接池的弊端

    前情提要: JDBC数据库连接池.

    在上一篇中数据库连接池虽然已经对JDBC的连接和释放做了优化,避免了资源的浪费,但在数据的操作上并未做出任何的改善,特别是在查询封装数据时更为麻烦。

    举个例子,获取封装一个学生信息表,则需要将数据每一行中的每一列取出来再封装到学生类中打包到列表中,需要一大串的代码,麻烦且复杂

    public static void main(String[] args) {
            Connection connection = DruidUtils.getConnection();
            try {
                Statement statement = connection.createStatement();
                ResultSet resultSet = statement.executeQuery("select * from b");
    
                List<Student> list = new ArrayList<>();
                while (resultSet.next()) {
                    int id = resultSet.getInt("id");
                    String name = resultSet.getString("name");
                    int age = resultSet.getInt("age");
                    String sex =  resultSet.getString("sex");
                    String local = resultSet.getString("local");
                    String phone = resultSet.getString("phone");
    
                    Student student = new Student();
                    student.setId(id);
                    student.setName(name);
                    student.setAge(age);
                    student.setLocal(local);
                    student.setPhone(phone);
                    student.setSex(sex);
    
                    list.add(student);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    

    概述

    本文所有资源都可到百度云下载
    链接:https://pan.baidu.com/s/1EkEXRoMTiRN1GvXrGAx62g
    提取码:j872

    由spring框架对JDBC的简单封装,提供一个JDBCTemplate对象简化JDBC的数据操作。

    使用步骤

    导入jar包

    在这里插入图片描述

    获取JDBCTemplate对象

    需要依赖于连接池的数据源DataSource

    JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidUtils.getDataSource());
    

    操作数据

    先创建一个数据表
    在这里插入图片描述

    JDBCTemplate采用了PreparedStatement预先编译,提高 SQL 的执行效率和避免sql注入攻击,sql语句的数据采用?占位符代替

    增删改返回的结果都为影响数据表的行数

    1. 增加数据
    jdbcTemplate.update("INSERT INTO b VALUES(?,?,?,?,?,?)", null, "a", 10, "男", "北京", "111");
    
    1. 删除数据
    jdbcTemplate.update("DELETE FROM b WHERE id=?", 1);
    
    1. 修改数据
    jdbcTemplate.update("UPDATE b SET age=? WHERE id=?", 20, 2);
    
    1. 查询数据
    • queryForMap
      将查询的数据结果封装到Map<String, Object>集合中,列名为集合的key,数据值为集合的value
      需要注意的是,此查询结果有且仅有一条,查询的结果大于或小于一条是都会报错。
      例如查询整个数据表
    jdbcTemplate.queryForMap("select * from b");
    

    则会发生IncorrectResultSizeDataAccessException异常,因为queryForMap期望获取的结果大小为1,可是返回的结果且为4
    在这里插入图片描述

    正确示范:

    Map<String, Object> map = jdbcTemplate.queryForMap("select * from b where id = ?", 2);
    Set<String> set = map.keySet();
    for (String s : set)
    	System.out.println(s + ": " + map.get(s));
    
    • queryForList
      将查询的数据结果封装到List<Map<String, Object>>集合中,list集合中的每一条数据都为Map<String, Object>集合,就如queryForMap获取到的一条条数据封装到list集合中
    List<Map<String, Object>> list = jdbcTemplate.queryForList("select * from b");
    for (Map<String, Object> map : list) {
    	Set<String> set = map.keySet();
    	for (String s : set)
    		System.out.print(s + ": " + map.get(s) + "  ");
    	System.out.println();//换行
    }
    
    • query
    1. 实现RowMapper接口的T mapRow(ResultSet resultSet, int i)方法,对查询结果进行手动封装成list集合。

    resultSet为sql语句查询数据的结果集
    i表示第几行数据,从0开始

    List<Student> query = jdbcTemplate.query("select * from b", new RowMapper<Student>() {
    
    	@Override
        public Student mapRow(ResultSet resultSet, int i) throws SQLException {
    		Student student = new Student();
            student.setId(resultSet.getInt("id"));
            student.setName(resultSet.getString("name"));
            student.setAge(resultSet.getInt("age"));
            student.setSex(resultSet.getString("sex"));
            student.setLocal(resultSet.getString("local"));
            student.setPhone(resultSet.getString("phone"));
            return student;
    	}
    });
    

    这中手动封装的方式和前面的一样的复杂。

    1. 实现BeanPropertyRowMapper方法自动完成封装,程序会将数据表列名和javaBean的属性名相同的查询数据进行封装。
    List<Student> query = jdbcTemplate.query("select * from b", new BeanPropertyRowMapper<Student>(Student.class));
    

    注意:JavaBean中的属性都应该为引用数据类型,因为数据表的数据可能为null,当属性为基本数据类型(int)时不可赋值null,则会出现数据类型转换错误

    • queryForObjectbc
      将查询对象封装成对象,查询结果有且仅有一条一列
      一般使用在聚合函数上
    Integer lenght = jdbcTemplate.queryForObject("SELECT COUNT(ID) FROM b", Integer.class);
    
    展开全文
  • 一、为什么要封装Jdbc工具类 使用Jdbc连接数据库时,总会有一些代码是必不可少的,如加载驱动、获取连接、释放资源等。为了提高重用性,可以将他们封装在一个工具类中。 二、Jdbc工具类的功能 1:properties配置文件...

    一、为什么要封装Jdbc工具类

    使用Jdbc连接数据库时,总会有一些代码是必不可少的,如加载驱动、获取连接、释放资源等。为了提高重用性,可以将他们封装在一个工具类中。

    二、Jdbc工具类的功能
    • 1:properties配置文件 封装获取连接 释放资源 提高代码复用性√
    • 2:类加载时加载驱动√
    • 3:ThreadLocal控制事务
    • 4:连接池,提高资源利用率
    • 5:rowmapper封装 减少代码冗余
    • 6:template封装 减少dao层代码冗余
    三、实现封装,JdbcUtil.java:

    下面的代码仅实现前两种功能,剩余的功能会在以后的学习中实现,JdbcUtil.java:

    package util;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.Properties;
    
    /**
     * Jdbc工具类
     * 1:properties配置文件 封装获取连接 释放资源 提高代码复用性√
     * 2:类加载时加载驱动√
     * 3:ThreadLocal控制事务×
     * 4:连接池,提高资源利用率×
     * 5:rowmapper封装 减少代码冗余×
     * 6:template封装 减少dao层代码冗余×
     * @author 郭乾亮1998
     *
     */
    public class JdbcUtil {
    	//创建properties
    	static Properties pro = new Properties();
    	//加载驱动
    	static{
    		InputStream is = null;
    		try {
    			is = JdbcUtil.class.getResourceAsStream("/conf/db.properties");
    			//加载文件
    			pro.load(is);
    			Class.forName(pro.getProperty("driverClassName"));
    		} catch (Exception e) {
    			e.printStackTrace();
    		}finally{
    			try {
    				is.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	//获取连接
    	public static Connection getConnection() throws Exception{
    		String url = pro.getProperty("url");
    		String user = pro.getProperty("username");
    		String password = pro.getProperty("password");
    		
    		Connection conn = DriverManager.getConnection(url,user,password);
    		return conn;
    	}
    	//释放资源
    	public static void release(ResultSet rs,PreparedStatement pstm,Connection conn) throws Exception{
    		if(rs!=null){
    			rs.close();
    		}
    		if(pstm!=null){
    			pstm.close();
    		}
    		if(conn!=null){
    			conn.close();
    		}
    	}
    }
    
    conf文件夹中的properties文件如下设置:

    在这里插入图片描述

    三、封装测试,TestJdbcUtil类:
    package jdbc;
    
    import java.sql.Connection;
    
    import util.JdbcUtil;
    
    public class TestJdbcUtil {
    	public static void main(String[] args) throws Exception {
    		Connection conn = JdbcUtil.getConnection();
    		System.out.println(conn);
    		JdbcUtil.release(null, null, conn);
    	}
    }
    
    

    在这里插入图片描述

    展开全文
  • 这里我们就要用到jdbc了,但是使用发现,我们的代码重复度过高,于是,我们对这些重复的代码进行了封装,当然,封装是一个极具挑战性的任务,这里面用到类回调,用到了反射,都是Java中的难点,小编也是在几天的代码...
  • java jdbc util封装

    千次阅读 2018-01-07 20:58:24
    1.先写一个简单的jdbc查询操作,了解思路: package com.uwo9.testcrud; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java....
  • 封装工具类package demo1; import java.sql.Connection; import java.sql.DriverManager; public class JDBCutilDemo { private static final String DRIVERNAME = "com.mysql.jdbc.Driver"; private...
  • 1、JDBC封装访问数据库的基类,目的是重用数据库访问代码 封装以下方法: MySQL数据库的连接 数据库关闭 开启数据库事务 提交数据库事务 事务回滚 注意没有封装存储过程的调用 /** * <p>Title: ...
  • JavaJDBC的使用详解

    万次阅读 多人点赞 2018-07-28 22:31:11
    打个广告,帮朋友卖点东西,东西超便宜的哟【衣服鞋子等】,厂家直接出货,绝对低于市场价!!!一般都比市场价便宜3—7... 新建一个Java工程jdbc,并导入数据驱动。 二、详细步骤 1、加载数据库驱动 //1.加载...
  • 封装JDBC—非框架开发必备的封装类

    千次阅读 多人点赞 2017-06-07 21:43:48
    一些小型的项目,有时不想使用框架如MyBatis,Hibernate等开发时,往往在数据持久化时操作比较繁琐,以下提供了对JDBC封装类,简化JDBC操作。 为了更客观展示MyJDBC,我们通过一般的JDBC连接数据库的增删改查来...
  • SpringBoot封装JDBC

    2020-07-14 20:39:05
    SpringBoot封装JDBC 1.创建sringBoot项目,导入基础模块 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-anatwnAY-1594730300080)(C:\Users\帅涛的电脑\AppData\Roaming\Typora\typora-...
  • 1。实现了action层的调度 2。实现了JDBC封装 3。实现了简单的事务管理
  •  在Java程序实现中,我们往往应用到事务的机制,在业务层进行事务开启,创建数据库连接,调用Dao层方法进行数据库访问,过程中需要将数据库连接Connection作为参数传递给Dao层方法。显而易见,这样的实现不利于Dao...
  • javaJDBC的使用与封装

    千次阅读 2020-06-20 16:06:57
    JDBC连接过程: 1.导入相关的JDBC驱动jar包; ①:新建一个文件夹,命名为lib; ②:将jar包粘贴至此文件夹; ③:右键jar包,Add to Build Path; ④:完成。 2.注册驱动,把mysql的Driver对象注册到java.sql....
  • Java进阶之JDBC知识点总结

    千次阅读 2014-12-02 23:38:25
    向大家介绍的是Java中的JDBC技术,这一技术对每个Java程序员来说都是非常关键的。
  • JDBC JDBC是一套标准(接口),用来连接【关系型数据库】。各个数据库厂商去实现具体的功能,用户使用时使用相同...其中JDBCjava版本的ODBC. ODBC(Open Database Connectivity)开放的数据库连接,由微软开发出来。...
  • JDBCJava中对数据进行操作 JDBC事务处理 JDBC封装工具类 操作所有数据库的方式 使用第三方图形化工具来访问MySQL:SQLyog、Navicat、SQLWave等 使用DOS命令行方式 核心:通过Java来访问MySQL数据库 案例: 使用...
  • 第十三天 - 封装JDBC操作Hive工具类 - HWI配置与使用 - JavaWeb结合Hive 第十三天 - 封装JDBC操作Hive工具类 - HWI配置与使用 - JavaWeb结合Hive 一、Hive Sql语句补充 二、封装JDBC操作Hive工具类 三、...
  • JAVA基础:JDBC的使用 附详细代码

    千次阅读 热门讨论 2021-03-22 23:50:16
    JDBC使用大全
  • 1.创建数据库表和索引(数据库操作工具使用的是华为Data Studio) 设置数据库主键列: ...2.封装高斯数据库JDBC访问类 •下载GaussDB数据库JDBC驱动jar包: JDBC包名: com.huawei.gaus...
  • Java中的JDBC(详解、带例子)

    千次阅读 2019-10-24 14:11:26
    一、 JDBCJava DataBase Connectivity,Java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成,JDBC提供一种基准,据此可以构建更高级的...
  • java JDBC

    千次阅读 2016-06-02 12:23:07
    一、JDBC常用接口、类介绍 JDBC提供对独立于数据库统一的API,用以执行SQL命令。API常用的类、接口如下:  DriverManager  管理JDBC驱动的服务类,主要通过它获取Connection数据库链接,常用方法如下: ...
  • 1.JDBCJava DataBase Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准,据此可以构建更高级的工具...
  • Java JDBC

    千次阅读 2013-11-18 16:53:19
    一、JDBC常用接口、类介绍 JDBC提供对独立于数据库统一的API,用以执行SQL命令。API常用的类、接口如下:  DriverManager  管理JDBC驱动的服务类,主要通过它获取Connection数据库链接,常用方法如下: ...
  • JavaWeb——Jdbc Template增删改查案例 一、学习目标 能够完成列表查询 能够理解分页的实现原理 能够完成修改用户的功能 能够完成删除指定用户的功能 二、项目简介 1.项目功能简介 查询联系人 添加联系人 ...
  • Java---JDBC学习

    2016-04-07 16:24:14
    Java---JDBC学习 1、JDBC简介 JDBC全称为Java Data Base Connectivity(java数据库链接) 可以为多种数据库提供统一的访问 体现了Java“编写一次,处处运行”的高大上精神 2、JDBC编程步骤 1、加载...
  • 二、封装JDBC工具类 之前的JDBC代码分析: 我们可以先回顾一下上一篇博文中的第五段:使用PreparedStatement重构增删改查。 通过分析可以发现有以下不足:有许多重复的代码、每次都要加载驱动、获取连接等...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,649
精华内容 12,259
关键字:

java手动封装jdbc结果

java 订阅