Spring框架学习有这一篇就够！

一颗小谷粒

于 2024-09-02 16:24:34 发布

阅读量496

点赞数 12

分类专栏： Spring全家桶文章标签： java spring spring boot 后端数据库 mysql 开发语言

本文链接：https://blog.csdn.net/2301_79263365/article/details/141775094

版权

Spring全家桶专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Spring家族相关文章传送门：

Spring框架：开发者的得力伙伴，魅力何在?-CSDN博客

【Spring框架】揭秘AOP面向切面编程以及Spring事务管理-CSDN博客

Spring+SpringWeb+MyBatis三大框架整合教程实现先前后端交互搭建-CSDN博客

一. Spring

Spring 框架介绍

Spring框架简化了企业级应用开发，控制反转(IOC)和面向切面编程(AOP)是它最主要的两大特点，同时也提供了数据访问和事务管理功能。

控制反转 (IOC)

对象创建和组装的过程交给Spring管理，程序员只需要专注于业务代码即可。

IOC设计思想：

之前，当我们需要使用某个对象时，需要我们手动通过new的方式创建对象，但现在，我们将手动创建对象的控制权交给Spring框架来管理，由IOC容器负责对象的实例化、初始化、对象与对象之间的依赖关系、对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由IOC容器来控制，当我们需要使用某个对象时，直接从IOC容器中获取即可，所以控制反转也就是将创建对象的控制权反转给了Spring框架。

Spring 搭建

👨‍💻代码演示：搭建学习Spring框架的第一个Hello World程序

①创建maven项目，导入spring核心基础 jar包

        <!-- spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

②编写spring配置文件

在resources目录下创建一个spring.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
 
</beans>

③编写一个实体类

④在spring配置文件中，通过bean标签来指定让Spring框架管理的类

<bean id="admin" class="com.ffyc.ssmproject.model.Admin"></bean>

⑤测试

    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        //Spring 容器中获取一个名为"admin"的 bean
        Admin admin = applicationContext.getBean("admin", Admin.class);
        System.out.println(admin);
    }

成功获取对象属性：

我们没有通过手动new的方式创建对象，但仍然可以获取对象，这就是Spring框架的IOC设计思想！

Spring Bean 管理

Spring中Bean管理的方式有两种：一种是基于XML配置，一种是通过注解。

由于现在注解方式较为流行，也相对方便，所有这里我以注解的方式进行解读和演示：

①开启注解扫描

<context:component-scan base-package="com.ffyc.ssmproject"></context:component-scan>

②通过注解创建对象

@Component( value = "user" ) 等同于 <bean id="user" class=" "></bean>

@Service：通常添加到Service层的类名之上

@Repository：通常添加到Dao层的类名之上

@Autowired：自动注入。用于在属性和属性的set方法上，如果写在属性上, set方法都可以不需要。默认情况下，要注入的值不能为空（required = true）

以上注解都可以实现创建对象功能，只是为了后续扩展功能，在不同的层使用不同的注解标记

Scope设置：
@Scope( value = "prototype") 原型
@Scope( value = "singleton") 单例

依赖注入

注解与 XML 的对比

注解更加直观, 高效, 代码少，没有配置文件的书写那么复杂，但是是以硬编码的方式写入到 Java 代码中，修改时需要重新编译代码的。

xml 配置和代码是分离的，所以修改时无需编译代码，只需在 xml 中做修改，但是编写麻烦，效率低，大型项目过于复杂。

Spring 数据访问层管理

1. 引入 Spring JDBC 模块的依赖配置以及阿里巴巴的数据库连接管理组件 Druid

        <!-- spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
 
        <!--阿里数据源 数据库连接管理组件-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

➱ 在企业级应用中，通常需要与数据库进行交互。Spring JDBC 提供了一种高效、可靠的方式来处理数据库操作，适用于各种规模的企业级应用。

➱ 阿里巴巴数据库连接管理对象，负责生成数据库连接对象，以及提供数据库连接池功能。

2. 让spring管理阿里巴巴数据库连接对象

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value=""></property>
        <property name="url" value=""></property>
        <property name="username" value=""></property>
        <property name="password" value=""></property>
        <property name="initialSize" value="10"></property><!--初始化连接数量-->
        <property name="maxActive" value="20"></property><!--最大连接数量-->
    </bean>

Spring 集成 MyBatis

Spring集成Mybatis其核心是将SqlSessionFactory交由Spring管理，并由 Spring管理对dao接口的代理实现。

① 在pom.xml配置文件中再添加上三个依赖

        <!--  mysql组件-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.2</version>
        </dependency>
        
        <!-- spring集成mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>

② 配置sqlSessionFactory

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis.xml"></property>
        <property name="mapperLocations" value="classpath:mappers/*Mapper.xml">
        </property>
    </bean>

③ 指定生成接口代理

    <!-- 生成dao包下所有接口的代理对象 -->
    <bean id="mapperFactory" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.ffyc.ssm.dao"></property>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>

如图所示：

通过在spring.xml文件中配置后，MyBatis的配置文件中只需要配置一些设置集就可以了！

MyBatis配置文件：（mybatis.xml）

<?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="logImpl" value="STDOUT_LOGGING"/>
        <!-- 开启数据库列名与java属性名转换,例如user_name  userName  -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- 全局二级缓存开关 -->
        <setting name="cacheEnabled" value="true"/>
    </settings>

    <typeAliases>
        <!--为类配置别名-->
        <package name="com.ffyc.ssmproject.model"/>
    </typeAliases>

</configuration>

面向切面编程 (AOP)

什么是面向切面编程？

面向切面编程思想是将程序中非业务代码 (像提交事务，打印日志，权限验证，统一异常处理) 提取分离出来，然后在调用业务代码时，通过一个代理对象帮助我们调用这些提取出来的非业务代码，这样，在业务代码不用显示的调用非业务代码，做到了业务代码和非业务代码的分离，降低耦合度，减少重复，使得程序员可以专注于业务。

原理：动态代理模式（给业务代码生成代理对象）

小误区：AOP编程思想是Java中的，不是spring专有的，只是spring使用AOP这一编程思想

AOP的基础概念：

连接点：类中可以被增强的方法（可以加功能的方法）

切入点：类中实际被增强的方法

通知：一个切面在特定的连接点要做的事情(方法被增强的功能)，分为前置通知、后置通知、异常

目标：代理的目标类，也就是连接点和切入点所在的类

代理：向目标对象应用通知时创建的代理对象

Spring AOP实现 (通知)

① 引入 Spring Aspectj 依赖

        <!--aspectj-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

② 在spring配置文件中开启自动代理

    <!--开启自动代理-->
    <aop:aspectj-autoproxy />

③ 在通知的类上添加注解 @Aspect

通知类型：

• @Before( )：前置通知，在业务方法执行之前调用执行

• @After( )：后置通知，在业务方法执行完后调用执行，即使业务代码中出现了异常也会执行

• @AfterReturning( )：返回通知，在业务方法执行完后调用执行，但当业务代码中出现了异常，不会执行

• @AfterThrowing( )：异常通知，在业务代码出现异常时执行

• @Around( )：环绕通知，可以在业务方法执行之前, 之后, 出异常时添加功能 (四合一)

👨‍💻环绕通知代码演示：

    @Around(value = "execution(* com.ffyc.springpro.dao.AdminDao.*(..))")
    public void around(ProceedingJoinPoint joinPoint){
        //前置通知
        System.out.println("前置通知");
        try {
            Object proceed = joinPoint.proceed();//调用目标业务方法
            //返回通知
            System.out.println("返回通知");
        }catch (Throwable throwable){
            throwable.printStackTrace();
            //异常通知
            System.out.println("异常通知");
        }
        //后置通知
        System.out.println("后置通知");
    }

Spring 事务管理

事务管理本质上是数据库提供的一种管理机制。Spring事务管理是Spring框架对事物提交这一功能进行封装，程序员在业务的开发中不需要显示的提交事务。

什么是事务管理？

数据库事务管理是对一次数据库操作过程中执行的多条sql语句进行管理，确保一次操作过程中的多条sql要么都执行成功，要么都不执行，从而保证数据的一致性。

Spring中的事务管理有编程式事务管理和注解式事务管理两种管理形式，前者代码复杂且在项目中很少用到，所有我将以后者方式进行演示：

声明式事务底层使用了AOP思想，可以为方法添加事务功能，它的控制是方法级别的。

1. 配置Spring事物管理器：

    <!--配置Spring事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

2. 开启注解事务管理：

    <!-- 开启注解事务管理 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

如图所示：

3. 在需要管理的类/方法上添加@Transactional注解标签即可

如果添加到类上面，此类中所有的方法都在Spring事物管理中进行。通常加在service层。

声明式事务不生效的场景：

• @Transactional 应用在非 public 修饰的方法上

• 异常被catch捕获导致失效

• 出现编译期异常

• 数据库引擎不支持事务

在注解中加 rollbackFor = Exception.class 这样所有的异常都会回滚（第三点的解决方法）

mysql 中只有 innodb 引擎支持事务 (关于第四点补充)

二. Spring Web

Spring Web介绍

Spring Web 是 Spring 框架中的一个重要模块，主要用于构建 Web 应用程序。

用户发送出请求到前端控制器DispatcherServlet 。前端控制器由框架提供，只需在web.xml中配置，负责统一处理请求和响应，是整个流程控制的中心，由它调用其他组件处理用户请求。

搭建 Spring Web

1. 在pom.xml配置文件中引入依赖

        <!-- Spring Web-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

2. 配置DispatcherServlet (在web.xml文件中)

配置spring核心请求分发器：

    <servlet>
        <servlet-name>application</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring.xml</param-value>
        </init-param>
        <load-on-startup>0</load-on-startup>
    </servlet>
    <!--请求映射-->
    <servlet-mapping>
        <servlet-name>application</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

3. 开启web层注解

<mvc:annotation-driven></mvc:annotation-driven>

如图所示：

4. 在web层的类上添加注解标签

接收请求

定义请求方式：

如上图所示，在SpringWeb框架中，接收请求通常有两种方式，一种是通过@RequestMapping标签中的method来定义接收的是get请求还是post请求，另一种则是直接使用@GetMapping或@PostMapping标签来定义。

拦截器

拦截器是 Spring Web 框架中的一个重要组件，它可以在请求处理的不同阶段进行拦截和处理，实现一些通用的功能，如权限验证、日志记录等。

如何实现拦截器？

① 让一个类实现HandlerInterceptor接口，它提供了preHandle、postHandle和afterCompletion三个方法：

preHandle方法在请求处理之前被调用，如果返回true，则继续执行后续的请求处理流程；如果返回false，则中断请求处理流程。
postHandle方法在请求处理之后被调用，可以对响应进行处理。
afterCompletion方法在整个请求处理完成后被调用，无论请求处理是否成功，都会被执行。

👨‍💻代码演示：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.ffyc.ssm.model.Result;
import org.springframework.web.servlet.HandlerInterceptor;

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

public class AdminTokenInterceptor implements HandlerInterceptor {
    /*
    * 拦截器处理方法
    * 当请求到达处理器前 进入到拦截器进行处理
    * 返回true 离开拦截器向后执行到达处理器
    * 返回false 不再向后执行
    * */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String adminToken = request.getHeader("adminToken");
        if(adminToken.equals("123")){
            System.out.println(adminToken);
            return true;
        }else {
            Result result = new Result(401, "token验证失败", null);
            response.getWriter().write(new ObjectMapper().writeValueAsString(result));
            return false;
        }

    }
}

②在spring.xml配置文件中注册拦截器：

    <!-- 注册拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>  <!--定义进入拦截器的地址-->
            <mvc:exclude-mapping path="/loginCtl/login"/>  <!--定义不进入拦截器的地址-->
            <!--拦截器的实现类-->
            <bean id="admintoken" class="com.ffyc.ssm.interceptor.AdminTokenInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

拦截器和过滤器的区别

1. 运行顺序不同

过滤器是在客户端请求到达服务器，但还未到Servlet时运行的，而拦截器是在到达Servelt后，调用适配器(HandlerAdapter)前运行的。

2. 配置方式不同

过滤器是在web.xml中配置，而拦截器是在Spring中的配置文件中配置，并且拦截器可以设置哪些请求可以不通过拦截器，而过滤器不能直接设置。

3. 依赖性不同

Filter是依赖于Servlet容器的，而Interceptor依赖于SpringMVC。

三. Spring Boot

Spring 框架的不足

1. Spring框架的配置是重量级的，且存在很多固定的模版化配置

2. 在Spring框架中需要程序员自己添加项目所依赖的jar，如果版本不匹配还会出现兼容性问题

基于Spring框架的不足， SpringBoot相当于在Spring框架的基础上进行了二次封装

Spring Boot 介绍

1. 快速开发。简化了 Spring 应用的初始搭建以及开发过程。通过自动配置，极大地减少了配置文件的数量和复杂度，开发者只需专注于业务逻辑的实现。

2. 内嵌服务器。可以内嵌 Tomcat、Jetty 或 Undertow 等服务器，使得应用程序可以作为独立的可执行 JAR 包或 WAR 包运行，无需额外部署到外部服务器上，方便开发、测试和部署。

3. 起步依赖。通过引入起步依赖，可以快速添加所需的功能模块，如数据库访问、Web 开发、安全等。

4. 微服务支持。非常适合构建微服务架构，轻松实现服务的独立部署和扩展，且可以与其他微服务技术配合使用，实现高效的分布式系统。

搭建教程

由于我的JDK版本是1.8，使用的2.6.6版本进行搭建，版本较老，所以还是相对有点麻烦，如果大家使用的是最新的版本，可以在官网创建或在创建项目时勾选起步依赖。

方式一：官网搭建

将生成的压缩包解压，修改 pom.xml 版本为 2.6.6，删除.mvn 文件夹，mvnw.cmd 文件，再导入到idea中。(修改的版本依据个人情况)

方式二：项目搭建

1. 创建一个普通的maven项目，在pom.xml文件中配置：

    <!--依赖的父级工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.6</version>
        <relativePath/>
    </parent>

    <!--指定jdk版本-->
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <!--添加基本的springweb依赖-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <!--打包插件-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.6.6</version>
            </plugin>
        </plugins>
    </build>

2. 创建基本包目录，在包下创建一个启动类，如下所示：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class NewsApplication {

    public static void main(String[] args) {
        SpringApplication.run(NewsApplication.class);
    }

}

SpringBoot启动图案设置

SpringBoot启动图案https://www.bootschool.net/ascii-art点击链接，选择喜欢的图案，点击拷贝，在resources目录下创建一个banner.txt文件，然后粘贴进来，重新运行即可。（文件名必须是banner.txt）

四. Lombok插件 (了解)

Lombok通过注解的方式自动生成常见的样板代码，从而减少冗长的代码，提高开发效率！例如自动为我们类中的属性生成get/set方法，不需要我们手动生成。

1. 在IDEA设置中搜索lombok插件，下载并应用：

2. 在pom.xml文件中添加依赖：

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

3. 在类上添加注解标签即可：

一、@Data 注解

当一个类被标注上@Data后，Lombok 会自动为这个类生成以下方法：

所有字段的 getter 和 setter 方法。
equals()、hashCode()方法。
toString()方法，用于以字符串形式显示对象的状态。

使用@Data注解可以大大减少样板代码的编写，提高开发效率。

二、@AllArgsConstructor 注解

被@AllArgsConstructor标注的类会自动生成一个包含所有参数的构造函数。

例如，如果一个类有多个属性，手动编写构造函数可能比较繁琐，使用这个注解可以自动生成一个接受所有属性作为参数的构造函数，方便在创建对象时进行初始化。

三、@NoArgsConstructor 注解

同样来自 Lombok。被@NoArgsConstructor标注的类会自动生成一个无参构造函数。

在某些情况下，如需要通过反射创建对象或者与某些框架集成时，可能需要一个无参构造函数。这个注解可以自动为类生成一个无参构造函数，避免手动编写的麻烦。

（欢迎大家与我交流）

关注作者，带你领略更多Spring框架的魅力所在！持续更新中...... 博主微信：g2279605572

本次的分享就到此为止了，希望我的分享能给您带来帮助，创作不易也欢迎大家三连支持，你们的点赞就是博主更新最大的动力！如有不同意见，欢迎评论区积极讨论交流，让我们一起学习进步！有相关问题也可以私信博主，评论区和私信都会认真查看的，我们下次再见

一颗小谷粒

关注

12
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Spring框架学习有这一篇就够！

本篇文章详细介绍了Spring核心框架、SpringWeb、SpringBoot的搭建，以及Spring框架集成MyBatis框架，一篇文章带你学习当今最流行的SSM架构体系！(附Lombok插件安装教程)
复制链接

扫一扫