连接mysql数据库生成pojo实体类及dao包,service包,servlet包的简易框架

最新推荐文章于 2023-09-13 21:03:51 发布
最新推荐文章于 2023-09-13 21:03:51 发布
阅读量601 收藏
点赞数 1
分类专栏： mysql工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45785118/article/details/107965094
版权

连接mysql数据库后在指定包下生成pojo实体类,dao层,service层,servlet层的简易代码
其中需要配置数据库的相关信息以及配置source root及目标包的绝对路径

在这里插入图片描述
运行效果如下,

运行效果
在这里插入图片描述

package utils;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;


public class SqlUtil_2 {
    /**
     * 数据库配置信息
     */
    private static String url = "jdbc:mysql://127.0.0.1:3306/travel?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC";
    private static String username = "root";
    private static String password = "123456";
    /**
     * 配置蓝色文件夹,即source root的绝对路径
     */
    private static String sourceRootAbsolutePath = "D:\\MyProject\\getSqlPojo\\src\\main\\java";
    public static void main(String[] args) throws IOException {
        SqlUtil_2.buildALL("D:\\MyProject\\getSqlPojo\\src\\main\\java\\com\\dgk\\test");
    }
    /**
     * 表类
     */
    static class Table {
        /**
         * 表名
         */
        public String tableName;
        /**
         * 表中的字段名
         */
        public ArrayList<String> colNames;
        /**
         * 表中的字段类型
         */
        public ArrayList<String> colTypes;

        /**
         * 构造方法
         */
        public Table(String tableName) {
            this.tableName = tableName;
            colNames = new ArrayList<String>();
            colTypes = new ArrayList<String>();
        }
    }
    /**
     * 连接对象
     */
    private static Connection connection;
    /**
     * sql语句执行对象
     */
    private static PreparedStatement preparedStatement;
    /**
     * 存储表对象的数组
     */
    private static ArrayList<Table> tables = new ArrayList<>();
    /**
     * sql数据类型 : java数据类型
     */
    private static Map<String, String> typeMapping = new HashMap<>();

    static {
        //获取数据库名称
        String database = url.split("/")[url.split("/").length-1].split("[?]")[0];
        /**
         * 此处类型可能不全面,后面根据需要补充
         * */
        typeMapping.put("INT", "Integer");
        typeMapping.put("VARCHAR", "String");
        typeMapping.put("DATE", "Date");
        typeMapping.put("DECIMAL", "BigDecimal");
        typeMapping.put("DOUBLE", "Double");
        typeMapping.put("DATETIME", "Timestamp");
        try {
            /**获取数据库连接对象*/
            connection = DriverManager.getConnection(url, username, password);
            /**
             * 获取结果集元数据
             * 获取所有表的名称
             * */
            DatabaseMetaData metaData = connection.getMetaData();
            //System.out.println(metaData.getDatabaseProductName());
            ResultSet tableSet = metaData.getTables(database, null, null, new String[]{"TABLE"});
            while (tableSet.next()) {
                //判断是否为test_db数据库
                //if (database.equals(tableSet.getString(1))) {
                //添加表名
                String tableName = tableSet.getString("TABLE_NAME");
                //首字母大写
                tableName = tableName.substring(0, 1).toUpperCase() + tableName.substring(1);
                tables.add(new Table(tableName));
                //}
            }
            for (Table table : tables) {
                String tableName = table.tableName;
                preparedStatement = connection.prepareStatement("select * from " + tableName);
                //结果集元数据
                ResultSetMetaData resultSetMetaData = preparedStatement.getMetaData();
                for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
                    String colName = resultSetMetaData.getColumnName(i);//字段名
                    String colType = resultSetMetaData.getColumnTypeName(i);//字段类型
                    colType = typeMapping.get(colType);//转为java数据类型
                    table.colNames.add(colName);
                    table.colTypes.add(colType);
                }
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            try {
                //释放资源
                preparedStatement.close();
                connection.close();
                for (Table table : tables) {
                    System.out.println("表名:" + table.tableName);
                    System.out.println("--->字段名:" + table.colNames);
                    System.out.println("--->字段类型:" + table.colTypes);
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

    /**
     * 构建pojo类
     *
     * @param absolutePath 构建pojo类的绝对路径
     * @throws IOException
     */
    public static void buildPojo(String absolutePath) throws IOException {
        File pojoFile = new File(absolutePath);
        //判断文件夹是否存在
        if (!pojoFile.exists()) {
            pojoFile.mkdirs();
        }
        //获取路径
        String pojoPath = pojoFile.getAbsolutePath() + "\\";
        for (Table table : tables) {
            String tableName = table.tableName;
            File file = new File(pojoPath + tableName + ".java");
            if (!file.exists()) {
                file.createNewFile();
                FileWriter fileWriter = new FileWriter(file, true);
                /**开始写文件*/
                /**写入包路径*/
                Integer delta = sourceRootAbsolutePath.length();
                String packagePath = pojoPath.substring(delta+1);
                if (packagePath.contains("\\")) {
                    packagePath = packagePath.replace("\\", ".");
                }
                if (packagePath.endsWith(".")) {
                    packagePath = packagePath.substring(0, packagePath.length() - 1);
                }
                fileWriter.write("package " + packagePath + ";\n");
                /**导包*/
                ArrayList<String> colNames = table.colNames;
                ArrayList<String> colTypes = table.colTypes;
                if (colTypes.contains("BigDecimal")) {
                    fileWriter.write("import java.math.BigDecimal;\n");
                }
                if (colTypes.contains("Date")) {
                    fileWriter.write("import java.util.Date;\n");
                }
                if (colTypes.contains("Timestamp")) {
                    fileWriter.write("import java.security.Timestamp;\n");
                }
                fileWriter.write("public class " + tableName + " {\n");
                //填充属性
                for (int i = 0; i < colNames.size(); i++) {
                    fileWriter.write("    private " + colTypes.get(i) + " " + colNames.get(i) + ";\n");
                }
                //填充getter&setter
                for (int i = 0; i < colNames.size(); i++) {
                    String colName = colNames.get(i);
                    String colType = colTypes.get(i);
                    //写入set方法
                    String set = "set" + colName.substring(0, 1).toUpperCase() + colName.substring(1);
                    fileWriter.write("    public void " + set + "(" + colType + " " + colName + ") {\n" +
                            "        this." + colName + " = " + colName + ";\n" +
                            "    }\n");
                    //写入get方法
                    String get = "get" + colName.substring(0, 1).toUpperCase() + colName.substring(1);
                    fileWriter.write("    public " + colType + " " + get + "() {\n" +
                            "        return " + colName + ";\n" +
                            "    }\n");
                }
                //写入toString方法
                String str = "    @Override\n" +
                        "    public String toString() {\n" +
                        "        return \"" + tableName + "{\" +" + "\n";
                for (int i = 0; i < colNames.size(); i++) {
                    String colName = colNames.get(i);
                    String colType = colTypes.get(i);
                    if (i != colNames.size() - 1) {
                        if ("String".equals(colType)) {
                            str += "                " + "\"" + colName + "='\" + " + colName + " + '\\'' + \",\"+" + "\n";
                        } else {
                            str += "                " + "\"" + colName + "=\" + " + colName + " + \", \"+" + "\n";
                        }
                        continue;
                    }
                    if ("String".equals(colType)) {
                        str += "                " + "\"" + colName + "='\" + " + colName + " + '\\''" + "\n";
                    } else {
                        str += "                " + "\"" + colName + "=\" + " + colName + "\n";
                    }
                }
                str += "                " + "+'}';\n" + "    }\n";
                fileWriter.write(str);
                fileWriter.write("}");
                fileWriter.close();
            }
        }
    }

    /**
     * 构建接口
     *
     * @param absolutePath 构建接口的包的绝对路径
     * @param addImpl      是否添加实现类
     * @throws IOException
     */
    public static void buildDao(String absolutePath, Boolean addImpl) throws IOException {
        File daoFile = new File(absolutePath);
        //判断文件夹是否存在
        if (!daoFile.exists()) {
            daoFile.mkdirs();
        }
        //获取路径
        String daoPath = daoFile.getAbsolutePath() + "\\";
        for (Table table : tables) {
            String tableName = table.tableName;
            File file = new File(daoPath + tableName + "Dao.java");
            if (!file.exists()) {
                file.createNewFile();
                FileWriter fileWriter = new FileWriter(file, true);
                /**开始写文件*/
                /**写入包路径*/
                Integer delta = sourceRootAbsolutePath.length();
                String packagePath = daoPath.substring(delta+1);
                if (packagePath.contains("\\")) {
                    packagePath = packagePath.replace("\\", ".");
                }
                if (packagePath.endsWith(".")) {
                    packagePath = packagePath.substring(0, packagePath.length() - 1);
                }
                fileWriter.write("package " + packagePath + ";\n");
                /**写接口*/
                fileWriter.write("public interface " + tableName + "Dao {\n");
                fileWriter.write("    \n");
                fileWriter.write("}");
                fileWriter.close();
            }
        }
        /**添加实现类*/
        if (addImpl) {
            String daoImplPath = daoPath + "impl\\";
            File mapperImplFile = new File(daoImplPath);
            //判断文件夹是否存在
            if (!mapperImplFile.exists()) {
                mapperImplFile.mkdirs();
            }
            for (Table table : tables) {
                String tableName = table.tableName;
                File file = new File(daoImplPath + tableName + "DaoImpl.java");
                if (!file.exists()) {
                    file.createNewFile();
                    FileWriter fileWriter = new FileWriter(file, true);
                    /**开始写文件*/
                    /**写入包路径*/
                    String packagePath = daoImplPath.split("java\\\\")[1];
                    if (packagePath.contains("\\")) {
                        packagePath = packagePath.replace("\\", ".");
                    }
                    if (packagePath.endsWith(".")) {
                        packagePath = packagePath.substring(0, packagePath.length() - 1);
                    }
                    fileWriter.write("package " + packagePath + ";\n");
                    /**导包*/
                    fileWriter.write("import " + packagePath.split("impl")[0] + "" + tableName + "Dao;\n");
                    /**写接口*/
                    fileWriter.write("public class " + tableName + "DaoImpl implements " + tableName + "Dao {\n");
                    fileWriter.write("    \n");
                    fileWriter.write("}");
                    fileWriter.close();
                }
            }
        }
    }

    /**
     * 构建service,若需要实现类则要传入daoImplPackageAbsolutePath,不需要impl则传入null
     *
     * @param absolutePath           service包的绝对路径
     * @param daoPackageAbsolutePath dao包的绝对路径
     * @throws IOException
     */
    public static void buildService(String absolutePath, String daoPackageAbsolutePath) throws IOException {
        File serviceFile = new File(absolutePath);
        //判断文件夹是否存在
        if (!serviceFile.exists()) {
            serviceFile.mkdirs();
        }
        //获取路径
        String servicePath = serviceFile.getAbsolutePath() + "\\";
        for (Table table : tables) {
            String tableName = table.tableName;
            File file = new File(servicePath + tableName + "Service.java");
            if (!file.exists()) {
                file.createNewFile();
                FileWriter fileWriter = new FileWriter(file, true);
                /**开始写文件*/
                /**写入包路径*/
                Integer delta = sourceRootAbsolutePath.length();
                String packagePath = servicePath.substring(delta+1);
                if (packagePath.contains("\\")) {
                    packagePath = packagePath.replace("\\", ".");
                }
                if (packagePath.endsWith(".")) {
                    packagePath = packagePath.substring(0, packagePath.length() - 1);
                }
                fileWriter.write("package " + packagePath + ";\n");
                /**写接口*/
                fileWriter.write("public interface " + tableName + "Service {\n");
                fileWriter.write("    \n");
                fileWriter.write("}");
                fileWriter.close();
            }
        }
        /**添加实现类*/
        if (null != daoPackageAbsolutePath && 0 < daoPackageAbsolutePath.length()) {
            String serviceImplPath = servicePath + "impl\\";
            File serviceImplFile = new File(serviceImplPath);
            //判断文件夹是否存在
            if (!serviceImplFile.exists()) {
                serviceImplFile.mkdirs();
            }
            for (Table table : tables) {
                String tableName = table.tableName;
                File file = new File(serviceImplPath + tableName + "ServiceImpl.java");
                if (!file.exists()) {
                    file.createNewFile();
                    FileWriter fileWriter = new FileWriter(file, true);
                    /**开始写文件*/
                    /**写入包路径*/
                    String packagePath = serviceImplPath.split("java\\\\")[1];
                    if (packagePath.contains("\\")) {
                        packagePath = packagePath.replace("\\", ".");
                    }
                    if (packagePath.endsWith(".")) {
                        packagePath = packagePath.substring(0, packagePath.length() - 1);
                    }
                    fileWriter.write("package " + packagePath + ";\n");
                    /**导包*/
                    fileWriter.write("import " + packagePath.split("impl")[0] + "" + tableName + "Service;\n");
                    /**
                     * 此处应该导入dao实现类的包,但是
                     */
                    String daoPath = daoPackageAbsolutePath.split("java\\\\")[1];
                    if (daoPath.contains("\\")) {
                        daoPath = daoPath.replace("\\", ".");
                    }
                    if (daoPath.endsWith(".")) {
                        daoPath = daoPath.substring(0, daoPath.length() - 1);
                    }
                    //接口
                    fileWriter.write("import " + daoPath + "." + tableName + "Dao;\n");
                    //实现类
                    fileWriter.write("import " + daoPath + ".impl." + tableName + "DaoImpl;\n");
                    /**写实现*/
                    fileWriter.write("public class " + tableName + "ServiceImpl implements " + tableName + "Service {\n");
                    String tableLowerName = tableName.substring(0, 1).toLowerCase() + tableName.substring(1);
                    fileWriter.write("private " + tableName + "Dao " + tableLowerName + "Dao = new " + tableName + "DaoImpl();\n");
                    fileWriter.write("    \n");
                    fileWriter.write("}");
                    fileWriter.close();
                }
            }
        }
    }

    /**
     * 构建servlet(继承BaseServlet)
     * @param absolutePath servlet包的绝对路径
     * @param servicePackageAbsolutePath service包的绝对路径
     * @throws IOException
     */
    public static void buildServlet(String absolutePath, String servicePackageAbsolutePath)throws IOException{
        File servletFile = new File(absolutePath);
        //判断文件夹是否存在
        if (!servletFile.exists()) {
            servletFile.mkdirs();
        }
        //获取路径
        String servletPath = servletFile.getAbsolutePath() + "\\";
        /**获取包路径*/
        Integer delta = sourceRootAbsolutePath.length();
        String packagePath = servletPath.substring(delta+1);
        if (packagePath.contains("\\")) {
            packagePath = packagePath.replace("\\", ".");
        }
        if (packagePath.endsWith(".")) {
            packagePath = packagePath.substring(0, packagePath.length() - 1);
        }
        for (Table table : tables) {
            String tableName = table.tableName;
            File file = new File(servletPath + tableName + "Servlet.java");
            if (!file.exists()) {
                file.createNewFile();
                FileWriter fileWriter = new FileWriter(file, true);
                /**开始写文件*/
                /**导包*/
                fileWriter.write("package " + packagePath + ";\n");
                String servicePath = servicePackageAbsolutePath.split("java\\\\")[1];
                if (servicePath.contains("\\")) {
                    servicePath = servicePath.replace("\\", ".");
                }
                if (servicePath.endsWith(".")) {
                    servicePath = servicePath.substring(0, servicePath.length() - 1);
                }
                //接口
                fileWriter.write("import " + servicePath + "." + tableName + "Service;\n");
                //实现类
                fileWriter.write("import " + servicePath + ".impl." + tableName + "ServiceImpl;\n");
                fileWriter.write("import javax.servlet.annotation.WebServlet;\n");
                String tableLowerName = tableName.substring(0, 1).toLowerCase() + tableName.substring(1);
                fileWriter.write("@WebServlet(\"/"+tableLowerName+"/*\")\n");
                fileWriter.write("public class "+tableName+"Servlet extends BaseServlet{\n");
                fileWriter.write("private "+tableName+"Service "+tableLowerName+"Service = new "+tableName+"ServiceImpl();\n");
                fileWriter.write("    \n");
                fileWriter.write("}");
                fileWriter.close();
            }
        }
        //构建baseServlet
        File file = new File(servletPath + "BaseServlet.java");
        if (!file.exists()) {
            file.createNewFile();
            FileWriter fileWriter = new FileWriter(file, true);
            /**开始写文件*/
            /**导包*/
            fileWriter.write("package " + packagePath + ";\n");
            fileWriter.write("import javax.servlet.ServletException;\n" +
                    "import javax.servlet.http.HttpServlet;\n" +
                    "import javax.servlet.http.HttpServletRequest;\n" +
                    "import javax.servlet.http.HttpServletResponse;\n" +
                    "import java.io.IOException;\n" +
                    "import java.lang.reflect.InvocationTargetException;\n" +
                    "import java.lang.reflect.Method;\n" +
                    "\n" +
                    "/**\n" +
                    " * @Author: dgk1024\n" +
                    " * @Date: 2020/7/23-17:01\n" +
                    " * @Description: 在这完成方法的分发\n" +
                    " */\n" +
                    "//不需要被访问到\n" +
                    "public class BaseServlet extends HttpServlet {\n" +
                    "    @Override\n" +
                    "    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {\n" +
                    "        /**\n" +
                    "         * 方法的分发:\n" +
                    "         *  1. 获取请求的路径\n" +
                    "         *  2. 获取方法的名称\n" +
                    "         *  3. 获取方法对象Method\n" +
                    "         *  4. 执行方法\n" +
                    "         *  (利用了反射相关知识)\n" +
                    "         */\n" +
                    "        //获取请求参数\n" +
                    "        String uri =request.getRequestURI();\n" +
                    "        //获取方法名称\n" +
                    "        String methodName = uri.substring(uri.lastIndexOf(\"/\")+1);\n" +
                    "        try {\n" +
                    "            //获取执行方法class对象\n" +
                    "            //Method getMethod(String name,类<?>...parameterTypes)\n" +
                    "            Method method = this.getClass().getMethod(\n" +
                    "                    methodName,\n" +
                    "                    HttpServletRequest.class,\n" +
                    "                    HttpServletResponse.class\n" +
                    "            );\n" +
                    "            //谁调用BaseServlet,BaseServlet代表谁\n" +
                    "            method.invoke(\n" +
                    "                    this,\n" +
                    "                    request,\n" +
                    "                    response\n" +
                    "            );\n" +
                    "        } catch (IllegalAccessException e) {\n" +
                    "            e.printStackTrace();\n" +
                    "        } catch (InvocationTargetException e) {\n" +
                    "            e.printStackTrace();\n" +
                    "        } catch (NoSuchMethodException e) {\n" +
                    "            e.printStackTrace();\n" +
                    "        }\n" +
                    "    }\n" +
                    "}");
            fileWriter.close();
        }
    }
    /**
     * 给定一个包的绝对路径,在当前包下生成pojo包,service包,servlet包
     * @param basePackageAbsolutePath
     * @throws IOException
     */
    public static void buildALL(String basePackageAbsolutePath) throws IOException {
        String pojoPath = basePackageAbsolutePath + "\\pojo";
        buildPojo(pojoPath);
        String daoPath = basePackageAbsolutePath + "\\dao";
        buildDao(daoPath, true);
        String servicePath = basePackageAbsolutePath + "\\service";
        buildService(servicePath, daoPath);
        String servletPath = basePackageAbsolutePath + "\\servlet";
        buildServlet(servletPath, servicePath);
    }
    public static void buildMapperXml(String absolutePath) {
        File mapperFile = new File(absolutePath);
        //判断文件夹是否存在
        if (!mapperFile.exists()) {
            mapperFile.mkdirs();
        }
    }
}
dgk1024
关注
专栏目录
Java ee 设计购物商城 源代码 数据库
05-22
7. **实体类（Entity Classes）**：如果使用了ORM（对象关系映射）框架如Hibernate或MyBatis，那么会有对应的实体类来映射数据库表。 在"数据库"目录下，我们可能找到数据库脚本、数据备份或者数据库连接配置信息。...
一步学会创建 Servlet（包含修改Servlet模板）
于小猿的博客
05-24 1642
## 什么是Servlet ？ 1、通俗来讲，Servlet就是一个特殊的类，这个类可以专门用来接收网络请求，网络请求就是前台页面提交的东西，需要后台进行数据处理，这个步骤叫请求（request），后台把信息回应给前台，这个步骤叫响应（response），这两个步骤的信息交换都是通过Servlet进行的。 2、要想做一个完完整整的网站，这个网站必须有前台、有后台、有数据库，只有这三部分结合在一起，才能算是一个项目。前台页面和后台之间的联系靠的就是Servlet。 ![在这里插入图片描述](https:..
酒店管理系统_02-Servlet版本-mysql数据库（使用方法封装自动创建数据表）
知识林www.zslin.com
07-03 1321
本小节主要讲述：     1、使用JDBC链接Mysql数据库；     2、使用方法封装自动创建数据表 视频信息：     1、时长：28分13秒     2、大小：61.7MB 视频及源代码：     1、视频地址：http://www.zslin.com/web/blog/show/14
自动创建servlet，实现网页提交数据与数据库的交互
qq_36067033的博客
07-05 6493
昨天初学Servlet，我采用的是手动创建servlet类，但日常开发中，基本上都用自动创建，自动创建更方便快捷，不用手动继承HttpServlet类，不用去web.xml文件中注册该servlet类，可以更高效的开发。昨天的servlet中我重写了 service（）方法，对于页面数据的2种提交方式（get和Post）提交的数据未做区分处理，这是不规范不严密的，实际开发中我们基本不用servic
Maven的Web项目中pojo层、Dao层、service层、servlet层、filter层实现一次登录操作
qq_43880100的博客
07-18 2907
Maven的Web项目中pojo层、Dao层、service层、servlet层、filter层实现一次登录操作。学习阶段的操作。供自己随时复习，主要是BaseDao的编写，后续工作中开发会常用。
SpringMVC 01 简介和回顾Servlet
小哞^同^学的技术博客
07-14 193
MVC：三层架构，视图层、控制层、模型层（dao、pojo、service）。而 SpringMVC 就是 Spring 版本的 MVC，是为了 方便 我们开发 WEB 项目的 框架。再牛逼的 WEB 框架，底层的核心 也都是 servlet，所以 学会 servlet 原生态 的 开发 web 程序 是很重要的。：pojo 的拆分类，就是 也是实体类，只不过 删掉了 一些 原有的属性，保留了 关键核心的属性。常用在 前端领域。 再新建 一个 空的 子 maven 模块。 3. 添加 WEB 框架支
CSGC.rar_capitalz75_java_propertyQDZ_servlet jsp_threadcdn
09-21
3. **分层架构**: 描述中提到了"pojo/dao/daoimpl/service/serviceImpl/servlet/jsp"，这是典型的三层架构，包括模型（Model）、控制（Controller）和视图（View）。POJO（Plain Old Java Object）是简单的Java对象...
java基于MySQL的学生管理系统
04-03
- **POJO（Plain Old Java Object）**：简单Java对象，用于表示学生实体类，包含属性和getter/setter方法。 2. **MySQL数据库** - **表结构设计**：创建学生表，包括ID（主键）、姓名、性别、年龄、班级等字段。 ...
Java Web图书管理系统（附上MySQL数据库）
05-25
- DAO（Data Access Object）类：封装数据库操作，如增删改查的实现。 此外，为了保证系统的健壮性和安全性，我们还需要关注错误处理、事务管理、权限控制等方面的设计。例如，使用异常处理机制来捕获运行时错误，...
大三软件工程项目：基于SSM和MySQL的博客系统Java源码下载.zip
09-10
这是一个典型的大学大三软件工程项目的源码包，主要基于Java的Spring、SpringMVC和MyBatis（简称SSM）框架以及MySQL数据库构建一个博客系统。这个项目对于学习Java Web开发，尤其是SSM整合和数据库设计的学生来说，...
dao+service+servlet+jsp实现留言板(添加、查看)
11-08
运用MVC模式以及servlet、jsp技术实现留言板添加、查看
java框架 jetty_深入Jetty源码之Servlet框架及实现(Servlet、Filter、Registration)
weixin_42394656的博客
02-28 158
publicinterfaceServlet{// Servlet Container在创建一个Servlet后调用该方法，并传入ServletConfig实例，从而用户可以在这个方法中做一些自定义的初始化工作，如初始化数据库连接等。// 并且Servlet Container可以保证一个Servlet实例init方法之后被调用一次，但是对一个Servlet类init方法可能会被多次调用，因...
使用jsp和servlet实现简单的信息管理系统(二)（pojo和dao）
weixin_44007988的博客
11-11 413
使用jsp和servlet实现简单的信息管理系统(二)（pojo和dao） package com.ning.pojo; import java.util.Objects; public class User { private int uid; private String uname; private String pwd; private String ...
JavaEE入门之Servlet——分层开发、请求转发与重定向、Cookie
最新发布
qq_52999405的博客
09-13 235
分层开发的基本分类及作用、请求转发的使用及特点、请求重定向的使用及特点、Cookie的使用、特点以及相关属性的设置
1、spring-boot配置自动生成dao层 mapper pojo实体类
weixin_39309918的博客
08-06 1542
java 自动化生成
Java Web基础——Controller+Dao+Service+Filter+Pojo+Utils+Vo各层意思
cat marshal的博客
07-17 3928
1. Controller/Service/DAO简介： Controller是管理业务（Service）调度和管理跳转的。 Service是管理具体的功能的。 Controller只负责管理，而Service负责实施。 DAO只完成增删改查，虽然可以1-n，n-n，1-1关联，模糊、动态、子查询都可以。但是无论多么复杂的查询，dao只是封装增删改查。至于增删查改如何去实现一...
Pojo层，Dao层，Mapper层，Service层，Controller层
qq_46423017的博客
10-29 4606
Pojo层（model层）： Dao层（mapper）： Service层（定义接口）： controller层（处理前台发送的请求）： util层（工具类）： VO层（方便前端获取数据）： Filter层（对用户请求的预处理）： 业务逻辑：
8、什么是JavaWeb三层架构思想以及如何使用Servlet
CurryISGod的博客
07-11 551
如何理解三层架构，学会如何使用servlet
Java--代码各层级介绍（controller、service、mapper、po、vo等）
MinggeQingchun的博客
07-04 7915
要了解各层作用，首先整体看下架构图 架构图：MVC模型： Java的(dao、service、controller)解释 1、dao（mapper）层：数据访问层 dao层属于一种比较底层，比较基础的操作，具体到对于某个表的增删改查，也就是说某个DAO一定是和数据库的某一张表一 一对应的，其中封装了增删改查基本操作，建议DAO只做原子操作，增删改查。 负责与数据库进行联络的一些任务都封装在此，dao层的设计首先是设计dao层的接口，然后在Spring的配置文件中定义此接口的实现类，然后就可以再模块
JavaWeb项目搭建：导包、建包与数据库连接
导包是项目初始化的重要步骤，特别是对于依赖于外部库的项目，如使用MySQL数据库时，我们需要引入相应的JDBC驱动包。Maven仓库是获取这些依赖的一个常见途径，开发者可以在这里找到所需的jar包或依赖的坐标，然后将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值