Spring笔记（6）：基于注解的配置

已于 2023-03-06 07:54:48 修改
阅读量401 收藏
点赞数
分类专栏： Java 文章标签： spring java mybatis
于 2023-03-06 07:17:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zain_horse/article/details/129353867
版权

为什么要使用直接配置？
当然是便捷性，维护性强呀~

如果想要使用注解，在XML文件中需要什么配置？

##注解配置载入
<context:annotation-config/>

四个重要的注解

  • @Required： 应用于set()方法
  • @Autowired： 应用于set()方法，构造方法，属性
  • @Qualifier： 指定确切的bean
  • JSR-250 Annotations： 支持 JSR-250 的基础的注解，其中包括了 @Resource，@PostConstruct 和 @PreDestroy 注解。

1、@Required注解

Product.java

public class Product {
    private String pid;
    private String pname;

    public Product() {
    }

    public Product(String pid, String pname) {
        this.pid = pid;
        this.pname = pname;
    }

    public String getPid() {
        return pid;
    }

    @Required
    public void setPid(String pid) {
        this.pid = pid;
    }

    public String getPname() {
        return pname;
    }

    @Required
    public void setPname(String pname) {
        this.pname = pname;
    }

    @Override
    public String toString() {
        return "Product{" +
                "pid='" + pid + '\'' +
                ", pname='" + pname + '\'' +
                '}';
    }
}

Beans.xml

        <context:annotation-config/>
        <bean id="product" class="org.example.POJO.Product">
            <property name="pid" value="p1233323"/>
            <property name="pname" value="经典牛奶"/>
        </bean>

输出结果

Product{pid='p1233323', pname='经典牛奶'}

你做了以上操作，你会发现，有没有@Required都不影响你的程序运行。
为什么会出现这样的情况呢？
@Required 主要是用来标注该set()方法必须使用XML文件中显式注入，不然会报错。
它就是这个作用，但是编辑器中也会自动识别XML文件中显式注入不完整，而产生错误高亮。

2、@Autowired注解

@Autowired就是自动装配，我们在前面已经讲了自动装配适用的场景就是引用了自定义类的地方，所以该注解也同样如此，并且指明了装配该区域，使得更加效率。

@Autowired用法

例如
在字段上

    @Autowired
    private Product product;

在set方法上

    @Autowired
    public void setProduct(Product product) {
        this.product = product;
    }

在构造方法上

    @Autowired
    public Sales(String sid, int price, Product product) {
        this.sid = sid;
        this.price = price;
        this.product = product;
    }

构造方法一定要在XML文件中，一定要配置好<constructor-arg />，否则会报异常。

所以我们可以意识到，Collection<Product>也同样适配@Autowired

3、@Qualifiler注解

首先理解Qualifier 的意思是 限定。
所以它的作用是限定一个bean类型进行装配

@Qualifiler通常会与@Autowired搭配使用，来限定采用哪一种同类型的bean

Sales.java

public class Sales {
    private String sid;
    private int price;
    @Autowired
    @Qualifier("product2")
    private Product product;

    public Sales(String sid, int price, Product product) {
        this.sid = sid;
        this.price = price;
        this.product = product;
    }

    public Sales() {
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public Product getProduct() {
        return product;
    }

    @Autowired
    @Qualifier("product2")
    public void setProduct(Product product) {
        this.product = product;
    }

    @Override
    public String toString() {
        return "Sales{" +
                "sid='" + sid + '\'' +
                ", price=" + price +
                ", product=" + product +
                '}';
    }
}

Beans.xml

        <context:annotation-config/>
        <bean id="sales" class="org.example.POJO.Sales">
            <property name="price" value="251"/>

            <property name="sid" value="sales100000"/>
        </bean>
        <bean id="product1" class="org.example.POJO.Product">
            <property name="pid" value="p1"/>
            <property name="pname" value="经典牛奶"/>
        </bean>
        <bean id="product2" class="org.example.POJO.Product">
            <property name="pid" value="p2"/>
            <property name="pname" value="奥利奥"/>
        </bean>

输出结果

Sales{sid='sales100000', price=251, product=Product{pid='p2', pname='奥利奥'}}

4、JSR-250注释

  • @PostConstruct： 替代XML中配置init-method
  • @PreDestroy 替代XML中配置destory-method
  • @Resource 指明使用哪一个bean，如果没有指定name，则默认为字段名或setter方法。
public class Sales{
	@Resource(name="price")
	private int price;
	
	@Resource(name="product")
	private Product product;

	@Resource(name="product")
	public void setProduct(Product product){
		this.product = product;
	}
}

Sales.java

public class Sales implements InitializingBean, DisposableBean {
    private String sid;
    private int price;
    @Autowired
    @Qualifier("product2")
    private Product product;

    public Sales(String sid, int price, Product product) {
        this.sid = sid;
        this.price = price;
        this.product = product;
    }

    public Sales() {
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public Product getProduct() {
        return product;
    }

    @Autowired
    @Qualifier("product2")
    public void setProduct(Product product) {
        this.product = product;
    }

    @Override
    public String toString() {
        return "Sales{" +
                "sid='" + sid + '\'' +
                ", price=" + price +
                ", product=" + product +
                '}';
    }

    @PreDestroy
    @Override
    public void destroy() throws Exception {
        System.out.println("Bean正在被销毁");
    }

    @PostConstruct
    public void init(){
        System.out.println("Bean正在被初始化");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Bean已经创建成功");
    }
}

输出结果

Bean正在被初始化
Bean已经创建成功
Sales{sid='sales100000', price=251, product=Product{pid='p2', pname='奥利奥'}}
Bean正在被销毁

5、基于Java的配置

重要的辅助注解

  • @Configuration： 标记为Bean定义来源
  • @Bean： 标记为注册成Spring应用程序上下文的Bean

User.java

public class User implements InitializingBean, DisposableBean {
    private String uid;
    private String uname;

    public User() {
    }

    public User(String uid, String uname) {
        this.uid = uid;
        this.uname = uname;
    }

    public String getUid() {
        return uid;
    }

    public void setUid(String uid) {
        this.uid = uid;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    @PostConstruct
    public void init(){
        System.out.println("Bean is going through init");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("Bean will destroy now");
    }

    @Override
    public String toString() {
        return "User{" +
                "uid='" + uid + '\'' +
                ", uname='" + uname + '\'' +
                '}';
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("UserBean has created。");
    }
}

UserConfig.java

@Configuration
public class UserConfig {
    @Bean
    public User getUser(){	//User作为class，getUser作为id
        return new User();
    }
}

等同于

<beans>
   <bean id="getUser" class="org.example.User" />
</beans>

Main.java

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(UserConfig.class);	//通过注解配置类加载到ApplicationContext容器
        User user = context.getBean(User.class);	//因为配置为Bean时通过User作为id，所以需要User.class来获取对象
        user.setUname("我是谁呢？");
        System.out.println(user);
    }
}

输出结果

Bean is going through init
UserBean has created。
User{uid='null', uname='我是谁呢？'}

注入Bean的依赖性

跟配置XML文件相同

@Configuration
public class AppConfig{
	@Bean
	public Foo foo(){
		return new Foo(bar());
	}
	@Bean
	public Bar bar(){
		return new Bar();
	}
}

等同于

<bean id="foo" class="Foo">
	<property id="bar" ref="bar" />
</bean>
<bean id="bar" class="Bar" />

@import注解
作用： 允许集合到一个配置类中

Man.java

public class Man {
    private int mid;

    public int getMid() {
        return mid;
    }

    public void setMid(int mid) {
        this.mid = mid;
    }
}

Female.java

public class Female {
    private int fid;

    public int getFid() {
        return fid;
    }

    public void setFid(int fid) {
        this.fid = fid;
    }
}

ManConfig.java

@Configuration
public class ManConfig {
    @Bean
    public Man man(){
        return new Man();
    }
}

FemaleConfig.java

@Configuration
@Import(ManConfig.class)
public class FemaleConfig {
    @Bean
    public Female female(){
        return new Female();
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
    	//只需要引入最终的配置类集合，就能够通过反射机制获取对象
        ApplicationContext context = new AnnotationConfigApplicationContext(UserConfig.class);
        context = new AnnotationConfigApplicationContext(FemaleConfig.class);	
        Female female = context.getBean(Female.class);
        female.setFid(12);
        Man man = context.getBean(Man.class);
        man.setMid(23);
        System.out.println(female.getFid());
        System.out.println(man.getMid());
    }
}

生命周期回调

@Bean(initMethod = "init",destroyMethod = "destroy")

指定Bean的范围

@Bean
@Scope("prototype")

6、事件处理

什么是事件？

举个例子： ApplicationContext启动会有start事件，ApplicationContext结束会有stop事件

如何处理事件？

  • 工具：ApplicationEvent类和ApplicationListener接口。
  • 应用：一个bean实现ApplicationListener，则ApplicationEvent发布到ApplicationContext上时，该bean也能获取到。

标准事件

  • ContextRefreshedEvent： 初始化或刷新时，该事件被发布，也可以通过ConfigurableApplicationContext.refresh()方法发生。
  • ContextStartedEvent： 当使用ConfigurableApplicationContext.start()启动ApplicationContext时，该事件被发布，进行调查数据库或重启任何应用程序。
  • ContextStoppedEvent： 当使用ConfigurableApplicationContext.stop()暂停ApplicationContext时，该事件被发布，进行清理工作。
  • ContextClosedEvent： 当使用 ConfigurableApplicationContext 接口中的 close() 方法关闭 ApplicationContext 时，该事件被发布。一个已关闭的上下文到达生命周期末端；它不能被刷新或重启。
  • RequestHandledEvent： 这是一个 web-specific 事件，告诉所有 bean HTTP 请求已经被服务。

注意： 由于 Spring 的事件处理是单线程的，所以如果一个事件被发布，直至并且除非所有的接收者得到的该消息，该进程被阻塞并且流程将不会继续。因此，如果事件处理被使用，在设计应用程序时应注意。

监听上下文事件
如何实现？ bean实现ApplicationListener

  • 步骤1： 创建监听事件配置文件 BStartEventHandler.java，BStopEventHandler.java
  • 步骤2： 注册监听Bean Beans.xml
  • 步骤3： 获取ConfigurableApplicationContext对象 Main.java

BStartEventHandler.java

public class BStartEventHandler implements ApplicationListener<ContextStartedEvent> {
    @Override
    public void onApplicationEvent(ContextStartedEvent event) {
        System.out.println("the ApplicationContext Container start");
    }
}

BStopEventHandler.java

public class BStopEventHandler implements ApplicationListener<ContextStoppedEvent> {
    @Override
    public void onApplicationEvent(ContextStoppedEvent event) {
        System.out.println("the ApplicationContext Container stop");
    }
}

Beans.xml

        <context:annotation-config/>
        <bean id="sales" class="org.example.POJO.Sales">
            <property name="price" value="251"/>
            <property name="sid" value="sales100000"/>
        </bean>
        <bean id="product1" class="org.example.POJO.Product">
            <property name="pid" value="p1"/>
            <property name="pname" value="经典牛奶"/>
        </bean>
        <bean id="product2" class="org.example.POJO.Product">
            <property name="pid" value="p2"/>
            <property name="pname" value="奥利奥"/>
        </bean>

        <bean id="bStartEventHandler" class="org.example.POJO.BStartEventHandler" />
        <bean id="bStopEventHandler" class="org.example.POJO.BStopEventHandler" />

Main.java

public class Main {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        context.start();
        Sales sales = (Sales) context.getBean("sales");
        System.out.println(sales);
        context.stop();
    }
}

输出结果

Bean正在被初始化
Bean已经创建成功
the ApplicationContext Container start
Sales{sid='sales100000', price=251, product=Product{pid='p2', pname='奥利奥'}}
the ApplicationContext Container stop

7、自定义事件

如何定义事件？

  • 步骤1： 创建ApplicationEvent继承类
  • 步骤2： 创建ApplicationEventPublisherAware接口实现类
  • 步骤3： 创建监听类
  • 步骤4： 声明监听Bean
  • 步骤5： 使用发布类

CustomEvent.java

public class CustomEvent extends ApplicationEvent{ 
   public CustomEvent(Object source) {
      super(source);
   }
   public String toString(){
      return "My Custom Event";
   }
}

CustomEventPublisher.java

public class CustomEventPublisher 
   implements ApplicationEventPublisherAware {
   private ApplicationEventPublisher publisher;
   
   //获取发布器
   public void setApplicationEventPublisher(ApplicationEventPublisher publisher){
      this.publisher = publisher;
   }
   public void publish() {
      CustomEvent ce = new CustomEvent(this);	//获取事件
      publisher.publishEvent(ce);	//发布事件
   }
}

MainApp.java

public class MainApp {
   public static void main(String[] args) {
      ConfigurableApplicationContext context = 
      new ClassPathXmlApplicationContext("Beans.xml");    
      CustomEventPublisher cvp = 
      (CustomEventPublisher) context.getBean("customEventPublisher");
      cvp.publish();
   }
}

Beans.xml

   <bean id="customEventHandler" 
      class="com.tutorialspoint.CustomEventHandler"/>

   <bean id="customEventPublisher" 
      class="com.tutorialspoint.CustomEventPublisher"/>
Zain_horse
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring_Annoation:学习Spring注解的笔记
05-15
spring学习笔记 人家也想要小星星，mua~
spring注解笔记
10-20
spring注解笔记spring注解笔记spring注解笔记spring注解笔记
Spring中基于注解的配置详解
InterestAndFun的博客
04-20 1228
在现在的框架开发中，大多数用的都是注解开发技术。注解配置要实现的功能和XML实现的功能都是一样的，只是配置的形式不同。 注解的标签可以分为3类：创建对象、注入数据、其他配置。XML配置文件亦是如此。 看一个简单的例子：例子中的3个框就是分成了3类，这三类标签最后都可以用注解来代替。 现在开始详细介绍spring中的标签。 一、Spring中的标签汇总 用于创建对象： @Component、@Controller、@Service、@Repository 用于注入数据： @Value、@Resource、@
Spring框架相关XML配置注解约束汇总
多凡的博客
07-26 1008
1.以下示例显示了基于XML的配置元数据的基本结构： <?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:...
JSR-250 的 @Resource
最新发布
xiaotu的博客
03-13 303
则从 IoC 容器中查找 name 匹配的 Bean 进行装配，找不到则抛出异常。属性两者同时出现，或同时不出现，亦或者出现一个，就意味着不同的『匹配的 Bean 进行装配，找不到或者找到多个，都会抛出异常。为依据在 IoC 容器中查找，如果没有找到，再以。这种情况下，类型和名字不是『且』的关系，而是『注意，type 和 name 两个条件是『规范定义的注解，它们分别是。，则从 IoC 容器中查找。
JSR 250
MichaelJY1991的专栏
04-08 1672
JSR 250 简介 JSR 250，Java注解规范，定义了一系列基于Java EE和Java SE通用注解。它避免了不同框架或组件间重复（或冗余）的注解。JSR 250正式发布于2006年5月11日。随着申明式注解配置被越来越多地应用在Java框架（比如Spring），JSR 250可能在未来会持续增长，所以在使用诸如Spring之类的框架时，尽量使用JSR 250中定义的注解，避免和特定...
第四章：Spring基于注解配置
p812438109的专栏
05-24 196
一）Spring注解配置 在spring XML配置中，注解连线在默认情况下不打开，需要在配置中显示配置。 <context:annotation-config/> 二）Spring常用注解 1、@Component 作用： 把资源让spring来管理。相当于在xml中配置一个 bean。相当于：<bean id="" class=""> 属性： value：指定bean的 id。如果不指定value属性，默认bean的id是当前类的类名，首字母小写。 衍生.
Spring framework Day09:JSR250注入注解
zhiqiuqiu2的博客
10-12 201
JSR 250 是 Java Specification Request 的缩写，它定义了一组用于依赖注入和生命周期管理的注解。这些注解是在 Java EE 5 规范中引入的，用于简化和标准化开发企业级应用程序的依赖注入和生命周期管理。
Spring注解 - 52注解 - 原稿笔记
08-09
注解包含: 拦截器 , 过滤器 , 序列化 , @After , @AfterReturning , @AfterThrowing , @annotation , @Around , @Aspect , @Autowired , @Bean , @Before , @Component , @ComponentScan , @ComponentScans , @...
Spring注解驱动笔记.md
01-06
Spring注解描述，底层笔记
spring系列笔记之常用注解
08-26
主要给大家介绍了关于spring系列笔记之常用注解的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用spring具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Spring基于注释（Annotation）的配置.pdf
07-01
Spring基于注释（Annotation）的配置.pdfSpring基于注释（Annotation）的配置.pdfSpring基于注释（Annotation）的配置.pdfSpring基于注释（Annotation）的配置.pdfSpring基于注释（Annotation）的配置.pdfSpring基于注释（Annotation）的配置.pdfSpring基于注释（Annotation）的配置.pdfSpring基于注释（Annotation）的配置.pdfSpring基于注释（Annotation）的配置.pdfSpring基于注释（Annotation）的配置.pdfv
Spring核心——JSR250与资源控制
weixin_30666427的博客
02-16 786
JSR-175与元编程 要说明JSR-250先要解释清楚JSR-175，要解释清楚JSR就的先了解JCP是什么。网上资料很多，就不细说了，简单的说JCP(Java Community Process)是管理Java生态(包括J2SE、J2EE等等)发展的合作组织。JSR(Java Specification Request)就是组织内的成员针对Java的发展提出的一些需求，通过审核之后即...
注解@Resource（JSR250）和@Inject（JSR330）和@Autowired（Spring）的区别
weixin_38357164的博客
11-06 1121
@Resource 和@Inject是java规范的自动装配注解，功能等同于Spring 的@Autowired。 1：@Resource：默认按照组件名称进行装配，通过@Resource（name=“id”）指定注入的bean，不支持参数required=false，不支 持  @Primary注解。 2：@Autowired：默认按照组件类型进行装配，通过@Qualifier（“id”）指...
spring--基础--05--基于注解的配置
zhou920786312的博客
09-20 190
五 基于注解的配置 @Required:应用于bean属性的setter方法。 @Autowired:应用到bean属性的setter方法,非setter方法,构造函数和属性。 @Qualifier：指定确切的的bean, @Autowired和@Qualifier注解可以用来删除混乱。 JSR-250Annotations:支持JSR-250的基础的注解 @Resource @PostConstruct @PreDestroy <?xml version="1.0" encoding=
spring基于注解的配置小结
weixin_53099632的博客
07-13 120
spring基于注解配置小论
Spring 基于注解的配置
m0_51756019的博客
09-14 213
基于注解的配置 从 Spring 2.5 开始就可以使用注解来配置依赖注入。而不是采用 XML 来描述一个 bean 连线，你可以使用相关类，方法或字段声明的注解，将 bean 配置移动到组件类本身。 在 XML 注入之前进行注解注入，因此后者的配置将通过两种方式的属性连线被前者重写。 注解连线在默认情况下在 Spring 容器中不打开。因此，在可以使用基于注解的连线之前，我们将需要在我们的 Spring 配置文件中启用它。所以如果你想在 Spring 应用程序中使用的任何注解，可以考虑到下面的配置文件。
springJSR-250注解学习
lcl249847947的博客
10-19 757
spring注解学习 1. {CSDN:CODE:@RestController} 相当于{SCDN:CODE:@Controller}和{CSDN:CODE:@Requestbody} 连个一起使用，使用@RestController不需要返回具体的前端页面，可以返回字符串。 2.@SpringBootApplication 由于大量项目都会在主要的配置类上添加@
尚硅谷spring6笔记
08-05
尚硅谷Spring6笔记主要讲解了Spring框架中的AOP（面向切面编程）和Spring的事务管理。 AOP是Spring框架中的核心特性之一，它通过将通用的横切关注点与业务逻辑进行解耦，提供了一种更加灵活和模块化的编程方式。在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Zain_horse

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值