SSM整合教程(配置类版)

最新推荐文章于 2024-10-09 21:20:02 发布
最新推荐文章于 2024-10-09 21:20:02 发布
阅读量1.1k 收藏 14
点赞数 3
文章标签： intellij-idea java intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55337678/article/details/125201443
版权

Hello，World！

大家看我的博客也有一段时间了，前面出了Spring和SringMVC的教程，现在就出一个综合性的教程把前面学的串联起来。

开发环境：

1.开发工具：Idea         

2.Jdk版本：8        

3.数据库连接架包：8以上即可

我们来回顾一下需要那些架包

1.第一SSM框架的基础Jar包springwebmvc

2.Mybaits和Juint，Servlet

3.进行事物管理的Jdbc，以及连接池的Druid

4.简化实体类开发的lombok和转换Json格式的FastJson

废话不多说，开始上手代码

1.创建一个maven项目，并引用以下架包

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.19</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.19</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.19</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.78</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
        <!-- 添加slf4j日志api -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.20</version>
        </dependency>
        <!-- 添加logback-classic依赖 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- 添加logback-core依赖 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.2.3</version>
        </dependency>
    </dependencies>

2.见一个Config包，用来写配置类

1.建一个applicationContextConfig.java

@Configuration
@ComponentScan(value = "com.yunhuisu",excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = Controller.class)})
@Import({DataSourceConfig.class,MybatisConfig.class})
public class ApplicationContextConfig {
}

2.建一个DataSourceConfig.java用来写数据源和开启事务，这里还有一个数据库连接配置文件db.properties

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@PropertySource("classpath:db.properties")
@EnableTransactionManagement
public class DataSourceConfig {

    @Value("${db.driver}")
    private String driver;
    @Value("${db.url}")
    private String url;
    @Value("${db.username}")
    private String username;
    @Value("${db.password}")
    private String password;

    @Bean
    public DataSource setDataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
    @Bean
    public PlatformTransactionManager setTransactionManager(@Autowired DataSource dataSource) {
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource);
        return dataSourceTransactionManager;
    }
}

db.properties

db.driver=com.mysql.cj.jdbc.Driver
db.url=jdbc:mysql:///ssmbuild
db.username=root
db.password=123456

3.建mybatis的配置类

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MybatisConfig {
    @Bean
    public SqlSessionFactoryBean setSqlSessionFactoryBean(@Autowired DataSource dataSource,@Autowired ApplicationContext applicationContext) {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setTypeAliasesPackage("com.yunhuisu.pojo");
        sqlSessionFactoryBean.setConfigLocation(applicationContext.getResource("classpath:mybatis-config.xml"));
        return sqlSessionFactoryBean;
    }
    @Bean
    public MapperScannerConfigurer setMapperScannerConfigurer() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.yunhuisu.mapper");
        return mapperScannerConfigurer;
    }
}

以及可建可不建的mybatis-config.xml,我这里建了是为了开启SLF4J日志

<?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>
    <settings>
        <setting name="cacheEnabled" value="false"/>
        <setting name="logImpl" value="SLF4J"/>
    </settings>
</configuration>

顺带把SLF4J日志的配置文件也一起建立了logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--
        CONSOLE ：表示当前的日志信息是可以输出到控制台的。
    -->
    <appender name="Console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>[%level] %blue(%d{HH:mm:ss.SSS}) %cyan([%thread]) %boldGreen(%logger{15}) - %msg %n</pattern>
        </encoder>
    </appender>

    <logger name="com.itheima" level="DEBUG" additivity="false">
        <appender-ref ref="Console"/>
    </logger>


    <!--

      level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF
     ， 默认debug
      <root>可以包含零个或多个<appender-ref>元素，标识这个输出位置将会被本日志级别控制。
      -->
    <root level="DEBUG">
        <appender-ref ref="Console"/>
    </root>
</configuration>

4.最后来建SpringMVC的配置类

sprinmvcServlet.java这个类就类似于你们在web.xml里面配置的一些东西

import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

import javax.servlet.Filter;


public class SpringmvcServlet extends AbstractAnnotationConfigDispatcherServletInitializer {
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{ApplicationContextConfig.class};
    }

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringmvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}

还要建一个类springmvcConfig.java

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@ComponentScan(value = "com.yunhuisu.controller")
public class SpringmvcConfig {
    @Bean
    public InternalResourceViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }
}

3.设计数据库

CREATE DATABASE `ssm`;
 
USE `ssm`;
 
DROP TABLE IF EXISTS `books`;
 
CREATE TABLE `books` (
  `bookID` INT(10) NOT NULL AUTO_INCREMENT COMMENT '书id',
  `bookName` VARCHAR(100) NOT NULL COMMENT '书名',
  `bookCounts` INT(11) NOT NULL COMMENT '数量',
  `detail` VARCHAR(200) NOT NULL COMMENT '描述',
  KEY `bookID` (`bookID`)
);
 
INSERT  INTO `books`(`bookID`,`bookName`,`bookCounts`,`detail`)VALUES 
(1,'Java',1,'从入门到放弃'),
(2,'MySQL',10,'从删库到跑路'),
(3,'Linux',5,'从进门到进牢');

4.建与数据库相对于的实体类和Mapper映射

1.在pojo包下面建Books.java类

import lombok.Data;

@Data
public class Books {
    private int bookID;
    private String bookName;
    private String bookCounts;
    private String detail;
}

2.在mapper包下面建BookMapper.java

import com.yunhuisu.pojo.Books;
import org.apache.ibatis.annotations.*;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public interface BookMapper {

    @Select("SELECT * FROM books")
    List<Books> findAllBook();

    @Select("SELECT * FROM books WHERE bookID = #{bookID}")
    Books findByIdBook(@Param("bookID")int bookID);

    @Insert("INSERT INTO books(bookName, bookCounts, detail) VALUES (#{bookName}, #{bookCounts}, #{detail})")
    boolean addBook(Books books);

    @Update("UPDATE books SET bookName = #{bookName},bookCounts = #{bookCounts},detail = #{detail}  WHERE bookID = #{bookID}")
    boolean updateBook(Books books);

    @Delete("DELETE FROM books WHERE bookID = #{bookID}")
    boolean byIdDeleteBook(@Param("bookID")int bookID);
}

5.在Service层对数据进行处理

1.建一个BookService.java

import com.yunhuisu.pojo.Books;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Transactional
@Service
public interface BookService {
    List<Books> findAllBook();
    Books findByIdBook(int bookID);
    boolean addBook(Books books);
    boolean updateBook(Books books);
    boolean byIdDeleteBook(int bookID);
}

2.在Impl进行实现，建BookServiceImpl.java

import com.yunhuisu.mapper.BookMapper;
import com.yunhuisu.pojo.Books;
import com.yunhuisu.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    BookMapper bookMapper;

    public List<Books> findAllBook() {
        return bookMapper.findAllBook();
    }

    @Override
    public Books findByIdBook(int bookID) {
        return bookMapper.findByIdBook(bookID);
    }

    @Override
    public boolean addBook(Books books) {
        return bookMapper.addBook(books);
    }

    @Override
    public boolean updateBook(Books books) {
        return bookMapper.updateBook(books);
    }

    @Override
    public boolean byIdDeleteBook(int bookID) {
        return bookMapper.byIdDeleteBook(bookID);
    }
}

6.最后来建Controller层

import com.alibaba.fastjson.JSON;
import com.yunhuisu.pojo.Books;
import com.yunhuisu.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;


import java.util.List;

@Controller
public class BookController {
    @Autowired
    BookService bookService;

    @RequestMapping(value = "/findBook", produces = "text/html;charset=utf-8")
    @ResponseBody
    public String findBook() {
        List<Books> books = bookService.findAllBook();
        String resultBooks = JSON.toJSONString(books);
        return resultBooks;
    }
    @RequestMapping(value = "/findByIdBook/{id}" , produces = "text/html;charset=utf-8")
    @ResponseBody
    public String findByIdBook(@PathVariable("id") int id) {
        Books byIdBook = bookService.findByIdBook(id);
        String resultBook = JSON.toJSONString(byIdBook);
        return resultBook;
    }
    @RequestMapping(value = "/addBook",produces = "text/html;charset=utf-8")
    @ResponseBody
    public String addBook(Books books) {
        boolean insertResult = bookService.addBook(books);
        return insertResult == true ? "插入成功" : "插入失败";
    }
    @RequestMapping(value = "/updateBook",produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updateBook(Books books) {
        boolean updateResult = bookService.addBook(books);
        return updateResult == true ? "修改成功" : "修改失败";
    }
    @RequestMapping(value = "/deleteByIdBook/{id}",produces = "text/html;charset=utf-8")
    @ResponseBody
    public String deleteByIdBook(@PathVariable("id") int id) {
        boolean deleteResult = bookService.byIdDeleteBook(id);
        return deleteResult == true ? "删除成功" : "删除失败";
    }
}

最后我们用Postman来测试我们写的接口

1.查询全部书接口

2.通过Id查询书接口

3.插入一本书接口

 4.修改一本书接口

 5.通过Id删除书接口

SSM框架——详细整合教程（Spring+SpringMVC+MyBatis）
在路上
07-19 63万+
使用SSM（Spring、SpringMVC和Mybatis）已经有三个多月了，项目在技术上已经没有什么难点了，基于现有的技术就可以实现想要的功能，当然肯定有很多可以改进的地方。之前没有记录SSM整合的过程，这次刚刚好基于自己的一个小项目重新搭建了一次，而且比项目搭建的要更好一些。以前解决问题的过程和方法并没有及时记录，以后在自己的小项目中遇到我再整理分享一下。这次，先说说三大框架整合过程。个人认
ssm整合配置
08-24
简单的ssm整合，适合刚学ssm框架的小伙伴，框架里外加了简单的ztree
配置类方式配置SSM框架
09-04
通过配置类方式搭建了SSM框架，完全抛弃了xml配置文件
SSM整合（配置类方式）
洛柒
10-30 1171
配置类整和SSM: 1、创建SpringConfig配置类（@Configuration、@ComponentScan 扫描service层的包、@PropertySource（”classpath:datasource.properties")、@Import({JdbcConfig.class,MybatisConfig.class})、@@EnableTransactionManagement :开启事务支持） 2. JdbcConfig配置类 ： @Bean 配置数据源 、配置数据源的事务 ...
使用fastjson解析json格式数据
最新发布
ABU009的博客
10-09 552
#在java中解析json数据内容
ssm整合中各个配置类的内容及注解详解
qq_65201998的博客
01-26 1240
ssm整合中各个配置类的内容及注解详解
SSM配置整合
2303_79615760的博客
07-15 1796
SSM整合是指将Spring，SpringMVC和Mybatis三大框架正和到一起，形成一个强大的java web框架。这种整合方式充分利用了各个框架的优势，使得开发过程高效，代码更加清晰，维护更加方便。
SSM框架——详细整合教程.pdf
06-12
SSM框架，全称为Spring、SpringMVC和MyBatis的整合框架，是Java开发中常用的Web应用程序开发架构。SSM框架的整合旨在提供一种高效、灵活且易于维护的开发方式，尤其适用于大型的企业级应用。 1. **Spring框架**： ...
SSM整合，配置详解
penanut的博客
04-27 397
SSM整合，配置详解 概述 在我们一一学习了spring、springMVC、mybatis后，我们需要将这三者做一个整合，即在一个项目中同时使用这三种技术 在讲述如何整合之前，我们还是先回顾一下，s、s、m都是什么 spring 他可以为我们做什么呢？ 它拥有控制反转、依赖注入以及AOP的功能 控制反转就是不再需要我们去手动new 对象而是由IOC 容器为我们创建 依赖注入就是在创建对象时自动为其内部的属性赋值 AOP，面向切面编程， 什么是切面？就是切点（被增强的方法）和通知（增强的方法）的结
SSM框架-详细整合教程 (2).pdf
11-13
在开始SSM整合前，需要搭建开发环境，包括安装JDK、设置环境变量，配置IDE，以及安装Maven等。此外，还需要设置数据库环境，如MySQL或Oracle。 **3. Maven Web项目创建** 使用Maven创建Web项目，Maven是一个项目...
SSM整合（基于配置类整合
weixin_48841931的博客
09-02 396
整合流程图目录图。
ssm整合(整合配置)
lwj_07的博客
07-27 431
也就是说先把spring、springmvc、mybatis的配置都整合在一起（以前的笔记都做过，这次整合在一起即可）
SSM整合（整合配置）
m0_53959851的博客
05-24 344
SSM整合配置的流程 1、创建工程 2、SSM整合 2.1 Spring SpringConfig 2.2 MyBatis MybatisConfig JdbcConfig jdbc.properties 2.3 SpringMvc ServletConfig SpringMvcConfig 我们按照该流程一步一步进行SSM整合配置部分的操作 1、创建工程后在maven中导入所需要的依赖 <dependencies> <dependency> <gro.
SSM完全去XML配置文件
p13993233504的博客
04-01 165
SSM完全去XML配置文件。
一篇文章教你整合ssm配置，可以收藏。
qq_53344479的博客
02-26 817
所谓的ssm框架就是mybatis+spring+springmvc，下面一篇文章将带你了解如何整合ssm。 大部分配置不需要再去改动，修改数据库配置以及包名，直接拿来用即可。 pom.xml 首先介绍的是依赖，这些是用到的最基本的依赖 <!-- 依赖：Junit，数据库驱动，连接池，Servlet，jsp,mybatis-spring,spring--> <dependencies> <!--Junit--> &l
SSM整合配置
lhj501382150的博客
10-10 139
web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="h...
Shiro与SSM整合（内含详细文档介绍）
11-06
本资料包将深入讲解如何将Shiro与SSM整合，以实现更高效、灵活的安全管理。 Shiro是一款轻量级的Java安全框架，它的主要优势在于其简洁的API和易于理解和使用的设计。Shiro提供了用户认证、权限授权、会话管理以及...
SSM整合-配置类版
蓝朽的小世界
08-22 711
SSM整合配置类版
SSM框架整合和配置
Likeslowsongs的博客
03-23 1935
当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和。数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或。负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的。视图结果，将结果返回给中心控制器，再将结果返回给请求者。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值