【Spring框架】

一、引言

Spring框架自2003年发布以来，凭借其轻量级、易于扩展的特性，在Java企业级应用开发领域得到了广泛的应用。本文旨在帮助初学者快速掌握Spring框架的基本使用，并为进阶学习打下基础。

二、Spring核心概念

1. 控制反转（IoC）
2. 依赖注入（DI）
3. 面向切面编程（AOP）

三、Spring入门示例

4. 添加Spring依赖
   首先，在项目的pom.xml文件中添加Spring的依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.9</version>
    </dependency>
</dependencies>
1
2
3
4
5
6
7

5. 创建Bean
   创建一个名为User的Java类，用于表示用户信息：

public class User {
    private String name;
    private int age;
    // 构造函数、设值方法和toString方法省略
}
1
2
3
4
5

6. 配置Spring容器
   在src/main/resources目录下创建一个名为applicationContext.xml的配置文件，配置User类的Bean：

<?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">
    <bean id="user" class="com.example.demo.User">
        <property name="name" value="张三"/>
        <property name="age" value="25"/>
    </bean>
</beans>
1
2
3
4
5
6
7
8
9

7. 获取Bean
   在测试类中，通过Spring容器获取User对象：

public class DemoTest {
    @Test
    public void test() {
        // 加载配置文件，创建Spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取Bean
        User user = (User) context.getBean("user");
        System.out.println(user);
    }
}
1
2
3
4
5
6
7
8
9
10

运行测试类，输出结果如下：

User{name='张三', age=25}
1

四、进一步了解Spring的依赖注入

8. 构造器注入
9. 设值注入
10. 自动装配
    以下是设值注入的示例：
    首先，确保User类中有相应的setter方法：

public class User {
    private String name;
    private int age;
    // 省略构造函数和其他代码
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
1
2
3
4
5
6
7
8
9
10
11

然后，在applicationContext.xml中配置设值注入：

<bean id="user" class="com.example.demo.User">
    <property name="name" value="王五"/>
    <property name="age" value="28"/>
</bean>
1
2
3
4

五、Spring的面向切面编程（AOP）

以下是一个简单的AOP示例：
11. 添加AOP依赖
在pom.xml中添加Spring AOP的依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.3.9</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>
1
2
3
4
5
6
7
8
9
10

12. 创建切面类
    创建一个名为LoggingAspect的类，用于记录方法调用的日志：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class LoggingAspect {
    @Pointcut("execution(* com.example.demo.UserService.*(..))")
    public void pointcut() {}
    @Before("pointcut()")
    public void beforeAdvice() {
        System.out.println("方法执行前，记录日志...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

13. 配置AOP
    在applicationContext.xml中配置AOP：

<aop:aspectj-autoproxy/>
<bean id="loggingAspect" class="com.example.demo.LoggingAspect"/>
1
2

14. 创建目标类
    创建一个名为UserService的类，作为AOP的目标：

public class UserService {
    public void addUser() {
1
2

    System.out.println("添加用户...");
}
1
2

}

在applicationContext.xml中配置UserService的Bean：
```xml
<bean id="userService" class="com.example.demo.UserService"/>
1
2
3

15. 测试AOP
    在测试类中，通过Spring容器获取UserService对象，并调用addUser方法：

public class AopTest {
    @Test
    public void testAop() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.addUser();
    }
}
1
2
3
4
5
6
7
8

运行测试类，输出结果如下：

方法执行前，记录日志...
添加用户...
1
2

从输出结果可以看出，在UserService的addUser方法执行前，LoggingAspect的beforeAdvice方法被调用，成功实现了AOP的日志记录功能。

六、总结

Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。