好的，下面是一个简单的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”的包，并在其中创建一个名为“UserController”的类。在“UserController”类中，实现对用户数据的
访问，并使用
SpringMVC的注解来处理HTTP请求和响应，如下所示：
```
java
@Controller
public class UserController {
@Autowired
private UserService userService;
@RequestMapping(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注解，将UserController组件声明为
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多
模块项目的基本结构和实现方法。
561
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
