【基础练习】一个SSM项目的自我修养，极简版，IDEA开发

本文链接：https://blog.csdn.net/qq_34093082/article/details/100571944

1、编写applicationContext.xml文件，用来配置Spring

2、加入log4j.properties

3、改写web.xml文件，将SpringMVC.xml文件放到项目中

4、编写SpringMVC.xml文件

5、添加过滤器（SpringMVC成功加入）

6、添加监听器（Spring成功加入）

7、测试Mybatis框架（sqlMapConfig.xml文件登场）

8、Spring整合Mybatis

9、建Mapper.xml文件并且加入到整合当中

前言

SSM框架，即为 SpringMVC+Spring+Mybatis的项目结构，是实现WEB项目常用的框架，同时也是很多公司到目前为止还在采用的框架结构。

①Mybatis自然就是对JDBC的封装，是使用户只注重于sql语句的框架，配置完配置文件之后，它让JDBC的加载数据库驱动，获取连接以及后面的释放资源对用户不可见，用户写完sql语句之后，mybatis就能自动执行得到结果

②SpirngMVC是一个前端控制器，普通的WEB项目我们有Servlet name, Servlet class 或者@WebServlet，将控制器注入，并且和前端的相应的链接请求对用起来，那么SpringMVC则提供了注解扫描，现在@controller注解标识控制层，同时还有视图解析器和拦截静态资源，一切都通过SpringMVC的注解来完成。

③Spring框架则包括两部分，一部分是页面的扫描，它将service层和dao层可以通过后台跳转，然后另一部分是Spring-Mybatis

的部分，是将Mybatis的东西整合到框架里头。

1、编写applicationContext.xml文件，用来配置Spring

首先新建项目目录结构，在新建项目的时候，选择maven项目，然后使用点击模板是Apache的web-start模板，新建之后建立java、resources和webapp文件夹，分别mark为root、sourceroot和普通文件夹。然后在java底下依次建立后台所需的文件夹。

在service底下写一个userService.java文件，里面写一段输出语句。例如输入业务层查询。

然后在resources底下建一个applicationContext.xml文件

<?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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:tx="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">

<!--    开启注解扫描,只希望处理service和dao-->
    <context:component-scan base-package="com.txy">
        <!--        配置哪些东西不扫描-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

接着就可以编写一个测试文件，用来测试spring是否正确完成后台的跳转。

public class TestSpring {
    @Test
    public void run1(){
        //加载配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        //获取对象
        UserService as =  (UserService) ac.getBean("userService");
        //调用方法
        as.findAll();
    }
}

as.findAll()是调用了findAll()方法，然后打印一条消息。

2、加入log4j.properties

log4j.properties文件可以当理解就好，不用自己去写。

#定义LOG输出级别
log4j.rootLogger=INFO,Console,File
#定义日志输出目的地为控制台
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out
#可以灵活地指定日志输出格式，下面一行是指定具体的格式
log4j.appender.Console.layout = org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n

#文件大小到达指定尺寸的时候产生一个新的文件
log4j.appender.File = org.apache.log4j.RollingFileAppender
#指定输出目录
#log4j.appender.File.File = logs/ssm.log
log4j.appender.File.File = D:/zmall-workspace/log/ssm.log
#定义文件最大大小
log4j.appender.File.MaxFileSize = 10MB
# 输出所以日志，如果换成DEBUG表示输出DEBUG以上级别日志
log4j.appender.File.Threshold = ALL
log4j.appender.File.layout = org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

3、改写web.xml文件，将SpringMVC.xml文件放到项目中

这一步的目的是提前做好SpringMVC的相关配置，但是因为我们还没有SpringMVC.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>

    <!--配置前端控制器-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--    加载springMvc.xml的配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
<!--    启动服务器，创建该servlet-->
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

</web-app>

SpringMVC加入的过程用到了servlet-name 和 serservlet-class ，对应的是dispatcherServlet用于做职责的分发。这些配置先完成，我们在去考虑SpringMVC里面应该包括什么。

4、编写SpringMVC.xml文件

SpringMVC文件应该包括，指定控制器的位置，指定前端页面的位置，过滤静态资源，支持SpringMVC的注解。

所以它是这样的：

<!--    开启注解扫描，只扫描controller注解-->
    <context:component-scan base-package="com.txy">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
<!--    配置的视图解析器对象-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
<!--    过滤静态资源-->
    <mvc:resources location="/css/" mapping="/css/**"/>
    <mvc:resources location="/images/" mapping="/images/**"/>
    <mvc:resources location="/js/" mapping="/js/**"/>
<!--    开启SpringMVC注解的支持-->
    <mvc:annotation-driven/>

5、添加过滤器（SpringMVC成功加入）

过滤器应该放在servlet前面，我这里使用过滤器的目的是解决中文乱码的问题，做到这一步之后，SpringMVC的框架就被成功加入到项目当中。

  <!--  解决中文乱码过滤器-->
  <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>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

这个时候，我们怎么测试用户已经成功配置好了SpringMVC框架了呢，很简单啊，只要在前端写一个跳转，例如叫做User/login,然后在后端写个controller，写一段输出，看看能否成功跳到，只要能跳到，就是成功配置了SpringMVC。

6、添加监听器（Spring成功加入）

添加监听器，监听器可以加载applicationContext.xml文件，这样，我们就将实现配置好的spring框架加入到了项目当中了，我们之前是写了一个测试类，用来测试Spring框架是否正确扫描到了，现在是正式加入到项目当中。

  <display-name>Archetype Created Web Application</display-name>
  <!--配置监听器。默认只加载web-inf 的applicationContext.xml-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!--  设置配置文件路径-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

7、测试Mybatis框架（sqlMapConfig.xml文件登场）

我们在将mybaits整合到Spring当中，先编写一个配置文件，测试一下mybaits单独拎出来是怎么连接数据库然后进行sql语句查询。

<?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>
<!--    配置环境-->
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/zmall?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone=UTC" />
                <property name="username" value="root" />
                <property name="password" value="123456" />
            </dataSource>
        </environment>
    </environments>

<!--    引入配置文件-->
    <mappers>
<!--        <mapper class="com.txy.dao.UserDao"></mapper>-->
        <package name="com.txy.dao"/>
    </mappers>
</configuration>

可以看到这里也是双边配置，一边配置的是数据库连接的驱动，连接，用户名、密码，另一边配置到dao文件夹里头，然后这样子数据库的连接配置和数据库语句的查询就分离开了，也就是之前说的Mybatis只注重sql语句。这里我们在写dao的sql语句用的是注入的方式。

@Select（"select * from t_user"）
public List<User> findAll();

稍后我们会采用xml文件的方式实现数据库查询，就不用这样的注入的方式了。

这个时候写TestMybatis的测试类，它的连接过程和我们之后整合的过程是一致的，所以很有借鉴意义，这个过程就是加载配置文件，创建工厂对象，通过工厂获得Session会话，然后get class 获取到代理对象，使用它查询所有数据就行。用完了之后，记得要关闭资源。

    @Test
    public void run1() throws Exception {
        //加载mybatis的配置文件
        InputStream in = Resources.getResourceAsStream("sqlMapConfig.xml");
        //创建sqlSessionFactory对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //创建sqlSession对象
        SqlSession session = factory.openSession();
        //获取到代理对象
        UserDao dao = session.getMapper(UserDao.class);
        //查询所有数据
        List<User> userList= dao.findAll();
        for(User user :userList){
            System.out.println(user);
        }
        session.close();
        in.close();
    }

8、Spring整合Mybatis

之前是写了sqlMapConfig.xml文件来测试MyBatis这个框架的作用是什么。但是我们是要把mybatis整合到项目里的，所以从这里开始，sqlMapConfig.xml文件会作为参考，而不会真正参与到项目当中。

在applicationContext.xml文件当中，我们需要加入如下代码：

<!--    引入配置文件-->
    <bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties" />
    </bean>
<!--    Spring 整合 mybaits的对象-->
<!--    配置连接池-->
    <!-- 基于Druid数据库链接池的数据源配置 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <!-- 基本属性driverClassName、 url、user、password -->
        <property name="driverClassName" value="${driver}" />
        <property name="url" value="${url}" />
        <property name="username" value="${username}" />
        <property name="password" value="${password}" />
        <!-- 配置初始化大小、最小、最大 -->
        <!-- 通常来说，只需要修改initialSize、minIdle、maxActive -->
        <!-- 初始化连接大小 -->
        <property name="initialSize" value="2" />
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="2" />
        <!-- 连接池最大使用连接数量 -->
        <property name="maxActive" value="100" />
        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="5000" />
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="30000" />
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000" />
        <property name="validationQuery" value="${druid.validationQuery}" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />
        <property name="testWhileIdle" value="true" />
        <!-- 解密密码必须要配置的项 <property name="filters" value="config" /> <property name="connectionProperties"
            value="config.decrypt=true" /> -->
    </bean>


<!--    配置sqlSessionFactory，工厂能帮我创建session，有了session就能拿到代理对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />

    </bean>


<!--    配置接口所在的包，mybaits的东西放到spring当中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.txy.dao" />
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>

<!--    配置spring框架声明式事务管理-->
<!--    配置事务管理器-->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

这也是内容最多的一块地方，慢慢讲，依赖中首先加入mysql druid连接池的依赖，然后，编写一个jdbc.properties的配置文件，用于存储我们的数据账户的信息。

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/zmall?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
username=root
#这个地方的名称仅仅是单纯的名称，便于你在引用的时候可以写名字而非值直接用

password=123456
initialSize=0
maxActive=20
maxIdle=20
minIdle=1
maxWait=60000
druid.validationQuery=select 1 from dual

接着引入这个配置文件

然后将配置文件的值依次填入连接属性当中

然后创建bean工厂，通过工厂创建session会话，有了session会话就能拿到代理对象，拿到代理对象就可以通过它去执行sql语句，和之前测试类不一样的地方就是：

1、将mybaits通过mapperScanner加入到spring当中去，此时扫描的是整个package，而不是单个的class。

2、加入了事务管理器

9、建Mapper.xml文件并且加入到整合当中

那我们不能每次都用注入的方式来实现Mybatis的语句查询吧，此时就使用Mapper.xml文件来放sql查询语句，将数据库的语句进一步分开，通过namespace和select id 来指定对应的包和方法名，此时 findAll() 就真正落实到了数据库查询当中了。

UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.txy.dao.UserDao">
  <resultMap id="BaseResultMap" type="com.txy.entity.User">
    <!--
      WARNING - @mbg.generated
    -->
    <id column="user_id" jdbcType="INTEGER" property="userId" />
    <result column="user_name" jdbcType="VARCHAR" property="userName" />
    <result column="user_pwd" jdbcType="VARCHAR" property="userPwd" />
    <result column="user_age" jdbcType="INTEGER" property="userAge" />
    <result column="user_gender" jdbcType="VARCHAR" property="userGender" />
  </resultMap>


  <select id="findAll" resultMap="BaseResultMap">
        select * from zmall_user
   </select>

  <insert id="saveUser" parameterType="com.txy.entity.User">
        insert into zmall_user values(#{userId},#{userName},#{userPwd},#{userAge},#{userGender})
  </insert>
</mapper>

然后在applicationContext.xml加入扫描.xml文件的设置。

<!--    配置sqlSessionFactory，工厂能帮我创建session，有了session就能拿到代理对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
<!--&lt;!&ndash;         自动扫描mapping.xml文件&ndash;&gt;-->
        <property name="mapperLocations"  value="classpath*:com/txy/mapping/*.xml"></property>
    </bean>

以上完成了以后，我们就可以测试整个的功能是否完成了，写两个功能，一个是查询数据库的所有用户信息，一个是向数据库当中插入相关的用户信息，一直没有给出数据库的代码，这边给一下。

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for zmall_user
-- ----------------------------
DROP TABLE IF EXISTS `zmall_user`;
CREATE TABLE `zmall_user` (
  `user_id` int(20) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_pwd` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_age` int(20) DEFAULT NULL,
  `user_gender` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=21 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

我们测试是怎么测试的，点击前端的查找所有用户，跑出来所有数据库当中所有用户的信息就行。

测试结果。