用java写一个完成的SSM多模块的项目,不要用springboot

好的，下面是一个简单的SSM多模块项目：

1. 首先，创建一个Maven项目，选择一个合适的名称（例如“ssm-multimodule-project”）和位置。在创建时，选择“Create a simple project（创建一个简单的项目）”，并勾选“Create a new module（创建新模块）”选项。

2. 在项目根目录下，创建一个名为“parent”的模块。在“parent”模块下的pom.xml文件中，指定项目的groupId、artifactId和version，并添加以下内容：

<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，并添加以下内容：

<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，并添加以下内容：

<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，并添加以下内容：

<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”文件中，添加以下内容：

<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”的文件，并添加以下内容：

<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”的文件，并添加以下内容：

<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”的文件，并添加以下内容：

<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”的文件，并添加以下内容：

<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”接口中定义数据访问方法，如下所示：

public interface UserDao {
    User findUserById(long id);
}

在“UserDaoImpl”实现类中，实现“UserDao”接口中的方法，并使用MyBatis的注解来映射SQL语句，如下所示：

@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”组件，如下所示：

@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请求和响应，如下所示：

@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”的文件，并添加以下内容：

<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多模块项目的基本结构和实现方法。