转自：该地址
 最近有同事问我怎么获取数据库中某数据表的某一列字段名称及数据类型，这种问题我还是第一次听别人问起，不过既然有，就应该得到解决。
 当你使用和学习JDK的时候，可以查看并学习它所提供给你的两个ResultSetMetaData
 和DataBaseMetaData类的源码并很好的了解它们的实现原理和思路，JDBC中提供有两种源数据,一种是数据库源数据,另一种是ResultSet源数据。这些源数据就是描述存储用户数据的容器的数据结构。其中ResultSetMetaData类完成了查询结果信息和结果中的列的各种信息。下面我就以ResultSetMetaData为例，简单的罗列它的使用方法以及它内部的方法的使用。
 首先，建立一张表并起名为users,表结构描述如下：
 字段描述 字段名称 是否为空 是否主键
 用户编号 id Not Null P
 用户名称 userName Not Null
 用户密码 password Not Null
 你也可以通过DLL执行下面脚本：(本人使用Mysql)
 CREATE TABLE users (
 id varchar(32) NOT NULL,
 userName varchar(20) NOT NULL,
 password varchar(20) NOT NULL,
 PRIMARY KEY (id),
 UNIQUE KEY id (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=gbk;
 然后向该表中插入几条数据。
 最后，新建一个测试类名为TestDemo.java,源代码如下：
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.PreparedStatement;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;

public class TestDemo {
	public static Connection getConnection() {
		Connection conn = null;
		try {
			Class.forName("com.mysql.jdbc.Driver");
			String url = "jdbc:mysql://localhost:3306/struts2Demo";
			String user = "root";
			String pass = "123456";
			conn = DriverManager.getConnection(url, user, pass);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return conn;
	}

	public static void main(String[] args) {
		Connection conn = getConnection();
		String sql = "select * from users";
		PreparedStatement stmt;
		try {
			stmt = conn.prepareStatement(sql);
			ResultSet rs = stmt.executeQuery(sql);
			ResultSetMetaData data = rs.getMetaData();
			while (rs.next()) {
				for (int i = 1; i <= data.getColumnCount(); i++) {
					// 获得所有列的数目及实际列数
					int columnCount = data.getColumnCount();
					// 获得指定列的列名
					String columnName = data.getColumnName(i);
					// 获得指定列的列值
					String columnValue = rs.getString(i);
					// 获得指定列的数据类型
					int columnType = data.getColumnType(i);
					// 获得指定列的数据类型名
					String columnTypeName = data.getColumnTypeName(i);
					// 所在的Catalog名字
					String catalogName = data.getCatalogName(i);
					// 对应数据类型的类
					String columnClassName = data.getColumnClassName(i);
					// 在数据库中类型的最大字符个数
					int columnDisplaySize = data.getColumnDisplaySize(i);
					// 默认的列的标题
					String columnLabel = data.getColumnLabel(i);
					// 获得列的模式
					String schemaName = data.getSchemaName(i);
					// 某列类型的精确度(类型的长度)
					int precision = data.getPrecision(i);
					// 小数点后的位数
					int scale = data.getScale(i);
					// 获取某列对应的表名
					String tableName = data.getTableName(i);
					// 是否自动递增
					boolean isAutoInctement = data.isAutoIncrement(i);
					// 在数据库中是否为货币型
					boolean isCurrency = data.isCurrency(i);
					// 是否为空
					int isNullable = data.isNullable(i);
					// 是否为只读
					boolean isReadOnly = data.isReadOnly(i);
					// 能否出现在where中
					boolean isSearchable = data.isSearchable(i);
					System.out.println(columnCount);
					System.out.println("获得列" + i + "的字段名称:" + columnName);
					System.out.println("获得列" + i + "的字段值:" + columnValue);
					System.out.println("获得列" + i + "的类型,返回SqlType中的编号:" + columnType);
					System.out.println("获得列" + i + "的数据类型名:" + columnTypeName);
					System.out.println("获得列" + i + "所在的Catalog名字:" + catalogName);
					System.out.println("获得列" + i + "对应数据类型的类:" + columnClassName);
					System.out.println("获得列" + i + "在数据库中类型的最大字符个数:" + columnDisplaySize);
					System.out.println("获得列" + i + "的默认的列的标题:" + columnLabel);
					System.out.println("获得列" + i + "的模式:" + schemaName);
					System.out.println("获得列" + i + "类型的精确度(类型的长度):" + precision);
					System.out.println("获得列" + i + "小数点后的位数:" + scale);
					System.out.println("获得列" + i + "对应的表名:" + tableName);
					System.out.println("获得列" + i + "是否自动递增:" + isAutoInctement);
					System.out.println("获得列" + i + "在数据库中是否为货币型:" + isCurrency);
					System.out.println("获得列" + i + "是否为空:" + isNullable);
					System.out.println("获得列" + i + "是否为只读:" + isReadOnly);
					System.out.println("获得列" + i + "能否出现在where中:" + isSearchable);
				}
			}
		} catch (SQLException e) {
			System.out.println("数据库连接失败");
		}
	}
}
 
就这么简单，希望通过该简单的代码能给读者一些帮助和启迪吧！

            当数据库表中有clob字段或要对表中数据做较复杂处理时就不太好用脚本从一个数据库导入数据到另外一个数据库中了，这时就要通过代码实现了，下面以orale数据库为例代码如下：
 

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.UUID;

import oracle.jdbc.driver.OracleConnection;
import oracle.sql.CLOB;

/**
 * import data from one database to another
 * 
 * @author 
 * @version 
 */
public class ImportDataByJdbc {
	public static void main(String[] args) throws Exception {
		Connection con = null;// 创建一个数据库连接
		PreparedStatement pre = null;// 创建预编译语句对象，一般都是用这个而不用Statement
		ResultSet result = null;// 创建一个结果集对象
		try {
			Class.forName("oracle.jdbc.driver.OracleDriver");// 加载Oracle驱动程序
			System.out.println("开始尝试连接cms数据库！");
			String url = "jdbc:oracle:" + "thin:@192.168.0.xx:1521:ORCL";
			String user = "policy";// 用户名,系统默认的账户名
			String password = "xxxx";// 你安装时选设置的密码
			con = DriverManager.getConnection(url, user, password);// 获取连接
			System.out.println("cms连接成功！");
			String sql = "select t.title,t.channel_code,t.content from cms_news t";// 预编译语句，“？”代表参数
			pre = con.prepareStatement(sql);// 实例化预编译语句
			result = pre.executeQuery();// 执行查询，注意括号中不需要再加参数
			importData(result);
			// while (result.next())
			// 当结果集不为空时
			// System.out.println("用户名:" + result.getString("title"));
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				// 逐一将上面的几个对象关闭，因为不关闭的话会影响性能、并且占用资源
				// 注意关闭的顺序，最后使用的最先关闭
				if (result != null)
					result.close();
				if (pre != null)
					pre.close();
				if (con != null)
					con.close();
				System.out.println("cms数据库连接已关闭！");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

	}

	public static String importData(ResultSet result) {

		Connection con = null;// 创建一个数据库连接
		PreparedStatement pre = null;// 创建预编译语句对象，一般都是用这个而不用Statement
		ResultSet result2 = null;// 创建一个结果集对象
		Timestamp currentTime = new Timestamp(System.currentTimeMillis());
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dateString = formatter.format(currentTime);
		try {
			Class.forName("oracle.jdbc.driver.OracleDriver");// 加载Oracle驱动程序
			System.out.println("开始尝试连接omp数据库！");
			String url = "jdbc:oracle:" + "thin:@192.168.0.xx:1521:orclgbk";
			String user = "xjsp";// 用户名,系统默认的账户名
			String password = "xxx";// 你安装时选设置的密码
			con = DriverManager.getConnection(url, user, password);// 获取连接
			System.out.println("omp连接成功！");
			int num = 0;
			while (result.next()) {
				String id = getUUID();
				String entryType = getEntryType(result
						.getString("CHANNEL_CODE"));
				String sql = "insert into kms_entry(ID,ENTRY_NAME,ENTRY_TYPE,ENTRY_CONTENT,EDIT_FLAG,AUDIT_TIME,IF_DEL,IF_AUDIT,LAST_EDIT_TIME,CREATE_USER,CREATE_TIME,LAST_EDIT_USER) "
						+ " values('"
						+ id
						+ "','"
						+ result.getString("title")
						+ "','"
						+ entryType
						+ "',?,'1',to_date('"
						+ dateString
						+ "','yyyy-mm-dd hh24:mi:ss'),'1','3',to_date('"
						+ dateString
						+ "','yyyy-mm-dd hh24:mi:ss'),'00000000000000000000000000000000',to_date('"
						+ dateString
						+ "','yyyy-mm-dd hh24:mi:ss'),'00000000000000000000000000000000')";// 预编译语句，“？”代表参数
				pre = con.prepareStatement(sql);// 实例化预编译语句
				CLOB clob = new CLOB((OracleConnection) con); // 创建一个实例化对象
				clob = oracle.sql.CLOB.createTemporary((OracleConnection) con,
						true, 1);
				clob.putString(1, result.getString("CONTENT")); // 为对象赋值
				pre.setClob(1, clob);
				pre.execute();
				pre.close();
				num = num + 1;
				System.out.println("插入成功第" + (num) + "条数据");

			}

		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				// 逐一将上面的几个对象关闭，因为不关闭的话会影响性能、并且占用资源
				// 注意关闭的顺序，最后使用的最先关闭
				if (result != null)
					result.close();
				if (pre != null)
					pre.close();
				if (con != null)
					con.close();
				System.out.println("omp数据库连接已关闭！");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;

	}

	/**
	 * 获取uuid
	 * 
	 * @return
	 */
	public static String getUUID() {
		UUID uuid = UUID.randomUUID();
		String s = uuid.toString();
		String uuids = s.substring(0, 8) + s.substring(9, 13)
				+ s.substring(14, 18) + s.substring(19, 23) + s.substring(24);
		return uuids;
	}

	public static String getEntryType(String chanelcode) {
		String entryTypeString = "";
		if (chanelcode != "" && chanelcode != null) {
			处理数据.....
		}

		return entryTypeString;

	}
}
           其中clob字段要用放进clob对象然后才进行插入，getUUID是当数据库中表的主键不是自增长生成时需要自己获取进行保存，如果数据库表设置的是自增长主键就不需要这个了

 

 
 

 
 

 
 

 

 项目地址：http://www.freeteam.cn/
 
 数据库信息采集
 
    从FreeCMS 2.1开始支持
 
 通过简单配置即可抓取目标数据库信息，支持增量式采集、关键字替换、定时采集，可采集多种信息属性，可自动审核且静态化信息页面。
 
 采集规则管理
 
 从左侧管理菜单点击采集规则进入。
 
 
 
 添加采集规则
 
 在采集规则列表下方点击"添加"按钮。
 
 
 
 
 
 
 
 
 
 填写相关属性后点击"保存"按钮即可。
 
 采集规则属性说明
 
 采集规则属性分为基本、设置、关键词替换。
 
 一般情况下只要在基本选项卡填写相关属性即可完成。如果需要更多高级设置可以使用后面几个选项卡。
 
 下面针对主要属性进行解释说明。
 
 名称：采集规则的名称。
 
 采集到栏目：采集的信息要添加到那个栏目。
 
 采集调度：设置定时执行采集操作，这个设置非常重要，只有设置了采集调度系统才执行采集操作。
 
 数据库类型：支持mysql,mssql,oracle.
 
 IP地址或者服务器名:目标数据库的地址。
 
 服务器端口：目标服务器提供数据库服务的端口,mysql默认为3306，mssql默认为1433，oracle默认为1521。
 
 登录账号：登录目标数据库的用户名。
 
 登录密码：登录目标数据库的密码。
 
 采集数据库名称：目标数据库的名称。
 
 采集表名称:设置好上面的属性后系统会自动连接目标数据库，并且把表和视图的名称提取出来显示在采集表名称下拉列表中，如果没有提取出数据，说明数据库配置有问题，需要检查数据库配置。
 
 主键字段名称：设置后采集表后，系统会自动提取这个表下的字段。主键字段是为了让系统判断此条数据是否已采集过。
 
 排序字段名称：查询数据时使用的排序字段。
 
 排序类型：根据排序字段正序或倒序查询。
 
 Where条件语句：可以增加查询条件过滤提取内容，在这里不需要填写where关键字，系统会自动添加。
 
 信息属性字段：可以设置各信息属性对应目标表中那个字段，可设置标题、内容、摘要、点击量、作者、来源、添加时间。
 
 状态：启用状态下的采集规则，系统才会执行。
 
 自动审核通过：将采集的信息直接设置为已审核状态。
 
 使用采集信息点击量：默认采集到的信息的点击量为0，设置此属性和内容点击量开始结束html后系统会截取目标信息的点击量，设置为采集后信息的点击量。
 
 最多采集内容数：默认不限制，如果设置了此属性，系统会从采集记录中统计此采集规则已采集了多少条信息，如果超过最多采集内容数，系统将不再采集。
 
 将首幅图片设为标题图片：如果信息内容中有图片，则提取第一张做为标题图片，并设置信息为图片信息。
 
 清除内容中的html标签：将信息内容中的html标签清除，保留纯文本。
 
 当内容为空时是否采集：可设置在内容为空时不采集此信息。
 
 使用采集信息的添加时间:默认采集到的信息的添加时间为当前时间，设置此属性和内容添加时间开始结束html后系统会截取目标信息的添加时间，设置为采集后信息的添加时间。
 
 采集信息添加时间格式:默认格式为yyyy-MM-dd,如果目标页面的添加时间格式不同，需要在这里设置为正确的日期格式。
 
 采集开始时间：默认为当前时间，如果不到采集开始时间，系统是不会采集的。
 
 采集结束时间：默认为永不结束，如果超过采集结束时间，系统是不会采集的。
 
 通过关键词替换功能，您可以将采集到的信息里面的关键词替换为自己想要的关键词。
 
 编辑采集规则
 
 选择需要编辑的采集规则，然后点击"编辑"按钮。
 
 注意:同时只能编辑一个采集规则。
 
 
 
 填写相关属性后点击"保存"按钮即可。
 
 采集
 
 选择需要采集的采集规则，然后点击"采集"按钮。
 
 注意:同时只能对一个采集规则进行采集操作。
 
 
 
 
 
 删除采集规则
 
 选择需要删除的采集规则，然后点击"删除"按钮。
 
 提示:同时可以删除多个采集规则。
 
 
 
 
 
 为了防止误操作，系统会提示用户是否删除，点击"确定"完成删除操作。
 
 查看采集记录
 
 从左侧管理菜单点击采集记录进入。
 
 在这里可以查看到所有数据库采集记录，您可以删除指定的采集记录，但并不会删除已采集的信息数据，选择需要删除的采集记录，然后点击"删除"按钮。
 
    提示:同时可以删除多个采集记录。
 
 
 
 
 
 
 
 
 为了防止误操作，系统会提示用户是否删除，点击"确定"完成删除操作。

 
文章目录
 
1.准备工作
2.创建一个数据库
（1）命令窗口形式：
（2）使用SQLyog：
    
3.JDBC&java数据库的连接
简单的介绍JDBC
JDBC连接数据库简单步骤(以遍历数据库信息为例)：
代码优化与改进
JDBC Dao模式
    
    
4.statement安全问题
statement的执行，其实是拼接sql语句，然后再一起执行。
PrepareStatement
    
    
5.数据库连接包mysql-connector-java-5.1.7链接以及SQLyog的安装包链接
  
 

 
1.准备工作
 
首先找到MySQL安装文件地址，在根目录下将mysql-connector-java-5.1.7文件放置在里面。例如我的MySQL文件是在C:\Program Files\MySQL\MySQL Server 5.5
在eclipse中创建一个java或者javaweb工程
在工程文件根目录上创建一个文件夹，命名为lib，然后将驱动文件：mysql-connector-java-5.1.7-bin.jar复制在此文件夹中。驱动文件是在如下图所示：
 
点击工程中lib文件mysql-connector-java-5.1.7-bin.jar，右键：
 
2.创建一个数据库
 
（1）命令窗口形式：
 
create database student;//1.创建数据库
use student;//2.使用创建的数据库
//3.创建一个简单的表
create table mystudent(
	id int primary key,
	name varchar(20),
	age int
);
//4.在表中添加数据
insert into mystudent values(null,"小明",19);
insert into mystudent values(null,"小芳",18);
insert into mystudent values(null,"小刚",20);
 
（2）使用SQLyog：
 
我觉得它就是命令窗口的可视化软件，具体的安装步骤可以百度，在打开时，写上你的数据库的对应端口号，账号和密码即可。
 
鼠标放在在左框》右键
 
打开数据库，右键表
 
写表名，以及表的列数据
 
右键所创的表
 
打开以后添加数据即可。
 注：由于我之前创建过mystudent，为了区分我加了下划线。
 
3.JDBC&java数据库的连接
 
简单的介绍JDBC
 
 
 
Java Database Connectivity
 
 
 
 
java数据库连接
 
 
SUN公司提供的访问数据库规则、规范，由于数据库种类较多，并且java语言使用比较广泛，sun公司就提供了一种规范，让其他的数据库去实现底层的访问规则。我们的java程序只要使用sun公司提供的jdbc驱动即可。
 
JDBC连接数据库简单步骤(以遍历数据库信息为例)：
 
注册驱动
建立连接
创建statement
执行sql,得到ResultSet
遍历结果集
释放资源
 
package test;

import java.sql.*;

public class MainTest {
	public static void main (String[] args) throws ClassNotFoundException {
		Connection conn=null;
		Statement st=null;
		ResultSet rs=null;
		try {
			//1.注册驱动
			//静态代码块----》类加载了就会执行：java.sql.DriverManager.registerDriver(new Driver());
			//因此以下代码，相当于注册了两次
			//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
			Class.forName("com.mysql.jdbc.Driver");//修改
			//2.建立连接 参数一：协议+访问的数据库，参数二：用户名，参数三：密码
			Connection conn= DriverManager.getConnection("jdbc:mysql://localhost/student", "root", "root");
			//3.创建statement,跟数据库打交道，一定需要这个对象
			Statement st = conn.createStatement();
			//4.执行查询，得到结果集
			String sql="select * from mystudent";
			ResultSet rs=st.executeQuery(sql);
			//遍历每一条记录
			while(rs.next()) {
				int id=rs.getInt("id");
				String name=rs.getString("name");
				int age=rs.getInt("age");
				System.out.println("id="+id+"==name="+name+"==age="+age);
				
			}
			rs.close();
			st.close();
			conn.close();
			
		}catch(SQLException e) {
		e.printStackTrace();
	}
	
}
}
 
代码优化与改进
 
在实际的应用中，我们通常会把代码的声明与实现分开进行。因为在完成一个巨大的代码量时，通常是多人进行合作的，每个人实现一部分的功能，它的声明我认为就相当于一本书的目录，方便管理。
 如何进行呢？那么我们就需要用到接口类
 
JDBC Dao模式
 
新建一个dao的接口，里面声明数据库访问规则创建一个package:dao
 在里面新建一个接口类：
 
package dao;
/**
 * 定义操作数据库的方法
 * */
public interface UserDao {
	void findAll();//findAll;
	void login(String username,String password);//登录方法（有条件查询）
	void insert(String username,String password);
	void delete(int id);
	void update(int id,String name);//根据ID更新具体用户名
	
}

 
新建一个dao的实现类，具体实现早前定义的规则（由于代码偏多，主要例举遍历数据库和插入数据）
 
package dao.impl;

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

import org.junit.jupiter.api.Test;


import dao.UserDao;
import util.JDBCUtil;

public class UserDaoImpl implements UserDao{

	@Override
	@Test
	public void findAll() {
		Connection conn=null;
		Statement st=null;
		ResultSet rs=null;
		try {
			//1.获取连接对象
			conn = JDBCUtil.getConn();
			//2.创建Statement对象
			st = conn.createStatement();
			//3.
			String sql = "select * from myuser";
			rs = st.executeQuery(sql);
			while(rs.next()) {
				int id=rs.getInt("id");
				String username=rs.getString("username");
				String password=rs.getString("password");
				String qqemail=rs.getString("QQ邮箱");
				int phone=rs.getInt("phone");
				System.out.println("id="+id+" username="+username+" password="+password+" QQ邮箱="+qqemail+" phone="+phone);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {

			JDBCUtil.release(conn, st, rs);//资源释放类在后面写
		}
	}
	public void insert(String username,String password) {
		Connection conn=null;
		PreparedStatement ps=null;
		ResultSet rs=null;
		try {
			conn=JDBCUtil.getConn();
			String sql="insert into myuser values(null,?,?)";
			ps=conn.prepareStatement(sql);
			//给占位符赋值
			ps.setString(1, username);
			ps.setString(2, password);
			int result=ps.executeUpdate();
			
			if(result>0) {
				System.out.println("添加成功");
			}else {
				System.out.println("添加失败");
			}
			
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			JDBCUtil.release(conn, ps);
		}
		
	}
	
}

 
资源释放类JDBCUtil
 ==说明：==我们通常不把driver,root,password直接写在程序里
 
 static String url=jdbc:mysql://localhost/student
 statico String name=root
 static String password=root
 
而是将它们单独写在资源文件中然后在使用时读取文件，这样我们只需要更改资源文件信息即可，不需要找到源java文件。
 首先在根目录下创建一个资源文件：
 右键项目文件》new》flie
 然后将其命名为jdbc.properties
 
driverClass=com.mysql.jdbc.Driver
 url=jdbc:mysql://localhost/user
 name=root
 password=root
 
url=jdbc:mysql://localhost/user中user是指具体使用数据库的名字，在写代码时要灵活处理
 
package util;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class JDBCUtil {
	static String driverClass=null;
	static String url=null;
	static String name=null;
	static String password=null;
	
	static {	
		
		
		try {
			Properties properties= new Properties();
			InputStream is=new FileInputStream("jdbc.properties");//放在工程文件下使用
			//InputStream is=JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");//放在src下使用
			//导入输入流
			properties.load(is);
			//读取属性
			driverClass=properties.getProperty("driverClass");
			url=properties.getProperty("url");
			name=properties.getProperty("name");
			password=properties.getProperty("password");
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		
	}
	/**
	 * 获取连接对象
	 * @return
	 * */
	public static Connection getConn() {
		Connection conn=null;
		try {
			Class.forName(driverClass);
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			conn = DriverManager.getConnection(url,name,password);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return conn;
	}
	/**  释放资源
	 *
	 *
	 **/
	public static void release(Connection conn,Statement st,ResultSet rs) {
		closeRs(rs);
		closeSt(st);
		closeConn(conn);
	}
	public static void release(Connection conn,Statement st) {
		closeSt(st);
		closeConn(conn);
	}
	private static void closeRs(ResultSet rs) {
		try {
			if(rs!=null)
			rs.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			rs=null;
		}
	}
	private static void closeSt(Statement st) {
		try {
			if(st!=null)
			st.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			st=null;
		}
	}
	private static void closeConn(Connection conn) {
		try {
			if(conn!=null)
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			conn=null;
		}

	}

}
 
测试类，测试你连接数据库是否成功
 
package test;
import org.junit.Test;
import dao.UserDao;
import dao.impl.UserDaoImpl;

public class TestUserDaoImpl {
	@Test
	public void TestfindAll() {
		UserDao dao=new UserDaoImpl();//接口引用对象
		dao.findAll();
	}
	@Test
	public void insert() {
		UserDao dao=new UserDaoImpl();
		dao.insert("xiaofang", "991");
	}

}
 
在这里，我们用了一个junit包，在想要测试的方法前写@Test然后鼠标放在该方法名上》右键
 就可以运行，如果运行结果显示绿色条，证明运行没有错误，但并不能保证逻辑等完全正确。
 
 这是改进后我所用的数据库：
 
 最终运行结果为：
 
 成功！
 这个 UserDao;UserDao.impl;JDBCUtil;jdbc.properties文件可以保留下来在多个工程中都可以去用，只需要稍作改动，这样避免每次都要写，很麻烦。
 
4.statement安全问题
 
statement的执行，其实是拼接sql语句，然后再一起执行。
 
//前面先拼接sql语句，如果变量里面带有了数据库的关键字，那么一并认为是关键字，不认为是普通的字符串
String sql = "select * from myuser where username='"+username+"' and password='"+password+"'";
			rs = st.executeQuery(sql);
			if(rs.next()) {
				System.out.println("登录成功");
			}else {
				System.out.println("登录失败");
			}


public void TestLogin() {
		UserDao dao=new UserDaoImpl();
		dao.login("admin", "10086'or'1=1");
//		SELECT * FROM myuser WHERE username="admin" AND PASSWORD="10088" OR 1=1;
	}
 
PrepareStatement
 
 
 
该对象就是替换前面的statement对象（预先对sql语句执行语法校验）
 
 
String sql="select * from myuser where username=? and password=?";
//？对应的内容，后面不管传递什么进来，都把它看成是字符串
			 PreparedStatement ps = conn.prepareStatement(sql);
			 //？对应的索引从1开始
			 ps.setString(1, username);
			 ps.setString(2, password);
			 
			 rs=ps.executeQuery();
			 if(rs.next()) {
				 System.out.println("登录成功");
			 }else {
				 System.out.println("登录失败");
			 }
 
statement 给preparedstatement参数不报错因为preparedstatement是statement 的子类（体现了多态性）
 
5.数据库连接包mysql-connector-java-5.1.7链接以及SQLyog的安装包链接
 
链接：https://pan.baidu.com/s/1Guio_lS-TmvbTN6_LKo3Rg
 提取码：herm
 
咳咳，如果有问题欢迎找我讨论哦~