更简单的读取或者存储对象（类注解、方法注解、依赖注入）

已于 2023-07-21 16:00:27 修改
阅读量42 收藏
点赞数
分类专栏： Spring 文章标签： spring
于 2023-07-21 15:25:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52136076/article/details/131798012
版权
本文介绍了如何在Spring框架中创建项目，配置扫描路径以管理Bean。通过类注解如@Controller和@Service，以及方法注解@Bean来存储Bean对象。同时详细讲解了依赖注入的三种方式：属性注入、构造器注入和Setter注入，以及它们各自的优缺点。文章还涵盖了类注解的命名规则和使用注意事项。
摘要由CSDN通过智能技术生成

目录

一、创建项目并且配置扫描路径

1.创建maven项目并且添加依赖

2.创建com.java.demo包并且添加Bean对象User

 3.配置扫描路径

二、更加简单的存储Bean对象

🍅使用类注解存储Bean对象

🍅使用方法注解存储bean对象（@Bean）

三、更加简单的读取Bean对象（依赖注入）

1.属性注入

2. Setter注入

3. 构造方法注入

四、总结（注意事项）

1. 使用类注解的注意事项

 🍅 通过类注解（5大类）实现Bean对象的存储

🍅 关于类注解默认命名方式 

2. 使用方法注解的注意事项

 🍅使用方法注解时要配合五大类注解才成功使用

🍅使用方法注解的命名规则

🍅重命名bean方式

🍅 多个Bean使用相同名称

3.Spring 依赖注入各有什么优缺点？

一、创建项目并且配置扫描路径

（一定要做的步骤）

1.创建maven项目并且添加依赖

在pom.xml中添加以下依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
    </dependencies>

2.创建com.java.demo包并且添加Bean对象User

 3.配置扫描路径

<?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:content="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--    配置Bean的扫描根路径-->
<!--    只有当前目录下的类才会扫描是否添加了注解,如果添加了注解,
就将这些加了注解的类存放到IoC容器种-->
    <content:component-scan base-package="com.java.demo">
    </content:component-scan>
</beans>

二、更加简单的存储Bean对象

🍅使用类注解存储Bean对象

对象必须放在被扫描到的目录里面。

给前面的User类加上注解：（只写了使用@Controller注解）

@Controller()
public class User {
    public  void sayHi(){
        System.out.println("hello");
    }
}

读取：

public class App {
    public static void main(String[] args) {
        //1.得到容器对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        //2.得到Bean对象
        User user = context.getBean("user",User.class);
        
        //3.使用Bean对象
        user.sayHi();
        
    }
}

🍅使用方法注解存储bean对象（@Bean）

类注解时添加到某个类上面的，而方法注解时放到某个方法上面。

首先创建一个实体类ArticleInfo(这个看看就行，不了解没事)

package com.java.demo.model;

import java.time.LocalDateTime;

public class ArticleInfo {
    private int aid;
    private String title;
    private String content;
    private LocalDateTime createTime;


    @Override
    public String toString() {
        return "ArticleInfo{" +
                "aid=" + aid +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                ", createTime=" + createTime +
                '}';
    }

    public int getAid() {
        return aid;
    }

    public void setAid(int aid) {
        this.aid = aid;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public LocalDateTime getCreateTime() {
        return createTime;
    }

    public void setCreateTime(LocalDateTime createTime) {
        this.createTime = createTime;
    }
}

然后使用方法中注解将当前方法返回的对象存储到IoC中：

package com.java.demo;
@Component
public class Articles {
    @Bean  //将当前方法返回的对象存储到IoC
    public ArticleInfo articleInfo(){
        ArticleInfo articleInfo = new ArticleInfo();
        articleInfo.setAid(1);
        articleInfo.setTitle("hellp");
        articleInfo.setContent("helloword");
        articleInfo.setCreateTime(LocalDateTime.now());
        return articleInfo;
    }
}

 读取存储的对象：

public class App {
    public static void main(String[] args) {
        //1.得到容器对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        //2.得到Bean对象
        //User user = context.getBean("user",User.class);
        ArticleInfo articleInfo = context.getBean("articleInfo",ArticleInfo.class);
        //3.使用Bean对象
        //user.sayHi();
        System.out.println(articleInfo.toString());

    }
}

三、更加简单的读取Bean对象（依赖注入）

获取Bean对象也叫做对象装配，把对象取出放到某个类中，也叫做对象注入。

对象注入一共有3种实现方式：属性注入、构造方法注入、Setter注入。

1.属性注入

首先创建一个UserRepository类

@Repository
public class UserRepository {
    public int add(){
        System.out.println("Do UserRepository add mathod");
        return 1;
    }
}

@Autowired属性注入 /依赖注入流程：

首先根据getType（从容器中）获取对象，

如果只获取了一个对象，那么直接将此对象直接注入到当前属性上；

如果获取到多个对象，才会使用getName根据名称进行匹配。

🍅 如果只获取了一个对象，下面的名称（userRepository）取什么都可以，这个名称就是一个辅助项；

@Service
public class UserService {
    //1.属性注入
    @Autowired  //从spring当中取到UserRepository并把它设置给当前的变量
    private UserRepository userRepository;//名称可以随意取，这里的名称就不会被约束了
    public int add(){
        System.out.println("Do UserService add method");
        return userRepository.add();
    }
}

🍅 如果获取到多个对象，才会使用getName根据名称进行匹配。

创建一个实体类User（不懂不用管，只是为了供后面的示例代码使用）

public class User {
    private String name;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

使用方法注解，将对象存储到容器中：

@Component
public class Users {
    @Bean("user1")
    public User user1() {
        User user = new User();
        user.setName("张三");
        return user;
    }
    @Bean("user2")
    public User user2(){
       User user = new User();
       user.setName("李四");
       return user;
    }
}

 使用属性注入取出对象：

@Service
public class UserService2 {
    //属性注入
    @Autowired
    @Qualifier("user1")  //指定取出的是user1
    private User user;
    public void sayHi(){
        System.out.println(user.toString());
    }
}

创建测试类：

class UserService2Test {

    @Test
    void add() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        UserService2 userService2 = context.getBean("userService2",UserService2.class);
        userService2.sayHi();
    }
}

2. Setter注入

@Service
public class UserService3 {
    private UserRepository userRepository;

    @Autowired //不能省略
    //使用setter的方式将对象注入
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void sayHi(){
        System.out.println("Do UserService3 sayHi");
        userRepository.add();
    }
}

3. 构造方法注入

public class UserService4 {
    private UserRepository userRepository;

    @Autowired
    public UserService4(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void sayHi(){
        System.out.println("hello ,UserService4");
        userRepository.add();
    }
}

关于三种依赖注入方式的优缺点，参考博客： 

Spring的一些基本概念_‍️藿香正气水的博客-CSDN博客

四、总结（注意事项）

1. 使用类注解的注意事项

 🍅 通过类注解（5大类）实现Bean对象的存储

 @Controller【控制器】：校验参数的合法性（安检系统）

@Service【服务】业务组装（客服中心）

 @Repository【数据持久层】业的业务处理（实际办理业务）

@Component【组件】工具类，实现业务中通用的功能（基础工具）

@Configuration【配置】配置层（针对当前做出一些设置）

阿里巴巴java开发手册工程结构：

Web层就相当于Controller控制层。

🍅 关于类注解默认命名方式 

以下时user就是一种注解命名“

 JDK中的命名方式其实并不全是上面这样的，主要的命名方式如下：

       🎊1. 当类名的首字母大写，第二个字母小写时，比如User，UserService等这种形式的类名，那么类注解就会默认使用首字母小写的方式命名，比如类名时UserService，那么类注解命名就是userService；

        🎊2.当类名的首字母大写，比如UConfig，UService等这种格式的类名，类注解就会默认使用原类名，也就是比如类名时UConfig，那么类注解命名也是UConfig。

2. 使用方法注解的注意事项

 🍅使用方法注解时要配合五大类注解才成功使用

🍅使用方法注解的命名规则

和类注解不同，使用方法注解时，默认情况下，获取类的命名必须和方法名对应一致。也就是上图中的地方需要一一对应。

🍅重命名bean方式

@Bean支持指定多个名称

方式1：@bean("a"),也可以使用多个名称来设置一个对象@bean({"a",""b})

方式2：@bean(name = "a") ，也可以使用多个名称来设置一个对象@bean(name={"a","b"})

方式3：@bean(value = "a" )，也可以使用多个名称来设置一个对象@bean(value={"a","b"})

当用了方法注解重命名以后，再次使用前面的默认使用方法名获取bean对象的方式就不能使用了。

🍅 多个Bean使用相同名称

如果多个Bean使用多个名称，那么程序执行时不会报错，但是第一个Bean之后的队形不会被存放到容器中，也就是只有在第一次创建Bean的时候会将对称和Bean关联起来，后续再有相同名称的Bean存储的时候，容器会自动忽略。

3.Spring 依赖注入各有什么优缺点？

🍅属性注入

优点：使用简单

缺点：

  • 无法注入finali修饰的变量

        首先final的特征（两种）：被修饰的变量需要赋值；在构造方法里面需要进行赋值。

  • 通用性问题：只适用于IoC容器。

  • 设计原则问题：更容易违背单一设计问题，因为使用起来比较简单。

🍅Setter注入

优点：更符合单一设计原则。因为Setter只有Set一个属性。

缺点：

  • 无法注入一个final修饰的变量

  • setter注入的对象是可以被需改的

🍅 构造方法注入

优点：

  • 可以注入一个final修饰的变量

  • 注入的对象不会被改变，因为构造方法只会被加载一次

  • 构造方法注入可以保证被注入的对象完全初始化

  • 构造方法注入通用性更好

缺点：

  • 写法比属性注入复杂

  • 无法解决循环依赖的问题

‍️小艺的学习旅途
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值