精华内容
下载资源
问答
  • java使用jdbc连接mysql数据库,实现增删改查等功能
  • java 使用jdbc 连接mysql 实现增删改查java 使用jdbc 连接mysql 实现增删改查java 使用jdbc 连接mysql 实现增删改查java 使用jdbc 连接mysql 实现增删改查java 使用jdbc 连接mysql 实现增删改查
  • 主要为大家详细介绍了java jdbc连接mysql数据库实现增删改查操作,需要的朋友可以参考下
  • 适合初学者理解Servlet,JDBCMySQL,JSP等基本概念。
  • Java之JDBC连接数据库实现增删改查(2018 使用Dao层实现) 实体类:User.java 接口类:IUserDao.java 实现接口类:UserDaoImpl.java 使用Junit4测试增删改查类:UserDaoTest.java
  • 主要介绍了JavaWeb JDBC + MySql 通讯录实现简单的增删改查功能,结合具体案例形式详细分析了JavaWeb JDBC + MySql数据库连接增删改查等相关操作技巧与注意事项,需要的朋友可以参考下
  • JDBC连接数据库并实现增删改查 JDBC的MYSQL数据库的直接连接 JDBC利用db.properties文件来实现MYSQL数据库的连接 JDBC使用数据库连接池来实现MYSQL数据库的连接 JDBC的MYSQL数据库的增删改查操作 时间之外的关于驱动...

    一、JDBC的基本概念
    1、JDBC的全称是Java数据库连接(Java Database Connectivity)。
    这里的连接有两个含义,一个是建立应用程序与数据库两个进程之间的通讯管道(Socket就是两端的插口);另一个要创建连接对象。
    2、JDBC在JDK中的位置
    Java sql 包是jdbc的基础API,主要解决驱动管理,连接创建,命令发送,结果的接收,数据类型等的相关规范。
    Javax sql包是jdbc的扩展API,主要解决数据库连接池的相关规范。

    3、jdbc出现的原因
    现在有很多厂商的数据库产品,每个数据库所提供的接口调用是不同的,应用程序操作数据库时,即使是同一种操作,代码却写得不一样。这样实现数据库相关的管理系统,代码的编写会很困难,一人程序员需要熟悉多种数据库所提供的不同的接口。Java的设计者为了解决这个问题,提供了一套操作数据库的API的标准,该标准提供了一系列的接口,并把它们分发给所有的数据库厂商,让它们基于这套标准来实现各自的驱动程序及操作数据库的各种对象类型。那么这套标准就成为了现在JDBC技术。作为开发人员,只要知道如何使用JDBC就可以了。从而让开发人员更容易写出数据库的应用程序。

    4、JDBC的基本架构
    在这里插入图片描述

    5、使用JDBC操作数据库的步骤
    创建连接              发送SQL命名            接收并处理结果

    二、JDBC的技术架构
    1、接口的部分
    public interface Driver 每个驱动程序必须实现的接口。
    public interface Connection extends Wrapper, AutoCloseable 与特定数据库的连接(会话)。

    public interface Statement extends Wrapper, AutoCloseable 用于执行静态SQL语句并返回其生成的结果的对象。一般称为陈述对象,陈述就是表达一个具体的操作。

    public interface PreparedStatement extends Statement 表示预编译的SQL语句的对象。预编译陈述对象。

    public interface ResultSet extends Wrapper, AutoCloseable 表示数据库结果集的数据表,通常通过执行查询数据库的语句生成。 它包含查询的结果数据。

    2、类的部分
    public class DriverManager extends Object 用于管理一组JDBC驱动程序的基本服务。 主要作用,1是注册驱动程序,2、利用驱动程序得到连接对象。
    3、枚举的部分
    public enum JDBCType extends Enum<JDBCType> implements SQLType 定义用于标识通用SQL类型(称为JDBC类型)的常量。

    4、异常的部分
    public class SQLException extends 异常 implements Iterable<Throwable> 提供有关数据库访问错误或其他错误的信息的异常。

    5、桥接模式在JDBC中的使用

    在这里插入图片描述

    三、使用JDBC操作数据库
    总览
    在这里插入图片描述
    下方db.properties文件,为属性文件。

    JDBC的MYSQL数据库的直接连接

    1、创建连接,前提是加载数据库的驱动程序。
    首先,将MYSQL数据库连接驱动,复制到项目lib目录中,并添加到项目库中。
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    此时就可以直接,利用这个刚加进来的驱动程序,来实现MYSQL数据库的连接了。

    /*
    * 8.0以上版本的写法(驱动程序的版本(mysql-connector-java-8.0.17.jar))
    *com.mysql.cj.jdbc.Driver
    *?serverTimezone=UTC&charactorEncoding=utf8
    */
    public class JDBCDemo {
        //建立数据库的连接需要四要素,分别是驱动程序名,连接的url,用户名,密码
        static String driverName="com.mysql.cj.jdbc.Driver";
        static String url="jdbc:mysql://localhost:3306/实验数据库" +
                "?serverTimezone=UTC&charactorEncoding=utf8";
        static String user="root";
        static String password="123456";
    
        public static void main(String[] args) throws ClassNotFoundException, SQLException {
            //加载驱动程序,com.mysql.jdbc.Driver类的静态代码块,
            // 向程序中注册加载的驱动程序
            Class.forName(driverName);
            //得到连接对象
            Connection connection= DriverManager.getConnection(url,user,password);
            System.out.println(connection);
        }
    }
    

    JDBC利用db.properties文件来实现MYSQL数据库的连接

    属性文件db.properties里的内容。(也就是将一些关键且可能需要改动的连接信息放置到了此文件中)
    db.properties

    driverName=com.mysql.cj.jdbc.Driver
    url=jdbc:mysql://localhost:3306/实验数据库?serverTimezone=UTC&charactorEncoding=utf8
    user=root
    password=123456
    
    public class JDBCDemo {
        static {
    
            try {
                Class.forName(getProperties().getProperty("driverName"));
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) {
            getConnection();
        }
    
        public static Properties getProperties(){
            Properties properties= null;
            try {
                properties=new Properties();
                //读取属性文件
                properties.load(new FileReader("E:\\IDEA .3代码文件\\src\\db.properties"));
            } catch (IOException e) {
                e.printStackTrace();
            }
            return properties;
        }
    
    
        public  static Connection getConnection(){
            Properties properties=null;
            Connection connection=null;
            try {
                properties=getProperties();
                connection= DriverManager.getConnection(properties.getProperty("url"),
                        properties.getProperty("user"),properties.getProperty("password"));
                return connection;
                
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            return null;
        }
    
    }
    

    这样实现连接,与直接连接的区别在于,利用了db.properties属性文件,将重要连接属性单独存储了,从而多了一些从db.properties文件中读取数据,并取出连接属性的一些额外的代码。

    JDBC使用数据库连接池来实现MYSQL数据库的连接

    1、项目中引入druid的jar包
    首先把阿里巴巴提供的数据库连接池druid(此druid为数据库连接池,而不是数据存储里的druid),复制到lib目录,并添加到项目库中。

    在这里插入图片描述

    在这里插入图片描述

    driverName=com.mysql.cj.jdbc.Driver
    url=jdbc:mysql://localhost:3306/实验数据库?serverTimezone=UTC&charactorEncoding=utf8
    user=root
    password=123456
    MaxActive=10
    MinIdle=10
    InitialSize=10
    
    public class JDBCDemo {
        static DruidDataSource pool;
        static {
            try {
                pool = new DruidDataSource();
                pool.setDriverClassName(getProperties().getProperty("driverName"));
                pool.setUrl(getProperties().getProperty("url"));
                pool.setUsername(getProperties().getProperty("user"));
                pool.setPassword(getProperties().getProperty("password"));
                pool.setMaxActive(Integer.valueOf(getProperties().getProperty("MaxActive")));//最大允许的连接数量
                pool.setMinIdle(Integer.valueOf(getProperties().getProperty("MinIdle")));//最小的空闲连接数量
                pool.setInitialSize(Integer.valueOf(getProperties().getProperty("InitialSize")));//创建池时初始创建的连接数量
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) throws Exception {
    
            for (int i = 0; i <100 ; i++) {
                new Thread(){
                    @Override
                    public void run() {
                       Connection connection=getConnection();
                        System.out.println(connection);
                        try {
                            connection.close(); //归还连接对象给连接池。(因为此时是连接池)
                        } catch (SQLException throwables) {
                            throwables.printStackTrace();
                        }
                    }
                }.start();
    
            }
    
    
        }
    
        private static Properties getProperties(){
    
            Properties properties = new Properties();
            try {
                properties.load(new FileReader("E:\\IDEA .3代码文件\\src\\db.properties"));
                return properties;
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        private static Connection getConnection() {
            try {
               return pool.getConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    

    此时,不光使用了db.properties来存储那些重要的连接属性了,同时还使用了数据库连接池,来替代了之前单独通过DriverManager类来获取Connection连接对象的实现方法(这种方式获取Connection连接对象是单例的,也就是无论从DriverManager类获取多少次Connection连接对象,返回的都是同一对象),而是使用数据库连接池来直接创建一些Connection连接对象,在使用完时,使用close()方法,来使Connection连接对象返回数据库连接池中反复利用,避免了反复创建与销毁Connection连接对象,降低了所消耗的时间与资源。

    JDBC的MYSQL数据库的增删改查操作

    1.在这之前,我们可以先安装一个对于实现数据库的各种操作及连接没有本质作用的一个测试框架junit的jar包,Junit是一个Java语言的单元测试框架(下面的代码就使用了junit里面提供的@Test注解,来对被注解的方法进行单独测试调用)。像上面两个jar包一样复制到lib目录,并添加到项目库中即可。
    在这里插入图片描述
    更多关于junit的内容可以看这篇博客
    https://www.cnblogs.com/lifexy/p/11389141.html
    在这里插入图片描述

    db.properties文件

    driverName=com.mysql.cj.jdbc.Driver
    url=jdbc:mysql://localhost:3306/实验数据库?serverTimezone=UTC&charactorEncoding=utf8
    user=root
    password=123456
    MaxActive=5
    MinIdle=2
    InitialSize=3
    

    一个典型的DAO 模式主要由以下几部分组成。

    1、DAO接口: 把对数据库的所有操作定义成抽象方法,可以提供多种实现。
    2、DAO 实现类: 针对不同数据库给出DAO接口定义方法的具体实现。
    3、实体类:用于存放与传输对象数据。
    4、数据库连接和关闭工具类:避免了数据库连接和关闭代码的重复使用,方便修改。

    更详细的描述可查看这篇博客https://www.runoob.com/note/27029


    创建一个数据库工具类,来统一提供连接对象,与关闭资源的功能。

    /**
     * 数据库工具类,提供创建连接池,产生连接对象,关闭资源对象等功能。
     */
    public class DbUtiles {
        static DruidDataSource pool;
        static {
            try {
                pool = new DruidDataSource();
                pool.setDriverClassName(getProperties().getProperty("driverName"));
                pool.setUrl(getProperties().getProperty("url"));
                pool.setUsername(getProperties().getProperty("user"));
                pool.setPassword(getProperties().getProperty("password"));
                pool.setMaxActive(Integer.valueOf(getProperties().getProperty("MaxActive")));//最大允许的连接数量
                pool.setMinIdle(Integer.valueOf(getProperties().getProperty("MinIdle")));//最小的空闲连接数量
                pool.setInitialSize(Integer.valueOf(getProperties().getProperty("InitialSize")));//创建池时初始创建的连接数量
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static Properties getProperties(){
    
            Properties properties = new Properties();
            try {
                properties.load(new FileReader("E:\\IDEA .3代码文件\\src\\db.properties"));
                return properties;
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static Connection getConnection() {
            try {
                return pool.getConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static void release(Connection connection, PreparedStatement pst, ResultSet rs){
            if (rs!=null){
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
    
            if (pst!=null){
                try {
                    pst.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
    
            if (connection!=null){
                try {
                    connection.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    
    
    }
    

    比较简易的DAO层(DataAccessobjects 数据存取对象),没有写DAO接口类,直接写了DAO实现类(关于增删改,三个的具体实现类)

    //CRUD 增删改查(增加(Create)、检索(Retrieve)、更新(Update)和删除(Delete))  DAO数据访问对象
    public class 双列表3CUDDAO {
        /**
         * 实现增删改的操作
         * @param sql,增删改命令
         * @param params sql命令中的参数
         */
        public static void update双列表(String sql,Object...params){
            //得到连接
            Connection connection=DbUtiles.getConnection();
            PreparedStatement pst=null;
            try {
                //创建预编译陈述对象
               pst= connection.prepareStatement(sql);
                //给sql命令注入参数
                for (int i = 0; i < (params==null?-1:params.length); i++) {
                    pst.setObject(i+1,params[i]);
                }
                //发送并执行命令
                //设置事务为显示事务
                connection.setAutoCommit(false);
                int result= pst.executeUpdate();
                //提交事务
                connection.commit();
            } catch (SQLException throwables) {
                //命令执行失败,回滚事务
                try {
                    connection.rollback();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                throwables.printStackTrace();
            }finally {
                DbUtiles.release(connection,pst,null);
            }
    
    
    
    
    
        }
    }
    

    关于查的接口类同上面的增删改的是一样的(如果有DAO接口,这些具体DAO实现类,或中间层的抽象类(假如有中间抽象层的话)理应会去继承和实现DAO接口的)。
    下方这里是查询具体实现类的上方的查询抽象类,因为在拿到查询结果后,对于查询结果的处理是各种处理方式都有的(但是,拿到查询结果这一块的代码的操作与代码的实现都是一样的,唯一不同的是关于对查询结果的处理。(这也是将这一块设置成抽象类,而不是具体实现类的原因)),需要分成更细致化的具体实现类,来实现更具体的事情。

    同时,抽象方法中写明整体的运行逻辑,而具体的实现类,却都可以根据不同需求去实现抽象类中的抽象方法的, 行为由父类控制,子类实现的,样式的即为23中设计模式中的模板方法模式。

    为了使抽象类中的已实现的方法具有通用性,所以下方对于数据的类型使用泛型的形式,以适应对多种表的操作而带来的不同数据类型的使用的兼容。
    (对于泛型的了解可以看这篇博客:https://segmentfault.com/a/1190000014120746

    public abstract class QueryDAO<T>{
        /**
         * 实现查询操作,不需要考虑事务的问题
         * @param sql,查询命令
         * @param params sql命令中的参数
         */
        public  List<T> query双列表(String sql,Object...params){
            //得到连接
            Connection connection=DbUtiles.getConnection();
            PreparedStatement pst=null;
            try {
                //创建预编译陈述对象
                pst= connection.prepareStatement(sql);
                //给sql命令注入参数
                for (int i = 0; i < (params==null?-1:params.length); i++) {
                    pst.setObject(i+1,params[i]);
                }
                //发送并执行查询命令,用结果集对象接收返回的结果(虚拟表)
              ResultSet result= pst.executeQuery();
                //处理结果
                List<T> list=new ArrayList<>();
                while(result!=null&&result.next()){
                    //处理结果的具体代码,本方法的设计者不知道用户要如何处理结果
                  T p= process(result);
                  list.add(p);
    
                }
                return list;
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }finally {
                DbUtiles.release(connection,pst,null);
            }
    
    
    return null;
    
        }
    
        protected abstract T process(ResultSet result);
    }
    

    与具体查询DAO类配套的实体类,一个对象用来存放返回的表数据中的一行数据。(所以要将一个表都存储下来的话,需要多个实体类对象的创建)

    /**
     * 产品的实体类,它的一个对象就对应一条记录,这些对象存放在集合中,该集合就对应一个虚拟表
     */
    public class 双列表3 {
    
        private int id;
        private String name;
    
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    

    具体的DAO 实现类

    /**
     * 本类的方法把查询到的产品数据封装到一个集合中,集合中的元素是产品的实体类
     * 实体类,凡是要对数据库中的表进行操作的程序,都应该根据每一个表创建对应的实体类对象,该实体类的属性对应表中的字段
     * 还要提供无参的构造,及所有属性的get set方法
     */
    public class 双列表3QueryDAO extends QueryDAO<双列表3> {
        @Override
        protected 双列表3 process(ResultSet result) {
    
            try {
                //把每条记录封装为一个实体对象
                双列表3 p=new 双列表3();
                p.setId(result.getInt(1)); //这一行从1列开始(第一列)
                p.setName(result.getString(2));
    
                return p;
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
    return null;
        }
    }
    

    测试类,(或者相对来说,也可以说成服务层)

    /**
     * 测试类,其中的方法都是测试方法,测试具体功能的执行是否正常
     * @Test 修饰的方法是测试方法
     */
    public class 双列表3Test {
        双列表3CUDDAO dao=null;
        QueryDAO<双列表3> queryDAO=null;
        {
            dao=new 双列表3CUDDAO();
            queryDAO=new 双列表3QueryDAO();
        }
    
    
        @Test
        public void testAdd(){
              String sql="insert into 双列表3 (id,name)values(?,?)";
              dao.update双列表(sql,15,"棒槌手");
        }
    
        @Test
        public void testModify(){
            String sql="update 双列表3 set id=? where name=?";
            dao.update双列表(sql,16,"棒槌手");
        }
    
        @Test
        public void testRemove(){
            String sql="delete from 双列表3 where id=?";
            dao.update双列表(sql,16);
        }
    
        @Test
        public void testQUery(){
            String sql="select * from 双列表3";
            List<双列表3> list=queryDAO.query双列表(sql,null);
    
            for (双列表3 p:list) {
                System.out.println(p.getId()+"-----"+p.getName());
            }
        }
    }
    
      public void testAdd()  执行时,数据库里的变化
    

    在这里插入图片描述

       public void testModify() 执行时,数据库里的变化
    

    在这里插入图片描述

      public void testRemove()  执行时,数据库的变化
    

    在这里插入图片描述

    再次插入数据,运行public void testQUery() ,返回的数据输出:
    在这里插入图片描述

    Jsp Mysql乱码问题解决方案
    https://blog.51cto.com/sharep/119700

    泛型就这么简单

    https://segmentfault.com/a/1190000014120746

    时间之外的关于驱动程序或框架的补充

    Class.forName(driverName) 语句说明

    在这里插入图片描述
    在这里插入图片描述
    沿着 static String driverName="com.mysql.cj.jdbc.Driver";这条路径,从驱动程序包中找去,可以找到以下代码。这是注册驱动程序的代码,注册成功之后,即可通过DriverManager类,来获取连接对象。(代码实现了Java sql包中,Driver接口)
    源码来源:com.mysql.cj.jdbc Driver类

    public class Driver extends NonRegisteringDriver implements java.sql.Driver {
        public Driver() throws SQLException {
        }
    
        static {
            try {
                DriverManager.registerDriver(new Driver());
            } catch (SQLException var1) {
                throw new RuntimeException("Can't register driver!");
            }
        }
    }
    

    同时DriverManager类中,维护着这样的List 集合
    源码来源:java.sql.DriverManager 类中

    private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
    

    这是线程安全的LIst,如果需要改变集合中的元素,先把集合复制一份,在复制品上进行修改,然后把复制品转换为源集合。
    所有的驱动程序加载后都存放在该集合中,这个过程就是驱动程序的注册。

    DriverManager类里的getConnection()方法的说明

    DriverManager类提供了getConnection()方法来得到连接对象,该方法是工厂方法,因此属于工厂模式。
    源码来源:java.sql.DriverManager 类中getConnection()方法片段

    for (DriverInfo aDriver : registeredDrivers) {
                // If the caller does not have permission to load the driver then
                // skip it.
                if (isDriverAllowed(aDriver.driver, callerCL)) {
                    try {
                        println("    trying " + aDriver.driver.getClass().getName());
                        Connection con = aDriver.driver.connect(url, info);
                        if (con != null) {
                            // Success!
                            println("getConnection returning " + aDriver.driver.getClass().getName());
                            return (con);
                        }
    

    同时,连接对象是由数据库驱动程序创建的。 Connection con = aDriver.driver.connect(url, info);,并且,得到的连接对象是单例的 得到的连接对象是单例的。(下方代码的case SINGLE_CONNECTION:
    return ConnectionImpl.getInstance(conStr.getMainHost()); 语句表名为单例模式)
    源码来源:com.mysql.cj.jdbc NonRegisteringDriver类 (是驱动程序中Driver类的父类)

    public Connection connect(String url, Properties info) throws SQLException {
            try {
                try {
                    if (!ConnectionUrl.acceptsUrl(url)) {
                        return null;
                    } else {
                        ConnectionUrl conStr = ConnectionUrl.getConnectionUrlInstance(url, info);
                        switch(conStr.getType()) {
                        case SINGLE_CONNECTION:
                            return ConnectionImpl.getInstance(conStr.getMainHost());
                        case LOADBALANCE_CONNECTION:
                            return LoadBalancedConnectionProxy.createProxyInstance((LoadbalanceConnectionUrl)conStr);
                        case FAILOVER_CONNECTION:
                            return FailoverConnectionProxy.createProxyInstance(conStr);
                        case REPLICATION_CONNECTION:
                            return ReplicationConnectionProxy.createProxyInstance((ReplicationConnectionUrl)conStr);
                        default:
                            return null;
                        }
                    }
                } catch (UnsupportedConnectionStringException var5) {
                    return null;
                } catch (CJException var6) {
                    throw (UnableToConnectException)ExceptionFactory.createException(UnableToConnectException.class, Messages.getString("NonRegisteringDriver.17", new Object[]{var6.toString()}), var6);
                }
            } catch (CJException var7) {
                throw SQLExceptionsMapping.translateException(var7);
            }
        }
    

    实现细节说明

    对于ResultSet返回类型的说明

    在这里插入图片描述
    ResultSet接口的对象包含了查询的结果,结果以一种虚拟表的形式来表示,可以包含多条记录。
    它内部有一个指针,它可以指向每一条记录,指针指向的记录就是当前记录,程序可以对当前记录进行处理。指针可以移动(一般从上到下),没处理完一条记录就向下移动一条记录,就可以处理下一条记录。
    结果集生成时,指针指向头部(第一条记录的上面),最终指针会移动到尾部(最后一条记录的下面)此时处理过程也就结束了。
    next()方法把指针下移一条记录,如果指向了具体的记录返回true,如果达到尾部返回false
    指向的过程可以使用get具体类型(第几列)的方法形式,对这一行的每一列的数据进行获取(列数从1开始算起)。

    使用PrepareStatement这个陈述接口对象说明

    这里使用PrepareStatement这个陈述接口对象,而没有使用Statement这个陈述接口和对象。
    (1)使用Statement来发送sql语句,sql语句是静态的,在执行前要把参数拼接到SQL命令中,(比如:insert into 双列表3 (id,name)values("+p1+","+p2+") ),这样容易写错,且Statement的同一命令都需要数据库进行编译,执行效率不高。
    (2)PrepareStatement它提供了预编译的功能,同一命令在数据库端只编译一次,后面再执行时不再编译,执行效率高。它的SQL命令中的参数不需要进行拼接,用 " ? "作为点位符,通过setObject(index,参数) ( setObject是比较通用化的设置方式 ) 的方法进行参数的传递,使用简单,不易出错。(index从1开始算起,如果清楚具体参数类型,也可以使用set具体类型(index,参数)的方法,但此时无法保证通用化,不建议使用)
    (3)现代的主流ORM框架内部都使用PrepareStatement来执行命令。

    关于在增删改的DAO具体实现类中使用事务的说明

    在实现增删改的功能时,要使用显示的事务处理机制。JDBC默认的事务处理是隐式的处理,这种事务是针对单一的DML操作命令。
    在Java程序中,需要开启显式事务,在命令成功执行后提交事务,命令执行失败就回滚事务。
    显式事务(也就是说我们需要针对多条DML命令的发生都具有事务属性,要么多条DML语句都执行,要么就都不执行)。
    隐式事务(只能针对单条DML命令的执行与回滚(撤销,也就是不执行))。
    可以使用 connection.setAutoCommit(false);方法关闭隐式事务,再使用connection.commit();方法进行显式的提交事务,如果发生错误,可以在catch中使用 connection.rollback();方法进行回滚操作。

    模板方法模式的简单示意图

    在这里插入图片描述

    关于dbcp、c3p0、druid三种数据库连接池的选择说明

    在这里插入图片描述

    数据库连接池示意图

    在这里插入图片描述

    展开全文
  • JDBC----用JDBC连接Mysql并进行增删改查操作

    千次阅读 多人点赞 2017-06-18 16:29:32
    一,JDBC:Java数据库连接,...二,简单的JDBC实例我使用JDBC写的一个简单程序,主要是使用JDBC连接Mysql数据库,然后对数据库进行一些基本的增删改查操作。1,设计数据表先设计一张数据表,用户保存用户信息,建表语句如

    一,JDBC:Java数据库连接,(Java Database Connectivity,简称JDBC)是Java语言中用来规范客户端程序如何访问数据库的应用程序接口,提供了诸如查询和更新数据库中数据的方法.

    二,简单的JDBC实例

    我使用JDBC写的一个简单程序,主要是使用JDBC连接Mysql数据库,然后对数据库进行一些基本的增删改查操作。

    1,设计数据表

    先设计一张数据表,用户保存用户信息,建表语句如下:

    CREATE TABLE `person` (
     `id` int(11) NOT NULL,
     `name` text NOT NULL,
     `phone` varchar(255) CHARACTER SET latin1 DEFAULT NULL,
     `age` int(11) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    

    在person表中定义了几个字段,分别是id,name,phone,age,其中id是主键,是自增长,name表示用户名,phone是用户的手机,age是用户的年龄。

    预先在数据库中插入几条数据,数据如下:

    这里写图片描述

    2,定义实体类

    定义一个Bean,与数据库表中的各个字段对应:

    public class Person {
    
    private int id;
    private String name;
    private String phone;
    private int age;
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", phone=" + phone
                + ", age=" + age + "]";
    }
    public Person(int id, String name, String phone, int age) {
        super();
        this.id = id;
        this.name = name;
        this.phone = phone;
        this.age = age;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    }
    

    3,定义数据库连接类
    定义一个数据看连接类,用户获取Mysql的连接

    public class DBUtil {
    
    private static String URL = "jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8";
    private static String Driver = "com.mysql.jdbc.Driver";
    private static String user = "root";
    private static String password = "";
    
    public static Connection connectDB() throws Exception {
        Class.forName(Driver);
        Connection conn = DriverManager.getConnection(URL, user, password);
    
        return conn;
    }
    }
    

    Mysql的JDBC URL编写方式为:jdbc:mysql//主机名称:连接端口/数据库名称?参数=值,为了避免中文乱码要指定useUnicode和characterEncoding.因为连接的是Mysql数据库,所以程序一开始需要加载Mysql的数据库驱动,然后通过DriverManager.getConnection(String URL)方法获取数据库的连接。

    4,实现数据库的增删改查

    获取了数据库的连接之后,就可以操作数据库了,下面分别实现数据库的增删改查操作,定义了一个PersonDao类用于操作数据库.

    1)查询

    先看查询操作,在PersonDao中定义了一个queryAll()方法:

    public List<Person> queryAll() throws Exception {
        Connection conn = DBUtil.connectDB();
        String sql = "SELECT * FROM person";
        List<Person> personList = new ArrayList<Person>();
    
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery(sql);
        while (rs.next()) {
            Person person = new Person();
            person.setId(rs.getInt("id"));
            person.setName(rs.getString("name"));
            person.setPhone(rs.getString("phone"));
            person.setAge(rs.getInt("age"));
    
            personList.add(person);
        }
    
        return personList;
    }
    

    这里使用conn.createStatement()方法获取一个Statement对象,这个对象里面有很多方法可以操作数据库,使用executeQuery(sql)执行查询操作,查询结果为一个结果集ResultSet,可以通过这个结果集获取相关信息。

    定义main函数:

    public static void main(String[] args){
        PersonDao dao = new PersonDao();
    
        try {
            List<Person> personList = dao.queryAll();
            for (Person person : personList) {
                System.out.println(person);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
       }
    

    执行结果:

    Person [id=10, name=胡春, phone=18229096647, age=34]
    Person [id=11, name=王菲, phone=18229096640, age=21]
    Person [id=12, name=刘明, phone=18229096649, age=22]
    Person [id=13, name=白云, phone=18229096646, age=25]
    Person [id=15, name=黄土, phone=18229096644, age=20]
    

    根据条件查询,定义一个queryByParams方法:

    public List<Person> queryParams(List<Map<String, Object>> params) throws Exception {
        Connection conn = DBUtil.connectDB();
        String sql = "SELECT * FROM person WHERE 26=26";
    
        System.out.println(sql.toString());
    
        List<Person> personList = new ArrayList<Person>();
    
        Statement stmt = conn.createStatement(); 
        ResultSet rs = stmt.executeQuery(sql.toString());
        while (rs.next()) {
            Person person = new Person();
            person.setId(rs.getInt("id"));
            person.setName(rs.getString("name"));
            person.setPhone(rs.getString("phone"));
            person.setAge(rs.getInt("age"));
    
            personList.add(person);
        }
        return personList;
     }
    

    这个方法自由选择查询的条件,只需要向方法中传入一个条件List即可,这些条件都市有Map组成,每一个Map包含三个元素,col表示查询列,rel表示查询条件的关系,value是指查询条件的值。

    PersonDao dao = new PersonDao();
    
    List<Map<String, Object>>  params = new ArrayList<Map<String,Object>>();
    Map<String, Object>  param1 = new  HashMap<String, Object>();
        param1.put("id", "20");
        param1.put("name", "jaerk");
        param1.put("phone", "13266512345");
        param1.put("age", "%26%");
    params.add(param1);
    
    Map<String, Object>  param2 = new  HashMap<String, Object>();
    param2.put("id", "290");
        param2.put("name", "jark");
        param2.put("phone", "13666512345");
        param2.put("age", 26);
        params.add(param2);
    
        try {
        List<Person> personList = dao.queryParams(params);
            for (Person person : personList) {
                System.out.println(person);
        }
    } catch (Exception e) {
        e.printStackTrace();
        }
        }
    

    2增加

    现在在PersonDao中写一个addPerson方法用于新增一条信息:

    public void addPerson(Person person) throws Exception {
        Connection conn = DBUtil.connectDB();
        String sql = "INSERT INTO person(id, name, phone, age)" 
                       + " VALUES(?, ?, ?, ?)";
    
              PreparedStatement psmt = conn.prepareStatement(sql);
            psmt.setInt(1, person.getId());
        psmt.setString(2, person.getName());
        psmt.setString(3, person.getPhone());
        psmt.setInt(4, person.getAge());
    
        psmt.execute();
        conn.close();
    }
    

    这个方法使用conn.prepareStatement(sql)获取一个PreparedStatement对象,使用这个方法可以传入带参数的SQL语句,而参数的值可以通过PreparedStatement.setXXX(index,value)方法指定,其中xxx为各种不同的类型,index指定第几个参数,value指定了带参数的值,便可以执行excute()方法执行sql语句了。

     PersonDao dao = new PersonDao();
        Person person = new Person();
    
        person.setName("黑风");       
        person.setPhone("18229096642");
        person.setAge(20);
        person.setId(16);
        try {
            dao.addPerson(person);
        } catch (Exception e) {
            e.printStackTrace();
        }
        }
    

    执行后再查看数据库,发现”黑风”用户插入成功

    这里写图片描述

    3:删除

    接下来写一个删除的方法,根据用户的id来删除数据:

    public void deleteUser(int id) throws Exception {
        Connection conn = DBUtil.connectDB();
        String sql = "DELETE FROM person WHERE id = ?";
    
        PreparedStatement psmt = conn.prepareStatement(sql);
        psmt.setInt(1, id);
    
        psmt.execute();
        }
    

    然后写一个main方法来验证:

    PersonDao dao = new PersonDao();
    
     try {
        dao.deleteUser(26);
        } catch (Exception e) {
            e.printStackTrace();
        }
    

    删除id为26的用户,运行后查看数据库:

    这里写图片描述

    4:更新数据库

    最后来看一下更新数据库:

     public void updatePerson(Person person) throws Exception {
        Connection conn = DBUtil.connectDB();
        String sql = "UPDATE person SET name=?, phone=?, age=?"
                      + " WHERE id=?";
        PreparedStatement pstmt = conn.prepareStatement(sql);
        pstmt.setInt(4, person.getId());
        pstmt.setString(1, person.getName());
        pstmt.setString(2, person.getPhone());
        pstmt.setInt(3, person.getAge());
        pstmt.executeUpdate();
        conn.close();
    }
    

    从SQL语句中可以看出更新的也就是根据用户id进行选择性的更新。
    写一个main方法验证:

     PersonDao dao = new PersonDao();
     Person person = new Person();
    
    
        person.setName("黑风");       
        person.setPhone("18229096642");
        person.setAge(26);
        person.setId(18);
    try {
            dao.updatePerson(person);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    

    这个方法里将用户名为黑风的用户年龄改为26岁,执行程序,运行后查看数据库:

    这里写图片描述

    可以看到用户的年龄变成了26,更新成功。

    三,总结
    使用JDBC连接Mysql数据库并进行基本的增删改查就已经完成了,这些只是最简单的数据库操作,实际开发过程中操作数据库比这些复杂多了,包括事务处理,存储过程等等,就需要使用JDBC更高级的功能了。

    展开全文
  • 接下来我们创建数据库(MySQL) 3.在数据库里面添加数据 4.首先是BaseDao,这个是重中之重,注意那个数据库的名字,强调所在的包名 5.这个是实体类,我相信大家都会写,注意所在的包名,注意所在的包名注意所在的包名,...

    目录

           1.首先这个Myeclipse的包名以及一些实现的类(这样子写是我的习惯)

              2.接下来我们创建数据库(MySQL)

            3.在数据库里面添加数据

            4.首先是BaseDao,这个是重中之重,注意那个数据库的名字,强调所在的包名

          5.这个是实体类,我相信大家都会写,注意所在的包名,注意所在的包名注意所在的包名,重要的事情所三遍

            6.接下来我们写BookingDao

            

        7.下面我们写Servlet

            1.查询的Servlet

            2.添加的Servlet

            3.修改的Servlet

            4.删除的Servlet

            8.再次写JSP页面

                  1.index.jsp 初始界面

                  2.insert.jsp 添加页面    

                  3.Update.jsp 修改页面

         9. 最后这个是在浏览器中显示的效果,这个是查询效果,查询全表如下

               1.查询

             2.增加

             3.修改(接下里我们把刚才我们添加的数据修改)

             4.删除(这个效果可能不是很明显,但为了界面我还是把它给截图下来了)


      

           1.首先这个Myeclipse的包名以及一些实现的类(这样子写是我的习惯)

          

              2.接下来我们创建数据库(MySQL)

              

             

     

            3.在数据库里面添加数据

             

            4.首先是BaseDao,这个是重中之重,注意那个数据库的名字,强调所在的包名

    package dao;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class BaseDao {
    
    	/***
    	 * 
    	 * @author 数据库连接类
    	 *
    	 */
    		private String driver ="com.mysql.jdbc.Driver";
    		private String url="jdbc:mysql://localhost:3306/表名";        ---------自己写数据库表名,只要数据库的表名跟这里的一样就行
    		private String name="数据库名称";      ----------你自己数据库的名称
    		private String pwd="密码";        -----------你自己数据库的密码
    	      Connection conn=null;
    	      /***
    	       * 
    	       * @return 打开连接
    	       */
    	    /*  public Connection getconn(){
    	  		Connection conn=null;
    	  		Context ctx;
    	  		try {
    	  			ctx = new InitialContext();
    	  			DataSource ds=(DataSource)ctx.lookup("java:comp/env/jdbc/news");	
    	  	    	conn=ds.getConnection();
    	  		}catch (Exception e) {
    	  			e.printStackTrace();
    	  		}
    	  		return conn;
    	  	}     */
    		protected  Connection getconn(){
    			conn=null;	
    			try {
    				Class.forName(driver);
    				conn=DriverManager.getConnection(url,name,pwd);
    			} catch (ClassNotFoundException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}		
    			return conn;
    		}
    		
    		/****
    		 * 
    		 * @param 关闭数据库连接
    		 */
    		protected void closeAll(Connection conn ,PreparedStatement ps,ResultSet rs){		
    			if(rs!=null)
    				try {
    					if(rs!=null)
    					rs.close();
    					if(ps!=null)
    					ps.close();
    					if(conn!=null)
    					conn.close();
    				} catch (SQLException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}				
    		}
    		/***
    		 * 
    		 * @param 增删改方法
    		 * @param 接受 参数为 SQL语句 和 对象数组
    		 * @return 返回受影响行数
    		 */
    		public int executeUpdate(String sql ,Object []ob){
    			conn=getconn();
    			PreparedStatement ps=null;
    			try {
    				ps=prepareStatement(conn,sql,ob);
    				int i=ps.executeUpdate();
    				return i;	
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    			    //	e.printStackTrace();
    				return 0;
    			}finally{			
    				closeAll(conn, ps, null);
    			}
    		
    		}	
    		/***
    		 * 查询方法
    		 */
    		protected PreparedStatement prepareStatement(Connection conn,String sql,Object []ob){		
    			PreparedStatement ps=null;
    					try {
    						int index=1;
    						ps = conn.prepareStatement(sql);
    							if(ps!=null&&ob!=null){
    								for (int i = 0; i < ob.length; i++) {			
    										ps.setObject(index, ob[i]);	
    										index++; 
    								}
    							}
    					} catch (SQLException e1) {
    						e1.printStackTrace();
    					}
    			 return ps;
    		}
    	
    }

          5.这个是实体类,我相信大家都会写,注意所在的包名

    package entity;
    
    public class Booking {
    	private int id;
    	private int categoryId;
    	private String title;
    	private String summary;
    	private String uploaduser;
    	private String createdate;
    	
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public int getCategoryId() {
    		return categoryId;
    	}
    	public void setCategoryId(int categoryId) {
    		this.categoryId = categoryId;
    	}
    	public String getTitle() {
    		return title;
    	}
    	public void setTitle(String title) {
    		this.title = title;
    	}
    	public String getSummary() {
    		return summary;
    	}
    	public void setSummary(String summary) {
    		this.summary = summary;
    	}
    	public String getUploaduser() {
    		return uploaduser;
    	}
    	public void setUploaduser(String uploaduser) {
    		this.uploaduser = uploaduser;
    	}
    	public String getCreatedate() {
    		return createdate;
    	}
    	public void setCreatedate(String createdate) {
    		this.createdate = createdate;
    	}
    	
    	
    }
    

            6.接下来我们写BookingDao

            

    package dao;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    import entity.Booking;
    
    public class BookingDao extends BaseDao{
    	
    	public List<Booking> search(String sql,Object...params){
    		List<Booking> list =new ArrayList<Booking>();
    		Connection conn=this.getconn();
    		PreparedStatement pst=null;
    		ResultSet rs=null;
    		try {
    			pst=this.prepareStatement(conn, sql, params);
    			rs=pst.executeQuery();
    			while(rs.next()){
    				Booking wor=new Booking();
    				wor.setId(rs.getInt(1));
    				wor.setCategoryId(rs.getInt(2));
    				wor.setTitle(rs.getString(3));
    				wor.setSummary(rs.getString(4));
    				wor.setUploaduser(rs.getString(5));
    				wor.setCreatedate(rs.getString(6));
    				list.add(wor);
    			}
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}finally{
    			closeAll(conn, pst, rs);
    		}
    		return list;
    	}
    	
    	//查询表
    	public List<Booking> findAll(){
    		String sql="SELECT * FROM `Book`";
    		return search(sql);
    	}
    	
    	//添加方法
    	public int insert(Booking t){
    		String str="INSERT INTO `book`(categoryId,title,summary,uploaduser,createdate) VALUE(?,?,?,?,?)";
    		return executeUpdate(str, new Object[]{t.getCategoryId(),t.getTitle(),t.getSummary(),t.getUploaduser(),t.getCreatedate()});
    	}
    	
    	//修改方法
    	public int update(Booking r){
    		String sql="UPDATE `book` SET `categoryId`=?,`title`=?,`summary`=?,`uploaduser`=?,`createdate`=? WHERE id=?";
    		return executeUpdate(sql, new Object[]{r.getCategoryId(),r.getTitle(),r.getSummary(),r.getUploaduser(),r.getCreatedate(),r.getId()});
    	}
    	
    	//删除方法
    	public int delete(Booking e){
    		String sql="DELETE FROM `book` WHERE id=?";
    		return executeUpdate(sql, new Object[]{e.getId()});
    	}
    	
    	
    }
    

        7.下面我们写Servlet

            1.查询的Servlet

                 

    package servlet;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.List;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import dao.BookingDao;
    import entity.Booking;
    
    public class selectServlet extends HttpServlet {
    
    	/**
    	 * Constructor of the object.
    	 */
    	public selectServlet() {
    		super();
    	}
    
    	/**
    	 * Destruction of the servlet. <br>
    	 */
    	public void destroy() {
    		super.destroy(); // Just puts "destroy" string in log
    		// Put your code here
    	}
    
    	/**
    	 * The doGet method of the servlet. <br>
    	 *
    	 * This method is called when a form has its tag value method equals to get.
    	 * 
    	 * @param request the request send by the client to the server
    	 * @param response the response send by the server to the client
    	 * @throws ServletException if an error occurred
    	 * @throws IOException if an error occurred
    	 */
    	public void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		doPost(request, response);
    	}
    
    	/**
    	 * The doPost method of the servlet. <br>
    	 *
    	 * This method is called when a form has its tag value method equals to post.
    	 * 
    	 * @param request the request send by the client to the server
    	 * @param response the response send by the server to the client
    	 * @throws ServletException if an error occurred
    	 * @throws IOException if an error occurred
    	 */
    	public void doPost(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		request.setCharacterEncoding("utf-8");
    		response.setCharacterEncoding("utf-8");
    		response.setContentType("text/html");
    		PrintWriter out = response.getWriter();
    		
    		String opr=request.getParameter("opr");
    		
    	
    		if(opr==null||opr.equals("list")){
    			//刷新
    			BookingDao goodsDao=new BookingDao();
    			List<Booking> list=goodsDao.findAll();
    			request.getSession().setAttribute("list", list);
    			response.sendRedirect("index.jsp");
    		}
    		
    		
    		
    		
    		out.flush();
    		out.close();
    	}
    
    	/**
    	 * Initialization of the servlet. <br>
    	 *
    	 * @throws ServletException if an error occurs
    	 */
    	public void init() throws ServletException {
    		// Put your code here
    	}
    
    }
    

     

            2.添加的Servlet

                

    package servlet;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.List;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import dao.BookingDao;
    import entity.Booking;
    
    public class insertServlet extends HttpServlet {
    
    	/**
    	 * Constructor of the object.
    	 */
    	public insertServlet() {
    		super();
    	}
    
    	/**
    	 * Destruction of the servlet. <br>
    	 */
    	public void destroy() {
    		super.destroy(); // Just puts "destroy" string in log
    		// Put your code here
    	}
    
    	/**
    	 * The doGet method of the servlet. <br>
    	 *
    	 * This method is called when a form has its tag value method equals to get.
    	 * 
    	 * @param request the request send by the client to the server
    	 * @param response the response send by the server to the client
    	 * @throws ServletException if an error occurred
    	 * @throws IOException if an error occurred
    	 */
    	public void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		doPost(request, response);
    	}
    
    	/**
    	 * The doPost method of the servlet. <br>
    	 *
    	 * This method is called when a form has its tag value method equals to post.
    	 * 
    	 * @param request the request send by the client to the server
    	 * @param response the response send by the server to the client
    	 * @throws ServletException if an error occurred
    	 * @throws IOException if an error occurred
    	 */
    	public void doPost(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		request.setCharacterEncoding("utf-8");
            response.setCharacterEncoding("utf-8");
    		response.setContentType("text/html;charset=utf-8");
    		PrintWriter out = response.getWriter();
    		
    		BookingDao rms=new BookingDao(); 
    		  int categoryId=Integer.parseInt(request.getParameter("categoryId"));
    		  String title=request.getParameter("title");
    		  String summary=request.getParameter("summary");
    		  String uploaduser=request.getParameter("uploaduser");
    		  String createdate=request.getParameter("createdate");
    		  Booking rm=new Booking();
    			  rm.setCategoryId(categoryId);
    			  rm.setTitle(title);
    			  rm.setSummary(summary);
    			  rm.setUploaduser(uploaduser);
    			  rm.setCreatedate(createdate);
    			 int i=rms.insert(rm);
    			 if(i>0){
    				 out.print("true");
    				//刷新
    					List<Booking> listrm=rms.findAll();
    					request.getSession().setAttribute("list", listrm);
    			 }else{
    				 out.print("false");
    			 }
    		
    		out.flush();
    		out.close();
    	}
    
    	/**
    	 * Initialization of the servlet. <br>
    	 *
    	 * @throws ServletException if an error occurs
    	 */
    	public void init() throws ServletException {
    		// Put your code here
    	}
    
    }
    

     

            3.修改的Servlet

     

                  

    package servlet;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.List;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import dao.BookingDao;
    import entity.Booking;
    
    public class updateServlet extends HttpServlet {
    
    	/**
    	 * Constructor of the object.
    	 */
    	public updateServlet() {
    		super();
    	}
    
    	/**
    	 * Destruction of the servlet. <br>
    	 */
    	public void destroy() {
    		super.destroy(); // Just puts "destroy" string in log
    		// Put your code here
    	}
    
    	/**
    	 * The doGet method of the servlet. <br>
    	 *
    	 * This method is called when a form has its tag value method equals to get.
    	 * 
    	 * @param request the request send by the client to the server
    	 * @param response the response send by the server to the client
    	 * @throws ServletException if an error occurred
    	 * @throws IOException if an error occurred
    	 */
    	public void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		doPost(request, response);
    	}
    
    	/**
    	 * The doPost method of the servlet. <br>
    	 *
    	 * This method is called when a form has its tag value method equals to post.
    	 * 
    	 * @param request the request send by the client to the server
    	 * @param response the response send by the server to the client
    	 * @throws ServletException if an error occurred
    	 * @throws IOException if an error occurred
    	 */
    	public void doPost(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		response.setContentType("text/html");
    		PrintWriter out = response.getWriter();
    		
    		
    		BookingDao booking=new BookingDao();
    	    	int id=Integer.parseInt(request.getParameter("id"));
    	    	 int categoryId=Integer.parseInt(request.getParameter("categoryId"));
    			  String title=request.getParameter("title");
    			  String summary=request.getParameter("summary");
    			  String uploaduser=request.getParameter("uploaduser");
    			  String createdate=request.getParameter("createdate");
    			  Booking rm=new Booking();
    			      rm.setId(id);
    				  rm.setCategoryId(categoryId);
    				  rm.setTitle(title);
    				  rm.setSummary(summary);
    				  rm.setUploaduser(uploaduser);
    				  rm.setCreatedate(createdate);
    	    	int i=booking.update(rm);
    			 if(i>0){
    				//刷新
    					List<Booking> listrm=booking.findAll();
    					request.getSession().setAttribute("list", listrm);
    					out.print("<script>alert('修改成功!!!');location.href='index.jsp';</script>");
    			 }else{
    				 out.print("<script>alert('修改失败!!!');location.href='Update.jsp';</script>");
    			 }
    		
    		out.flush();
    		out.close();
    	}
    
    	/**
    	 * Initialization of the servlet. <br>
    	 *
    	 * @throws ServletException if an error occurs
    	 */
    	public void init() throws ServletException {
    		// Put your code here
    	}
    
    }
    

     

            4.删除的Servlet

    package servlet;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.List;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import dao.BookingDao;
    import entity.Booking;
    
    public class deleteServlet extends HttpServlet {
    
    	/**
    	 * Constructor of the object.
    	 */
    	public deleteServlet() {
    		super();
    	}
    
    	/**
    	 * Destruction of the servlet. <br>
    	 */
    	public void destroy() {
    		super.destroy(); // Just puts "destroy" string in log
    		// Put your code here
    	}
    
    	/**
    	 * The doGet method of the servlet. <br>
    	 *
    	 * This method is called when a form has its tag value method equals to get.
    	 * 
    	 * @param request the request send by the client to the server
    	 * @param response the response send by the server to the client
    	 * @throws ServletException if an error occurred
    	 * @throws IOException if an error occurred
    	 */
    	public void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		doPost(request, response);
    	}
    
    	/**
    	 * The doPost method of the servlet. <br>
    	 *
    	 * This method is called when a form has its tag value method equals to post.
    	 * 
    	 * @param request the request send by the client to the server
    	 * @param response the response send by the server to the client
    	 * @throws ServletException if an error occurred
    	 * @throws IOException if an error occurred
    	 */
    	public void doPost(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		response.setContentType("text/html");
    		PrintWriter out = response.getWriter();
    		
    		BookingDao rms=new BookingDao();
    		Booking rm=new Booking();
    		int id=Integer.parseInt(request.getParameter("id"));
    		rm.setId(id);
    		int i=rms.delete(rm);
    		if(i>0){
    			List<Booking> listrm=rms.findAll();
    			request.getSession().setAttribute("list", listrm);
    			out.print("<script>alert('删除成功!!!');location.href='index.jsp';</script>");
    		}else{
    			out.print("<script>alert('删除失败!!!');location.href='index.jsp';</script>");
    		}
    		
    		out.flush();
    		out.close();
    	}
    
    	/**
    	 * Initialization of the servlet. <br>
    	 *
    	 * @throws ServletException if an error occurs
    	 */
    	public void init() throws ServletException {
    		// Put your code here
    	}
    
    }

            8.配置web.xml

               

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="3.0"
        xmlns="http://java.sun.com/xml/ns/javaee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
      <servlet>
        <description>This is the description of my J2EE component</description>
        <display-name>This is the display name of my J2EE component</display-name>
        <servlet-name>selectServlet</servlet-name>
        <servlet-class>servlet.selectServlet</servlet-class>
      </servlet>
      <servlet>
        <description>This is the description of my J2EE component</description>
        <display-name>This is the display name of my J2EE component</display-name>
        <servlet-name>insertServlet</servlet-name>
        <servlet-class>servlet.insertServlet</servlet-class>
      </servlet>
      <servlet>
        <description>This is the description of my J2EE component</description>
        <display-name>This is the display name of my J2EE component</display-name>
        <servlet-name>updateServlet</servlet-name>
        <servlet-class>servlet.updateServlet</servlet-class>
      </servlet>
      <servlet>
        <description>This is the description of my J2EE component</description>
        <display-name>This is the display name of my J2EE component</display-name>
        <servlet-name>deleteServlet</servlet-name>
        <servlet-class>servlet.deleteServlet</servlet-class>
      </servlet>
      <servlet>
        <description>This is the description of my J2EE component</description>
        <display-name>This is the display name of my J2EE component</display-name>
        <servlet-name>idServlet</servlet-name>
        <servlet-class>servlet.idServlet</servlet-class>
      </servlet>
    
      <servlet-mapping>
        <servlet-name>selectServlet</servlet-name>
        <url-pattern>/selectServlet</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
        <servlet-name>insertServlet</servlet-name>
        <url-pattern>/insertServlet</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
        <servlet-name>updateServlet</servlet-name>
        <url-pattern>/updateServlet</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
        <servlet-name>deleteServlet</servlet-name>
        <url-pattern>/deleteServlet</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
        <servlet-name>idServlet</servlet-name>
        <url-pattern>/idServlet</url-pattern>
      </servlet-mapping>
      <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
      </welcome-file-list>
    
    </web-app>

     需要注意的是下面段,在上面是web.xml中比较下面,

    <servlet-mapping>标签声明了与该servlet相应的匹配规则,每个<url-pattern>标签代表1个匹配规则。含了两个子元素<servlet- name>和<url-pattern>,<servlet-name>元素给出的Servlet名字必须是 在<servlet>元素中声明过的Servlet的名字。<url-pattern>元素指定对应于Servlet的URL路 径,该路径是相对于Web应用程序上下文根的路径。

    <servlet-mapping>
       <servlet-name></servlet-name>
       <url-pattern></url-pattern>
    </servlet-mapping>

     

            9.再次写JSP页面

                  1.index.jsp 初始界面

       

    <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
    <%@ taglib  uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
    <%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
    %>
    
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
      <head>
        <base href="<%=basePath%>">
        
        <title></title>
    	<meta http-equiv="pragma" content="no-cache">
    	<meta http-equiv="cache-control" content="no-cache">
    	<meta http-equiv="expires" content="0">    
    	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    	<meta http-equiv="description" content="This is my page">
    	<!--
    	<link rel="stylesheet" type="text/css" href="styles.css">
    	-->
      </head>
      
      <body>
      
      	<c:if test="${list==null}">
         <jsp:forward page="selectServlet"></jsp:forward>
        </c:if>
        <a href="insert.jsp"><input type="button" value="新增图书"></a>
        
        <table border="1">
        	<tr><td>电子图书列表</td></tr>
        	<tr><td>书品编号</td><td>书名</td><td>摘要</td><td>上传人</td><td>上传时间</td><td>操作</td></tr>
        	<c:forEach items="${list}" var="gd">
              <tr>
              	<td>${gd.categoryId}</td>
              	<td>${gd.title}</td>
              	<td>${gd.summary}</td>
              	<td>${gd.uploaduser}</td>
              	<td>${gd.createdate }</td>
              	<td><a href="idServlet?id=${gd.id}"><input type="button" value="修改"></a></td>
              	<td><a href="deleteServlet?id=${gd.id}"><input type="button" value="删除"></a></td>
              </tr>
           </c:forEach>
        	
        </table>
      
      </body>
    </html>
    

     

                  2.insert.jsp 添加页面    

                      

    <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
    <%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
    %>
    
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
      <head>
        <base href="<%=basePath%>">
        
        <title></title>
        
    	<meta http-equiv="pragma" content="no-cache">
    	<meta http-equiv="cache-control" content="no-cache">
    	<meta http-equiv="expires" content="0">    
    	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    	<meta http-equiv="description" content="This is my page">
    	<!--
    	<link rel="stylesheet" type="text/css" href="styles.css">
    	-->
    
    	<script type="text/javascript" src="js/jquery-1.12.4.js"></script>
    	<script type="text/javascript">
    	$(function(){
    
               $("#submit").click(function(){
                    //非空验证
                        var $form=$("form").serialize();
                        alert($form);
                      $.get("insertServlet",$form,function(data){
                          if(data=="true"){
                             alert("新增成功");
                             window.location="index.jsp";
                          }else{
                           alert("新增失败");
                          }
                      });
           });
           });
    	</script>
    
      </head>
      
      <body>
      	<form action="">
      		<h2>新增书本</h2>
      		书本编号:<input type="text" name="categoryId"><br>
      		书本名称:<input type="text" name="title"><br>
      		摘要:<input type="text" name="summary"><br>
      		上传人:<input type="text" name="uploaduser"><br>
      		上传时间:<input type="text" name="createdate"><br>
      		<input type="button" id="submit" value="提交"><input type="reset" value="重置">
      	</form>
      
      </body>
    </html>
    

     

                  3.Update.jsp 修改页面

                    (1)这个是修改的主要

    <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
    <%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
    %>
    
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
      <head>
        <base href="<%=basePath%>">
        
        <title></title>
        
    	<meta http-equiv="pragma" content="no-cache">
    	<meta http-equiv="cache-control" content="no-cache">
    	<meta http-equiv="expires" content="0">    
    	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    	<meta http-equiv="description" content="This is my page">
    	<!--
    	<link rel="stylesheet" type="text/css" href="styles.css">
    	-->
    
      </head>
      
      <body>
        	<form action="updateServlet">
      		<h2>修改书本</h2>
      		<input type="hidden" value="${idid}" name="id">
      		书本编号:<input type="text" name="categoryId"><br>
      		书本名称:<input type="text" name="title"><br>
      		摘要:<input type="text" name="summary"><br>
      		上传人:<input type="text" name="uploaduser"><br>
      		上传时间:<input type="text" name="createdate"><br>
      		<input type="submit" id="submit" value="提交"><input type="reset" value="重置">
      	</form>
      </body>
    </html>

                    (2)这个idServlet是我后面出现的BUG,我现在只能给又加了一个Servlet

    package servlet;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class idServlet extends HttpServlet {
    
    	/**
    	 * Constructor of the object.
    	 */
    	public idServlet() {
    		super();
    	}
    
    	/**
    	 * Destruction of the servlet. <br>
    	 */
    	public void destroy() {
    		super.destroy(); // Just puts "destroy" string in log
    		// Put your code here
    	}
    
    	/**
    	 * The doGet method of the servlet. <br>
    	 *
    	 * This method is called when a form has its tag value method equals to get.
    	 * 
    	 * @param request the request send by the client to the server
    	 * @param response the response send by the server to the client
    	 * @throws ServletException if an error occurred
    	 * @throws IOException if an error occurred
    	 */
    	public void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		doPost(request, response);
    	}
    
    	/**
    	 * The doPost method of the servlet. <br>
    	 *
    	 * This method is called when a form has its tag value method equals to post.
    	 * 
    	 * @param request the request send by the client to the server
    	 * @param response the response send by the server to the client
    	 * @throws ServletException if an error occurred
    	 * @throws IOException if an error occurred
    	 */
    	public void doPost(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		response.setContentType("text/html");
    		PrintWriter out = response.getWriter();
    		
    		int id=Integer.parseInt(request.getParameter("id"));
    		request.getSession().setAttribute("idid", id);
    		response.sendRedirect("Update.jsp");
    		
    		out.flush();
    		out.close();
    	}
    
    	/**
    	 * Initialization of the servlet. <br>
    	 *
    	 * @throws ServletException if an error occurs
    	 */
    	public void init() throws ServletException {
    		// Put your code here
    	}
    
    }
    

     

         9. 最后这个是在浏览器中显示的效果,这个是查询效果,查询全表如下

               1.查询

            

             2.增加

                   

             3.修改(接下里我们把刚才我们添加的数据修改)

                    

     

             4.删除(这个效果可能不是很明显,但为了界面我还是把它给截图下来了)

                   我把刚才我们上面操作的添加和修改给删除掉看看效果!

                  

    最后,项目运行地址:http://localhost:8080/ebookentry-JDBC/index.jsp     看你的端口是808几了。

    好了,这个项目也算了做完了,是个完整的,虽然在往数据库传数据的时候出现了中文乱码,但是我会去调这个BUG的,但至少功能实现了。

    以上就是这个项目了,虽然在有些地方大家看到的效果不是很明显,如果本篇文章看了对大家有帮助,麻烦大家点个赞,谢谢,如果对本篇有疑问有出现报错的地方或者是其他问题,加我QQ3506346737(备注:CSDN博客+QQ名字),很期待您的好友申请,也很期待大家对本篇文章的一些改进建议,谢谢

    附源码获取下载地址:百度网盘。如果连接资源不存在,也请在第一时间加QQ,捧上源码。下载代码后遇到问题及时联系本人,尽快修正错误。

    链接:https://pan.baidu.com/s/1nlOSG10a0dW72qeeUKrS2g 
    提取码:ycqr 

     

     

     

    展开全文
  • jdbc连接MySQL进行增删改查等操作的源码示例。有创建实体类进行操作和不创建实体类进行操作的两种方法
  • 目录查询语句()插入语句()删除语句()修改语句()SQL注入问题完整的网站登录检查 点击截图右边的加号 然后选择jar包 mysql-connector-java-5.1.17.jar 这个jar包让我们可以在java中操作mysql 接着...

    在这里插入图片描述
    点击截图右边的加号
    在这里插入图片描述
    然后选择jar包 mysql-connector-java-5.1.17.jar 这个jar包让我们可以在java中操作mysql
    接着点击右下角的apply应用和OK,之后就可以正常使用了

    查询语句(查)

    注释中包含:

    1. 连接里面的字段含义解释,url,user,password
    2. 查询语句的执行语句是executeQuery,返回的是包含一至多条数据的结果集
      增删改操作的执行语句是executeUpdate,返回结果为1或者非1,为1 正确执行,非1 直接报错
    3. 获取结果集中的字段值,不同类型有不同的语句。String类型对应getString,int类型对应getInt
    4. getString语句的括号中可以写字段名或者索引值,索引从1开始,索引为1表示第一列
    package mysql;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.Statement;
    
    /*
    	顺序:
        1.加载驱动:使用反射来引用jdbc中的代码
        2.获取连接
        3.执行sql语句
     */
    public class MYSQLTest1 {
        public static void main(String[] args) throws Exception {
            // 1,加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            
            //2,获取连接 ,DriverManager.getConnection返回一个对象,通过这个对象可以操作sql
            //返回来的这个conn对象就相当于mysql服务
            //jdbc:mysql://master:3306/show1 ,jdbc是固定值,mysql根据连接的数据库类型而定
            //master是ip地址,我是在hosts文件里面将master与ip地址绑定了,所以可以直接写master
            //3306是端口号,一般固定是这个数值,最后的show1是要连接的数据库的名字
            //最后面的root和123456是mysql的用户名和密码
            Connection conn = DriverManager.getConnection("jdbc:mysql://master:3306/show1", "root", "123456");
            
            //3,执行mysql
            //3.1 写具体的sql语句
            String sql = "select * from stu";
            //3.2 获取执行sql语句的执行器
            Statement statement = conn.createStatement();
            //3.3 利用执行器statement执行sql语句
            //sql语句可以分为两大类,一类是查询语句,一类是增删改的修改语句
            //查询语句的返回结果是一个结果集,里面可以包含多行查询到的数据,使用executeQuery
            //修改语句的返回结果要么是1说明执行成功,要么不是1就会报错,使用executeUpdate
            //这里先看查询语句,使用executeQuery
            ResultSet resultSet = statement.executeQuery(sql);
    
            //查看执行完的结果
            //这里遍历结果集resultSet,不能用for和Iterator,只能用while+next()获取里面的每一条数据
            while(resultSet.next()){
                //根据不同的数据类型有不同的语句,比如String类型用getString,int类型用getInt
                //而这些语句都有两种用法,一种是下面的第一行,直接用字段名来获取这一列的字段值
                //第二种方法是第二行用索引值来获取数据,注意mysql字段的索引从1开始
                String name = resultSet.getString("StudentName");
                String string = resultSet.getString(2);
    
                //name和String结果相同
                System.out.println(name);
                System.out.println(string);
                System.out.println("-----------");
            }
            //关闭连接
            resultSet.close();
            statement.close();
            conn.close();
        }
    }
    
    

    在这里插入图片描述

    插入语句(增)

    注释中包含:

    1. sql语句中单引号与双引号的区别
      sql语句中没有变量时,字段值统一用单引号。sql需要变量时,用" ’ “+变量名+” ’ "这样的写法在执行时被转换为 ‘ 变量 ’
    package mysql;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.Statement;
    
    public class MYSQLTest2 {
        public static void main(String[] args) throws Exception{
            //1.获取驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://master:3306/show1", "root", "123456");
            
            //3.执行sql
            //3.1 sql语句
            //在sql的语句中尽量都用单引号,
            //如果使用双引号,因为sql整个被双引号包括,如果双引号里面有双引号,就会发生双引号的匹配错误问题
            String sql = "insert into stu values(10008,'tang',15,'0')";
    
            //如果sql语句中有变量,就需要用到双引号
            String name = "song";
            String sql1 = "insert into stu values(10009,'"+name+"',34,'1')";
            //'"+name+"'里面的第一个双引号与insert前的双引号匹配,第二个双引号与sql1语句最后面的双引号匹配
            //双引号旁边还各有一个单引号是因为,sql语句中字符串应该用单引号包起来
            //所以最后的sql语句的结果是insert into stu values(10009,'song',34,1)
            System.out.println(sql1);
    
            //3.2获取执行器
            Statement statement = conn.createStatement();
            //3.3 执行sql语句
            int i1 = statement.executeUpdate(sql);
            int i2 = statement.executeUpdate(sql1);
    
            //i1,i2里面是执行的结果,如果正确执行,结果为1
            System.out.println("i1 = "+i1+" --- "+" i2 = "+i2);
    
            //关闭
            statement.close();
            conn.close();
        }
    }
    
    

    在这里插入图片描述
    i1和i2都为1说明执行成功,到navicat中查看一下
    在这里插入图片描述
    stu表中多出来两条数据,添加成功

    删除语句(删)

    package mysql;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.Statement;
    
    public class MYSQLTest3 {
        public static void main(String[] args) throws Exception {
            //获取驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://master:3306/show1", "root", "123456");
            //执行sql
            String sql = "delete from stu where id=10009";
            Statement statement = conn.createStatement();
            int i = statement.executeUpdate(sql);
            System.out.println(i);
            //关闭
            statement.close();
            conn.close();
        }
    }
    
    

    在这里插入图片描述
    结果为1说明执行成功,查看一下表stu
    在这里插入图片描述
    最后一行被删去了

    修改语句(改)

    package mysql;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.Statement;
    
    public class MYSQLTest4 {
        public static void main(String[] args) throws Exception{
            //获取驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://master:3306/show1", "root", "123456");
            //执行sql
            String sql = "update stu set StudentName='ning' where id=10008";
            Statement statement = conn.createStatement();
            int i = statement.executeUpdate(sql);
            System.out.println(i);
            //关闭
            statement.close();
            conn.close();
        }
    }
    
    

    在这里插入图片描述
    在这里插入图片描述
    id为10008的这一行的StudentName被修改为ning

    SQL注入问题

    sql注入:参数中有mysql命令,而mysql把这些关键字当做命令去执行

    比如登录一个网站时,需要输入用户名和密码。用户输入的用户名和密码会和数据库中存储的用户名和密码进行匹配,如果匹配正确则可以登录,匹配错误则登录失败

    现在来模拟一下这个过程,先来建一下用户信息表

    create table userInfo(
    username varchar(255),
    password int
    )engine=innodb;
    
    insert into userInfo values('root','123456');
    
    select * from userInfo;
    

    在这里插入图片描述

    package mysql;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.Statement;
    
    //SQL注入问题
    public class LoginTest1 {
        public static void main(String[] args) throws Exception {
            //获取驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://master:3306/show1", "root", "123456");
            
            //执行sql语句
            //username和password假定为用户输入的用户名和密码
            String username = "root";
            String password = "123456";
            //利用sql语句查询表中是否有root,123456的这一行数据
            String sql = "select * from userInfo where username='"+username+"' and password='"+password+"'";
            Statement statement = conn.createStatement();
            ResultSet resultSet = statement.executeQuery(sql);
            //查看结果
            if(resultSet.next()){
                System.out.println("登录成功");
            }else{
                System.out.println("登录失败");
            }
    
            //关闭
            resultSet.close();
            statement.close();
            conn.close();
        }
    }
    
    

    此时结果为
    在这里插入图片描述
    然后修改一下用户名

    package mysql;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.Statement;
    
    //SQL注入问题
    public class LoginTest1 {
        public static void main(String[] args) throws Exception {
            Class.forName("com.mysql.jdbc.Driver");
            Connection conn = DriverManager.getConnection("jdbc:mysql://master:3306/show1", "root", "123456");
            
            //修改输入的用户名
            String username = "root' or '1'='1 ";
            String password = "123456";
            String sql = "select * from userInfo where username='"+username+"' and password='"+password+"'";
            System.out.println(sql);
            
            Statement statement = conn.createStatement();
            ResultSet resultSet = statement.executeQuery(sql);
            if(resultSet.next()){
                System.out.println("登录成功");
            }else{
                System.out.println("登录失败");
            }
            resultSet.close();
            statement.close();
            conn.close();
        }
    }
    
    

    在这里插入图片描述

    会发现即使用户名是错误的,依旧登录成功了。再来看看sql语句,发现无论username的值是什么都可以匹配到。原因就是用户名中包含关键字的话,传入sql语句中时,关键字没有被当作字符串处理,而是当sql的关键字处理。

    为了避免这种情况,就需要改变获取执行器的语句
    将conn.createStatement() 改为conn.prepareStatement(sql)

    package mysql;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    
    //解决SQL注入问题,将conn.createStatement()换成conn.prepareStatement()
    public class LoginTest2 {
        public static void main(String[] args) throws Exception{
            //获取驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://master:3306/show1", "root", "123456");
            //执行sql
            String username = "root";
            //conn.createStatement(sql)是将sql语句连带着参数一起传入执行器里面
            //conn.prepareStatement()是先将sql语句的模板传进去,然后在利用setString传入参数
            //传入的位置是 ? 所在的位置,为了确定传入哪个问号,问号有索引,从1开始
            String sql = "select * from userInfo where username=?";
            // 先将模板传入执行器ps
            PreparedStatement ps = conn.prepareStatement(sql);
            //然后将参数传入执行器ps
            ps.setString(1,username);
            //利用执行器执行sql语句
            ResultSet resultSet = ps.executeQuery();
            //查询结果
            if(resultSet.next()){
                System.out.println("成功");
            }else{
                System.out.println("失败");
            }
            //关闭
            resultSet.close();
            ps.clearParameters();
            conn.close();
        }
    }
    
    

    对比一下:

    //conn.createStatement() 会造成sql注入问题
    String username = "root' or '1'='1 ";
    String sql = "select * from userInfo where username='"+username+"'";
    Statement statement = conn.createStatement();
    ResultSet resultSet = statement.executeQuery(sql);
    
    //conn.prepareStatement(sql) 不会造成sql注入问题
    String username = "root";
    String sql = "select * from userInfo where username=?";
    PreparedStatement ps = conn.prepareStatement(sql);
    ps.setString(1,username);
    ResultSet resultSet = ps.executeQuery();
    

    这里就可以发现 createStatement() 是将sql语句整个的包含参数一起传入执行器
    而prepareStatement(sql) 是先将sql语句,参数以外的内容传入执行器,相当于先传入一个模板,参数的位置用 ? 来代替。然后再用 set语句将参数值传入 ?的位置,问号?也有索引,从1开始,用索引指定传入第几个问号中。

    完整的网站登录检查

    package mysql;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.util.Scanner;
    
    public class LoginTest3 {
        static Connection conn = null;
        static{
            try{
                Class.forName("com.mysql.jdbc.Driver");
                conn = DriverManager.getConnection("jdbc:mysql://master:3306/show1", "root", "123456");
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        public static void main(String[] args) throws Exception {
            Scanner sc = new Scanner(System.in);
            String username = sc.next();
            String password = sc.next();
            String login = Login(username,password);
            System.out.println(login);
        }
        //验证用户名是否正确
        public static String Login(String username,String password) throws Exception{
            String sql = "select * from userInfo where username=?";
            PreparedStatement ps = conn.prepareStatement(sql);
            ps.setString(1,username);
            ResultSet resultSet = ps.executeQuery();
            //如果结果集为空,说明用户名错误,数据库的数据中没有叫这个的用户
            if(!resultSet.next()){
                return "登录失败";
            }
            //经过了上面的判断后还能继续执行,说明结果集不为空,应该接着比较密码是否正确,此时结果集里面是一行数据
            //数据的用户名即为查询的用户名,还有密码password,这个密码是数据库里面的密码,是正确的密码
            // 此时应该判断数据库的密码与用户输入的密码,即方法参数列表传入的密码是否一致
            //先获取数据库的密码
            String SQLpassword = resultSet.getString("password");
            String message = LoginPassword(password,SQLpassword);
            return message;
    
        }
        //比较密码是否正确
        public static String LoginPassword(String password,String SQLpassword) throws Exception{
            if(!password.equals(SQLpassword)){
                return "用户输入密码与数据库密码不一致";
            }
            return "登录成功";
    
        }
    }
    
    

    在这里插入图片描述

    展开全文
  • public static final String URL="jdbc:mysql://localhost:3306/student"; public static final String USERNAME="root"; public static final String PWD="root"; } package com.bdqn.dao.impl...
  • 讲解了java如何连接操作数据库,需要mysql数据库连接的jar包,然后添加build path/*** Project Name: Java* Package Name: com.train.jdbc* File Name: jdbcTest.java* Created on: 2016年5月26日 下午8:48:32* ...
  • JDBC连接数据库及增删查改基本步骤,仅供Java新手参考
  • 一、实现删改: 比较简单: import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.Statement;   public class Demo2 { /* * 1.连接数据库 * 2...
  • 主要为大家详细介绍了使用c3p0连接数据库实现增删改查,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • MySQL是一种关联数据库管理系统,关联数据库将数据保存在不同的表中,...1、Java 连接 MySQL 需要驱动包,Mysql服务器目前最新版本为:mysql-5.6.22-winx64.zip2、JDBC驱动目前最新版本为:mysql-connector-java-3....
  • JavaWeb最全JDBC实现增删改查——重构(一) 代码结构 需要jar包都在下面,如果你的数据库版本是5的话就用mysql5的jar,如果是8.0的话就用对应版本jar 用8.0的同学: 关注微信关注公众号"一颗剽悍的种子"回复:...
  • java基础导航.使用javaWeb连接mysql数据库并且可以增删改查,对java新手有一点帮助。希望各位进步。
  • 使用JDBC连接MySQL数据库并且完成增删改查完整代码

    万次阅读 多人点赞 2017-06-28 10:10:40
    * 作用:传递用户输入的信息,调用后台业务逻辑层代码,实现增删改查 * */ public static void main(String[] args) { Scanner input = new Scanner(System.in); do { System.out.println("请选择...
  • JDBC连接MySQL数据库操作增删改查 环境:jdk1.8、MySQL5.5、IDEA2018.2 JDBC连接数据库 JDBC(Java数据库连接,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用...
  • 5.Servlet + JSP +JavaBean + JDBC(DBUtils)+ mysql 6.数据库 create database day19; use day19; create table t_customer( id varchar(40) primary key, username varchar(20), gender varchar(10), ...
  • 记得导连接数据的依赖包 jdbc依赖包下载地址 不多说,直接附上代码 package com.fang.jdbc; import java.sql.*; /** * @program: blog * @description: 连接数据库并进行简单的操作 * @author: Fang * @create: ...
  • 为了保证简单,甚至没有把每个servlet里的jdbc连接单独拿出来,直观。数据库也一并给出。使用本项目时,首先访问的登录页面,即:http://localhost:8080/demo1/login.jsp,用户名root,密码root,也可以用库里面的...
  • 实现类 UserDaoImpl.java(实现增删改查功能 使用预编译对象PreparedStatement 安全、便捷不需要我们去拼接字符串,特别是字段很多的时候 同时效率比Statement更高 ) 测试类 UserDaoTest.java(做测试增删改查功能...
  • 1.Android 连接MySQL数据库public class DBOpenHelper {private static String driver = "com.mysql.jdbc.Driver";//MySQL 驱动private static String url = "jdbc:mysql://IP:3306/数据库";//MYSQL数据库连接Url...
  • JDBC连接数据库执行流程: 1.加载驱动 2.获取连接:与数据库建立连接 3.sql预编译对象:预编译对象 4.执行sql语句 5.释放资源 /** * 1.加载mysql驱动:com.mysql.jdbc.Driver * 2.获取连接:与数据库建立连接 ...
  • servlet_mysql_jdbc_crud增删改查案例,其中使用到了c3p0连接池技术,内部包含完整的数据库脚本文件,项目具体信息在博客上面有完整的截图以及使用工具的介绍,博客地址:...
  • Java使用jdbc连接MySql数据库,实现增删改查

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,678
精华内容 15,471
关键字:

jdbc连接mysql增删改查

mysql 订阅