Spring IOC

最新推荐文章于 2024-07-20 20:04:43 发布
最新推荐文章于 2024-07-20 20:04:43 发布
阅读量83 收藏
点赞数 1
分类专栏： java 文章标签： spring maven java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61211769/article/details/120173118
版权

1、Spring 框架

1.1、环境搭建

1.1.1、创建 Maven 的 jar 项目

1.1.2、引入依赖

<!-- 添加 Spring 框架的核心依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.4.RELEASE</version>
</dependency>

1.1.3、创建 bean 对象

public class UserService {
    public void test01(){
        System.out.println("UserService test01.....");
    }
}
public class AccountService {
    public void test01(){
        System.out.println("AccountService test01.....");
    }
}

1.1.4、添加 Spring01 配置文件

<?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
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
      id：bean 对象的名称，默认是对象名称的首字母小写
      class：bean 对象的类路径
      scope：作用域
        singleton：单例的 默认值
        prototype：原型的、非单例
      -->
    <bean id="userService" class="com.yjxxt.service.UserService" scope="prototype"></bean>
    <bean id="accountService" class="com.yjxxt.service.AccountService"></bean>

</beans>

1.1.5、测试

public class TestSpring {

    @Test
    public void test01(){
        
        // 获取配置文件，可读多个
        ApplicationContext app = new ClassPathXmlApplicationContext("spring01.xml");
        // 获取 bean
        UserService us = app.getBean("userService", UserService.class);
        AccountService as = app.getBean("accountService", AccountService.class);
        // 调用方法
        us.test01();
        as.test01();

    }
}

2、Spring 框架实例化对象

2.1、默认构造器实例化

public class User {

    private Integer id;
    private String name;

    public User() {}

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}
<!--  通过无参构造器实例化对象  -->
<bean id="user1" class="com.yjxxt.bean.User">
    <!--  相当于 set()  -->
    <property name="id" value="1001"></property>
    <property name="name" value="zhangsan"></property>
</bean>

2.2、有参构造器实例化

public class User {

    private Integer id;
    private String name;

    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}
<!--  通过有参构造器实例化对象  -->
<bean id="user2" class="com.yjxxt.bean.User">
    <constructor-arg name="id" value="1002"></constructor-arg>
    <constructor-arg name="name" value="李四"></constructor-arg>
</bean>

2.3、静态工厂实例化

public class CarFactory1 {
    public static Car getCar(){
        return new Car("10454621", "劳斯莱斯幻影", 2000000);
    }
}

public class Car {

    private String number;
    private String name;
    private Integer price;

    public Car(String number, String name, Integer price) {
        this.number = number;
        this.name = name;
        this.price = price;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getPrice() {
        return price;
    }

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

    @Override
    public String toString() {
        return "Car{" +
                "number='" + number + '\'' +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}
<!--  通过静态工厂实例化对象  -->
<bean id="car1" class="com.yjxxt.factory.CarFactory1" factory-method="getCar"></bean>

2.4、非静态工厂实例化

public class CarFactory2 {
    public Car getCar(){
        return new Car("10454621", "劳斯莱斯幻影", 2000000);
    }
}

<!--  通过实例化工厂实例化对象  -->
<bean id="factory" class="com.yjxxt.factory.CarFactory2"></bean>
<bean id="car2" factory-bean="factory" factory-method="getCar"></bean>

3、Spring IOC 注入

3.1、xml 

public class Student {

    private Integer id;
    private String name;
    private Integer age;
    private Double score;
    private Date birthday;
    private List<String> subject;
    private Set<String> hobby;
    private Map<String, Object> bankCard;
    private Properties properties;
    private String [] eat;
    private Car myCar;

    public Student() {}

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public List<String> getSubject() {
        return subject;
    }

    public void setSubject(List<String> subject) {
        this.subject = subject;
    }

    public Set<String> getHobby() {
        return hobby;
    }

    public void setHobby(Set<String> hobby) {
        this.hobby = hobby;
    }

    public Map<String, Object> getBankCard() {
        return bankCard;
    }

    public void setBankCard(Map<String, Object> bankCard) {
        this.bankCard = bankCard;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public String[] getEat() {
        return eat;
    }

    public void setEat(String[] eat) {
        this.eat = eat;
    }

    public Car getMyCar() {
        return myCar;
    }

    public void setMyCar(Car myCar) {
        this.myCar = myCar;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                ", birthday=" + birthday +
                ", subject=" + subject +
                ", hobby=" + hobby +
                ", bankCard=" + bankCard +
                ", properties=" + properties +
                ", eat=" + Arrays.toString(eat) +
                ", myCar=" + myCar +
                '}';
    }
}
<?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
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--  实例化日期对象  -->
    <bean id="date" class="java.util.Date">
        <property name="year" value="2021"></property>
        <property name="month" value="9"></property>
        <property name="date" value="06"></property>
    </bean>

    <!--  静态工厂实例化  -->
    <bean id="car" class="com.yjxxt.factory.CarFactory1" factory-method="getCar">
        <property name="name" value="法拉利"></property>
    </bean>

    <bean id="stu" class="com.yjxxt.bean.Student">
        <property name="id" value="20210906"></property>
        <property name="name" value="张三"></property>
        <property name="age" value="20"></property>
        <property name="score" value="59.9"></property>
        
        <!--  参考日期对象  -->
        <property name="birthday" ref="date"></property>
        
        <!--  注入 list  -->
        <property name="subject">
            <list>
                <value>语文</value>
                <value>数学</value>
                <value>英语</value>
            </list>
        </property>
        
        <!--  注入 set  -->
        <property name="hobby">
            <set>
                <value>抽烟</value>
                <value>喝酒</value>
                <value>烫头</value>
            </set>
        </property>
        
        <!--  注入 map  -->
        <property name="bankCard">
            <map>
                <entry key="农业银行" value="10000"></entry>
                <entry key="储蓄银行" value="15000"></entry>
                <entry key="建设银行" value="20000"></entry>
            </map>
        </property>
        
        <!--  注入 properties  -->
        <property name="properties">
            <props>
                <prop key="省">安徽省</prop>
                <prop key="市">六安市</prop>
                <prop key="县">霍山县</prop>
            </props>
        </property>
        
        <!--  注入数组  -->
        <property name="eat">
            <array>
                <value>烧鸡</value>
                <value>红酒</value>
                <value>阿根达斯</value>
            </array>
        </property>
        
        <!--  注入 car  -->
        <property name="myCar" ref="car"></property>
    </bean>

</beans>

3.2、注解（自动装配）

3.2.1、@Autowired

        默认通过类型（Class 类型）查找 bean 对象，与属性字段的名称无关

public class UserDao {
    public void test01(){
        System.out.println("UserDao test01.....");
    }
}
public class ServiceDao {

    @Autowired
    public UserDao userDao;

    public void test01(){
        System.out.println("ServiceDao test01.....");
        userDao.test01();
    }
}
<?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
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!--  开启自动装配  -->
    <context:annotation-config/>

    <!--  实例化 UserDao -->
    <bean id="userDao" class="com.yjxxt.dao.UserDao"></bean>

    <!--  实例化 ServiceDao  -->
    <bean id="user" class="com.yjxxt.service.ServiceDao"></bean>

</beans>
public class TestUser {

    @Test
    public void test01(){
        ApplicationContext app = new ClassPathXmlApplicationContext("spring06.xml");
        ServiceDao user = app.getBean("user", ServiceDao.class);
        user.test01();
    }
}

        当类型相同时，需使用 @Qualifier 来指明对象的名称

public interface AccountDao {
    void save();
}
public class StudentDao implements AccountDao {

    @Override
    public void save() {
        System.out.println("StudentDao save.......");
    }
}
public class TeacherDao implements AccountDao {

    @Override
    public void save() {
        System.out.println("TeacherDao save.......");
    }
}
<?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
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!--  开启注解  -->
    <context:annotation-config/>

    <bean id="sd" class="com.yjxxt.dao.StudentDao"></bean>
    <bean id="td" class="com.yjxxt.dao.TeacherDao"></bean>
    <bean id="as" class="com.yjxxt.service.AccountService2"></bean>

</beans>
public class AccountService2 {

    @Autowired
    @Qualifier(value = "td")
    private AccountDao accountDao;

    public void test01(){
        System.out.println("AccountService2 test01....");
        accountDao.save();
    }
}
public class Test01 {

    @Test
    public void test01(){
        ApplicationContext app = new ClassPathXmlApplicationContext("spring07.xml");
        AccountService2 as = app.getBean("as", AccountService2.class);
        as.test01();
    }
}

3.2.2、@Resource

        通过名称查找对应的 bean 对象（属性字段的名称与 bean 标签的 id 属性值相等）

  引入依赖：

<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>
public class ServiceDao {

    @Resource(name = "userDao")
    public UserDao userDao;

    public void test01(){
        System.out.println("ServiceDao test01.....");
        userDao.test01();
    }
}

        当 @Resource 不指定名称，默认按类型查找，相当于 @Autowired

4、自动扫描

4.1、设置自动扫描的范围

<?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
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启扫描-->
    <context:component-scan base-package="com.yjxxt"/>

</beans>

4.2、特定注解的使用

  • Dao 层：@Repository

  • Service 层：@Service

  • Controller 层：@Controller

  • 任意类：@Component

YANG**
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring IOC 流程
小熊的博客
09-12 2843
Spring IOC 首先，在此之前，我们就必须先知道什么是ioc，ioc叫做控制反转，也可以称为依赖注入（DI），实际上依赖注入是ioc的另一种说法， 1.谁控制谁？：在以前，对象的创建和销毁都是由用户控制的，用了ioc之后，对象的创建和销毁就都交给容器来控制了，用户就不用管这些，只关注业务需求就好了； 2.什么是反转？：既然叫反转，肯定就有正转，正转其实就是对象去找实例，而反转就反过来了嘛，让实例来找对象；怎么找呢？当然是通过容器啦！ 3.谁依赖谁？：在spring项目中，将对象理解为Bean，也可
Spring IoC容器
qq_25073223的博客
11-06 1623
Spring IoC容器
Spring IoC实现及原理
Guo_Liwei的博客
07-01 2538
快速了解spring实现与底层原理
spring ioc
03-06
标题 "Spring IOC" 描述了我们讨论的核心主题——Spring 框架中的依赖注入（Inversion of Control，简称 IOC）机制。Spring 是一个广泛应用的 Java 应用开发框架，其核心特性之一就是IOC，它极大地简化了软件组件...
SPRING IOC注入方式过程解析
08-25
SPRING IOC注入方式过程解析 SPRING IOC是一种轻量级的控制反转（Inversion of Control）容器框架，主要用于解耦合Java应用程序中的组件。其中，IOC（Inversion of Control）注入是SPRING IOC的核心机制之一。下面...
springIoc实现原理
04-20
**Spring Ioc 实现原理详解** Spring Ioc（Inversion of Control，控制反转）是Spring框架的核心特性之一，它改变了传统应用程序中对象的创建和管理方式。在传统的软件设计中，对象的创建和依赖关系的维护通常由...
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器启动流程分析 Spring IOC 容器是 Java 企业级应用程序的核心组件之一，它提供了一个统一的依赖注入机制，使得应用程序的组件之间能够松耦合。Spring IOC 容器的启动流程是整个 Spring 框架的核心...
spring IOC
04-11
【Spring IOC】是Spring框架的核心特性，全称为Inversion of Control，即控制反转。它将对象的创建和管理从应用程序代码中分离出来，使得开发者可以更专注于业务逻辑的实现，而不是对象的生命周期管理。在传统的Java...
SpringBoot整合SSE，实现后端主动推送DEMO
zjy660358的专栏
07-17 348
说起服务端主动推送，大家第一个想到的一定是WEBSOCKET。作为软件工程师，不能无脑使用一种技术，要结合实际情况，择优选取。SSE（Server-Sent Events）相比于WEBSOCKET1、轻量化、兼容性 基于传统的HTTP协议，所以浏览器兼容性比较好2、 只支持单向通讯。（服务器->客户端）
OAuth2.0 or Spring Session or 单点登录流程
最新发布
qq_53374893的博客
07-20 254
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
Spring3(代理模式 Spring1案例补充 Aop 面试题)
qq_52897007的博客
07-17 1214
为其他对象提供一种代理以控制对这个对象的访问。
手写简易版Spring IOC容器02【学习】
weixin_44794897的博客
07-19 515
其中applyPropertyValues用于从beanDefinition中读取属性的配置信息然后通过BeanUtil(hutool-all中提供的类)为其赋值@Overridetry {// 创建bean实例Class<?if (null!break;// 设置属性值try {// 从beanDefinition中获取property通过Resource获取文件流。
Spring-使用
weixin_61094678的博客
07-17 302
众所周知，Spring是一个包含了众多工具的IoC容器。既然是容器就必然包含两个最基本的功能：将对象存储到容器中，从容器中将对象取出来故本篇文章 将讲述如何在Spring中，如何创建，存储，获取并使用Bean对象。
SpringMVC-拦截器
时间如瑾 代码如诗
07-16 2748
Spring MVC 中的拦截器（Interceptor）是一种强大的机制，用于拦截请求和响应。它允许开发者在请求处理的不同阶段执行预处理和后处理操作，比如日志记录、权限检查、国际化等。
Springcloud （一站式微服务架构的解决方案）
great_sz的博客
07-16 217
上课内容，期待日后学会了能看到这些图片，呜呜呜
SpringBoot使用开发环境的application.properties
培根芝士的专栏
07-16 424
在Spring Boot项目中，application.properties 或 application.yml 文件是用于配置应用程序外部属性的重要文件。这些文件允许定制你的应用，而无需更改代码。根据不同的运行环境，可以通过创建以application-{profile}.properties格式命名的文件来定义不同环境的配置，其中{profile}是环境标识，如test（测试）、dev（开发）、prod（生产）等。
springboot助农管理系统lw源码调试讲解
u014445459的博客
07-19 577
在系统将要投入使用前，需要进行的一个必不可少的工作环节就是系统测试。测试人员通过系统测试工作，验证在系统的使用过程中，界面环境是否整洁友好，用户账号信息是否安全可靠，性能方面是否稳定健壮，功能方面是否符合用户需要等。系统测试不仅需要找出系统运行中会出现的问题，还需要分析产生这些问题的原因，并且找到解决这些问题的方法[21]。系统测试主要分为黑盒测试和白盒测试[22]。黑盒测试即功能测试，其主要是站在使用者的角度对系统进行测试。
Spring IoC
05-26
Spring IoC (Inversion of Control) 是 Spring 框架的核心之一，也是 Spring 的基础。它是一种设计模式，用于实现对象之间的依赖关系管理，通过将控制反转到容器中，来实现对象之间的解耦和灵活性。 在 Spring IoC 中，容器负责管理对象的生命周期和依赖关系，并将对象装配到应用程序中。开发人员只需要声明需要使用的对象和依赖关系，而不需要手动创建和管理它们。 Spring IoC 实现依赖注入（Dependency Injection），即将对象之间的依赖关系通过容器来自动注入。它有三种方式来实现依赖注入：构造函数注入、Setter 方法注入和字段注入。 总之，Spring IoC 通过将控制反转到容器中来实现对象之间的解耦和灵活性，使得应用程序更加易于开发、测试和维护。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值