完整的SSM搭建过程

最新推荐文章于 2024-06-11 07:55:51 发布

marwi_study

最新推荐文章于 2024-06-11 07:55:51 发布

阅读量1.1w

点赞数 19

分类专栏： JavaEE 文章标签： java 后端 spring

本文链接：https://blog.csdn.net/marwi_study/article/details/105658217

版权

JavaEE 专栏收录该内容

2 篇文章 1 订阅

订阅专栏

SSM架构搭建过程

框架构成

Spring：简化Java开发

低侵入/低耦合：降低组件之间的耦合度，实现软件各层之间的解耦
声明式事务管理：基于切面和惯例
方便集成其他框架，降低Java开发难度

SpringMVC：简化MVC架构的搭建

Servlet–controller
JavaBean–model
JSP（html）–view

Mybatis：持久层框架

简化数据库连接操作，只需提供SQL语句即可

搭建过程

1.创建一个有web结构的maven项目

org.apache.cocoon:cocoon-22-archetype-webapp

2.将项目修改成maven项目统一的项目结构

在这里插入图片描述

具体代码实现过程

1.pom.xml文件配置，将需要的jar包导入项目（可在中途需要时加入jar包依赖）
设置编码和所需要的框架jar包统一版本

<properties>
    <!-- 设置项目编码编码 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <!-- spring版本号 -->
    <spring.version>4.3.5.RELEASE</spring.version>
    <!-- mybatis版本号 -->
    <mybatis.version>3.4.1</mybatis.version>
</properties>

JavaEE所需要的jar包

<dependency>
   <groupId>javax</groupId>
   <artifactId>javaee-api</artifactId>
   <version>7.0</version>
</dependency>

spring所需要的jar包

<!-- 核心包 -->
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-core</artifactId>
   <version>${spring.version}</version>
</dependency>
<!-- bean管理所需要的jar包 -->
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-beans</artifactId>
   <version>${spring.version}</version>
</dependency>
<!-- 上下文支持jar包 -->
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-context</artifactId>
   <version>${spring.version}</version>
</dependency>
<!-- 数据库访问层需要的jar包 -->
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-jdbc</artifactId>
   <version>${spring.version}</version>
</dependency>
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-tx</artifactId>
   <version>${spring.version}</version>
</dependency>
<!-- spring 提供的测试插件 -->
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-test</artifactId>
   <version>${spring.version}</version>
</dependency>
<!-- 网络支持jar包,可以使用Spring框架的支持开发Servlet代码. -->
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-web</artifactId>
   <version>${spring.version}</version>
</dependency>

SpringMVC所需要的jar包

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>${spring.version}</version>
</dependency>

Mybatis所需要的jar包

<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis</artifactId>
   <version>${mybatis.version}</version>
</dependency>

Mybatis与Spring整合所需要的jar包

<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis-spring</artifactId>
   <version>1.3.1</version>
</dependency>

数据库连接所需要的jar包

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.19</version>
   <scope>runtime</scope>
</dependency>

<!-- 数据库连接池 -->
<dependency>
   <groupId>com.mchange</groupId>
   <artifactId>c3p0</artifactId>
   <version>0.9.5.2</version>
</dependency>

其他jar包

<!-- 单元测试 -->
<dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.12</version>
</dependency>

<!-- 实现slf4j接口并整合 -->
<dependency>
   <groupId>ch.qos.logback</groupId>
   <artifactId>logback-classic</artifactId>
   <version>1.2.2</version>
</dependency>

<!-- JSON -->
<dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.8.7</version>
</dependency>

2.web.xml文件配置，声明DispatcherServlet和过滤器（编码过滤器）
web配置文件位于WEB-INF中，首先配置DispatcherServlet，这是SpringMVC所要求的，可帮助SpringMVC框架进行请求定位

<servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 配置springMVC需要加载的配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-*.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
</servlet>
<servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <!-- 匹配所有请求 -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

编写编码过滤器，统一页面编码

<filter>
    <filter-name>encodingFilter</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>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

3.创建数据库和数据表
根据数据模型，确定数据表的字段，建立数据库和数据表
以mysql建数据库为例

DROP DATABASE IF EXISTS ssm;
CREATE DATABASE ssm DEFAULT CHARACTER SET utf8;

use ssm;
CREATE TABLE user(
    id int(11) NOT NULL AUTO_INCREMENT,
    username varchar(50) NOT NULL,
    PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO user VALUES(1,'mistwind');

4.jdbc.properties文件配置，声明与数据库有关的属性
数据库连接必要的属性有jdbc连接驱动、jdbc连接链接、用户、密码

jdbc.driver=com.mysql.cj.jdbc.Driver
#数据库地址
jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
#用户名
jdbc.username=root
#密码
jdbc.password=root

数据库连接池需要多一些c3p0的配置

#最大连接数
c3p0.maxPoolSize=30
#最小连接数
c3p0.minPoolSize=10
#关闭连接后不自动commit
c3p0.autoCommitOnClose=false
#获取连接超时时间
c3p0.checkoutTimeout=10000
#当获取连接失败重试次数
c3p0.acquireRetryAttempts=2

5.创建对应实体类
根据数据表字段设计符合POJO规则的实体类，即封装且包含getter和setter的Java类

package cn.mistwind.entity;

/**
 * User 实体类
 * @author: mistwind
 * @create: 2020-4-20
 *
 */
public class User {
    private int id;
    private String username;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

6.创建DAO接口和mybatis映射文件
设计DAO层，即数据访问层，在Mybatis中，数据库访问层只需要设计接口，其实现有两种方式，一种是由映射文件mapper编写相应方法的SQL语句来实现，另一种是用注解直接在接口方法上编写SQL语句实现
映射文件实现

<?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" >
<!-- namespace指定该映射文件要实现的接口 -->
<mapper namespace="cn.mistwind.dao.UserDao">
    <select id="findUserById" resultType="cn.mistwind.entity.User" parameterType="int">
        SELECT * FROM user WHERE id = #{id}
    </select>
</mapper>

注解实现

package cn.mistwind.dao;

import cn.mistwind.entity.User;
import org.apache.ibatis.annotations.Select;

public interface UserDao {
    @Select("SELECT * FROM user WHERE id = #{id}")
    User findUserById(int id);
}

7.配置spring和mybatis整合
以上过程已经配置好了mybatis框架，为了spring能够跟mybatis协同工作，我们需要将spring与mybatis进行整合，即告诉spring一些关于mybatis配置的信息，说到底其实就是让spring管理一个mybatis的对象，可以让整个项目在需要访问数据库时可以直接使用这个数据源，spring-mybatis的配置如下：

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

    <!-- 扫描service包下所有使用注解的类型 -->
    <context:component-scan base-package="cn.mistwind.service"/>
    <!-- 加上这一行以后，将自动扫描路径下面的包，如果一个类带了@Service注解，将自动注册到Spring容器，不需要再在applicationContext.xml文件定义bean了，类似的还包括@Component、@Repository、@Controller。 -->

    <!-- 配置数据库相关参数properties的属性：${url} -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
        <property name="minPoolSize" value="${c3p0.minPoolSize}"/>
        <property name="autoCommitOnClose" value="${c3p0.autoCommitOnClose}"/>
        <property name="checkoutTimeout" value="${c3p0.checkoutTimeout}"/>
        <property name="acquireRetryAttempts" value="${c3p0.acquireRetryAttempts}"/>
    </bean>

    <!-- 配置SqlSessionFactory对象 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 扫描entity包 使用别名 -->
        <property name="typeAliasesPackage" value="cn.mistwind.entity"/>
        <!-- 扫描sql配置文件:mapper需要的xml文件 -->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>

    <!-- 配置扫描Dao接口包，动态实现Dao接口，注入到spring容器中 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!-- 给出需要扫描Dao接口包 -->
        <property name="basePackage" value="cn.mistwind.dao"/>
    </bean>

    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 配置基于注解的声明式事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

熟悉spring的基本使用后你会发现，这个配置就是spring最基础的bean配置，其中所有配置项其实就是声明创建了几个需要用到的工具，这个可以在需要用到时再加入，例如上面文件中只需要先加入与数据库连接相关的一些配置
8.测试数据库连接和访问
spring还有一个很好的地方就在于它可以整合一些工具插件，例如JUnit，可以方便我们进行单元测试，配置完spring-mybatis之后，我们可以测试一下spring与mybatis框架是否整合完成了，即能不能直接拿到数据库连接访问到数据库

package cn.mistwind;

import cn.mistwind.dao.UserDao;
import cn.mistwind.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)  //进行测试要使用的工具
@ContextConfiguration("classpath:spring-mybatis.xml") //指定配置所在位置
public class UserDaoTest{
    @Autowired //spring自动注入
    private UserDao userDao; //由配置文件spring-mybatis声明创建，相关配置代码段如下

    @Test  //测试方法
    public void testFindUserById(){
        int id = 1;
        User user = userDao.findUserById(id);
        System.out.println(user.getId() + ":" + user.getUsername());
    }
}

<!-- 配置扫描Dao接口包，动态实现Dao接口，注入到spring容器中 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!-- 注入sqlSessionFactory -->
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    <!-- 给出需要扫描Dao接口包 -->
    <property name="basePackage" value="cn.mistwind.dao"/>
</bean>

9.配置springMVC，配置视图解析器，可组装视图前缀与后缀
在本地数据库访问成功了，我们就可以将从数据库获得的数据通过视图展示给用户了，web项目最根本的问题就在于servlet的编写和页面的跳转，在springMVC中servlet的mapping有DispatcherServlet帮助我们完成，上面在配置web.xml时已经配置了，接下来我们的请求定向只需要用注解 @RequestMapping({"/"})在controller中完成，而页面的跳转我们可以用spring-mvc配置来完成统一的要求（例如统一的前缀和后缀），这样可以保证项目的安全性，防止用户直接访问某一页面
通过以下配置我们可以将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
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

    <!-- 扫描web相关的bean -->
    <context:component-scan base-package="cn.mistwind.controller"/>

    <!-- 开启SpringMVC注解模式 -->
    <mvc:annotation-driven/>

    <!-- 静态资源默认servlet配置 -->
    <mvc:default-servlet-handler/>

    <!-- 配置jsp 显示ViewResolver -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

从我理解的层面上来说，这个配置其实就是声明了一个视图组装器，将从控制层传过来的视图文件名通过组装得到它在服务器中存在的文件全名，MVC再根据这个文件全名去找到这个视图文件将其返回给用户，而WEB-INF这个目录是web项目的隐藏目录，即在地址栏出现WEB-INF是访问不到WEB-INF下的资源的，所以以上配置就能保证项目资源的安全性和项目的健壮性了
10.业务管理层编写（包括接口和实现类），根据业务逻辑调用持久层接口
业务管理层是将项目要完成的业务逻辑输入到项目中来，它就相当于一个工厂中的工人，使用工厂中的工具进行要求的生产工作，而DAO就是我们的工具，业务管理层希望能够对从数据库获得的数据进行必要的处理来为控制层提供服务。业务管理层需要编写一些接口和接口的实现类，这样做的好处是可以解耦，方便我们后期修改方法实现

package cn.mistwind.service;

import cn.mistwind.entity.User;

public interface UserService {
    public User findUserById(int id);
}

package cn.mistwind.service.Impl;

import cn.mistwind.dao.UserDao;
import cn.mistwind.entity.User;
import cn.mistwind.service.UserService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service("userService")  //创建一个名为userService的对象注入到Spring容器中，类似于Component，不指明名字以userServiceImpl为名，可用Scope指定是否单例
public class UserServiceImpl implements UserService {
    @Resource  //自动注入，类似于Autowired
    private UserDao userDao;

    public User findUserById(int id) {
        return userDao.findUserById(id);
    }
}

11.控制层编写，响应前端发送过来的请求，调用业务层接口做相应的处理
如果说业务管理层是工人的话，那控制层就是经理，它可以调动工人使用其服务来响应视图层的请求。上面提到的DispatcherServlet可以帮忙定位，而我们的控制层就是要完成跳转后的工作的

package cn.mistwind.controller;

import cn.mistwind.entity.User;
import cn.mistwind.service.UserService;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.annotation.Resource;

@Controller //标记为MVC的控制器类，方便DispatcherServlet进行扫描定位
@RequestMapping("")
public class UserController {
    @Resource
    private UserService userService;

    @RequestMapping("/findUser")
    public String findUser(Model model){
        int id = 1;
        User user = this.userService.findUserById(id);
        model.addAttribute("user", user);
        return "index";
    }
}

以上代码便可以在地址栏跳转到/findUser时返回WEB-INF下的index.jsp视图
12.视图创建
最后就是我们将应用运行的结果呈现给用户，即创建所需要的视图，当然可以是html也可以是jsp或者可以是其他，这个视图文件的类型主要由spring-mvc控制

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2020/4/20
  Time: 20:57
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>My SSM Model</title>
</head>
<body>
<h1 align="center">Hello SSM</h1>
<table border="1" align="center">
    <tr>
        <th>ID</th>
        <th>姓名</th>
    </tr>
    <tr>
        <td>${user.id}</td>
        <td>${user.username}</td>
    </tr>
</table>
</body>
</html>

13.logback.xml文件配置，完成日志输出的相关配置
这个配置是一个长远的配置，为的是开发过程中出现错误以及后期的维护所需要的日志输出配置

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="debug">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

14.整体测试
在这里插入图片描述

marwi_study

关注

19
点赞
踩
88

收藏

觉得还不错? 一键收藏
5
评论
完整的SSM搭建过程

SSM架构搭建过程框架构成Spring：简化Java开发低侵入/低耦合：降低组件之间的耦合度，实现软件各层之间的解耦声明式事务管理：基于切面和惯例方便集成其他框架，降低Java开发难度SpringMVC：简化MVC架构的搭建Servlet–controllerJavaBean–modelJSP（html）–viewMybatis：持久层框架简化数据库连接操作，只需提供...
复制链接

扫一扫