SSM整合之基础xml文件以及基础理解

最新推荐文章于 2024-05-15 01:23:24 发布
最新推荐文章于 2024-05-15 01:23:24 发布
阅读量789 收藏 4
点赞数 1
分类专栏： spring 文章标签： mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zly03/article/details/125701261
版权

文章目录

前言

最近在学习SSM框架，就去找了一些视频来看，写一篇整合的文章，文章包括一些整合的依赖，以及创建的xml文件

什么是SSM框架

SSM（Spring+SpringMVC+MyBatis）框架集由Spring、MyBatis两个开源框架整合而成（SpringMVC是Spring中的部分内容），常作为数据源较简单的web项目的框架。

主要分为四层：

  1. 持久层：dao层（Mapper)层

主要是用来对数据进行持久化的工作，我们一般会在该层设计接口，然后从数据源获取数据，更新数据等，从而进行业务数据的处理

  1. 业务层：Service层

Service层主要是用来写一些业务逻辑。

一般Service层是调用Mapper层，然后对数据进行处理后返回给Controller控制层

  1. 控制层：Controller层

控制层一般是对用来对业务模块的控制，控制层一般是为了处理视图层发起的请求，调用Serivice层来完成请求的处理。

  1. 视图层（View)：

视图层主要就是我们最常接触到的层，也是最接近用户的一层，主要负责前台的展示。

各层之间的关系，可以使用这张图来表示，表达的非常简略，主要是为了更加直观的展示各层之间的调用顺序，我们一般编写的顺序是从dao层到Service层，最后才到Controller层。

请添加图片描述

实例

下面就不对上述框架进行介绍了，直接上一个简单的整合实例以及创建。

首先我们需要创建一个maven项目，请确保你的本地仓库和配置文件都有正确配置。

pom依赖

 <groupId>org.example</groupId>
    <artifactId>ssm_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- MyBatis框架 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <!-- MyBatis整合Spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
        <!-- 数据库连接 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.23</version>
        </dependency>
        <!-- C3P0连接池-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>

        <!-- Spring框架 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <!-- AOP -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>

        <!-- Spring获取数据源-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.9</version>
        </dependency>

        <!--Servlet、JSP、JSTL-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- JUnit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

<!--        Lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.6</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>


    </dependencies>

构建项目的路径设置

<build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

Spring 文件配置

我们先配置一个database.properties来配置连接数据源的文件，这里我就只用简单的4个基础配置，最大连接数量这些就不添加在这里了。

jdbc.Driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=123456

数据库文件写好了我们是不是需要配置mybatis的配置文件了，那是不是需要配置一些选项，这里我们用的是Spring来整合项目，数据库的连接池管理就交给Spring 的BeanFactory来管理了

mybatis-config.xml

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--        配置数据源spring-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <typeAliases>
        <package name="com.DY.entity"/>
    </typeAliases>
    <mappers>
        <mapper resource="mapper/UserInfoMapper.xml"/>
    </mappers>

</configuration>

mappers是用来存放mapper层对应的接口配置文件，比如UserInfoMapper.xml。

配置好mybatis的文件后，我们是不是可以来配置Mapper层的文件了

spring-mapper.xml

我们需要配置连接池，通过context来获取到database.properties配置文件

<?xml version="1.0" encoding="UTF8"?>
<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
         https://www.springframework.org/schema/context/spring-context.xsd">

    <!--    1.关联数据库配置文件-->
    <context:property-placeholder location="classpath:database.properties"/>

    <!--    2. 连接池-->
    <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}"/>

    </bean>
    <!--    3。sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref = "dataSource"/>
        <!--        绑定配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <!--    配置mapper接口扫描包，动态实现mapper接口注入Spring容器,-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<!--        扫描dao包-->
        <property name="basePackage" value="com.DY.mapper"/>
    </bean>

</beans>

接着我们创建一个spring-service.xml文件来扫描service的接口文件

spring-service.xml

<?xml version="1.0" encoding="UTF8"?>
<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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       ">
<!--    扫描service下的包-->
    <context:component-scan base-package="com.DY.service.impl"/>

<!--    将所有的业务类，注入Spring,-->

    <bean id="UserInfoServiceImpl" class="com.DY.service.impl.UserInfoServiceImpl">
        <property name="userInfoMapper" ref="userInfoMapper"/>
    </bean>

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--        注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    
</beans>

我们是不是可以通过所有的业务类都注入Spring的工厂中，ref=“dataSource”，相当于在在这个Bean中注入id=dataSource这个Bean，这个我们在后面applicationContext.xml有定义，这里如果需要还可以定义Spring的AOP的配置。

那上述工作都完成后是不是可以到MVC层了，我们创建spring-mvc文件

spring-mvc.xml

<?xml version="1.0" encoding="UTF8"?>
<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-4.2.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.2.xsd">


<!--    1.注解驱动-->
    <mvc:annotation-driven/>

<!--    2.静态资源过滤-->
    <mvc:default-servlet-handler/>

<!--    3.扫描包-->
    <context:component-scan base-package="com.DY.controller"/>


<!--    4.视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

这个整合的比较老，使用的还是jsp文件，这里和web.xml是配合使用的。

最后是不是可以到applicationContext.xml文件的配置了，如果前面的我们都配置的没有问题，是不是我们直接import这些配置文件进去就完成整个整合了。

<?xml version="1.0" encoding="UTF8"?>
<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
       https://www.springframework.org/schema/context/spring-context.xsd">

    <import resource="classpath:spring-mapper.xml"/>
    <import resource="classpath:spring-service.xml"/>
    <import resource="classpath:spring-mvc.xml"/>
</beans>

最后

这里还是展示一些相关的代码吧，比如我需要新建一个controller包、entity包、mapper包、service包，在resources下面定义一些配置文件

在这里插入图片描述

展示代码

controller

@Controller
@RequestMapping("/user")
public class UserInfoController {
    private GetDate getDate;
    @Autowired
    @Qualifier("UserInfoServiceImpl")
    private UserInfoService userInfoService;

    //查询所有用户,并返回到页面
    @RequestMapping("/allUser")
    public String list(Model model){
        List<UserInfo> userInfos = userInfoService.querryAllUsers();
        model.addAttribute("userInfos", userInfos);
        return "allUser";
    }
}

entity，对应着数据库的表的字段名，一般采用驼峰命名法,@Data是lombok插件的注解可以自动帮你写getter和setter方法

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor

public class UserInfo {
    /**
     * 用户ID
     */
    private Long userId;
    /**
     *
     */
    private String username;
    /**
     *
     */
    private String userPassword;


    /**
     *
     */
    private Date createTime;
    /**
     *
     */
    private Date updateTime;

}

mapper, 展示一个UserInfoMapper

包括一些方法，和一些参数的获取

package com.DY.mapper;

import com.DY.entity.UserInfo;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface UserInfoMapper {
    /**
     * 增加用户
     */
//    int addUser(UserInfo userInfo);

    /**
     * 查询用户
     */
    UserInfo querryUserById(@Param("userId") Long userId);

    /**
     * 查询所有用户
     * DY
     * @return
     */
    List<UserInfo> querryAllUsers();

    /**
     * 增加用户
     * @param userInfo
     * @return
     */
    Integer insertUserInfo(UserInfo userInfo);

    /**
     * 更新用户
     */
    Integer updateUserInfo(UserInfo userInfo);

    /**
     * 根据用户姓名查询用户
     * @param userName
     * @return
     */
    List<UserInfo> querryUserByUserName(@Param("userName") String userName);

}

service层
service一般会分成两个部分，一个是接口部分，一个是这个接口的实现Impl包

比如这里我先展示UserInfoService

package com.DY.service;

import com.DY.entity.UserInfo;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface UserInfoService {
    UserInfo querryUserById(@Param("userId") Long userId);

    /**
     * 查询所有用户
     * DY
     * @return
     */
    List<UserInfo> querryAllUsers();

    /**
     * 插入一个新用户
     * @return
     */
    Integer insertUserInfo(UserInfo userInfo);

    /**
     * 更新用户信息
     * @param userInfo
     * @return
     */
    Integer updateUserInfo(UserInfo userInfo);

    /**
     * 根据用户姓名查询用户
     */
    List<UserInfo> querryUserByUserName(String userName);
}

这里是不是有一些业务逻辑的接口方法，对应的Impl类

UserInfoServiceImpl.java，需要@Autowired使用自动装载，将mapper层的注入到Service中，方便我们调用Mapper层的方法

package com.DY.service.impl;

import com.DY.entity.UserInfo;
import com.DY.mapper.UserInfoMapper;
import com.DY.service.UserInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;


@Service
public class UserInfoServiceImpl implements UserInfoService {
    //service层组合mapper,
    @Autowired
    private UserInfoMapper userInfoMapper;
    
    public void setUserInfoMapper(UserInfoMapper userInfoMapper) {
        System.out.println("设置mapper");
        this.userInfoMapper = userInfoMapper;
    }

    @Override
    public UserInfo querryUserById(Long userId) {

        return this.userInfoMapper.querryUserById(userId);
    }

    @Override
    public List<UserInfo> querryAllUsers() {

        return this.userInfoMapper.querryAllUsers();
    }

    @Override
    public Integer insertUserInfo(UserInfo userInfo) {
        System.out.println(userInfo);
        return this.userInfoMapper.insertUserInfo(userInfo);
    }

    @Override
    public Integer updateUserInfo(UserInfo userInfo) {
        System.out.println(userInfo);
        return this.userInfoMapper.updateUserInfo(userInfo);
    }

    @Override
    public List<UserInfo> querryUserByUserName(String userName) {
        System.out.println(userName);
        return this.userInfoMapper.querryUserByUserName(userName);
    }
}

总结

到这里，基本的整个项目的整合就结束了，可能写的还不是很清楚，只是我的粗略理解，刚学望各位大佬指点。

宏远十一冠王
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSM使用pom自动生成model,mapper.mapper.xml文件
麋鹿
03-26 624
导入所需要的pom依赖 额外配置文件 <build> <finalName>test</finalName> <pluginManagement> <plugins> <plugin> <groupId>or...
SSM框架的xml文件配置问题
qq_41981045的博客
06-28 397
#首先提一下一个由MAVEN建立的SSM框架到底该有几个xml文件。 在上图可以看到， WEB-INF下存在一个web.xml，这是配置web项目的总的文件。 在web.xml中， 我们加载其他用到的xml文件，也就是spring目录下的 spring-dao.xml ：配置数据持久层（dao层） spring-service.xml：配置业务层（service层） spring-mvc.x...
springboot中controller层接收参数，servers层调用mapper层
Code Writers
12-28 2356
很多小伙伴们在公司不管是测试C端产品还是B端产品，都会测到排序的业务需求；那么我们就会好奇排序是如何实现的呢？下面我们开始介绍代码的实现。
SSM框架配置文件详解
weixin_43521975的博客
08-17 4915
SSM框架配置文件详解 在SSM项目当中，所需要的配置文件总共有以下三个： ①web.xml ②applicationContext.xml ③springmvc.xml 以及两个properties文件jdbc.properties和log4j.properties 1.web.xml web.xml是ssm项目当中最重要的一个配置文件，当服务启动时会首先加载web.xml这个文件，里面包括了对前端控制器、字符编码的配置 案例： <?xml version="1.0" encoding
讲解SSM的xml文件
最新发布
m0_63251896的博客
05-15 285
SSM的xml文件
ssm项目的主要配置文件解析
weixin_53772494的博客
02-07 367
ssm项目主要的配置文件内容
mybatis（三）springboot整合mybatis（SSM）注解或mybatis的SQL语句XML映射文件实现方式
u011529483的博客
11-17 1678
springboot整合mybatis（SSM）注解或mybatis的SQL语句XML映射文件实现方式
整理ssm maven项目中的xml文件配置以防以后掉坑
chimeidian9400的博客
05-20 117
1、sqlMapConfig.xml 表头文件 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config...
ssm整合最基础demo
09-07
3. **Mapper接口和XML映射文件**：定义SQL查询和更新操作，XML文件中编写具体的SQL语句。 4. **Service接口和服务实现类**：业务逻辑层，通常通过@Autowired注入Mapper进行数据操作。 5. **Controller**：处理HTTP...
基于XML构建的SSM框架整合开发源码
03-25
项目概述： 本项目是一个基于XML构建的SSM（Spring、SpringMVC、MyBatis）整合...项目以XML方式进行SSM框架的搭建，确保了配置的清晰性和易于维护性，同时也便于开发者理解和扩展，是学习和实践SSM整合开发的良好起点。
SSM整合配置文件.rar
03-28
总的来说，这些配置文件共同构成了一个完整的SSM整合项目的基础框架，它们之间的协同工作使得开发者能够更专注于业务逻辑，而不是底层的基础设施。理解和配置这些文件对于进行有效的Java Web开发至关重要。
ssm框架整合配置文件
12-25
4. **batis的Mapper XML文件**：这些文件用于编写具体的SQL查询语句，每个Mapper XML文件对应一个Mapper接口，它们之间通过namespace进行关联，实现SQL与Java代码的分离。 5. **web.xml**：Web应用的部署描述符，...
ssm整合的配置文件
01-13
在这个"ssm整合的配置文件"中，我们将深入探讨这三个框架如何协同工作以及它们的核心配置。 1. **Spring框架配置**： Spring是整个SSM架构的基础，它提供依赖注入（DI）和面向切面编程（AOP）等核心功能。在`beans...
如何快速在ssm项目中快速生成mybatis-config.xml或mapper.xml
weixin_41083069的博客
05-08 504
如何快速在ssm项目中快速生成mybatis-config.xml或mapper.xml 首先要找到自己的mybatis-x.x.x.jar(你下载的版本，我的是mybatis-3.4.5.jar),解压，把里面的两个dtd文件保存在eclipse的文件夹里， dtd文件具体位置（解压后的org文件夹里的apache–>ibatis–>builder–>xml）在我下面的截图里：...
SSM框架学习-xml配置与注解配置的比较
qq_45681515的博客
05-10 271
ssm笔记
ssm框架 mybatis.xml 详解
kuirito的博客
05-16 788
m'y'batis.xml 说明
ssm框架的配置文件详解
dogedk的博客
10-25 412
主要的配置文件有：4.spring-mvc.xml(springmvc核心配置文件)5.web.xml6.实例Mapper.xml。
SSM 框架整合（基于 XML）
Spring-_-Bear 的 CSDN 博客
06-26 1191
SSM（Spring + SpringMVC + MyBatis）框架集由 Spring、MyBatis 两个开源框架整合而成（SpringMVC 是 Spring 中的部分内容），常作为数据源较简单的 Web 项目的框架。
SSM整合（xml版与注解版）-超详细
weixin_73608766的博客
06-02 348
javax.servlet-api依赖，使用作用范围为provided在web项目编译，测试的时候,提供servlet依赖，当tomcat运行起来的使用，tomcat本身也是Java写的，他也会依赖这个jar包，所以就不需要在提供了，否则就报错，tomcat不知道使用lib目录下的还是pom.xml文件中提供的了。2.3开启aop注解支持，如果我们在service层中使用aop切面编程的时候我们就需要提供aop注解支持（在controller层中是不建议使用aop注解的，推荐使用hander拦截器）
SSM框架整合的资料（pdf版本），直接下载打开后即可查阅
07-05
5. 配置MyBatis，如mybatis-config.xml，以及Mapper接口和Mapper XML文件。 6. 编写Controller、Service、DAO层的代码，利用注解进行方法映射和依赖注入。 7. 进行单元测试，确保各个组件正常工作。 通过以上步骤，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值