好的，下面是
一个简单的SSM多模块项目：
1. 首先，创建
一个Maven项目，选择
一个合适的名称（例如“ssm-multimodule-project”）和位置。在创建时，选择“Create a simple project（创建
一个简单的项目）”，并勾选“Create a new module（创建新模块）”选项。
2. 在项目根目录下，创建
一个名为“parent”的模块。在“parent”模块下的pom.xml文件
中，指定项目的groupId、artifactId和version，并添加以下内容：
```xml
<packaging>pom</packaging>
<modules>
<module>web</module>
<module>service</module>
<module>dao</module>
</modules>
<dependencies>
<!-- 添加Spring依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.8.RELEASE</version>
</dependency>
<!-- 添加MyBatis依赖 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.4</version>
</dependency>
</dependencies>
```
在这里，我们创建了
一个Maven父子模块项目，定义了三个子模块（web、service和dao），并添加了Spring和MyBatis的依赖。
3. 创建
一个名为“web”的模块，用于实现Web服务。在“web”模块下的pom.xml文件
中，指定项目的groupId、artifactId和version，并添加以下内容：
```xml
<packaging>war</packaging>
<dependencies>
<!-- 添加SpringMVC依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.8.RELEASE</version>
</dependency>
<!-- 添加JSP依赖 -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
</dependencies>
```
在这里，我们创建了
一个War包，添加了SpringMVC和JSP的依赖。
4. 创建
一个名为“service”的模块，用于实现服务层。在“service”模块下的pom.xml文件
中，指定项目的groupId、artifactId和version，并添加以下内容：
```xml
<packaging>jar</packaging>
<dependencies>
<!-- 添加Spring依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.8.RELEASE</version>
</dependency>
</dependencies>
```
在这里，我们创建了
一个Jar包，添加了Spring的依赖。
5. 创建
一个名为“dao”的模块，用于实现数据访问层。在“dao”模块下的pom.xml文件
中，指定项目的groupId、artifactId和version，并添加以下内容：
```xml
<packaging>jar</packaging>
<dependencies>
<!-- 添加MyBatis依赖 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.4</version>
</dependency>
<!-- 添加MySQL驱动依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.21</version>
</dependency>
</dependencies>
```
在这里，我们创建了
一个Jar包，添加了MyBatis和MySQL驱动的依赖。
6. 在“web”模块下的src/main/webapp目录下，创建
一个名为“WEB-INF”的目录，并在其
中创建
一个名为“web.xml”的文件。在“web.xml”文件
中，添加以下内容：
```xml
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version="3.0">
<display-name>ssm-multimodule-project</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:application-context.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:spring-mvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-
mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-
mapping>
</web-app>
```
在这里，我们定义了SpringMVC的DispatcherServlet，并指定了SpringMVC
配置文件的位置。
7. 在“web”模块下的src/main/resources目录下，创建
一个名为“spring-mvc.xml”的文件，并添加以下内容：
```xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
<mvc:annotation-driven />
<mvc:resources location="classpath:/static/"
mapping="/static/**" />
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/" />
<property name="suffix" value=".jsp" />
</bean>
</beans>
```
在这里，我们定义了SpringMVC的注解驱动、静态资源访问路径和视图解析器。
8. 在“web”模块下的src/main/resources目录下，创建
一个名为“application-context.xml”的文件，并添加以下内容：
```xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
<import resource="classpath*:application-context-*.xml" />
</beans>
```
在这里，我们定义了应用上下文，引入了其他
配置文件。
9. 在“service”模块下的src/main/resources目录下，创建
一个名为“application-context-service.xml”的文件，并添加以下内容：
```xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
<!-- 定义Service组件 -->
<bean id="userService" class="com.example.service.UserService">
<property name="userDao" ref="userDao" />
</bean>
</beans>
```
在这里，我们定义了
一个UserService组件，并注入了UserDao组件。
10. 在“dao”模块下的src/main/resources目录下，创建
一个名为“application-context-dao.xml”的文件，并添加以下内容：
```xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
<!--
配置MyBatis -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/test" />
<property name="username" value="root" />
<property name="password" value="password" />
</bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.example.dao" />
</bean>
</beans>
```
在这里，我们定义了MyBatis的数据源、SqlSessionFactory和MapperScannerConfigurer。
11. 在“dao”模块下的src/main/java目录下，创建
一个名为“com.example.dao”的包，并在其
中创建
一个名为“UserDao”的接口和
一个名为“UserDaoImpl”的实现类。在“UserDao”接口
中定义数据访问方法，如下所示：
```java
public interface UserDao {
User findUserById(long id);
}
```
在“UserDaoImpl”实现类
中，实现“UserDao”接口
中的方法，并使用MyBatis的注解来映射SQL语句，如下所示：
```java
@Repository
public class UserDaoImpl implements UserDao {
@Autowired
private SqlSession sqlSession;
public User findUserById(long id) {
return sqlSession.selectOne("com.example.UserMapper.findUserById", id);
}
}
```
在这里，我们使用了@Repository注解，将UserDaoImpl组件声明为Spring的Repository组件，以便在其他组件
中进行依赖注入。
12. 在“service”模块下的src/main/java目录下，创建
一个名为“com.example.service”的包，并在其
中创建
一个名为“UserService”的类。在“UserService”类
中，实现业务逻辑，并注入“UserDao”组件，如下所示：
```java
@Service
public class UserService {
@Autowired
private UserDao userDao;
public User findUserById(long id) {
return userDao.findUserById(id);
}
}
```
在这里，我们使用了@Service注解，将UserService组件声明为Spring的Service组件，以便在其他组件
中进行依赖注入。
13. 在“web”模块下的src/main/java目录下，创建
一个名为“com.example.web”的包，并在其
中创建
一个名为“User
Controller”的类。在“User
Controller”类
中，实现对用户数据的访问，并使用SpringMVC的注解来处理HTTP请求和响应，如下所示：
```java
@
Controller
public class User
Controller {
@Autowired
private UserService userService;
@Request
Mapping(value = "/user/{id}", method = RequestMethod.GET)
public ModelAndView getUser(@PathVariable long id) {
ModelAndView mav = new ModelAndView("user");
User user = userService.findUserById(id);
mav.addObject("user", user);
return mav;
}
}
```
在这里，我们使用了@
Controller注解，将User
Controller组件声明为SpringMVC的
Controller组件，以便处理HTTP请求和响应。
14. 在“web”模块下的src/main/webapp/WEB-INF/views目录下，创建
一个名为“user.jsp”的文件，并添加以下内容：
```jsp
<html>
<head>
<title>User</title>
</head>
<body>
<h1>User Details</h1>
<p>ID: ${user.id}</p>
<p>Name: ${user.name}</p>
<p>Email: ${user.email}</p>
</body>
</html>
```
在这里，我们定义了用户详情页面，用于显示用户的详细信息。
15. 运行项目。在控制台
中输入以下命令：
```
mvn clean install tomcat7:run
```
该命令将编译并打包项目，并启动Tomcat服务器。在浏览器
中访问http://localhost:8080/ssm-multimodule-project/user/1，即可查看ID为1的用户的详细信息。
至此，我们已经完成了
一个简单的SSM多模块项目。在实际项目
中，可能需要添加更多的模块和功能，但是本例提供了
一个SSM多模块项目的基本结构和实现方法。
"在Springboot中，可以将多个精确的@RequestMapping映射到同一个Controller。实现方式是利用GetMapping等注解的value属性接受字符串数组的特性，例如：@GetMapping({"/data/user1","/data/user2"}
扫一扫
4675
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
