idea搭建基于SSM的javaweb项目，保姆级包看包会

 

第一步：创建Maven项目，配置相应的依赖

(1)创建项目

(2)选择maven，勾选然后往下翻，找到webapp

(3)创建目录

(4)修改pom.xml，加入依赖

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.zs</groupId>
  <artifactId>furn-ssm</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>furn-ssm Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--======================= springmvc============================ -->
    <!--引入springmvc  这会也会导入spring的库-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.8</version>
    </dependency>
    <!--引入spring-jdbc支持事务相关-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.3.8</version>
    </dependency>
    <!--引入spring aspects切面编程需要的库-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.3.8</version>
    </dependency>
    <!-- 引入 jackson,处理 json 数据 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.12.4</version>
    </dependency>
    <!--JSR303数据校验支持 引入hibernate-->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>6.1.0.Final</version>
    </dependency>
    <!--======================= mybatis整合============================ -->
    <!--引入mybatis-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.7</version>
    </dependency>
    <!--引入druid数据库连接池-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.2.6</version>
    </dependency>
    <!--引入mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.49</version>
    </dependency>
    <!--引入mybatis分页插件-->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.2.1</version>
    </dependency>
    <!-- 引入 mybatis 逆向工程依赖包 -->
    <dependency>
      <groupId>org.mybatis.generator</groupId>
      <artifactId>mybatis-generator-core</artifactId>
      <version>1.4.0</version>
    </dependency>
    <!--======================= spring整合mybatis============================ -->
    <!--引入mybatis整合spring的适配库-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.6</version>
    </dependency>

  </dependencies>

</project>

 加入依赖之后需要刷新maven，不然这些依赖不会生效。

第二步：配置tomcat

第三步：配置 web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--第一步、  配置启动 Spring 容器:主要配置和业务逻辑有关的，比如数据源，事务控制等-->
  <!--注意 配置完可能会报红，不用怕，因为这是还没有写对应的其他配置文件-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <!--
    1、ContextLoaderListener 监听器作用是启动 Web 容器时，自动装配 ApplicationContext 的配置信息
    2、它实现了 ServletContextListener 接口，在 web.xml 配置该监听器，启动容器时，会默认执行它实现的方法
  -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!--第二步、SpringMVC 的前端控制器，拦截所有请求
      解读
      1. springmvc 中央控制器
      2. 负责处理所有的应用请求
      3. 如果没有指定 springmvc 的配置文件，默认为 servlet-name 值-servlet.xml
      4. 如果指定了 springmvc 的配置文件，则以指定的为准
      -->
  <servlet>
    <servlet-name>springDispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springDispatcherServlet</servlet-name>
    <!--用户的所有请求，都经过中央控制器-->
    <url-pattern>/</url-pattern>
  </servlet-mapping>

 <!--第三步、字符编码过滤器，一定要放在所有过滤器的最前面
    源码解读
    (1) 如果 forceRequestEncoding 设置为 true, 执行request.setCharacterEncoding(encoding)
    (2) 如果 forceResponseEncoding 设置为 true, 执行response.setCharacterEncoding(encoding);
  -->
  <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>

  <!-- 第四步、配置 HiddenHttpMethodFilter,
    使用 Rest 风格的 URI，可以把页面发过来的 post 请求转为指定的 delete 或者 put 请求
  -->
  <filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

</web-app>

注意 配置完可能会报红，不用怕，因为这是还没有写对应的其他配置文件。

第四步：SpringMVC 配置

（1）这时要先把一些包创建起来了

(2)写springMVC配置文件，里面的注释很清楚，要有耐心瞅一下。除非你创建的东西跟本文章一摸一样。

因为springMVC用于构建Web应用程序，并且在web.xml中配置了相关属性。所以创建文件要在WEB-INF下面，而且注意文件名和后缀。

<?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">

    <!-- 解读
        1. 扫描 com.zs 包
        2. use-default-filters="false" 禁用默认过滤规则
        3. context:include-filter 配置说明 只是扫描控制器
    -->
    <context:component-scan base-package="com.zs" use-default-filters="false">
        <!-- SpringMVC 只扫描控制器-->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 配置视图解析器，指定页面返回-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"></property>
        <property name="suffix" value=".html"></property>
    </bean>

    <!-- 两个常规配置 -->
    <!-- 将 SpringMVC 不能处理的请求交给 Tomcat, 比如请求 css,js 等-->
    <mvc:default-servlet-handler/>
    <!-- 能支持 SpringMVC 高级功能，比如 JSR303 校验，映射动态请求-->
    <mvc:annotation-driven/>
</beans>

第五步：配置 Spring 和 MyBatis , 并完成整合

只要是spring文件，就是右键->New->XML configuration -> Spring Config

spring文件：

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

    <!-- spring 的配置文件 : 主要配置和业务逻辑有关的，比如数据源，事务控制等 -->
    <!-- 1. 扫描 com.zs.exercise 包
        2. context:exclude-filter 配置说明 不扫描控制器@Controller注解
    -->
    <context:component-scan base-package="com.zs.exercise">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 数据源配置
        1. 引入外部配置文件 : jdbc.properties 放在 resources 下
    -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="pooledDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"></property>
        <property name="driverClassName" value="${jdbc.driverClass}"></property>
        <property name="username" value="${jdbc.userName}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <!--配置spring和mybatis整合
        1.在项目中引入mybatis整合到spring的适配库
    -->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
        <!--指定mybatis全局配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!--指定数据源-->
        <property name="dataSource" ref="pooledDataSource"/>
        <!--指定mybatis的mapper文件位置
            1.开发中通常将 mapper.xml 放在类路径 resources/mapper
        -->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>

    <!-- 配置扫描器，将 mybatis 接口的实现加入到 ioc 容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 1. 扫描所有的 dao 接口的实现，加入到 ioc 容器中
             2. 这里 dao 接口，就是 mapper 接口,接口都在com.zs.furn.dao目录下
        -->
        <property name="basePackage" value="com.zs.exercise.dao"/>
    </bean>

    <!-- 配置事务控制-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 指定数据源-->
        <property name="dataSource" ref="pooledDataSource"></property>
    </bean>

    <!-- 解读
        1. 开启基于注解的事务，并指定切入点
        2. execution(* com.zs.exercise.service..*(..)):
        表示对 com.zs.exercise.service 包所有类的所有方法控制事务
        3. tx:advice : 配置事务增强, 也就是指定事务如何切入
    -->
    <aop:config>
        <!-- 切入点表达式 -->
        <aop:pointcut id="txPoint" expression="execution(* com.zs.exercise.service..*(..))"/>
        <!-- 配置事务增强: 使用 txAdvice 指定规则对 txPoint 进行切入-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
    </aop:config>
    <!-- 配置事务增强，也就是指定事务如何切入-->
    <tx:advice id="txAdvice">
        <tx:attributes>
            <!-- *代表所有方法都是事务方法-->
            <tx:method name="*"/>
            <!-- 以 get 开始的所有方法 ，我们认为是只读，进行调优-->
            <tx:method name="get*" read-only="true"/>
        </tx:attributes>
    </tx:advice>
</beans>

mybatis文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--配置mybatis自带的日志输出，查看原生的sql-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
        <!-- 1. 如果一个包下有很多的类，我们可以直接引入包
             2. 这样该包下面的所有类名，可以直接使用
        -->
    <!--对包下面的类起别名-->
    <typeAliases>
        <package name="com.zs.exercise.bean"/>
    </typeAliases>
    <!--
        1.plugins标签需要放在typeAliases标签后，是doctype约束的
        2.配置分页拦截器
    -->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <!--
                配置分页合理化
                1.如果用户请求的pageNum>pages，就显示查询最后一页
                2.如果请求的pageNum<0 ，默认查询第一页
            -->
            <property name="reasonable" value="true"/>
        </plugin>
    </plugins>

</configuration>

数据库配置文件：

#这个是登录数据库的用户名
jdbc.userName=root
#这个是登录数据库的密码
jdbc.password=zs123
#这个是登录数据库的连接方式
jdbc.driverClass=com.mysql.jdbc.Driver
#dbc:mysql://localhost:3306这个是登录数据库端口和方法
#exercise 这个是指定登录哪个数据库
#userSSL=true& 这个是安全连接
#userUnicode=true&characterEncoding=UTF-8  编码格式
jdbc.url=jdbc:mysql://localhost:3306/exercise?userSSL=true&userUnicode=true&characterEncoding=UTF-8

 配置逆向工程

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
    <context id="DB2Tables" targetRuntime="MyBatis3">
        <!-- 生成没有注释的 bean-->
        <commentGenerator>
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>
        <!-- 配置数据库连接信息-->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/exercise?characterEncoding=utf8"
                        userId="root"
                        password="root">
        </jdbcConnection>
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>
        <!-- 指定 javaBean 生成的位置-->
        <javaModelGenerator targetPackage="com.zs.exerciese.bean"
                            targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true"/>
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>
        <!-- 指定 sql 映射文件生成的位置-->
        <sqlMapGenerator targetPackage="mapper" targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>
        <!-- 指定 dao 接口生成的位置, 也就是 mapper 接口-->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.zs.exerciese.dao"
                             targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>
        <!-- 指定要逆向生成的表和生成策略-->
        <!--我这里在数据库创建的是user表，所以写user-->
        <table tableName="user" domainObjectName="User"></table>
    </context>
</generatorConfiguration>

最后就是测试了。

(1)创建文件夹

(2)测试使用逆向工程：

注意：要首先需要去创建数据库和表，并且配置文件中的库和表的信息要写正确

package com.zs.exercise;

import org.junit.Test;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class MBGTest {

    @Test
    public void generator() throws Exception {
        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        //指定配置文件
        File configFile = new File("mbg.xml");
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
        myBatisGenerator.generate(null);
        System.out.println("逆向生成 OK");
    }
}

(3)测试是否配置可以正常互相支持

package com.zs.exercise.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class T1 {

    @Test
    public void t1(){
        //1.获取到容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");

        //2.获取Bean
        System.out.println(ioc.getBean("pooledDataSource"));
        System.out.println(ioc.getBean("sqlSessionFactory"));
    }
}

（4）测试tomcat页面访问正常跳转

创建一个类和一个页面

类代码

package com.zs.exercise.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class Demo {

    @RequestMapping("/demo")
    public String demo(){
        System.out.println("测试");
        return "demo";
    }
}

页面代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>测试</title>
</head>
<body>
<h1>这是我的第一个测试Demo</h1>
</body>
</html>

代码整完，启动tomcat完成测试

结束：基本框架就搭建完毕。通过逆向工程生成的信息，去完成业务即可。