员工角度开发流程（基于接口）
1. 数据库设计
首先创建数据库和表结构，并插入接近真实的测试数据：
```sql
CREATE DATABASE dvd_management;
USE dvd_management;
CREATE TABLE dvd (
id INT PRIMARY KEY AUTO_INCREMENT,
title VARCHAR(100) NOT NULL,
director VARCHAR(50),
main_actor VARCHAR(50),
publish_date DATE,
status INT DEFAULT 1 COMMENT '1-可借 2-已借出'
);
INSERT INTO dvd (title, director, main_actor, publish_date, status) VALUES
('肖申克的救赎', '弗兰克·德拉邦特', '蒂姆·罗宾斯', '1994-09-23', 1),
('阿甘正传', '罗伯特·泽米吉斯', '汤姆·汉克斯', '1994-06-23', 2),
('泰坦尼克号', '詹姆斯·卡梅隆', '莱昂纳多·迪卡普里奥', '1997-12-19', 1);
```
2. 创建实体类
```java
package cn.jr.pojo;
import java.util.Date;
public class Dvd {
private Integer id;
private String title;
private String director;
private String mainActor;
private Date publishDate;
private Integer status;
// 构造方法
public Dvd() {}
public Dvd(Integer id, String title, String director, String mainActor, Date publishDate, Integer status) {
this.id = id;
this.title = title;
this.director = director;
this.mainActor = mainActor;
this.publishDate = publishDate;
this.status = status;
}
// Getter和Setter方法
public Integer getId() { return id; }
public void setId(Integer id) { this.id = id; }
public String getTitle() { return title; }
public void setTitle(String title) { this.title = title; }
public String getDirector() { return director; }
public void setDirector(String director) { this.director = director; }
public String getMainActor() { return mainActor; }
public void setMainActor(String mainActor) { this.mainActor = mainActor; }
public Date getPublishDate() { return publishDate; }
public void setPublishDate(Date publishDate) { this.publishDate = publishDate; }
public Integer getStatus() { return status; }
public void setStatus(Integer status) { this.status = status; }
@Override
public String toString() {
return "Dvd{" +
"id=" + id +
", title='" + title + '\'' +
", director='" + director + '\'' +
", mainActor='" + mainActor + '\'' +
", publishDate=" + publishDate +
", status=" + status +
'}';
}
}
```
3. 数据库工具类
```java
package cn.jr.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DBHelper {
private static final String DRIVER = "com.mysql.cj.jdbc.Driver";
private static final String URL = "jdbc:mysql://localhost:3306/dvd_management?useSSL=false&serverTimezone=UTC";
private static final String USERNAME = "root";
private static final String PASSWORD = "123456";
static {
try {
Class.forName(DRIVER);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static Connection getConnection() {
Connection conn = null;
try {
conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
public static void closeConnection(Connection conn) {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
```
4. DAO层接口
```java
package cn.jr.dao;
import cn.jr.pojo.Dvd;
import java.util.List;
public interface IDvdDao {
// 查询所有DVD
List<Dvd> findAllDvds();
// 根据ID查询DVD
Dvd findDvdById(Integer id);
// 添加DVD
int addDvd(Dvd dvd);
// 更新DVD
int updateDvd(Dvd dvd);
// 删除DVD
int deleteDvd(Integer id);
// 根据标题模糊查询
List<Dvd> findDvdsByTitle(String title);
}
```
5. DAO层实现类
```java
package cn.jr.dao.impl;
import cn.jr.dao.IDvdDao;
import cn.jr.pojo.Dvd;
import cn.jr.util.DBHelper;
import java.sql.;
import java.util.ArrayList;
import java.util.List;
public class DvdDaoImpl implements IDvdDao {
@Override
public List<Dvd> findAllDvds() {
List<Dvd> dvdList = new ArrayList<>();
Connection conn = DBHelper.getConnection();
String sql = "SELECT FROM dvd";
try (PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
Dvd dvd = new Dvd();
dvd.setId(rs.getInt("id"));
dvd.setTitle(rs.getString("title"));
dvd.setDirector(rs.getString("director"));
dvd.setMainActor(rs.getString("main_actor"));
dvd.setPublishDate(rs.getDate("publish_date"));
dvd.setStatus(rs.getInt("status"));
dvdList.add(dvd);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
DBHelper.closeConnection(conn);
}
return dvdList;
}
@Override
public Dvd findDvdById(Integer id) {
Dvd dvd = null;
Connection conn = DBHelper.getConnection();
String sql = "SELECT FROM dvd WHERE id = ?";
try (PreparedStatement ps = conn.prepareStatement(sql)) {
ps.setInt(1, id);
try (ResultSet rs = ps.executeQuery()) {
if (rs.next()) {
dvd = new Dvd();
dvd.setId(rs.getInt("id"));
dvd.setTitle(rs.getString("title"));
dvd.setDirector(rs.getString("director"));
dvd.setMainActor(rs.getString("main_actor"));
dvd.setPublishDate(rs.getDate("publish_date"));
dvd.setStatus(rs.getInt("status"));
}
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
DBHelper.closeConnection(conn);
}
return dvd;
}
// 其他方法实现类似，限于篇幅省略
@Override
public int addDvd(Dvd dvd) { / 实现代码 / return 0; }
@Override
public int updateDvd(Dvd dvd) { / 实现代码 / return 0; }
@Override
public int deleteDvd(Integer id) { / 实现代码 / return 0; }
@Override
public List<Dvd> findDvdsByTitle(String title) { / 实现代码 / return null; }
}
```
6. Service层接口
```java
package cn.jr.service;
import cn.jr.pojo.Dvd;
import java.util.List;
public interface IDvdService {
// 获取所有DVD
List<Dvd> getAllDvds();
// 根据ID获取DVD
Dvd getDvdById(Integer id);
// 添加DVD
boolean addDvd(Dvd dvd);
// 更新DVD
boolean updateDvd(Dvd dvd);
// 删除DVD
boolean deleteDvd(Integer id);
// 搜索DVD
List<Dvd> searchDvds(String keyword);
}
```
7. Service层实现类
```java
package cn.jr.service.impl;
import cn.jr.dao.IDvdDao;
import cn.jr.dao.impl.DvdDaoImpl;
import cn.jr.pojo.Dvd;
import cn.jr.service.IDvdService;
import java.util.List;
public class DvdServiceImpl implements IDvdService {
private IDvdDao dvdDao = new DvdDaoImpl();
@Override
public List<Dvd> getAllDvds() {
return dvdDao.findAllDvds();
}
@Override
public Dvd getDvdById(Integer id) {
return dvdDao.findDvdById(id);
}
@Override
public boolean addDvd(Dvd dvd) {
return dvdDao.addDvd(dvd) > 0;
}
@Override
public boolean updateDvd(Dvd dvd) {
return dvdDao.updateDvd(dvd) > 0;
}
@Override
public boolean deleteDvd(Integer id) {
return dvdDao.deleteDvd(id) > 0;
}
@Override
public List<Dvd> searchDvds(String keyword) {
return dvdDao.findDvdsByTitle(keyword);
}
}
```
8. 主测试类
```java
package cn.jr.test;
import cn.jr.pojo.Dvd;
import cn.jr.service.IDvdService;
import cn.jr.service.impl.DvdServiceImpl;
import java.util.List;
import java.util.Scanner;
public class DvdMain {
private static IDvdService dvdService = new DvdServiceImpl();
private static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
while (true) {
showMenu();
int choice = scanner.nextInt();
scanner.nextLine(); // 消耗换行符
switch (choice) {
case 1:
showAllDvds();
break;
case 2:
searchDvd();
break;
case 3:
addDvd();
break;
case 4:
updateDvd();
break;
case 5:
deleteDvd();
break;
case 0:
System.out.println("谢谢使用，再见！");
return;
default:
System.out.println("无效选择，请重新输入！");
}
}
}
private static void showMenu() {
System.out.println("\n===== DVD管理系统 =====");
System.out.println("1. 显示所有DVD");
System.out.println("2. 搜索DVD");
System.out.println("3. 添加DVD");
System.out.println("4. 修改DVD信息");
System.out.println("5. 删除DVD");
System.out.println("0. 退出系统");
System.out.print("请选择操作: ");
}
private static void showAllDvds() {
List<Dvd> dvdList = dvdService.getAllDvds();
System.out.println("\n===== 所有DVD信息 =====");
for (Dvd dvd : dvdList) {
System.out.println(dvd);
}
}
// 其他方法实现类似，限于篇幅省略
private static void searchDvd() { / 实现代码 / }
private static void addDvd() { / 实现代码 / }
private static void updateDvd() { / 实现代码 / }
private static void deleteDvd() { / 实现代码 / }
}
```
经理角度开发流程（标准管理）
1. 数据库设计
```sql
CREATE TABLE standard (
id INT PRIMARY KEY AUTO_INCREMENT,
std_num VARCHAR(20) NOT NULL UNIQUE,
zhname VARCHAR(100) NOT NULL,
version VARCHAR(20),
keys VARCHAR(200),
release_date DATE,
impl_date DATE,
package_path VARCHAR(200)
);
```
2. 实体类
```java
package cn.jr.pojo;
import java.util.Date;
public class Standard {
private Integer id;
private String stdNum;
private String zhname;
private String version;
private String keys;
private Date releaseDate;
private Date implDate;
private String packagePath;
// 构造方法、Getter和Setter省略
}
```
3. Service层接口
```java
package cn.jr.service;
import cn.jr.pojo.Standard;
import java.util.List;
public interface IStandardService {
// 分页多条件模糊查询
List<Standard> queryStandardByInfo(Standard st);
// 根据主键删除一条信息
boolean removeStandardById(int id);
// 添加标准
boolean addStandard(Standard st);
// 修改标准
boolean changeStandard(Standard st);
// 获取所有标准
List<Standard> getAllStandards();
// 根据ID获取标准
Standard getStandardById(int id);
}
```
4. DAO层接口
```java
package cn.jr.dao;
import cn.jr.pojo.Standard;
import java.util.List;
public interface IStandardDao {
// 多条件查询标准
List<Standard> selectByStandard(Standard st);
// 根据ID删除标准
int deleteStandardById(int id);
// 查询所有标准
List<Standard> selectAllStandards();
// 添加标准
int insertStandard(Standard st);
// 根据ID查询标准
Standard selectStandardById(int id);
// 更新标准
int updateStandard(Standard st);
}
```
5. DAO层实现类
```java
package cn.jr.dao.impl;
import cn.jr.dao.IStandardDao;
import cn.jr.pojo.Standard;
import cn.jr.util.DBHelper;
import java.sql.;
import java.util.ArrayList;
import java.util.List;
public class StandardDaoImpl implements IStandardDao {
@Override
public List<Standard> selectByStandard(Standard st) {
List<Standard> standardList = new ArrayList<>();
Connection conn = DBHelper.getConnection();
StringBuilder sql = new StringBuilder("SELECT FROM standard WHERE 1=1");
List<Object> params = new ArrayList<>();
// 动态构建SQL
if (st.getStdNum() != null && !st.getStdNum().isEmpty()) {
sql.append(" AND std_num LIKE ?");
params.add("%" + st.getStdNum() + "%");
}
if (st.getZhname() != null && !st.getZhname().isEmpty()) {
sql.append(" AND zhname LIKE ?");
params.add("%" + st.getZhname() + "%");
}
// 其他条件类似...
try (PreparedStatement ps = conn.prepareStatement(sql.toString())) {
// 设置参数
for (int i = 0; i < params.size(); i++) {
ps.setObject(i + 1, params.get(i));
}
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
Standard standard = new Standard();
// 设置属性
standardList.add(standard);
}
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
DBHelper.closeConnection(conn);
}
return standardList;
}
// 其他方法实现
// ...
}
```
6. Service层实现类
```java
package cn.jr.service.impl;
import cn.jr.dao.IStandardDao;
import cn.jr.dao.impl.StandardDaoImpl;
import cn.jr.pojo.Standard;
import cn.jr.service.IStandardService;
import java.util.List;
public class StandardServiceImpl implements IStandardService {
private IStandardDao standardDao = new StandardDaoImpl();
@Override
public List<Standard> queryStandardByInfo(Standard st) {
return standardDao.selectByStandard(st);
}
@Override
public boolean removeStandardById(int id) {
return standardDao.deleteStandardById(id) > 0;
}
@Override
public boolean addStandard(Standard st) {
return standardDao.insertStandard(st) > 0;
}
@Override
public boolean changeStandard(Standard st) {
return standardDao.updateStandard(st) > 0;
}
@Override
public List<Standard> getAllStandards() {
return standardDao.selectAllStandards();
}
@Override
public Standard getStandardById(int id) {
return standardDao.selectStandardById(id);
}
}
```
7. 视图展示层
```java
package cn.jr.view;
import cn.jr.pojo.Standard;
import cn.jr.service.IStandardService;
import cn.jr.service.impl.StandardServiceImpl;
import java.util.List;
import java.util.Scanner;
public class StandardView {
private static IStandardService standardService = new StandardServiceImpl();
private static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
showMainMenu();
}
private static void showMainMenu() {
while (true) {
System.out.println("\n===== 标准管理系统 =====");
System.out.println("1. 查询标准");
System.out.println("2. 添加标准");
System.out.println("3. 修改标准");
System.out.println("4. 删除标准");
System.out.println("5. 显示所有标准");
System.out.println("0. 退出系统");
System.out.print("请选择操作: ");
int choice = scanner.nextInt();
scanner.nextLine(); // 消耗换行符
switch (choice) {
case 1:
queryStandard();
break;
case 2:
addStandard();
break;
case 3:
updateStandard();
break;
case 4:
deleteStandard();
break;
case 5:
showAllStandards();
break;
case 0:
System.out.println("谢谢使用，再见！");
return;
default:
System.out.println("无效选择，请重新输入！");
}
}
}
private static void queryStandard() {
System.out.println("\n----- 标准查询 -----");
System.out.print("请输入标准编号(可部分输入): ");
String stdNum = scanner.nextLine();
System.out.print("请输入中文名称(可部分输入): ");
String zhname = scanner.nextLine();
Standard condition = new Standard();
condition.setStdNum(stdNum);
condition.setZhname(zhname);
List<Standard> standards = standardService.queryStandardByInfo(condition);
System.out.println("\n查询结果:");
for (Standard standard : standards) {
System.out.println(standard);
}
}
// 其他方法实现类似
// ...
}
```
总结
本文从两个角度展示了Java项目的开发流程：
1. 员工角度：按照传统的分层架构，从数据库设计到展示层，逐步实现了一个DVD管理系统。
2. 经理角度：采用先设计Service接口再设计DAO接口的方式，实现了标准管理系统，更注重业务逻辑的设计。
两种开发方式各有特点：
- 员工角度更适合初学者，按照数据流动方向自然开发
- 经理角度更适合有经验的开发者，先设计业务接口再实现具体功能
无论采用哪种方式，良好的分层架构、清晰的代码结构和规范的命名都是开发高质量Java项目的关键。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
