3 . 三层架构建立类

建立如下的项目目录

三层架构

Cotroller控制器负责接收前端界面传回来的HTTP请求,控制页面的跳转和数据的传递,前端传进来数据之后将数据转到Service类中进行业务逻辑的处理和控制器传过来的数据验证,最后把结果返回给Dao类进行与数据库的交互,执行SQL语言

Project 项目实体类
功能：定义项目的数据模型，映射数据库中的project表
注解说明：@Data是Lombok注解，自动生成getter、setter、toString等方法
主要属性：包含项目编号、名称、位置、属性、投资金额等14个字段

`@Data
public class Project {
private String projectId; // 项目编号
private String projectName; // 项目名称
private String projectLocation; // 项目位置
private String projectProperty; // 项目属性
private Integer totalInvestment; // 项目总投资
private Integer currentInvestment; // 截至目前投资金额
private Integer year2025Investment; // 2025年度投资金额
private String constructionContent; // 建设内容
private Date startTime; // 开工时间
private Date endTime; // 完工时间
private Date reportDate; // 上报日期
private Integer auditStatus; // 审核状态（0未审核，1已审核）
private String auditOpinion; // 审核意见

// 为了与DAO层保持一致，添加getProperty方法
public String getProperty() {
    return projectProperty;
}

// 设置上报日期默认值
public void setReportDate(Date reportDate) {
    this.reportDate = reportDate;
}

ProjectDao 项目数据访问对象

功能：负责与数据库交互，执行SQL操作
注解说明：@Repository标记这是一个数据访问组件
核心组件：通过@Autowired注入JdbcTemplate进行数据库操作
主要方法：包含项目的增(insertProject)、删(deleteProject)、改(updateProject)、查(findProjectById)以及审核(auditProject)、搜索(searchProjects)等功能

`@Repository
public class ProjectDao {
@Autowired
private JdbcTemplate jdbcTemplate;

// 插入项目信息
public int insertProject(Project project) {
    String sql = "INSERT INTO project (project_id, project_name, project_location, project_property, " +
            "total_investment, current_investment, year2025_investment, construction_content, " +
            "start_time, end_time, report_date, audit_status, audit_opinion) " +
            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
    return jdbcTemplate.update(sql, project.getProjectId(), project.getProjectName(),
            project.getProjectLocation(), project.getProjectProperty(), project.getTotalInvestment(),
            project.getCurrentInvestment(), project.getYear2025Investment(),
            project.getConstructionContent(), project.getStartTime(), project.getEndTime(),
            project.getReportDate(), project.getAuditStatus(), project.getAuditOpinion());
}

// 根据项目编号查询项目
public Project findProjectById(String projectId) {
    String sql = "SELECT * FROM project WHERE project_id = ?";
    List<Project> projects = jdbcTemplate.query(sql, new Object[]{projectId},
            new BeanPropertyRowMapper<>(Project.class));
    return projects.isEmpty() ? null : projects.get(0);
}

// 更新项目信息
public int updateProject(Project project) {
    String sql = "UPDATE project SET total_investment = ?, current_investment = ?, " +
            "year2025_investment = ?, construction_content = ?, start_time = ?, " +
            "end_time = ?, report_date = ?, project_property = ? WHERE project_id = ?";
    return jdbcTemplate.update(sql, project.getTotalInvestment(), project.getCurrentInvestment(),
            project.getYear2025Investment(), project.getConstructionContent(), project.getStartTime(),
            project.getEndTime(), project.getReportDate(), project.getProjectProperty(), project.getProjectId());
}

// 删除项目
public int deleteProject(String projectId) {
    String sql = "DELETE FROM project WHERE project_id = ?";
    return jdbcTemplate.update(sql, projectId);
}

// 审核项目
public int auditProject(String projectId, Integer auditStatus, String auditOpinion) {
    String sql = "UPDATE project SET audit_status = ?, audit_opinion = ? WHERE project_id = ?";
    return jdbcTemplate.update(sql, auditStatus, auditOpinion, projectId);
}

// 模糊查询项目
public List<Project> searchProjects(String projectId, String projectName) {
    StringBuilder sql = new StringBuilder("SELECT * FROM project WHERE 1=1");
    if (projectId != null && !projectId.isEmpty()) {
        sql.append(" AND project_id LIKE ?");
    }
    if (projectName != null && !projectName.isEmpty()) {
        sql.append(" AND project_name LIKE ?");
    }
    sql.append(" ORDER BY report_date DESC");

    Object[] params;
    if (projectId != null && !projectId.isEmpty() && projectName != null && !projectName.isEmpty()) {
        params = new Object[]{"%" + projectId + "%", "%" + projectName + "%"};
    } else if (projectId != null && !projectId.isEmpty()) {
        params = new Object[]{"%" + projectId + "%"};
    } else if (projectName != null && !projectName.isEmpty()) {
        params = new Object[]{"%" + projectName + "%"};
    } else {
        params = new Object[]{};
    }

    return jdbcTemplate.query(sql.toString(), params, new BeanPropertyRowMapper<>(Project.class));
}

// 获取所有项目（按上报日期倒序）
public List<Project> getAllProjects() {
    String sql = "SELECT * FROM project ORDER BY report_date DESC";
    return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Project.class));
}

ProjectService 项目服务类

功能：包含业务逻辑处理和数据验证
注解说明：@Service标记这是一个业务组件，@Transactional标记事务管理
核心功能：

数据验证：提供项目编号、名称、位置等7项验证方法
业务处理：实现项目的创建、修改、删除、审核等功能，包含业务规则校验
事务管理：关键业务操作添加事务注解，确保数据一致性

`@Service
public class ProjectService {
@Autowired
private ProjectDao projectDao;

// 验证项目编号格式
public boolean isValidProjectId(String projectId) {
    // 八位数字，前四位表示两位年两位月，后四位表示序号
    String pattern = "^\\d{8}$";
    if (!Pattern.matches(pattern, projectId)) {
        return false;
    }
    // 检查年月部分是否有效（这里简化处理，只检查格式）
    String yearMonth = projectId.substring(0, 4);
    return Pattern.matches("^\\d{4}$", yearMonth);
}

// 验证项目位置格式
public boolean isValidProjectLocation(String location) {
    // 要求实现XX省XX市XX区XX格式
    String pattern = "^.{2,}省.{2,}市.{2,}区.{1,}$";
    return location != null && Pattern.matches(pattern, location);
}

// 验证项目属性
public boolean isValidProjectProperty(String property) {
    String[] validProperties = {"道路", "管廊", "住宅", "商业", "公建", "园林绿化", "产业类"};
    if (property == null) {
        return false;
    }
    for (String valid : validProperties) {
        if (valid.equals(property)) {
            return true;
        }
    }
    return false;
}

// 验证项目名称长度
public boolean isValidProjectName(String name) {
    return name != null && name.length() <= 50 && !name.isEmpty();
}

// 验证建设内容长度
public boolean isValidConstructionContent(String content) {
    return content != null && content.length() <= 500 && !content.isEmpty();
}

// 验证投资金额
public boolean isValidInvestment(Integer investment) {
    return investment != null && investment >= 0;
}

// 立项项目
@Transactional
public boolean createProject(Project project) {
    // 验证项目信息
    if (!isValidProjectId(project.getProjectId()) ||
            !isValidProjectName(project.getProjectName()) ||
            !isValidProjectLocation(project.getProjectLocation()) ||
            !isValidProjectProperty(project.getProjectProperty()) ||
            !isValidConstructionContent(project.getConstructionContent()) ||
            !isValidInvestment(project.getTotalInvestment()) ||
            !isValidInvestment(project.getCurrentInvestment()) ||
            !isValidInvestment(project.getYear2025Investment())) {
        return false;
    }

    // 检查项目是否已存在
    if (projectDao.findProjectById(project.getProjectId()) != null) {
        return false;
    }

    // 设置默认值
    project.setAuditStatus(0);
    if (project.getReportDate() == null) {
        project.setReportDate(new Date());
    }
    return projectDao.insertProject(project) > 0;
}

// 获取项目信息
public Project getProjectById(String projectId) {
    return projectDao.findProjectById(projectId);
}

// 修改项目信息
@Transactional
public boolean updateProject(Project project) {
    // 验证项目是否存在
    Project existingProject = projectDao.findProjectById(project.getProjectId());
    if (existingProject == null) {
        return false;
    }

    // 验证项目是否已审核
    if (existingProject.getAuditStatus() == 1) {
        return false;
    }

    // 验证新的项目信息
    if (!isValidProjectProperty(project.getProjectProperty()) ||
            !isValidConstructionContent(project.getConstructionContent()) ||
            !isValidInvestment(project.getTotalInvestment()) ||
            !isValidInvestment(project.getCurrentInvestment()) ||
            !isValidInvestment(project.getYear2025Investment())) {
        return false;
    }

    return projectDao.updateProject(project) > 0;
}

// 删除项目
@Transactional
public boolean deleteProject(String projectId) {
    // 验证项目是否存在
    Project project = projectDao.findProjectById(projectId);
    if (project == null) {
        return false;
    }

    // 验证项目是否已审核
    if (project.getAuditStatus() == 1) {
        return false;
    }

    return projectDao.deleteProject(projectId) > 0;
}

// 审核项目
@Transactional
public boolean auditProject(String projectId, Integer auditStatus, String auditOpinion) {
    // 验证项目是否存在
    Project project = projectDao.findProjectById(projectId);
    if (project == null) {
        return false;
    }

    // 验证审核状态
    if (auditStatus != 0 && auditStatus != 1) {
        return false;
    }

    return projectDao.auditProject(projectId, auditStatus, auditOpinion) > 0;
}

// 搜索项目
public List<Project> searchProjects(String projectId, String projectName) {
    return projectDao.searchProjects(projectId, projectName);
}

// 获取所有项目
public List<Project> getAllProjects() {
    return projectDao.getAllProjects();
}

ProjectController 项目管理控制器

功能：处理HTTP请求，控制页面跳转和数据传递
注解说明：@Controller标记控制器组件，@RequestMapping定义请求路径
请求处理：

GET请求：处理页面跳转，如跳转到立项、修改、删除、审核页面
POST请求：处理表单提交，如提交立项信息、修改信息、删除确认、审核等
数据传递：使用Model对象传递数据到视图层
日期处理：通过@InitBinder注解配置日期格式转换

`@Controller
@RequestMapping("/project")
public class ProjectController {
@Autowired
private ProjectService projectService;

// 主页面
@GetMapping("/")
public String index() {
    return "index";
}

// 跳转到立项页面
@GetMapping("/create")
public String createProject() {
    return "create_project";
}

// 提交立项信息
@PostMapping("/create")
public String submitProject(Project project, Model model) {
    boolean success = projectService.createProject(project);
    if (success) {
        model.addAttribute("message", "保存成功");
        return "redirect:/project/audit";
    } else {
        model.addAttribute("error", "上报数据有误");
        return "create_project";
    }
}

// 跳转到修改项目页面
@GetMapping("/update")
public String updateProject() {
    return "update_project";
}

// 根据项目编号查询项目信息用于修改
@PostMapping("/getForUpdate")
public String getProjectForUpdate(String projectId, Model model) {
    Project project = projectService.getProjectById(projectId);
    if (project == null) {
        model.addAttribute("error", "项目不存在");
        return "update_project";
    }

    if (project.getAuditStatus() == 1) {
        model.addAttribute("error", "项目已审核，不允许修改");
        return "update_project";
    }

    model.addAttribute("project", project);
    return "update_project_form";
}

// 提交修改后的项目信息
@PostMapping("/updateSubmit")
public String updateProjectSubmit(Project project, Model model) {
    boolean success = projectService.updateProject(project);
    if (success) {
        model.addAttribute("message", "修改成功");
        return "redirect:/project/";
    } else {
        model.addAttribute("error", "修改失败");
        model.addAttribute("project", project);
        return "update_project_form";
    }
}

// 跳转到删除项目页面
@GetMapping("/delete")
public String deleteProject() {
    return "delete_project";
}

// 根据项目编号查询项目信息用于删除
@PostMapping("/getForDelete")
public String getProjectForDelete(String projectId, Model model) {
    Project project = projectService.getProjectById(projectId);
    if (project == null) {
        model.addAttribute("error", "项目不存在");
        return "delete_project";
    }

    if (project.getAuditStatus() == 1) {
        model.addAttribute("error", "项目已审核，不能删除");
        return "delete_project";
    }

    model.addAttribute("project", project);
    return "delete_confirm";
}

// 确认删除项目
@PostMapping("/confirmDelete")
public String confirmDelete(String projectId, Model model) {
    boolean success = projectService.deleteProject(projectId);
    if (success) {
        model.addAttribute("message", "删除成功");
    } else {
        model.addAttribute("error", "删除失败");
    }
    return "delete_project";
}

// 跳转到审核项目页面
@GetMapping("/audit")
public String auditProject(@RequestParam(required = false) String projectId,
                           @RequestParam(required = false) String projectName,
                           Model model) {
    List<Project> projects;
    if ((projectId != null && !projectId.isEmpty()) || (projectName != null && !projectName.isEmpty())) {
        projects = projectService.searchProjects(projectId, projectName);
    } else {
        projects = projectService.getAllProjects();
    }
    model.addAttribute("projects", projects);
    model.addAttribute("projectId", projectId);
    model.addAttribute("projectName", projectName);
    return "audit_project";
}

// 审核项目
@PostMapping("/auditProject")
public String doAuditProject(String projectId, Integer auditStatus, String auditOpinion, Model model) {
    boolean success = projectService.auditProject(projectId, auditStatus, auditOpinion);
    if (success) {
        model.addAttribute("message", "审核成功");
    } else {
        model.addAttribute("error", "审核失败");
    }
    return "redirect:/project/audit";
}

// 处理日期格式转换（用于Project类的日期字段绑定）
@InitBinder
public void initBinder(WebDataBinder binder) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    dateFormat.setLenient(false);
    binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));
}

DatabaseConfig 数据库配置

功能：配置数据库连接和数据访问组件
注解说明：@Configuration标记配置类，@Value注入配置文件中的属性值，@Bean定义Spring Bean
核心配置：

从application.properties读取数据库连接参数
创建并配置DataSource数据源
创建JdbcTemplate实例，供DAO层使用

`@Configuration
public class DatabaseConfig {

@Value("${spring.datasource.url}")
private String url;

@Value("${spring.datasource.username}")
private String username;

@Value("${spring.datasource.password}")
private String password;

@Value("${spring.datasource.driver-class-name}")
private String driverClassName;

@Bean
public DataSource dataSource() {
    return DataSourceBuilder.create()
            .url(url)
            .username(username)
            .password(password)
            .driverClassName(driverClassName)
            .build();
}

@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
    return new JdbcTemplate(dataSource);
}

posted @ 2025-11-10 15:52 时酒阅读(5) 评论(0) 收藏举报

刷新页面返回顶部

zc2006

3 . 三层架构建立类

公告