1. Maven project splitting, inheritance, aggregation
1.1 Problems in traditional project development
Engineering projects developed using Java technology, whether it is a data processing system or a Web site, with the continuous development of the project, the continuous refinement and addition of requirements, more and more codes in the project, and more and more complex package structures. When the progress of the project will encounter various problems:
1. In a traditional project, all services will be written into one project and deployed with a web application server. At this time, if a certain business operation causes the server to go down, all project services cannot be accessed.
2. The codes in different aspects are coupled with each other. At this time, when a problem occurs in a system, it is difficult to locate the cause of the problem. Even if the problem is located, it is difficult to correct the problem, and more problems may be introduced when the problem is corrected.
3. Many aspects of code are concentrated in an overall structure. It is difficult for new developers to have an intuitive feeling for the overall project, which increases the cost for novices to intervene in development. A developer who is familiar with the entire project is required to maintain the structure of the entire project ( This is often difficult to do when the project is large and the development time is long).
4. The code boundaries that developers are responsible for themselves or others are very vague, which is the easiest to encounter in complex projects. The result is that developers can easily modify the codes that others are responsible for without the person in charge of the code knowing it. Responsibility tracking Very troublesome.
Splitting a complex project into multiple modules is an important way to solve the above problems. The division of multiple modules can reduce the coupling between codes (from class-level coupling to jar package-level coupling), and each module has It can be self-explanatory (by module name or module documentation). Modules also regulate the division of code boundaries. Developers can easily determine what they are responsible for through modules.
1.2 Maven project split
I wonder if you have ever thought about why a good maven project should be split? In the face of today's Internet + industry, software projects are becoming larger and more complex, which greatly increases the cost of development and management. The splitting of projects can realize sub-module development and testing, as well as multi-thread development and management, which not only improves the reuse of engineering codes, but also improves the speed and efficiency of software development.
For example, a complete early-developed crm project needs to be split using the maven project. At this time, the dao layer can be disassembled to form an independent project. The same is true for the service layer and the web layer. split.
Link to the original text of concept explanation and pictures: https://blog.csdn.net/yerenyuan_pku/article/details/103680220
Understand the benefits of project splitting:
As can be seen from the above figure, there is a problem. If there is a bug in the dao layer in the crm project and needs to be repaired, the dao layer in the erp project and the oa project must also be modified accordingly. Repeating things like this need to be done three times ! It is not desirable, so how to solve it?
At this time, the dao layer in the crm project can be disassembled to form an independent project, and then each project can reuse this independent project.
Split the project into individual projects, and just import their coordinates when you need them in the future, which is a bit like building blocks.
Build blocks into various projects:
For a large-scale project, if we directly develop it as a project, we can only develop it by a group of people from the beginning to the end due to mutual dependence, otherwise there will be a chaotic situation where many people develop and change each other. We split the project horizontally and vertically.
The so-called horizontal split is what we usually call a three-tier architecture, which divides the project into web layer, service layer, and dao layer (the web layer is also called the presentation layer, the service layer is also called the business layer, and the dao layer is also called the persistence layer. ), which can be understood as splitting the different calling processes of a function module in the horizontal direction.
The so-called vertical split is to split multiple functional modules of a project. After the horizontal split, each functional module has been developed independently. When the project is integrated, it is necessary to have a project that can integrate these projects or modules. Engineering, this is the meaning of the so-called aggregate engineering.
1.3 Maven project aggregation
Project development is usually developed in groups and modules. After the development of each module is completed, each module needs to be aggregated and run together to run the entire project. For example, the three projects of dao, service, and web will eventually be packaged as an independent war package. run.
Take a complete early-developed crm project as an example. After dismantling the crm project into multiple sub-modules, running each module independently cannot meet the requirements of the software project. Only by integrating them all can the work be completed through division of labor and cooperation. Therefore, the parent project is required to manage each sub-module and run them together, that is, to package the three projects crm_dao, crm_service and crm_web into an independent executable war package.
It's a bit like taking the parts of a car and putting it together into a car that can drive. Below is a bunch of various parts of the car.
Assemble the various parts of the car to turn it into a car that can run.
Attention should be paid to the establishment of the aggregation project:
1. The aggregation project itself is also a Maven project, and it must have its own POM.
2. Its packaging method must be: pom.
3. A new element is introduced: modules---module.
4. Version: The version of the aggregated module is consistent with the version of the aggregated module.
5. relativePath: The value of each module is a relative directory of the current POM.
Specifies the (relative) path to find the pom.xml of this parent project. Default order: relativePath > local warehouse > remote warehouse.
No relativePath tag is equivalent to .../pom.xml, that is, it is found from the upper directory of the current pom file by default.
6. Directory name: In order to quickly locate the content conveniently, the directory where the module is located should be consistent with its artifactId (Maven agreement rather than a rigid requirement). In short, the directory where the module is located must be the same as the directory where the <module>module is located</module > Consistent.
7. Reduced content of the aggregation module: the content of the aggregation module is just a pom.xml file, which does not contain src/main/java, src/test/java and other directories, because it is only a tool to help other modules build, itself There is no real content.
8. Directories of aggregation modules and submodules: they can be parent-child classes, or parallel structures. Of course, if parallel structures are used, the POM of the aggregation module also needs to be changed accordingly.
9. If the submodule of the aggregation project is deleted after it is created, it must be deleted in the modules tab in the pom.xml of the aggregation project.
<modules>
<module>../maven-util</module>
<module>../maven-entity</module>
<module>../maven-dao</module>
<module>../maven-service</module>
<module>../maven-web</module>
</modules>Summarize:
对于聚合模块来说，它知道有哪些被聚合的模块，而对于被聚合的模块来说，它们不知道被谁聚合了，也不知道它的存在
对于继承关系的父POM来说，它不知道自己被哪些子模块继承了，对于子POM来说，它必须知道自己的父POM是谁
在一些最佳实践中我们会发现：一个POM既是聚合POM，又是父POM，这么做主要是为了方便。1.4 Inheritance of Maven projects
Similar to the inheritance of classes in Java, it is all to eliminate duplication. The subclass inherits the parent class, and the methods and properties in the parent class do not need to be defined and implemented in the subclass, and it is enough to directly call the parent class when using it. After we split the crm project, there will be a parent project (such as crm) and several sub-projects (such as crm_dao, crm_service, crm_web), and the dependencies to be used in the sub-projects can be in the pom.xml file of the parent project With dependency management, there is no need to define the version when sub-projects are developed in the future. The purpose of this is to facilitate management.
In addition to avoiding duplication, inheritance also has the advantage of making the project more secure.
Note when inheriting:
1. When it comes to inheritance, it must be a parent-child structure, so we create a parent project in the aggregation project.
2. <packaging>: As the POM of the parent module, its packaging type must also be POM.
3. Structure: The parent module is just to help us eliminate duplication, so it does not need directories such as src/main/java, src/test/java, etc.
4. A new element: <parent>, which is used in submodules.
5. Attributes of the <parent> element: <relativePath>: Indicates the relative path of the parent module POM. When building, Maven will first check the parent POM according to the relativePath. If it cannot find it, it will search from the local warehouse.
6. The default value of relativePath: ../pom.xml.
7. Submodule omits groupId and version: GroupId and version may not be declared in a submodule that uses inheritance, and the submodule will implicitly inherit these two elements of the parent module.
Two, Maven comprehensive case
For a large-scale project, in most cases, multiple functional modules of a project are split. After the split, each functional module is developed independently. When the project is integrated, it is necessary to have a The engineering of these projects or modules is the meaning of the so-called aggregation engineering.
We don't write so many modules now, but split a student module into modules according to the function of the class (three-tier architecture), and then experience the splitting, inheritance, and aggregation of projects.
2.1 Build the project structure
2.1.1 Create and manage parent project
1. Create a management parent project (maven-student), and the packaging method of Maven management projects is pom. The parent project of the management class is just a tool to help other modules build, and has no real content in itself. You can delete the src directory.
2. After the creation is complete, do the following configuration:
2.1 Modify the project packaging method to pom.
2.2 Dependency version management.
2.3 Dependency management
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.maven</groupId>
<artifactId>maven-student</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 1、修改为管理项目，packaging为pom -->
<packaging>pom</packaging>
<!-- 2、依赖版本管理：对项目中所有的依赖的版本进行管理 -->
<properties>
<!-- properties里面可以定义自定义标签 -->
<servlet.version>3.0.1</servlet.version>
<jsp.version>2.1</jsp.version>
<jstl.version>1.2</jstl.version>
<junit.version>4.12</junit.version>
<mysql.version>5.1.49</mysql.version>
</properties>
<!-- 3、依赖管理：对项目中所有的依赖进行管理 -->
<!-- 依赖管理不会引入依赖 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<!-- maven表达式获取版本 -->
<version>${servlet.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>${jsp.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>${jstl.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>2.1.2 Create tool class subproject
1. Create a tool subproject (maven-student-util).
Note: When creating a subproject, a Module is created. Right click on the parent project -> New -> Module, Module is also a Maven project.
2. The pom.xml file of the maven-student-util submodule will automatically add the parent tag to identify the parent project or parent module of the current module. And modules will be automatically added to the pom.xml file of the parent project to identify the aggregated modules.
<!-- Maven继承：子模块中的parent表示当前模块的父项目或父模块 -->
<parent>
<artifactId>maven-student</artifactId>
<groupId>com.maven</groupId>
<version>1.0-SNAPSHOT</version>
</parent><!-- 父项目管理的子模块列表：聚合 -->
<modules>
<module>maven-student-util</module>
<module>maven-student-entity</module>
</modules>3. Introduce the dependencies needed by the current module.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<!-- Maven继承：子模块中的parent表示当前模块的父项目或父模块 -->
<parent>
<artifactId>maven-student</artifactId>
<groupId>com.maven</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<!-- 子模块可以继承groupId和version等，但是artifactId不能继承 -->
<artifactId>maven-student-util</artifactId>
<!-- 配置当前模块的依赖 -->
<dependencies>
<!-- 子模块中配置依赖无需再配置版本，都是参照父项目的版本号 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</project>2.1.3 Create entity class subprojects
Create an entity class subproject (maven-student-entity) and introduce the dependencies needed by the current module.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>maven-student</artifactId>
<groupId>com.maven</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>maven-student-entity</artifactId>
<!-- 配置当前模块的依赖 -->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</project>2.1.4 Create Persistence Layer Subproject
Create a persistence layer subproject (maven-student-dao) and introduce the dependencies needed by the current module.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>maven-student</artifactId>
<groupId>com.maven</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>maven-student-dao</artifactId>
<!-- 配置当前模块的依赖 -->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
<!-- 持久层需要用到工具类,那么就需要引入自己的模块,无需安装 -->
<!-- 这里没有定义版本,是因为在父项目中对自己的模块进行依赖管理了 -->
<dependency>
<groupId>com.maven</groupId>
<artifactId>maven-student-util</artifactId>
</dependency>
<dependency>
<groupId>com.maven</groupId>
<artifactId>maven-student-entity</artifactId>
</dependency>
</dependencies>
</project>Dependency management is performed on its own modules in the parent project, and there is no need to define versions in submodules.
<dependency>
<groupId>com.maven</groupId>
<artifactId>maven-student-util</artifactId>
<!-- Maven表达式中的对象project -->
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.maven</groupId>
<artifactId>maven-student-entity</artifactId>
<version>${project.version}</version>
</dependency>2.1.5 Create a business layer subproject
Create a business layer sub-project (maven-student-service) and introduce the dependencies needed by the current module.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>maven-student</artifactId>
<groupId>com.maven</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>maven-student-service</artifactId>
<dependencies>
<dependency>
<groupId>com.maven</groupId>
<artifactId>maven-student-dao</artifactId>
</dependency>
</dependencies>
</project>2.1.6 Create presentation subproject
1. Create a presentation layer sub-project (maven-student-web), and modify the project packaging method to war.
2. Introduce the dependencies needed by the current module
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>maven-student</artifactId>
<groupId>com.maven</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>maven-student-web</artifactId>
<packaging>war</packaging>
<dependencies>
<dependency>
<groupId>com.maven</groupId>
<artifactId>maven-student-service</artifactId>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>
</dependencies>
</project>Finally, the contents of the parent project's pom.xml file:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.maven</groupId>
<artifactId>maven-student</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 父项目管理的子模块列表：聚合 -->
<modules>
<module>maven-student-util</module>
<module>maven-student-entity</module>
<module>maven-student-dao</module>
<module>maven-student-service</module>
<module>maven-student-web</module>
</modules>
<!-- 1、修改为管理项目，packaging为pom -->
<packaging>pom</packaging>
<!-- 2、依赖版本管理：对项目中所有的依赖的版本进行管理 -->
<properties>
<!-- properties里面可以定义自定义标签 -->
<servlet.version>3.0.1</servlet.version>
<jsp.version>2.1</jsp.version>
<jstl.version>1.2</jstl.version>
<junit.version>4.12</junit.version>
<mysql.version>5.1.38</mysql.version>
</properties>
<!-- 3、依赖管理：对项目中所有的依赖进行管理 -->
<!-- 依赖管理不会引入依赖 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<!-- maven表达式获取版本 -->
<version>${servlet.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>${jsp.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>${jstl.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>com.maven</groupId>
<artifactId>maven-student-util</artifactId>
<!-- Maven表达式中的对象project -->
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.maven</groupId>
<artifactId>maven-student-entity</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.maven</groupId>
<artifactId>maven-student-dao</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.maven</groupId>
<artifactId>maven-student-service</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>2.1.7 about modules
modules can be added or not. But modules have an advantage. After defining modules, we execute the life cycle through the parent project, and all sub-modules will execute the corresponding life cycle.
Note: If we have no dependencies between modules, then execute them in the order of aggregation configuration; if there are dependencies, the dependent ones must be built first.
Compile via parent project:
2.2 Project backend implementation
2.2.1 Create student table
Create a student table under the test library of the MySQL database. The fields of the student table are as follows:
2.2.2 DBUtils tool class implementation
Create the com.maven.util package in the tool class subproject, and create the DBUtils tool class.
The DBUtils code is as follows:
package com.maven.util;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/*
* JDBC工具类的高度封装
* */
public class DBUtils {
/*
* private 为了不让外部调用
* static 因为要在static代码块或方法中使用
* final 不允许修改
* */
private static final String driverName = "com.mysql.jdbc.Driver";
private static final String url = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8";
private static final String userName = "root";
private static final String userPwd = "root";
private static Connection connection;
private static PreparedStatement preparedStatement;
private static ResultSet resultSet;
/*
* 注册数据库驱动,注册驱动只需要执行一次即可
* static静态代码块,在类加载的时候有且仅执行一次
* */
static {
try {
Class.forName(driverName);
} catch (ClassNotFoundException e) {
System.out.println("数据库驱动加载失败!");
}
}
/*
* 获取连接
* */
public static Connection getConnection() {
try {
connection = DriverManager.getConnection(url, userName, userPwd);
} catch (SQLException throwables) {
System.out.println("数据库连接获取失败!");
}
return connection;
}
/*
* 查询数据的方法
* 参数:
* String sql,要执行的sql语句
* List list,sql的参数
* 返回值:
* 不能返回ResultSet,因为资源释放之后,结果集不能在操作
* 把结果集里面的数据用另外一种形式返回即可 List<Map<String,String>>
* */
public static List<Map<String, String>> query(String sql, List list) {
List<Map<String, String>> resultList = new ArrayList<>();
// 每次执行查询,都要获取得到连接
getConnection();
// 获取执行SQL语句的PrepareStatement对象
try {
preparedStatement = connection.prepareStatement(sql);
// 给sql设置参数
for (int i = 0; i < list.size(); i++) {
// 因为不知道参数的类型,所以我们直接使用setObject(占位符索引,值); 占位符索引从1开始
preparedStatement.setObject(i + 1, list.get(i));
}
// 执行查询
resultSet = preparedStatement.executeQuery();
// 获取结果集对应的结构
ResultSetMetaData metaData = resultSet.getMetaData();
// 把resultSet转换为List<Map<String,String>>
while (resultSet.next()) {
// resultSet里面每有一条数据,就创建一个Map集合
Map<String, String> map = new HashMap<>();
// map里面的key是列名,value是列对应的值
// 结果集里面有多少列,就向map里面存储多少对值
for (int i = 1; i <= metaData.getColumnCount(); i++) {
map.put(metaData.getColumnName(i), resultSet.getString(i));
}
// 把map存储到list中
resultList.add(map);
}
} catch (SQLException throwables) {
System.out.println("SQL语句异常");
} finally {
close();
}
return resultList;
}
/*
* 增删改的方法
* 返回值: int类型,表示增、删、改的条目数
* 参数:
* String sql,要执行的sql语句
* List list,sql的参数
* */
public static int update(String sql, List list) {
int count = 0;
// 每次执行更改操作,都要获取得到连接
getConnection();
// 获取执行SQL语句的PrepareStatement对象
try {
preparedStatement = connection.prepareStatement(sql);
// 给sql设置参数
for (int i = 0; i < list.size(); i++) {
// 因为不知道参数的类型,所以我们直接使用setObject(占位符索引,值); 占位符索引从1开始
preparedStatement.setObject(i + 1, list.get(i));
}
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
System.out.println("SQL语句异常");
} finally {
close();
}
return count;
}
/*
* 释放资源
* */
public static void close() {
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException throwables) {
System.out.println("结果集关闭失败");
}
}
if (preparedStatement != null) {
try {
preparedStatement.close();
} catch (SQLException throwables) {
System.out.println("Statement关闭失败");
}
}
if (connection != null) {
try {
connection.close();
} catch (SQLException throwables) {
System.out.println("连接关闭失败!");
}
}
}
}2.2.3 Student Entity Class Implementation
Create the com.maven.entity package in the entity class subproject, and create the StudentEntity entity class.
The StudentEntity code is as follows:
package com.maven.entity;
/**
* 学生实体类
*/
public class StudentEntity {
private Integer id;
private String name;
private String sex;
private String major;
public StudentEntity() {
}
public StudentEntity(Integer id, String name, String sex, String major) {
this.id = id;
this.name = name;
this.sex = sex;
this.major = major;
}
public Integer getId() {
return id;
}
public void setId(Integer 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 String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
@Override
public String toString() {
return "StudentEntity{" +
"id=" + id +
", name='" + name + '\'' +
", sex='" + sex + '\'' +
", major='" + major + '\'' +
'}';
}
}2.2.4 Student Persistence Layer Implementation
Create the com.maven.dao package in the persistence layer subproject, and create the StudentDao interface.
Create the com.maven.dao.impl package in the persistence layer subproject, and create the StudentDaoImpl implementation class.
Note: We only implement a simple set of CRUD.
The StudentDao interface code is as follows:
package com.maven.dao;
import com.maven.entity.StudentEntity;
import java.util.List;
import java.util.Map;
/*
* 学生DAO接口
*/
public interface StudentDao {
/*
* 新增学生的方法
* @param studentEntity 包含新增学生的信息实体类
* @return int 实际插入的数量
*/
public abstract int insert(StudentEntity studentEntity);
/*
* 删除学生的方法
* @param id 删除学生的id
* @return int 实际删除的数量
*/
public abstract int delete(Integer id);
/*
* 修改学生的方法
* @param studentEntity 包含修改学生的信息实体类
* @return int
*/
public abstract int update(StudentEntity studentEntity);
/*
* 根据id查询学生的方法
* @param id 查询学生的id
* @return StudentEntity 查询到的学生信息
*/
public abstract List<Map<String, String>> query(Integer id);
/*
* 查询所有学生的方法
* @return List<StudentEntity> 查询到的所有数据
*/
public abstract List<Map<String, String>> queryAll();
}The StudentDaoImpl implementation class code is as follows:
package com.maven.dao.impl;
import com.maven.dao.StudentDao;
import com.maven.entity.StudentEntity;
import com.maven.util.DBUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
/**
* 学生DAO接口实现类
*/
public class StudentDaoImpl implements StudentDao {
@Override
public int insert(StudentEntity studentEntity) {
String sql = "insert into student(name,sex,major) values (?,?,?)";
List list = Arrays.asList(studentEntity.getName(), studentEntity.getSex(), studentEntity.getMajor());
return DBUtils.update(sql, list);
}
@Override
public int delete(Integer id) {
String sql = "delete from student where id = ?";
List list = Arrays.asList(id);
return DBUtils.update(sql, list);
}
@Override
public int update(StudentEntity studentEntity) {
String sql = "update student set name = ?,sex=?,major=? where id = ?";
List list = Arrays.asList(studentEntity.getName(), studentEntity.getSex(), studentEntity.getMajor(),studentEntity.getId());
return DBUtils.update(sql, list);
}
@Override
public List<Map<String, String>> query(Integer id) {
String sql = "select * from student where id = ?";
List list = Arrays.asList(id);
return DBUtils.query(sql,list);
}
@Override
public List<Map<String, String>> queryAll() {
String sql = "select * from student";
List list = new ArrayList();
return DBUtils.query(sql,list);
}
}2.2.5 Implementation of student business layer
Create a com.maven.service package in the business layer subproject, and create a StudentService class.
The StudentService class code is as follows:
package com.maven.service;
import com.maven.dao.StudentDao;
import com.maven.dao.impl.StudentDaoImpl;
import com.maven.entity.StudentEntity;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* 学生的业务逻辑层
*/
public class StudentService {
//创建DAO实现类对象
private StudentDao studentDao = new StudentDaoImpl();
public int insert(StudentEntity studentEntity) {
return studentDao.insert(studentEntity);
}
public int delete(Integer id) {
return studentDao.delete(id);
}
public int update(StudentEntity studentEntity) {
return studentDao.update(studentEntity);
}
public StudentEntity query(Integer id) {
StudentEntity studentEntity = null;
List<Map<String, String>> query = studentDao.query(id);
if (query.size() > 0) {
Map<String, String> stringMap = query.get(0);
studentEntity = new StudentEntity();
studentEntity.setId(Integer.parseInt(stringMap.get("id")));
studentEntity.setName(stringMap.get("name"));
studentEntity.setSex(stringMap.get("sex"));
studentEntity.setMajor(stringMap.get("major"));
}
return studentEntity;
}
public List<StudentEntity> queryAll() {
List<StudentEntity> list = new ArrayList<>();
List<Map<String, String>> query = studentDao.queryAll();
for (int i = 0; i < query.size(); i++) {
Map<String, String> stringMap = query.get(0);
StudentEntity studentEntity = new StudentEntity();
studentEntity.setId(Integer.parseInt(stringMap.get("id")));
studentEntity.setName(stringMap.get("name"));
studentEntity.setSex(stringMap.get("sex"));
studentEntity.setMajor(stringMap.get("major"));
list.add(studentEntity);
}
return list;
}
}2.2.6 Servlet Implementation of Student Presentation Layer
Servlet to query all students:
package com.maven.servlet;
import com.maven.entity.StudentEntity;
import com.maven.service.StudentService;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
/**
* 查询所有学生的Servlet
*/
@WebServlet("/student/list")
public class StudentQueryAllServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
StudentService studentService = new StudentService();
List<StudentEntity> list = studentService.queryAll();
System.out.println(list);
req.setAttribute("stuList", list);
System.out.println(req.getServletContext().getContextPath());
//在请求转发中,/表示项目根目录
req.getRequestDispatcher("/student/list.jsp").forward(req, resp);
}
}Query the student's Servlet according to the id:
package com.maven.servlet;
import com.maven.entity.StudentEntity;
import com.maven.service.StudentService;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* 根据学生id查询学生的Servlet
*/
@WebServlet("/student/query")
public class StudentQueryServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
//获取查询学生的id
int id = Integer.parseInt(req.getParameter("id"));
StudentService studentService = new StudentService();
StudentEntity studentEntity = studentService.query(id);
req.setAttribute("editStudentInfo", studentEntity);
req.getRequestDispatcher("/student/edit.jsp").forward(req, resp);
}
}Add the student's servlet:
package com.maven.servlet;
import com.maven.entity.StudentEntity;
import com.maven.service.StudentService;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* 添加学生的Servlet
*/
@WebServlet("/student/add")
public class StudentAddServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
String name = req.getParameter("name");
String sex = req.getParameter("sex");
String major = req.getParameter("major");
StudentEntity studentEntity = new StudentEntity(null, name, sex, major);
StudentService studentService = new StudentService();
int i = studentService.insert(studentEntity);
if (i > 0) {
req.setAttribute("msg", "添加成功!");
} else {
req.setAttribute("msg", "添加失败!");
}
req.getRequestDispatcher("/student/list").forward(req, resp);
}
}Servlet for removing students:
package com.maven.servlet;
import com.maven.entity.StudentEntity;
import com.maven.service.StudentService;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* 删除学生的Servlet
*/
@WebServlet("/student/delete")
public class StudentDeleteServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
//获取删除学生的id
int id = Integer.parseInt(req.getParameter("id"));
System.out.println("删除学生的id："+id);
StudentService studentService = new StudentService();
int i = studentService.delete(id);
if (i > 0) {
req.setAttribute("msg", "删除成功!");
} else {
req.setAttribute("msg", "删除失败!");
}
req.getRequestDispatcher("/student/list").forward(req, resp);
}
}Modify the student's servlet:
package com.maven.servlet;
import com.maven.entity.StudentEntity;
import com.maven.service.StudentService;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* 修改学生的Servlet
*/
@WebServlet("/student/update")
public class StudentUpdateServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
int id = Integer.parseInt(req.getParameter("id"));
String name = req.getParameter("name");
String sex = req.getParameter("sex");
String major = req.getParameter("major");
StudentEntity studentEntity = new StudentEntity(id, name, sex, major);
System.out.println(studentEntity);
StudentService studentService = new StudentService();
int i = studentService.update(studentEntity);
if (i > 0) {
req.setAttribute("msg", "修改成功!");
} else {
req.setAttribute("msg", "修改失败!");
}
req.getRequestDispatcher("/student/list").forward(req, resp);
}
}2.3 Front-end implementation of the project
The directory structure is as follows:
2.3.1 Implementation of the project home page
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>这里是项目首页</h1>
<a href="${pageContext.request.contextPath}/student/list">查询所有学生信息</a>
</body>
</html>2.3.2 Student List Page Implementation
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>Title</title>
<style>
table, td, th {
border: 1px solid black;
border-collapse: collapse;
}
table {
width: 600px;
}
tr {
height: 40px;
}
</style>
</head>
<body>
<h2>所有学生的信息: ${msg}</h2>
<table>
<tr>
<th>学号</th>
<th>姓名</th>
<th>性别</th>
<th>专业</th>
<th>操作</th>
</tr>
<c:forEach items="${stuList}" var="stu">
<tr>
<td>${stu.id}</td>
<td>${stu.name}</td>
<td>${stu.sex}</td>
<td>${stu.major}</td>
<td>
<a href="${pageContext.request.contextPath}/student/delete?id=${stu.id}">删除</a>
<%--先根据id查询学生信息，然后跳转到修改页面--%>
<a href="${pageContext.request.contextPath}/student/query?id=${stu.id}">修改</a>
</td>
</tr>
</c:forEach>
</table>
</body>
</html>2.3.3 Modify student page implementation
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h2>修改学生信息</h2>
<form action="${pageContext.request.contextPath}/student/update" method="post">
<p>
学号: <input type="text" name="id" value="${editStudentInfo.id}" readonly>
</p>
<p>
姓名: <input type="text" name="name" value="${editStudentInfo.name}">
</p>
<p>
性别:
<c:if test="${editStudentInfo.sex == '男'}">
<input type="radio" name="sex" value="男" checked> 男
<input type="radio" name="sex" value="女"> 女
</c:if>
<c:if test="${editStudentInfo.sex == '女'}">
<input type="radio" name="sex" value="男"> 男
<input type="radio" name="sex" value="女" checked> 女
</c:if>
</p>
<p>
专业: <input type="text" name="major" value="${editStudentInfo.major}">
</p>
<p>
<button type="submit">修改</button>
</p>
</form>
</body>
</html>2.3.4 Add student page implementation
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h2>添加学生信息</h2>
<form action="${pageContext.request.contextPath}/student/add" method="post">
<p>
姓名: <input type="text" name="name">
</p>
<p>
性别:
<input type="radio" name="sex" value="男" checked> 男
<input type="radio" name="sex" value="女"> 女
</p>
<p>
专业: <input type="text" name="major">
</p>
<p>
<button type="submit">新增</button>
</p>
</form>
</body>
</html>