SpringFramework简述

最新推荐文章于 2024-06-06 19:45:10 发布

白菜园子

最新推荐文章于 2024-06-06 19:45:10 发布

阅读量1.2k

点赞数 24

文章标签： spring

本文链接：https://blog.csdn.net/qq_45927587/article/details/138843363

版权

springFramework简述

Spring Framework是一个开源的企业级Java应用程序框架，由Rod Johnson创建，首次发布于2003年。Spring的核心理念在于简化企业级Java开发并提高其可测试性，它通过提供一个全方位的基础架构支持，帮助开发者关注于业务逻辑而非基础设施的繁琐细节。以下是Spring Framework的一些核心特征和组件：

1.控制反转（IoC, Inversion of Control）和依赖注入（DI, Dependency Injection）

IOC，即控制反转（Inversion of Control），是一种设计模式，用于降低软件组件之间的耦合度，提高系统的灵活性和可维护性。在传统的程序设计中，组件之间的依赖关系通常由组件自身控制，而在采用IOC的设计中，这种依赖关系的管理交由外部容器来控制，即“控制权”的反转。这一模式在Spring框架中得到了广泛应用，并通过依赖注入（Dependency Injection，简称DI）技术实现。

IOC的基本原理

控制权转移：原本由代码内部直接负责创建依赖对象和管理对象生命周期的控制权，转移到外部容器（如Spring容器）。

依赖注入：容器在运行期间，动态地将依赖对象注入到需要依赖的对象中，而不是由对象自己创建依赖对象。这可以通过构造器注入、setter方法注入等方式实现。

为什么使用IOC

降低耦合：由于对象的依赖是由外部容器管理，因此对象之间不必直接依赖，降低了模块间的耦合性，有利于系统的解耦。

提高灵活性和可测试性：通过配置而非硬编码来管理依赖关系，使得组件更易于替换和配置，也使得单元测试更加容易，因为可以独立测试每个组件，无需关心其依赖。

增强可管理性和重用性：容器统一管理对象的生命周期，使得对象的创建、初始化、销毁等过程更加透明和统一，便于管理和重用对象。

Spring中实现IOC

在Spring框架中，可以通过XML配置文件或使用注解（如@Component、@Autowired等）来实现IOC和依赖注入。Spring容器读取这些配置或扫描带有特定注解的类，然后负责创建Bean实例及其依赖关系的解析和注入。
XML配置：在Spring的配置文件中定义Bean及其依赖关系。
<bean id="exampleBean" class="com.example.ExampleClass">
    <property name="dependency" ref="dependencyBean"/>
</bean>
注解配置：直接在类或字段上使用注解(@Autowired)来声明Bean及其依赖。
@Component
public class ExampleClass {
    @Autowired
    private DependencyClass dependency;
    
    // ...
}
通过这些机制，Spring框架实现了控制反转，使得开发者可以专注于业务逻辑的实现，而不必关心对象的创建和依赖关系的管理，从而提高了开发效率和应用的可维护性。

2.面向切面编程（AOP, Aspect-Oriented Programming）

面向切面编程（AOP，Aspect-Oriented Programming）是一种编程范式，用于解决软件开发中的横切关注点问题。横切关注点是指那些遍布于多个对象层次和模块中的功能，如日志记录、安全性验证、事务管理、异常处理等，这些功能通常会渗透到业务逻辑的各个部分，导致代码重复且难以维护。

AOP的核心概念包括

切面（Aspect）：切面是封装横切关注点的一个模块，比如日志记录切面就是负责所有日志记录功能的模块。
连接点（Joinpoint）：程序执行过程中的某个特定点，比如方法调用或异常抛出，可以在这些点插入切面代码。
切入点（Pointcut）：定义了切面应该在哪些连接点上执行的规则，即满足何种条件的连接点会被切面所影响。
通知（Advice）：在切面识别的连接点上执行的具体动作，比如“前置通知”在方法调用前执行，“后置通知”在方法调用后执行。
织入（Weaving）：将切面代码插入到目标对象上的过程，这个过程可以在编译时、类加载时或运行时进行。

如何使用AOP

以Java Spring框架为例，说明如何使用AOP：

1. 添加依赖

首先，确保你的项目中包含了Spring AOP的依赖。如果你使用Maven，可以在pom.xml中添加如下依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
2. 定义切面

创建一个切面类，该类中定义了通知（Advice）和切入点（Pointcut）。
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

   @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
       // 这里是在调用服务层方法之前执行的代码，例如打印日志
     System.out.println("Executing: " + joinPoint.getSignature().getName());
}
}
在这个例子中，@Before注解定义了一个前置通知，它将在匹配的连接点执行前被调用。切入点表达式execution(* com.example.service.*.*(..))指定了切入点为com.example.service包下的所有类的所有方法。

3. 配置AOP

在Spring Boot应用中，通常不需要额外配置，因为自动配置已经足够。但如果有特殊需求，可以通过配置类进一步定制AOP的行为。

应用场景

AOP广泛应用于处理那些与核心业务逻辑关系不大，但却影响整个应用程序或多个模块的功能，主要包括但不限于：

日志记录：在方法调用前后记录日志，帮助跟踪程序执行流程和问题排查。
权限验证：在访问敏感资源前验证用户权限，实现安全控制。
性能监控：记录方法执行时间，监控系统性能。
事务管理：在需要的地方自动开启和提交/回滚事务，保持数据一致性。
异常处理：集中处理特定类型的异常，如统一的错误日志记录或异常转换。
缓存：自动缓存方法的结果，提高系统响应速度。

通过在这些场景中应用AOP，可以减少代码重复，提高代码的可读性和可维护性，并使核心业务逻辑更加清晰。

AOP的优势在于它可以将业务逻辑与系统服务分离，使得开发者能够专注于核心业务逻辑的开发，同时又能够保证系统的非功能性需求得到统一和高效的管理。在Java世界中，Spring框架是一个广泛使用的支持AOP的框架，它提供了基于代理的AOP实现，使得开发者能够轻松地应用切面编程思想来增强应用程序的功能。

3.事务管理

Spring Framework 提供了一套强大的事务管理机制，允许开发者以声明式或编程式的方式来管理事务。以下是Spring事务管理的关键点和如何使用它的概览：

声明式事务管理

这是推荐的做法，因为它将事务管理代码从业务逻辑中分离出来，使得代码更简洁、易于维护。主要通过@Transactional注解来实现。

使用@Transaction注解：你可以在类或方法级别使用此注解来指定事务的属性，如传播行为（Propagation）、隔离级别（Isolation）、超时时间（Timeout）和是否只读（ReadOnly）等。例如：
@Service
@Transactional(rollbackFor = Exception.class)
public class UserService {
    public void createUser(User user) {
        // 业务逻辑
    }
}
在这个例子中，如果createUser方法内部抛出了异常，事务将自动回滚。

编程式事务管理

虽然不如声明式事务管理常用，但在某些复杂场景下可能需要更细粒度的控制，Spring提供了PlatformTransactionManager接口以及TransactionTemplate和TransactionManager的直接使用。

TransactionTemplate：通过模板方法模式简化事务管理代码，提供了回调方法来执行事务性操作。

直接使用TransactionManager：对于更复杂的事务控制，可以直接使用PlatformTransactionManager的API来手动管理事务的开始、提交和回滚。

核心接口与类

PlatformTransactionManager：是Spring事务管理的核心接口，不同的持久化技术会有各自的实现类，如JDBC的DataSourceTransactionManager，Hibernate的HibernateTransactionManager。
TransactionDefinition：定义了事务的隔离级别、传播行为、超时时间、是否只读等属性。
TransactionStatus：代表一个事务的状态，提供事务是否新开始、是否已提交或回滚等信息。

配置

XML配置：在Spring的XML配置文件中定义事务管理器bean，并配置事务属性。
Java配置：使用@Configuration和@EnableTransactionManagement注解，配合PlatformTransactionManager的bean定义来配置事务管理。

举例

假设我们有一个简单的银行转账业务场景，需要从一个账户转账到另一个账户，并确保这一系列操作处于同一个事务中。在Spring中，我们可以通过以下方式实现编程式事务管理：
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

public class BankService {

   private DataSourceTransactionManager transactionManager;
    private AccountDAO accountDAO;

    // 通过构造函数或者setter注入
    public BankService(DataSourceTransactionManager transactionManager, AccountDAO accountDAO) {
        this.transactionManager = transactionManager;
        this.accountDAO = accountDAO;
    }

    public void transferFunds(long fromAccountId, long toAccountId, double amount) {
       TransactionDefinition def = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(def);
       try {
            // 执行转账操作
            accountDAO.withdraw(fromAccountId, amount);
            accountDAO.deposit(toAccountId, amount);

           // 如果一切顺利，提交事务
            transactionManager.commit(status);
        } catch (Exception e) {
            // 发生异常，回滚事务
            transactionManager.rollback(status);
            throw e;
        }
  }
}
在这个例子中，transferFunds方法开始时创建了一个新的事务定义，并通过事务管理器获取了一个事务状态。之后，它尝试执行转账操作（提款和存款）。如果所有操作成功，它就提交事务；如果过程中有任何异常抛出，则通过事务状态回滚事务，保证数据的一致性。

注意事项

事务传播行为：在更复杂的场景中，可能需要考虑事务的传播行为，这在编程式事务管理中需要手动处理。
资源管理：确保在事务结束后正确关闭数据库连接等资源，虽然现代连接池和框架通常会自动管理这一点。
异常处理：需要仔细处理异常，确保在正确的异常情况下回滚事务，避免因不当的异常捕获导致事务没有按预期回滚。

编程式事务管理虽然提供了高度的控制力，但通常推荐使用声明式事务管理，因为它更简洁、更易于维护，并能减少代码中的错误。

优势

Spring事务管理的优势在于其灵活性和易用性，能够方便地与各种持久层技术集成，提供一致的事务管理接口，同时支持声明式事务降低了业务代码的耦合度，提高了开发效率和代码质量。

4.MVC框架

MVC（Model-View-Controller）框架是一种软件设计模式，广泛应用于构建用户界面的软件应用，特别是Web应用程序。这种模式将应用程序的逻辑分为三个核心部分，旨在分离关注点，提高代码的可维护性、可扩展性和可重用性。以下是MVC框架的每个部分的详细解释：

Model（模型）

职责: 模型负责封装数据和业务逻辑。它直接管理应用程序的数据、逻辑处理以及与数据库或其他持久层的交互。模型通常包含实体类（代表数据库中的表或业务对象）、业务逻辑类（处理数据验证、计算等）。
作用: 提供数据给控制器（Controller）处理，同时也可能根据控制器的指令更新数据。模型是应用程序的核心，与数据相关的所有操作都在这里完成，确保了数据的一致性和完整性。

View（视图）

职责: 视图负责展示用户界面，即数据的可视化。它从模型获取数据并将其呈现给用户。视图不包含业务逻辑，只关心如何布局和展示数据。
作用: 根据模型提供的数据渲染用户界面。当模型数据发生变化时，视图可以自动更新以反映这些变化。视图与用户的交互通常是单向的，即从模型到用户的展示。

Controller（控制器）

职责: 控制器作为模型和视图之间的协调者，处理用户输入，执行业务逻辑，并决定应该向用户展示哪些视图。它接收用户的请求，解析请求，调用模型进行处理，然后选择合适的视图返回给用户。
作用: 接收HTTP请求，根据请求类型和数据调用模型进行处理，处理完成后将结果传递给视图进行展示。如果需要，它还可以将用户的输入转发给模型进行数据更新。

MVC框架的工作流程

用户交互: 用户通过浏览器发起请求。
路由解析: 请求首先被框架的路由系统解析，确定应该由哪个控制器处理。
控制器处理: 控制器接收到请求后，根据请求的内容调用相应的模型处理业务逻辑。
模型处理: 模型可能需要从数据库获取数据，或者执行一些业务逻辑运算。
数据传递: 处理完毕后，模型将数据返回给控制器。
视图渲染: 控制器选择合适的视图，并将模型提供的数据传递给视图。
响应生成: 视图使用数据生成HTML页面或者其他格式的响应。
响应发送: 最终，响应被发送回用户的浏览器进行展示。

优点

解耦: MVC将应用程序的不同部分分离，便于独立开发、测试和维护。
可重用性: 模块化的结构使得代码和组件更容易重用。
扩展性: 新的需求可以容易地通过添加新的控制器、视图或模型来实现，而不影响现有代码。
灵活性: 支持多种视图展示同一份数据，适应不同设备和用户需求。

5.数据访问/集成

Spring简化了与数据库的交互，提供了JDBC、ORM（如JPA、Hibernate）和其他数据访问技术的支持，以及事务管理的集成。

JDBC模板 (JdbcTemplate)

Spring的JdbcTemplate是其提供的一个高度抽象化的类，用于简化使用JDBC进行数据库操作的过程。它处理了诸如打开和关闭连接、创建语句、处理异常等重复性工作，并提供了一系列方便的方法来执行SQL查询、更新和批处理操作。通过使用JdbcTemplate，开发者可以直接使用SQL语句，同时享受到Spring框架提供的事务管理和资源管理便利。

ORM（对象关系映射）

Spring框架对多种ORM框架提供了集成支持，其中最著名的包括：

JPA (Java Persistence API): JPA是Java平台上的一个ORM规范，它提供了一种标准化的方式来管理关系数据库中的对象。Spring Data JPA是Spring的一个模块，进一步简化了使用JPA的过程，通过提供Repository接口和自动实现，让开发者能够以声明式的方式操作数据库，无需编写具体的实现代码。

Hibernate: Hibernate是一个成熟的ORM框架，实现了JPA规范。Spring与Hibernate的集成允许开发者利用Spring的依赖注入和事务管理功能，同时享受Hibernate带来的对象关系映射便利。

jpa举例:

环境设定

假设你已经创建了一个Spring Boot项目，并添加了Spring Data JPA和相应的数据库驱动（例如，对于MySQL，你需要添加spring-boot-starter-data-jpa和mysql-connector-java依赖）到项目的pom.xml文件中。

实体类（Entity）

首先，我们定义一个实体类，比如一个简单的User实体：
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity // 标记这是一个JPA实体类
public class User {
    @Id // 标记这是主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 主键生成策略
    private Long id;
    private String name;
    private String email;

    // 构造器、getter和setter省略
}
Repository接口

接着，我们创建一个继承自JpaRepository的接口，Spring Data JPA会自动为我们生成实现：
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // 这里可以定义自定义的查询方法，Spring Data JPA会自动实现
    List<User> findByName(String name);
}
Service类

然后，在Service层，我们注入Repository并使用它来进行数据库操作：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User createUser(User user) {
        return userRepository.save(user);
    }

    public List<User> getUsersByName(String name) {
        return userRepository.findByName(name);
    }

    // 其他CRUD方法...
}
Controller类

最后，在Controller层，我们将Service暴露为REST API：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    @GetMapping("/users")
    public List<User> getUsersByName(@RequestParam String name) {
        return userService.getUsersByName(name);
    }
}
在这个例子中，我们展示了如何定义一个实体类，创建一个Repository接口来处理数据访问，使用Service进行业务逻辑处理，最后通过Controller暴露为Web服务。Spring Data JPA自动帮我们处理了SQL查询的编写，使得我们可以专注于业务逻辑。

Spring Data

Spring Data是Spring家族中的一个重要组成部分，它为各种数据访问技术提供了统一的编程模型。Spring Data的关键特性包括：

Repository接口: 开发者只需定义一个简单的接口，Spring Data就能自动为其生成实现，从而极大地减少了编写数据访问代码的工作量。
查询方法命名规则: 通过遵循一定的命名约定，Spring Data能够自动生成查询语句，使得开发者无需编写复杂的SQL或查询DSL。
多数据源支持: Spring Data能够轻松处理多个数据源，适用于那些需要访问不同数据库的应用场景。
支持多种数据库和数据存储技术: 包括但不限于关系型数据库（如MySQL、PostgreSQL）、NoSQL数据库（如MongoDB）、以及图数据库等。

6.安全性

Spring Security为应用提供了全面的安全服务，包括认证、授权、保护Web请求等。

Spring Security是一个强大的、高度可定制的身份验证和访问控制框架，用于为Java应用程序提供安全服务。它无缝集成Spring框架，支持多种认证机制（包括HTTP基本认证、表单登录、OAuth2等）和授权策略（如角色-based权限控制、访问决策管理等）。下面通过一个基础示例来说明如何在Spring Boot应用中使用Spring Security进行基本的安全配置。

环境设定

确保你的Spring Boot项目中已加入Spring Security依赖。通常情况下，在pom.xml中加入以下依赖即可：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
基础配置

Spring Security提供了基于Java配置的方式，我们可以在一个配置类中设置安全规则。下面是一个简单的配置示例，用于开启表单登录和定义一些基本的访问规则：
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/resources/**", "/signup", "/about").permitAll() // 允许所有人访问资源、注册和关于页面
            .anyRequest().authenticated() // 任何其他请求都需要身份验证
            .and()
            .formLogin() // 启用表单登录
            .loginPage("/login") // 自定义登录页面的URL
            .defaultSuccessUrl("/home") // 登录成功后跳转的URL
            .permitAll()
            .and()
            .logout() // 启用注销功能
            .logoutUrl("/logout") // 自定义注销URL
            .permitAll();
    }

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password(passwordEncoder().encode("password")).roles("USER"); // 简单的内存认证用户
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder(); // 密码编码器
    }
}
解释

@EnableWebSecurity注解启用了Spring Security的Web安全支持。
configure(HttpSecurity http) 方法用来配置HTTP相关的安全约束，如哪些URL需要被保护，哪些不需要，以及如何处理登录和注销等。
configureGlobal(AuthenticationManagerBuilder auth) 方法用于配置全局的认证信息，这里简单地使用内存中的用户进行演示，实际项目中可能会连接数据库获取用户信息。
PasswordEncoder用于加密密码，确保存储和传输过程中的安全性。

这个基本配置实现了：

对除了指定的公共资源外的所有请求进行身份验证。
设置了一个登录页面，并指定了登录成功后的跳转地址。
启用了注销功能，并指定了注销的URL。

这只是Spring Security强大功能的冰山一角，根据需要，你可以配置更复杂的认证逻辑、授权策略、异常处理、CSRF防护等高级功能。

7.测试支持

Spring框架非常注重测试，提供了对JUnit等测试框架的集成，以及模拟对象（Mock Objects）的创建，便于进行单元测试和集成测试。

白菜园子

关注

24
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
SpringFramework简述

Spring Framework是一个开源的企业级Java应用程序框架，由Rod Johnson创建，首次发布于2003年。Spring的核心理念在于简化企业级Java开发并提高其可测试性，它通过提供一个全方位的基础架构支持，帮助开发者关注于业务逻辑而非基础设施的繁琐细节。以下是Spring Framework的一些核心特征和组件： Spring简化了与数据库的交互，提供了JDBC、ORM（如JPA、Hibernate）和其他数据访问技术的支持，以及事务管理的集成。 Spring
复制链接

扫一扫