纯注解整合SSM框架

转x33g5p2x  于2022-02-28 转载在 其他  
字(9.5k)|赞(0)|评价(0)|浏览(387)

说在前面的话

SSM：Spring+SpringMVC+MyBatis。

​ SSM框架组合已经是现在最热门的后端框架组合了。本篇我要说的就是使用纯注解整合这三大框架。当然了SpringMVC本身就是spring的一部分。也谈不上整合。所以SSM有时我叫SM。（其实不用在意叫法，好听就行）。

​ 当然了我们都知道现在有SpringBoot可以轻松完成这些框架整合配置。所以这篇文章是给学习中的学子们准备的，已经熟练使用SpringBoot的大佬请绕行。

tips：后面有源码下载地址。

嗨！直接开打吧

你需要准备的武器

  • 学习过Spring，SpringMVC和MyBatis框架
  • 最好使用xml的方式整合过SSM框架
  • 当然也必须知道Maven是个啥，肯定也必须会使用Mavne
  • 要有一份对技术不断追求的心
  • 要热爱我的民族，热爱我们的祖国_

不说了，开整吧

整合思路

​ 首先我们要有明确的整合思路，所谓SSM整合其实就是将MyBatis整合到Spring中。这时就要考虑MyBatis中都有什么要整的呢？？

​ 经过考虑，整体思路大概如下:

  • MyBatis 需要的数据源要交给spring，也就是在spring中注册数据源。
  • MyBatis的Mapper要交给spring使用动态代理生成。嗯…SqlSessionFactory的配置…
  • spring的RootContent和WebContent要合并…嗯…

OK！动手

[1]创建项目

打开你的idea，配置好Maven，创建新的项目，创建好需要的目录和包。像下面的截图一样。

[2]配置依赖

打开POM文件，添加下面的配置

版本锁定的部分，我这里使用的spring5.2.6 你是啥打算呢？

  1. <!-- 版本锁定 -->
  2. <properties>
  3.     <!-- spring版本 -->
  4.     <spring.version>5.2.6.RELEASE</spring.version>
  5.     <project.build.sourceEncoding>
  6.         UTF-8
  7.     </project.build.sourceEncoding>
  8. </properties>

添加依赖：

  1. <dependencies>
  2.     <!-- spring框架的jar -->
  3.     <dependency>
  4.         <groupId>org.springframework</groupId>
  5.         <artifactId>spring-context</artifactId>
  6.         <version>${spring.version}</version>
  7.     </dependency>
  8.     <dependency>
  9.         <groupId>org.springframework</groupId>
  10.         <artifactId>spring-webmvc</artifactId>
  11.         <version>${spring.version}</version>
  12.     </dependency>
  13.     <dependency>
  14.         <groupId>org.springframework</groupId>
  15.         <artifactId>spring-web</artifactId>
  16.         <version>${spring.version}</version>
  17.     </dependency>
  18.     <dependency>
  19.         <groupId>org.springframework</groupId>
  20.         <artifactId>spring-tx</artifactId>
  21.         <version>${spring.version}</version>
  22.     </dependency>
  23.     <dependency>
  24.         <groupId>org.springframework</groupId>
  25.         <artifactId>spring-jdbc</artifactId>
  26.         <version>${spring.version}</version>
  27.     </dependency>
  28.     <dependency>
  29.         <groupId>org.springframework</groupId>
  30.         <artifactId>spring-aspects</artifactId>
  31.         <version>${spring.version}</version>
  32.     </dependency>
  33.     <!-- mysql驱动 5.1.47 -->
  34.     <!-- 如果你的数据库是MySQL8 请更换对应的版本 -->
  35.     <dependency>
  36.         <groupId>mysql</groupId>
  37.         <artifactId>mysql-connector-java</artifactId>
  38.         <version>5.1.47</version>
  39.     </dependency>
  41.     <!-- MyBatisjar -->
  42.     <dependency>
  43.         <groupId>org.mybatis</groupId>
  44.         <artifactId>mybatis</artifactId>
  45.         <version>3.4.1</version>
  46.     </dependency>
  47.     <!-- MyBatis和spring整合的第三方jar文件 -->
  48.     <dependency>
  49.         <groupId>org.mybatis</groupId>
  50.         <artifactId>mybatis-spring</artifactId>
  51.         <version>1.3.2</version>
  52.     </dependency>
  53.     <!-- druid连接池 -->
  54.     <dependency>
  55.         <groupId>com.alibaba</groupId>
  56.         <artifactId>druid</artifactId>
  57.         <version>1.1.10</version>
  58.     </dependency>
  59.     <!-- servlet-api -->
  60.     <dependency>
  61.         <groupId>javax.servlet</groupId>
  62.         <artifactId>javax.servlet-api</artifactId>
  63.         <version>3.1.0</version>
  64.         <!-- 这里的scope必须是 provided -->
  65.         <scope>provided</scope>
  66.     </dependency>
  67.     <!-- 处理JSON的jar文件 -->
  68.     <dependency>
  69.         <groupId>com.fasterxml.jackson.core</groupId>
  70.         <artifactId>jackson-databind</artifactId>
  71.         <version>2.9.8</version>
  72.     </dependency>
  73. </dependencies>

再来个插件吧：

  1. <build>
  2.         <!-- 配置将main/java下的资源文件也打包 -->
  3.         <resources>
  4.             <resource>
  5.                 <directory>src/main/java</directory>
  6.                 <includes>
  7.                     <include>**/*.properties</include>
  8.                     <include>**/*.*</include>
  9.                 </includes>
  10.                 <filtering>false</filtering>
  11.             </resource>
  12.             <resource>
  13.                 <directory>src/main/resources</directory>
  14.                 <includes>
  15.                     <include>**/*.properties</include>
  16.                     <include>**/*.*</include>
  17.                 </includes>
  18.                 <filtering>false</filtering>
  19.             </resource>
  20.         </resources>
  22.         <plugins>
  24.             <!-- tomcat插件控制 -->
  25.             <plugin>
  26.                 <groupId>org.apache.tomcat.maven</groupId>
  27.                 <artifactId>tomcat7-maven-plugin</artifactId>
  28.                 <version>2.2</version>
  29.                 <configuration>
  30.                     <port>8080</port>
  31.                     <path>/</path>
  32.                     <uriEncoding>UTF-8</uriEncoding>
  33.                 </configuration>
  34.             </plugin>
  35.             <!-- maven插件控制 -->
  36.             <plugin>
  37.                 <groupId>org.apache.maven.plugins</groupId>
  38.                 <artifactId>maven-compiler-plugin</artifactId>
  39.                 <version>3.1</version>
  40.                 <configuration>
  41.                     <source>1.8</source>
  42.                     <target>1.8</target>
  43.                     <encoding>utf-8</encoding>
  44.                 </configuration>
  45.             </plugin>
  47.         </plugins>
  48.     </build>
[3]两个配置类

添加一个RootConfig配置，这个配置类主要用来创建根容器。

这个类就相当使用XML配置文件整合时的spring的配置文件applicationContext.xml

  1. package com.qidian.config;
  3. import com.alibaba.druid.pool.DruidDataSource;
  4. import org.mybatis.spring.SqlSessionFactoryBean;
  5. import org.mybatis.spring.annotation.MapperScan;
  6. import org.springframework.beans.factory.annotation.Value;
  7. import org.springframework.context.annotation.*;
  8. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  9. import org.springframework.transaction.TransactionManager;
  10. import org.springframework.transaction.annotation.EnableTransactionManagement;
  12. import javax.sql.DataSource;
  14. /**
  15.  * @author  戴着假发的程序员
  16.  * 相当于spring的配置文件
  17.  */
  18. @Configuration
  19. //  配置service的扫描包
  20. @ComponentScans({
  21.         @ComponentScan("com.qidian.service") 
  22. })
  23. // 这个配置用来扫描加载所有的mapper接口和xml文件。 
  24. // 当然也可以使用@Bean的方式注入一个扫描器MapperScannerConfigurer来扫描
  25. @MapperScan("com.qidian.mapper")
  26. // 加载数据库连接的配置的资源文件
  27. @PropertySource("classpath:db.properties")
  28. public class RootConfig {
  30.     @Value("${jdbc.driver}")
  31.     private String driverClass;
  32.     @Value("${jdbc.url}")
  33.     private String url;
  34.     @Value("${jdbc.username}")
  35.     private String username;
  36.     @Value("${jdbc.password}")
  37.     private String password;
  39.     // 配置数据源
  40.     @Bean
  41.     public DataSource dataSource(){
  42.         // druid数据源
  43.         DruidDataSource dataSource = new DruidDataSource();
  44.         dataSource.setDriverClassName(driverClass);
  45.         dataSource.setPassword(password);
  46.         dataSource.setUsername(username);
  47.         dataSource.setUrl(url);
  48.         return  dataSource;
  49.     }
  50. 	// 注入SqlSessionFactoryBean
  51.     @Bean
  52.     public SqlSessionFactoryBean sqlSessionFactoryBean(){
  53.         SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  54.         bean.setDataSource(dataSource());
  55.         // 实体类别名包
  56.         bean.setTypeAliasesPackage("com.qidian.bank.pojo");
  57.         return bean;
  58.     }
  59. 	// 注入事务管理器
  60.     @Bean
  61.     public TransactionManager transactionManager(){
  62.         DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
  63.         transactionManager.setDataSource(dataSource());
  64.         return transactionManager;
  65.     }
  66. }

添加配置类WebConfig 这个类可以继承WebMvcConfigurer，可以通过父类的API添加视图解析器，静态资源映射，拦截器等等。

这个配置主要用来配置web相关的内容，扫描controller等。

  1. package com.qidian.config;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
  6. import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
  7. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  9. /**
  10.  * @author  戴着假发的程序员
  11.  */
  12. @Configuration
  13. // 扫描所有的controller
  14. @ComponentScan("com.qidian.controller")
  15. // 添加SpringMVC相关配置
  16. @EnableWebMvc
  17. public class WebConfig implements WebMvcConfigurer {
  18.     @Override
  19.     public void addResourceHandlers(ResourceHandlerRegistry registry) {
  20.         // 静态资源的映射
  21.         registry.addResourceHandler("/**/*.html").addResourceLocations("/");
  22.         registry.addResourceHandler("/**/*.css").addResourceLocations("/");
  23.         registry.addResourceHandler("/**/*.js").addResourceLocations("/");
  24.         registry.addResourceHandler("/**/*.png").addResourceLocations("/");
  25.         registry.addResourceHandler("/**/*.jpg").addResourceLocations("/");
  26.         registry.addResourceHandler("/lib/**/*.*").addResourceLocations("/lib/");
  27.         registry.addResourceHandler("/**/*.json").addResourceLocations("/");
  28.     }
  29. }

当然不要忘记在resources中添加db.properties

  1. jdbc.driver=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql://127.0.0.1:3306/bank?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8
  3. jdbc.username=root
  4. jdbc.password=

看看现在情况呢：

[4]RootWebApplicationContext和DispatcherServletWebApplicationContext

​ 以下简称RootWebApplicationContext为：RootContext，DispatcherServletWebApplicationContext为：DispatcherServletContext。

​ WebApplicationContext扩展了ApplicationContext，代表的Spring Web的应用上下文，RootContext由ContextLoaderListener创建，其中存放了各种注册到Spring的非Web组件的bean(比如service)。RootContext初始化完成后将其存储到ServletContext中，便于获取。在源码中你可以看到这样的代码：servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

  1. 接着是DispatcherServletContext的初始化，它会以RootContext为父上下文（在DispatcherServletContext中可以引用RootContext中的非web组件，而反过来不行。），然后初始化Web相关组件，比如控制器，视图解析器等。DispatcherServletContext初始化完毕后将自身存入ServletContext.

WebApplicationContext和DispatcherServlet上下文初始化方式

在主包中添加一个初始化Web环境的类：

  1. package com.qidian;
  3. import com.qidian.config.RootConfig;
  4. import com.qidian.config.WebConfig;
  5. import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
  7. /**
  8.  * @author 戴着假发的程序员
  9.  */
  10. public class BankContextInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
  11.     @Override
  12.     protected Class<?>[] getRootConfigClasses() {
  13.         // 根容器配置类
  14.         return new Class[]{RootConfig.class};
  15.     }
  17.     @Override
  18.     protected Class<?>[] getServletConfigClasses() {
  19.         // web容器配置类
  20.         return new Class[]{WebConfig.class};
  21.     }
  23.     @Override
  24.     protected String[] getServletMappings() {
  25.         // 拦截的路径
  26.         return new String[]{"/*","*.action"};
  27.     }
  28. }

看看这个类的位置：

[5]添加对应的mapper，service，controller进行测试了

浏览器访问：

源码下载地址：https://gitee.com/win-dk/SSM-annotation-demo

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/q2780004063/article/details/123148949

内容来源于网络，如有侵权，请联系作者删除！

JavaspringMavenspring框架

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com