SpringMVC——CRUD操作 (包含JavaConfig的方式)

已于 2023-10-19 15:48:02 修改
阅读量1.9k 收藏 4
点赞数 4
分类专栏： # Spring MVC 文章标签： SpringMVC CRUD
于 2020-03-31 12:07:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37989980/article/details/104720074
版权

目录

  • SpringMVC的CRUD操作
    在这里插入图片描述

一、SpringMVC完成CRUD

0、导入相关依赖
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.10</version>
    <scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.10</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.10</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.10</version>
</dependency>

<!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.8</version>
</dependency>

<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.4</version>
</dependency>

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.5</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

<!-- 用于做表单安全校验-->
<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-validator -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.1.0.Final</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.fasterxml/classmate -->
<dependency>
    <groupId>com.fasterxml</groupId>
    <artifactId>classmate</artifactId>
    <version>1.3.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.validation/validation-api -->
<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>2.0.1.Final</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.jboss.logging/jboss-logging -->
<dependency>
    <groupId>org.jboss.logging</groupId>
    <artifactId>jboss-logging</artifactId>
    <version>3.3.0.Final</version>
</dependency>

<!--文件上传-->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>
<!--servlet-api导入高版本的-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>
1、设计数据库表
CREATE TABLE `employee` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(20) DEFAULT NULL,
  `password` varchar(40) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `hiredate` date DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=40 DEFAULT CHARSET=utf8;

配置文件

#key=value
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/springmvc
jdbc.username=root
jdbc.password=1111
jdbc.initialSize=2

实体类

package com.sunny.domain;

import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;

import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import java.util.Date;

@Data
public class Employee {

	private Long id;

	@NotNull(message = "用户名不能为空")
	@Size(max = 10, min = 4, message = "用户名在4-10位之间")
	private String username;

	@NotNull(message = "密码不能为空")
	@Size(max = 10, min = 4, message = "密码在4-10位之间")
	private String password;

	@NotNull(message = "年龄不能为空")
	@Min(value = 18, message = "年龄最小值为18")
	@Max(value = 60, message = "年龄最大值为60")
	private Integer age;

	@DateTimeFormat(pattern = "yyyy-MM-dd")
	private Date hiredate;
}
2、控制层代码

LoginController

@Controller
public class LoginController {

    @Autowired
    private IEmployeeService service;

    @RequestMapping("/login")
    public String login(String username, String password, HttpSession session){
        System.out.println("LoginController.login");
        Employee current = service.login(username, password);
        if (current == null){
            session.setAttribute("errorMsg", "账号或密码错误");
            return "redirect:/login.jsp";
        }
        session.setAttribute("user_in_session", current);
        return "redirect:/employee/list";
    }

/*    @RequestMapping("/login")
    public String login(String username, String password, HttpSession session) {
        try {
            service.login(username, password);
        } catch (Exception e) {
            session.setAttribute("errorMsg", e.getMessage());
            return "redirect:/login.jsp";
        }
        return "redirect:/employee/list";
    }*/
}

EmployeeController

@Controller
@RequestMapping("/employee")
public class EmployeeController {

    @Autowired
    private IEmployeeService employeeService;

    @RequestMapping("/list")
    public String list(Model model) {
        //int a = 1 / 0;
        // 共享数据到list界面
        model.addAttribute("employees", employeeService.listAll());
        return "employee/list"; // 跳转到list界面
    }

    // 新增员工
    @RequestMapping("/input")
    public String input(Model model, Long id) {
        if (id != null) {
            model.addAttribute("employee", employeeService.get(id));
        } else {
            model.addAttribute("employee", new Employee());
        }
        return "employee/input";
    }

/*    @RequestMapping("/saveOrUpdate")
    public String saveOrUpdate(Employee emp){
        if (emp.getId() == null){
            employeeService.save(emp);
        } else {
            employeeService.update(emp);
        }
        return "redirect:/employee/list";
    }*/

    @RequestMapping("/saveOrUpdate")
    public String saveOrUpdate(@Valid Employee emp, BindingResult bindingResult, Model model) {

        List<ObjectError> errors = bindingResult.getAllErrors();
        if (errors.size() > 0) {
            model.addAttribute("errors", errors);
            return "employee/input";
        }

        if (emp.getId() == null) {
            employeeService.save(emp);
        } else {
            employeeService.update(emp);
        }
        return "redirect:/employee/list";
    }

    @RequestMapping("/delete")
    public String delete(Long id) {
        if (id != null) {
            employeeService.delete(id);
        }
        return "redirect:/employee/list";
    }
}

拦截器代码:CheckLoginInterceptor

public class CheckLoginInterceptor implements HandlerInterceptor {
    // 在请求处理方法之前执行
    // 如果返回true,执行下一个拦截器
    // 如果返回false,就不执行下一个拦截器

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 没有登录的情况
        if (request.getSession().getAttribute("user_in_session") == null){
            System.out.println("----------------");
            response.sendRedirect("/login.jsp");
            return false; // 阻止往后放行
        }
        // 放行,给下一个拦截器或者最终的处理器
        return true;
    }

    // 在请求处理方法执行之后执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    // 在dispatcherServlet处理后执行,做清理工作
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}
3、业务层代码
public interface IEmployeeService {
	void save(Employee emp);

	void update(Employee emp);

	void delete(Long id);

	Employee get(Long id);

	List<Employee> listAll();

	Employee login(String username, String password);

	/*void login(String username, String password);*/
}
@Service("employeeServiceImpl")
@Transactional // 增加事务处理, 底层AOP来实现(动态代理); 原始功能+切入点+额外功能+组装切面 (4部分)
public class EmployeeServiceImpl implements IEmployeeService {

	@Autowired
	private IEmployeeDAO dao;


	public void save(Employee emp) {
		dao.save(emp);
		//int a = 1/0;
	}

	public void update(Employee emp) {
		dao.update(emp);
	}

	public void delete(Long id) {
		dao.delete(id);
	}

	@Transactional(readOnly = true)
	public List<Employee> listAll() {
		return dao.listAll();
	}

	@Transactional(readOnly = true)
	public Employee get(Long id) {
		return dao.get(id);
	}

	@Transactional(readOnly = true)
	public Employee login(String username, String password) {
		return dao.login(username, password);
	}

/*	public void login(String username, String password){
		Employee current = dao.login(username, password);
		if (current == null){
			throw new RuntimeException("账号或密码错误!");
		}
		UserContext.setCurrentUser(current);
	}*/
}
4、持久层代码
public interface IEmployeeDAO {
	void save(Employee emp);

	void update(Employee emp);

	void delete(Long id);

	Employee get(Long id);

	List<Employee> listAll();

	Employee login(String username, String password);
}
public class EmployeeDAOImpl implements IEmployeeDAO {

    private JdbcTemplate jdbcTemplate;

    public void setDataSource(DataSource ds) {
        this.jdbcTemplate = new JdbcTemplate(ds);
    }

    public void save(Employee e) {
        jdbcTemplate.update("INSERT INTO employee (username,password,age,hiredate) VALUES (?,?,?,?)", e.getUsername(),
                e.getPassword(), e.getAge(), e.getHiredate());
    }

    public void update(Employee e) {
        jdbcTemplate.update("UPDATE employee SET username= ?,password=?,age = ?,hiredate=? WHERE id= ?",
                e.getUsername(), e.getPassword(), e.getAge(), e.getHiredate(), e.getId());
    }

    public void delete(Long id) {
        jdbcTemplate.update("DELETE FROM employee WHERE id = ?", id);
    }


    public Employee get(Long id) {
        String sql = "SELECT id,username,password,age,hiredate FROM employee WHERE id = ?";

        List<Employee> list = jdbcTemplate.query(sql, new Object[]{id}, new RowMapper<Employee>() {
            public Employee mapRow(ResultSet rs, int i) throws SQLException {
                Employee e = new Employee();
                e.setId(rs.getLong("id"));
                e.setUsername(rs.getString("username"));
                e.setPassword(rs.getString("password"));
                e.setAge(rs.getInt("age"));
                e.setHiredate(rs.getDate("hiredate"));
                return e;
            }
        });

        return list.size() == 1 ? list.get(0) : null;
    }


    public List<Employee> listAll() {
    	String sql = "SELECT id,username,password,age,hiredate FROM employee";
        List<Employee> listAll = jdbcTemplate.query(sql, new Object[]{}, new RowMapper<Employee>() {
                    public Employee mapRow(ResultSet rs, int i) throws SQLException {
                        Employee e = new Employee();
                        e.setId(rs.getLong("id"));
                        e.setUsername(rs.getString("username"));
                        e.setPassword(rs.getString("password"));
                        e.setAge(rs.getInt("age"));
                        e.setHiredate(rs.getDate("hiredate"));
                        return e;
                    }
                });

        return listAll;
    }

    public Employee login(String username, String password) {

        String sql = "SELECT id,username,password,age,hiredate FROM employee WHERE username = ? AND password = ?";

        List<Employee> list = jdbcTemplate.query(sql, new Object[]{username, password}, new RowMapper<Employee>() {
            public Employee mapRow(ResultSet rs, int i) throws SQLException {
                Employee e = new Employee();
                e.setId(rs.getLong("id"));
                e.setUsername(rs.getString("username"));
                e.setPassword(rs.getString("password"));
                e.setAge(rs.getInt("age"));
                e.setHiredate(rs.getDate("hiredate"));
                return e;
            }
        });
        return list.size() == 1 ? list.get(0) : null;
    }
}

全局异常控制

/**
 * Description: 处理全局的异常,当发现异常,自动跳转到error.jsp
 *
 * @author zygui
 * @date 2020/3/7 10:21
 */

@ControllerAdvice // 控制器增强.底层仍是AOP切面(AOP底层是动态代理来实现)
public class HandleExceptionAdviceController {

    //@ExceptionHandler(XxxException.class) // 对XxxException异常做处理
    @ExceptionHandler // 默认就是对Exception做处理
    public String error(Model model, Exception ex){
        model.addAttribute("errorMsg", ex.getMessage());
        return "/commons/error";
    }
}
5、web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!-- 针对POST请求设置编码过滤器,GET请求,框架已经帮我们做好了 -->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
        <!-- 如果有编码格式,设置强制使用上面我们设置的编码格式-->
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--配置前端控制器-->
    <!--1.注册DispatcherServlet-->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springMVC的配置文件:【servlet-name】-servlet.xml-->
        <!--默认去WEB-INF目录中去寻找-->
        <!-- 默认寻找<servlet-name>元素文本内容-servlet.xml文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-1,在Tomcat启动时就初始化Spring容器-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--/ 匹配所有的请求；（不包括.jsp）-->
    <!--/* 匹配所有的请求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>
6、applicationContext.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" xmlns:tx="http://www.springframework.org/schema/tx"

	   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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

	<context:annotation-config/>

	<!-- 从classpath的根路径去加载db.properties文件 -->
	<context:property-placeholder location="classpath:db.properties" system-properties-mode="NEVER" />

	<!-- 配置一个druid的连接池 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<property name="initialSize" value="${jdbc.initialSize}" />
	</bean>

	<!-- 1:WHAT:配置JDBC事务管理器 -->
	<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<tx:annotation-driven transaction-manager="txManager"/>

</beans>
7、springmvc-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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <import resource="classpath:applicationContext.xml"/>

    <!-- 自动扫描包,让指定包下的注解生效,由IoC容器统一管理-->
    <context:component-scan base-package="com.sunny"/>

    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />

    <!-- mvc注解解析器-->
    <mvc:annotation-driven/>

    <!--视图解析器:DispatcherServlet给他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/views/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--关于拦截器的配置-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--/** 包括路径及其子路径-->
            <!--/admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
            <!--/admin/** 拦截的是/admin/下的所有-->
            <mvc:mapping path="/**"/>
            <!-- 排除不需要被拦截的资源 -->
            <mvc:exclude-mapping path="/login"/>
            <!--bean配置的就是拦截器-->
            <bean class="com.sunny.web.interceptor.CheckLoginInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

    <!--配置异常处理器 和写Java类的方式2选1-->
<!--    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">-->
<!--        &lt;!&ndash;当出错后,需要跳转的视图&ndash;&gt;-->
<!--        <property name="defaultErrorView" value="commons/error"/>-->
<!--        &lt;!&ndash;定义异常处理页面用来获取异常信息的变量名,默认名为exception&ndash;&gt;-->
<!--        <property name="exceptionAttribute" value="ex"/>-->
<!--        &lt;!&ndash;定义需要特殊处理的异常,用类名或完全路径作为key,异常视图作为值&ndash;&gt;-->
<!--        &lt;!&ndash;<property name="exceptionMappings">-->
<!--            <value>-->
<!--                com.sunny.web.xxx.XxxException = commons/xxx-->
<!--                &lt;!&ndash;还可以继续扩展&ndash;&gt;-->
<!--            </value>-->
<!--        </property>&ndash;&gt;-->
<!--    </bean>-->
</beans>
8、相关jsp页面

在这里插入图片描述
login.jsp

<!-- login.jsp -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录界面</title>
</head>
<body>
    <h3>登录界面</h3>
    <form action="/login" method="post">
        账号:<input type="text" name="username"><br>
        密码:<input type="password" name="password"><br>
        <input type="submit" value="登录"><br>
    </form>

    <span style="color: red">${errorMsg}</span>
    <!--销毁session-->
    <%
        session.invalidate();
    %>
</body>
</html>

list.jsp

<%@ 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>
</head>
<body>
    <span>恭喜${user_in_session.username}:登录成功</span>
    <span style="color: blue"><a href="/login">注销</a></span>
    <h3>员工列表</h3>
    <!--跳转到Controller的input-->
    <a href="/employee/input">新增</a>
    <table border="1" cellpadding="0" cellspacing="0" width="500">
        <tr>
            <th>ID</th>
            <th>用户名</th>
            <th>密码</th>
            <th>入职时期</th>
            <th>操作</th>
        </tr>

        <c:forEach items="${employees}" var="e">
            <tr>
                <td>${e.id}</td>
                <td>${e.username}</td>
                <td>${e.password}</td>
                <td>${e.hiredate}</td>
                <td>
                    <a href="/employee/delete?id=${e.id}">删除</a>
                    <a href="/employee/input?id=${e.id}">编辑</a>
                </td>
            </tr>
        </c:forEach>
    </table>
</body>
</html>

input.jsp(新增联系人)

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<html>
<head>
    <title>Title</title>
</head>

<body>

    <!--使用SpringMVC的表单标签-->

    <!--默认请求就是POST-->
	<h3>编辑员工</h3>
    <form:form action="/employee/saveOrUpdate" modelAttribute="employee">
        <form:hidden path="id"/><br>
        账号:<form:input path="username"/>							<form:errors path="username" cssStyle="color: red"/><br>
        密码:<form:password path="password" showPassword="true"/> 	<form:errors path="password"
																				cssStyle="color: red"/> <br>
        年龄:<form:input path="age"/>								<form:errors path="age" cssStyle="color: red"/> <br>
        入职:<form:input path="hiredate"/><br>
        <input type="submit" value="保存"><br>
    </form:form>
    
    <hr>

<%-- <c:forEach items="${errors}" var="error">
		<div style="color: red">${error.defaultMessage}</div>
	</c:forEach>
	<h3>编辑员工</h3>
	<form action="/employee/saveOrUpdate" method="post">
		<input type="hidden" name="id" value="${employee.id}">
		账号:<input type="text" name="username" value="${employee.username}"><br>
		密码:<input type="password" name="password" value="${employee.password}"><br>
		年龄:<input type="text" name="age" value="${employee.age}"><br>
		入职:<input type="text" name="hiredate" value="${employee.hiredate}"><br>
		<input type="submit" value="保存">
	</form>--%>
</body>
</html>

error.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" isErrorPage="true" %>
<html>
<head>
    <title>错误页面</title>
</head>
<body>
    出错了:<%= exception%> <br>

    ${ex}<br>

    ${errorMsg}<br>

</body>
</html>

重点:

使用JavaConfig的方式来将上面的xml配置文件消除掉, 用配置类来替换

  • Web.xml的替代
// Web容器启动; 相当于web.xml
public class MyWebInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    // 根容器: 相当于_关联Spring的核心配置文件
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{AppConfig.class};
    }

    // SpringMVC容器:相当于在web.xml中配置mvc.xml
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    // 映射路径
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    /*    // 配置全局过滤器(字符编码问题)
        protected void registerContextLoaderListener(ServletContext servletContext) {
            super.registerContextLoaderListener(servletContext);
            //编码过滤器
            Dynamic filter = servletContext.addFilter("CharacterEncodingFilter", CharacterEncodingFilter.class);
            filter.setInitParameter("encoding", "UTF-8");
            filter.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), true, "/*");
        }*/
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceEncoding(true);
        return new Filter[]{characterEncodingFilter};
    }
}
  • applicationContext.xml的替代
// 对应applicationContext.xml的配置类

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

// 相当于applicationContext.xml文件
@Configuration
@ComponentScan("com.sunny")
@PropertySource("classpath:db.properties")
@EnableTransactionManagement // 事务处理的注解; 开启事务的注解
public class AppConfig {

    @Value("${jdbc.driverClassName}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    @Value("${jdbc.initialSize}")
    private int initialSize;

    // 连接池对象
    @Bean // bean的id就是dataSource,也可以起一个
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driverClassName);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        ds.setInitialSize(initialSize);
        return ds;
    }

    // 事务管理器对象;这里传的ds对象,就是上面的连接池对象,它会自动找ds对象
    // DataSourceTransactionManager将数据源添加到事务管理中;必须配置
    @Bean
    public DataSourceTransactionManager txManager(DataSource ds){
        return new DataSourceTransactionManager(ds);
    }
}
  • springmvc-servlet.xml的替代

import com.sunny.web.interceptor.CheckLoginInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

// 相当于springmvc-servlet这个配置文件
// springmvc相关的配置类
@Configuration
@EnableWebMvc //启动SpringMVC
@ComponentScan("com.sunny")
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public CheckLoginInterceptor checkLoginInterceptor(){
        // 拦截器, 实现HandlerInterceptor的类
        return new CheckLoginInterceptor();
    }


    // 配置拦截器
    public void addInterceptors(InterceptorRegistry registry){
        registry.addInterceptor(checkLoginInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/login");
    }

    // 配置JSP视图
    @Bean
    public ViewResolver viewResolver(){
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/views/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }

    // 配置静态资源处理
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}
white camel
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
SpringMVC(四)：案例实现RESTFUL风格的CRUD操作
m0_64997559的博客
09-12 461
根据尚硅谷学习的在SpringMVC的RESUFUL风格的增删改查操作
Spring MVC之CRUD（简单实现）
qq_43580544的博客
06-13 1140
初步实现SpringMVC增删改查搭建springMVC环境基本构建CRUD 搭建springMVC环境 web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://j
MySQL：CRUD初阶(有图有实操)
最新发布
月临水的博客
05-20 1816
📑1. 数据库的操作 🌤️1.1 显示当前的数据库 🌤️1.2 创建数据库 🌤️1.3 选中数据库 🌤️1.4 删除数据库 📑2. 表的操作 🌤️2.1 查看表结构 🌤️2.2 创建表 🌤️2.3 删除表 🌤️2.4 向表中插入数据 💫2.4.1 单行数据 + 全列插入 💫2.4.2 多行数据 + 指定列插入 🌤️2.5 查询 💫2.5.1 全列查询 💫2.5.2 指定列查询 💫2.5.3 查询字段为表达式 💫2.5.4 别名(as) 💫2.5.5 去重distinct
【高效编程】SpringMVC框架如何与Junit整合，看这个就够了
m0_54850952的博客
03-02 781
您好，我是，感谢您阅读本文！如果此文对您有所帮助，请毫不犹豫的一键三连吧！本文主要介绍在SpringMVC框架整合Junit框架进行单元测试。闲话少述，让我们直入主题。 文章目录 系统环境 引入依赖 编写单元测试基类 代码说明 MockMvcRequestBuilders 返回结果的content-type是application/json的请求的单元测试 get请求测试 post请求测试 文件上传测试 发送一个json格式的数据到Controller层 返回结果是视图请求的单元测试
什么是CRUD？ CRUD的操作
热门推荐
DJyzh的博客
08-11 15万+
版权声明：转载请附上文章地址https://blog.csdn.net/qq_42672839 什么是CRUD？ CRUD的操作 CRUD是指在做计算处理时的增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)几个单词的首字母简写。主要被用在描述软件系统中DataBase或者持久层的基本操作功能。 数据库CRUD操作 一、删除表 dr...
MVC中CRUD
weixin_33795833的博客
03-02 61
今天看见页面操作中方法重载，里面提到过一点，Action处理的思路是：“从哪来回到哪里去”。 看下面代码截图 1 public ActionResult Delete(int id) 2 { 3 ViewData.Model = dbContext.ClassInfos.Find(id); 4 r...
ssm框架搭建——实现增删查改用户信息
06-28
这个项目"ssm框架搭建——实现增删查改用户信息"旨在教你如何利用这些框架搭建一个基础的用户管理系统，具备基本的CRUD（创建、读取、更新、删除）功能。 首先，我们需要安装并配置好相关的开发环境。这里提到的是...
SSM框架——项目详细搭建（Spring+SpringMVC+MyBatis + oracle）
05-04
6. **实体类与Mapper接口**：为数据库中的表创建对应的Java实体类，编写Mapper接口，实现对数据库的CRUD操作。 7. **Controller层**：编写Controller类，处理HTTP请求，调用Service层方法，将结果转发给视图。 8. ...
SpringMVC+MyBatis+Maven 完整项目
06-14
这个项目为初学者提供了完整的SpringMVC+MyBatis+Maven项目结构参考，包括了基本的配置、依赖管理和数据库操作，对于理解和实践这些技术非常有帮助。在实际开发中，你可能还需要添加更多的组件，如Spring Security...
基于springMVC+spring+mybatis+mysql框架的增删改查demo
07-07
在IT行业中，构建Web应用程序是常见的任务之一，而SpringMVC、Spring和Mybatis结合MySQL数据库的SSM框架是Java领域广泛使用的开发组合。这个基于SSM+MySQL的增删改查（CRUD）示例提供了对Web应用基础功能的实践演示...
springmvc-mybatis整合例子
04-09
标题 "springmvc-mybatis整合例子" 涉及到的是两个流行Java开发框架的集成——Spring MVC和MyBatis。Spring MVC是Spring框架的一部分，用于构建Web应用程序的模型-视图-控制器（MVC）架构，而MyBatis是一个轻量级的...
一个完整的Spring MVC的CRUD操作实例
05-25
NULL 博文链接：https://myclover.iteye.com/blog/455762
mvc三层架构中经典的CRUD写法(1)
忧桑的小猿猿
09-13 739
mvc三层架构中经典的CRUD写法(1) 需要： mysql驱动jar包，jdbcUtil工具类及其配置文件 ---------------------------------------------------------------------------------------------- dao接口层： public interface CustomerDao {  
Spring框架CRUD(配置文件+注解)
Mr_Li的博客
07-04 657
Spring框架CRUD(配置文件+注解) 注解开发流程 导入依赖 配置文件 applicationContext.xml 在需要创建对象的类上添加注解 测试 具体实现 导入依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xm...
SpringMVC模式编写CRUD操作
weixin_42543911的博客
03-27 652
首先是所有工程目录的展示。 1.展示所有图书（GET请求） index.jsp用于导航 点击Display all books后，请求将被之前配置好的DispatcherServlet拦截，拦截后的请求根据Controller类中的@RequestMapping注解运行相对的方法 display()方法的参数是一个Model类型，model用于装载集合list，并且转发到下一个...
springMVC入门 (简单crud)
Soul717的博客
12-22 475
1. 什么是springMVC?    Spring Web MVC是一种基于Java的实现了MVC设计模式的、请求驱动类型的、轻量级Web框架。     2.具体流程： （1）首先用户发送请求——&gt;DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制； （2）DispatcherServlet...
三、基本CRUD操作
runewbie的博客
10-26 3681
上一节我们完成了mybatis-plus的集成，也已经在mp01中添加相关的实体类的对应的数据库表，这一节我们来实现基于mybatis-plus的CRUD操作。 首先按照上一节的操作，新建一个mp02 的 Module,可以将mp01中的内容全部复制过来，同时进行一下修改： 修改 Employee实体类: /** * mybatis-plus默认会使用实体类的小写类...
SpringMVC 学习笔记（六）- 简单的 CRUD 练习（一）
0start1的博客
01-06 419
1. 显示所有员工信息 1.1. 根据以下步骤创建 springmvc 工程 1. 创建 springmvc - 2 动态 web 工程 最终的工程目录： 2. 导入 jar 包 具体 jar 包如下图 3. 配置 web.xml 文件 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;web-app xmlns:xsi="http://www...
SpringMVC 学习笔记(五) 基于RESTful的CRUD
胡小海丶
06-04 9383
当提交的表单带有_method字段时,通过HiddenHttpMethodFilter 将 POST 请求转换成 DELETE、PUT请求,加上@PathVariable注解从而实现 RESTful 风格的CRUD
完整版 Java开发实训课程系列-SpringMVC框架技术教程 第1章 springmvc概述 （共27页）.pptx
12-26
完整全套资源下载地址：https://download.csdn.net/download/qq_27595745/71319667 【完整课程列表】 完整版 Java开发实训课程系列-SpringMVC框架技术教程 第1章 springmvc概述 （共27页）.pptx 完整版 Java开发实训课程系列-SpringMVC框架技术教程 第2章 处理器映射器和适配器 （共22页）.pptx 完整版 Java开发实训课程系列-SpringMVC框架技术教程 第3章 映射请求和返回值 （共18页）.pptx 完整版 Java开发实训课程系列-SpringMVC框架技术教程 第4章 参数绑定 （共20页）.pptx 完整版 Java开发实训课程系列-SpringMVC框架技术教程 第5章 数据校验 （共26页）.pptx 完整版 Java开发实训课程系列-SpringMVC框架技术教程 第6章 异常处理 （共12页）.pptx 完整版 Java开发实训课程系列-SpringMVC框架技术教程 第7章 文件上传和json数据交互 （共30页）.pptx 完整版 Java开发实训课程系列-SpringMVC框架技术教程 第8章 拦截器 （共12页）.pptx 完整版 Java开发实训课程系列-SpringMVC框架技术教程 第9章 SSM框架整合 （共26页）.pptx

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

white camel

感谢支持~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值