精华内容
下载资源
问答
  • 通用的jdbc增删改查

    2018-10-13 22:02:11
    通用的jdbc增删改查,仅仅只是两个通用的方法,利用反射和泛型
  • 主要介绍了JDBC增删改查和查唯一的完整代码解析,代码分为第四部分,每部分代码都不错,对jdbc增删改查操作感兴趣的朋友一起学习吧
  • 简单的jsp+servlet+jdbc+javaBean实现的增删查改项目,供新手参考
  • java十分经典的jdbc增删改查程序,含sql语句
  • JDBC增删改查

    2018-03-26 19:53:42
    JDBC增删改查 1.案例需求:jdbc增删改查 2.需要注意的:a.优化了注册驱动的步骤: //1.注册驱动com.mysql.jdbc.Driver DriverManager.registerDriver(new Driver()); 缺点:1.造成驱动被注册了两次  2.是...

    JDBC增删改查

    1.案例需求:jdbc增删改查
    2.需要注意的:a.优化了注册驱动的步骤:

    //1.注册驱动com.mysql.jdbc.Driver  
    DriverManager.registerDriver(new Driver());

    缺点:1.造成驱动被注册了两次
       2.是程序和驱动产生了紧耦合
    解决方法:Class.forName(“com.mysql.jdbc.Driver”); 
     
          b.传输器对象Statement
          作用:用来执行SQL
          提供的常用方法:
          executeQuery —执行查询的SQL
          executeUpdate — 执行增删改的SQL,返回int 类型

    package on.jdbc;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    import org.junit.Test;
    
    /**
     * 这个类用做jdbc的增删改查操作
     * 
     * @date 2018年3月23日
     *
     */
    public class JDBCCURD {
        Connection conn=null;
        Statement st=null;
        //需求:向account中插入一条记录
        //name为xiongda,money为2000
        @Test
        public void add(){
            try {
                //1.注册驱动
                Class.forName("com.mysql.jdbc.Driver");
                //2.获取数据库连接java.sql.Connection
                conn=DriverManager.getConnection("jdbc:mysql:///jt_db","root","root");
                //3.获取传输器java.sql.Statement
                st=conn.createStatement();
                String sql="insert into account values( null,'xiongda','2000')";
                //4.执行SQL语句
                int rows=st.executeUpdate(sql);//返回一个int
                //5.获取结果集
                System.out.println(rows);
            } catch (Exception e) {
    
                e.printStackTrace();
            }finally{
                //6.关闭资源
                if(conn!=null){
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }finally{
                        conn=null;
                    }
                }
                if(st!=null){
                    try {
                        st.close();
                    } catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
        //需求:修改account表中
        //id为3的money为1000
        @Test
        public void update(){
            Connection conn=null;
            Statement st=null;
            try {
                //1.注册驱动
                Class.forName("com.mysql.jdbc.Driver");
                //2.获取数据库连接
                conn=DriverManager.getConnection("jdbc:mysql:///jt_db","root","root");
                //3.获取传输器
                st = conn.createStatement();//快捷键 Ctrl+1;
                //4.执行SQL
                String sql="update account set money=1000 where id=3";
                int rows=st.executeUpdate(sql);//返回一个int
                //5.获取查询结果集
                System.out.println(rows);
    
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                //6.关闭资源
                if(conn!=null){
                    try{
                        conn.close();
                    }catch(SQLException e){
                        e.printStackTrace();
                    }finally{
                        conn=null;
                    }
                }
                if(st!=null){
                    try{
                        st.close();
                    }catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
        //需求:
        //删除account表中id为3的数据
        @Test
        public void delete(){
            Connection conn=null;
            Statement st=null;
            try {
                //1.注册驱动
                Class.forName("com.mysql.jdbc.Driver");
                //2.获取数据库的连接
                conn=DriverManager.getConnection("jdbc:mysql:///jt_db","root","root");
                //3.获取传输器
                st = conn.createStatement();    
                String sql="delete from account where id=3";
                //4.执行SQL
                int rows=st.executeUpdate(sql);
                //5.获取查询结果集
                System.out.println(rows);
    
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                //6.关闭资源
                if(conn!=null){
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }finally{
                        conn=null;
                    }
                }
                if(st!=null){
                    try {
                        st.close();
                    } catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }finally{
                        st=null;
                    }
                }
            }
        }
    
    }
    
    
    展开全文
  • struts2+jdbc增删改查

    2018-05-20 21:14:55
    基于初学struts2框架的人群,能更好的理解struts2和jdbc框架的使用,包含struts2、jstl标签库、MySQL数据库连接的jar包以及数据库文件,下载导入即可使用
  • 简单的springboot+jdbc增删改查,实现了与数据库的连接
  • JDBC增删改查简单例子

    2017-04-12 16:37:54
    JDBC对用户的增删改查的实现
  • jdbc实现增删改查.rar

    2019-09-01 19:07:33
    使用jquery easyui和原生jdbc实现 增删改查以及分页显示
  • 轻量级jdbc 封装类,适用于不使用mybatis hibernate等轻量级场合, 无需太多配置。
  • 前期项目 Spring+Spring MVC+JDBC Template 增删改查,包含建库,前端加后台
  • clickhouse jdbc 增删改查

    2021-08-04 08:43:42
    提示:本文利用MergeTree作为引擎 获取连接(示例): ... String address = "jdbc:clickhouse://1.1.20.169:8123/default"; Class.forName("ru.yandex.clickhouse.ClickHouseDriver"); connection = Drive

    提示:本文利用MergeTree作为引擎
    pom依赖

    		<dependency>
    			<groupId>org.apache.logging.log4j</groupId>
    			<artifactId>log4j-slf4j-impl</artifactId>
    			<version>2.11.0</version>
    		</dependency>
    		<dependency>
    			<groupId>ru.yandex.clickhouse</groupId>
    			<artifactId>clickhouse-jdbc</artifactId>
    			<version>0.2.6</version>
    		</dependency>
    

    获取连接(示例):

        public void getConn() throws SQLException, ClassNotFoundException{
        	String address = "jdbc:clickhouse://127.0.0.1:8123/default";
        	Class.forName("ru.yandex.clickhouse.ClickHouseDriver");
            connection = DriverManager.getConnection(address);
    
        }
    

    建表(示例):

        public void creatTable() throws SQLException{
        	String sql = "create table IF NOT EXISTS t_skip("
        			+ "id String,"
        			+ "website String,"
        			+ "code String,"
        			+ "createtime datetime"
    //    			+ ","   //索引部分
    //    			+ "index ix_id id type minmax granularity 5," 
    //    			+ "index ix_length(length(id)*8) type set(2) granularity 5,"
    //    			+ "index ix_id_code (id,code) type ngrambf_v1(3,256,2,0) granularity 5,"
    //    			+ "index ix_token id type tokenbf_v1(256,2,0) granularity 5"
        			+ ")"
        			+ "engine=MergeTree() "
        			+ "partition by toYYYYMM(createtime) "
        			+ "order by id primary key id" ; 
        	PreparedStatement ps = connection.prepareStatement(sql);
        	ps.execute();
        	ps.close();
        }
    

    单条新增(示例):

        public void insert() throws SQLException, ParseException{
        	String sql = "INSERT INTO t_skip (id,website,code,createtime) VALUES (?,?,?,?)";
        	PreparedStatement ps = connection.prepareStatement(sql);
        	ps.setString(1, "1");
        	ps.setString(2, "2");
        	ps.setString(3, "3");
        	ps.setTimestamp(4, LocalDateTime.of("2022-07-01 11:11:11").toTimestamp() ); //时间戳转换
        	ps.execute();
        	ps.close();
        }
    

    多条新增(示例)仅需几百毫秒:

    public void insert100000() {
        	System.out.println(LocalDateTime.now());
        	String sql = "INSERT INTO t_skip (id,website,code,createtime) VALUES (?,?,?,?)";
            PreparedStatement prepareStatement = null;
            try {
                connection.setAutoCommit(false);
                prepareStatement = connection.prepareStatement(sql);
                for(int i=0;i<100000;i++) {
                	prepareStatement.setString(1, "1");
                	prepareStatement.setString(2, "2");
                	prepareStatement.setString(3, "3");
                	prepareStatement.setTimestamp(4, LocalDateTime.of("2022-06-02 11:11:11").toTimestamp() );
                    prepareStatement.addBatch();
                }
                prepareStatement.executeBatch();
                connection.commit();
            } catch (Exception e) {
               e.printStackTrace();
            } finally {
                if (prepareStatement != null) {
                    try {
                        prepareStatement.close();
                    } catch (SQLException e) {
                    }
                }
            }
            System.out.println(LocalDateTime.now());
        }
    

    删除(示例):

        public void delete() throws SQLException{
        	String sql = "ALTER TABLE t_skip DELETE WHERE id = ?";
        	PreparedStatement ps = connection.prepareStatement(sql);
        	ps.setString(1, "1111111111");
        	ps.execute();
        	ps.close();
        }
    

    分区删除(示例):

    	public void deleteByPARTITION() throws SQLException{
        	String sql = "ALTER TABLE t_skip DROP PARTITION '202205'";
        	PreparedStatement ps = connection.prepareStatement(sql);
        	ps.execute();
        	ps.close();
        }
    

    修改(示例):

        public void update() throws SQLException{
        	String sql = "ALTER TABLE t_skip UPDATE website=? WHERE id=?";
        	PreparedStatement ps = connection.prepareStatement(sql);
        	ps.setString(1, "xxxxxxxxxxx");
        	ps.setString(2, "1");
        	ps.execute();
        	ps.close();
        	
        }
        ```
    
    
    展开全文
  • Spring JDBC 增删改查

    2013-09-09 16:34:41
    Spring JDBC 增删改查
  • struts+jdbc增删改查

    2015-03-18 16:09:27
    struts+jdbc增删改查,,, struts2.0 一个小案例
  • Java之JDBC连接数据库实现增删改查(2018 使用Dao层实现) 实体类:User.java 接口类:IUserDao.java 实现接口类:UserDaoImpl.java 使用Junit4测试增删改查类:UserDaoTest.java
  • 那么这讲本帅将接着上次未完待续的开始讲解,这讲你将会了解到:JDBC增删改查操作,JDBCUtil封装的工具类, 废话不多说,现在开始吧! JDBC的连接以及增删改查 基本步骤: 加载JDBC驱动管理器 {Class.for....

    引言

    上一讲讲到了Android如何通过JDBC连接到mysql远程数据库,什么?忘记啦!给你个传送门好好复习!

    传送门: Android通过JDBC连接远程数据库

    那么这讲本帅将接着上次未完待续的开始讲解,这讲你将会了解到:JDBC的增删改查操作,JDBCUtil封装的工具类
    废话不多说,现在开始吧!

    JDBC的连接以及增删改查

    基本步骤:

    1. 加载JDBC驱动管理器 {Class.forName(com.mysql.jdbc.Driver0)//加载类,名字为myql包下的jdbc的驱动类,为固定写法}
    2. 连接数据库
    3. 开启Statement,执行sql语句
    4. 得到结果集 (仅查找)
    5. 对结果集进行操作
    6. 关闭释放资源(栈式关闭,先关闭结果集,再关闭statement,最后关闭连接)

    相信对于之前的学习,小伙伴们已经掌握了1,2步骤,具体伪代码实现如下:

    1.Class.forName(com.mysql.jdbc.Driver);//类的加载(加载MySQL的JDBC驱动)
    2.String url = jdbc:mysql://局域网ip:port/mysqldatabase
    String username = root//本帅创建的可远程访问数据库的用户的用户名和密码
    String password = “”;
    Connection connection = DriverManager.getConnection(url,username,password);

    这里看不懂的小伙伴接着回去复习~!

    3.开启statement,执行sql语句(statement为陈述句)
    其语法为: Statement stmt = connection.creatStatement();
    stmt.execute(sql)
    其中sql 语句有插入,删除,修改和查询,其中执行查询方法有返回结果集,见4
    当执行删除/修改等sql语句时,若采用sql = ”delete form user where id =“ + id (有可能被sql注入)
    sql注入: String id = ”1 or 1=1" 由于1==1恒成立,所以会删除数据表user中的所有数据
    为了解决sql注入问题,采用PrepareStatement + 占位符的形式来防止sql注入
    PreparedStatement ps = connection.preparedStatement();
    如:sql = “delete from user where id= ?”//此处的?即为占位符
    ps.setObject(1,2);//用准备好的陈述设置第一个问号的值为2

    4.sql为查询语句时,有结果集
    Resultset rs = stmt.executeQuery(sql)

    5.通过rs.next方法,对结果集进行操作

    6.关闭资源(rs,statement,connection)

    example(insert)

    JDBC执行插入代码如下:

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    public class insert{
    
        private static Statement stmt = null;//静态方法在类加载的时候就加载,所以stmt必须是static 类型
        private static  Connection connection = null;
    
        public  static void main(String[] args){
            try {
                //1.加载jdbc驱动类
                Class.forName("com.mysql.jdbc.Driver");
                //2.获取远程mysql连接(url(主要用到的是ip+port+databaseName),user,password(主要用到的是phpMyadmin创建的可远程访问的用户的用户名和密码))
                String url = "jdbc:mysql://192.168.43.160:3306/test";//通过jdbx访问mysql数据库服务器,远程服务器ip为192.168.43.160 ,port为3306,数据库名称为 test
                //phpMyadmin中创建的可远程访问权限的用户的用户名和密码
                String user = "root";
                String password = "";
               connection = DriverManager.getConnection(url,user,password);//jdbc 连接上mysql服务器上的test数据库了
                //3.开启sql称述,(Statement,PreparedStatement(?占位符形式)),执行sql语句
                stmt = connection.createStatement();
                String sql = "insert into user(id,username) values (1,'张大帅比')";
                stmt.execute(sql);
                //4.获取结果集(只有查询有)
                //5.对结果集进行操作(只有查询有)
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                //6.对资源进行关闭(Resultset(此处没有),stmt,connection(采用栈式关闭)) 不能放入一个try catch 中,因为若一个执行失败,则其余资源也无法关闭
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
        }
    }
    
    

    Android stutdio 中未运行以上代码前
    在这里插入图片描述
    Android stutdio 中未运行以上代码后
    在这里插入图片描述
    至此,插入完毕!

    example(delete)

    JDBC执行删除代码如下:

    package JDBC;
    

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

    //删
    public class deleteUtil {
    private static PreparedStatement ps =null;
    private static Connection connection=null;

    public static void main(String[] args){
    
        try {
       //加载类驱动
        Class.forName("com.mysql.jdbc.Driver");//通过反射加载jdbc驱动类
        //获取连接
        String url = "jdbc:mysql:// 192.168.43.160:3306/test";//用jdbc连接mysql下的服务器,服务器ip为192.168.43.160,数据库访问端口为3306,数据库名称为test
        String user = "root";
        String password = "";
        connection = DriverManager.getConnection(url,user,password);
        //创建陈述sql对象
        String sql = "delete from user where id = 1";//删除id = 1 的记录
            ps = connection.prepareStatement(sql);//有定义有准备的陈述sql
            //设置占位符
            ps.setObject(1,1);
            int result=ps.executeUpdate();//executeUpdate方法如果有返回值,则代表该操作影响了返回值条记录
            System.out.print(result);
        } catch (Exception e) {
            e.printStackTrace();
        }finally{//栈式关闭资源(rs,ps,Connection)
           
                try {
                    if(ps!=null){
                        ps.close();
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            try {
                if(connection!=null){
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            
        }
    
      }
    }
    

    此代码运行完成后,删除数据库中id=1的记录,也即上图中的那条记录将被删除

    运行代码前
    在这里插入图片描述
    运行代码后

    在这里插入图片描述
    在这里插入图片描述
    此时可以看到,user表中id=1的记录全部被删除了,JDBC删除记录功能get!

    看了以上的代码,相信聪明的小伙伴们已经发现了,虽然JDBC的记录插入和删除实现代码不一样,但还是存在相同的耦合的代码,
    如第一步类的驱动加载,以及第二步的获取连接,以及最后的关闭资源等,代码都是一样一样的。想到一般情况下,同时只访问一个数据库下的不同表,本帅决定将耦合的代码重构,创建出一个JDBCUtil工具类,用以简化代码,明确逻辑,减少代码的耦合性。

    分析:1.加载JDBC驱动类是固定写法,直接在JDBCUtil也如此写即可。
    2.获取连接时主要通过以下几行代码实现
    Connection connection = DriverManager.getConnection(url,username,password);
    其中url 随着 访问的数据库的不同服务器ip数据库访问端口的不同而不同
    而用户自定义的mysql可远程访问权想的用户也不尽相同,因此,我们需要在JDBCUtil中创建这些成员变量,当以上的某个值变化时方便改动,或者利用构造函数传入等。
    3.关闭资源。关闭资源主要包含:关闭结果集rs,关闭Prestatement ps,关闭连接connection(栈式关闭)且为了防止前面的资源关闭出错,后续的关闭不执行,需要将其放在不同的代码块下。

    综上我们可以写出JDBCUtil工具类的具体代码,如下所示:

    JDBCUtil工具类

    		package JDBC;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    
    /**
     * JDBC工具类  (通常将方法设置为静态方法,不然还要通过new 一个对象来调用方法,不优雅,类加载时即加载)
     * 1.获取连接fangf
     * 2.关闭释放jdbx使用的资源
     * */
    public class JDBCUtil {
        private static Connection connection;
        private static String url; //= "jdbc:mysql://"+ ip + ":" + port +"/"+  mysqldatabase
        //远程访问mysql数据库权限用户的用户名和密码
        private  static String username = "root";//用户名通常为root
        private  static String password = "";//密码通常空
        //服务器ip,数据库访问端口port,数据库名称mysqldatabase
        private static String ip = "192.168.43.160";
        private static int port = 3306;//数据库访问端口号通常为3306
        private static String mysqldatabase = "test";
        private static PreparedStatement ps;
    
        /**1.
         * 获取jdbc连接的方法getconnection (通过JDBCUtil.getConnection()来获取一个JDBC的连接)
         * ip 为数据库所在的远程服务器的ip地址
         * port 为数据库访问的端口
         * mysqldatabase  要连接的数据库名称
         * */
       // public static Connection getConnection(String ip,String mysqldatabase){
        public static Connection getConnection(){
            try {
                    //1加载驱动
                    Class.forName("com.mysql.jdbc.Driver");
                    //String url = "jdbc:mysql://ip:port/数据库名称";(port通常是3306,ip需输入,数据库名称需输入,用户名密码为PHPMyAdmin的进入密码)
                   //2.获取连接,url为jdbc连接:连接的mysql,服务器ip+数据库的名称   再由驱动管理者获取连接(url,username,password)
                    url = "jdbc:mysql://"+ ip + ":" + port +"/"+  mysqldatabase;
                    return connection = DriverManager.getConnection(url, username, password);
                } catch (Exception e) {//捕捉所有的异常
                    e.printStackTrace();
                }
                return null;
        }
    
    
        /**2.
         * 关闭,释放资源的方法close (若不存在使用下列资源,传递参数为null即可,通过JDBCUtil.close()关闭资源)
         * rs 为结果集,通过JDBC查到的结果集,使用后需关闭释放资源
         * stmt 为开启的sql语句
         * connection 为jdbc的连接
         * */
        public static void close(ResultSet rs, Statement stmt,Connection connection){//栈式关闭(最先连接,最后关闭连接)
            try{//关闭结果集
                if(rs!=null) rs.close();
            }catch (SQLException e){
                e.printStackTrace();
            }
    
            try{//关闭sql语句
                if(ps!=null) ps.close();
                if(stmt!=null) stmt.close();
            }catch (SQLException e){
                e.printStackTrace();
            }
    
            try{//关闭连接
                if(connection!=null) connection.close();
            }catch (SQLException e){
                e.printStackTrace();
            }
    
        }
    
    
    }
    

    此时我们就能利用JDBCUtil类来简化我们的代码啦!
    首先是获取连接代码 : Connection conection = JDBCUtil.getConnection();
    使用完资源后关闭资源的代码:JDBCUtil.close();

    至此,我们接下来的更新和查询都使用JDBCUtil封装的方法来简化实现,具体如下:

    example(update)

    JDBC执行更新代码如下:

    	package JDBC;
    

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

    public class updateUtil {

    private static PreparedStatement  ps=null;
    
    public static void main(String[] args){
        Connection connection = JDBCUtil.getConnection();
    
    
        try {
            String sql="update  user  set id= ?,username =? where id = ?";
            ps = connection.prepareStatement(sql);
            ps.setObject(1,3);
            ps.setObject(2,"张大帅");
            ps.setObject(3,1);
            int result = ps.executeUpdate();
            System.out.print(result);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JDBCUtil.close(null,ps,connection);
        }
    }
    

    }

    执行代码前
    在这里插入图片描述
    执行代码后
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    至此,咱们写的JDBCUtil工具类经检测可以使用,JDBC的更新操作也能完美执行啦!

    example(query)

    使用JDBC查询操作的代码如下:

    		package JDBC;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class queryUtil {
    
        private static PreparedStatement ps=null;
        private static   ResultSet rs = null;
    
        public static void main(String[] args){
            Connection connection = JDBCUtil.getConnection();
    
            try {
                String sql="select * from user ";
                ps = connection.prepareStatement(sql);
                rs =ps.executeQuery();
                while (rs.next()){//游标结果集不为空,则输出
                    System.out.print(rs.getInt(1)+"--"+rs.getString("username"));
                    //System.out.print(String.valueOf(rs.getClob(2)));
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                JDBCUtil.close(rs,ps,connection);
            }
    
        }
    
    }
    

    当执行以上代码时,此时数据库中的内容就打印出来了,如下图:

    在这里插入图片描述

    至此,JDBC的查询操作也完美收官。

    附:JDBC出错处理:

    当jdbc语句出错时,找到dao类,将sql语句复制粘贴到PHPmyAdmin里。
    如:
    在这里插入图片描述
    在这里插入图片描述
    在phpadmin服务器上执行一遍看能不能执行,能执行则没有错误。

    结语

    好啦,这次的博客到这里就要跟大家说再见啦!截止到这篇博客,JDBC的讲解也暂时告一段落了,下一次帅比本帅将记录本帅在使用PHPMyadmin创建数据库时,所遇到的数据库插入中文的编码问题,以及JDBC在Android跑起来的实战。点个小手跟我一起期待后续吧!!

    展开全文
  • Struts2 JDBC 增删改查

    2012-12-13 13:22:59
    这是一个基于Struts2 jdbc的单表增删改查,绝对好用,我的主键是通过 sequence来自增的 ,其他的看代码即可。
  • 简单的jdbc增删改查

    2012-03-01 17:35:35
    java中简单的mysql数据库连接JDBC,包含了配置文件(Config)
  • jdbc增删改查加分页

    2019-04-14 01:23:34
    NULL 博文链接:https://zhang964761032.iteye.com/blog/1742235
  • JDBC增删改查.pdf

    2021-06-07 17:41:07
    jdbc连接sqlserver增删改查 javascript非空验证
  • java增删改查JDBC封装类(泛型封装),这个是高度封装化的,增删改查,直接用到我的项目中去的。
  • JDBC增删改查封装(mysql)

    千次阅读 多人点赞 2019-04-15 22:28:05
    基于mysql的JDBC增删改查的封装 这是一篇有节操的博客,主要介绍JDBC对数据库(这里以mysql为例)的操作:添加数据,修改数据,删除数据,查询数据(用反射来实现),先说明我不是手把手,哈哈太简单的步骤就略过吧~ 若您的...

    基于mysql的JDBC的增删改查的封装

    忧伤…昨晚写的代码简直不能看啊,你们看完了竟然不告诉我~哼!
    趁着我现在有空,把这篇博客再优化一下,就叫我女神吧!
    首先,这是一篇有节操的博客,主要介绍JDBC对数据库(这里以mysql为例)的操作:添加数据,修改数据,删除数据,查询数据(用反射+内省来实现)
    若您的火眼金睛发现我有小错误的话,咱们评论中交流哇~

    1 数据库(mysql)操作:

    在数据库中创建一张表,这里以用户表为例,如下图:table_name:user,您的table,怎么舒服怎么建:
    还有jdbc驱动的jar包的引入我就略了,不要忘记导入这个jar包噢~
    user

    2 创建类(User.java):

    先封装一个用户类(User),当然你可以封装其他的类,在封装类的时候注意以下两点:

    1. 类中的属性名要和数据库对应表的列名一致(一模一样拿过来就对了):是为了方便后面通过内省获取指定方法,名字不一样的话,找到地老天荒也找不到┗|`O′|┛ 嗷~~
    2. 属性(成员)的数据类型最好是包装类型:通过内省获取的方法传参时用的是从数据库中拿出来的数据(放到结果集中了),你可以测试一下,这些数据是包装类型欧
    也可以不实现Serializable接口,这个是实现数据库连接池时使用的,懒得删了~

    package com.myproject.beans;
    import java.io.Serializable;
    /**
     * Administrator
     * 2019/4/15 0015
     * 用户类
     */
    public class User implements Serializable {
        private static final long serialVersionUID = 373910607014836778L;
        private Integer id;
        private String username;
        private String password;
        private Integer age;
        private String gendar;
    
        public User() {
        }
    
        public User(Integer id, String username, String password, Integer age, String gendar) {
            this.id = id;
            this.username = username;
            this.password = password;
            this.age = age;
            this.gendar = gendar;
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        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 Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public String getGendar() {
            return gendar;
        }
    
        public void setGendar(String gendar) {
            this.gendar = gendar;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", age=" + age +
                    ", gendar='" + gendar + '\'' +
                    '}';
        }
    }
    

    3 创建配置文件(db.properties)

    主要是将连接数据库的几个变量封装一下,更换数据库信息的时候,我们只需要修改这个配置文件中的内容即可,对,一切为了方便,emm~懒创造了高效的代码:

    #驱动名称
    driverClass=com.mysql.jdbc.Driver
    #数据库url
    url=jdbc:mysql:///mydatebase
    #当然上面的这句话就等价于:url=jdbc:mysql://localhost:3306/mydatabase
    #数据库用户名
    user=root
    #数据库密码
    password=root
    

    4 创建封装类(DB_Tools.java)

    本篇博客所有的精华都在这里了,来让我们一起来感受一下:

    4.1 注册JDBC驱动

    将注册驱动的实现代码置于静态代码块中,类被调用时首先被加载:
    通过加载配置文件,完成JDBC的驱动注册,(悄咪咪的问一下,看到这里的你应该知道不同的数据库有不同的JDBC驱动不~

    public class DB_Tools{
        private static String driverClass;
        private static String url;
        private static String user;
        private static String password;
        /**
         *1.注册JDBC驱动
         */
        static {
            try {
                //获取配置文件
                InputStream inputStream = DB_Tools.class.getClassLoader().getResourceAsStream("db.properties");
                Properties properties = new Properties();
                properties.load(inputStream);
                //从配置文件中获取数据信息
                driverClass = properties.getProperty("driverClass");
                url = properties.getProperty("url");
                user = properties.getProperty("user");
                password = properties.getProperty("password");
                try {
                    //注册驱动
                    Class.forName(driverClass);
                    System.out.println("注册驱动成功");
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("注册驱动失败");
            }
        }
    }
    
    4.2 获取数据库连接

    这个感觉没有什么好说的,就是常规操作嘛~

    public class DB_Tools{
        /**
         * 2.获取连接
         * @return Connection null连接失败 !null连接成功
         */
        public static Connection getDBConnection() {
            try {
                return DriverManager.getConnection(url, user, password);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    
    4.3 断开连接释放资源

    emmm,这个也是常规操作~
    注意以下关闭的顺序就好了,这里我们用PreparedStatement的父类Statement(虽然我不是很喜欢这个接口),使代码更加灵活.

    public class DB_Tools{
        /**
         * 3.释放资源close()
         * @param connection        连接
         * @param preparedStatement 执行命令
         * @param resultSet         结果集
         */
        public static void allClose(Connection connection, Statement statement, ResultSet resultSet) {
            try {
            	if (resultSet != null) {
                    resultSet.close();
                }
                if (statement!= null) {
                    statement.close();
                }
                if (connection != null) {
                    connection.close();
                }
                System.out.println("执行结束");
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    
    4.4 执行增删改查

    代码中都有注释,我是仙女本仙没错了~看看下面的代码,增删改的操作返回的结果是一个int类型的数字:
    操作成功 结果>0 返回受影响的行数,
    操作失败 结果<0 返回的是一个负数,
    还有一个点:这里用PreparedStatement,本仙不喜欢Statement,Statement会发生sql注入,嫌弃.PreparedStatement相对来说会做预处理,执行效率高还比较安全,可以举一个生动形象的例子:Statement是我眼里的渣男,而PreparedStatement就是那完美的男神!
    代码如下:

    public class DB_Tools{
         /**
         * 4.执行增删改
         * @param sql     sql操作语句
         * @param objects sql语句中的参数,可以为null
         * @return int >0操作(增删改)成功 <0操作失败
         */
        public static int excumentDBUpdate(String sql, Object[] objects) {
            int updateResult = 0;
            Connection connection = null;
            PreparedStatement preparedStatement = null;
            try {
                //1.获取连接
                connection = getDBConnection();
                //2.获取增删改查的执行命令
                preparedStatement = connection.prepareStatement(sql);
                //3.向sql语句中?填充数据
                if (objects != null) {
                    for (int i = 0; i < objects.length; i++) {
                        preparedStatement.setObject(i + 1, objects[i]);
                    }
                }
                //4.执行增删改查
                updateResult = preparedStatement.executeUpdate();
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                //5.关闭连接,释放资源
                allClose(connection, preparedStatement, null);
            }
            return updateResult;
        }
    }
    
    4.5 (重点)查询数据

    你也能看出来,前面的都太简单了,嗯哼不用写出来,谁都会的么那重点就来了:
    下面的炫点有三个:

    1.泛型的使用
    2.反射的使用
    > 3.内省的使用
    上面使代码复用性更高

    4.5.1 查询单条数据

    思路:如代码中注释所示(我是有个仙女没错了,写代码还加注释~)

    public class DB_Tools{
        //这个我先放在前面,后面就不再赘述了
     	/**
         * 通过反射+内省将结果集中数据拿出来
         * @param resultSet 结果集啊
         * @param tClass 传递过来的操作类
         * @param <T> 泛型
         * @return 返回一个泛型对象Object
         * @throws Exception
         */
        public static <T> T getObject(ResultSet resultSet, Class<T> tClass) throws Exception {
            T object = tClass.newInstance();
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
            for (int i = 0; i < resultSetMetaData.getColumnCount(); i++) {
                //获取列名
                String colName = resultSetMetaData.getColumnName(i + 1);
                //通过内省获取包含列名指定方法(一般是get和set)
                PropertyDescriptor propertyDescriptor = new PropertyDescriptor(colName, tClass);
                if (propertyDescriptor != null) {
                    //获取到方法后我们再获取set方法来对private修饰的相关属性进行赋值
                    Method method = propertyDescriptor.getWriteMethod();
                    //然后我们执行这个方法并将属性添加到object对象中
                    method.invoke(object, resultSet.getObject(colName));
                }
            }
            return object;
        }
    
    	 /**
         * 5.查询单条数据(反射加内省实现)
         *
         * @param sql     sql操作语句
         * @param objects sql语句中的参数,可以为null
         * @param tClass
         * @param <T>     泛型
         * @return 返回单个实体对象
         */
        public static <T> T getSingleResult(String sql, Object[] objects, Class<T> tClass) {
            Connection connection = null;
            PreparedStatement preparedStatement = null;
            ResultSet resultSet = null;
            T object = null;
    
            try {
                //1.获取连接
                connection = getDBConnection();
                //2.创建命令对象
                preparedStatement = connection.prepareStatement(sql);
                //3.向sql语句中添加数据(objects),如果objects不为空的话
                if (objects != null) {
                    for (int i = 0; i < objects.length; i++) {
                        preparedStatement.setObject(i + 1, objects[i]);
                    }
                }
                //4.执行查询语句
                resultSet = preparedStatement.executeQuery();
                //5.通过反射创建tClass类的对象
                //6.从结果集中获取数据
                if (resultSet.next()) {
                    object = getObject(resultSet, tClass);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //7.关闭连接释放资源
                allClose(connection, preparedStatement, resultSet);
            }
            //8.返回object对象
            return object;
        }
    }
    
    4.5.2 查询多条数据

    实现和前面的思路如出一辙,我们这里有个人的脚超级臭(我发现好像是我胖胖的同桌的jio…),伴着阵阵吹向我的方向的微风,我快给熏牺牲了,怀疑人生…快速沾完这个代码撤!狗命重要!

    public class DB_Tools{
    	 /**
         * 5.2查询多条数据(反射+内省实现)
         *
         * @param sql     sql操作语句
         * @param objects sql语句中的参数,可以为null
         * @param tClass
         * @param <T>     泛型
         * @return 返回多个对象的集合
         */
        public static <T> List<T> getComplexResult(String sql, Object[] objects, Class<T> tClass) {
            Connection connection = null;
            PreparedStatement preparedStatement = null;
            ResultSet resultSet = null;
            List<T> tList = new ArrayList<T>();
    
            try {
                //1.获取连接
                connection = getDBConnection();
                //2.创建命令对象
                preparedStatement = connection.prepareStatement(sql);
                //3.向sql语句中添加数据(objects),如果objects不为空的话
                if (objects != null) {
                    for (int i = 0; i < objects.length; i++) {
                        preparedStatement.setObject(i + 1, objects[i]);
                    }
                }
                //4.执行查询语句
                resultSet = preparedStatement.executeQuery();
                //5.从结果集中获取数据
                while (resultSet.next()) {
                    T object = getObject(resultSet, tClass);
                    tList.add(object);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //7.关闭连接释放资源
                allClose(connection, preparedStatement, resultSet);
            }
            //8.返回tList集合
            return tList;
        }
    }
    

    本篇博客只是模拟了对JDBC增删改查超简易封装,和Apache提供的对JDBC进行简单封装的开源工具类库DBUtils还相差甚远,后面有时间我会写一篇关于DBUtils这个轻量级工具类的介绍,敬请期待.

    感谢你看到了这里啊,
    如果你有收获的话记得点赞呦
    有问题可以留言,本仙看见了就会回复的
    再见,祝您学习快乐,生活愉快~

    展开全文
  • jdbc增删改查.rar

    2021-10-19 18:19:00
    简单jdbc增删改查
  • 经典jdbc增删改查

    2014-04-30 08:58:59
    加深对jdbc的理解和应用,理解MVC经典开发模式,示例经典的增删改查操作
  • JSP+JDBC增删改查操作

    2012-07-30 23:05:45
    JSP+JDBC增删改查操作 web项目开发
  • java使用jdbc连接mysql数据库,实现增删改查等功能
  • jdbc增删改查

    2015-11-29 17:36:02
    jdbc增删改查
  • 使用java原生jdbc完成数据的增删改查
  • 本项目适合初学者,框架集合后做的ssm整合,支持增删改查,模糊查询,有bug敬请指正
  • java对mongodb数据库的增删改查测试demo。可直接运行,需要自己安装mongodb数据库,需要手动添加bins包下面的jdbc的jar包和junit4的jar包。包含自己写的mongodb安装文档。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 65,321
精华内容 26,128
关键字:

jdbc增删改查