知识点2:Spring入门

Spring是什么？

1:是一个轻量级的开源框架，是为解决企业应用开发的复杂性而创建的；

2:是一个[三层架构](https://so.csdn.net/so/search?q=%E4%B8%89%E5%B1%82%E6%9E%B6%E6%9E%84&spm=1001.2101.3001.7020)，也为J2EE应用程序开发提供集成的框架；

        Web层：Spring MVC；

        业务层 ：Spring的IoC；

        持久层 ：Spring的JDBC、ORM、等持久层框架；

3:Spring的核心是：控制反转(IoC)和面向切面编程(AOP)；

Spring简介

Spring 的历史

Spring 是目前主流的 Java Web 开发框架，是 Java 世界最为成功的框架。该框架是一个轻量级的开源框架，具有很高的凝聚力和吸引力。

Spring 由 Rod Johnson 创立，2004 年发布了 Spring 框架的第一版，其目的是用于简化企业级应用程序开发的难度和周期。

随着Spring越来越受欢迎，在Spring Framework基础上，又诞生了Spring Boot、Spring Cloud、Spring Data、Spring Security等一系列基于Spring Framework的项目。本章我们只介绍Spring Framework，即最核心的Spring框架。

Spring Framework

• 支持IoC和AOP的容器；

  IoC 指的是将对象的创建权交给 Spring 去创建。使用 Spring 之前，对象的创建都是由我们使用 new 创建，而使用 Spring 之后，对象的创建都交给了 Spring 框架。AOP 用来封装多个类的公共行为，将那些与业务无关，却为业务模块所共同调用的逻辑封装起来，减少系统的重复代码，降低模块间的耦合度。另外，AOP 还解决一些系统层面上的问题，比如日志、事务、权限等。

• 支持JDBC和ORM的数据访问模块；

• 支持声明式事务的模块；

  在 Spring 中，认为一切 Java 类都是资源，而资源都是类的实例对象（Bean），容纳并管理这些 Bean 的是 Spring 所提供的 IoC 容器，所以 Spring 是一种基于 Bean 的编程，它深刻地改变着 Java 开发世界，使用基本的 JavaBean 来完成以前只有 EJB 才能完成的工作，使得很多复杂的代码变得优雅和简洁，避免了 EJB 臃肿、低效的开发模式，极大的方便项目的后期维护、升级和扩展。迅速地取代 EJB 成为了实际的开发标准。

• 支持基于Servlet的MVC开发；

• 支持基于Reactive的Web开发；

• 以及集成JMS、JavaMail、JMX、缓存等其他模块。

​

‍

Spring Framework 的核心功能

• 依赖注入（Dependency Injection, DI） ： Spring 提供了一种基于依赖注入的开发模型，这使得对象之间的依赖关系不再通过硬编码，而是通过配置（通常是基于注解或 XML 配置）来实现，增强了代码的可维护性和可测试性。

  DI（依赖注入）这里单独讲，因为DI其实是属于IoC内的一个分支，IoC本质上是一个概念，是一种思想，控制反转就是对对象控制权的转移，SpringIoC容器创建对象，然后将对象的使用权交出去在控制反转中，大致理解成是Spring赋值用的，一般讲到IoC就会降到DI，这边做简单的描述~

• 面向切面编程（Aspect-Oriented Programming, AOP） ： Spring 支持 AOP，可以将与业务逻辑无关的功能（如日志记录、事务管理、权限检查等）通过 AOP 技术分离出来，避免了横切关注点的污染。

• 声明式事务管理： Spring 提供了简化的事务管理机制，允许通过注解或 XML 配置方式来控制事务的边界。

• Spring MVC： Spring 包含一个强大的 Web 框架，称为 Spring MVC，用于构建基于 MVC（Model-View-Controller）模式的 Web 应用程序。它与其他 Spring 模块无缝集成，能够简化 Web 应用的开发。

• Spring Boot： Spring Boot 是 Spring 的子项目，通过自动配置、大量的开箱即用功能，简化了 Spring 应用的创建和部署，开发者可以在最少配置的情况下构建生产级的应用。

• 数据访问支持： Spring 对数据库访问提供了良好的支持，整合了 JPA、JDBC、MyBatis 等数据访问框架，简化了与数据库交互的流程。

其他分支与扩展

• Spring Boot：

  • 简化配置和快速开发；
  • 提供内嵌服务器（如 Tomcat、Jetty）；
  • 支持微服务架构。

• Spring Cloud：

  • 提供云原生应用的构建工具；
  • 支持服务发现、负载均衡和配置管理；
  • 集成 API 网关和熔断器。

• Spring Data：

  • 提供统一的数据访问策略；
  • 支持多种数据存储（如 MongoDB、Redis）；
  • 简化数据库操作和查询。

• Spring Security：

  • 提供强大的安全框架；
  • 支持认证和授权；
  • 集成 OAuth2 和 JWT 机制。

• Spring Reactive：

  • 支持响应式编程；
  • 提供高并发和低延迟的应用能力；
  • 与 WebFlux 结合，实现异步处理。

Spring的下载和安装

Spring下载演示

方法一：下载网址 https://repo.spring.io/artifactory/snapshot/org/springframework/spring/

​
​

Spring安装演示

​​

2.新建lib​目录, 引入开发Spring5的基本包

4.src​目录下: 新建一个容器配置文件beans.xml​

​​

创建好之后, 右上角进行配置, 不难

​​

方法二：

可以直接用Maven下载，根据坐标在Maven窗口中即可找到Spring源程序

• Spring 官网：https://spring.io/
• Spring Framework：https://spring.io/projects/spring-framework

使用Spring管理Bean

Spring的本质是一个bean工厂（beanFactory）或者说bean容器，它按照我们的要求，生产我们需要的各种各样的bean，提供给我们使用。在生产bean的过程中，Spring需要解决bean之间的依赖问题，因此引入了依赖注入（DI）技术。依赖注入是beanFactory在生产bean时为了解决bean之间依赖的一种技术。

beanFactory会在bean的生命周期的各个阶段中对bean进行管理。Spring将这些生命周期阶段通过各种接口暴露给我们，使我们可以对bean进行各种处理。只需让bean实现对应的接口，Spring就会在bean的生命周期中调用我们实现的接口来处理该bean。

以下是使用Spring管理Bean的几种方法，详细介绍如下：

1. 使用XML配置

在applicationContext.xml​中定义Bean。这种方式是Spring早期的配置方法，适用于不支持Java注解的场景。

<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">

    <bean id="myBean" class="com.example.MyClass">
        <property name="propertyName" value="value" />
    </bean>

</beans>

2. 使用Java注解

Spring支持使用Java注解来定义和管理Beans，提供了更简洁和直观的方式。

2.1 @Component​ 注解

可以用在类上，表示这个类是一个Spring Bean。Spring会自动扫描带有该注解的类并将其注册为Bean。

import org.springframework.stereotype.Component;

@Component
public class MyComponent {
    // 类体
}

2.2 @Service​ 注解

用于标识业务层的Bean，通常用于定义服务层的类，便于区分不同层次的Bean。

import org.springframework.stereotype.Service;

@Service
public class MyService {
    // 类体
}

2.3 @Repository​ 注解

用于数据访问层的Bean，主要用于数据访问对象（DAO）类，Spring会为此类提供异常转换。

import org.springframework.stereotype.Repository;

@Repository
public class MyRepository {
    // 类体
}

3. 依赖注入

使用@Autowired​注解进行依赖注入，Spring会自动将符合条件的Bean注入到目标Bean中。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {
  
    @Autowired
    private MyService myService;

    // 类体
}

4. 配置类

使用@Configuration​和@Bean​注解来定义Bean，允许在Java类中以编程方式创建Bean。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
  
    @Bean
    public MyClass myBean() {
        return new MyClass();
    }
}

5. Spring Boot自动配置

在Spring Boot应用中，使用@SpringBootApplication​注解自动扫描Bean，简化了配置过程。

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

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

6. Bean的生命周期管理

Spring会在Bean的生命周期中调用相关的接口，允许开发者在特定的生命周期阶段执行自定义逻辑。

6.1 初始化方法

可以通过@PostConstruct​注解标识一个初始化方法，在Bean创建后自动调用。

import javax.annotation.PostConstruct;

@Component
public class MyBean {
  
    @PostConstruct
    public void init() {
        // 初始化逻辑
    }
}

6.2 销毁方法

可以通过@PreDestroy​注解标识一个销毁方法，在Bean被销毁前自动调用。

import javax.annotation.PreDestroy;

@Component
public class MyBean {

    @PreDestroy
    public void cleanup() {
        // 清理逻辑
    }
}

7. Bean的作用域

Spring支持多种Bean作用域，如单例（singleton）、原型（prototype）、请求（request）和会话（session），可以通过@Scope​注解来设置。

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype") // 每次请求都会创建一个新的实例
public class MyPrototypeBean {
    // 类体
}

通过上述方法，Spring能够有效管理Bean的创建、依赖、生命周期以及作用域，为开发者提供灵活、可维护的应用架构。

使用Spring管理Bean

Spring的本质是一个bean工厂(beanFactory)或者说bean容器，它按照我们的要求，生产我们需要的各种各样的bean，提供给我们使用。只是在生产bean的过程中，需要解决bean之间的依赖问题，才引入了依赖注入(DI)这种技术。也就是说依赖注入是beanFactory生产bean时为了解决bean之间的依赖的一种技术而已。

beanFactory会在bean的生命周期的各个阶段中对bean进行各种管理，并且spring将这些阶段通过各种接口暴露给我们，让我们可以对bean进行各种处理，我们只要让bean实现对应的接口，那么spring就会在bean的生命周期调用我们实现的接口来处理该bean.

当然可以！以下是使用Spring管理Bean的几种方法，详细介绍并用Markdown格式输出。

1. 使用XML配置

在applicationContext.xml​中定义Bean。

<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">

    <bean id="myBean" class="com.example.MyClass">
        <property name="propertyName" value="value" />
    </bean>

</beans>

2. 使用Java注解

2.1 @Component​ 注解

可以用在类上，表示这个类是一个Spring Bean。

2.2 @Service​ 注解

用于标识业务层的Bean。

2.3 @Repository​ 注解

用于数据访问层的Bean。

3. 依赖注入

使用@Autowired​进行依赖注入。

4. 配置类

使用@Configuration​和@Bean​注解定义Bean。

5. Spring Boot自动配置

在Spring Boot应用中，使用@SpringBootApplication​自动扫描Bean。

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

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

‍

在Eclipse中使用Spring

一、首先下载好全部所需要的工具和jar包

1 安装 springsource-tool-suite:

（1）打开eclipse-help-marketplace

search中输入spring，下载

​​

按install，这里我已经下载好了

（2） 安装

然后点击下一步知道最后完成安装，重启Eclipse。

.最后Windows下的Preferences显示Spring选项即为安装成功。

​​

（3） 下载springframework包

http://repo.spring.io/release/org/springframework/spring/4.3.9.RELEASE/spring-framework-4.3.9.RELEASE-dist.zip

（4） 下载spring依赖的日志包commons-logging

http://commons.apache.org/proper/commons-logging/download_logging.cgi

（5） 将（3）和（4）解压后将相关jar包放在工程的lib目录下。

​

在IDEA中使用Spring

首先利用IDEA创建Maven工程项目

1.选择新建项目
​​

2.选中Maven骨架
​
3.填写项目名称和项目位置
4.Finsh之后默认打开的是pom.xml文件
​
5.在pom.xml文件下填写Spring的相关依赖(其中有一些拓宽工具依赖)
​
​
5.1完整的pom.xml代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

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

    <dependencies>
        <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13</version>
        </dependency>
            <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
            <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.9</version>
        </dependency>
            <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
            <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>

解决IDEA Maven 下载依赖包速度过慢问题 ，jar包下载过慢，有一部分网络原因，很大一部分是因为需要请求到国外镜像仓库，响应比较慢

右键点击项目，找到maven，选择 Open ‘settings.xml’或者Create ‘settings.xml’

​​

将以下代码粘入文件中，重启idea即可提高速度

idea超级镜像库，这是阿里云镜像库和junit镜像库

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<mirrors>

<!--    <mirror>-->
<!--      <id>mirrorId</id>-->
<!--      <mirrorOf>repositoryId</mirrorOf>-->
<!--      <name>Human Readable Name for this Mirror.</name>-->
<!--      <url>http://my.repository.com/repo/path</url>-->
<!--    </mirror>-->

    <mirror>
        <id>alimaven</id>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <mirrorOf>central</mirrorOf>
    </mirror>

    <mirror>
        <id>uk</id>
        <mirrorOf>central</mirrorOf>
        <name>Human Readable Name for this Mirror.</name>
        <url>http://uk.maven.org/maven2/</url>
    </mirror>

    <mirror>
        <id>CN</id>
        <name>OSChina Central</name>
        <url>http://maven.oschina.net/content/groups/public/</url>
        <mirrorOf>central</mirrorOf>
    </mirror>

    <mirror>
        <id>nexus</id>
        <name>internal nexus repository</name>
        <url>http://repo.maven.apache.org/maven2</url>
        <mirrorOf>central</mirrorOf>
    </mirror>

    <!-- junit镜像地址 -->
    <mirror>
        <id>junit</id>
        <name>junit Address/</name>
        <url>http://jcenter.bintray.com/</url>
        <mirrorOf>central</mirrorOf>
    </mirror>

<!--    <mirrors>-->
        <!-- mirror
         | Specifies a repository mirror site to use instead of a given repository. The repository that
         | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
         | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
         |
        <mirror>
          <id>mirrorId</id>
          <mirrorOf>repositoryId</mirrorOf>
          <name>Human Readable Name for this Mirror.</name>
          <url>http://my.repository.com/repo/path</url>
        </mirror>
         -->

        <mirror>
            <!--This sends everything else to /public -->
            <id>nexus-aliyun</id>
            <mirrorOf>*</mirrorOf>
            <name>Nexus aliyun</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public</url>
        </mirror>

        <mirror>
            <id>osc</id>
            <mirrorOf>*</mirrorOf>
            <url>http://maven.oschina.net/content/groups/public/</url>
        </mirror>

        <mirror>
            <id>repo2</id>
            <mirrorOf>central</mirrorOf>
            <name>Human Readable Name for this Mirror.</name>
            <url>http://repo2.maven.org/maven2/</url>
        </mirror>

        <mirror>
            <id>net-cn</id>
            <mirrorOf>central</mirrorOf>
            <name>Human Readable Name for this Mirror.</name>
            <url>http://maven.net.cn/content/groups/public/</url>
        </mirror>

        <mirror>
            <id>ui</id>
            <mirrorOf>central</mirrorOf>
            <name>Human Readable Name for this Mirror.</name>
            <url>http://uk.maven.org/maven2/</url>
        </mirror>

        <mirror>
            <id>ibiblio</id>
            <mirrorOf>central</mirrorOf>
            <name>Human Readable Name for this Mirror.</name>
            <url>http://mirrors.ibiblio.org/pub/mirrors/maven2/</url>
        </mirror>

        <mirror>
            <id>jboss-public-repository-group</id>
            <mirrorOf>central</mirrorOf>
            <name>JBoss Public Repository Group</name>
            <url>http://repository.jboss.org/nexus/content/groups/public</url>
        </mirror>

        <mirror>
            <id>JBossJBPM</id>
            <mirrorOf>central</mirrorOf>
            <name>JBossJBPM Repository</name>
            <url>https://repository.jboss.org/nexus/content/repositories/releases/</url>
        </mirror>

    </mirrors>
</settings>

‍

8.1 bean的作用域
1.单例(Singleton)在整个应用程序中,只创建bean的一个shili2.原型(prototype)每次注入或通过Spring上下文获取的时候,都会创建一个新的bean实例3.会话(Session)在Web应用中,为每个会话创建一个bean实例4.请求(request)在Web应用中,为每个请求创建一个bean实例

8.2 Spring的框架运行有三种配置方式
1.xml配置2.自动装配(注解的方式)3.JavaConfig配置(如前面的AppConfig类+注解配置)

简单总结

1. Spring的环境搭建使用Maven更加方便
2. Spring的注解需要多学习,实际应用远不止这些基础注解
3. Spring的IOC控制反转和AOP切面编织思想需要认真理解
4. 博客的编写不够熟练,整体排版简陋