项目改造--Spring mvc

最新推荐文章于 2023-12-18 17:51:18 发布
最新推荐文章于 2023-12-18 17:51:18 发布
阅读量162 收藏
点赞数
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43796669/article/details/105548661
版权

项目改造–Spring mvc

github链接

文件目录

在这里插入图片描述

重要代码

线程池

package org.example.spring.mvc.jdbc;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

@Configuration
public class DatabasePool {

    private static HikariDataSource hikariDataSource;

    public static HikariDataSource getHikariDataSource(){

        if(null != hikariDataSource){
            return  hikariDataSource;
        }

        synchronized (DatabasePool.class) {
            if (null == hikariDataSource) {

                String jdbcurl = "jdbc:mysql://127.0.0.1:3306/school?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC";
                String driverName = "com.mysql.cj.jdbc.Driver";

                HikariConfig hikariConfig = new HikariConfig();
                hikariConfig.setUsername("root");
                hikariConfig.setPassword("990619");
                hikariConfig.setDriverClassName(driverName);
                hikariConfig.setJdbcUrl(jdbcurl);

                hikariDataSource = new HikariDataSource(hikariConfig);

                return hikariDataSource;
            }
        }
        return null;
    }

数据库管理

package org.example.spring.mvc.jdbc;

import org.example.spring.mvc.bean.Homework;
import org.example.spring.mvc.bean.Student;
import org.example.spring.mvc.bean.StudentHomework;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;
@Configuration

public class StudentHomeworkJdbc {
    private static ApplicationContext contextSh;
    static {
        contextSh = new AnnotationConfigApplicationContext(StudentHomework.class);
    }

    private static ApplicationContext contextS;
    static {
        contextS = new AnnotationConfigApplicationContext(Student.class);
    }

    private static ApplicationContext contextH;
    static {
        contextH = new AnnotationConfigApplicationContext(Homework.class);
    }



    public static List<StudentHomework> selectAll(){


        String  sqlString = "select * from s_student_homework";

        List<StudentHomework> list = new ArrayList<>();

        try(Connection connection = DatabasePool.getHikariDataSource().getConnection()){
            try(Statement statement = connection.createStatement()){
                try(ResultSet resultSet = statement.executeQuery(sqlString)){
                    while(resultSet.next()){
                        StudentHomework sh = (StudentHomework) contextSh.getBean("studentHomework");
                        sh.setId(resultSet.getLong("id"));
                        sh.setStudentId(resultSet.getLong("student_id"));
                        sh.setHomeworkId(resultSet.getLong("homework_id"));
                        sh.setHomeworkTitle(resultSet.getString("homework_title"));
                        sh.setHomeworkContent(resultSet.getString("homework_content"));
                        sh.setCreateTime(resultSet.getTimestamp("create_time"));
                        list.add(sh);
                    }

                }
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        }

        return list;
    }
    public static List<Student> selectAllStudent(){


        String  sqlString = "select * from s_student";

        List<Student> list = new ArrayList<>();

        try(Connection connection = DatabasePool.getHikariDataSource().getConnection()){
            try(Statement statement = connection.createStatement()){
                try(ResultSet resultSet = statement.executeQuery(sqlString)){
                    while(resultSet.next()){
                        Student stu = (Student) contextS.getBean("student");
                        stu.setId(resultSet.getLong("id"));
                        stu.setName(resultSet.getString("name"));
                        stu.setCreate_time(resultSet.getTimestamp("create_time"));
                        list.add(stu);
                    }

                }
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        }

        return list;
    }
    public static List<Homework> selectAllHomework(){


        String  sqlString = "select * from s_homework";


        List<Homework> list = new ArrayList<>();

        try(Connection connection = DatabasePool.getHikariDataSource().getConnection()){
            try(Statement statement = connection.createStatement()){
                try(ResultSet resultSet = statement.executeQuery(sqlString)){
                    while(resultSet.next()){
                        Homework hw = (Homework) contextH.getBean("homework");
                        hw.setId(resultSet.getLong("id"));
                        hw.setTitle(resultSet.getString("title"));
                        hw.setContent(resultSet.getString("content"));
                        hw.setCreate_time(resultSet.getTimestamp("create_time"));
                        list.add(hw);
                    }

                }
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        }

        return list;
    }
    public boolean addHomework(Homework hw) {

        String sql = "INSERT INTO `school`.`s_homework`(`id`,`title`,`content`,`create_time`,`update_time`) VALUES (?,?,?,?,?)";


        try(Connection connection = DatabasePool.getHikariDataSource().getConnection()){
            PreparedStatement ps =  connection.prepareStatement(sql);
            ps.setLong(1,hw.getId());
            ps.setString(2,hw.getTitle());
            ps.setString(3,hw.getContent());
            ps.setTimestamp(4, (Timestamp) hw.getCreate_time());
            ps.setTimestamp(5, (Timestamp) hw.getUpdate_time());
            int count = ps.executeUpdate();
            ps.close();
            return count > 0 ? true : false;
        }catch(SQLException e){
            e.printStackTrace();
        }
        return false;
    }

    public boolean addStudent(Student stu) {

        String sql = "INSERT INTO `school`.`s_student`(`id`,`name`,`create_time`,`update_time`) VALUES (?,?,?,?)";


        try(Connection connection = DatabasePool.getHikariDataSource().getConnection()){
            PreparedStatement ps =  connection.prepareStatement(sql);
            ps.setLong(1,stu.getId());
            ps.setString(2,stu.getName());
            ps.setTimestamp(3, (Timestamp) stu.getCreate_time());
            ps.setTimestamp(4, (Timestamp) stu.getUpdate_time());
            int count = ps.executeUpdate();
            ps.close();
            return count > 0 ? true : false;
        }catch(SQLException e){
            e.printStackTrace();
        }
        return false;
    }

    public boolean submitHomework(StudentHomework studentHomework) {

        String sql = "INSERT INTO `school`.`s_student_homework`(`id`,`student_id`,`homework_id`,`homework_title`,`homework_content`,`create_time`,`update_time`) VALUES (?,?,?,?,?,?,?)";


        try(Connection connection = DatabasePool.getHikariDataSource().getConnection()){
            PreparedStatement ps =  connection.prepareStatement(sql);
            ps.setLong(1,studentHomework.getId());
            ps.setLong(2,studentHomework.getStudentId());
            ps.setLong(3,studentHomework.getHomeworkId());
            ps.setString(4,studentHomework.getHomeworkTitle());
            ps.setString(5,studentHomework.getHomeworkContent());
            ps.setTimestamp(6, (Timestamp) studentHomework.getCreateTime());
            ps.setTimestamp(7, (Timestamp) studentHomework.getUpdateTime());
            int count = ps.executeUpdate();
            ps.close();
            return count > 0 ? true : false;
        }catch(SQLException e){
            e.printStackTrace();
        }
        return false;
    }

    public boolean isExistStudent(Long id){


        String sql = "SELECT * from `school`.`s_student` where id = ? ";
        boolean flag = false;
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = DatabasePool.getHikariDataSource().getConnection();
            preparedStatement=connection.prepareStatement(sql);
            preparedStatement.setLong(1,id);
            resultSet = preparedStatement.executeQuery();
            //获取执行结果
            if(resultSet.next()){
                flag = true;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            if(null != resultSet) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(null != preparedStatement) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(null != connection) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return flag;
    }

    public boolean isExistHomework(Long id){

        String sql = "SELECT * from `school`.`s_homework` where id = ? ";
        boolean flag = false;
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {

            connection = DatabasePool.getHikariDataSource().getConnection();
            preparedStatement=connection.prepareStatement(sql);
            preparedStatement.setLong(1,id);
            resultSet = preparedStatement.executeQuery();
            //获取执行结果
            if(resultSet.next()){
                flag = true;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            if(null != resultSet) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(null != preparedStatement) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(null != connection) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return flag;
    }

TeacherController

package org.example.spring.mvc.controller;

import org.example.spring.mvc.jdbc.StudentHomeworkJdbc;
import org.example.spring.mvc.bean.Homework;
import org.example.spring.mvc.bean.Student;
import org.example.spring.mvc.bean.StudentHomework;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

@Controller
/*@RequestMapping("/Teacher/")*/
public class TeacherController  extends HttpServlet {
    @RequestMapping("/add")
    public void AddStudentHomeworkServlet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Long id = Long.parseLong(req.getParameter("id"));
        String title = req.getParameter("title");
        String content = req.getParameter("content");


        Homework hw = new Homework();
        hw.setId(id);
        hw.setTitle(new String(title.getBytes("ISO-8859-1"), "UTF-8"));
        hw.setContent(new String(content.getBytes("ISO-8859-1"), "UTF-8"));
        StudentHomeworkJdbc add = new StudentHomeworkJdbc();
        add.addHomework(hw);
    }

    @RequestMapping("/addStu")
    public void AddStudentServlet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Long id = Long.parseLong(req.getParameter("id"));
        String name = req.getParameter("name");


        Student stu = new Student();
        stu.setId(id);
        stu.setName(new String(name.getBytes("ISO-8859-1"), "UTF-8"));
        StudentHomeworkJdbc addStu = new StudentHomeworkJdbc();
        addStu.addStudent(stu);
    }

    @RequestMapping("/list")
    public void StudentHomeworkServlet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        List<StudentHomework> list = StudentHomeworkJdbc.selectAll();

        req.setAttribute("list",list);

        req.getRequestDispatcher("index.jsp").forward(req,resp);
    }
}

StudentController

package org.example.spring.mvc.controller;

import org.example.spring.mvc.jdbc.StudentHomeworkJdbc;
import org.example.spring.mvc.bean.StudentHomework;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServlet;
import java.io.UnsupportedEncodingException;

@Controller
/*@RequestMapping("/Student/")*/
public class StudentController extends HttpServlet {

    /**
     * @RequestMapping(value = "submitHomework",method = RequestMethod.GET)等价于
     *    @GetMapping("submitHomework")
     */

    @ResponseBody
    public Object testMapping(@RequestBody Object request, @RequestParam(required = true) String id){
        //HttpServletRequest 获取Body ------> request

        //Object ------> HttpServletResponse
        return new Object();
    }


    @RequestMapping("/submitHomework")  /**会映射到 StudentController.SubmitHomeworkServlet()*/
    public void SubmitHomeworkServlet(@RequestParam(value = "id")Long id,
                                      @RequestParam(value = "studentId")Long studentId,
                                      @RequestParam(value = "homeworkId")Long homeworkId,
                                      @RequestParam(value = "homeworkTitle")String homeworkTitle,
                                      @RequestParam(value = "homeworkContent")String homeworkContent) throws UnsupportedEncodingException {
  /*      Long id = Long.parseLong(req.getParameter("id"));
        Long studentId = Long.parseLong(req.getParameter("studentId"));
        Long homeworkId = Long.parseLong(req.getParameter("homeworkId"));
        String homeworkTitle = req.getParameter("homeworkTitle");
        String homeworkContent = req.getParameter("homeworkContent");
*/
        StudentHomeworkJdbc submitHw = new StudentHomeworkJdbc();
        if (submitHw.isExistStudent(studentId)) {
            if (submitHw.isExistHomework(homeworkId)) {
                StudentHomework sh = new StudentHomework();
                sh.setId(id);
                sh.setStudentId(studentId);
                sh.setHomeworkId(homeworkId);
                sh.setHomeworkTitle(new String(homeworkTitle.getBytes("ISO-8859-1"), "UTF-8"));
                sh.setHomeworkContent(new String(homeworkContent.getBytes("ISO-8859-1"), "UTF-8"));
                submitHw.submitHomework(sh);
            }

        }
    }



}

app-context.xml

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

<!--    <bean id="testBean" class="org.example.spring.mvc.bean.TestBean"></bean>-->
    <bean id = "dbPool" class="org.example.spring.mvc.jdbc.DatabasePool"></bean>

    <context:component-scan base-package="org.example.spring.mvc.bean"></context:component-scan>
    <context:component-scan base-package="org.example.spring.mvc.jdbc"></context:component-scan>



</beans>

app-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">


    <context:component-scan base-package="org.example.spring.mvc.controller"></context:component-scan>

</beans>
weixin_43796669
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Spring mvc项目改造为Spring boot 问题
时无英雄、使竖子成名
11-09 1101
1. 打包方式 jar war jar的方式比较简单，是springboot 默认的。 如果打包war, 部署到外部的tomcat, 需要做以下调整： 启动类 @SpringBootApplication public class WebApplication extends SpringBootServletInitializer { @Override protected SpringApplicationBuilder configure(SpringApplication
Spring MVC项目改造Spring Boot项目
在途中
12-19 575
最近在公司需要把一个老的Spring Mvc项目升级为Spring Boot项目，升级后将一些无用代码去除，在升级过程遇到了一些问题，特此记录。 引入Spring Boot的相关依赖 首先需要在pom文件中引入Spring Boot的相关依赖 <parent> <groupId>org.springframework.boot</groupId> ...
已存项目改造spring mvc
li371490890的博客
08-19 236
1、引入所需jar包； <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> </dependency> <dependency> <groupId>org.spring
【Spring】SpringMVC项目升级成SpringBoot实践
最新发布
后端研发工程师Marion的博客
12-18 1898
将Spring MVC项目升级为Spring Boot项目需要一系列详细的步骤。web.xml@Service@Component请注意，这只是一个更详细的步骤指南，具体的升级过程可能会因您的项目和使用的库而有所不同。因此，在开始升级之前，最好详细阅读Spring Boot的官方文档和迁移指南，并遵循最佳实践进行升级。
springmvc xml配置项目的改造执行过程
li_a_long的博客
06-17 171
项目是开源项目 技术是spring、springmvc、springjdbc、mysql，git clone的主分支，主要开发都是提交的master分支，提供了不同版本war包下载，但是想着基于源码编译本地ide运行的想法就直接用的主分支。 IDE选则 IDEA 内置tomcat启动 首先根据项目要求建立数据库表，导入数据，修改配置文件中的mysql数据库的连接信息。 配置tomcat过程自行百度，idea中部署项目到tomcat过程，我用的tomcat是8.5版本 启动后访问程序接口报错.
Spring MVC入门篇：从一个项目创建实例练习开始！
向小雅的博客
06-05 306
参考文章：https://www.jianshu.com/p/91a2d0a1e45a 文章描述的很详细，但实际操作中出现了几个小问题。 IDEA output 中文乱码：https://www.cnblogs.com/henrypaul/p/12524544.html 将Tomcat中的servlet-api.jar拷贝到lib下，不是真正的导入依赖包，直到启动Tomcat，报错org.springframework.web.context.ContextLoaderListener找不到，于是
spring-boot-ssm:springboot-ssm 是一个基于Spring Boot & Spring & Spring MVC & MyBatis的简单通用的项目，用于快速构建中小型API的后端服务系统
05-14
spring-boot-ssm 是一个基于Spring Boot & Spring & Spring MVC & MyBatis的简单通用的项目，用于快速构建中小型API的后端服务系统. 可以做为一个种子项目,进行改造升级. 另外,还有个对应的Vue+ElementUI的前端项目,...
ssm-demo：Spring + SpringMVC + Mybatis + easyUI实现简单的后台管理系统
02-02
本项目为ssm系列的第一篇， Spring + SpringMVC + mybatis + easyUI的一个简单演示，实现了后台管理系统的基本功能，后续会逐步优化改造，Wiki文档已经整理，可以到查看，关于项目的简介及技术选型，也已经单独整理...
Spring MVC +Spring + Mybatis 构建分库分表源码
03-10
在本资源中，我们主要探讨如何使用Spring MVC、Spring和Mybatis这三大流行框架来构建一个支持分库分表的应用。这些技术都是Java Web开发中的关键组件，它们各自承担着不同的职责并协同工作，以实现高效、可扩展的...
SpringMVC源码总结（二）mvc:mvc:annotation-driven背后的那些事
08-07
在Spring MVC框架中，`mvc:annotation-driven`是Spring MVC配置中的一个重要元素，它使得我们的应用能够支持基于注解的控制器、数据绑定、格式化转换器和服务端验证等功能。这篇博客将深入探讨`mvc:annotation-...
土鳖的jsp改造
weixin_34405332的博客
01-09 135
title: 土鳖的jsp改造 tags: sitemesh jsp template categories: 工作日志 date: 2017-12-23 10:50:38 背景 前端世界变化太快，各种模板各种新的技术框架出现。 虽然如此，我们java后端也有模板三宝 jsp freemarker velocity 当然还有一些groovy的模板等等 我司目前仍然有老项目在使用jsp ...
JSP | 基于Servlet和JSP改造oa项目
m0_61933976的博客
12-04 785
JSP | 基于Servlet和JSP改造oa项目
重构老项目所学 _ JSP
Mr.小灰狼_随笔
12-01 536
JSP（Java Server Pages）是JavaWeb 服务器端的动态资源 , 它与 html 页面的作用是相同的，显示数据和获取数据。
jsp+javaBean工程改造
sxl
02-01 106
公司要做一个电子商务网站，算是一个中型项目吧，为了加快开发进度，有合作伙伴提供一套基础框架，其实也谈不上框架，就是他们曾经用jsp+javaBean做过一个类似我们需要的网站，后台javaBean倒是简单，就是在jsp页面中有大量java代码。 现在公司想要我们在这个基础上开发，但我们研发人员看了后都感觉用这种方式开发有点别扭，不知道这种方式会不会影响我们的开发进度，请问我们是应...
JSP融合vuejs全面重构升级老旧项目页面维护
chenyanqin1992的专栏
03-19 4262
如果在老项目jsp页面的话不可能是全部重构的，所有闪亮登场的就是jsp配合vue杀手锏，可以做出复杂的交互和组件；比如三级菜单在融合商品选择等； 第一步引入挂载header.jsp <script type="text/javascript" src="/bizbox/js/public/vue/vue@2.6.14.min.js"></script> <script type="text/javascript" src="/bizbox/js/public/vue/el
springmvc 项目改造成springboot
亲测，只为展现最完美的有效！
12-17 1万+
改造的要点： 1、提取配置 2、导入配置 3、优化依赖 4、打包改造 一、首先 spring mvc 配置文件初始化入口是 web.xml 里面会去加载 servlet，一般会有如下配置，这是所有springmvc的配置入口 <servlet> <servlet-name>springMVC</servlet-name> <servlet-class>org.springframework.web.servlet.Dispatcher...
SpringMVC改造成Springboot【汇总】
u010473656的专栏
04-04 9679
最近公司技术升级，要将所有的微服务改造成 Spring Cloud 框架，但由于外部系统还是SpringMVC架构，直接切换会影响接口调用，所以暂时先改造成 Springboot 框架。在改造中也遇到了一些问题，在这边记录下改造过程，希望可以对网友提供一点借鉴。 Springboot最大的特点就是提供了整合过的jar，使得开发过程中无需自行引用过多的jar，从而简化了 Spring应用 的初始搭...
maven的springmvc改造成springboot项目
止境博客
08-17 3673
1.原来MVC目录结构图，原来的项目前端是用jsp页面展示，使用tomcat启动项目，改造结果使用springboot加载前端页面，使用springboot内置tomcat启动项目，加载数据库链接和原来一些用MVC加载的东西。原来mvc加载了扫描java路径，静态资源加载，数据库链接和拦截器，改造的时候只需要将这几个需要加载的改为用springboot加载即可。 2.改造前目录结构图 3.改造后结构图 4.需要改造的几个地方，pom文件配置springboot内置tomcat，并且配置jsp模
手把手教你将springmvc项目转为springboot
热门推荐
业余架构师博客
02-25 3万+
说明 如果你的项目连maven项目都不是，请自行转为maven项目，在按照本教程进行。 本教程适用于spring+springmvc+mybatis+shiro的maven项目。 1.修改pom文件依赖 删除之前的spring依赖，添加springboot依赖 &lt;parent&gt; &lt;groupId&gt;org.springframework.b...
Spring MVC项目开发教程：结合Hibernate与Freemarker
总结来说，本教程覆盖了使用Spring MVC、Hibernate和FreeMarker进行Web应用开发的全过程，从环境搭建、数据库配置、项目结构设计到实际运行，提供了一个完整的示例，适合初学者深入理解和实践。通过学习这个教程，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值