三层架构实现增删改查操作封装

于 2023-07-11 16:53:09 发布
阅读量1.1k 收藏 10
点赞数 2
文章标签： 架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77478553/article/details/131661544
版权
本文介绍了Java后端开发中的三层架构，包括表示层（UI）、业务逻辑层（BLL）和数据访问层（DAL），并详细展示了如何使用JSP连接MySQL数据库实现增删改查操作。通过DAO层的JDBC实现，强调了分层设计在软件架构中的重要性，以提高代码的可维护性和解耦。
摘要由CSDN通过智能技术生成

概要

三层架构 
三层架构分为：数据（dao）层、 业务（service）层、控制（controller）层

（1）表示层（USL，即User Show Layer）：视图层
    a. 前台：对应于MVC中的View，用于和用户交互、界面的显示。
    b. 对应于MVC中的Controller，用于控制跳转、调用业务逻辑层。
（2）业务逻辑层（BLL，即Business Logic Layer）：Service层
    a. 接收表示层的请求及调用
    b. 组装数据访问层
（3）数据访问层（DAL，即Data Access Layer）：Dao层
    直接访问数据库的操作

整体架构流程

代码顺序：

1.数据库表

2.实体层

3.dao层、daoimpl

4.service层、serviceimpl

5.controller层

就像搭房子，又下往上，像领导向下调用。controller层调用service层，再由service调用dao层。

技术名词解释

三层架构来源于后端开发的一种分层的思想。

引用自百科的解释：

三层架构（3-tier architecture）通常意义上的三层架构就是将整个业务应用划分为：界面层（User Interface layer）、业务逻辑层（Business Logic Layer）、数据访问层（Data access layer）。

区分层次的目的即为了“高内聚低耦合”的思想。在软件体系架构设计中，分层式结构是最常见，也是最重要的一种结构。微软推荐的分层式结构一般分为三层，从下至上分别为：数据访问层、业务逻辑层（又或称为领域层）、表示层。

各层的作用如下：

表示层：主要对用户的请求接受，以及数据的返回，为客户端提供应用程序的访问。
业务逻辑层：主要负责对数据层的操作。也就是说把一些数据层的操作进行组合。
数据访问层：主要看数据层里面有没有包含逻辑处理，实际上它的各个函数主要完成各个对数据文件的操作。而不必管其他操作。

 

技术细节

一.案例（JSP连接MySQL数据库并实现增删改查）

1.代码目录

 2.应用的MySQL数据库中的表（包含username和password，后面也只会用到这两个）：

3.代码介绍

（1）先要写的是pojo包中的Dept类和Emp类，最后写User类

package com.hp.pojo;

public class Dept {
    private int did;
    private String dname;
    private String dlocation;
    private String leader;

    public static void main(String[] args) {
        System.out.println(new Dept());
    }
    @Override
    public String toString() {
        return "Dept{" +
                "did=" + did +
                ", dname='" + dname + '\'' +
                ", dlocation='" + dlocation + '\'' +
                ", leader='" + 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;
    }
}

 

package com.hp.pojo;

import java.util.Date;

public class Emp {
    private String id;
    private String name;
    private String sex;
    private Date birth;
    private double salary;
    private int deptId;

    public Emp(String id, String name, String sex, Date birth, double salary, int deptId) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.birth = birth;
        this.salary = salary;
        this.deptId = deptId;
    }

    public Emp() {
    }

    @Override
    public String toString() {
        return "Emp{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", birth=" + birth +
                ", salary=" + salary +
                ", deptId=" + deptId +
                '}';
    }

    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 getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public int getDeptId() {
        return deptId;
    }

    public void setDeptId(int deptId) {
        this.deptId = deptId;
    }
}
（2）接下来进行dao层的增删改查操作（这里再附带JdbcUtil，即对jdbc的封装）
package com.hp.dao.impl;

import com.hp.dao.IDeptDao;
import com.hp.pojo.Dept;
import com.hp.utils.JdbcUtil;
import com.hp.utils.JdbcUtilPlus;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

/*
DeptDaoImpl:
Dept 表示操作的实体
Dao 表示执行层/数据访问层/基层
Impl 表示实现类
*/
public class DeptDaoImpl implements IDeptDao {
    @Override
    public List<Dept> list() {
        return JdbcUtil.list("select * from t_dept where did=13",Dept.class);
      }

    @Override
    public Dept selectRow(int did) {
        return JdbcUtilPlus.selectRow("select * from t_Dept where did= ?",Dept.class,did);
    }
}
//查询多行多列
public static <T> List<T> list(String sql,Class<T> c) {
    //创建一个集合，存放所有对象
    List<T> tList = new ArrayList<>();
    try {
        Class.forName("com.mysql.jdbc.Driver");
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/salary?characterEncoding=utf-8", "root", "root");
        Statement statement = conn.createStatement();
        //statement执行sql，返回结果集
        ResultSet rs = statement.executeQuery(sql);
        //结果集rs得到结果集元数据
        ResultSetMetaData md = rs.getMetaData();
        //获取结果集的总列数
        int columnCount = md.getColumnCount();
        //解析rs(循环打印)
        while (rs.next()) {//读取结果集的光标向下移动，光标默认在哪一行，列名所在的那一行
            //根据每一行的数据，封装成一个实体对象
            T t = c.newInstance();
            //1.取出某一行的每一列数据，封装到对象t的属性中
            for (int i = 1; i <= columnCount; i++) {
                //通过列的序号，获取每一列的值
                Object value = rs.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);//理解为：把value赋值给对象t的columnName属性，相当于set方法
                }
            }
            //把对象存入集合中
            tList.add(t);
        }
        //关闭资源
        statement.close();
        conn.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return tList;
}
//查询一行
public static <T> T selectRow(String sql,Class<T> c) {
    try {
        Class.forName("com.mysql.jdbc.Driver");
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/salary?characterEncoding=utf-8", "root", "root");
        Statement statement = conn.createStatement();
        //statement执行sql，返回结果集
        ResultSet rs = statement.executeQuery(sql);
        //结果集rs得到结果集元数据
        ResultSetMetaData md = rs.getMetaData();
        //获取结果集的总列数
        int columnCount = md.getColumnCount();
        //解析rs(循环打印)
        // 根据每一行的数据，封装成一个实体对象
        T t=null;
        if (rs.next()) {//读取结果集的光标向下移动，光标默认在哪一行，列名所在的那一行
            t = c.newInstance();
            //1.取出某一行的每一列数据，封装到对象t的属性中
            for (int i = 1; i <= columnCount; i++) {
                //通过列的序号，获取每一列的值
                Object value = rs.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);//理解为：把value赋值给对象t的columnName属性，相当于set方法
                }
            }
        }
        //关闭资源
        statement.close();
        conn.close();
        return t;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
//查询一列
public static <T> List<T> selectColumn(String sql,Class<T> c) {
    //创建一个集合，存放所有对象
    List<T> tList = new ArrayList<>();
    try {
        Class.forName("com.mysql.jdbc.Driver");
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/salary?characterEncoding=utf-8", "root", "root");
        Statement statement = conn.createStatement();
        //statement执行sql，返回结果集
        ResultSet rs = statement.executeQuery(sql);
        //结果集rs得到结果集元数据
        ResultSetMetaData md = rs.getMetaData();
        //获取结果集的总列数
        int columnCount = md.getColumnCount();
        //解析rs(循环打印)
        while (rs.next()) {//读取结果集的光标向下移动，光标默认在哪一行，列名所在的那一行
                //通过列的序号，获取每一列的值
                T t = (T) rs.getObject(1);
                //把对象存入集合中
                tList.add(t);
            }
        //关闭资源
        statement.close();
        conn.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return tList;
}
//查询单个
public static <T> T selectOne(String sql,Class<T> c) {
    try {
        Class.forName("com.mysql.jdbc.Driver");
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/salary?characterEncoding=utf-8", "root", "root");
        Statement statement = conn.createStatement();
        //statement执行sql，返回结果集
        ResultSet rs = statement.executeQuery(sql);
        //结果集rs得到结果集元数据
        ResultSetMetaData md = rs.getMetaData();
        //获取结果集的总列数
        int columnCount = md.getColumnCount();
        //解析rs(循环打印)
        T t=null;
        if (rs.next()){
            t = (T) rs.getObject(1);
        }
        //关闭资源
        statement.close();
        conn.close();
        return t;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
//增 删 改
public static int update(String sql) {
    try {
        Class.forName("com.mysql.jdbc.Driver");
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/salary?characterEncoding=utf-8", "root", "root");
        Statement statement = conn.createStatement();
        //statement执行sql，返回结果集
        int i = statement.executeUpdate(sql);
        //关闭资源
        statement.close();
        conn.close();
        return i;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return 0;
}

上述难度跳动比较大，涉及到反射、泛类，而且这还是没有升级后的代码，存在sql注入的问题。我们后续还需要改进代码，让代码变得更加安全简洁。需要帮助理解的可以留言私信我！我们接着往下面看

（3）是逻辑性的service包啦
package com.hp.service.impl;

import com.hp.dao.IDeptDao;
import com.hp.dao.impl.DeptDaoImpl;
import com.hp.pojo.Dept;
import com.hp.service.IDeptService;

import java.util.List;

/*
DeptServiceImpl:
Dept 操作的实体类，或者操作某个表
Service 表示业务层
Impl 表示实现类*/
public class DeptServiceImpl implements IDeptService {
    //引入dao层
    private IDeptDao deptDao=new DeptDaoImpl();
    @Override
    public int add() {
        return 0;
    }

    @Override
    public List<Dept> list() {
        return deptDao.list();
    }

    @Override
    public Dept selectRow(int did) {
        return deptDao.selectRow(did);
    }
}
因为我们都已经把实现类写出来了，所以说它的接口类很容易就能写出，这里就不一一给大家说明了
（4）最后我想给大家实现一个入口测试类，用来判断所写的功能是否实现
@Test
public void testRow(){
    Dept dept = selectRow("select * from t_Dept where did=6", Dept.class);
    System.out.println(dept);
}
@Test
public void testColumn(){
    List<String> list = selectColumn("select dname from t_Dept", String.class);
    System.out.println(list);
}
@Test
public void testOne(){
    String dname = selectOne("select dname from t_Dept where did=1", String.class);
    System.out.println(dname);
}
@Test
public void testUpdate(){
    int j = update("insert into t_Dept values (null,'a','b','c')");
    System.out.println(j);
}
@Test//测试登录
public void testLogin(){
    String username="cc'or'1'='1";
    String password="cc'or'1'='1";
    User user = selectRow("select * from t_users where username='" + username + "' and password='" + password+"'", User.class);
    System.out.println(user!=null?"登陆成功":"登录失败");
}
最后一个也是下次讲述的内容之一，这里我留一个悬念，聪明的小伙伴们也看到这里我用了@Test，注意这里要导一个包junit-4.12.jar，需要的可以私信我！有什么问题后续也可以提出来，知无不言言无不尽。

小结

本节课我们大家搭建了三层架构：控制层、业务层、数据访问层，让我们的数据在各个层之间传递，最后我们要简化代码——抽取工具类。从总结来看，我们的核心就是抽取工具类。所以我们最重要的就是理解工具类的方法，在java基础中好好学习泛类，面向对象，反射，这样在后续的java进阶学习中，才能更加如鱼得水，游刃有余！最后我们为什么要用三层架构的设计模式？这一点也困惑我许久。通过老师的讲解和自己的总结得出dao层是基层，而service是中层管理人员，最后controller是高层，一个项目需要每个人发挥自己的能力，这样反映了java编程工作团队合作的重要性。只有我们一层管理着下一层，秩序才不会紊乱，功能模块才会更加稳定。有不同见解的朋友也可以底下留言，也可以私下联系我，让我们遨游在java的海洋里面吧！

sheiily
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C# 用三层架构实现简单的增删改查
06-07
C# 用三层架构实现简单的增删改查，适合初学者学习的三层架构
三层架构实现增删改查
最新发布
xiaoyi______的博客
03-10 735
三层架构连接数据库实现增删改查
使用三层架构实现增删改查】
qq_60281421的博客
04-30 3409
使用三层架构实现增删改查
三层架构增删改查
05-24
完整的三层架构源码的增删改查项目，对于初识三层架构的程序员来说可以下载下来借鉴借鉴。
C# .net mvc 三层架构 增删改查
02-09
本篇文章将详细探讨“C# .NET MVC 三层架构的增删改查”相关知识点。 首先，三层架构（也称为N-Tier Architecture）是为了实现应用程序组件之间的松耦合，它将应用逻辑分为三个主要部分：表现层（Presentation ...
三层架构实现增删改查（十四）.zip
06-27
总结起来，"三层架构实现增删改查（十四）"这个项目可能包含了如何使用Java、Tomcat、Servlet和JSP来实现一个包含增删改查功能的Web应用。开发者可能已经详细讲解了每个层次的职责以及它们之间的协作方式，包括如何...
三层 MVC 增删改查例子
05-10
在"三层MVC增删改查例子"中，Controller可能包含了处理用户提交的表单数据，调用相应的DAO方法来执行CRUD操作，然后将结果传递给View展示。 这个案例是一个很好的学习资源，特别是对于初学者。它展示了如何在实际...
使用.NET三层结构实现增删改查（简单）
06-03
在"使用.NET三层结构实现增删改查（简单）"的例子中，开发者可能会创建一个简单的数据库模型，比如一个学生信息管理系统。首先，创建数据访问层的类，如`StudentDAL`，其中包含`InsertStudent`、`UpdateStudent`、`...
vs2010 c#三层架构实现简单的增删改查
09-23
对于初学者实现简单的增删改查功能. 实现三层架构,每层分层写的,简单好理解,便于初学者借鉴.
Net.asp BLL+DAL+Web实现三层架构，自带增删改查
10-13
一个简单的项目架构，使用MVC模式，实现了增删改查。 VS 2010 旗舰版 +SQL Server 2008 R2
asp.net三层架构（增删改查）例子.rar
09-26
用ASP.NET三层架构的来实现增删改，内有源码和数据库简单实用
C#窗体程序对数据库的增删改查操作（三层架构）.
08-07
基于vb进行数据库的增删改查操作 sql语句 c#
简单的jsp课程大作业，采用MVC模式，三层架构，实现增删改查等基础操作
01-03
一个简单的jsp课程大作业，实现后台管理员通过该系统对数据库表的增删改查等功能的一个后台管理系统，压缩包含有代码加数据库（MySQL）加配套说明文档，文档有三十多页，对每个页面都有说明。
使用MVC三层架构实现对数据库表的增删改查操作（全部代码）
11-01 2356
使用MVC三层架构实现对数据库表的增删改查操作（全部代码）
三层架构实现品牌数据的增删改查
m0_56428218的博客
10-16 837
三层架构（3-tier architecture）通常意义上的三层架构就是将整个业务应用划分为：界面层（User Interface layer）、业务逻辑层（Business Logic Layer）、数据访问层（Data access layer）。区分层次的目的即为了“高内聚低耦合”的思想。在软件体系架构设计中，分层式结构是最常见，也是最重要的一种结构。微软推荐的分层式结构一般分为三层，从下至上分别为：数据访问层、业务逻辑层（又或称为领域层）、表示层。
C#三层架构的搭建与数据库连接的增删改查
qq_42392283的博客
12-08 684
1.先创建一个空的解决方案。 2.创建四个项目，3个类库。 3.增加项目的引用实现关联。 表现层：模型层+业务逻辑层 FreshLiveWeb：Models+BLL 业务逻辑层：模型层+数据访问层 BLL:Models+DAL 数据访问层：模型层 DAL：Mod...
三层架构、增删改查
weixin_51120880的博客
09-03 873
持久层 public class TeacherMapperImpl implements TeacherMapper { @Override //查看全部 public List<teacher> teacherAll() { //提高作用域 InputStream Stream=null; SqlSessionFactory build=null; SqlSession session=null; .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值