1.最基本的JAVA代码连接mysql数据库
//日期：2019.5.30
//作者：***
//功能：熟悉基本的jdbc连接数据库，以及进阶的preparedstatement的学习使用
//以及最后的一种O/R映射的编程模式，DOA的编程逻辑
//本程序，先记录学习的基本流程，很简单但也是之后所有学习的基础
package com.*****
import java.util.*;
import java.sql.*;
public class Test {
//主函数，测试程序
public static void main(String args[])
{
Test test = new Test();
test.run();
}
//封装程序执行逻辑函数，run
public void run()
{
String driverName = "com.mysql.cj.jdbc.Driver";
String url = "jdbc:mysql://localhost:3306/school?serverTimezone=GMT%2B8";
String user = "root";
String password = "dba.liuxuanjie";
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
//记载数据库连接驱动
try {
Class.forName(driverName);
} catch (Exception e) {
System.out.println("加载数据库驱动失败！");
}
//连接数据库
try {
connection = DriverManager.getConnection(url,user,password);
statement = connection.createStatement();
String sql = "select * from students";
resultSet = statement.executeQuery(sql);
while(resultSet.next())
{
String id = resultSet.getString(1);
String name = resultSet.getString(2);
String phone = resultSet.getString(3);
System.out.println(id+" "+name+" "+phone);
}
} catch (Exception e) {
e.printStackTrace();
}finally
{
try {
if(connection != null)
connection.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
}
数据库的格式如下：（mysql）
2.PreparedStatement进阶
//日期：2019.5.30
//作者：刘烜杰
//功能：熟悉基本的jdbc连接数据库，以及进阶的preparedstatement的学习使用
//以及最后的一种O/R映射的编程模式，DOA的编程逻辑
//本程序接上上述的Test程序，学习并练习预编译的preparedStatement
//即：带参数的sql语句的使用，也就是sql语句中带有？（占位符）！
/*
* 经验总结：
* 在jdbc应用开发中，应当尽量使用preparedStatement而避免使用statement
* 1.代码的可读性和可维护性更高
* 2.提高性能：预编译的preparedstatement会被缓存，
* 重复调用时，不需要重新编译，直接传入参数（占位符的实际变量值）
* 3.能够防止sql注入，很容易理解，别人猜测你的sql验证语句的模式，会输入'or' 1 '=' 1
* 而是where的查询结果始终是true，导致验证无效
* */
package com.liuxuanjie3;
import java.util.*;
import java.sql.*;
public class Test2 {
//主函数，作为程序代码测试的入口
public static void main(String args[])
{
Test2 test2 = new Test2();
test2.run();
}
//封装程序实际执行逻辑的函数
public void run()
{
String driverName = "com.mysql.cj.jdbc.Driver";
String url = "jdbc:mysql://localhost:3306/school?serverTimezone=GMT%2B8";
String user = "root";
String password = "dba.liuxuanjie";
Connection connection = null;
PreparedStatement preparedStatement = null;
String sql = "insert into students values(?,?,?)";
//加载驱动
try {
Class.forName(driverName);
} catch (Exception e) {
System.out.println("加载驱动失败！");
}
//连接数据库
try {
connection = DriverManager.getConnection(url,user,password);
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, "55161009");
preparedStatement.setString(2, "jilindaxue");
preparedStatement.setString(3, "11011011011");
preparedStatement.executeUpdate();
preparedStatement.setString(1, "55161010");
preparedStatement.setString(2, "ruanjianxueyuan");
preparedStatement.setString(3, "12012012022");
preparedStatement.executeUpdate();
System.out.println("数据库更新成功：添加新元素");
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(connection != null)
connection.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
}
3.元数据MetaData相关
//日期：2019.5.30
//作者：刘烜杰
//功能：熟悉基本的jdbc连接数据库，以及进阶的preparedstatement的学习使用
//以及最后的一种O/R映射的编程模式，DOA的编程逻辑
/*
* 本程序主要学习练习：如何获取元数据MetaData
* 其中：
* 1.数据库元数据（Database MetaData）可以使用connection.getMetaData()获得，
* 包含了关于数据库整体元数据的信息
* 2.结果集元数据(ResultSet MetaData)可以使用resultSet.getMetaData()获得,
* 包含了表的相关信息，比如列名，列数等信息！
* x下属程序包含了获取具体信息的方法！
* */
package com.liuxuanjie3;
import java.util.*;
import java.sql.*;
public class Test3 {
//主函数，作为程序代码测试的入口
public static void main(String args[])
{
Test3 test3 = new Test3();
test3.run();
}
//封装函数执行代码的具体逻辑
public void run()
{
String driverName = "com.mysql.cj.jdbc.Driver";
String url = "jdbc:mysql://localhost:3306/school?serverTimezone=GMT%2B8";
String user = "root";
String password = "dba.liuxuanjie";
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
String sql = "select * from students";
//加载驱动
try {
Class.forName(driverName);
} catch (Exception e) {
System.out.println("加载驱动失败！");
}
//连接数据库
try {
connection = DriverManager.getConnection(url,user,password);
preparedStatement = connection.prepareStatement(sql);
resultSet = preparedStatement.executeQuery();
DatabaseMetaData dbMetaData = connection.getMetaData();
ResultSetMetaData rSetMetaData = resultSet.getMetaData();
System.out.println("数据库相关元数据信息如下：");
System.out.println("数据库名称："+dbMetaData.getDatabaseProductName());
System.out.println("数据库版本号："+dbMetaData.getDatabaseProductVersion());
System.out.println("数据库驱动名："+dbMetaData.getDriverName());
System.out.println("数据库驱动版本号："+dbMetaData.getDriverVersion());
System.out.println("数据库URL："+dbMetaData.getURL());
System.out.println("该连接的登录名："+dbMetaData.getUserName());
System.out.println("结果集元数据对象信息如下：");
System.out.println("字段个数:"+rSetMetaData.getColumnCount());
System.out.println("字段名字："+rSetMetaData.getColumnName(1));
System.out.println("字段的JDBC类型："+rSetMetaData.getColumnType(1));
System.out.println("字段数据库类型："+rSetMetaData.getColumnTypeName(1));
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(connection != null)
connection.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
}4.事务相关
//日期：2019.5.30
//作者：刘烜杰
//功能：熟悉基本的jdbc连接数据库，以及进阶的preparedstatement的学习使用
//以及最后的一种O/R映射的编程模式，DOA的编程逻辑
/*
* 该程序简单学习以及理解事务的处理相关知识
* 1.事务是一组原子操作，为了解决数据安全操作而应用的
* 通俗理解就是：一组sql语句要么都执行，要么撤销都不执行，强调其原子性
* 2.在jdbc编程中事务的使用：
* jdbc事务是由connection控制的。而connection又提供了两种事务模式：
* 自动提交 和 手动提交
* ①：其默认的缺省操作是自动提交：即最简单的一条对数据库执行更新的sql语句就代表一个事务
* 操作成功后，系统自动调用commit方法提交，失败则进行rollback回滚
* ②：使用setAutoCommit(false)来禁止自动提交，变更为手动提交
* 然后可以把多条SQL表达式作为一个事务，最后手动调用cimmit函数提交，
* 假如其中任意sql语句执行失败，都不会成功执行commit，冰抛出异常，
* 然后在捕获异常处理方法，手动实行回滚操作！保证原子性和正确性
* */
package com.liuxuanjie3;
import java.util.*;
import java.sql.*;
public class Test4 {
//主函数，作为程序代码测试的入口
public static void main(String args[])
{
Test4 test4 = new Test4();
test4.run();
}
//封装函数，执行代码的实际逻辑
public void run()
{
String driverName = "com.mysql.cj.jdbc.Driver";
String url = "jdbc:mysql://127.0.0.1:3306/school?serverTimezone=GMT%2B8";
String user = "root";
String password = "dba.liuxuanjie";
Connection connection = null;
PreparedStatement preparedStatement = null;
try {
Class.forName(driverName);
} catch (Exception e) {
System.out.println("数据库驱动加载失败！");
}
try {
String sql = "insert into students values(?,?,?)";
connection = DriverManager.getConnection(url, user, password);
connection.setAutoCommit(false); //把自动提交关闭，改为手动提交
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, "55161011");
preparedStatement.setString(2, "runajian");
preparedStatement.setString(3, "11911911999");
preparedStatement.executeUpdate();
preparedStatement.setString(1, "55161012");
preparedStatement.setString(2, "gongcehng");
preparedStatement.setString(3, "15615615655");
preparedStatement.executeUpdate();
try {
connection.commit();
System.out.println("事务提交成功，数据库更新！");
} catch (Exception e) {
System.out.println("提交失败，回滚事务操作！");
connection.rollback();
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(connection != null)
connection.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
}
5.O/R映射，server和DOA的分层设计
//日期：2019.5.30
//作者：刘烜杰
//功能：熟悉基本的jdbc连接数据库，以及进阶的preparedstatement的学习使用
//以及最后的一种O/R映射的编程模式，DOA的编程逻辑
/*
* 本程序学习练习jdbc编程中对程序逻辑进行分层设计的一种思想，
* 也就是常说的 ORM（Object Pelational Mapping）对象关系映射
* 简单理解就是：
* 把数据库中的表（数据）映射成一种程序中的类（object），表中列映射成类的属性
* 然后设计到一个DAO层，即Data ACcess Object，即相应的数据库操作，底层的操作
* 然后实现一个server类，实现具体的操作逻辑，业务逻辑
* */
package com.liuxuanjie3;
import java.util.*;
import org.omg.CORBA.PRIVATE_MEMBER;
import java.sql.*;
public class Test5 {
//主函数，作为程序测试代码的入口
public static void main(String args[])
{
Test5 test5 = new Test5();
test5.run();
}
//封装函数，作为程序执行逻辑
public void run()
{
//对这个包含O/R映射关系，以及实现server业务逻辑类，和DOA数据库底层逻辑操作的分层结构进行执行
Server server = new Server();
//执行服务层的查询功能：
List <DataInfo> aList = server.executeQuery();
//采用对其格式控制显示
System.out.printf("%-20s%-20s%-20s","id","name","phone");
System.out.println();
System.out.println("=============================================================");
for(DataInfo dataInfo : aList)
{
System.out.printf("%-20s%-20s%-20s",
dataInfo.getId(),dataInfo.getName(),dataInfo.getPhone());
System.out.println();
}
}
}
//实现一个Server类。进行具体的业务逻辑操作类
class Server
{
//执行实际的业务逻辑操作，查询函数
public List<DataInfo> executeQuery()
{
List <DataInfo> aList = new ArrayList<DataInfo>();
//直接进行业务逻辑的操作，构建sql语句
//String sql = "select * from students where name=?";
String sql2 = "select * from students";
//String [] strings = new String[1];
//strings[0] = "liuxuanjie";
//利用DOA的底层逻辑实现，进行实际的操作
DoaClass doaClass = new DoaClass();
doaClass.accessDB();
//doaClass.executeQuery(sql, strings);
doaClass.executeQuery(sql2, null);
ResultSet resultSet = doaClass.getResultSet();
try {
while(resultSet.next())
{
DataInfo dataInfo = new DataInfo();
dataInfo.setId(resultSet.getString(1));
dataInfo.setName(resultSet.getString(2));
dataInfo.setPhone(resultSet.getString(3));
aList.add(dataInfo);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
doaClass.closeAll();
}
return aList;
}
//执行具体的业务逻辑操作，执行添加的更新操作
public void executeUpdate(DataInfo dataInfo)
{
//仍旧构造实际业务逻辑的sql语句
String sql = "insert into students values(?,?,?);";
String [] strings = new String[3];
strings[0] = dataInfo.getId();
strings[1] = dataInfo.getName();
strings[2] = dataInfo.getPhone();
//使用底层的DOA逻辑，进行实现数据库相关操作
DoaClass doaClass = new DoaClass();
doaClass.accessDB();
doaClass.executeUpdate(sql, strings);
try {
doaClass.closeAll();
} catch (Exception e) {
e.printStackTrace();
}
}
}
//实现一个o/r映射关系的类
class DataInfo
{
private String id = null;
private String name = null;
private String phone = null;
//无参构造函数
public DataInfo(){}
//形参构造函数
public DataInfo(String id,String name,String phone)
{
this.id = id;
this.name = name;
this.phone = phone;
}
public String getId() {
return id;
}
public void setId(String 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;
}
}
//实现一个DOA层，即最底层的数据库操作类
class DoaClass
{
private String driverName = null;
private String url = null;
private String user = null;
private String password = null;
private Connection connection = null;
private PreparedStatement preparedStatement = null;
private ResultSet resultSet = null;
//无参构造函数
public DoaClass()
{
driverName = "com.mysql.cj.jdbc.Driver";
url = "jdbc:mysql://127.0.0.1:3306/school?serverTimezone=GMT%2B8";
user = "root";
password = "dba.liuxuanjie";
}
//连接数据库
public void accessDB()
{
//加载数据库驱动
try {
Class.forName(driverName);
} catch (Exception e) {
System.out.println("数据库驱动加载失败！");
}
//连接数据库
try {
connection = DriverManager.getConnection(url, user, password);
} catch (Exception e) {
e.printStackTrace();
}
}
//关闭所有开启的接口
public void closeAll()
{
try {
if (resultSet != null) {
resultSet.close();
}
if(preparedStatement != null)
{
preparedStatement.close();
}
if (connection != null) {
connection.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
//执行查询封装函数,传入业务逻辑需要的sql语句，以及缺省值的参数
public void executeQuery(String sql,String str[])
{
if(connection != null)
{
try {
preparedStatement = connection.prepareStatement(sql);
if(str != null)
{
for (int i = 0; i < str.length; i++) {
preparedStatement.setString(i+1, str[i]);
}
}
this.resultSet = preparedStatement.executeQuery();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
//执行更新操作
public void executeUpdate(String sql,String str[])
{
if(connection != null)
{
try {
preparedStatement = connection.prepareStatement(sql);
if(str != null)
{
for (int i = 0; i < str.length; i++) {
preparedStatement.setString(i+1, str[i]);
}
}
preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public String getDriverName() {
return driverName;
}
public void setDriverName(String driverName) {
this.driverName = driverName;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Connection getConnection() {
return connection;
}
public void setConnection(Connection connection) {
this.connection = connection;
}
public PreparedStatement getPreparedStatement() {
return preparedStatement;
}
public void setPreparedStatement(PreparedStatement preparedStatement) {
this.preparedStatement = preparedStatement;
}
public ResultSet getResultSet() {
return resultSet;
}
public void setResultSet(ResultSet resultSet) {
this.resultSet = resultSet;
}
}
扫一扫
2799
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
