分层构建项目

最新推荐文章于 2024-06-29 10:47:43 发布
最新推荐文章于 2024-06-29 10:47:43 发布
阅读量265 收藏
点赞数
分类专栏： 项目经验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a6697238/article/details/49915343
版权

分层构建WEB项目

如何分层

···sequence

Created with Raphaël 2.1.0 WEB客户端 WEB客户端 Servlet Servlet 业务逻辑 业务逻辑 持久化逻辑 持久化逻辑 JSP JSP 客户端 客户端 request 取得页面数据 调用业务逻辑方法 调用持久化逻辑方法 返回 返回 渲染页面 输出页面

每一层只依赖于下一层，不能跨层依赖

每层作用

  • WEB客户端

    该层只负责提交表单到后台的Servlet，通过request取得数据等，打印输出到表格显示

  • Servlet层
    关键的一层，接收到表单数据，调用业务逻辑，处理业务。
    相同的servlet可以先抽象出来一个 抽象类 继承使用，比如对于物料的 增，删，改，查 ，都需要使用业务逻辑 Manager 类，可以 在 init()时即取得该 类的对象，其他类直接继承
    即该层可以需要创建业务逻辑层对象

抽象类

package com.houlu.drp.basedata.web;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;

import com.houlu.drp.basedata.dao.ItemDao;
import com.houlu.drp.basedata.manager.ItemManager;
import com.houlu.drp.basedata.manager.ItemManagerImpl;
import com.houlu.drp.util.BeanFactory;


/**
 * 物料servlet抽象
 * @author Administrator
 *
 */
public abstract class AbstractItemServlet extends HttpServlet {

    protected ItemManager itemManager;

    public AbstractItemServlet(){

        System.out.println("AbstractItemServlet-----------Construct");
    }

    @Override
    public void init() throws ServletException{

    //  itemManager = (ItemManager)BeanFactory.getInstance().getServiveObject("itemManager");

        BeanFactory beanFactory = (BeanFactory)this.getServletContext().getAttribute("beanFactory");
        itemManager = (ItemManager)beanFactory.getServiveObject(ItemManager.class);
    }
}

继承类

package com.houlu.drp.basedata.web;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.houlu.drp.basedata.domain.Item;
import com.houlu.drp.basedata.manager.ItemManager;
import com.houlu.drp.basedata.manager.ItemManagerImpl;
import com.houlu.drp.datadict.domain.ItemCategory;
import com.houlu.drp.datadict.domain.ItemUnit;

public class AddItemServlet extends AbstractItemServlet {

    private ItemManager itemManager;

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        //取得表单数据
        String itemNo = request.getParameter("itemNo");
        String itemName = request.getParameter("itemName");
        String spec = request.getParameter("spec");
        String pattern = request.getParameter("pattern");
        String category = request.getParameter("category");
        String unit = request.getParameter("unit");

        //构造item对象
        Item item = new Item();
        item.setItemNo(itemNo);
        item.setItemName(itemName);
        item.setSpec(spec);
        item.setPattern(pattern);


        //构造物料类别
        ItemCategory itemCategory = new ItemCategory();
        itemCategory.setId(category);
        item.setItemCategory(itemCategory);

        //构造物料单位
        ItemUnit itemUnit = new ItemUnit();
        itemUnit.setId(unit);
        item.setItemUnit(itemUnit);

    //  itemManager = new ItemManagerImpl();

        try {
            itemManager.addItem(item);
        } catch (Exception e) {
            request.setAttribute("add_message", "添加物料失败，失败代码 ["+itemNo+"]");
        }
        //重定向
        //response.sendRedirect(requset.getContextPath()+"/basedata/item_maint.jsp");
        request.setAttribute("add_message", "添加成功");
        //转发
        request.getRequestDispatcher("/basedata/item_maint.jsp").forward(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }

}
  • 业务逻辑
    该层只与业务逻辑打交道，该层创建DAO层的connection
    业务逻辑层创建固定接口，然后不同类实现。

业务逻辑接口

package com.houlu.drp.basedata.manager;

import java.sql.Connection;

import com.houlu.drp.basedata.domain.Item;
import com.houlu.drp.util.PageModel;

/**
 * 物料业务逻辑层接口
 * @author Administrator
 *
 */
public interface ItemManager {

    /**
     * 添加物料
     * @param conn
     * @param item
     */
    public void addItem(Item item);

    /**
     * 根据物料代码集合删除
     * @param conn
     * @param itemNos
     */
    public void delItem(String[] itemNos);

    /**
     * 修改物料
     * @param conn
     * @param item
     */
    public void modifyItem(Item item);

    /**
     * 根据物料代码查询
     * @param conn
     * @param itemNo
     * @return
     */
    public Item findItemById(String itemNo);

    /**
     * 根据条件分页查询
     * @param pageNo
     * @param pageSize
     * @param condation
     * @return
     */
    public PageModel findItemList(int pageNo, int pageSize, String condation);
}

实现类

package com.houlu.drp.basedata.manager;

import java.sql.Connection;

import com.houlu.drp.basedata.dao.ItemDao;
import com.houlu.drp.basedata.dao.ItemDaoFactory;
import com.houlu.drp.basedata.dao.ItemDaoFactory4SqlServer;
import com.houlu.drp.basedata.domain.Item;
import com.houlu.drp.util.ApplicationException;
import com.houlu.drp.util.BeanFactory;
import com.houlu.drp.util.DbUtil;
import com.houlu.drp.util.PageModel;
import com.houlu.drp.util.XmlConfigReader;

/**
 * 物料管理接口实现
 * @author Administrator
 *
 */
public class ItemManagerImpl implements ItemManager {

    private ItemDao itemDao = null;

    public ItemManagerImpl(){
        //System.out.println("new------------------------ItemManagerImplClass");
        itemDao = (ItemDao)BeanFactory.getInstance().getDaoObject(ItemDao.class);
    }

    public void addItem(Item item) {
        Connection conn = null;

        try {
            conn = DbUtil.getConnection();
                if(itemDao.findItemById(conn, item.getItemNo())!=null){
                    throw new ApplicationException("该代码物料已经存在");
                }
            itemDao.addItem(conn, item);
        } finally{
            DbUtil.close(conn);
        }

    }

    @Override
    public void delItem(String[] itemNos) {
        // TODO Auto-generated method stub

    }

    @Override
    public void modifyItem(Item item) {
        // TODO Auto-generated method stub

    }

    @Override
    public Item findItemById(String itemNo) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public PageModel findItemList(int pageNo, int pageSize, String condation) {
        Connection conn = null;
        PageModel pageModel = null;
        try {
            conn = DbUtil.getConnection();
            pageModel = itemDao.findItemList(conn, pageNo, pageSize, condation);
        } finally{
            DbUtil.close(conn);
        }

        return pageModel;
    }


}
  • 持久化层
    该层与数据库打交道，取得业务逻辑层的connection进行sql操作

上层接口

package com.houlu.drp.basedata.dao;

import java.sql.Connection;

import com.houlu.drp.basedata.domain.Item;
import com.houlu.drp.util.PageModel;

/**
 * 物料数据访问接口
 * @author Administrator
 *
 */
public interface ItemDao {

    /**
     * 添加物料
     * @param conn
     * @param item
     */
    public void addItem(Connection conn,Item item);

    /**
     * 根据物料代码集合删除
     * @param conn
     * @param itemNos
     */
    public void delItem(Connection conn,String[] itemNos);

    /**
     * 修改物料
     * @param conn
     * @param item
     */
    public void modifyItem(Connection conn,Item item);

    /**
     * 根据物料代码查询
     * @param conn
     * @param itemNo
     * @return
     */
    public Item findItemById(Connection conn,String itemNo);

    /**
     * 根据条件分页查询
     * @param pageNo
     * @param pageSize
     * @param condation
     * @return
     */
    public PageModel findItemList(Connection conn,int pageNo, int pageSize, String condation);

}

具体实现

package com.houlu.drp.basedata.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.houlu.drp.basedata.domain.Item;
import com.houlu.drp.datadict.domain.ItemCategory;
import com.houlu.drp.datadict.domain.ItemUnit;
import com.houlu.drp.util.ApplicationException;
import com.houlu.drp.util.DbUtil;
import com.houlu.drp.util.PageModel;

public class ItemDao4SqlServerImpl implements ItemDao {

    @Override
    public void addItem(Connection conn, Item item) {
        StringBuffer sb = new StringBuffer();
        sb.append("INSERT INTO T_ITEMS ");
        sb.append("(ITEM_NO, ITEM_CATEGORY_ID, ITEM_UNIT_ID, ITEM_NAME, SPEC, PATTERN) ");
        sb.append("VALUES (?,?,?,?,?,?)");
        String sql = sb.toString();

        PreparedStatement pstmt = null;
        try {
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, item.getItemNo());
            pstmt.setString(2, item.getItemCategory().getId());
            pstmt.setString(3, item.getItemUnit().getId());
            pstmt.setString(4, item.getItemName());
            pstmt.setString(5, item.getSpec());
            pstmt.setString(6, item.getPattern());
            pstmt.executeUpdate();

        } catch (Exception e) {
            e.printStackTrace();
            throw new ApplicationException("添加物料失败");
        } finally{
            DbUtil.close(pstmt);
        }

    }

    @Override
    public void delItem(Connection conn, String[] itemNos) {
        // TODO Auto-generated method stub

    }

    @Override
    public void modifyItem(Connection conn, Item item) {
        // TODO Auto-generated method stub

    }

    @Override
    public Item findItemById(Connection conn, String itemNo) {
        StringBuffer sb = new StringBuffer();
        sb.append("select i.ITEM_NO,i.ITEM_NAME,I.SPEC,I.PATTERN,i.ITEM_CATEGORY_ID as category_id, d1.NAME as category_name,i.ITEM_UNIT_ID as unit_id, d2.NAME as unit_name ");
        sb.append("from T_ITEMS i,T_DATA_DIC d1, T_DATA_DIC d2 ");
        sb.append("where i.ITEM_CATEGORY_ID = d1.ID and i.ITEM_UNIT_ID = d2.ID and i.ITEM_NO = ?");
        String sql = sb.toString();

        PreparedStatement pstmt = null;
        ResultSet rs = null;
        Item item = null;
        try {
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, itemNo);
            rs = pstmt.executeQuery();
            if(rs.next()){
                item = new Item();
                item.setItemNo(rs.getString("item_no"));
                item.setItemName(rs.getString("item_name"));
                item.setSpec(rs.getString("spec"));
                item.setPattern(rs.getString("pattern"));

                //构造ItemCategory
                ItemCategory ic = new ItemCategory();
                ic.setId(rs.getString("category_id"));
                ic.setName(rs.getString("category_name"));
                item.setItemCategory(ic);

                //构造ItemUnit
                ItemUnit iu = new ItemUnit();
                iu.setId(rs.getString("unit_id"));
                iu.setName(rs.getString("unit_name"));
                item.setItemUnit(iu);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new ApplicationException("根据物料代码查询出错");
        }finally{
            DbUtil.close(rs);
            DbUtil.close(pstmt);
        }

        return item;
    }

    @Override
    public PageModel findItemList(Connection conn,int pageNo, int pageSize, String condation) {
        StringBuffer sb = new StringBuffer();
        sb.append("select * from( ");
        sb.append("select ROW_NUMBER() over(order by i.ITEM_NO) as r2,* from( ");
        sb.append("select ");
        sb.append("ROW_NUMBER() over(order by a.ITEM_NO) as r1,a.ITEM_NO,a.item_name,a.SPEC,a.PATTERN,a.ITEM_CATEGORY_ID,b.NAME as item_category_name,a.ITEM_UNIT_ID,c.NAME as item_unit_name ");
        sb.append("from T_ITEMS a,T_DATA_DIC b,T_DATA_DIC c where a.ITEM_CATEGORY_ID=b.ID and a.ITEM_UNIT_ID = c.ID ");
        if(condation!=null&&!"".equals(condation)){
            sb.append("and a.ITEM_NAME like '"+ condation +"%' ");
        }
        sb.append(") i where i.r1<= ? ");
        sb.append(")o where o.r2 > ? ");

        String sql = sb.toString();

    //  System.out.println(sql);
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        PageModel pageModel = null;
        try {
            pstmt = conn.prepareStatement(sql);
            pstmt.setInt(1, pageNo*pageSize);
            pstmt.setInt(2, (pageNo-1)*pageSize);
            rs = pstmt.executeQuery();
            List<Item> itemList = new ArrayList<Item>();
            while(rs.next()){
                Item item = new Item();
                item = new Item();
                item.setItemNo(rs.getString("item_no"));
                item.setItemName(rs.getString("item_name"));
                item.setSpec(rs.getString("spec"));
                item.setPattern(rs.getString("pattern"));

                //构造ItemCategory
                ItemCategory ic = new ItemCategory();
                ic.setId(rs.getString("item_category_id"));
                ic.setName(rs.getString("item_category_name"));
                item.setItemCategory(ic);

                //构造ItemUnit
                ItemUnit iu = new ItemUnit();
                iu.setId(rs.getString("item_unit_id"));
                iu.setName(rs.getString("item_unit_name"));
                item.setItemUnit(iu);

                itemList.add(item);
            }
            pageModel = new PageModel();
            pageModel.setPageNo(pageNo);
            pageModel.setPageSize(pageSize);
            pageModel.setList(itemList);

            //根据条件取得记录数
            int totalRecorders = getTotalRecords(conn, condation);
            pageModel.setTotalRecords(totalRecorders);

        } catch (Exception e) {
            e.printStackTrace();
            throw new ApplicationException("分页查询失败");
        }finally{
            DbUtil.close(rs);
            DbUtil.close(pstmt);
        }

        return pageModel;
    }

    /**
     * 根据条件取得记录数
     * @param conn
     * @param condation
     * @return
     * @throws SQLException
     */
    private int getTotalRecords(Connection conn,String condation)throws SQLException{
        String sql = "select count(*) from t_items ";
            if(condation!=null&&!"".equals(condation)){
                sql += "where ITEM_NAME like '"+ condation +"%' ";      
            }
        //System.out.println(sql);
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        int temp=0;
        try {
            pstmt = conn.prepareStatement(sql);
            rs = pstmt.executeQuery();
            rs.next();
            temp = rs.getInt(1);
        }finally{
            DbUtil.close(rs);
            DbUtil.close(pstmt);
        }
        return temp;
    }


    public static void main(String[] args){
        Connection conn = DbUtil.getConnection();
        ItemDao itemDao = new ItemDao4SqlServerImpl();
        itemDao.findItemList(conn, 1, 5, "当");
    }

}
齐天大圣后裔啦
关注
专栏目录
Docker的分层构建
roger_zhong的博客
07-27 725
docker分层构建
Dockerfile制作的分层构建概念
Dou_Hua_Hua的博客
08-07 759
公司中的所有镜像都是要上传到harbor仓库上，一层一层的打镜像，在打的同时将镜像上传到harbor上 第一层原始系统层（ubantu/debain/centos）： 这个目录结构一定要提前设计好，我先将官方的原始系统镜像pull下来，在这层的基础之上我们会加一些常用命令 第二层常用命令层： 否则后期还要在镜像中安装命令太过于麻烦，我们将这个安装常用命令的镜像称为公司的基础镜像叫做baseimgae，后期我们在打镜像的时候就不再调用官方的了，而是直接调用baseimgae。我们会在baseimgae这个镜.
浅谈代码分层：构建模块化程序
JDWL20090304的专栏
09-18 720
浅谈代码分层：构建模块化程序 Author: Kevin Lynx Date: 4.4.2011 Contact: kevinlynx at gmail dot com 模块化的程序是怎样的程序？我们可以说一个具有明显物理结构的软件是模块化的，例如带 插件的软件，一个完整的软件由若干运行时库共同构建；也可以说一个高度面向对象的库是 模块
项目结构（分层）
weixin_34101229的博客
01-13 1052
2019独角兽企业重金招聘Python工程师标准>>> ...
【开发】springboot项目docker分层构建
飞的博客
03-08 1046
在使用dockerfile构建springboot项目时，速度较慢，用时比较长，为了加快构建docker镜像的速度，采用分层构建的方式。
Gradle父子项目构建
HELLOW，文浩
04-09 4800
Gradle对构建模块化项目提供了强大的支持，在Gradle中每一个模块都是一个项目，称之为Gradle多项目构建技术，多项目构建实现了项目模块化，降低代码耦合度，增加内聚性，本篇文章将简单介绍如何使用Gradle进行多项目构建。 1、组装多项目构建： Gradle整个项目是由一个根目录和多个模块的子目录构成，在根目录下新建build.gradle构建脚本，使用gradle projec...
Spring Boot 分层构建 Docker 镜像实战
公众号：Java后端
02-28 1068
目录一、什么是镜像分层二、SpringBoot 2.3.x 新增对分层的支持三、创建测试的 SpringBoot 应用1、Maven 中引入相关依赖和插件2、创建测试的 Controlle...
多阶段分层构建容器化Spring Boot应用程序
最新发布
静水深流
06-29 586
后续代码发生变更后，通过以上步骤，重新打包、构建新的镜像、删除已有的容器并启动新的容器，便可完成进行新代码的部署工作。如上图，需要关注configuration部分的配置以及executions中的设置，否则会导致后续分层配置的失败，本文是经过测试可使用的，大家可以直接复制即可。容器启动后，启动应用程序，需要注意的是，我们不是使用的jar -jar application.jar，而是使用的。开始支持分层构建容器化的镜像，在使用时需要注意，本文使用的spring boot的版本是：3.3.1。
express 项目分层实践详解
10-17
在开发Web应用时，合理地组织项目结构是提高代码可维护性和可扩展性的重要手段。Express，作为Node.js中流行的Web应用框架，...在阅读源代码和实践过程中，开发者可以深入理解每一层的作用，提升自己的项目构建能力。
互联网时代会计人员能力框架分层构建.pdf
07-15
文章《互联网时代会计人员能力框架分层构建》针对这一变化，提出了一个三维能力框架模型，并探讨了如何在互联网背景下提升会计人员的能力，以及如何通过教育体系的改革培养适应新时代需求的会计人才。 首先，会计...
postgresql-layered-arquitecture-node:使用NodeJS为EPAM全球培训计划构建的示例Postgres和分层Arquitecture项目
04-03
Postgresql分层的Arquitecture...使用NodeJS为EPAM全球培训计划构建的示例Postgres和分层Arquitecture项目 对于此DEMO，我使用了PostgreSQL本地实例。 用户名和密码设置为“ postgres”，更多信息在屏幕快照文件夹中。
Android开发——规划项目结构（分层，分模块，分包）
CallmeZhe的博客
03-07 1365
规划Android项目结构1.1建立AndroidLab类库，将与业务无关的逻辑转移到AndroidLab。AndroidLab至少包括五大部分：包名+ acticity,cache,net,ui,utils 。activity包里面存放的是与业务无关的Activity基类。net包里存放的是网络底层封装。cacahe包里面存放的是缓存数据的图片和图片的相关处理。ui包中存放的是自定义控件util...
SpringBoot-2-3-x分层构建Docker镜像实践，docker教程学习
m0_65321095的博客
12-24 1247
org.springframework.boot spring-boot-maven-plugin true 执行 Maven 命令，构建分层的 JAR 包，命令和平时的 Maven 构建命令相同： $ mvn install 观察 Jar 结构，可以看到里面多了 classpath.idx 与 layers.idx 两个文件： classpath.idx： 文件列出了依赖的 jar 包列表，到时候会按照这个顺序载入。
使用XML配置JDBC驱动
a6697238的博客
10-29 2359
XML文件作用http://www.cnblogs.com/hellojava/archive/2012/12/28/2835730.html‘xml这种文件格式由于属于树形结构，方便不同文件读取，解析XML文件过程有4中，常用的是DOM4J http://blog.csdn.net/jzhf2012/article/details/8532873建立并且配置xml文件1.可以在根目录下建立xml
学生成绩管理系统
a6697238的博客
10-16 1905
第一次写博客，算是开始码农的旅程吧，把学的小项目简单书写一下，使用MyEclipse10 + sql sever2008 + Powerdesigner完成成绩管理系统，包括数据库的使用，增删改查之类的。成绩管理系统开发流程 PowerDesigner设计表格 使用SQL SERVER2008数据库建立表格 建立JAVA项目 使用PowerDesigner设计表格PowerDesigner可以用来设
XML文件配置使用
a6697238的博客
11-19 374
XML文件读取该文件配置
使用Struts完成上传
a6697238的博客
01-20 231
Struts集成上传功能 1.ActionForm 内定义上传文件格式为 Formfile，对应jsp文件内的input输入 域格式为file，定义form表单编码类型为enctype=”multipart/form-data 2.需要引入JAR包，commons-io http://commons.apache.org/proper/commons-io/download_io.cgi
SpringBoot+Mybatis：构建高效分层Web项目与一键启动
在现代Web开发中，构建一...这篇文章详细阐述了如何通过SpringBoot和Mybatis这两个强大的框架，构建出易于维护、高效开发的SpringMVCWeb项目，同时强调了在整个开发过程中如何处理分层、配置简化以及协作问题的重要性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值