首页 > 其他分享 >Spring 框架介绍和使用

Spring 框架介绍和使用

时间：2022-12-05 14:09:05浏览次数：45  
标签：框架 Spring 代理 介绍 public Bean AOP class

微信公众号：运维开发故事，作者；老郑

本文主要是对 Spring 的一个基本使用，建议阅读时间 5min。

历史的选择

Spring 作为一个基础的框架，是在 Java EE 开发历史中，是成千上万公司选择。单独使用 Spring 的非常少了，很多都是用 Spring-Boot/Spring-Cloud 来开发，但是 Spring 基础依然是我们使用的基石。我们将一起来聊一聊 Spring 的基本使用。首先我们一起来了解一下 Spring 框架整体架构图如下：

Spring 框架介绍和使用_spring

  1. 数据访问/集成，包括 JDBC 、ORM、OXM、JMS 和 Transaction 模块；
  2. WEB 模块，包括 WebSocket、Servlet、Web、Porlet 模块；
  3. 核心容器，包括 Bean 模块、Core 模块、Context 模块 和 SpEL 模块；
  4. 其他部分，包括：AOP、Test 等模块

Spring 同类框架

  • Micronaut
  • Quarkus

Spring 核心功能

核心功能：控制反转（IOC） 、AOP 非核心功能：事件驱动、国际化、资源管理，数据绑定、类型转换 、SpEL、单元测试等。

PS：核心功能，在本文会有使用实践。

Spring Bean 容器

控制反转（IOC）是 Spring 框架的核心功能之一，其本质的就是将用户创建 Bean 的过程赋予给 IOC 容器去完成，实现 Bean 创建权利的反转为容器来创建 Bean 和依赖 Bean 。

Spring 框架介绍和使用_spring_02

image.png

Bean 创建

Spring 容器创建 Bean 只需要三个步骤：

  1. 定义 Bean
  2. 创建 Bean 容器/Bean 工厂
  3. 获取 Bean 对象

举一个例子：

public class TestMain {

    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(AppConfig.class);
        Student student = applicationContext.getBean(Student.class);
        student.study();
        student.sleep();
        student.study();
    }
}

@Configuration
@Import(Student.class)
class AppConfig {

}

@Component
class Student {

    private String name;

    private Integer source;

    public void study() {
        System.out.println("学习中...");
    }

    public void sleep() {
        System.out.println("休息中...");
    }
    // setter getter
}

运行上面的代码我们可以得到一下结果：

学习中...
休息中...
学习中...

上面的代码执行什么呢？其实我们可以将 ​​ApplicationContext​​理解为 Spring 容器对象，然后我们在 AppConfig 配置类中去定义 Spring 容器去帮助我们加载那些 Bean ，最后我们通过 getBean 方法获取我们注册的 Bean 对象。如下图：

Spring 框架介绍和使用_spring_03

在这个过程中使用到那些关键的接口/类呢？

  • BeanFactory� 是 Bean 的抽象工厂，也就是我们 ​​ApplicationContext​​ 的一个父接口。
  • BeanDefinition� 是 Bean 的定义信息， 比如 beanName, className, isAbstract� 等 Bean 定义信息。

注入依赖 （DI）

Spring IOC 容器主要是解决了 Bean 的创建和依赖管理的问题。我们常见的有两种依赖注入方式：

  1. 属性注入
  2. 构造方法注入

属性注入

通过成员属性的方式实现 Bean 的自动注入

@Component
class Student {
    @Autowired
    private Address address;
    // ...
}

@Component
class Address {
    // ...
}
  • 通过 ​​@Component​​可以将 Student 、Address 类标记为一个 bean 对象
  • 通过 ​​@Autowired​​可以将依赖 Bean 自动注入进来。

构造方法注入

通过构造方法实现 Bean 的自动注入

@Component
class Student {
    
 public Student(Address address) {
        this.address = address;
    }
}

@Component
class Address {
    // ...
}

Spring 的 IOC 解决了什么问题？

  1. 容器化，Spring包含并管理应用中对象的生命周期和配置（配置成单例还是原型，以及什么时候使用什么时候销毁）。
  2. 方便解耦，简化开发，Spring就是一个大工厂，可以将所有对象创建和依赖关系维护交给Spring管理，实现松耦合。符合高内聚低耦合的思想，这个特性也叫IOC（控制反转）。
  3. AOP编程的支持，Spring提供面向切面的编程，可以方便的实现对程序进行权限拦截、运行监控等功能，是通过动态代理和CGlib实现的，底层原理是反射。
  4. 声明式事务的支持，通过AOP来实现。不需通过编程的方式而进行管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明，便可将事务规则应用到业务逻辑中。
  5. 方便程序的测试，Spring对Junit4的支持，可以通过注解方便的测试Spring程序。
  6. 方便集成各种优秀框架，Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的直接支持（如Struts2、Hibernate、MyBatis等）。
  7. 异常处理，Spring提供方便的API把具体技术相关的异常转化为一致的unchecked异常（比如由JDBC、Hibernate或者JDO抛出的异常）。SpringMVC也有一个异常集中处理的思想，将异常抛给SpringMVC框架，由框架来处理异常。
  8. 降低JavaEE API的使用难度，Spring对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低。

Spring AOP 面向切面

AOP(Aspect Oriented Programming)是面向切面的意思。

理解 AOP

Java 是一个面向对象（OOP）的编程语言，但是它有一个弊端就是需要为多个不具有继承关系的对象引入一个公共行为时，例如：日志记录、权限验证、事务管理、访问统计等公共行为，这样不便于维护，而且有大量重复代码，AOP 可以实现和 AOP 的互补。

举个例子： 我们有两个逻辑登录业务、订单业务，需要在他们调用前后进行：权限验证、日志记录等公共逻辑。

  1. 通过 OOP 的方式实现我们需要做一个逻辑模板：权限验证，具体逻辑（登录、订单），日志记录。
  2. 通过 AOP 的方式实现我们只需针对具体逻辑（登录、订单）前后做一个自定义切点，进行权限验证、日志记录。

如下图：

Spring 框架介绍和使用_spring_04

经过 AOP 方式处理过后，我们可以减少公共对象的引用、通过非继承的方式来处理切入逻辑的拦截，实现公共逻辑和业务的逻辑的松耦合关系。

AOP 实现

Spring 通过代理的方式去实现 AOP，Java 代理的两种模式：静态代理、动态代理。

  • 静态代理：静态代理是指在程序运行前，可以理解为是 .java 文件编译后就存在代理类的字节码 .class 文件。
  • 动态代理：动态代理指在程序运行期间通过 JVM 反射等动态机制，在运行期生成代理对象确定代理逻辑。

Spring 的两种代理模式：

  • JDK 代理：核心类 JdkDynamicAopProxy。
  • GCLIB 代理：核心类 ObjenesisCglibAopProxy。

两种代理的选择：如果 Bean 实现了接口就采用 JDK 代理， 如果没有实现就采用 GCLIB 代理。

AOP 使用

假设已经有一个 UserService 类提供了登录业务，我们需要对该业务做一个【权限验证】、【日志记录】这两个公共逻辑，在不修改 UserService 类代码的前提下就可以通过 AOP 来解决。示例如下：

// 1. 测试类
public class AopTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(AopConfig.class);
        UserService userService = applicationContext.getBean(UserService.class);
        userService.login("admin", "123456");
    }
}

// 2. 配置类
@EnableAspectJAutoProxy
@Configuration
@Import({UserService.class, ValidateAspect.class})
class AopConfig {


}

// 业务类
@Component
class UserService {
    public String login(String username, String password) {
        System.out.println("username：" + username + ",password:" + password);
        return "ok";
    }
}

// Aspect
@Aspect
@Component
class ValidateAspect {

    @Pointcut("execution(public * io.zhengsh.simu.spring.UserService.*(..))")
    public void servicePoint() {
        // Do nothing
    }


    @Around("servicePoint()")
    public Object doAroundService(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("validate param invoke !!!");
        return joinPoint.proceed();
    }
}

maven 依赖

<!-- Spring核心依赖 -->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
  </dependency>
  <!-- Spring beans包-->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
  </dependency>
  <!-- Spring 容器包 -->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
  </dependency>

  <!-- aop -->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
  </dependency>

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

参考文档

  • Spring 官方文档
  • 骆驼整理说-Spring AOP
  • Java－为什么使用Spring框架


标签：框架,Spring,代理,介绍,public,Bean,AOP,class
From： https://blog.51cto.com/u_12970189/5911979

相关文章

  • Spring Boot实现任意位置的properties及yml文件内容配置与获取
    〇、参考资料1、SpringBoot中文乱码问题解决方案汇总​​https://blog.51cto.com/u_15236724/5372824​​2、springboot读取自定义配置properties文件★​​https://www.......
  • Spring Boot整合log4j实战（一）：排除自带依赖、日志重定向、测试类验证
    〇、参考资料1、springboot整合log4j全过程详解2、SpringBoot全局排除spring-boot-starter-logging依赖一、项目概述1、项目框架2、技术栈SpringBoot+log4j+SpringBoot......
  • pytest + yaml 框架 -5.调用内置方法和自定义函数
    前言在yaml用例文件中，有些数据不是固定的，比如注册账号，我需要每次生成不一样的，那么我们可以调用自己定义的函数pip安装插件pipinstallpytest-yaml-yoyoyaml中调用内置方......
  • Spring中@Async注解使用及配置
    Spring中@Async注解使用及配置参考文章：https://blog.csdn.net/weixin_42272869/article/details/123082657一、@Async注解的使用在使用spring框架中，可以非常简单方便的......
  • 答疑 - SAP OData 框架处理 Metadata 元数据请求的实现细节，前后端组件部署在同一台物
    我的知识星球里有一个朋友提出了SAPOData服务metadata缓存方面的疑问，本文就来详细说一说：jerry，啥时候有时间给介绍一下fiori的Metadata数据系统的处理机制吧。我现......
  • extjs4,spring mvc3上传文件
    本文讲解下extjs4结合springmvc3的注解完成上传文件的例子。1页面文件  <!--ExtJSFiles--><linkrel="stylesheet"type="text/css......
  • RT-Thread的信号 在keil中使用程序框架
    按照如下方式，添加信号，使用信号信号量的原理：操作系统中的信号量在解决线程之间的同步中起着非常大的作用，那么什么是信号量呢？百度百科：信号量(Semaphore)，有时被称为信号灯，......
  • Spring Boot注入静态变量
    SpringBoot注入静态变量@value或者@Autowired不能直接注入值给静态属性，spring不允许/不支持把值注入到静态变量中；spring支持set方法注入，我们可以利用非静态setter方法......
  • 几款JS 框架介绍和比较
     目前来看，JS框架以及一些开发包和库类有如下几个：Dojo、Scriptaculous、Prototype、yui-ext、Jquery、Mochikit、mootools、moo.fx。 Dojo（JS li......
  • Spring
    组成SpringCore：核心容器，BeanFactory提供了组件生命周期的管理，组件的创建、装配，销毁等功能。SpringContext：实现了ApplicationContext接口，Spring的上下文，拓展了核心容......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99