目录
连接数据库
连接数据库六大步骤：
- 注册MySql驱动
- 获取连接对象
- 定义sql语句
- 获取处理sql语句的对象
- 执行sql语句
- 释放资源
注意，以上六步适用于操作数据库的增删改，如果是数据库查询，
则需要将在执行完sql语句之后，对结果集进行处理
牛刀小试：对数据库进行数据添加操作
// 1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
// 2、获取连接对象
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/summer-camp2023?characterEncoding=utf8", "root", "root");
// 3、定义sql语句
String sql = "insert into t_dept values (null,'乌克兰分部','基辅','陈总')";
// 4、获取执行sql语句的对象
Statement stat = conn.createStatement();
// 5、statement执行sql语句，返回结果
int i = stat.executeUpdate(sql);
System.out.println("向t_dept表中插入了" + i + "条数据");
// 6、关闭资源
stat.close();
conn.close();完整操作数据库
注意使用查询语句时，查询语句的光标默认在列表表头上所以我们必须让光标向下移动一位，才能输入数据 result.next();这句话就是将光标向下移动一位，但是这里只会查询一条语句
boolean next() throws SQLException; 这里next()，默认是一个boolean类型的值
@return <code>true</code> if the new current row is valid; <code>false</code> if there are no more rows 这两句话表示，当表中还有下一条语句时，next()的值为true；否则为false 根据这个特性，我们可以结合while循环来遍历查找所有的语句
public class jdbc03 {
public static void main(String[] args) throws Exception {
// f1()添加操作，f2()删除操作，f3()修改操作，f4()查询操作
f1();
f2();
f3();
f4();
}
// 添加数据
private static void f1() throws Exception {
// 1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
// 2、获取链接对象
String url = "jdbc:mysql://localhost:3306/summer-camp2023?characterEncoding=utf8";
String user = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url, user, password);
// 3、定义sql语句
String sql = "insert into t_dept values (18,'乌克兰分部','基辅','陈总')";
// 4、获取执行sql语句的对象
Statement stat = conn.createStatement();
// 5、执行sql语句
int i = stat.executeUpdate(sql);
System.out.println(i>0?"数据添加成功~":"数据添加失败~");
// 6、释放资源
stat.close();
conn.close();
}
// 删除数据
private static void f2() throws Exception {
// 1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
// 2、获取连接对象
String url = "jdbc:mysql://localhost:3306/summer-camp2023?characterEncoding=utf8";
String user = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url, user, password);
// 3、定义sql语句
String sql = "delete from t_dept where did=14";
// 4、获取执行sql语句的对象
Statement stat = conn.createStatement();
// 5、执行sql语句
int i = stat.executeUpdate(sql);
System.out.println(i>0?"数据删除成功~":"数据删除失败~");
// 6、释放资源
stat.close();
conn.close();
}
// 修改数据
private static void f3() throws Exception {
// 1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
// 2、获取连接对象
String url = "jdbc:mysql://localhost:3306/summer-camp2023?characterEncoding=utf8";
String user = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url, user, password);
// 3、定义sql语句
String sql = "update t_dept set leader='王总' where did=18";
// 4、获取执行sql语句的对象
Statement stat = conn.createStatement();
// 5、执行sql语句
int i = stat.executeUpdate(sql);
System.out.println(i>0?"修改数据成功~":"修改数据失败~");
// 6、释放资源
stat.close();
conn.close();
}
// 查询数据
private static void f4() throws Exception {
// 1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
// 2、获取连接对象
String url = "jdbc:mysql://localhost:3306/summer-camp2023?characterEncoding=utf8";
String user = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url, user, password);
// 3、定义sql语句
String sql = "select * from t_dept";
// 4、获取处理sql语句的对象
Statement stat = conn.createStatement();
// 5、执行sql查询语句，并返回结果集
ResultSet result = stat.executeQuery(sql);
// 6、处理查询结果集
while (result.next()){
int did = result.getInt("did");
String dname = result.getString("dname");
String dlocation = result.getString("dlocation");
String leader = result.getString("leader");
System.out.println(did + "--" + dname + "--" + dlocation + "--" + leader);
}
// 7、释放资源
result.close();
stat.close();
conn.close();
}
}连接数据库之三层架构
首先我们先创建自己的文件包，然后创建3个子包
接着在包中根据数据表创建对应的类与接口
注意这里的命名规则：我们全部以dept数据表来解释
IDeptService分析：I表示接口，Dept表示操作的实体，Service表示是Service层
impl包表示实体的实现子包
DeptServiceImpl分析：Dept表示操作的实体，Service表示是Service层，Impl表示实现类
IDeptDao分析：I表示接口，Dept表示操作的实体，Dao表示是Dao层
DeptDaoImpl分析：Dept表示操作的实体，Dao表示是Dao层，Impl表示实现类
三层架构之间的调用
控制层---调用--->业务层，业务层---调用--->数据访问层
public void list() {
try{
// 1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
// 2、获取连接
String url = "jdbc:mysql://localhost:3307/summer-camp2023?characterEncoding=utf8";
String user = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url, user, password);
// 3、定义sql语句
String sql = "select * from t_dept";
// 4、获取处理sql语句的对象
Statement stat = conn.createStatement();
// 5、执行sql查询语句，返回结果集
ResultSet result = stat.executeQuery(sql);
// 6、处理查询结果集
while ( result.next()) {
int did = result.getInt("did");
String dname = result.getString("dname");
String dlocation = result.getString("dlocation");
String leader = result.getString("leader");
System.out.println(did + "--" + dname + "--" + dlocation + "--" + leader);
}
// 7、关闭资源(先开的资源后关闭)
result.close();
stat.close();
conn.close();
}catch (Exception e){
e.printStackTrace();
}
}
}dao数据访问层的数据太过零散，不满足Java封装的特性；并且主方法中对数据的调用也没有经过对象调用，所以决定添加类来实现对数据的封装
添加pojo包下子类，实现对dao数据的封装
该类将属性私有化，提供getter、setter和构造器方法，对数据进行封装，当数据层中的数据需要进行处理时，将处理的结果存放在Dept类对象中。之后想要使用便可通过对象调用
public class Dept {
private int did;
private String dname;
private String dlocation;
private String leader;
public Dept(int did, String dname, String dlocation, String leader) {
this.did = did;
this.dname = dname;
this.dlocation = dlocation;
this.leader = leader;
}
public Dept() {
}
public int getDid() {
return did;
}
public void setDid(int did) {
this.did = did;
}
public String getDname() {
return dname;
}
public void setDname(String dname) {
this.dname = dname;
}
public String getDlocation() {
return dlocation;
}
public void setDlocation(String dlocation) {
this.dlocation = dlocation;
}
public String getLeader() {
return leader;
}
public void setLeader(String leader) {
this.leader = leader;
}
@Override
public String toString() {
return "Dept{" +
"did=" + did +
", dname='" + dname + '\'' +
", dlocation='" + dlocation + '\'' +
", leader='" + leader + '\'' +
'}';
}
}封装类创建完毕之后，选择在数据层创建一个集合，集合的泛型定义为Dept。那么此时，sql访问的数据通过对象封装之后，在将对象添加进入集合。在控制层调用集合即可访问数据
我们发现，写的dao层的结构都差不多，只有些许变化，但是每次还是要进行大篇幅的书写，十分的不方便。我们决定使用一个工具类将所有的公共代码提取出来，方便使用。
创建工具类，简化dao层数据操作
public class JdbcUtils {
// 查询多行多列
// 前面单独的<T>表示声明一个泛型T，后面List<T>就是使用泛型T了
public static <T> List<T> list(String sql, Class<T> c){
List<T> tList = new ArrayList<>();
try{
// 1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
// 2、获取连接
String url = "jdbc:mysql://localhost:3306/summer-camp2023?characterEncoding=utf8";
String user = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url, user, password);
// 3、定义sql语句
// 4、获取处理sql语句的对象
Statement stat = conn.createStatement();
// 5、执行sql查询语句，返回结果集
ResultSet result = stat.executeQuery(sql);
// 通过结果集，得到结果集元数据
ResultSetMetaData md = result.getMetaData();
// 获取结果集总列数
int columnCount = md.getColumnCount();
// 6、处理查询结果集
while ( result.next()) {
// 将每一行数据封装成一个对象，这里通过反射机制创建泛型对象
T t = c.newInstance();
// 取出某一行的每一列数据，封装到对象t的属性中
for (int i = 1; i <= columnCount; i++) {
// 通过类的序号，获取每一列的值
Object value = result.getObject(i);
// 对数据进行非空验证
if (value != null){
// 通过列的序号，获取每一类的列名
String columnName = md.getColumnName(i);
// 因为表中的类名和实体类t中的属性名相同，为每一个属性构造一个反射中的set方法
Field f = c.getDeclaredField(columnName);
// 赋予私有属性赋值权限
f.setAccessible(true);
// 使用反射，把value值给到对象属性t中
f.set(t,value);
}
}
// 将这个泛型对象，添加到泛型集合中去
tList.add(t);
}
// 7、关闭资源(先开的资源后关闭)
result.close();
stat.close();
conn.close();
}catch (Exception e){
e.printStackTrace();
}
return tList;
}
}
public class DeptDaoImpl implements IDeptDao {
@Override
// 查询方法
public List<Dept> list() {
return JdbcUtils.list("select * from t_dept",Dept.class);
}
}总结：
1、首先我们就用最普通的面向对象 + jdbc的知识完成对数据库的操作
2、然后为了满足面向对象，创建了三层架构，通过控制层调用方法，实现了对数据库的操作
3、接着为了满足封装特性，对数据访问层的数据进行封装
4、最后，发现数据访问层大量代码冗余，选择用一个公共的工具类来将重复的代码规整到一个类中。在数据访问层，调用公共类即可
935
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
