精华内容
下载资源
问答
  • jdbc 增删改查
    千次阅读
    2021-02-27 12:25:20

    5.2.1 JDBC连接

           只要用到数据库操作,首先要做的就是获取数据库连接,获取数据库连接三要素:连接串,用户和密码。

    public static Connection getConnection() throws SQLException {
        String url = "jdbc:mysql://localhost:3303/info_manage?serverTimezone=Asia/Shanghai&zeroDateTimeBehavior=CONVERT_TO_NULL&autoReconnect=true&useSSL=false&failOverReadOnly=false";
        String userName = "root";
        String password = "你的密码";
        return DriverManager.getConnection(url, userName, password);
    }
    

    5.2.2 创建数据库表

    1. 创建数据库表sql语句
    static String createSql =  "CREATE TABLE user_info (\n" +
            "  id bigint(20) NOT NULL AUTO_INCREMENT,\n" +
            "  user_email varchar(255) DEFAULT NULL,\n" +
            "  user_location varchar(255) DEFAULT NULL,\n" +
            "  user_mobile varchar(255) DEFAULT NULL,\n" +
            "  user_name varchar(255) DEFAULT NULL,\n" +
            "  user_status int(11) DEFAULT NULL,\n" +
            "  PRIMARY KEY (id)\n" +
            ") ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;";
    
    1. 执行sql
    Connection connection = getConnection();
    Statement statement = connection.createStatement();
    boolean succ = statement.execute(createSql);
    
    1. 执行成功返回false,这是一个需要的点,当statement执行的是非查询语句,返回值false表示执行成功,可以去看源码注释,明确指出了该点。

    5.2.3 JDBC增删改查

           使用原生JDBC操作数据库操作基本过程的过程如下:

    1. 获取数据库连接
    2. 编写定义好的sql
    3. 创建statement或者prepareStatement执行sql
    4. 获取返回值

    1. 插入数据(插入语句->执行)

    static String insertSql = "insert into user_info(user_email,user_location," +
            "user_mobile,user_name,user_status) values (?,?,?,?,?);";
    
    Statement statement = connection.createStatement();
    PreparedStatement preparedStatement = connection.prepareStatement(insertSql);
    for (int i=0;i<1000;i++){
        //first是1,不是0
        preparedStatement.setString(1,"lll@"+i+".com");
        preparedStatement.setString(2,"A"+i);
        preparedStatement.setString(3,""+i);
        preparedStatement.setString(4,"name"+i);
        preparedStatement.setInt(5,1);
        boolean execute = preparedStatement.execute();
        System.err.println(execute);
    }
    

    2. 删除数据

    static String deleteSql = "delete from user_info where id>100;";
    
    
    Statement statement = connection.createStatement();
    boolean execute = statement.execute(deleteSql);
    

    3. 修改数据

    static String updateSql = "update user_info set user_name=? where id = ?;";
    
    PreparedStatement preparedStatement = connection.prepareStatement(updateSql);
    
    preparedStatement.setString(1,"王大锤");
    preparedStatement.setInt(2,1);
    preparedStatement.execute();
    

    4. 查询数据

    static String querySql = "select user_name from user_info where id = ?";
    
    PreparedStatement preparedStatement = connection.prepareStatement(querySql);
    preparedStatement.setInt(1,1);
    ResultSet resultSet = preparedStatement.executeQuery();
    while (resultSet.next()){
        String name = resultSet.getString(1);
        System.err.println(name);
    }
    

    在这里插入图片描述

    更多相关内容
  • 主要介绍了JDBC增删改查和查唯一的完整代码解析,代码分为第四部分,每部分代码都不错,对jdbc增删改查操作感兴趣的朋友一起学习吧
  • JDBC增删改查

    千次阅读 2022-04-22 15:00:16
    总共4个public方法:增删改查 package com.xy; import java.io.IOException; import java.io.InputStream; import java.sql.*; import java.util.*; /** * @ClassName JdbcUtil * @Description * @Author xy * @Date...

     总共4个public方法:增删改查

    package com.xy;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.sql.*;
    import java.util.*;
    
    /**
     * @ClassName JdbcUtil
     * @Description
     * @Author xy
     * @Date 2022/4/22
     * @Version 1.0
     **/
    public class JdbcUtil {
    
        private static String driver = "com.mysql.jdbc.Driver";
        private static String url = "jdbc:mysql://localhost:3306/mysql"; //连接数据库(mysql是数据库名)
        private static String user = "root";//连接mysql的用户名
        private static String password = "123";//连接mysql的密码
        private static Connection conn = null;
    
    
        static {
            try {
    //            readProperties();
    /*
    
    jdk1.6以后会去读取mysql META-INF/services/java.sql.Driver下自动注册
    mysqL驱动5.1.6版本会有META-INF/services/java.sql.Driver
    */
    // jdk1.6、mysql 5.1.6以后不再需要手动加载   Class.forName(driver);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        private static void readProperties() throws IOException {
            //读取配置文件
            InputStream in = JdbcUtil.class.getResourceAsStream("db.properties");
            Properties properties = new Properties();
            //加载配置文件
            properties.load(in);
            //获取配置文件中的数据
            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            user = properties.getProperty("user");
            password = properties.getProperty("password");
        }
    
        /**
         * 获取一个数据库链接
         */
        private static Connection getConnection() throws SQLException {
            return DriverManager.getConnection(url, user, password);
        }
    
        private static void closeConn(Connection conn) {
            try {
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        private static void execute(String sql) {
            try {
                conn = getConnection();
                conn.setAutoCommit(false);
                PreparedStatement preparedStatement = conn.prepareStatement(sql);
                preparedStatement.executeUpdate();
                conn.commit();
            } catch (SQLException e) {
                e.printStackTrace();
                try {
                    conn.rollback();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            } finally {
                closeConn(conn);
            }
        }
    
        /**
         * 增加数据
         */
        public static void create(String sql) {
    //        String sql = "INSERT INTO USER (user_name,user_password,user_age) VALUES('老王','123456',18)";
            execute(sql);
        }
    
        /**
         * 删除数据
         */
        public static void delete(String sql) {
    //        String sql = "DELETE FROM USER WHERE USER.user_name = '老王'";
            execute(sql);
        }
    
    
        /**
         * 修改数据
         */
        public static void update(String sql) {
    //        String sql = "UPDATE USER SET USER.user_name = '老李'";
            execute(sql);
        }
    
        private static ResultSet getResultSet(String sql) throws SQLException {
            PreparedStatement preparedStatement = null;
            //执行查询语句并返回结果集
            ResultSet resultSet = null;
            conn = getConnection();
            preparedStatement = conn.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();
            return resultSet;
        }
    
        public static List<Map<String, Object>> queryForListMap(String sql) {
            ResultSet resultSet = null;
            List<Map<String, Object>> result = new ArrayList<>();
            try {
                resultSet = getResultSet(sql);
                ResultSetMetaData rsmd = resultSet.getMetaData();//获得结果集结构信息,元数据
                int numberOfColumns = rsmd.getColumnCount();//获得列数
                while (resultSet.next()) {
                    Map<String, Object> rowData = new HashMap<>();
                    for (int j = 1; j <= numberOfColumns; j++) {
                        rowData.put(rsmd.getColumnName(j), resultSet.getString(j));
                    }
                    result.add(rowData);
                }
    
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                closeConn(conn);
            }
            return result;
        }
    
        public static void main(String[] args) {
            System.out.println(queryForListMap("select db,user from db"));
        }
    }
    

    拓展

    jdk1.6 使用了jdbc4,以后会去读取mysql META-INF/services/java.sql.Driver下自动注册
    mysqL驱动5.1.6版本会有META-INF/services/java.sql.Driver

     

    展开全文
  • jdbc实现的增删改查,完美代码,完美封装
  • JDBC增删改查案例

    千次阅读 2022-02-03 16:08:24
    JDBC增删改查案例 1.概述 ​ 为了支持各大编程语言能够操纵数据库,完成对数据库的增删改查。各大厂商各自编写了连接自己数据库的JDBC实现程序。这个JDBC接口模板则由Java程序的设计者提供,由数据库厂商自己完成...

    JDBC增删改查案例

    1.概述

    ​ 为了支持各大编程语言能够操纵数据库,完成对数据库的增删改查。各大厂商各自编写了连接自己数据库的JDBC实现程序。这个JDBC接口模板则由Java程序的设计者提供,由数据库厂商自己完成逻辑编写。对于最早的平台服务应用,由于没有各大ORM框架,我么基本所有的数据库操作都需要程序员自己编写,最底层就是对JDBC程序的封装。现在由于ORM框架的兴起,程序编写者只用更加注重业务逻辑的编写,对于数据库的连接管理基本都是框架自动完成,大大方便了程序编写者。

    这里探究JDBC的应用,使用JDBC操纵MySQL数据库完成简单的增删改查逻辑。

    2.基础环境介绍

    2.1 数据库表

    这里以员工(employee) 和部门(emp)表为例进行操作。

    
    create table emp(
    	id int primary key auto_increment,
    	empname varchar(60)
    );
    create table employee(
    	id int primary key auto_increment comment '员工id',
    	ename employeevarchar(60) comment '员工名称',
    	gender varchar(1) comment '员工性别',
    	empid int comment '部门id'
    );
    alter table employee add foreign key(empid) references emp(id);
    insert into emp values(1,'广告部');
    insert into emp values(2,'开发部');
    insert into employee values(1,'tom','M',2);
    

    2.2 版本

    工具版本
    JDK1.8
    MySQL5.7
    IDEA2020.1

    2.3 环境搭建

    创建简单的maven工程即可,导入mysql连接依赖包

            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.37</version>
            </dependency>
    

    3.代码编写

    3.1 连接工具类编写

    我们将连接进行封装,可以快速获取连接,避免重复造轮子,提高开发效率。

    package cn.jdbccase.demo.utils;
    import java.io.IOException;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.util.Properties;
    
    public class JDBCUtils {
        
        public static Properties getdbproperties(){
            Properties properties = new Properties();
            // 获取类加载器
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            try {
                properties.load(classLoader.getResourceAsStream("db.properties"));
            } catch (IOException e) {
                e.printStackTrace();
            }
            return properties;
        }
    
        // 获取连接
        public static Connection getCon(){
            Properties properties = getdbproperties();
    
            String url = properties.getProperty("jdbc.url");
    
            String user = properties.getProperty("jdbc.user");
    
            String password = properties.getProperty("jdbc.password");
    
            String driver = properties.getProperty("jdbc.driver");
    
            Connection con = null;
            try {
                // 注册驱动
                Class.forName(driver);
                // 获取连接
                con = DriverManager.getConnection(url, user, password);
            } catch (SQLException | ClassNotFoundException throwables) {
                throwables.printStackTrace();
            }
            return con;
        }
        // 关闭资源
        public static void closeResource(Connection con, Statement st) {
            if (st != null) {
                try {
                    st.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (con != null) {
                try {
                    con.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    db.properties文件:

    jdbc.url=jdbc:mysql://localhost:3306/jdbc_db
    jdbc.user=root
    jdbc.password=123456
    jdbc.driver=com.mysql.jdbc.Driver
    

    3.2 查询测试

    package cn.jdbccase.demo;
    import cn.jdbccase.demo.utils.JDBCUtils;
    import java.sql.*;
    public class demo1 {
        public static void main(String[] args) throws  SQLException {
            Connection con = JDBCUtils.getCon();
    
            Statement statement = con.createStatement();
    
            ResultSet res = statement.executeQuery("select * from employee");
    
            while (res.next()){
                int id = res.getInt("id");
                String ename = res.getString("ename");
                String gender = res.getString("gender");
                int empid = res.getInt("empid");
                System.out.println(id + "\t" + ename + "\t" + gender + "\t" + empid);
            }
            res.close();
            JDBCUtils.closeResource(con,statement);
        }
    }
    

    结果:

    image-20220203114119301

    3.3 具体案例编写

    3.3.1 Employee

    get 和 set方法省略

    public class employee {
        private Integer id;
        private String ename;
        private String gender;
        private Integer empid;
    	....get and set 方法
    }
    
    3.3.2 Emp
    public class Emp {
        private Integer id;
        private String empname;
    	....get and set 方法
    }
    
    3.3.3 通用BaseDao类编写
    package cn.jdbccase.demo.dao;
    import cn.jdbccase.demo.utils.JDBCUtils;
    import java.lang.reflect.Field;
    import java.sql.*;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 通用dao类
     */
    public abstract class BaseDao<T> {
    
        /**
         * 通用的增删改操作
         *
         * @param sql
         * @param params
         * @return
         */
        public int update(Connection conn, String sql, Object... params) {
            int count = 0;
            try {
                PreparedStatement ps = conn.prepareStatement(sql);
                // 添加参数
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i+1,params[i]);
                }
                //执行sql语句
                count = ps.executeUpdate();
                // 关闭资源
                JDBCUtils.closeResource(null,ps);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            return count;
        }
    
        /**
         * 查询某个对象
         * @param conn
         * @param cla
         * @param sql
         * @param args
         * @param <T>
         * @return
         */
        public <T> T getInstance(Connection conn, Class<T> cla, String sql, Object... args) {
            PreparedStatement ps = null;
            ResultSet rs = null;
            try {
                ps = conn.prepareStatement(sql);
                for (int i = 0; i < args.length; i++) {
                    ps.setObject(i + 1, args[i]);
                }
                rs = ps.executeQuery();
                // 获取结果集的元数据 :ResultSetMetaData
                ResultSetMetaData rsmd = rs.getMetaData();
                // 通过ResultSetMetaData获取结果集中的列数
                int columnCount = rsmd.getColumnCount();
    
                //利用反射封装对象
                if (rs.next()) {
                    T t = cla.newInstance();
                    for (int i = 0; i < columnCount; i++) {
                        Object columValue = rs.getObject(i + 1);
                        String columnLabel = rsmd.getColumnLabel(i + 1);
                        Field field = cla.getDeclaredField(columnLabel);
                        field.setAccessible(true);
                        field.set(t, columValue);
                    }
                    return t;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                JDBCUtils.closeResource(null, ps, rs);
            }
    
            return null;
        }
    
        // 查询一批数据
        public <T> List<T> getForList(Connection conn, Class<T> clazz, String sql, Object... args) {
            PreparedStatement ps = null;
            ResultSet rs = null;
            try {
                ps = conn.prepareStatement(sql);
                for (int i = 0; i < args.length; i++) {
                    ps.setObject(i + 1, args[i]);
                }
                rs = ps.executeQuery();
                ResultSetMetaData rsmd = rs.getMetaData();
                int columnCount = rsmd.getColumnCount();
                ArrayList<T> list = new ArrayList<T>();
                while (rs.next()) {
                    T t = clazz.newInstance();
                    for (int i = 0; i < columnCount; i++) {
                        Object columValue = rs.getObject(i + 1);
                        String columnLabel = rsmd.getColumnLabel(i + 1);
                        Field field = clazz.getDeclaredField(columnLabel);
                        field.setAccessible(true);
                        field.set(t, columValue);
                    }
                    list.add(t);
                }
                return list;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                JDBCUtils.closeResource(null, ps, rs);
            }
            return null;
        }
    }
    

    BaseDao类里面使用了反射来封装查询结果,这里理解比较抽象,需要先理解反射机制。通过反射来分装结果集,可以令方法变的通用,更加的灵活。

    3.3.4 EmployeeDao

    根据面向接口编程的思想,若需要编写Employee层的逻辑,我们需要先定义操作接口。

    package cn.jdbccase.demo.dao;
    
    import cn.jdbccase.demo.domain.employee;
    
    import java.sql.Connection;
    
    public interface EmployeeDao {
        // 添加员工
        public Integer addEmployee(employee em, Connection con);
    
        // 根据id删除员工
        public Integer delEmployById(Integer id, Connection con);
    
        // 根据id修改员工
        public Integer updateEmployById(employee e, Connection con);
    
        // 根据id查询某个员工
        public employee getEmployById(Integer id, Connection con);
    }
    

    实现类的编写:

    package cn.jdbccase.demo.dao;
    
    import cn.jdbccase.demo.domain.employee;
    
    import java.sql.Connection;
    
    public class EmployeeDaoImpl extends BaseDao implements EmployeeDao{
    
        @Override
        public Integer addEmployee(employee em, Connection con) {
            String sql = "insert into employee(ename,gender,empid) values(?,?,?)";
    
            int count = update(con,sql, em.getEname(), em.getGender(), em.getEmpid());
    
            return count;
        }
    
        @Override
        public Integer delEmployById(Integer id, Connection con) {
    
            String sql = "delete from employee where id = ?";
    
            int count = update(con,sql, id);
    
            return count;
        }
    
        @Override
        public Integer updateEmployById(employee e, Connection con) {
            String sql = "update employee set ename = ?,gender = ?,empid = ? where id = ?";
    
            int count = update(con,sql,e.getEname(),e.getGender(),e.getEmpid(),e.getId());
    
            return count;
        }
    
        @Override
        public employee getEmployById(Integer id, Connection con) {
    
            String sql = "select * from employee where id = ?";
    
            employee instance = (employee) getInstance(con, employee.class, sql, id);
    
            return instance;
        }
    }
    
    3.3.5 测试类编写
    package cn.jdbccase.demo.test;
    import cn.jdbccase.demo.dao.EmployeeDao;
    import cn.jdbccase.demo.dao.EmployeeDaoImpl;
    import cn.jdbccase.demo.domain.employee;
    import cn.jdbccase.demo.utils.JDBCUtils;
    import org.junit.Before;
    import org.junit.Test;
    import java.sql.Connection;
    
    public class DaoTest {
    
        EmployeeDao empdao = null;
    
        @Before
        public void init(){
            empdao = new EmployeeDaoImpl();
        }
    
        @Test
        public void testadd(){
            Connection con = JDBCUtils.getConnection();
            employee employee = new employee();
            employee.setEname("Bob");
            employee.setGender("M");
            employee.setEmpid(2);
            Integer count = empdao.addEmployee(employee, con);
            System.out.println(count);
            JDBCUtils.closeResource(con,null);
        }
    
        @Test
        public void testdel(){
            Connection con = JDBCUtils.getConnection();
    
            Integer count = empdao.delEmployById(4, con);
            System.out.println(count);
            JDBCUtils.closeResource(con,null);
        }
    
        @Test
        public void testupdate(){
            Connection con = JDBCUtils.getConnection();
            employee employee = new employee();
            employee.setId(1);
            employee.setEname("tom");
            employee.setGender("F");
            employee.setEmpid(1);
            Integer count = empdao.updateEmployById(employee,con);
            System.out.println(count);
            JDBCUtils.closeResource(con,null);
        }
    
        @Test
        public void testselect(){
    
            Connection con = JDBCUtils.getConnection();
    
            employee employ = empdao.getEmployById(1,con);
    
            System.out.println(employ);
    
            JDBCUtils.closeResource(con,null);
        }
    }
    

    完成简单的增删改查

    展开全文
  • JDBC.zip_JDBC增删改查

    2022-09-19 22:43:53
    java jdbc编程,源码包含java如何运用jdbc实现数据库连接及创建表,对表进行增删改查操作
  • 数据库和eclipse连接及增删改查操作
  • 通用的jdbc增删改查

    2018-10-13 22:02:11
    通用的jdbc增删改查,仅仅只是两个通用的方法,利用反射和泛型
  • JDBC增删改查的封装

    千次阅读 2021-08-01 23:35:44
    JDBC增删改查的封装 JDBCJDBC增删改查的封装1.JDBC五步走完成2.DAOUtil3.增,删,改,查的封装1.添加2.删除3.修改4.查询 1.JDBC五步走完成 2.DAOUtil import java.sql.Connection; import java.sql.DriverManager;...

    JDBC增删改查的封装


    在这里插入图片描述

    1.JDBC五步走完成

    在这里插入图片描述

    2.DAOUtil

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    public class DAOUtil {
        //通过常量解决魔法值
        private static final String CLASSNAME = "com.mysql.jdbc.Driver";
        private static final String URL = "jdbc:mysql://localhost:3306/jdbc001";
        private static final String USERNAME = "root";
        private static final String PASSWORD = "123456";
    
        static { //加载驱动只执行一次
            try {
                //Class.forName(CLASSNAME);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 获取连接对象的函数
         */
        public static Connection getConnection() throws Exception {
            return DriverManager.getConnection(URL, USERNAME, PASSWORD);
    
        }
    
        //增,删,改
        public static int executeUpdate(String sql, Object[] params) {
            Connection conn = null;
            try {
                conn = DAOUtil.getConnection();
                PreparedStatement ps = conn.prepareStatement(sql);
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
                int i = ps.executeUpdate();
                return i;
    
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (conn != null) {
                        conn.close();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return 0;
        }
    
        //查
        public static List<Map<String,Object>> executeQuery(String sql,Object... params){
            Connection conn=null;
            try {
                conn = DAOUtil.getConnection();
                PreparedStatement ps = conn.prepareStatement(sql);
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i+1,params[i]);
                }
                ResultSet set = ps.executeQuery();
                int columnCount = set.getMetaData().getColumnCount();
                List<Map<String,Object>> data = new ArrayList<>();
                while(set.next()){
                    Map<String, Object> map = new HashMap<>();
                    for (int i=1;i<=columnCount;i++){
                        map.put(set.getMetaData().getColumnLabel(i),set.getObject(i));
                    }
                    data.add(map);
                }
                return data;
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                try {
                    if(conn!=null){
                        conn.close();
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
            return null;
        }
    }
    

    3.增,删,改,查的封装

    1.添加

        public void test02() {
            MyJava721 s = new MyJava721(2, "新学生");
            String sql = "insert into user values(?,?)";
            Object[] params = {s.getId(),s.getName()};
            int i = DAOUtil.executeUpdate(sql, params);
            System.out.println(i);
        }
    

    2.删除

        public void test03(){
            String sql = "delete from user where id = ?";
            Object[] params = {22};
            int i = DAOUtil.executeUpdate(sql, params);
            System.out.println(i);
        }
    

    3.修改

        public void test01() {
            MyJava721 s = new MyJava721(2, "周二");
            String sql = "update user set name = ?where id =?";
            Object[] params = {s.getName(),s.getId()};
            int i = DAOUtil.executeUpdate(sql, params);
            System.out.println(i);
        }
    

    4.查询

    查询某一个

        public void test04(){
            String sql = "select *from user where id = ?";
            //Object[] params = {4};
            List<Map<String, Object>> list = DAOUtil.executeQuery(sql, 4);//可变参数
            System.out.println(list);
        }
    

    查询全部

        public void test05(){
            String sql = "select *from user";
            Object[] params = {};
            List<Map<String, Object>> list = DAOUtil.executeQuery(sql,params);
            System.out.println(list);
    
        }
    
    展开全文
  • jdbc最简的单代码片段,最简单的增删改查功能
  • 前一天给大家分享了一些基本的JDBC知识,今天给大家做了一分最详尽的增删改查总结。Let’s go!作用关键字举例是否需要返回数据添加(增)INSERTINSERT INTO customers(id)VALUES(9)显示受到影响,不返回值删除(删)...
  • JDBC的入门级教程以及相关资料,包括对数据库的增删改查
  • 能进行学生的增删改查,再通过连接数据库,将学生的相关信息输入到数据库里的的相关的库及表
  • JDBC增删改查简单例子

    2017-04-12 16:37:54
    JDBC对用户的增删改查的实现
  • } //删改 public static boolean excuteUpdate(String sql,Object[] params) throws ClassNotFoundException { try { pstmt = createPreparedStatement(sql,params); int count = pstmt....
  • 基于servlet和jdbc增删查改,学生课程管理
  • 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
  • 简单的jsp+servlet+jdbc+javaBean实现的增删查改项目,供新手参考
  • 基本流程 1:导入对于数据库厂商提供的连接jar包 2:加载对应的数据库驱动 3:获得数据库和java程序的连接通道 4:通过连接通道,获得预处理平台 5:插入sql语句执行sql...Class.forName("com.mysql.jdbc.Driver"); Dr
  • Spring JDBC 增删改查

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

    2015-03-18 16:09:27
    struts+jdbc增删改查,,, struts2.0 一个小案例
  • jdbc增删改查加分页

    2019-04-14 01:23:34
    NULL 博文链接:https://zhang964761032.iteye.com/blog/1742235
  • 史上最简单的jsp+servlet+jdbc实现CRUD项目,已经经历了千锤百炼的测试与修改,健壮性一级棒!没有任何问题。而且简明易懂,内附大量注释,是不可多得的好例子。为了保证简单,甚至没有把每个servlet里的jdbc连接...
  • JDBC增删改查.pdf

    2021-06-07 17:41:07
    jdbc连接sqlserver增删改查 javascript非空验证
  • jdbc增删改查.rar

    2021-10-19 18:19:00
    简单jdbc增删改查
  • Struts2 JDBC 增删改查

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

    2012-03-01 17:35:35
    java中简单的mysql数据库连接JDBC,包含了配置文件(Config)
  • jsp + servlet + springboot + springJdbc + druid + mysql 员工列表 ID 姓名 性别 入职日期 所属部门 部门地址 操作 1 张三 男 1982-2-2 开发部 北京 修改|删除 2 李四 男 1982-2-2 开发部 北京 修改|删除

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 77,161
精华内容 30,864
关键字:

jdbc 增删改查

友情链接: Kmeans.zip