Spring 框架学习5 - Spring 中的常用注解

最新推荐文章于 2021-05-15 15:25:29 发布
最新推荐文章于 2021-05-15 15:25:29 发布
阅读量267 收藏 2
点赞数
分类专栏： spring 框架 文章标签： java Spring 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41302594/article/details/101023430
版权

文章目录

Spring 中的常用注解

1. 常用 IOC 注解的分类

首先，看一个 Spring 的配置文件：

<bean id="" class="" scope="" init-method="" destroy-method="">
	<property name="" value="" (ref="")></properties>
</bean>

与上面的标签相对应，IOC 注解按照功能分类可以分为一下几类：

  • 用于创建对象的
    • 它们的作用就和在 xml 配置文件中编写一个 bean 标签实现的功能是一样的
  • 用于注入数据的
    • 它们的作用就和在 xml 配置文件中的 bean 标签中的property、constructor-arg 标签的作用是一样的
  • 用于改变作用范围的
    • 它们的作用就和在 bean 标签中使用 scope 属性的功能是一样
  • 和声明周期相关
    • 它们的作用就和在 bean 标签中使用 init-method 和 destroy-method 是一样的。

2.用于创建的 Component 注解

2.1 Componet 注解的详解

Component：用于创建对象，它可以将创建被注解的类的对象，然后再将当前创建的对象存入到 Spring 容器中。

Component 有一个属性值：value。这个属性用来定义 bean 的 id。当然，当我们不写时，它的默认值是当前的类名，且开头为小写字母。

2.2 使用实例

  • 首先，需要在想要用来创建 bean 的类的类名前，加上 @Component 标签：

    package com.selflearning.spring.service.impl;

import com.selflearning.spring.dao.IAccountDao;
import com.selflearning.spring.dao.impl.AccountDaoImpl;
import com.selflearning.spring.service.IAccountService;
import org.springframework.stereotype.Component;

@Component(value = "accountService")
public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao = null;

    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

  • 但是这样还是不能用的，我们来看一下主函数的调用：

    import com.selflearning.spring.dao.IAccountDao;
import com.selflearning.spring.service.IAccountService;
import com.selflearning.spring.service.impl.AccountServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {

    /**
     * 获取 spring 的 ioc 核心容器，并根据 id 获取对象
     * @param args
     */
    public static void main(String[] args) {
        // 1. 获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 根据 id 获取 bean 对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        System.out.println(as);
    }

}

    主函数这里，由于使用 ApplicationContext 类创建的 bean，默认情况下是 singleton （单例的），所以，当读取了 bean.xml 文件时，就已经创建好了对象。读取 xml 时，我们发现，我们的 xml 文件里面是空的（因为使用注解不需要在 xml 文件配置 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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
    <!-- 告知 Spring 在创建容器时需要扫描的包，配置所需要的标签不是在beans
            的约束中，而是一个名为 context 明恒空间和约束中-->
</beans>

    主函数：

        public static void main(String[] args) {
        // 1. 获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 根据 id 获取 bean 对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        System.out.println(as);
    }

    运行，然后报错：

    Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'accountService' available
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBeanDefinition(DefaultListableBeanFactory.java:771)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getMergedLocalBeanDefinition(AbstractBeanFactory.java:1221)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:294)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:199)
	at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1105)
	at com.selflearning.spring.ui.Client.main(Client.java:23)

    NoSuchBeanDefinitionException 没有当前的 bean 的详细定义。

  • 这个时候，由于配置文件中，并没有配置 bean 的信息，所以，我们需要提醒 Spring 框架进入到源包中扫描注解，就需要对配置文件进行一定的修改：

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 告知 Spring 在创建容器时需要扫描的包，配置所需要的标签不是在beans
            的约束中，而是一个名为 context 明恒空间和约束中-->
    <context:component-scan base-package="com.selflearning"></context:component-scan>
</beans>

    这里，导入了 context 约束（记得要导入 spring-aop 的包），然后使用 context:component 标签，将源包作为 base-package 属性的属性，以提醒 Spring 框架去扫描源包内 Java 类的注解。

    再次运行：

    com.selflearning.spring.service.impl.AccountServiceImpl@6eceb130

    成功。

3. Controller、Service、Repository

Controller、Service、Repository 这三个注解，它们的作用和属性与 Component 是一模一样的。为什么一样呢？可能是这三个家伙都相当于继承了 Component 接口吧。

它们三个是 Spring 框架作为我们提供明确的三层使用的注解，使我们的三层对象更加清晰

所以，在以后的 web 项目中：

  • Controller：一般用于表现层
  • Service：一般用于业务层
  • Repository：一般用于持久层

3.1 一个小小的例子

之前模拟了一个 web 项目，现在可以拿过来用用。

  • 首先，在模拟的持久层的类名上，添加注解 Repository：

    package com.selflearning.spring.dao.impl;

import com.selflearning.spring.dao.IAccountDao;
import org.springframework.stereotype.Repository;

/**
 * 账户的持久层实现类
 */
@Repository(value="accountDao")
public class AccountDaoImpl implements IAccountDao {
    @Override
    public void saveAccount() {
        System.out.println("保存了账户");
    }
}

  • 然后，在模拟的业务层类上，加上注解 Service：

    package com.selflearning.spring.service.impl;

import com.selflearning.spring.dao.IAccountDao;
import com.selflearning.spring.service.IAccountService;
import org.springframework.stereotype.Service;

@Service(value = "accountService")
public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao = null;

    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

  • 在现实层进行调用：

    package com.selflearning.spring.ui;


import com.selflearning.spring.dao.IAccountDao;
import com.selflearning.spring.dao.impl.AccountDaoImpl;
import com.selflearning.spring.service.IAccountService;
import com.selflearning.spring.service.impl.AccountServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {

    /**
     * 获取 spring 的 ioc 核心容器，并根据 id 获取对象
     * @param args
     */
    public static void main(String[] args) {
        // 1. 获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 根据 id 获取 bean 对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        IAccountDao ad = (IAccountDao) ac.getBean("accountDao");
        System.out.println(as);
        System.out.println(ad);
    }
}

  • 最后是结果：

    com.selflearning.spring.service.impl.AccountServiceImpl@df27fae
com.selflearning.spring.dao.impl.AccountDaoImpl@24a35978

4. 自动按照类型注入

自动按照类型注入，使用的标签是 Autowired

当 ioc 容器中有唯一一个 bean 对象类型和要注入的数据类型匹配，就可以实现注入。

4.1 唯一对象类型匹配的注入

我们来看一下的例子：

这里有两个类，一个是持久层的实现类，一个是业务层的实现类：

持久层：

package com.selflearning.spring.dao.impl;

        import com.selflearning.spring.dao.IAccountDao;
        import org.springframework.stereotype.Repository;

/**
 * 账户的持久层实现类
 */
@Repository(value="accountDao")
public class AccountDaoImpl implements IAccountDao {
    @Override
    public void saveAccount() {
        System.out.println("保存了账户");
    }
}

业务层：

package com.selflearning.spring.service.impl;

import com.selflearning.spring.dao.IAccountDao;
import com.selflearning.spring.service.IAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service(value = "accountService")
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao = null;

    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

在业务层中，我们创建了一个 IAccountDao 类型的成员变量。而持久层的实现类也实现了这个接口，那么持久层的实现类 AccountDaoImpl 就是一个 IAccountDao 类型的对象。而且，在 ioc 容器中，也只有一个和 IAccountDao 类型相匹配的 bean 对象（AccountDaoImpl， 它被注解 Repository 注解着，会被 Spring 框架创建成为一个 bean 对象存放在 Spring 的 ioc 核心容器中）。所以，可以注入成功。

然后，创建一个表现层的类，用来进行测试：

package com.selflearning.spring.ui;


import com.selflearning.spring.dao.IAccountDao;
import com.selflearning.spring.dao.impl.AccountDaoImpl;
import com.selflearning.spring.service.IAccountService;
import com.selflearning.spring.service.impl.AccountServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {

    /**
     * 获取 spring 的 ioc 核心容器，并根据 id 获取对象
     * @param args
     */
    public static void main(String[] args) {
        // 1. 获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 根据 id 获取 bean 对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        System.out.println(as);
        as.saveAccount();
    }

}

结果：

com.selflearning.spring.service.impl.AccountServiceImpl@4ae82894
保存了账户

4.2 多个对象类型匹配的注入

但是，如果 ioc 容器中两个 IAccountDao 类型的 bean 对象呢？

我们在之前持久层的基础上，在多增加一个持久层实现类 AccountDaoImpl2， 并将之前的 AccountDaoImpl 改名为 AccountDaoImpl1：

package com.selflearning.spring.dao.impl;

        import com.selflearning.spring.dao.IAccountDao;
        import org.springframework.stereotype.Repository;

/**
 * 账户的持久层实现类
 */
@Repository(value="accountDao1")
public class AccountDaoImpl implements IAccountDao {
    @Override
    public void saveAccount() {
        System.out.println("保存了账户");
    }
}

package com.selflearning.spring.dao.impl;

import com.selflearning.spring.dao.IAccountDao;
import org.springframework.stereotype.Repository;

/**
 * 账户的持久层实现类
 */
@Repository(value="accountDao2")
public class AccountDaoImpl2 implements IAccountDao {
    @Override
    public void saveAccount() {
        System.out.println("保存了账户");
    }
}

我们保持显示层不变：

package com.selflearning.spring.ui;


import com.selflearning.spring.dao.IAccountDao;
import com.selflearning.spring.dao.impl.AccountDaoImpl;
import com.selflearning.spring.service.IAccountService;
import com.selflearning.spring.service.impl.AccountServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {

    /**
     * 获取 spring 的 ioc 核心容器，并根据 id 获取对象
     * @param args
     */
    public static void main(String[] args) {
        // 1. 获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 根据 id 获取 bean 对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        IAccountDao ad = (IAccountDao) ac.getBean("accountDao");
        System.out.println(as);
        System.out.println(ad);
        as.saveAccount();
    }

}

运行：

Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.selflearning.spring.dao.IAccountDao' available: expected single matching bean but found 2: accountDao1,accountDao2

由于 ioc 存在两个 bean 对象的类型和注入变量的类型相同，此时，Spring 就会报出 “没有指定类型对象可获得的错误，预期是单个 bean 对象匹配，可是找到两个”。

那么，此时应该怎么办呢？

由于 Spring 的 ioc 容器是以 Map 形式存放 bean 对象的:

在这里插入图片描述

这的 key 就是 xml 中 bean 标签的 id 属性值，或者是注解中的 value 属性的属性值。而 value 存放的就是 bean 对象。

如果这里，我们在业务层的实现类中将需要注入的变量的名称进行修改，改成 accountDao1, 此时，便能通过运行：

package com.selflearning.spring.service.impl;

import com.selflearning.spring.dao.IAccountDao;
import com.selflearning.spring.service.IAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service(value = "accountService")
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao1 = null;

    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

com.selflearning.spring.service.impl.AccountServiceImpl@44a3ec6b
保存了账户

这时因为当有两个或以上的 bean 对象的数据类型和需要注入的变量的数据类型相同时，Spring 便会通过上面表中的 key 的值来寻找相匹配的 bean 对象。

在这里插入图片描述

5. 用于注入数据的注解：

5.1 Qualifier

由于之前的 Autowired 自动注入对象类型时，我们只能通过让唯一 bean 数据类型和注入对象的数据类型相匹配或者修改需注入变量的变量名称的方法来注入实现对象。

这个时候，Spring 框架提供了一个名为 Qualifier 的注解。

这个注解可以在按照数据类型注入的基础上，再按照名称注入。它在给类成员注入时不能单独使用，但是在给方法注入时，可以单独使用。

Qualifier 有以下的属性：

value：用于指定注入 bean 的 id。

@Service(value = "accountService")
public class AccountServiceImpl implements IAccountService {
    @Autowired
    @Qualifier("accountDao1")
    private IAccountDao accountDao;

    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

5.2 Resource

作用：直接按照 bean 的 id 注入。它可以单独使用

属性：

  • name：用于指定 bean 的 id
@Service(value = "accountService")
public class AccountServiceImpl implements IAccountService {
    @Resource(name = "accountDao1")
    private IAccountDao accountDao;

    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

5.3 value

由于之前的三个注解只能注入其他 bean 类型的数据，而基本数据类型和 String 类型无法使用上述注解实现。

另外，集合类型的注入，只能通过 xml 注入。

value：

  • 作用：
    • 用于注入基本类型数据类型和 String 类型的数据
  • 属性：
    • 用于指定数据的值，它可以使用 Spring 中 spEL （也就是 Spring 中的 EL 表达式）
    • spEL：${表达式}

5.4 改变作用范围以及和生命周期相关的注解

5.4.1 Scope - 改变作用范围
  • 作用：
    • 用于指定 bean 的作用范围
  • 属性
    • value：指定范围的取值。常用取值：singleton、prototype
5.4.2 生命周期相关的注解

  • PreDestroy：

    • 作用：用于指定销毁方法

  • PostConstruct：

    • 作用：用于指定初始化方法

  • 一个小的例子：

    • 需要创建 bean 对象的类：

      @Service(value = "accountService")
@Scope("singleton")
public class AccountServiceImpl implements IAccountService {
//    @Autowired
//    @Qualifier("accountDao1")
    @Resource(name = "accountDao1")
    private IAccountDao accountDao;

    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }

    @PostConstruct
    public void init() {
        System.out.println("该 bean 初始化了");
    }

    @PreDestroy()
    public void destroy() {
        System.out.println("该 bean 被销毁");
    }
}

    • main方法：

          /**
     * 获取 spring 的 ioc 核心容器，并根据 id 获取对象
     * @param args
     */
    public static void main(String[] args) {
        // 1. 获取核心容器对象
//        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 根据 id 获取 bean 对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
//        IAccountDao ad = (IAccountDao) ac.getBean("accountDao");
        System.out.println(as);
//        System.out.println(ad);
        as.saveAccount();
    }

    • 执行结果：

      该 bean 初始化了
com.selflearning.spring.service.impl.AccountServiceImpl@7e9a5fbe
保存了账户
该 bean 被销毁
qq_41302594
关注
专栏目录
SpringMVC九大常用注解
11-03
SpringMVC九大常用注解 SpringMVC
Spring 或者 Springmvc中常用的5个注解 ，并解释含义
weixin_44050355的博客
10-27 3384
[1]. @Component 基本注解，标识一个受Spring管理的组件 [2]. **@Controller** 标识为一个表示层的组件（安不安全的问题） [3]. @Service 标识为一个业务层的组件 [4]. @Repository 标识为一个持久层的组件 [5]. @Autowired 自动装配 [6]. @Qualifier(“”) 具体指定要装配的组件的id值 [7]. @RequestMapping() ...
Spring5中常用注解介绍
Java全栈领域/离线地图/微服务
01-16 3899
将实体类存入Spring的IOC容器: @Component:用于创建对象的,作用于类。 value：指定 bean 的 id。如果不指定 value 属性，默认 bean 的 id 是当前类的类名。首字母小写。 @Controller： 一般用于表现层的注解。 @Service： 一般用于业务层的注解。 @Repository： 一般用于持久层的注解。 @Bean 作用：用于把当前方法的返回值作...
springmvc的五个常用注解？
link123link的博客
09-15 3万+
1、@Controller 在SpringMVC 中，控制器Controller 负责处理由DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model 返回给对应的View 进行展示。在SpringMVC 中提供了一个非常简便的定义Controller 的方法，你无需继承特定的类或实现特定的接口，只需使用@Controll...
小鸟初学Spring IOC
lenotang的专栏
07-02 2226
冬眠(Hibernate)过后，春天(Spring)又来了!呵呵，JAVA开源世界就是这样生机勃勃。Spring这个框架够经典，我们来一起学习下。下面我们以新颖的对话方式来讲述Spring。一直很喜欢听赵传的“我是一只小小鸟”，初学者傻傻地，羽翼未丰，就简称“小鸟”吧，技术强人呢，牛气冲天，当然就叫“大牛”了。一天，   小鸟在路上郁闷地唱着歌：“我是一只小小小小鸟，想学Spring却怎么也学
spring框架的学习--事务
11-08
本篇文章将重点围绕“Spring框架的学习--事务”这一主题，深入解析Spring中的事务管理机制。 首先，事务在数据库操作中扮演着至关重要的角色，确保数据的一致性和完整性。事务具有四大特性，通常被称作ACID（原子性...
spring5 框架 中文文档_spring-framework-5-doc-cn.zip
03-20
Spring框架是Java后端开发中的核心框架之一，它以其强大的依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）能力而著名。Spring5是该框架的一个重要版本，带来了许多新特性...
spring_tx.zip_dividezgx_spring-tx_spring框架学习
09-20
本文将深入探讨Spring框架中的事务管理，包括基本概念、配置方式以及如何在实际项目中进行事务控制。 首先，事务管理是数据库操作的核心部分，它确保了数据的一致性和完整性。在Spring框架中，事务管理分为编程式...
spring-ai-core 0.8.1
最新发布
05-21
在现代软件开发领域，Spring框架以其强大的功能和灵活性，已经成为Java开发中的首选框架之一。而Spring AI Core则是Spring生态系统中专门为人工智能（AI）和机器学习（ML）打造的一个模块，它的出现进一步拓宽了...
spring-demo10-注解-IOC.zip
08-08
在IT行业中，Spring框架是Java企业级应用开发的首选框架之一，因其强大的功能和灵活性而备受推崇。在Spring中，依赖注入（Dependency Injection，简称DI）是核心特性，而注解（Annotation）则是实现DI的一种现代化...
Spring框架学习笔记-<bean>之间的关系
编程使我快乐
11-18 184
不但可以通过< ref >引用另一个Bean，建立起Bean和Bean之间的依赖关系，相似的，< bean >元素标签之间也可以建立类似的关系，完成一些特殊的功能。 1.继承 OOP思想告诉我们，如果多个类拥有相同的方法和属性，则我们可以引入一个父类，在父类中定义这些共同的方法和属性，以消除重复的代码。相似的，如果多个< bean >存在相同的配置信息，Spri...
Spring常用注解
renxyz的专栏
09-15 1426
看到一篇讲解注解的文章，讲的太好了，文章转载地址 http://www.cnblogs.com/xdp-gacl/p/3495887.html 具体如下： 使用注解来构造IoC容器 用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册。 如：在base-package指明一个包 1 context:component-sca
Spring中的常用注解理解
AADDDD5的博客
04-08 2994
Spring中定义了一系列的注解，常用的注解如下所示： @Component:可以使用此注解描述Spring中的Bean，但它只是一个泛化的概念，仅仅表现一个组件（Bean），并且可以作用在任何层次。 @Repository: 用于将数据访问层( DAO层)的类标识为Spring中的Bean，其功能与@Component相同。 @Service: 通常作用在业务层( Service层)用于将业务层...
Spring入门
qq_35315363的博客
06-10 124
Spring优势（作用） （1）Spring是一站式框架，因为Spring框架的性质是属于容器性质，容器中装了什么对象就有什么功能，所以可以一站式。 （2）不仅不排斥其他框架、还能其他框架帮忙管理对象。 （3）AOP支持 （4）基于IOC思想 （5）Spring jdbc （6）aop 事务 （7）Junit测试支持。 Spring框架搭建（入门） 1、创...
SpringBoot 后端接收JSON格式的参数
热门推荐
IT技术总结
08-14 4万+
接收简单的JSON字符串： JSON数据格式： {"accNbr":"15915849463" , "state":"拆机"} 定义实体类： controller接收参数： 接收复杂的JSON数据组： json数据格式： { "data": [ {"accNbr":"15915849463" , "state":"拆机"}, {"accNbr"...
Spring中的18个注解，你会几个？
Java之间
05-29 2万+
点击上方“Java之间”，选择“置顶或者星标”你关注的就是我关心的！作者：Java的小本家 @Controller标识一个该类是Spring MVC controller...
Spring框架相关知识
weixin_41804367的博客
05-26 135
程序的耦合与解耦 * 程序的耦合 * 耦合：程序间的依赖关系 * 包括： * 类之间的依赖 * 方法间的依赖 * 解耦： * 降低程序间的依赖关系 * 实际开发中： * 应该做到：编译期不依赖，运行时才依赖。 * 解耦的思路： *...
Spring5注解
weixin_43481118的博客
05-15 383
IOC：控制反转，把创建对象过程交给 Spring 进行 1、什么是注解 （1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值..) （2）使用注解，注解作用在类上面，方法上面，属性上面 （3）使用注解目的：简化 xml 配置 2、Spring 针对 Bean 管理中创建对象提供注解 （1）@Component （2）@Service （3）@Controller （4）@Repository * 上面四个注解功能是一样的，都可以用来创建 bean 实例 3、基于注解方式
Spring框架开发者指南-夏昕
"Spring开发指南-夏昕，V0.6预览版，作者夏昕，专注于Spring框架的开发者指南，包含对Spring框架的详细解释和使用指导，尤其在0.6版本中增加了‘持久层’的内容。文档鼓励开源文档分享精神，并设有严格的版权说明，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值