MTingCat
MTingCat

JDBC连接数据库详讲

1.JDBC概述

JDBC连接数据库详讲_第1张图片

1.1 JDBC

JDBC（Java DataBase Connectivity），简单来讲JDBC是利用Java语言或程序连接并且访问数据库的一门技术，是Java语言中用来规范客户端程序如何访问数据库的应用程序接口，提供了查询和更新数据库操作方法，通常是面向关系型数据库的。这种方法摒弃了原先通过CMD挥着Navicat等工具连接数据库的方式。

1.2 访问数据库步骤

1.注册驱动

  • 2.获取连接
  • 3.获取传输器
  • 4.通过传输器发送SQL到服务器质性并且返回执行结果
  • 5.数据处理
  • 6.释放资源
1.3 原理

每次需要访问数据时就和数据库建立连接，操作，返回结果，关闭。需要走完整的六个步骤。

2.通过JDBC访问数据库

2.1准备数据
--本机环境：win7,mysql(8.0.15)
set names utf8;
drop database if exists testjdbc_db;
create database testjdbc_db charset utf8;
use testjdbc_db;
create table account(
    id int primary key auto_increment,
    name varchar(50),
    money double
);
insert into account values(null, 'tom', 1000);
insert into account values(null, 'andy', 1000);
insert into account values(null, 'tony', 1000);
2.2 创建项目导入驱动包

注：导入MySQL驱动包，下载地址https://dev.mysql.com/downloads/mysql/
JDBC连接数据库详讲_第2张图片

JDBC连接数据库详讲_第3张图片

JDBC连接数据库详讲_第4张图片

2.3 代码实现
package com.MTngCat.Person.JDBC.Connection;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

/**
 * JDBC连接数据库的步骤：
 * @author MTing
 * 步骤：
 *         1.注册驱动
 *         2.获取连接
 *        3.获取传输器
 *        4.通过传输器发送SQL到服务器质性并且返回执行结果
 *        5.数据处理
 *        6.释放资源
 */
public class connectionBasic {
    
    public static void main(String[] args) throws Exception {
        
        //1.注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获取连接
        Connection conn = DriverManager.getConnection(
                "jdbc:mysql://localhost:3306/testjdbc_db?characterEncoding=UTF-8&serverTimezone=GMT%2B8&useServerPrepStms=true&cachePrepStms=true",
                "root",
                "MTingCat819"
                );
        //3.获取传输器
        Statement st = conn.createStatement();
        //4.通过传输器发送SQL到服务器执行并且返回执行结果
        String sql = "select * from account";
        ResultSet rs = st.executeQuery(sql);
        //5.数据处理
        while( rs.next() ) {
            int id = rs.getInt("id");
            String name = rs.getString("name");
            double money = rs.getDouble("money");
            System.out.println(id + ":" + name + ":" + money );
        }
        //6.释放资源
//        rs.close();
//        st.close();
//        conn.close();
        if( rs != null ) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                rs = null;
            }
        }
        if( st != null ) {
            try {
                st.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                st = null;
            }
        }
        if( conn != null ) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                conn = null;
            }
        }
    }
    
}
2.4 代码注意事项详注：
//1.注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");

①MySQL版本在8.0之前的驱动的全限定类名是"com.mysql.jdbc.Driver"
②MySQL版本在8.0之后的驱动的全限定类名是"com.mydql.cj.jdbc.Driver"

    //2.获取连接
    Connection conn = DriverManager.getConnection(
            "jdbc:mysql://localhost:3306/testjdbc_db?characterEncoding=UTF-8&serverTimezone=GMT%2B8&useServerPrepStms=true&cachePrepStms=true", 
            "root",
            "MTingCat819"
            );

①参数一：jdbc:mysql://localhost:3306/testjdbc_db
JDBC连接数据库详讲_第5张图片
用于指定访问的是哪一个数据库，如果连接本地数据库，可以简写为：jdbc:mysql:///testjdbc_db
②参数二：characterEncoding=UTF-8&serverTimezone=GMT%2B8"
这里指定的是编码格式和时区，MySQL驱动8.0之后的版本都需要自己配置时区。
③参数三：useServerPrepStms=true
保证MySQL驱动会把以连接器PreparedStatement类型传输来的SQL语句发送给数据库进行预编译为函数交给服务器存储key。
④参数四：cachePrepStms=true
保证在执行相同的语句时数据库不会进行二次编译，原因保证在第一次预编译为函数后的key值存在于服务器
⑤参数五：
⑥参数六：

  //3.获取传输器
  Statement st = conn.createStatement();

该方法用于向数据库服务器发送SQL语句的Statement传输对象。

//4.通过传输器发送SQL到服务器质性并且返回执行结果
        String sql = "select * from account";
        ResultSet rs = st.executeQuery(sql);
        //用于向数据库发送查询类型的sql语句，返回一个ResultSet对象结果集
        //int rows = st.executeUpdate(sql)
        //用于向数据库发送更新(增加、删除、修改)类型的sql语句，返回一个int值，表示影响的记录行数

①ResultSet结果集对象：用于封装SQL语句查询的结果，该对象提供了遍历数据以及获取数据的方法。

//5.数据处理
        while( rs.next() ) {
            int id = rs.getInt("id");
            String name = rs.getString("name");
            double money = rs.getDouble("money");
            System.out.println(id + ":" + name + ":" + money );
        }

①遍历数据行的方法：next()使指向数据行的箭头向下移动一行，并且返回一个布尔类型的结果，后面有数据组则返回true，发欧泽false
②获取数据的方法

getInt(int columnIndex)
getInt(String columnLable)
getString(int columnIndex)
getString(String columnLable)
getDouble(int columnIndex)
getDouble(String columnLable)
getObject(int columnIndex)
getObject(String columnLable)
//6.释放资源
        rs.close();
        st.close();
        conn.close();

①释放资源：越晚获取的资源越先关闭
②为避免程序抛出异常释放资源的代码不会执行，应该把代码放在finally块中

if( rs != null ) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                rs = null;
            }
        }
        if( st != null ) {
            try {
                st.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                st = null;
            }
        }
        if( conn != null ) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                conn = null;
            }
        }
2.5 执行结果

JDBC连接数据库详讲_第6张图片

3.通过JDBC实现对数据库的操作

3.1 简化代码：数据库注册工具类

由于每次访问数据库都要走完整的六个步骤，也就是说每次对数据库操作都要写一系列的代码，所以我们编写数据库注册工具类进行简化代码。

package com.MTngCat.Person.JDBC.JDBCUtil;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

/**
 * 创建jdbc工具类简化代码
 * @author MTing
 *    本质：
 *        注册驱动 + 获取连接
 */
public class JdbcUtil {
    public static Connection getConnection() {
        try {
            //注册驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            //获取数据库连接
            Connection conn = DriverManager.getConnection(
                    "jdbc:mysql:///testjdbc_db?characterEncoding=utf-8&serverTimezone=GMT%2B8&useServerPrepStms=true&cachePrepStms=true",
                    "root",
                    "MTingCat819"
                    );
            return conn;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static Connection getConnection(String dbName,String user, String password) {
        try {
            //注册驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            //获取数据库连接
            Connection conn = DriverManager.getConnection(
                    "jdbc:mysql:///"+ dbName + "characterEncoding=utf-8&serverTimezone=GMT%2B8&useServerPrepStms=true&cachePrepStms=true",
                    user,
                    password
                    );
            return conn;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static void close(Connection conn, Statement stat, ResultSet rs) {
        if( conn != null ) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                conn = null;
            }
            if( stat != null ) {
                try {
                    stat.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    stat = null;
                }
            }
            if( rs != null ) {
                try {
                    rs.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    rs = null;
                }
            }
        }
        
    }
}
3.2 测试代码
package com.MTngCat.Person.JDBC.Connection;

import java.sql.Connection;
import java.sql.ResultSet;

import java.sql.Statement;

import org.junit.Test;

import com.MTngCat.Person.JDBC.JDBCUtil.JdbcUtil;

/**
 * 通过JDBC工具类连接数据库
 * @author MTing
 *
 */
public class testJdbcUtil {
    
    //1.查询所有数据
    @Test
    public void testSelect() {
        Connection conn = null;
        Statement stat = null;
        ResultSet rs = null;
        try {
            //1.注册驱动，2.获取连接
            conn = JdbcUtil.getConnection();
            //3.获取连接
            stat = conn.createStatement();
            //4.通过传输器发送SQL语句到服务器执行并返回结果
            String sql = "select * from account";
            rs = stat.executeQuery(sql);
            //5.处理结果
            while( rs.next() ) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                double money = rs.getDouble("money");
                System.out.println(id + ":" + name + ":" + money );
            }
            //6.关闭连接，释放资源
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtil.close(conn,stat,rs);
        }
    }
    //2.插入数据：Anny 4000
    @Test
    public void testInsert() {
        Connection conn = null;
        Statement stat = null;
        ResultSet rs = null;
        try {
            //1.注册驱动，2.获取连接
            conn = JdbcUtil.getConnection();
            //3.获取连接
            stat = conn.createStatement();
            //4.通过传输器发送SQL语句到服务器执行并返回结果
            String sql = "insert into account values(null,'Anny',4000)";
            int rows = stat.executeUpdate(sql);
            //5.处理结果
            System.out.println("影响的行数是：" + rows);
            //6.关闭连接，释放资源
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtil.close(conn,stat,rs);
        }
    }
     
    //3.修改数据：Anny 4000->4800
    @Test
    public void testUpdate() {
        Connection conn = null;
        Statement stat = null;
        ResultSet rs = null;
        try {
            //1.注册驱动，2.获取连接
            conn = JdbcUtil.getConnection();
            //3.获取连接
            stat = conn.createStatement();
            //4.通过传输器发送SQL语句到服务器执行并返回结果
            String sql = "update account set money = 4800 where name = 'Anny'";
            int rows = stat.executeUpdate(sql);
            //5.处理结果
            System.out.println("影响的行数是：" + rows);
            //6.关闭连接，释放资源
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtil.close(conn,stat,rs);
        }
    }
    
    //4.删除数据：Anny
    @Test
    public void testDelete() {
        Connection conn = null;
        Statement stat = null;
        ResultSet rs = null;
        try {
            //1.注册驱动，2.获取连接
            conn = JdbcUtil.getConnection();
            //3.获取连接
            stat = conn.createStatement();
            //4.通过传输器发送SQL语句到服务器执行并返回结果
            String sql = "delete from account where name = 'Anny'";
            int rows = stat.executeUpdate(sql);
            //5.处理结果
            System.out.println("影响的行数是：" + rows);
            //6.关闭连接，释放资源
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtil.close(conn,stat,rs);
        }
    }
    
}

①单元测试：不用创建新的类，也不用提供main方法，也不用创建实例，就可以直接执行的方法，添加@Test注解就可以通过单元测试（Junit）框架测试该方法，框架会创建该方法的实例，通过实例调用该方法。，满足单元测试方法的几个条件：
a.方法必须是公共的
b.方法必须是非静态的
c.方法必须是无返回值的
d.方法必须是无参数的
e.方法可以抛出异常
f.进行单元测试的方法或者类，命名时不要命名为 Test/test

5.Statement和PreparedStatement区别

5.1 概述

简单PreparedStatement是Statement子类接口，比Statement更加安全，并且能够提高执行效率。

5.2 原理

底层中Statement在执行语句时，是直接将语句发送给数据库进行编译，正确则执行，错误抛出异常，即每一次的对数据库的操作都被认为是新的操作，而且传递的参数也是以拼接的方式，效率低下，线程不安全。
PreparedStatement在执行SQL语句时，先将SQL语句交个数据库进行预编译，错误抛出异常，正确生成骨架即函数，用户只需要传递参数即可，提高了执行效率，线程安全。

6.SQL注入攻击（深度理解Statement和PreparedStatement）

6.1 准备数据
use testjdbc_db;
create table user(
    id int primary key auto_increment,
    username varchar(50),
    password varchar(50)
);
insert into user values(null,'MTing','123');
insert into user values(null,'Cat','234');

JDBC连接数据库详讲_第7张图片

6.2 创建登录类，提供登录方法
package com.MTngCat.Person.JDBC.PS;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Scanner;

import com.MTngCat.Person.JDBC.JDBCUtil.JdbcUtil;

public class loginUser {
    public static void main(String[] args) {
        
        @SuppressWarnings("resource")
        Scanner sc = new Scanner( System.in );
        System.out.println("欢迎登录！");
        System.out.println("请输入用户名称：");
        String user = sc.nextLine();
        System.out.println("请输入密码：");
        String password = sc.nextLine();
        login( user, password );
    }
    private static void login( String user, String password ) {
        Connection conn = null;
        Statement stat = null;
        ResultSet rs = null;
        try {
            //1.注册驱动，2.获取连接
            conn = JdbcUtil.getConnection();
            //3.获取连接
            stat = conn.createStatement();
            //4.通过传输器发送SQL语句到服务器执行并返回结果
            String sql = "select * from user where username='"+ user + "'and password = '"+ password +"'";
            rs = stat.executeQuery(sql);
            //5.处理结果
            System.out.println( sql );
            if( rs.next() ) { //有数据 -- 用户名密码都正确
                System.out.println("登录成功!");
            }else { //没数据 -- 用户名或密码不正确
                System.out.println("登录失败, 用户名或密码不正确!");
            }
            //6.关闭连接，释放资源
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtil.close(conn,stat,rs);
        }
    }

}

JDBC连接数据库详讲_第8张图片

6.3 测试登录方法
6.3.1 异常

JDBC连接数据库详讲_第9张图片

6.3.2 异常

JDBC连接数据库详讲_第10张图片

6.3.3 异常

JDBC连接数据库详讲_第11张图片

6.3.4 正常

JDBC连接数据库详讲_第12张图片

6.3.4 SQL注入攻击

从以上的异常中不难看出，在不按照正常的输入的情况下依旧能登录成功，这就是SQL注入攻击，原因：执行查询的SQL语句是拼接而来的

String sql = "select * from user where username='"+ user + "'and password = '"+ password +"'"

其中的参数是用户端提交过来的，按照这种方式，用户在提交数据时如果掺杂特殊符号等，会导致SQL语句的语义发生变化，从而执行一些意外的操作

7.如何防止SQL注入攻击

7.1 正则表达式

通过正则表达式的方式对用户提交的数据进行验证，如果用户提交注入特殊符号等的不合法数据，提示用户重新输入。

7.2 使用PreparedStatement对象替换Statement

本质：增加SQL预编译生成骨架，保证语义的准确性不会发生改变。

7.2.1代码
package com.MTngCat.Person.JDBC.PS;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Scanner;

import com.MTngCat.Person.JDBC.JDBCUtil.JdbcUtil;

public class loginUser2 {
    public static void main(String[] args) {
        
        @SuppressWarnings("resource")
        Scanner sc = new Scanner( System.in );
        System.out.println("欢迎登录！");
        System.out.println("请输入用户名称：");
        String user = sc.nextLine();
        System.out.println("请输入密码：");
        String password = sc.nextLine();
        login( user, password );
    }
    private static void login( String user, String password ) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            //1.注册驱动，2.获取连接
            conn = JdbcUtil.getConnection();
            //3.获取传输器，通过传输器发送SQL语句到服务器执行并返回结果
            String sql = "select * from user where username = ? and password = ?";
            ps = conn.prepareStatement(sql);
            //4.设置SQL语句中的参数
            ps.setString(1, user);
            ps.setString(2, password);
            //5.执行SQL语句
            rs = ps.executeQuery();
            //5.处理结果
            System.out.println( sql );
            if( rs.next() ) { //有数据 -- 用户名密码都正确
                System.out.println("登录成功!");
            }else { //没数据 -- 用户名或密码不正确
                System.out.println("登录失败, 用户名或密码不正确!");
            }
            //6.关闭连接，释放资源
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtil.close(conn,ps,rs);
        }
    }

}

JDBC连接数据库详讲_第13张图片

7.2.2 测试登录方法
7.2.2.1 无异常
7.2.2.2 正常

JDBC连接数据库详讲_第14张图片

JDBC连接数据库详讲_第15张图片

JDBC连接数据库详讲_第16张图片

7.连接池的应用

1. 概念引入

在上面所讲连接中，每次访问数据库都会创建一个连接，初始化连接，关闭连接，会走访问数据库的所有操作，由于每次创建初始化连接和关闭连接会花费大量的时间，会导致整个程序效率低下，因此为解决在访问数据库时要不断的初始化连接和关闭连接带来的时间消耗问题，我们采取了连接池的方式

2.何为连接池

池即容器，连接池顾名思义是能够存储有很多连接的容器，在程序启动时我们第一次访问数据库，就会在连接池中创建一个连接，首次创建的连接进行初始化也会花费很多的时间，但是当用完这个连接执行*.close()方法的时候，不再是关闭连接，而是把连接送回到连接池中，下次需要访问数据库的时候，直接从连接池中取出第一次用完放回的连接对象，不需要再次初始化，用完放回连接池，即也不需要关闭连接，解决的访问数据库时初始化连接和关闭连接耗时长的问题---预见问题出现的点，并且避开问题寻求捷径的思想是连接池的主要思想

JDBC连接数据库详讲_第17张图片

3.代码实现
3.1 导包 build path

JDBC连接数据库详讲_第18张图片

3.2代码实现
3.2.1 通过静态代码块获取连接
//2.创建一个连接池对象
    static ComboPooledDataSource pool = new ComboPooledDataSource();
    //3.设置连接池的基本信息（方式一）
    static {
        try {
            pool.setDriverClass("com.mysql.cj.jdbc.Driver");
            pool.setJdbcUrl("jdbc:mysql:///testjdbc_db?characterEncoding=utf-8&serverTimezone=GMT%2B8&useServerPrepStms=true&cachePrepStms=true");
            pool.setUser("root");
            pool.setPassword("MTingCat819");
        }catch (Exception e) {
            e.printStackTrace();
        }    
    }
package com.MTngCat.Person.JDBC.C3P0;

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

import org.junit.Test;

import com.mchange.v2.c3p0.ComboPooledDataSource;

/**
 * 测试C3P0连接池的使用
 *    1.导入C3P0jar包
 *    2.在程序中创建一个连接池（容器：里面会放一批连接）
 *     3.设置连接数据的基本信息（驱动类的全路径，连接库的URL地址，连接库的用户名和密码）
 *        3.1直接将连接数据库的参数写死在程序中，使得代码不灵活
 *        3.2将连接数据库的基本信息配置在c3p0.properties文件，文件放在类目录下，即src根目录下    
 *        3.3将连接数据库的基本信息配置在池c3p0-config.xml中，文件放在类目录下。
 *        3.2和3.3中的文件名和文件的配置信息都是固定的
 *4.从链接池中获取一个连接使用
 * @author MTing
 *
 */
public class testC3P0 {

    //2.创建一个连接池对象
    static ComboPooledDataSource pool = new ComboPooledDataSource();
    //3.设置连接池的基本信息（方式一）
    static {
        try {
            pool.setDriverClass("com.mysql.cj.jdbc.Driver");
            pool.setJdbcUrl("jdbc:mysql:///testjdbc_db?characterEncoding=utf-8&serverTimezone=GMT%2B8&useServerPrepStms=true&cachePrepStms=true");
            pool.setUser("root");
            pool.setPassword("MTingCat819");
        }catch (Exception e) {
            e.printStackTrace();
        }    
    }
    //查询表中所有的信息
    @Test
    public void testFindAll() throws SQLException {
        
        //4.初始化一个连接对象
        Connection conn = pool.getConnection();
        //5.编写SQL，获取连接器
        String sql = "select * from user";
        PreparedStatement ps = conn.prepareStatement(sql);
        //6.执行操作返回查询对象
        ResultSet rs = ps.executeQuery();
        //7.处理结果
        while( rs.next() ) {
            int id = rs.getInt("id");
            String username = rs.getString("username");
            String password = rs.getString("password");
            System.out.println(id + " " + username + " " + password);
            System.out.println(pool.getClass().getName());
        }
        //8.关闭连接
        if( rs != null) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                rs = null;
            }
        }
        if( ps != null) {
            try {
                ps.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                ps = null;
            }
        }
        if( conn != null) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                conn = null;
            }
        }
    }
    @Test
    public void testFindAll02() throws SQLException {
        
        //4.初始化一个连接对象
        Connection conn = pool.getConnection();
        //5.编写SQL，获取连接器
        String sql = "select * from user";
        PreparedStatement ps = conn.prepareStatement(sql);
        //6.执行操作返回查询对象
        ResultSet rs = ps.executeQuery();
        //7.处理结果
        while( rs.next() ) {
            int id = rs.getInt("id");
            String username = rs.getString("username");
            String password = rs.getString("password");
            System.out.println(id + " " + username + " " + password);
            System.out.println(pool.getClass().getName());
        }
        //8.关闭连接
        if( rs != null) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                rs = null;
            }
        }
        if( ps != null) {
            try {
                ps.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                ps = null;
            }
        }
        if( conn != null) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                conn = null;
            }
        }
    }
    //查询MTing
    @Test
    public void testOne() throws SQLException {
        
        //4.初始化一个连接对象
        Connection conn = pool.getConnection();
        //5.编写SQL，获取连接器
        String sql = "select * from user where username = ?";
        PreparedStatement ps = conn.prepareStatement(sql);
        //6.执行操作返回查询对象
        ps.setString(1, "MTing");
        ResultSet rs = ps.executeQuery();
        //7.处理结果
        while( rs.next() ) {
            int id = rs.getInt("id");
            String username = rs.getString("username");
            String password = rs.getString("password");
            System.out.println(id + " " + username + " " + password);
            System.out.println(pool.getClass().getName());
        }
        //8.关闭连接
        if( rs != null) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                rs = null;
            }
        }
        if( ps != null) {
            try {
                ps.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                ps = null;
            }
        }
        if( conn != null) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                conn = null;
            }
        }
    }
}
3.2.2 通过配置文件获取连接（c3p0.properties）
# key=value
c3p0.driverClass=com.mysql.cj.jdbc.Driver
c3p0.jdbcUrl=jdbc:mysql:///testjdbc_db?characterEncoding=UTF-8&serverTimezone=GMT%2B8&useServerPrepStms=true&cachePrepStms=true
c3p0.user=root
c3p0.password=MTingCat819
3.2.3 通过配置文件获取连接（c3p0-config.xml）


    
        
            com.mysql.cj.jdbc.Driver
        
        
            jdbc:mysql:///testjdbc_db?characterEncoding=UTF-8&serverTimezone=GMT%2B8&useServerPrepStms=true&cachePrepStms=true
        
        
            root
        
        
            MTingCat819
        
    

package com.MTngCat.Person.JDBC.C3P0;

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

import org.junit.Test;

import com.mchange.v2.c3p0.ComboPooledDataSource;

/**
 * 测试C3P0连接池的使用
 *    1.导入C3P0jar包
 *    2.在程序中创建一个连接池（容器：里面会放一批连接）
 *     3.设置连接数据的基本信息（驱动类的全路径，连接库的URL地址，连接库的用户名和密码）
 *        3.1直接将连接数据库的参数写死在程序中，使得代码不灵活
 *        3.2将连接数据库的基本信息配置在c3p0.properties文件，文件放在类目录下，即src根目录下    
 *        3.3将连接数据库的基本信息配置在池c3p0-config.xml中，文件放在类目录下。
 *        3.2和3.3中的文件名和文件的配置信息都是固定的
 *4.从链接池中获取一个连接使用
 * @author MTing
 *
 */
public class testC3P001 {

    //2.创建一个连接池对象
    ComboPooledDataSource pool = new ComboPooledDataSource();
    //3.设置连接池的基本信息（方式一）
//    static {
//        try {
//            pool.setDriverClass("com.mysql.cj.jdbc.Driver");
//            pool.setJdbcUrl("jdbc:mysql:///testjdbc_db?characterEncoding=utf-8&serverTimezone=GMT%2B8&useServerPrepStms=true&cachePrepStms=true");
//            pool.setUser("root");
//            pool.setPassword("MTingCat819");
//        }catch (Exception e) {
//            e.printStackTrace();
//        }    
//    }
    //查询表中所有的信息
    @Test
    public void testFindAll() throws SQLException {
        
        //4.初始化一个连接对象
        Connection conn = pool.getConnection();
        //5.编写SQL，获取连接器
        String sql = "select * from user";
        PreparedStatement ps = conn.prepareStatement(sql);
        //6.执行操作返回查询对象
        ResultSet rs = ps.executeQuery();
        //7.处理结果
        while( rs.next() ) {
            int id = rs.getInt("id");
            String username = rs.getString("username");
            String password = rs.getString("password");
            System.out.println(id + " " + username + " " + password);
            System.out.println(pool.getClass().getName());
        }
        //8.关闭连接
        if( rs != null) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                rs = null;
            }
        }
        if( ps != null) {
            try {
                ps.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                ps = null;
            }
        }
        if( conn != null) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                conn = null;
            }
        }
    }
    @Test
    public void testFindAll02() throws SQLException {
        
        //4.初始化一个连接对象
        Connection conn = pool.getConnection();
        //5.编写SQL，获取连接器
        String sql = "select * from user";
        PreparedStatement ps = conn.prepareStatement(sql);
        //6.执行操作返回查询对象
        ResultSet rs = ps.executeQuery();
        //7.处理结果
        while( rs.next() ) {
            int id = rs.getInt("id");
            String username = rs.getString("username");
            String password = rs.getString("password");
            System.out.println(id + " " + username + " " + password);
            System.out.println(pool.getClass().getName());
        }
        //8.关闭连接
        if( rs != null) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                rs = null;
            }
        }
        if( ps != null) {
            try {
                ps.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                ps = null;
            }
        }
        if( conn != null) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                conn = null;
            }
        }
    }
    //查询MTing
    @Test
    public void testOne() throws SQLException {
        
        //4.初始化一个连接对象
        Connection conn = pool.getConnection();
        //5.编写SQL，获取连接器
        String sql = "select * from user where username = ?";
        PreparedStatement ps = conn.prepareStatement(sql);
        //6.执行操作返回查询对象
        ps.setString(1, "MTing");
        ResultSet rs = ps.executeQuery();
        //7.处理结果
        while( rs.next() ) {
            int id = rs.getInt("id");
            String username = rs.getString("username");
            String password = rs.getString("password");
            System.out.println(id + " " + username + " " + password);
            System.out.println(pool.getClass().getName());
        }
        //8.关闭连接
        if( rs != null) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                rs = null;
            }
        }
        if( ps != null) {
            try {
                ps.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                ps = null;
            }
        }
        if( conn != null) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                conn = null;
            }
        }
    }
}

你可能感兴趣的:(java,mysql,jdbc,c3p0)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • mysql禁用远程登录 igotyback mysql
    去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • MYSQL面试系列-04 king01299 面试mysql面试
    MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解 秋刀prince mysqlmysql数据库
    提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • MongoDB知识概括 GeorgeLin98 持久层mongodb
    MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • 入门MySQL——查询语法练习 K_un
    前言：前面几篇文章为大家介绍了DML以及DDL语句的使用方法，本篇文章将主要讲述常用的查询语法。其实MySQL官网给出了多个示例数据库供大家实用查询，下面我们以最常用的员工示例数据库为准，详细介绍各自常用的查询语法。1.员工示例数据库导入官方文档员工示例数据库介绍及下载链接：https://dev.mysql.com/doc/employee/en/employees-installation.h
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • SQL的各种连接查询 xieke90 UNION ALLUNION外连接内连接JOIN
    一、内连接   概念：内连接就是使用比较运算符根据每个表共有的列的值匹配两个表中的行。                 内连接（join 或者inner join ）       SQL语法：       select * fron
  • java编程思想--复用类 百合不是茶 java继承代理组合final类
          复用类看着标题都不知道是什么,再加上java编程思想翻译的比价难懂,所以知道现在才看这本软件界的奇书   一:组合语法:就是将对象的引用放到新类中即可     代码:     package com.wj.reuse; /** * * @author Administrator 组
  • [开源与生态系统]国产CPU的生态系统 comsci cpu
          计算机要从娃娃抓起...而孩子最喜欢玩游戏....       要让国产CPU在国内市场形成自己的生态系统和产业链,国家和企业就不能够忘记游戏这个非常关键的环节....       投入一些资金和资源,人力和政策,让游
  • JVM内存区域划分Eden Space、Survivor Space、Tenured Gen，Perm Gen解释 商人shang jvm内存
    jvm区域总体分两类，heap区和非heap区。heap区又分：Eden Space（伊甸园）、Survivor Space(幸存者区)、Tenured Gen（老年代-养老区）。 非heap区又分：Code Cache(代码缓存区)、Perm Gen（永久代）、Jvm Stack(java虚拟机栈)、Local Method Statck(本地方法栈)。 HotSpot虚拟机GC算法采用分代收
  • 页面上调用 QQ oloz qq
    <A href="tencent://message/?uin=707321921&amp;Site=有事Q我&amp;Menu=yes">   <img style="border:0px;" src=http://wpa.qq.com/pa?p=1:707321921:1></a>
  • 一些问题 文强chu 问题
    1.eclipse 导出 doc  出现“The Javadoc command does not exist.” javadoc command 选择 jdk/bin/javadoc.exe 2.tomcate 配置 web 项目 ..... SQL:3.mysql  * 必须得放前面 否则  select&nbs
  • 生活没有安全感 小桔子 生活孤独安全感
           圈子好小，身边朋友没几个，交心的更是少之又少。在深圳，除了男朋友，没几个亲密的人。不知不觉男朋友成了唯一的依靠，毫不夸张的说，业余生活的全部。现在感情好，也很幸福的。但是说不准难免人心会变嘛，不发生什么大家都乐融融，发生什么很难处理。我想说如果不幸被分手(无论原因如何)，生活难免变化很大，在深圳，我没交心的朋友。明
  • php 基础语法 aichenglong php 基本语法
    1 .1 php变量必须以$开头 <?php $a=” b”; echo ?> 1 .2 php基本数据库类型 Integer  float/double Boolean string 1 .3 复合数据类型 数组array和对象 object 1 .4 特殊数据类型  null 资源类型(resource)    $co
  • mybatis tools 配置详解 AILIKES mybatis
    MyBatis Generator中文文档 MyBatis Generator中文文档地址： http://generator.sturgeon.mopaas.com/ 该中文文档由于尽可能和原文内容一致，所以有些地方如果不熟悉，看中文版的文档的也会有一定的障碍，所以本章根据该中文文档以及实际应用，使用通俗的语言来讲解详细的配置。 本文使用Markdown进行编辑，但是博客显示效
  • 继承与多态的探讨 百合不是茶 JAVA面向对象 继承 对象
    继承 extends   多态 继承是面向对象最经常使用的特征之一：继承语法是通过继承发、基类的域和方法 //继承就是从现有的类中生成一个新的类，这个新类拥有现有类的所有extends是使用继承的关键字：     在A类中定义属性和方法； class A{ //定义属性 int age； //定义方法 public void go
  • JS的undefined与null的实例 bijian1013 JavaScriptJavaScript
    <form name="theform" id="theform"> </form> <script language="javascript"> var a alert(typeof(b)); //这里提示undefined if(theform.datas
  • TDD实践（一） bijian1013 java敏捷TDD
    一.TDD概述         TDD：测试驱动开发，它的基本思想就是在开发功能代码之前，先编写测试代码。也就是说在明确要开发某个功能后，首先思考如何对这个功能进行测试，并完成测试代码的编写，然后编写相关的代码满足这些测试用例。然后循环进行添加其他功能，直到完全部功能的开发。     
  • [Maven学习笔记十]Maven Profile与资源文件过滤器 bit1129 maven
    什么是Maven Profile Maven Profile的含义是针对编译打包环境和编译打包目的配置定制，可以在不同的环境上选择相应的配置，例如DB信息，可以根据是为开发环境编译打包，还是为生产环境编译打包，动态的选择正确的DB配置信息   Profile的激活机制 1.Profile可以手工激活，比如在Intellij Idea的Maven Project视图中可以选择一个P
  • 【Hive八】Hive用户自定义生成表函数(UDTF) bit1129 hive
    1. 什么是UDTF   UDTF，是User Defined Table-Generating Functions，一眼看上去，貌似是用户自定义生成表函数，这个生成表不应该理解为生成了一个HQL Table， 貌似更应该理解为生成了类似关系表的二维行数据集   2. 如何实现UDTF 继承org.apache.hadoop.hive.ql.udf.generic
  • tfs restful api 加auth 2.0认计 ronin47
    　　目前思考如何给tfs的ngx-tfs api增加安全性。有如下两点： 　　一是基于客户端的ip设置。这个比较容易实现。 　　二是基于OAuth2.0认证，这个需要lua，实现起来相对于一来说，有些难度。 　　现在重点介绍第二种方法实现思路。 　　 前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGe
  • jdk环境变量配置 byalias javajdk
    进行java开发，首先要安装jdk，安装了jdk后还要进行环境变量配置： 1、下载jdk（http://java.sun.com/javase/downloads/index.jsp），我下载的版本是：jdk-7u79-windows-x64.exe 2、安装jdk-7u79-windows-x64.exe 3、配置环境变量：右击"计算机"-->&quo
  • 《代码大全》表驱动法-Table Driven Approach-2 bylijinnan java
    package com.ljn.base; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Collections; import java.uti
  • SQL 数值四舍五入 小数点后保留2位 chicony 四舍五入
    1.round() 函数是四舍五入用，第一个参数是我们要被操作的数据，第二个参数是设置我们四舍五入之后小数点后显示几位。 2.numeric 函数的2个参数，第一个表示数据长度，第二个参数表示小数点后位数。 例如： 　　select   cast(round(12.5,2)   as   numeric(5,2))  
  • c++运算符重载 CrazyMizzz C++
    一、加+，减-，乘*，除/ 的运算符重载 Rational operator*(const Rational &x) const{ return Rational(x.a * this->a); } 在这里只写乘法的，加减除的写法类似 二、<<输出,>>输入的运算符重载      &nb
  • hive DDL语法汇总 daizj hive修改列DDL修改表
    hive DDL语法汇总 １、对表重命名 hive> ALTER TABLE table_name RENAME TO new_table_name;   2、修改表备注 hive> ALTER TABLE table_name SET TBLPROPERTIES ('comment' = new_comm
  • jbox使用说明 dcj3sjt126com Web
    参考网址：http://www.kudystudio.com/jbox/jbox-demo.html jBox v2.3 beta [ 点击下载]  技术交流QQGroup：172543951 100521167 [2011-11-11] jBox v2.3 正式版 - [调整&修复] IE6下有iframe或页面有active、applet控件
  • UISegmentedControl 开发笔记 dcj3sjt126com
      //    typedef NS_ENUM(NSInteger, UISegmentedControlStyle) {     //        UISegmentedControlStylePlain,     // large plain   &
  • Slick生成表映射文件 ekian scala
    Scala添加SLICK进行数据库操作，需在sbt文件上添加slick-codegen包 "com.typesafe.slick" %% "slick-codegen" % slickVersion 因为我是连接SQL Server数据库，还需添加slick-extensions，jtds包 "com.typesa
  • ES-TEST gengzg test
    package com.MarkNum; import java.io.IOException; import java.util.Date; import java.util.HashMap; import java.util.Map; import javax.servlet.ServletException; import javax.servlet.annotation
  • 为何外键不再推荐使用 hugh.wang mysqlDB
    表的关联，是一种逻辑关系，并不需要进行物理上的“硬关联”，而且你所期望的关联，其实只是其数据上存在一定的联系而已，而这种联系实际上是在设计之初就定义好的固有逻辑。 在业务代码中实现的时候，只要按照设计之初的这种固有关联逻辑来处理数据即可，并不需要在数据库层面进行“硬关联”，因为在数据库层面通过使用外键的方式进行“硬关联”，会带来很多额外的资源消耗来进行一致性和完整性校验，即使很多时候我们并不
  • 领域驱动设计 julyflame VODAO设计模式DTOpo
    概念： VO（View Object）：视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。 DTO（Data Transfer Object）：数据传输对象，这个概念来源于J2EE的设计模式，原来的目的是为了EJB的分布式应用提供粗粒度的数据实体，以减少分布式调用的次数，从而提高分布式调用的性能和降低网络负载，但在这里，我泛指用于展示层与服务层之间的数据传输对
  • 单例设计模式 hm4123660 javaSingleton单例设计模式懒汉式饿汉式
           单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。      &nb
  • logback zhb8015 loglogback
    一、logback的介绍      Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块：logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个 改良版本。此外logback-class
  • 整合Kafka到Spark Streaming——代码示例和挑战 Stark_Summer sparkstormzookeeperPARALLELISMprocessing
    作者Michael G. Noll是瑞士的一位工程师和研究员，效力于Verisign，是Verisign实验室的大规模数据分析基础设施（基础Hadoop）的技术主管。本文，Michael详细的演示了如何将Kafka整合到Spark Streaming中。 期间， Michael还提到了将Kafka整合到 Spark Streaming中的一些现状，非常值得阅读，虽然有一些信息在Spark 1.2版
  • spring-master-slave-commondao 王新春 DAOspringdataSourceslavemaster
    互联网的web项目，都有个特点：请求的并发量高，其中请求最耗时的db操作，又是系统优化的重中之重。 为此，往往搭建 db的 一主多从库的 数据库架构。作为web的DAO层，要保证针对主库进行写操作，对多个从库进行读操作。当然在一些请求中，为了避免主从复制的延迟导致的数据不一致性，部分的读操作也要到主库上。（这种需求一般通过业务垂直分开，比如下单业务的代码所部署的机器，读去应该也要从主库读取数
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他