Spring基础3 - Spring的入门程序

目录

1. 引言
2. Spring框架概述
   • 2.1 Spring的特点
   • 2.2 Spring的核心功能
3. Spring项目搭建
   • 3.1 环境准备
   • 3.2 创建Spring项目
4. Spring的基本配置
   • 4.1 XML配置
   • 4.2 Java配置
   • 4.3 注解配置
5. Spring的依赖注入
   • 5.1 构造器注入
   • 5.2 Setter注入
6. Spring的AOP支持
   • 6.1 AOP的基本概念
   • 6.2 Spring AOP示例
7. Spring与数据库的集成
   • 7.1 JDBC与Spring
   • 7.2 Spring Data JPA示例
8. Spring Boot快速入门
   • 8.1 Spring Boot简介
   • 8.2 创建Spring Boot应用
9. 总结与展望

---

引言

Spring框架是一个开源的企业级应用开发框架，广泛应用于Java开发中。它提供了全面的基础设施支持，使得开发者能够轻松地构建高效、可维护的应用程序。本文将介绍Spring的入门程序，并展示一些实际的案例与场景，以便读者能更好地理解和使用Spring框架。

Spring框架概述

2.1 Spring的特点

• 轻量级：Spring框架本身非常轻量，对开发者友好。
• 控制反转（IoC）：通过IoC容器，Spring管理对象的生命周期与依赖关系。
• 面向切面编程（AOP）：支持AOP，帮助开发者实现横切关注点的分离。
• 模块化：Spring提供多个模块，开发者可以根据需求选择相应模块。

2.2 Spring的核心功能

• IoC容器：管理Bean的创建及其依赖关系。
• AOP支持：提供对面向切面的编程支持。
• 持久化支持：与多种持久化技术如JDBC、Hibernate无缝集成。
• MVC框架：支持构建Web应用程序，提供Model-View-Controller架构。

Spring项目搭建

3.1 环境准备

在开始之前，需要确保以下环境已准备：

• JDK 1.8 或以上
• Maven
• IDE（如 IntelliJ IDEA 或 Eclipse）

3.2 创建Spring项目

使用Maven创建一个新的Spring项目。在终端中运行以下命令：

bashCopy Code
mvn archetype:generate -DgroupId=com.example -DartifactId=spring-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

进入项目目录：

bashCopy Code
cd spring-demo

更新 pom.xml 文件，添加Spring依赖：

xmlCopy Code
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.9</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.3.9</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.9</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Spring的基本配置

4.1 XML配置

在 src/main/resources 目录下创建 applicationContext.xml 文件：

xmlCopy Code
<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="helloWorld" class="com.example.HelloWorld"/>
</beans>

创建一个简单的 Java 类 HelloWorld：

javaCopy Code
package com.example;

public class HelloWorld {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

在主程序中加载Spring上下文并调用方法：

javaCopy Code
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
        helloWorld.sayHello();
    }
}

4.2 Java配置

你也可以使用Java配置来代替XML配置。在 App 类中可以直接使用 @Configuration 和 @Bean 注解：

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

@Configuration
public class AppConfig {
    @Bean
    public HelloWorld helloWorld() {
        return new HelloWorld();
    }
}

更新 main 方法以使用 Java 配置：

javaCopy Code
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        HelloWorld helloWorld = context.getBean(HelloWorld.class);
        helloWorld.sayHello();
    }
}

4.3 注解配置

Spring还支持基于注解的配置。首先需要在 HelloWorld 类中添加 @Component 注解：

javaCopy Code
import org.springframework.stereotype.Component;

@Component
public class HelloWorld {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

然后在 AppConfig 中启用组件扫描：

javaCopy Code
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

Spring的依赖注入

5.1 构造器注入

在 Spring 中，可以通过构造器注入依赖。例如，创建一个 GreetingService 接口和其实现：

javaCopy Code
public interface GreetingService {
    void greet();
}

@Component
public class GreetingServiceImpl implements GreetingService {
    @Override
    public void greet() {
        System.out.println("Greetings!");
    }
}

@Component
public class HelloWorld {
    private GreetingService greetingService;

    @Autowired
    public HelloWorld(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    public void sayHello() {
        greetingService.greet();
    }
}

5.2 Setter注入

除了构造器注入外，Spring 还支持 Setter 注入：

javaCopy Code
@Component
public class HelloWorld {
    private GreetingService greetingService;

    @Autowired
    public void setGreetingService(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    public void sayHello() {
        greetingService.greet();
    }
}

Spring的AOP支持

6.1 AOP的基本概念

面向切面编程（AOP）是一种编程范式，用于实现横切关注点的分离，比如日志记录、性能监控等。在 Spring 中，可以使用 AOP 功能来增强方法的行为。

6.2 Spring AOP示例

首先，添加 AOP 相关依赖：

xmlCopy Code
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

创建一个切面类，定义横切逻辑：

javaCopy Code
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.HelloWorld.sayHello(..))")
    public void logBefore() {
        System.out.println("Executing sayHello method");
    }
}

Spring与数据库的集成

7.1 JDBC与Spring

Spring 提供了对 JDBC 的支持，简化了数据库操作。创建 JdbcConfig 类：

javaCopy Code
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

import javax.sql.DataSource;

@Configuration
public class JdbcConfig {
    
    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/testdb");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate() {
        return new JdbcTemplate(dataSource());
    }
}

通过 JdbcTemplate 进行数据库操作：

javaCopy Code
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

@Component
public class UserDao {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void createUser(String name) {
        String sql = "INSERT INTO users (name) VALUES (?)";
        jdbcTemplate.update(sql, name);
    }
}

7.2 Spring Data JPA示例

Spring Data JPA 使得数据访问更简单。

首先，添加依赖：

xmlCopy Code
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

创建实体类：

javaCopy Code
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    // getters and setters
}

创建Repository接口：

javaCopy Code
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

使用Repository

在服务中使用Repository：

javaCopy Code
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;

    public List<User> findAll() {
        return userRepository.findAll();
    }

    public void save(User user) {
        userRepository.save(user);
    }
}

Spring Boot快速入门

8.1 Spring Boot简介

Spring Boot 是一个用于简化 Spring 应用程序开发的框架，提供了开箱即用的配置和快速开发的能力。

8.2 创建Spring Boot应用

创建 Spring Boot 应用的最简单方式是使用 Spring Initializr。

选择项目元数据，勾选所需的依赖项，点击生成项目。

下载后解压缩并导入到 IDE 中。

在 Application 类中添加 @SpringBootApplication 注解：

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

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

创建一个 REST 控制器：

javaCopy Code
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    
    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}

总结与展望

Spring 框架是一个强大的工具，适用于企业级应用开发。本文介绍了 Spring 的基本概念、配置方式、依赖注入、AOP 支持以及与数据库的集成。借助 Spring Boot，开发者能够更加高效地构建应用程序，享受极速开发的乐趣。

未来，可以深入学习 Spring 的更多高级特性，如 Spring Security、Spring Cloud 等，以应对更复杂的企业需求。

---

希望这篇文章能够帮助您更好地理解和使用 Spring 框架！