SSM框架整合(使用mybatis注解的方式)

SSM框架中的配置文件繁杂，此文帮大家疏通一下整体流程！

一环境准备

1.1 创建maven工程

如图所示：

输入一下信息：

groupId：组织名称

artifactId：项目名称

便可进入项目中

1.2添加本次项目需要的jar包

jar包版本号

<spring.version>5.0.2.RELEASE</spring.version>
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
<shiro.version>1.2.3</shiro.version>
<mysql.version>5.1.6</mysql.version>
<mybatis.version>3.4.5</mybatis.version>

对应的说明（坐标文件）

  1     <dependency>
  2       <groupId>junit</groupId>
  3       <artifactId>junit</artifactId>
  4       <version>4.11</version>
  5       <scope>test</scope>
  6     </dependency>
  7 
  8     <!-- spring -->
  9     <dependency>
 10       <groupId>org.aspectj</groupId>
 11       <artifactId>aspectjweaver</artifactId>
 12       <version>1.6.8</version>
 13     </dependency>
 14 
 15     <dependency>
 16       <groupId>org.springframework</groupId>
 17       <artifactId>spring-aop</artifactId>
 18       <version>${spring.version}</version>
 19     </dependency>
 20 
 21     <dependency>
 22       <groupId>org.springframework</groupId>
 23       <artifactId>spring-context</artifactId>
 24       <version>${spring.version}</version>
 25     </dependency>
 26 
 27     <dependency>
 28       <groupId>org.springframework</groupId>
 29       <artifactId>spring-web</artifactId>
 30       <version>${spring.version}</version>
 31     </dependency>
 32 
 33     <dependency>
 34       <groupId>org.springframework</groupId>
 35       <artifactId>spring-webmvc</artifactId>
 36       <version>${spring.version}</version>
 37     </dependency>
 38 
 39     <dependency>
 40       <groupId>org.springframework</groupId>
 41       <artifactId>spring-test</artifactId>
 42       <version>${spring.version}</version>
 43     </dependency>
 44 
 45     <dependency>
 46       <groupId>org.springframework</groupId>
 47       <artifactId>spring-tx</artifactId>
 48       <version>${spring.version}</version>
 49     </dependency>
 50 
 51     <dependency>
 52       <groupId>org.springframework</groupId>
 53       <artifactId>spring-jdbc</artifactId>
 54       <version>${spring.version}</version>
 55     </dependency>
 56 
 57     <dependency>
 58       <groupId>junit</groupId>
 59       <artifactId>junit</artifactId>
 60       <version>4.12</version>
 61       <scope>test</scope>
 62     </dependency>
 63 
 64     <dependency>
 65       <groupId>mysql</groupId>
 66       <artifactId>mysql-connector-java</artifactId>
 67       <version>${mysql.version}</version>
 68     </dependency>
 69 
 70     <dependency>
 71       <groupId>javax.servlet</groupId>
 72       <artifactId>servlet-api</artifactId>
 73       <version>2.5</version>
 74       <scope>provided</scope>
 75     </dependency>
 76 
 77     <dependency>
 78       <groupId>javax.servlet.jsp</groupId>
 79       <artifactId>jsp-api</artifactId>
 80       <version>2.0</version>
 81       <scope>provided</scope>
 82     </dependency>
 83 
 84     <dependency>
 85       <groupId>jstl</groupId>
 86       <artifactId>jstl</artifactId>
 87       <version>1.2</version>
 88     </dependency>
 89 
 90     <!-- log start -->
 91     <dependency>
 92       <groupId>log4j</groupId>
 93       <artifactId>log4j</artifactId>
 94       <version>${log4j.version}</version>
 95     </dependency>
 96 
 97     <dependency>
 98       <groupId>org.slf4j</groupId>
 99       <artifactId>slf4j-api</artifactId>
100       <version>${slf4j.version}</version>
101     </dependency>
102 
103     <dependency>
104       <groupId>org.slf4j</groupId>
105       <artifactId>slf4j-log4j12</artifactId>
106       <version>${slf4j.version}</version>
107     </dependency>
108     <!-- log end -->
109     <dependency>
110       <groupId>org.mybatis</groupId>
111       <artifactId>mybatis</artifactId>
112       <version>${mybatis.version}</version>
113     </dependency>
114 
115     <dependency>
116       <groupId>org.mybatis</groupId>
117       <artifactId>mybatis-spring</artifactId>
118       <version>1.3.0</version>
119     </dependency>
120 
121     <dependency>
122       <groupId>c3p0</groupId>
123       <artifactId>c3p0</artifactId>
124       <version>0.9.1.2</version>
125       <type>jar</type>
126       <scope>compile</scope>
127     </dependency>
128     <dependency>
129       <groupId>org.junit.jupiter</groupId>
130       <artifactId>junit-jupiter-api</artifactId>
131       <version>RELEASE</version>
132       <scope>compile</scope>
133     </dependency>
134     <dependency>
135       <groupId>org.junit.jupiter</groupId>
136       <artifactId>junit-jupiter-api</artifactId>
137       <version>RELEASE</version>
138       <scope>compile</scope>
139     </dependency>

1.3 标记文件夹

需要注意，要用IDEA中的mark as将文件夹分别标注为源代码和配置文件

1.4 编写实体类

 1 public class User {
 2     private int id;
 3     private String username;
 4     private Date birthday;
 5     private String sex;
 6     private String address;
 7 
 8     public int getId() {
 9         return id;
10     }
11 
12     public void setId(int id) {
13         this.id = id;
14     }
15 
16     public String getUsername() {
17         return username;
18     }
19 
20     public void setUsername(String username) {
21         this.username = username;
22     }
23 
24     public Date getBirthday() {
25         return birthday;
26     }
27 
28     public void setBirthday(Date birthday) {
29         this.birthday = birthday;
30     }
31 
32     public String getSex() {
33         return sex;
34     }
35 
36     public void setSex(String sex) {
37         this.sex = sex;
38     }
39 
40     public String getAddress() {
41         return address;
42     }
43 
44     public void setAddress(String address) {
45         this.address = address;
46     }
47 
48     @Override
49     public String toString() {
50         return "User{" +
51                 "id=" + id +
52                 ", username='" + username + '\'' +
53                 ", birthday=" + birthday +
54                 ", sex='" + sex + '\'' +
55                 ", address='" + address + '\'' +
56                 '}';
57     }
58 }

1.5 编写业务层接口和持久层接口

持久层接口

1 public interface IUserDao {
2     public List<User> findAll();
3 }

业务层接口

1 public interface IUserService {
2     public List<User> findAll();
3 }

二、Spring框架

2.1 编写spring配置文件

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:aop="http://www.springframework.org/schema/aop"
 5        xmlns:tx="http://www.springframework.org/schema/tx"
 6        xmlns:context="http://www.springframework.org/schema/context"
 7        xsi:schemaLocation="http://www.springframework.org/schema/beans
 8         http://www.springframework.org/schema/beans/spring-beans.xsd
 9         http://www.springframework.org/schema/tx
10         http://www.springframework.org/schema/tx/spring-tx.xsd
11         http://www.springframework.org/schema/aop
12         http://www.springframework.org/schema/aop/spring-aop.xsd
13         http://www.springframework.org/schema/context
14         http://www.springframework.org/schema/context/spring-context.xsd">
15     <!-- 配置 spring 创建容器时要扫描的包  -->
16     <context:component-scan base-package="com.justnow">
17         <!--制定扫包规则，不扫描@Controller 注解的 JAVA 类，其他的还是要扫描 -->
18         <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
19     </context:component-scan>
20 </beans>

使用componet-scan，可以让Spring自动识别哪些类需要被装配程Bean，从而减少在xml中的配置

2.2 使用注解配置业务层和持久层

此时，需要实现类，实现注解配置

其中持久层

 1 import java.util.List;
 2 
 3 @Repository("userDao")
 4 public class UserDaoImpl implements IUserDao {
 5     @Override
 6     public List<User> findAll() {
 7         System.out.println("查询了所有账户");
 8         return null;
 9     }
10 }

业务层

 1 @Service("userService")
 2 public class UserService implements IUserService {
 3 
 4     @Autowired
 5     private IUserDao userDao;
 6 
 7     @Override
 8     public List<User> findAll() {
 9         return userDao.findAll();
10     }
11 }

因为我们使用的是自动检测Bean的方式，所以要明确知道哪些类需要注册为spring Bean。此时，需要使用构造性(stereotype)来注解所标注的类

@Component：把资源让spring来管理，相当于在xml中配置了一个Bean

@Controller：一般用于表现层的注解

@Service：一般用于业务层的注解

@Repository：一般用于持久层的注解

后面三个是第一个的衍生注解，与@Commponent作用和属性是都一样，只不过是提供了更加明确的使用场景。

注解的value指定了Bean的id。如@Service("userService")，可以表示将该类注册为Bean，其中id为userService。如果没有指定value的话，该Bean的id为类名第一个字母小写

@Autowired：当Spring发现@Autowired注解时，将自动在代码上下文中找到与其匹配（默认是类型匹配）的Bean，并自动注入到相应的地方去。

2.3 测试spring能否独立运行

1 public class Test01Spring {
2     public static void main(String[] args) {
3         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
4         IUserService userService = (IUserService) context.getBean("userService");
5         userService.findAll();
6     }
7 }

拿到配置文件，根据id值实例化类，执行findAll方法

执行的结果为：

说明，上述的配置过程无问题！

三、配置SpringMvc框架

3.1 在web.xml中配置核心控制器(DIspatcherServlet)

① 配置spring mvc的核心控制器

② 解决中文乱码过滤器

③ 默认访问的文件

代码如下：

 1   <!-- 1、配置 spring mvc 的核心控制器 -->
 2   <servlet>
 3     <servlet-name>springmvcDispatcherServlet</servlet-name>
 4     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 5     <!-- 配置初始化参数，用于读取 springmvc 的配置文件 -->
 6     <init-param>
 7       <param-name>contextConfigLocation</param-name>
 8       <param-value>classpath:spring-mvc.xml</param-value>
 9     </init-param>
10     <!-- 配置 servlet 的对象的创建时间点：应用加载时创建。取值只能是非 0 正整数，表示启动顺序 -->
11     <load-on-startup>1</load-on-startup>
12   </servlet>
13   <servlet-mapping>
14     <servlet-name>springmvcDispatcherServlet</servlet-name>
15     <url-pattern>/</url-pattern>
16   </servlet-mapping>
17 
18   <!-- 2、解决中文乱码过滤器 -->
19   <filter>
20     <filter-name>characterEncodingFilter</filter-name>
21     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
22     <!--设置过滤中的属性值-->
23     <init-param>
24       <param-name>encoding</param-name>
25       <param-value>UTF-8</param-value>
26     </init-param>
27     <!--启动过滤器-->
28   </filter>
29   <!--过滤所有请求-->
30   <filter-mapping>
31     <filter-name>characterEncodingFilter</filter-name>
32     <url-pattern>/*</url-pattern>
33   </filter-mapping>
34 
35   <!--3、默认的访问文件-->
36   <welcome-file-list>
37     <welcome-file>index.html</welcome-file>
38     <welcome-file>index.htm</welcome-file>
39     <welcome-file>index.jsp</welcome-file>
40     <welcome-file>default.html</welcome-file>
41     <welcome-file>default.htm</welcome-file>
42     <welcome-file>default.jsp</welcome-file>
43   </welcome-file-list>

3.2 编写SpringMVC的配置文件spring-mvc.xml

① 扫描controller的注解，别的不扫描

② 配置视图解析器

③ 开启对SpringMVC注解的支持

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:mvc="http://www.springframework.org/schema/mvc"
 4        xmlns:context="http://www.springframework.org/schema/context"
 5        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 6        xmlns:aop="http://www.springframework.org/schema/aop"
 7        xsi:schemaLocation="
 8            http://www.springframework.org/schema/beans
 9            http://www.springframework.org/schema/beans/spring-beans.xsd
10            http://www.springframework.org/schema/mvc
11            http://www.springframework.org/schema/mvc/spring-mvc.xsd
12            http://www.springframework.org/schema/context
13            http://www.springframework.org/schema/context/spring-context.xsd
14            http://www.springframework.org/schema/aop
15         http://www.springframework.org/schema/aop/spring-aop.xsd
16            ">
17 
18     <!-- 1、扫描controller的注解，别的不扫描 -->
19     <context:component-scan base-package="com.justnow.controller">
20     </context:component-scan>
21 
22     <!-- 2、配置视图解析器 -->
23     <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
24         <!-- JSP文件所在的目录 -->
25         <property name="prefix" value="/pages/" />
26         <!-- 文件的后缀名 -->
27         <property name="suffix" value=".jsp" />
28     </bean>
29 
30     <!--3、开启对SpringMVC注解的支持 -->
31     <mvc:annotation-driven />
32 
33 
34 </beans>

3.3 编写Controller和jsp视图，测试

此处并没有连接数据库，所以只是测试

创建UserController

 1 package com.justnow.controller;
 2 
 3 import org.springframework.stereotype.Controller;
 4 import org.springframework.web.bind.annotation.RequestMapping;
 5 
 6 @Controller
 7 @RequestMapping("/user")
 8 public class UserController {
 9     @RequestMapping("/findAll")
10     public String findAll(){
11         System.out.println("测试通过");
12         return "userList";
13     }
14 }

当访问/user/findAll的时候，就会在控制台打印"测试通过"

修改index.jsp为

1 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
2 <html>
3 <body>
4 <h2>Hello World!</h2>
5 <a href="${pageContext.request.contextPath}/user/findAll">click</a>
6 </body>
7 </html>

最后的测试效果

四、整合Spring和SpringMVC

4.1 配置监听器实现启动服务创建容器

在web.xml中添加以下内容

 1   <!--配置spring提供的监听器，用于启动服务器时加载容器。该监听器只能加载WEB-INF目录中名称为applicationContext.xml的配置文件，所以需要手动指定spring配置文件的位置-->
 2   <listener>
 3     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 4   </listener>
 5 
 6   <!--手动指定spring配置文件位置-->
 7   <context-param>
 8     <param-name>contextConfigLocation</param-name>
 9     <param-value>classpath:applicationContext.xml</param-value>
10   </context-param>

五、使用Mybatis

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

5.1 编写SqlMapConfig.xml的配置文件

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE configuration
 3         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 5 <configuration>
 6     <properties resource="jdbcConfig.properties"></properties>
 7     <environments default="mysql">
 8         <environment id="mysql">
 9             <transactionManager type="JDBC"></transactionManager>
10             <dataSource type="pooled">
11                 <property name="driver" value="${jdbc.driver}"/>
12                 <property name="url" value="${jdbc.url}"/>
13                 <property name="username" value="${jdbc.username}"/>
14                 <property name="password" value="${jdbc.password}"/>
15             </dataSource>
16         </environment>
17     </environments>
18     <mappers>
19         <!--该包下所有的dao接口-->
20         <package name="com.justnow.dao"/>
21     </mappers>
22 </configuration>

使用mybatis的注解配置，所以不需要再写对应接口的映射文件

5.2 在IUserDao接口的方法上添加注解，编写SQL语句

 1 package com.justnow.dao;
 2 
 3 import com.justnow.domain.User;
 4 import org.apache.ibatis.annotations.Select;
 5 
 6 import java.util.List;
 7 
 8 public interface IUserDao {
 9     @Select("select * from user")
10     public List<User> findAll();
11 }

5.3 写测试类，查看结果

强调，Resource类来自mybatis的包下，不要导错了

 1 package test;
 2 
 3 import com.justnow.dao.IUserDao;
 4 import com.justnow.domain.User;
 5 import org.apache.ibatis.io.Resources;
 6 import org.apache.ibatis.session.SqlSession;
 7 import org.apache.ibatis.session.SqlSessionFactory;
 8 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 9 import org.junit.jupiter.api.Test;
10 
11 import java.io.IOException;
12 import java.io.InputStream;
13 import java.util.List;
14 
15 
16 public class Test02Mybatis {
17     @Test
18     public void test() throws IOException {
19         //加载配置文件
20         InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
21         //创建工厂
22         SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
23         //创建sqlSession对象
24         SqlSession session = factory.openSession();
25         //获取代理对象
26         IUserDao dao = session.getMapper(IUserDao.class);
27         //调用查询的方法
28         List<User> list = dao.findAll();
29         for (User user : list) {
30             System.out.println(user);
31         }
32         //释放资源
33         session.close();
34         inputStream.close();
35     }
36 }

查看测试结果

六 Spring整合Mybatis框架

6.1 SqlMapConfig.xm配置文件的内容配置到applicationContext.xml中

注意：配置完成后，直接删除SqlMapConfig.xml。

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:aop="http://www.springframework.org/schema/aop"
 5        xmlns:tx="http://www.springframework.org/schema/tx"
 6        xmlns:context="http://www.springframework.org/schema/context"
 7        xsi:schemaLocation="http://www.springframework.org/schema/beans
 8         http://www.springframework.org/schema/beans/spring-beans.xsd
 9         http://www.springframework.org/schema/tx
10         http://www.springframework.org/schema/tx/spring-tx.xsd
11         http://www.springframework.org/schema/aop
12         http://www.springframework.org/schema/aop/spring-aop.xsd
13         http://www.springframework.org/schema/context
14         http://www.springframework.org/schema/context/spring-context.xsd">
15     <!-- 配置 spring 创建容器时要扫描的包 -->
16     <context:component-scan base-package="com.justnow">
17         <!--制定扫包规则，不扫描@Controller 注解的 JAVA 类，其他的还是要扫描 -->
18         <context:exclude-filter type="annotation"
19                                 expression="org.springframework.stereotype.Controller" />
20     </context:component-scan>
21 
22     <!--加载配置文件-->
23     <context:property-placeholder location="classpath:jdbcConfig.properties" />
24 
25     <!--配置数据源-->
26     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
27         <property name="driverClass" value="${jdbc.driver}"></property>
28         <property name="jdbcUrl" value="${jdbc.url}"></property>
29         <property name="user" value="${jdbc.username}"></property>
30         <property name="password" value="${jdbc.password}"></property>
31     </bean>
32     <!--配置mybatis的Session工厂-->
33     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
34         <!--数据库连接池-->
35         <property name="dataSource" ref="dataSource"/>
36 
37         <!-- 扫描sql配置文件:mapper需要的xml文件 -->
38         <property name="mapperLocations" value="classpath:mapper/*.xml"/>
39     </bean>
40 
41     <!--配置扫描dao接口包，动态实现dao接口，注入到spring容器中-->
42     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
43         <!-- 注入sqlSessionFactory -->
44         <property name="basePackage" value="com.justnow.ssm.dao"/>
45     </bean>
46 
47 
48 </beans>

6.2 删除dao接口的实现类，并修改Controller

 1 package com.justnow.controller;
 2 
 3 import com.justnow.domain.User;
 4 import com.justnow.service.IUserService;
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.stereotype.Controller;
 7 import org.springframework.web.bind.annotation.RequestMapping;
 8 import org.springframework.web.servlet.ModelAndView;
 9 
10 import java.util.List;
11 
12 @Controller
13 @RequestMapping("/user")
14 public class UserController {
15     @Autowired
16     private IUserService userService;
17 
18     @RequestMapping("/findAll")
19     public ModelAndView findAll(){
20         ModelAndView mv = new ModelAndView();
21         List<User> userList = userService.findAll();
22         mv.addObject("userList", userList);
23         mv.setViewName("userList");
24         return mv;
25     }
26 }

6.3 修改jsp页面，读取服务器返回的参数

 1 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 2 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
 3 <html>
 4 <head>
 5     <title>title</title>
 6 </head>
 7 <body>
 8     我是userList界面
 9     展示user信息
10     <table border="1px">
11         <tr>
12             <th>id</th>
13             <th>username</th>
14             <th>birthday</th>
15             <th>sex</th>
16             <th>address</th>
17         </tr>
18 
19             <c:forEach items="${userList}" var="user">
20                 <tr>
21                     <td>${user.id}</td>
22                     <td>${user.username}</td>
23                     <td>${user.birthday}</td>
24                     <td>${user.sex}</td>
25                     <td>${user.address}</td>
26                 </tr>
27             </c:forEach>
28 
29     </table>
30 </body>
31 </html>

6.4 访问后的结果为：

七 Spring 配置注解事务

7.1 配置注解事务

如果不同的用户同时插入数据，那么这时候就需要事务来处理问题。在applicationContenxt.xml中配置用注解的方法来设置事务的相关属性

1     <!--3 配置Spring的声明式事务管理 -->
2     <!--3.1 配置事务管理器 -->
3     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
4         <property name="dataSource" ref="dataSource"/>
5     </bean>
6 
7     <!--3.2 事务驱动注解-->
8     <tx:annotation-driven transaction-manager="transactionManager"/>

同时在service的实现类中添加@Transactional

这里使用的默认的事务属性，找到注解的源代码

7.2 添加jsp页面、修改controller、service、dao代码

userInsert.jsp

 1 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 2 <html>
 3 <head>
 4     <title>title</title>
 5 </head>
 6 <body>
 7 
 8 <form action="${pageContext.request.contextPath}/user/save" method="post">
 9     id<input type="text" name="id">
10     username<input type="text" name="username"><br>
11     birthday<input type="date" name="birthday"><br>
12     sex<input type="text" name="sex"><br>
13     address<input type="text" name="address"><br>
14     <input type="submit" value="提交">
15 </form>
16 </body>
17 </html>

在dao中添加插入方法

package com.justnow.dao;

import com.justnow.domain.User;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;


public interface IUserDao {
    @Select("select * from user")
    public List<User> findAll();

    @Insert("insert into user(id, username, birthday, sex, address) values (#{id}, #{username}, #{birthday}, #{sex}, #{address})")
    public void save(User user);
}

在service中添加插入方法

在controller中添加两个映射，一个跳转到userInsert.jsp页面，一个是form表单中提交后，重定向到用户列表页面userList.jsp中

注意：因为提交中参数出现了日期，所以必须在实体类中确定日期的格式。用注解的方法实现

现在开始测试，

第一步：打开user/add,并填入内容

第二步：查看是否插入成功

ok!,搞定

附上本次项目源代码：

https://github.com/justn0w/javawebdemo/tree/master/ssmdemo

posted @ 2019-08-21 20:54 justn0w 阅读(4526) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

justn0w