SSM 框架搭建整合（IDEA）保姆级mysql

阿A轲

已于 2023-04-27 10:05:50 修改

阅读量1.9k

点赞数 7

于 2022-05-14 00:07:57 首次发布

本文链接：https://blog.csdn.net/qq_57381370/article/details/124758483

版权

一：搭建整合环境

1. 搭建整合环境

1. 整合说明：SSM整合可以使用多种方式，咱们会选择XML + 注解的方式

2. 整合的思路：

先搭建整合的环境
先把Spring的配置搭建完成
再使用Spring整合SpringMVC框架
最后使用Spring整合MyBatis框架

3. 创建数据库和表结构：

create database ssm;
create table account(
id int primary key auto_increment,
name varchar(20),
money double
);

4. 创建maven的工程：

我这里改成了自己的maven ， idea自带的可能会有问题

创建好后把pom.xml文件中部分内容删掉剩下：，在光标处，再粘贴复制进去下方这些

<properties>
    <spring.version>5.0.2.RELEASE</spring.version>
    <slf4j.version>1.6.6</slf4j.version>
    <log4j.version>1.2.12</log4j.version>
    <mysql.version>5.1.6</mysql.version>
    <mybatis.version>3.4.5</mybatis.version>
    <jackson.version>2.9.4</jackson.version>
  </properties>
  <dependencies>
    <!--spring-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.6.8</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency><dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
  </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!--log start-->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <!-- log end-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>
    <!--连接池-->
    <dependency>
      <groupId>org.thymeleaf</groupId>
      <artifactId>thymeleaf-spring4</artifactId>
      <version>3.0.9.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.10</version></dependency>
    <dependency>
      <groupId>org.mybatis.generator</groupId>
      <artifactId>mybatis-generator-core</artifactId>
      <version>1.3.5</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.1.10</version>
    </dependency>
    <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-all</artifactId>
      <version>5.2.3</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>ssm</finalName>
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.2</version>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
            <encoding>UTF-8</encoding>
            <showWarnings>true</showWarnings>
          </configuration>
        </plugin>
      </plugins>
    </pluginManagement>
    <plugins>
      <plugin>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-maven-plugin</artifactId>
        <version>1.3.5</version>
        <!--告诉插件，配置文件所在的位置-->
        <configuration>
          <configurationFile>src/main/resources/mbg.xml</configurationFile>
          <verbose>true</verbose>
          <overwrite>true</overwrite>
        </configuration>
      </plugin>
    </plugins>
  </build>

5. 编写实体类。

在src下的main目录下创建 java 和resource 两个目录，在java目录中新建软件包，再在这个新建的软件包中新建 controller ,dao,entity,service 软件包。

。每一个数据库的表，对应一个实体，实体中 get set和toString方法都要写上。（根据本篇最开始的数据库编写字段）。在entity中新建Account类，写好

public class Account{
    // 主键
    private int id;
    // 账户名称
    private String name;
    // 账号的金额
    private Double money;

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

6. 编写service接口和实现类，在service中新建AccountService 接口

import com.qcby.entity.Account;

import java.util.List;

public interface AccountService {

    //查询所有
    public List<Account> findAll();
}

7.写一个实现类，在service下新建软件包 serviceimpl，在其中新建实现类AccountServiceImpl

实现AccountService接口，加上@service注解，实现相应方法

import com.qcby.entity.Account;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class AccountServiceImpl implements AccountService {
    //查询所有
    @Override
    public List<Account> findAll() {
        System.out.println("业务层：查询所有");
        return null;
    }
}

8.在resources 目录下创建spring配置，就叫spring就行

光标出写入开启注解扫描，然后光标放在<context 处（Alt+回车）导入。

    <!--开启注解扫描，要扫描的是service-->
    <context:component-scan base-package="com.qcby"/>

如果不会。。就直接粘贴下方进去

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

    <!--开启注解扫描，要扫描的是service-->
    <context:component-scan base-package="com.qcby"/>

</beans>

不过要注意 base-package= "com.qcby"，这里的com.qcby是java下写的大的那个软件包的名称。我写的是 com.qcby,注意写成自己的。

9.测试一下，main下新建个Test目录，作为测试，其中新建com.qcby 其中创建一个测试类 TestSpring

，

import com.qcby.service.AccountService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    @Test
    public void run(){
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("classpath:spring.xml");
        AccountService service = ac.getBean(AccountService.class);
        service.findAll();
    }
}

以上是对Spring最简单的配置

下面配置 SpringMVC

Spring整合SpringMVC框架

1. 搭建和测试SpringMVC的开发环境

1. 在web.xml中配置DispatcherServlet前端控制器

注意一定要知道，DispatcherServlet

打开web.xml 全删除掉里边内容，再粘贴进，（因为他自己的版本太老了）

<web-app version="3.0" 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">
   
 </web-app>

再加入

<!--在web.xml中配置Spring提供的过滤器类 -->
<filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <async-supported>true</async-supported>
    <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>
<!--不拦截所有是html的页面请求-->
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.html</url-pattern>
</servlet-mapping>

<!--配置前端控制器，对浏览器发送的请求进行统一处理-->
<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--加载springmvc.xml配置文件的位置和名称，配置的是Spring配置-->
    <init-param>
        <!--contextConfigLocation:上下文配置路径，固定值-->
        <param-name>contextConfigLocation</param-name>
        <!--classpath:类路径，值得是Java和resources文件夹-->
        <!--springmvc.xml:指的是配置文件的名称：需要配置springmvc.xml，在下面-->
        <param-value>classpath:springmvc.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>

<!--开启项目时打开的页面-->
<welcome-file-list>
    <welcome-file>/index.html</welcome-file>
</welcome-file-list>

会有一个springmvc.xml 字段报红，因为我们还没有创建springmvc配置文件

2.现在创建在resource下新建spring配置，取名为springmvc，写进：（还是注意 base-package）

   <!--配置spring创建容器时要扫描的包-->
<context:component-scan base-package="com.qcby"/>

<!--处理映射器-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<!--处理器适配器-->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

<!--配置视图解析器-->
<bean id="viewResolver" class="org.thymeleaf.spring4.view.ThymeleafViewResolver">
    <property name="order" value="1"/>
    <property name="characterEncoding" value="UTF-8"/>
    <property name="templateEngine" ref="templateEngine"/>
</bean>
<!-- templateEngine -->
<bean id="templateEngine" class="org.thymeleaf.spring4.SpringTemplateEngine">
    <property name="templateResolver" ref="templateResolver"/>
</bean>
<bean id="templateResolver" class="org.thymeleaf.spring4.templateresolver.SpringResourceTemplateResolver">
    <property name="prefix" value="/html/" />
    <property name="suffix" value=".html" />
    <property name="templateMode" value="HTML5"/>
</bean>

3.在webapp下的index文件删除，再新建html文件命名为 index，因为上上边的代码里写的开启项目打开的页面是index.html。注意（href="/项目名/hello")

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>主页</title>
</head>
<body>
<html>
<head>
    <meta charset="utf-8">
    <title>入门程序</title>
</head>
<body>
<h3>入门</h3><a href="/SSMTest/hello" >入门程序</a>
</body>
</html>
</body>
</html>

注意（href="/项目名/hello") ，hello则是在 controller 软件包下新建一个类叫AccountController，写入

import com.qcby.entity.Account;
import com.qcby.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@Controller
public class AccountController {

//    service 层注入
    @Autowired
    private AccountService accountService;

    @RequestMapping(path = "/hello")
    public String sayHello(Model model){
        System.out.println("入门方法执行了2...");
        List<Account> accounts = accountService.findAll();
        // 向模型中添加属性msg与值，可以在html页面中取出并渲染
        model.addAttribute("msg","hello,SpringMVC");
        // 配置了视图解析器后，写法
        return "suc";
    }
}

可以看到最后return“suc”，这是返回 suc页面。所以

再在webapp下新建一个叫html的目录，里边新建 suc.html

其中写入

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">

    <title>成功</title>
</head>
<body>
<h1>Hello <b th:text="${msg}"></b></h1>
</body>
<script>
</script>
</html>

4.在springmvc.xml里再配置spring对mvc的支持

<mvc:annotation-driven/>

虽然就这一行但还是建议手写，选这个

这样springmvc框架样例就完成了

还需要spring整合Springmvc框架

Spring整合SpringMVC的框架

1. 目的：在controller中能成功的调用service对象中的方法。

2. 在项目启动的时候，就去加载spring.xml的配置文件，在web.xml中配置

ContextLoaderListener监听器（该监听器默认加载WEB-INF目录下的applicationContext.xml的配置文

件，所以要配置全局的变量加载类路径下的配置文件）。web.xml 里找个地方写进

<!--配置Spring的监听器-->
<display-name>Archetype Created Web Application</display-name>
<listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--配置加载类路径的配置文件-->
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:spring.xml</param-value>
</context-param>

导进本地tomcat服务

，选好自己下载的tomcat

，_war 可以先删掉。然后确定，去运行点击，

之后 spring整合mybatis

Spring整合MyBatis框架

1. Spring整合MyBatis框架

1. 目的：把SqlMapConfig.xml配置文件中的内容配置到spring.xml配置文件中；整合原理就是把Dao生成的代理对象，存入到IOC容器中

2.jdbc.properties。resources 中新建资源包，命名jdbc

里边写入：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
jdbc.username=root  
jdbc.password=2020

要注意修改（mysql8.0以上不可用）：

3306 是mysql默认端口号

3.在spring.的xml文件中配置mybatis（注意看里边内容是否需要修改）

<!--开启注解扫描，要扫描的是service-->
<context:component-scan base-package="com.qcby.service"/>
<!--加载数据库配置文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--配置数据库连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

<!--spring整合mybatis-->
<bean id="SqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!--注入数据库连接池-->
    <property name="dataSource" ref="dataSource"/>

    <!--扫描entity，配置entity包下类的别名-->
    <property name="typeAliasesPackage" value="com.qcby.entity"/>


    <!--扫描sql配置文件，mapper文件夹中的xml文件-->
    <property name="mapperLocations" value="classpath:mapper/*.xml"/>
</bean>

<!--配置扫描Dao接口包，动态实现Dao接口，注入到ioc容器-->
<bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.qcby.dao"/>
</bean>

4.在web.xml文件当中设置对spring.xml的访问

<!-- 配置加载类路径下的applicationContext.xml配置文件 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml</param-value>
</context-param>
<!-- 配置监听器-->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

6.resources下新建mapper目录其中新建mabatis.mapper文件

如果之前没配置过是没有的，如果有下边这一块跳过

----------------------------------------------------------------

如何配置：

点 file（文件），settings（设置），editor（编辑器），Files and code templates（文件与代码模板）

，英文是

点小加号，命名为 mybatis-mapper.xml ，扩展选 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="">
    
</mapper>

如：，再在resources目录下，创建mapper文件夹，再创建 .xml文件。

--------------------------------------------------------

创建命名为AccountDao 之后 <mapper> 标签写入注意namespace路径

<mapper namespace="com.qcby.dao.UserDao">
    <select id="findAll" resultType="com.qcby.entity.Account">
        select * from account;
    </select>
</mapper>

这里会有报错因为该有的东西还没写。

在dao层软件包下新建接口叫 UserDao，写入导入

import com.qcby.entity.Account;

import java.util.List;

public interface UserDao {
    public List<Account> findAll();
}

service层下的 AccountService中写（之前已经写过了）看看还有没有

   public List<Account> findAll();

在serviceimpl层（service实现层）下的AccountServiceImpl 中写，（dao层的注入，然后return修改返回findAll方法）

import com.qcby.dao.UserDao;
import com.qcby.entity.Account;
import com.qcby.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private UserDao userDao;

    //查询所有
    @Override
    public List<Account> findAll() {
        System.out.println("业务层：查询所有");
        return this.userDao.findAll();
    }
}

controller层下的 AccountController 中的之前写的方法中加一个 for each循环

import com.qcby.entity.Account;
import com.qcby.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@Controller
public class AccountController {

//    service 层注入
    @Autowired
    private AccountService accountService;

    @RequestMapping(path = "/hello")
    public String sayHello(Model model){
        System.out.println("入门方法执行了2...");
        List<Account> accounts = accountService.findAll();
        for (Account account: accounts) {
            System.out.println(account.toString());
        }
        // 向模型中添加属性msg与值，可以在html页面中取出并渲染
        model.addAttribute("msg","hello,SpringMVC");
        // 配置了视图解析器后，写法
        return "suc";
    }
}

整体项目样例配置完毕

还剩下一个异常处理

比如：AccountController 写一个，

    @RequestMapping("/findAll")
    public String findAll(){
        System.out.println("执行了...");
        // 模拟异常
        int a = 10/0;
        return "suc";
    }

0怎么能当除数呢，这样必然报错。

（传统就是 try catch，前端页面还是能返回到 suc页面，但是后端其实是有报错的。）

在html文件中新建一个error.html页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>主页</title>
</head>
<body>
<html>
<body>
<h1><b th:text="${errorMsg}"></b></h1>
</body>
</html>

一旦出了错就返回到此页面。

在新建一个conf 软件包其中建一个异常处理类 SysExceptionResolver，去实现接口HandlerExceptionResolver

import com.qcby.entity.SysException;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class SysExceptionResolver implements HandlerExceptionResolver {

    /**
     * 程序出现了异常，调用异常处理器中的方法
     * @param httpServletRequest
     * @param httpServletResponse
     * @param o
     * @param e
     * @return
     */
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest,
                                         HttpServletResponse httpServletResponse, Object o, Exception e) {
        e.printStackTrace(); //在命令行打印异常信息在程序中出错的位置及原因。
        // 做强转
        SysException exception = null;
        // 判断
        if(e instanceof SysException){
            exception = (SysException)e;
        }else{
            exception = new SysException("系统正在维护，请联系管理员");

        }
        ModelAndView mv = new ModelAndView();
        mv.addObject("errorMsg",exception.getMessage());
        // 设置跳转的页面
        mv.setViewName("error");
        return mv;
    }
}

这里会先报错，去创建实体对象 entity中新建类叫 SysException（出错时向前台返回实体对象），

/**
 * 异常处理类
 */
public class SysException extends Exception{
    // 提示消息
    private String message;
    public SysException(String message){
        this.message = message;
    }

    @Override
    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    @Override
    public String toString() {
        return "SysException{" +
                "message='" + message + '\'' +
                '}';
    }
}

springmvc.xml 当中-配置异常处理器-

<!--配置异常处理器-->
    <bean id="sysExceptionResolver" class="com.qcby.conf.SysExceptionResolver" />

运行tomcat 访问。并不会报 500错误。

结束!

阿A轲

关注

7
点赞
踩
58

收藏

觉得还不错? 一键收藏
0
评论
SSM 框架搭建整合（IDEA）保姆级mysql

一：搭建整合环境1. 搭建整合环境1. 整合说明：SSM整合可以使用多种方式，咱们会选择XML + 注解的方式2. 整合的思路：先搭建整合的环境先把Spring的配置搭建完成再使用Spring整合SpringMVC框架最后使用Spring整合MyBatis框架3. 创建数据库和表结构：create database ssm;create table account(id int primary key auto_increment,name varcha...
复制链接

扫一扫