Spring Framework 学习笔记2：注解开发

于 2023-09-28 09:00:00 发布
阅读量361 收藏
点赞数
分类专栏： JAVA 文章标签： spring 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hy6533/article/details/133361892
版权

Spring Framework 学习笔记2：注解开发

本文使用的示例项目是 spring-demo。

1.@Component

@Component注解的用途与<bean/>标签的用途是相同的，都用于向 IoC 容器添加一个 Bean 定义。

比如：

@Component
public class UserDaoImpl implements UserDao {
    @Override
    public void save(){
        System.out.println("UserDaoImpl.save() is called.");
    }
}

只使用@Component注解是不够的，我们还需要告诉 IoC 容器在哪个包路径下检索 Bean 定义：

<context:component-scan base-package="cn.icexmoon.springdemo.dao"/>

需要引入命名空间 context，方式在上一篇文章中有介绍。

现在 Spring 会自动扫描cn.icexmoon.springdemo.dao包下的 Java 类，如果有使用@Component注解，就会将其添加到 Bean 定义。

实际上通常会使用项目的顶级包名，这样就可以扫描项目下的所有类：

<context:component-scan base-package="cn.icexmoon.springdemo"/>

现在通过 IoC 容器就可以获取 Bean 实例：

ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
UserDao userDao = ctx.getBean(UserDao.class);
userDao.save();

默认情况下@Component注解创建的 Bean 的名称使用的是类名（首字母小写）：

UserDao userDao = ctx.getBean("userDaoImpl", UserDao.class);

可以通过value属性指定 Bean 名称：

@Component("userDao")
public class UserDaoImpl implements UserDao {
    // ...
}

public class Application {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
        UserDao userDao = ctx.getBean("userDao", UserDao.class);
        userDao.save();
    }
}

@Component有一些衍生注解，比如：

  • @Service，表示 Service 层的 Bean。
  • @Controller，表示 Controller 层的 Bean。
  • @Repository，表示持久层的 Bean。

用途是相同的，都是用于定义 Bean，只不过对 Bean 的用途进行了进一步的区分。

所以示例可以改写为：

@Repository("userDao")
public class UserDaoImpl implements UserDao {
	// ...
}

@Service
public class UserServiceImpl implements UserService {
    // ...
}

public class Application {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
        UserDao userDao = ctx.getBean("userDao", UserDao.class);
        userDao.save();
        UserService userService = ctx.getBean(UserService.class);
        userService.save();
    }
}

2.纯注解开发

虽然现在 Bean 定义已经通过@Component注解实现了，但示例项目依然要加载 XML 配置文件。可以进一步改为不使用配置文件的“纯注解开发”。

需要先准备一个配置类：

@Configuration
@ComponentScan(basePackages = "cn.icexmoon.springdemo")
public class WebConfig {
}

@Configuration表示这个类是一个配置类，它充当了 XML 配置文件的功能，可以用于定义 Bean。

在配置类上添加一个@ComponentScan注解可以用于指定扫描 Bean 定义的包范围，相当于之前使用的<context:component-scan/>标签。

IoC 容器的创建也需要修改，实现类使用AnnotationConfigApplicationContext，将不再加载 XML 配置文件，而是加载配置类作为 Bean 定义：

public class Application {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(WebConfig.class);
        // ...
    }
}

现在已经可以删除 XML 配置文件了。

3.@Scope

注解开发模式下，Bean 默认的作用域同样为单例，可以使用@Scope注解修改作用域：

@Repository("userDao")
@Scope("prototype")
public class UserDaoImpl implements UserDao {
    @Override
    public void save(){
        System.out.println("UserDaoImpl.save() is called.");
    }
}

public class Application {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(WebConfig.class);
        UserDao userDao = ctx.getBean("userDao", UserDao.class);
        UserDao userDao2 = ctx.getBean("userDao", UserDao.class);
        System.out.println(userDao2 == userDao ? "is same object" : "is not same object");
    }
}

虽然可以使用字符串指定作用域，但更好的方式是是用预定义常量：

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

除此之外还有其他常量可选，具体可以查看@Scope的源码注释。

4.生命周期

注解模式下同样可以使用上篇文章提到的接口定义 Spring Bean 的生命周期回调：

@Repository("userDao")
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public class UserDaoImpl implements UserDao, InitializingBean, DisposableBean {
	// ...
    @Override
    public void destroy() throws Exception {
        System.out.println("before UserDaoImpl instance destroy.");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("after UserDaoImpl instance init.");
    }
}

但更推荐的方式是使用注解：

@Repository("userDao")
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public class UserDaoImpl implements UserDao {
	// ...
    @PreDestroy
    public void destroy() {
        System.out.println("before UserDaoImpl instance destroy.");
    }

    @PostConstruct
    public void afterPropertiesSet() {
        System.out.println("after UserDaoImpl instance init.");
    }
}

需要注意的是，@PreDestroy和@PostConstruct注解并不属于 spring-context 依赖，其属于 javax.annotation-api 依赖。所以需要添加：

<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.2</version>
</dependency>

5.自动装配

5.1.属性

可以使用@Autowired注解实现对属性依赖的自动装配：

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
	// ...
}

Spring 会寻找类型匹配的 Bean 并使用反射的方式完成依赖注入，所以这里并不需要添加 Set 方法。

5.2.构造器

用@Autowired标记构造器同样可以实现自动装配：

@Service
public class UserServiceImpl implements UserService {
    private UserDao userDao;

    @Autowired
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
	// ...
}

5.3.Setter

也可以用@Autowired标记 Setter 实现自动装配：

@Service
public class UserServiceImpl implements UserService {
    @Setter(onMethod = @__(@Autowired))
    private UserDao userDao;
	// ...
}

这里使用的是 Lombok 生成 Setter 的写法，具体可以参考这篇文章。

5.4.@Qualifier

如果有多个类型匹配，我们需要用@Qualifier注解指定其中的一个 Bean 用于注入：

@Repository
public class UserDaoImpl implements UserDao {
	// ...
}

@Repository
public class UserDaoImpl2 implements UserDao {
	// ...
}

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    @Qualifier("userDaoImpl")
    private UserDao userDao;
    // ...
}

5.5.@Value

对于简单类型（基础类型和 String ），可以使用@Value实现自动装配：

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    @Qualifier("userDaoImpl")
    private UserDao userDao;
    @Value("icexmoon")
    private String name;

    @Override
    public void save() {
        System.out.println("UserServiceImpl.save() is called.");
        System.out.println("name:" + name);
        userDao.save();
    }
}

在这个示例中这样做多少显得有点多余，完全可以：

@Service
public class UserServiceImpl implements UserService {
    // ...
    private String name = "icexmoon";
}

但使用@Value的好处是可以从 properties 文件加载属性。

比如 Resource 目录下有一个 jdbc.properties 文件：

name=icexmoon

在配置类上使用@PropertySource注解加载这个 properties 文件：

@Configuration
@ComponentScan(basePackages = "cn.icexmoon.springdemo")
@PropertySource("classpath:jdbc.properties")
public class WebConfig {
}

使用@Value完成注入：

@Service
public class UserServiceImpl implements UserService {
	// ...
    @Value("${name}")
    private String name;
	// ...
}

6.管理第三方 Bean

添加第三方依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

在配置类中添加一个 Bean 方法：

@Configuration
@ComponentScan(basePackages = "cn.icexmoon.springdemo")
@PropertySource("classpath:jdbc.properties")
public class WebConfig {
    @Bean
    public DataSource dataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("mysql");
        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        druidDataSource.setUrl("jdbc://localhost:3306/test");
        return druidDataSource;
    }
}

通过 IoC 容器获取 Bean：

public class Application {
    public static void main(String[] args) {
        // ...
        DataSource dataSource = ctx.getBean(DataSource.class);
        System.out.println(dataSource);
    }
}

可以按照 Bean 类型对配置类进行拆分，比如将数据库的相关类放在JDBCConfig中：

@Configuration
public class JDBCConfig {
    @Bean
    public DataSource dataSource() {
        // ...
    }
}

因为@Configuration同样是@Component的一个衍生注解，所以在我们已经制定扫描顶级包的情况下，这个配置类同样是有效的。

也可以不使用扫描，在作为入口的配置类上通过@Import注解导入其它配置类：

public class JDBCConfig {
    @Bean
    public DataSource dataSource() {
        // ...
    }
}

@Configuration
@ComponentScan(basePackages = "cn.icexmoon.springdemo")
@PropertySource("classpath:jdbc.properties")
@Import(JDBCConfig.class)
public class WebConfig {

}

public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(WebConfig.class);
        // ...
    }
}

同样的，数据库连接信息应当从 properties 文件中读取，比如：

jdbc.user=root
jdbc.password=mysql
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc://localhost:3306/test

利用@Value自动装配数据库连接信息到属性，并在 Bean 方法中使用：

public class JDBCConfig {
    @Value("${jdbc.user}")
    private String user;
    @Value("${jdbc.password}")
    private String password;
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;

    @Bean
    public DataSource dataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUsername(user);
        druidDataSource.setPassword(password);
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        return druidDataSource;
    }
}

The End，谢谢阅读。

7.参考资料

魔芋红茶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
@Setter(onMethod = @__(@Inject)) 是什么意思
hongchangfirst
01-11 6204
这是Lombok的实验性质的语法，以后可能会deprecate掉。 @Setter都知道就是lombok帮你生成setter方法，那里面的onMethod是什么意思呢？就是让lombok在生成setter方法时，在这个setter方法上进行annotate，annotation就是@Inject @Setter(onMethod = @__(@Inject)) private String...
SpringCloud学习笔记
12-08
【SpringBoot核心特性】 SpringBoot是Spring框架的一个扩展，它旨在简化Spring应用程序的开发过程，...这份学习笔记涵盖了SpringBoot的基础特性和SpringCloud的负载均衡实践，对于深入理解这两个技术有极大的帮助。
Spring Boot 自动注入方式
最新发布
m0_72465310的博客
06-04 2191
总结: final 修饰符的字段使用 lombok 可以帮助生成构造器，spring 会为构造器所有的属性注入。使用 [ Lombok ] 的 [ @RequiredArgsConstructor ] 进行构造器注入。总结： [ Lombok ] 的 [ @Setter ] 注解可以指定在生成时加入指定注解。方式三、 使用 [ Lombok ] 的 [ @Setter ] 注解按字段名字注入。方式二、使用 [ Lombok ] 的 [ @Setter ] 进行注入。[SpringBoot] 运行结果。
@Autowired三种注入方式的区别以及@Inject注解的基本使用
m0_63323097的博客
05-02 4001
对于必需的依赖项，建议使用构造器注入，且一般配合final使用，这样保证依赖注入后不可变。使用构造函数注入可以非常明确地表达一个类的依赖关系，使得代码依赖性更加明显和易于维护。此外，由于所有必须的依赖项都必须在构造函数中声明，因此这种方式可以提高代码的可测试性。对于可选的依赖，推荐setter注入。setter注入可以避免直接访问类的属性，从而实现更好的封装性。属性注入能够减少类的代码，使其更加简洁易懂，但属性注入有可能注入为null，这些错误只有在使用时才会爆出来，另外属性注入也存在一些隐患。
SpringBoot整合RocketMQ，老鸟们都是这么玩的！
飘渺Jam的博客
04-10 5358
今天我们来讨论如何在项目开发中优雅地使用RocketMQ。本文分为三部分，第一部分实现SpringBoot与RocketMQ的整合，第二部分解决在使用RocketMQ过程中可能遇到的一些问题并解决他们，第三部分介绍如何封装RocketMQ以便更好地使用。1. SpringBoot整合RocketMQ在SpringBoot中集成RocketMQ，只需要简单四步：引入相关依赖<dependenc...
设计模式实战 - 工厂类获取数据同步器 OpenDataSynchronizerFactory
你今天真好看呀
10-16 371
*** 用于* {@link OpenDataSynchronizer} 标注支持的同步类型* {@link DeviceConnector} 标注支持的设备连接器/*** @return 支持的同步数据类型};/*** @return 支持的设备类型};}
Spring学习笔记-cqupt
03-19
在本篇 Spring 学习笔记中，我们将探讨 Spring 的入门、优点、组成以及重要的IOC理论。 1. **Spring 简介** Spring 是一个开源的、免费的 Java 框架，它的目标是减少企业级开发的复杂性。它集成了许多现有的技术，...
Spring3学习笔记（一）简单概念及配置
12-20
**Spring3学习笔记（一）：简单概念及配置** 在软件开发领域，Spring框架是Java平台上最流行的应用框架之一，特别是在企业级应用开发中。Spring3是Spring框架的一个重要版本，它提供了许多改进和新特性，使得开发...
spring学习笔记掘金1
08-08
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> ``` 在运行时，Spring容器会解析XML文件，通过反射创建并初始化Bean，...
spring-framework:spring-framework原始阅读笔记-spring源码阅读
03-24
本文将基于“spring-framework原始阅读笔记”展开，深入探讨Spring的核心组件，包括容器实现、属性名解析、AOP（面向切面编程）以及SpringMVC的细节。 首先，让我们从Spring的核心——容器开始。Spring容器是整个...
SpringSecurity入门和项目中使用
weixin_43604021的博客
09-20 292
Spring Security
【Spring】三大依赖注入(@Autowired，Setter，构造方法)
qq_63218110的博客
04-22 8714
本篇文章注意介绍Spring中的三大注入，属性注入（@Autowired），Setter注入，构造方法注入的优缺点分析，其中还涉及了关于属性注入可能涉及违背单一涉及原则的实例，存在循环依赖的可能，及解决方案，还对JDK中的@Resourece注解与其中的@Autowired进行了比较。
@Autowired注入、构造器注入、setter注入的使用方式？区别？
guoqiaosen的博客
12-23 1万+
文章目录三种注入方式的使用1、@Autowired注入（不推荐）2.1、构造器注入（推荐）2.2、构造器注入-lombok升级版（推荐）3、setter注入循环依赖问题如何解决？ 三种注入方式的使用 1、@Autowired注入（不推荐） spring官方不推荐使用这种方式，同时idea会给我们发出警告：Field injection is not recommended @RestController @RequestMapping("/test") public class TestController
SpringBoot中如何实现限流，这种方式才叫优雅。
王不困的博客
03-21 691
前面两篇文章我们介绍了如何在SpringBoot中使用Guava和Redis实现接口限流的文章。具体包括1.2.现在，一个问题摆在我们面前：如何将这两种限流机制整合到同一个组件中，以便用户随时切换呢？显然，我们需要定义一个通用的限流组件，将其引入到业务中，并支持通过配置文件自由切换不同的限流机制。举例而言，当使用时，启用Redis分布式限流组件，当使用时，启用Guava限流组件。这种自由切换机制能够为用户提供更大的灵活性和可维护性。接下来，让我们开始动手实现吧！
lombok java: 找不到符号
asp.net爱好
07-11 438
lombok java: 找不到符号
SpringBoot中如何实现限流，这种方式才叫优雅！
m0_73311735的博客
03-21 230
很早以前，我曾写过两篇介绍如何在SpringBoot中使用Guava和Redis实现接口限流的文章。现在，一个问题摆在我们面前：如何将这两种限流机制整合到同一个组件中，以便用户随时切换呢？显然，我们需要定义一个通用的限流组件，将其引入到业务中，并支持通过配置文件自由切换不同的限流机制。举例而言，当使用时，启用Redis分布式限流组件，当使用时，启用Guava限流组件。这种自由切换机制能够为用户提供更大的灵活性和可维护性。接下来，让我们开始动手实现吧！
SpringBoot - 利用@DependsOn注解自定义Bean的加载顺序在Flayway之后
你今天真好看呀
10-13 959
可以看到 AkSkCacheUtils 这个 Bean 实现了 InitializingBean 接口，在项目启动的时候会执行 afterPropertiesSet() 方法实现自定义初始化逻辑，在该方法中需要访问数据表，但是表中的数据需要 flyway 去初始化 sql 脚本，如果不让AkSkCacheUtils 这个bean的加载控制顺序在 flyway 执行后，会出现各种报错。这个 bean 负责的。flyway的加载是由。
@Autowired详解
一个摩羯座的程序猿
12-03 1229
首先要知道另一个东西，default-autowire，它是在xml文件中进行配置的，可以设置为byName、byType、constructor和autodetect；比如byName，不用显式的在bean中写出依赖的对象，它会自动的匹配其它bean中id名与本bean的set**相同的，并自动装载。 @Autowired是用在JavaBean中的注解，通过byType形式，用来给指定的字段或方法注入所需的外部资源。 两者的功能是一样的，就是能减少或者消除属性或构造器参数的设置，只是配置地方不一样而已
Spring Boot 使用 RequiredArgsConstructor 参数 onConstructor 报错 找不到符号onConstructor_ __解决方法
热门推荐
。。。。
03-02 1万+
在使用 注解@RequiredArgsConstructor 时，带参有两种写法： @RequiredArgsConstructor //第一种 @RequiredArgsConstructor(onConstructor = @__(@Autowired)) //第二种 @RequiredArgsConstructor(onConstructor_ = {@Autowired}) 这样就会自动注入了。但是有时候设置不对 就会出现这样的错误。 错误1:使用 @RequiredArgsConstruct

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值